Merge commit '56ca59a03150cf44cea340f58967c990ed6bf43c^' into HEAD

483 files changed, 24791 insertions, 2795 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 6e70999..67906ac 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,1876 @@
+2023-11-18  Xi Ruoyao  <xry111@xry111.site>
+
+	* config/loongarch/predicates.md (const_call_insn_operand):
+	Remove buggy "HAVE_AS_SUPPORT_CALL36" conditions.  Change "1" to
+	"true" to make the coding style consistent.
+
+2023-11-18  Xi Ruoyao  <xry111@xry111.site>
+
+	* config/loongarch/genopts/isa-evolution.in: (lam-bh, lamcas):
+	Add.
+	* config/loongarch/loongarch-str.h: Regenerate.
+	* config/loongarch/loongarch.opt: Regenerate.
+	* config/loongarch/loongarch-cpucfg-map.h: Regenerate.
+	* config/loongarch/loongarch-cpu.cc
+	(ISA_BASE_LA64V110_FEATURES): Include OPTION_MASK_ISA_LAM_BH
+	and OPTION_MASK_ISA_LAMCAS.
+	* config/loongarch/sync.md (atomic_add<mode:SHORT>): Use
+	TARGET_LAM_BH instead of ISA_BASE_IS_LA64V110.  Remove empty
+	lines from assembly output.
+	(atomic_exchange<mode>_short): Likewise.
+	(atomic_exchange<mode:SHORT>): Likewise.
+	(atomic_fetch_add<mode>_short): Likewise.
+	(atomic_fetch_add<mode:SHORT>): Likewise.
+	(atomic_cas_value_strong<mode>_amcas): Use TARGET_LAMCAS instead
+	of ISA_BASE_IS_LA64V110.
+	(atomic_compare_and_swap<mode>): Likewise.
+	(atomic_compare_and_swap<mode:GPR>): Likewise.
+	(atomic_compare_and_swap<mode:SHORT>): Likewise.
+	* config/loongarch/loongarch.cc (loongarch_asm_code_end): Dump
+	status if -mlam-bh and -mlamcas if -fverbose-asm.
+
+2023-11-18  Xi Ruoyao  <xry111@xry111.site>
+
+	* config/loongarch/loongarch.cc (loongarch_print_operand): Don't
+	print dbar 0x700 if TARGET_LD_SEQ_SA.
+	* config/loongarch/sync.md (atomic_load<mode>): Likewise.
+
+2023-11-18  Xi Ruoyao  <xry111@xry111.site>
+
+	* config/loongarch/loongarch.md (DIV): New mode iterator.
+	(<optab:ANY_DIV><mode:GPR>3): Don't expand if TARGET_DIV32.
+	(<optab:ANY_DIV>di3_fake): Disable if TARGET_DIV32.
+	(*<optab:ANY_DIV><mode:GPR>3): Allow SImode if TARGET_DIV32.
+	(<optab:ANY_DIV>si3_extended): New insn if TARGET_DIV32.
+
+2023-11-18  Xi Ruoyao  <xry111@xry111.site>
+
+	* config/loongarch/loongarch-def.h:
+	(loongarch_isa_base_features): Declare.  Define it in ...
+	* config/loongarch/loongarch-cpu.cc
+	(loongarch_isa_base_features): ... here.
+	(fill_native_cpu_config): If we know the base ISA of the CPU
+	model from PRID, use it instead of la64 (v1.0).  Check if all
+	expected features of this base ISA is available, emit a warning
+	if not.
+	* config/loongarch/loongarch-opts.cc (config_target_isa): Enable
+	the features implied by the base ISA if not -march=native.
+
+2023-11-18  Xi Ruoyao  <xry111@xry111.site>
+
+	* config/loongarch/genopts/isa-evolution.in: New data file.
+	* config/loongarch/genopts/genstr.sh: Translate info in
+	isa-evolution.in when generating loongarch-str.h, loongarch.opt,
+	and loongarch-cpucfg-map.h.
+	* config/loongarch/genopts/loongarch.opt.in (isa_evolution):
+	New variable.
+	* config/loongarch/t-loongarch: (loongarch-cpucfg-map.h): New
+	rule.
+	(loongarch-str.h): Depend on isa-evolution.in.
+	(loongarch.opt): Depend on isa-evolution.in.
+	(loongarch-cpu.o): Depend on loongarch-cpucfg-map.h.
+	* config/loongarch/loongarch-str.h: Regenerate.
+	* config/loongarch/loongarch-def.h (loongarch_isa):  Add field
+	for evolution features.  Add helper function to enable features
+	in this field.
+	Probe native CPU capability and save the corresponding options
+	into preset.
+	* config/loongarch/loongarch-cpu.cc (fill_native_cpu_config):
+	Probe native CPU capability and save the corresponding options
+	into preset.
+	(cache_cpucfg): Simplify with C++11-style for loop.
+	(cpucfg_useful_idx, N_CPUCFG_WORDS): Move to ...
+	* config/loongarch/loongarch.cc
+	(loongarch_option_override_internal): Enable the ISA evolution
+	feature options implied by -march and not explicitly disabled.
+	(loongarch_asm_code_end): New function, print ISA information as
+	comments in the assembly if -fverbose-asm.  It makes easier to
+	debug things like -march=native.
+	(TARGET_ASM_CODE_END): Define.
+	* config/loongarch/loongarch.opt: Regenerate.
+	* config/loongarch/loongarch-cpucfg-map.h: Generate.
+	(cpucfg_useful_idx, N_CPUCFG_WORDS) ... here.
+
+2023-11-18  Xi Ruoyao  <xry111@xry111.site>
+
+	* config/loongarch/genopts/loongarch-strings:
+	(STR_ISA_BASE_LA64V110): Add.
+	* config/loongarch/genopts/loongarch.opt.in:
+	(ISA_BASE_LA64V110): Add.
+	* config/loongarch/loongarch-def.c
+	(loongarch_isa_base_strings): Initialize [ISA_BASE_LA64V110]
+	to STR_ISA_BASE_LA64V110.
+	* config/loongarch/loongarch.opt: Regenerate.
+	* config/loongarch/loongarch-str.h: Regenerate.
+
+2023-11-18  Sebastian Huber  <sebastian.huber@embedded-brains.de>
+
+	* doc/invoke.texi (-fprofile-update): Clarify default method.  Document
+	the atomic method behaviour.
+	* tree-profile.cc (enum counter_update_method): New.
+	(counter_update): Likewise.
+	(gen_counter_update): Use counter_update_method.  Split the
+	atomic counter update in two 32-bit atomic operations if
+	necessary.
+	(tree_profiling): Select counter_update_method.
+
+2023-11-18  Sebastian Huber  <sebastian.huber@embedded-brains.de>
+
+	* tree-profile.cc (gen_assign_counter_update): New.
+	(gen_counter_update): Likewise.
+	(gimple_gen_edge_profiler): Use gen_counter_update().
+	(gimple_gen_time_profiler): Likewise.
+
+2023-11-18  Sebastian Huber  <sebastian.huber@embedded-brains.de>
+
+	* config/rtems.h (TARGET_HAVE_LIBATOMIC): Define.
+	* doc/tm.texi: Regenerate.
+	* doc/tm.texi.in (TARGET_HAVE_LIBATOMIC): Add.
+	* target.def (have_libatomic): New.
+
+2023-11-18  Sebastian Huber  <sebastian.huber@embedded-brains.de>
+
+	Revert:
+	2023-11-18  Sebastian Huber  <sebastian.huber@embedded-brains.de>
+
+	* config/sparc/rtemself.h (SPARC_GCOV_TYPE_SIZE): Define.
+	* config/sparc/sparc.c (sparc_gcov_type_size): New.
+	(TARGET_GCOV_TYPE_SIZE): Redefine if SPARC_GCOV_TYPE_SIZE is defined.
+	* coverage.c (get_gcov_type): Use targetm.gcov_type_size().
+	* doc/tm.texi (TARGET_GCOV_TYPE_SIZE): Add hook under "Misc".
+	* doc/tm.texi.in: Regenerate.
+	* target.def (gcov_type_size): New target hook.
+	* targhooks.c (default_gcov_type_size): New.
+	* targhooks.h (default_gcov_type_size): Declare.
+	* tree-profile.c (gimple_gen_edge_profiler): Use precision of
+	gcov_type_node.
+	(gimple_gen_time_profiler): Likewise.
+
+2023-11-18  Kito Cheng  <kito.cheng@sifive.com>
+
+	* config/riscv/riscv-target-attr.cc
+	(riscv_target_attr_parser::parse_arch): Use char[] for
+	std::unique_ptr to prevent mismatched new delete issue.
+	(riscv_process_one_target_attr): Ditto.
+	(riscv_process_target_attr): Ditto.
+
+2023-11-18  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/vector-iterators.md: Refactor iterators.
+
+2023-11-18  Lulu Cheng  <chenglulu@loongson.cn>
+
+	* config/loongarch/sync.md (atomic_load<mode>): New template.
+
+2023-11-18  Lulu Cheng  <chenglulu@loongson.cn>
+
+	* config/loongarch/loongarch-def.h: Add comments.
+	* config/loongarch/loongarch-opts.h (ISA_BASE_IS_LA64V110): Define macro.
+	* config/loongarch/loongarch.cc (loongarch_memmodel_needs_rel_acq_fence):
+	Remove redundant code implementations.
+	* config/loongarch/sync.md (d): Added QI, HI support.
+	(atomic_add<mode>): New template.
+	(atomic_exchange<mode>_short): Likewise.
+	(atomic_cas_value_strong<mode>_amcas): Likewise..
+	(atomic_fetch_add<mode>_short): Likewise.
+
+2023-11-18  Lulu Cheng  <chenglulu@loongson.cn>
+
+	* config.gcc: Support LA664.
+	* config/loongarch/genopts/loongarch-strings: Likewise.
+	* config/loongarch/genopts/loongarch.opt.in: Likewise.
+	* config/loongarch/loongarch-cpu.cc (fill_native_cpu_config): Likewise.
+	* config/loongarch/loongarch-def.c: Likewise.
+	* config/loongarch/loongarch-def.h (N_ISA_BASE_TYPES): Likewise.
+	(ISA_BASE_LA64V110): Define macro.
+	(N_ARCH_TYPES): Update value.
+	(N_TUNE_TYPES): Update value.
+	(CPU_LA664): New macro.
+	* config/loongarch/loongarch-opts.cc (isa_default_abi): Likewise.
+	(isa_base_compat_p): Likewise.
+	* config/loongarch/loongarch-opts.h (TARGET_64BIT): This parameter is enabled
+	when la_target.isa.base is equal to ISA_BASE_LA64V100 or ISA_BASE_LA64V110.
+	(TARGET_uARCH_LA664): Define macro.
+	* config/loongarch/loongarch-str.h (STR_CPU_LA664): Likewise.
+	* config/loongarch/loongarch.cc (loongarch_cpu_sched_reassociation_width):
+	Add LA664 support.
+	* config/loongarch/loongarch.opt: Regenerate.
+
+2023-11-18  Lulu Cheng  <chenglulu@loongson.cn>
+	    Xi Ruoyao  <xry111@xry111.site>
+
+	* config.in: Regenerate.
+	* config/loongarch/loongarch-opts.h (HAVE_AS_SUPPORT_CALL36): Define macro.
+	* config/loongarch/loongarch.cc (loongarch_legitimize_call_address):
+	If binutils supports call36, the function call is not split over expand.
+	* config/loongarch/loongarch.md: Add call36 generation code.
+	* config/loongarch/predicates.md: Likewise.
+	* configure: Regenerate.
+	* configure.ac: Check whether binutils supports call36.
+
+2023-11-18  David Malcolm  <dmalcolm@redhat.com>
+
+	PR analyzer/106147
+	* Makefile.in (ANALYZER_OBJS): Add analyzer/infinite-loop.o.
+	* doc/invoke.texi: Add -fdump-analyzer-infinite-loop and
+	-Wanalyzer-infinite-loop.  Add missing CWE link for
+	-Wanalyzer-infinite-recursion.
+	* timevar.def (TV_ANALYZER_INFINITE_LOOPS): New.
+
+2023-11-17  Robin Dapp  <rdapp@ventanamicro.com>
+
+	PR middle-end/112406
+	PR middle-end/112552
+	* tree-vect-loop.cc (vect_transform_reduction): Pass truth
+	vectype for mask operand.
+
+2023-11-17  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/107571
+	* gimplify.cc (expand_FALLTHROUGH_r): Use wi->removed_stmt after
+	gsi_remove, change the way of passing fallthrough stmt at the end
+	of sequence to expand_FALLTHROUGH.  Diagnose IFN_FALLTHROUGH
+	with GF_CALL_NOTHROW flag.
+	(expand_FALLTHROUGH): Change loc into array of 2 location_t elts,
+	don't test wi.callback_result, instead check whether first
+	elt is not UNKNOWN_LOCATION and in that case pedwarn with the
+	second location.
+	* gimple-walk.cc (walk_gimple_seq_mod): Clear wi->removed_stmt
+	after the flag has been used.
+	* internal-fn.def (FALLTHROUGH): Mention in comment the special
+	meaning of the TREE_NOTHROW/GF_CALL_NOTHROW flag on the calls.
+
+2023-11-17  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/112566
+	PR tree-optimization/83171
+	* match.pd (ctz(ext(X)) -> ctz(X), popcount(zext(X)) -> popcount(X),
+	parity(ext(X)) -> parity(X), ffs(ext(X)) -> ffs(X)): New
+	simplifications.
+	( __builtin_ffs (X) == 0 -> X == 0): Use FFS rather than
+	BUILT_IN_FFS BUILT_IN_FFSL BUILT_IN_FFSLL BUILT_IN_FFSIMAX.
+
+2023-11-17  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/112374
+	* tree-vect-loop.cc (check_reduction_path): Perform the cond_fn_p
+	special case only if op_use_stmt == use_stmt, use as_a rather than
+	dyn_cast in that case.
+
+2023-11-17  Richard Biener  <rguenther@suse.de>
+
+	Revert:
+	2023-11-14  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/112281
+	* tree-loop-distribution.cc (pg_add_dependence_edges):
+	Preserve stmt order when the innermost loop has exact
+	overlap.
+
+2023-11-17  Georg-Johann Lay  <avr@gjlay.de>
+
+	PR target/53372
+	* config/avr/avr.cc (avr_asm_named_section) [AVR_SECTION_PROGMEM]:
+	Only return some .progmem*.data section if the user did not
+	specify a section attribute.
+	(avr_section_type_flags) [avr_progmem_p]: Unset SECTION_NOTYPE
+	in returned section flags.
+
+2023-11-17  Xi Ruoyao  <xry111@xry111.site>
+
+	* config/loongarch/lsx.md (copysign<mode>3): Allow operand[2] to
+	be an reg_or_vector_same_val_operand.  If it's a const vector
+	with same negative elements, expand the copysign with a bitset
+	instruction.  Otherwise, force it into an register.
+	* config/loongarch/lasx.md (copysign<mode>3): Likewise.
+
+2023-11-17  Haochen Gui  <guihaoc@gcc.gnu.org>
+
+	PR target/111449
+	* config/rs6000/vsx.md (*vsx_le_mem_to_mem_mov_ti): New.
+
+2023-11-17  Haochen Gui  <guihaoc@gcc.gnu.org>
+
+	PR target/111449
+	* config/rs6000/altivec.md (cbranchv16qi4): New expand pattern.
+	* config/rs6000/rs6000.cc (rs6000_generate_compare): Generate
+	insn sequence for V16QImode equality compare.
+	* config/rs6000/rs6000.h (MOVE_MAX_PIECES): Define.
+	(STORE_MAX_PIECES): Define.
+
+2023-11-17  Li Wei  <liwei@loongson.cn>
+
+	* config/loongarch/loongarch.h (CLZ_DEFINED_VALUE_AT_ZERO):
+	Implement.
+	(CTZ_DEFINED_VALUE_AT_ZERO): Same.
+
+2023-11-17  Richard Biener  <rguenther@suse.de>
+
+	* dwarf2out.cc (add_AT_die_ref): Assert we do not add
+	a self-ref DW_AT_abstract_origin or DW_AT_specification.
+
+2023-11-17  Jiahao Xu  <xujiahao@loongson.cn>
+
+	* config/loongarch/loongarch.cc
+	(loongarch_builtin_vectorization_cost): Adjust.
+
+2023-11-16  Andrew Pinski  <pinskia@gmail.com>
+
+	PR rtl-optimization/112483
+	* simplify-rtx.cc (simplify_binary_operation_1) <case COPYSIGN>:
+	Call simplify_unary_operation for NEG instead of
+	simplify_gen_unary.
+
+2023-11-16  Edwin Lu  <ewlu@rivosinc.com>
+
+	PR target/111557
+	* config/riscv/riscv-c.cc (riscv_cpu_cpp_builtins): update macro name
+
+2023-11-16  Uros Bizjak  <ubizjak@gmail.com>
+
+	PR target/78904
+	* config/i386/i386.md (*addqi_ext2<mode>_0):
+	New define_insn_and_split pattern.
+	(*subqi_ext2<mode>_0): Ditto.
+	(*<code>qi_ext2<mode>_0): Ditto.
+
+2023-11-16  John David Anglin  <danglin@gcc.gnu.org>
+
+	PR rtl-optimization/112415
+	* config/pa/pa.cc (pa_legitimate_address_p): Allow 14-bit
+	displacements before reload.  Simplify logic flow.  Revise
+	comments.
+	* config/pa/pa.h (TARGET_ELF64): New define.
+	(INT14_OK_STRICT): Update define and comment.
+	* config/pa/pa64-linux.h (TARGET_ELF64): Define.
+	* config/pa/predicates.md (base14_operand): Don't check
+	alignment of short displacements.
+	(integer_store_memory_operand): Don't return true when
+	reload_in_progress is true.  Remove INT_5_BITS check.
+	(floating_point_store_memory_operand): Don't return true when
+	reload_in_progress is true.  Use INT14_OK_STRICT to check
+	whether long displacements are always okay.
+
+2023-11-16  Uros Bizjak  <ubizjak@gmail.com>
+
+	PR target/112567
+	* config/i386/i386.md (*<any_logic:code>qi_ext<mode>_1_slp):
+	Fix generation of invalid RTX in split pattern.
+
+2023-11-16  David Malcolm  <dmalcolm@redhat.com>
+
+	* diagnostic.cc (diagnostic_context::set_option_hooks): Add
+	"lang_mask" param.
+	* diagnostic.h (diagnostic_context::option_enabled_p): Update for
+	move of m_lang_mask.
+	(diagnostic_context::set_option_hooks): Add "lang_mask" param.
+	(diagnostic_context::get_lang_mask): New.
+	(diagnostic_context::m_lang_mask): Move into m_option_callbacks,
+	thus making private.
+	* lto-wrapper.cc (main): Update for new lang_mask param of
+	set_option_hooks.
+	* toplev.cc (init_asm_output): Use get_lang_mask.
+	(general_init): Move initialization of global_dc's lang_mask to
+	new lang_mask param of set_option_hooks.
+
+2023-11-16  Tamar Christina  <tamar.christina@arm.com>
+
+	PR tree-optimization/111878
+	* tree-vect-loop-manip.cc (find_loop_location): Skip edges check if
+	latch incorrect.
+
+2023-11-16  Kito Cheng  <kito.cheng@sifive.com>
+
+	* config.gcc (riscv): Add riscv-target-attr.o.
+	* config/riscv/riscv-protos.h (riscv_declare_function_size) New.
+	(riscv_option_valid_attribute_p): New.
+	(riscv_override_options_internal): New.
+	(struct riscv_tune_info): New.
+	(riscv_parse_tune): New.
+	* config/riscv/riscv-target-attr.cc
+	(class riscv_target_attr_parser): New.
+	(struct riscv_attribute_info): New.
+	(riscv_attributes): New.
+	(riscv_target_attr_parser::parse_arch): New.
+	(riscv_target_attr_parser::handle_arch): New.
+	(riscv_target_attr_parser::handle_cpu): New.
+	(riscv_target_attr_parser::handle_tune): New.
+	(riscv_target_attr_parser::update_settings): New.
+	(riscv_process_one_target_attr): New.
+	(num_occurences_in_str): New.
+	(riscv_process_target_attr): New.
+	(riscv_option_valid_attribute_p): New.
+	* config/riscv/riscv.cc: Include target-globals.h and
+	riscv-subset.h.
+	(struct riscv_tune_info): Move to riscv-protos.h.
+	(get_tune_str): New.
+	(riscv_parse_tune): New parameter null_p.
+	(riscv_declare_function_size): New.
+	(riscv_option_override): Build target_option_default_node and
+	target_option_current_node.
+	(riscv_save_restore_target_globals): New.
+	(riscv_option_restore): New.
+	(riscv_previous_fndecl): New.
+	(riscv_set_current_function): Apply the target attribute.
+	(TARGET_OPTION_RESTORE): Define.
+	(TARGET_OPTION_VALID_ATTRIBUTE_P): Ditto.
+	* config/riscv/riscv.h (SWITCHABLE_TARGET): Define to 1.
+	(ASM_DECLARE_FUNCTION_SIZE) Define.
+	* config/riscv/riscv.opt (mtune=): Add Save attribute.
+	(mcpu=): Ditto.
+	(mcmodel=): Ditto.
+	* config/riscv/t-riscv: Add build rule for riscv-target-attr.o
+	* doc/extend.texi: Add doc for target attribute.
+
+2023-11-16  Kito Cheng  <kito.cheng@sifive.com>
+
+	PR target/112478
+	* config/riscv/riscv.cc (riscv_save_return_addr_reg_p): Check ra
+	is ever lived.
+
+2023-11-16  liuhongt  <hongtao.liu@intel.com>
+
+	PR target/112532
+	* config/i386/mmx.md (*vec_dup<mode>): Extend for V4HI and
+	V2HI.
+
+2023-11-16  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/112526
+	* config/i386/i386.md
+	(mov imm,%rax; mov %rdi,%rdx; mulx %rax -> mov imm,%rdx; mulx %rdi):
+	Verify in define_peephole2 that operands[2] dies or is overwritten
+	at the end of multiplication.
+
+2023-11-16  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/112536
+	* tree-vect-slp.cc (arg0_map): New variable.
+	(vect_get_operand_map): For IFN_CLZ or IFN_CTZ, return arg0_map.
+
+2023-11-16  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	PR middle-end/112554
+	* tree-vect-loop.cc (vect_determine_partial_vectors_and_peeling):
+	Clear SELECT_VL_P for non-partial vectorization.
+
+2023-11-16  Hongyu Wang  <hongyu.wang@intel.com>
+
+	* config/i386/sse.md (vec_extract_hi_<mode>): Add noavx512vl
+	alternative with attr addr gpr16 and "jm" constraint.
+	(vec_extract_hi_<mode>): Likewise for SF vector modes.
+	(@vec_extract_hi_<mode>): Likewise.
+	(*vec_extractv2ti): Likewise.
+	(vec_set_hi_<mode><mask_name>): Likewise.
+	* config/i386/mmx.md (@sse4_1_insertps_<mode>): Correct gpr16 attr for
+	each alternative.
+
+2023-11-15  Uros Bizjak  <ubizjak@gmail.com>
+
+	PR target/78904
+	* config/i386/i386.md (*movstrictqi_ext<mode>_1): New insn pattern.
+	(*addqi_ext<mode>_2_slp): New define_insn_and_split pattern.
+	(*subqi_ext<mode>_2_slp): Ditto.
+	(*<any_logic:code>qi_ext<mode>_2_slp): Ditto.
+
+2023-11-15  Patrick O'Neill  <patrick@rivosinc.com>
+
+	* common/config/riscv/riscv-common.cc
+	(riscv_subset_list::parse_std_ext): Emit an error and skip to
+	the next extension when a non-canonical ordering is detected.
+
+2023-11-15  Bernhard Reutner-Fischer  <aldot@gcc.gnu.org>
+
+	* gcc-rich-location.cc (maybe_range_label_for_tree_type_mismatch::get_text):
+	Revert using the macro CAN_HAVE_LOCATION_P.
+
+2023-11-15  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	PR target/112447
+	* config/riscv/riscv-vsetvl.cc (pre_vsetvl::emit_vsetvl): Insert
+	local vsetvl info before LCM suggested one.
+	Tested-by: Patrick O'Neill <patrick@rivosinc.com> # pre-commit-CI #679
+	Co-developed-by: Vineet Gupta <vineetg@rivosinc.com>
+
+2023-11-15  Vineet Gupta  <vineetg@rivosinc.com>
+
+	* config/riscv/riscv.cc (riscv_sign_extend_if_not_subreg_prom): New.
+	* (riscv_extend_comparands): Call New function on operands.
+
+2023-11-15  Uros Bizjak  <ubizjak@gmail.com>
+
+	* config/i386/i386.md (*addqi_ext<mode>_1_slp):
+	Add "&& " before "reload_completed" in split condition.
+	(*subqi_ext<mode>_1_slp): Ditto.
+	(*<any_logic:code>qi_ext<mode>_1_slp): Ditto.
+
+2023-11-15  Uros Bizjak  <ubizjak@gmail.com>
+
+	PR target/112540
+	* config/i386/i386.md (*addqi_ext<mode>_1_slp):
+	Correct operand numbers in split pattern.  Replace !Q constraint
+	of operand 1 with !qm.  Add insn constrain.
+	(*subqi_ext<mode>_1_slp): Ditto.
+	(*<any_logic:code>qi_ext<mode>_1_slp): Ditto.
+
+2023-11-15  Thomas Schwinge  <thomas@codesourcery.com>
+
+	* doc/extend.texi (Nvidia PTX Built-in Functions): Fix
+	copy'n'paste-o in '__builtin_nvptx_brev' description.
+
+2023-11-15  Roger Sayle  <roger@nextmovesoftware.com>
+	    Thomas Schwinge  <thomas@codesourcery.com>
+
+	* config/nvptx/nvptx.md (UNSPEC_BITREV): Delete.
+	(bitrev<mode>2): Represent using bitreverse.
+
+2023-11-15  Andrew Stubbs  <ams@codesourcery.com>
+	    Andrew Jenner   <andrew@codesourcery.com>
+
+	* config/gcn/constraints.md: Add "a" AVGPR constraint.
+	* config/gcn/gcn-valu.md (*mov<mode>): Add AVGPR alternatives.
+	(*mov<mode>_4reg): Likewise.
+	(@mov<mode>_sgprbase): Likewise.
+	(gather<mode>_insn_1offset<exec>): Likewise.
+	(gather<mode>_insn_1offset_ds<exec>): Likewise.
+	(gather<mode>_insn_2offsets<exec>): Likewise.
+	(scatter<mode>_expr<exec_scatter>): Likewise.
+	(scatter<mode>_insn_1offset_ds<exec_scatter>): Likewise.
+	(scatter<mode>_insn_2offsets<exec_scatter>): Likewise.
+	* config/gcn/gcn.cc (MAX_NORMAL_AVGPR_COUNT): Define.
+	(gcn_class_max_nregs): Handle AVGPR_REGS and ALL_VGPR_REGS.
+	(gcn_hard_regno_mode_ok): Likewise.
+	(gcn_regno_reg_class): Likewise.
+	(gcn_spill_class): Allow spilling to AVGPRs on TARGET_CDNA1_PLUS.
+	(gcn_sgpr_move_p): Handle AVGPRs.
+	(gcn_secondary_reload): Reload AVGPRs via VGPRs.
+	(gcn_conditional_register_usage): Handle AVGPRs.
+	(gcn_vgpr_equivalent_register_operand): New function.
+	(gcn_valid_move_p): Check for validity of AVGPR moves.
+	(gcn_compute_frame_offsets): Handle AVGPRs.
+	(gcn_memory_move_cost): Likewise.
+	(gcn_register_move_cost): Likewise.
+	(gcn_vmem_insn_p): Handle TYPE_VOP3P_MAI.
+	(gcn_md_reorg): Handle AVGPRs.
+	(gcn_hsa_declare_function_name): Likewise.
+	(print_reg): Likewise.
+	(gcn_dwarf_register_number): Likewise.
+	* config/gcn/gcn.h (FIRST_AVGPR_REG): Define.
+	(AVGPR_REGNO): Define.
+	(LAST_AVGPR_REG): Define.
+	(SOFT_ARG_REG): Update.
+	(FRAME_POINTER_REGNUM): Update.
+	(DWARF_LINK_REGISTER): Update.
+	(FIRST_PSEUDO_REGISTER): Update.
+	(AVGPR_REGNO_P): Define.
+	(enum reg_class): Add AVGPR_REGS and ALL_VGPR_REGS.
+	(REG_CLASS_CONTENTS): Add new register classes and add entries for
+	AVGPRs to all classes.
+	(REGISTER_NAMES): Add AVGPRs.
+	* config/gcn/gcn.md (FIRST_AVGPR_REG, LAST_AVGPR_REG): Define.
+	(AP_REGNUM, FP_REGNUM): Update.
+	(define_attr "type"): Add vop3p_mai.
+	(define_attr "unit"): Handle vop3p_mai.
+	(define_attr "gcn_version"): Add "cdna2".
+	(define_attr "enabled"): Handle cdna2.
+	(*mov<mode>_insn): Add AVGPR alternatives.
+	(*movti_insn): Likewise.
+	* config/gcn/mkoffload.cc (isa_has_combined_avgprs): New.
+	(process_asm): Process avgpr_count.
+	* config/gcn/predicates.md (gcn_avgpr_register_operand): New.
+	(gcn_avgpr_hard_register_operand): New.
+	* doc/md.texi: Document the "a" constraint.
+
+2023-11-15  Andrew Stubbs  <ams@codesourcery.com>
+
+	* config/gcn/gcn-valu.md (mov<mode>_sgprbase): Add @ modifier.
+	(reload_in<mode>): Delete.
+	(reload_out<mode>): Delete.
+	* config/gcn/gcn.cc (CODE_FOR): Delete.
+	(get_code_for_##PREFIX##vN##SUFFIX): Delete.
+	(CODE_FOR_OP): Delete.
+	(get_code_for_##PREFIX): Delete.
+	(gcn_secondary_reload): Replace "get_code_for" with "code_for".
+
+2023-11-15  Stefan Schulze Frielinghaus  <stefansf@linux.ibm.com>
+
+	* config/s390/t-s390: Generate s390-gen-builtins.h without
+	linemarkers.
+
+2023-11-15  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/112282
+	* tree-if-conv.cc (ifcvt_hoist_invariants): Only hoist from
+	the loop header.
+
+2023-11-15  Richard Biener  <rguenther@suse.de>
+
+	* tree-vect-slp.cc (vect_slp_region): Also clear visited flag when
+	we skipped an instance due to -fdbg-cnt.
+
+2023-11-15  Xi Ruoyao  <xry111@xry111.site>
+
+	* config/loongarch/loongarch.cc
+	(loongarch_memmodel_needs_release_fence): Remove.
+	(loongarch_cas_failure_memorder_needs_acquire): New static
+	function.
+	(loongarch_print_operand): Redefine 'G' for the barrier on CAS
+	failure.
+	* config/loongarch/sync.md (atomic_cas_value_strong<mode>):
+	Remove the redundant barrier before the LL instruction, and
+	emit an acquire barrier on failure if needed by
+	failure_memorder.
+	(atomic_cas_value_cmp_and_7_<mode>): Likewise.
+	(atomic_cas_value_add_7_<mode>): Remove the unnecessary barrier
+	before the LL instruction.
+	(atomic_cas_value_sub_7_<mode>): Likewise.
+	(atomic_cas_value_and_7_<mode>): Likewise.
+	(atomic_cas_value_xor_7_<mode>): Likewise.
+	(atomic_cas_value_or_7_<mode>): Likewise.
+	(atomic_cas_value_nand_7_<mode>): Likewise.
+	(atomic_cas_value_exchange_7_<mode>): Likewise.
+
+2023-11-15  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-v.cc (expand_vector_init_trailing_same_elem): New function.
+	(expand_vec_init): Add trailing optimization.
+
+2023-11-15  Pan Li  <pan2.li@intel.com>
+
+	* config/riscv/riscv-v.cc (rvv_builder::get_merge_scalar_mask):
+	Add inner_mode mask arg for mask int mode.
+	(get_repeating_sequence_dup_machine_mode): Add mask_bit_mode arg
+	to get the good enough vector int mode on precision.
+	(expand_vector_init_merge_repeating_sequence): Pass required args
+	to above func.
+
+2023-11-15  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	PR target/112535
+	* config/riscv/riscv.cc (riscv_legitimate_address_p): Disallow RVV modes base address.
+
+2023-11-15  David Malcolm  <dmalcolm@redhat.com>
+
+	* json.cc (selftest::assert_print_eq): Add "loc" param and use
+	ASSERT_STREQ_AT.
+	(ASSERT_PRINT_EQ): New macro.
+	(selftest::test_writing_objects): Use ASSERT_PRINT_EQ to capture
+	source location of assertion.
+	(selftest::test_writing_arrays): Likewise.
+	(selftest::test_writing_float_numbers): Likewise.
+	(selftest::test_writing_integer_numbers): Likewise.
+	(selftest::test_writing_strings): Likewise.
+	(selftest::test_writing_literals): Likewise.
+
+2023-11-14  David Malcolm  <dmalcolm@redhat.com>
+
+	PR analyzer/103533
+	* doc/invoke.texi (Static Analyzer Options): Add the six
+	-Wanalyzer-tainted-* warnings.  Update documentation of each
+	warning to reflect removed requirement to use
+	-fanalyzer-checker=taint.  Remove discussion of
+	-fanalyzer-checker=taint.
+
+2023-11-14  David Malcolm  <dmalcolm@redhat.com>
+
+	* diagnostic-format-json.cc
+	(json_output_format::on_end_diagnostic): Update calls to m_context
+	callbacks to use member functions; tighten up scopes.
+	* diagnostic-format-sarif.cc (sarif_builder::make_result_object):
+	Likewise.
+	(sarif_builder::make_reporting_descriptor_object_for_warning):
+	Likewise.
+	* diagnostic.cc (diagnostic_context::initialize): Update for
+	callbacks being moved into m_option_callbacks and being renamed.
+	(diagnostic_context::set_option_hooks): New.
+	(diagnostic_option_classifier::classify_diagnostic): Update call
+	to global_dc->m_option_enabled to use option_enabled_p.
+	(diagnostic_context::print_option_information): Update calls to
+	m_context callbacks to use member functions; tighten up scopes.
+	(diagnostic_context::diagnostic_enabled): Likewise.
+	* diagnostic.h (diagnostic_option_enabled_cb): New typedef.
+	(diagnostic_make_option_name_cb): New typedef.
+	(diagnostic_make_option_url_cb): New typedef.
+	(diagnostic_context::option_enabled_p): New.
+	(diagnostic_context::make_option_name): New.
+	(diagnostic_context::make_option_url): New.
+	(diagnostic_context::set_option_hooks): New decl.
+	(diagnostic_context::m_option_enabled): Rename to
+	m_option_enabled_cb and move within m_option_callbacks, using
+	typedef.
+	(diagnostic_context::m_option_state): Move within
+	m_option_callbacks.
+	(diagnostic_context::m_option_name): Rename to
+	m_make_option_name_cb and move within m_option_callbacks, using
+	typedef.
+	(diagnostic_context::m_get_option_url): Likewise, renaming to
+	m_make_option_url_cb.
+	* lto-wrapper.cc (print_lto_docs_link): Update call to m_context
+	callback to use member function.
+	(main): Use diagnostic_context::set_option_hooks.
+	* opts-diagnostic.h (option_name): Make context param const.
+	(get_option_url): Likewise.
+	* opts.cc (option_name): Likewise.
+	(get_option_url): Likewise.
+	* toplev.cc (general_init): Use
+	diagnostic_context::set_option_hooks.
+
+2023-11-14  David Malcolm  <dmalcolm@redhat.com>
+
+	* selftest-diagnostic.cc
+	(test_diagnostic_context::test_diagnostic_context): Use
+	diagnostic_start_span.
+	* tree-diagnostic-path.cc (struct event_range): Likewise.
+
+2023-11-14  David Malcolm  <dmalcolm@redhat.com>
+
+	* diagnostic-show-locus.cc (diagnostic_context::show_locus):
+	Update for renaming of text callbacks fields.
+	* diagnostic.cc (diagnostic_context::initialize): Likewise.
+	* diagnostic.h (class diagnostic_context): Add "friend" for
+	accessors to m_text_callbacks.
+	(diagnostic_context::m_text_callbacks): Make private, and add an
+	"m_" prefix to field names.
+	(diagnostic_starter): Convert from macro to inline function.
+	(diagnostic_start_span): New.
+	(diagnostic_finalizer): Convert from macro to inline function.
+
+2023-11-14  David Malcolm  <dmalcolm@redhat.com>
+
+	* diagnostic.h (diagnostic_ready_p): Convert from macro to inline
+	function.
+
+2023-11-14  Uros Bizjak  <ubizjak@gmail.com>
+
+	PR target/78904
+	* config/i386/i386.md (*addqi_ext<mode>_1_slp):
+	New define_insn_and_split pattern.
+	(*subqi_ext<mode>_1_slp): Ditto.
+	(*<any_logic:code>qi_ext<mode>_1_slp): Ditto.
+
+2023-11-14  Andrew Stubbs  <ams@codesourcery.com>
+
+	PR target/112481
+	* expr.cc (store_constructor): Use OPTAB_WIDEN for mask adjustment.
+
+2023-11-14  David Malcolm  <dmalcolm@redhat.com>
+
+	* diagnostic-format-sarif.cc (sarif_builder::get_sarif_column):
+	Use m_context's file_cache.
+	(sarif_builder::maybe_make_artifact_content_object): Likewise.
+	(sarif_builder::get_source_lines): Likewise.
+	* diagnostic-show-locus.cc
+	(exploc_with_display_col::exploc_with_display_col): Add file_cache
+	param.
+	(layout::m_file_cache): New field.
+	(make_range): Add file_cache param.
+	(selftest::test_layout_range_for_single_point): Create and use a
+	temporary file_cache.
+	(selftest::test_layout_range_for_single_line): Likewise.
+	(selftest::test_layout_range_for_multiple_lines): Likewise.
+	(layout::layout): Initialize m_file_cache from the context and use it.
+	(layout::maybe_add_location_range): Use m_file_cache.
+	(layout::calculate_x_offset_display): Likewise.
+	(get_affected_range): Add file_cache param.
+	(get_printed_columns): Likewise.
+	(line_corrections::line_corrections): Likewwise.
+	(line_corrections::m_file_cache): New field.
+	(source_line::source_line): Add file_cache param.
+	(line_corrections::add_hint): Use m_file_cache.
+	(layout::print_trailing_fixits): Likewise.
+	(layout::print_line): Likewise.
+	(selftest::test_layout_x_offset_display_utf8): Create and use a
+	temporary file_cache.
+	(selftest::test_layout_x_offset_display_tab): Likewise.
+	(selftest::test_diagnostic_show_locus_one_liner_utf8): Likewise.
+	(selftest::test_add_location_if_nearby): Pass global_dc's
+	file_cache to temp_source_file ctor.
+	(selftest::test_overlapped_fixit_printing): Create and use a
+	temporary file_cache.
+	(selftest::test_overlapped_fixit_printing_utf8): Likewise.
+	(selftest::test_overlapped_fixit_printing_2): Use dc's file_cache.
+	* diagnostic.cc (diagnostic_context::initialize): Always create a
+	file_cache.
+	(diagnostic_context::initialize_input_context): Assume
+	m_file_cache has already been created.
+	(diagnostic_context::create_edit_context): Pass m_file_cache to
+	edit_context.
+	(convert_column_unit): Add file_cache param.
+	(diagnostic_context::converted_column): Use context's file_cache.
+	(print_parseable_fixits): Add file_cache param.
+	(diagnostic_context::report_diagnostic): Use context's file_cache.
+	(selftest::test_print_parseable_fixits_none): Create and use a
+	temporary file_cache.
+	(selftest::test_print_parseable_fixits_insert): Likewise.
+	(selftest::test_print_parseable_fixits_remove): Likewise.
+	(selftest::test_print_parseable_fixits_replace): Likewise.
+	(selftest::test_print_parseable_fixits_bytes_vs_display_columns):
+	Likewise.
+	* diagnostic.h (diagnostic_context::file_cache_init): Delete.
+	(diagnostic_context::get_file_cache): Convert return type from
+	pointer to reference.
+	* edit-context.cc (edited_file::get_file_cache): New.
+	(edited_file::m_edit_context): New.
+	(edit_context::edit_context): Add file_cache param.
+	(edit_context::get_or_insert_file): Pass this to edited_file's
+	ctor.
+	(edited_file::edited_file): Add edit_context param.
+	(edited_file::print_content): Use get_file_cache.
+	(edited_file::print_diff_hunk): Likewise.
+	(edited_file::print_run_of_changed_lines): Likewise.
+	(edited_file::get_or_insert_line): Likewise.
+	(edited_file::get_num_lines): Likewise.
+	(edited_line::edited_line): Pass in file_cache and use it.
+	(selftest::test_get_content): Create and use a
+	temporary file_cache.
+	(selftest::test_applying_fixits_insert_before): Likewise.
+	(selftest::test_applying_fixits_insert_after): Likewise.
+	(selftest::test_applying_fixits_insert_after_at_line_end):
+	Likewise.
+	(selftest::test_applying_fixits_insert_after_failure): Likewise.
+	(selftest::test_applying_fixits_insert_containing_newline):
+	Likewise.
+	(selftest::test_applying_fixits_growing_replace): Likewise.
+	(selftest::test_applying_fixits_shrinking_replace): Likewise.
+	(selftest::test_applying_fixits_replace_containing_newline):
+	Likewise.
+	(selftest::test_applying_fixits_remove): Likewise.
+	(selftest::test_applying_fixits_multiple): Likewise.
+	(selftest::test_applying_fixits_multiple_lines): Likewise.
+	(selftest::test_applying_fixits_modernize_named_init): Likewise.
+	(selftest::test_applying_fixits_modernize_named_init): Likewise.
+	(selftest::test_applying_fixits_unreadable_file): Likewise.
+	(selftest::test_applying_fixits_line_out_of_range): Likewise.
+	(selftest::test_applying_fixits_column_validation): Likewise.
+	(selftest::test_applying_fixits_column_validation): Likewise.
+	(selftest::test_applying_fixits_column_validation): Likewise.
+	(selftest::test_applying_fixits_column_validation): Likewise.
+	* edit-context.h (edit_context::edit_context): Add file_cache
+	param.
+	(edit_context::get_file_cache): New.
+	(edit_context::m_file_cache): New.
+	* final.cc: Include "diagnostic.h".
+	(asm_show_source): Use global_dc's file_cache.
+	* gcc-rich-location.cc (blank_line_before_p): Add file_cache
+	param.
+	(use_new_line): Likewise.
+	(gcc_rich_location::add_fixit_insert_formatted): Use global dc's
+	file_cache.
+	* input.cc (diagnostic_file_cache_init): Delete.
+	(diagnostic_context::file_cache_init): Delete.
+	(diagnostics_file_cache_forcibly_evict_file): Delete.
+	(file_cache::missing_trailing_newline_p): New.
+	(file_cache::evicted_cache_tab_entry): Don't call
+	diagnostic_file_cache_init.
+	(location_get_source_line): Delete.
+	(get_source_text_between): Add file_cache param.
+	(get_source_file_content): Delete.
+	(location_missing_trailing_newline): Delete.
+	(location_compute_display_column): Add file_cache param.
+	(dump_location_info): Create and use temporary file_cache.
+	(get_substring_ranges_for_loc): Add file_cache param.
+	(get_location_within_string): Likewise.
+	(get_source_range_for_char): Likewise.
+	(get_num_source_ranges_for_substring): Likewise.
+	(selftest::test_reading_source_line): Create and use temporary
+	file_cache.
+	(selftest::lexer_test::m_file_cache): New field.
+	(selftest::assert_char_at_range): Use test.m_file_cache.
+	(selftest::assert_num_substring_ranges): Likewise.
+	(selftest::assert_has_no_substring_ranges): Likewise.
+	(selftest::test_lexer_string_locations_concatenation_2): Likewise.
+	* input.h (class file_cache): New forward decl.
+	(location_compute_display_column): Add file_cache param.
+	(location_get_source_line): Delete.
+	(get_source_text_between): Add file_cache param.
+	(get_source_file_content): Delete.
+	(location_missing_trailing_newline): Delete.
+	(file_cache::missing_trailing_newline_p): New decl.
+	(diagnostics_file_cache_forcibly_evict_file): Delete.
+	* selftest.cc (named_temp_file::named_temp_file): Add file_cache
+	param.
+	(named_temp_file::~named_temp_file): Optionally evict the file
+	from the given file_cache.
+	(temp_source_file::temp_source_file): Add file_cache param.
+	* selftest.h (class file_cache): New forward decl.
+	(named_temp_file::named_temp_file): Add file_cache param.
+	(named_temp_file::m_file_cache): New field.
+	(temp_source_file::temp_source_file): Add file_cache param.
+	* substring-locations.h (get_location_within_string): Add
+	file_cache param.
+
+2023-11-14  David Malcolm  <dmalcolm@redhat.com>
+
+	* diagnostic-format-json.cc: Use type-specific "set_*" functions
+	of json::object to avoid naked new of json value subclasses.
+	* diagnostic-format-sarif.cc: Likewise.
+	* gcov.cc: Likewise.
+	* json.cc (object::set_string): New.
+	(object::set_integer): New.
+	(object::set_float): New.
+	(object::set_bool): New.
+	(selftest::test_writing_objects): Use object::set_string.
+	* json.h (object::set_string): New decl.
+	(object::set_integer): New decl.
+	(object::set_float): New decl.
+	(object::set_bool): New decl.
+	* optinfo-emit-json.cc: Use type-specific "set_*" functions of
+	json::object to avoid naked new of json value subclasses.
+	* timevar.cc: Likewise.
+	* tree-diagnostic-path.cc: Likewise.
+
+2023-11-14  Andrew MacLeod  <amacleod@redhat.com>
+
+	PR tree-optimization/112509
+	* tree-vrp.cc (find_case_label_range): Create range from case labels.
+
+2023-11-14  Stefan Schulze Frielinghaus  <stefansf@linux.ibm.com>
+
+	* config/s390/s390-builtin-types.def: Add/remove types.
+	* config/s390/s390-builtins.def (s390_vec_scatter_element_flt):
+	The type for the offset should be UV4SI instead of V4SF.
+
+2023-11-14  Saurabh Jha  <saurabh.jha@arm.com>
+
+	PR target/112337
+	* config/arm/arm.cc (mve_vector_mem_operand): Add a REG_P check for INC
+	and DEC operations.
+
+2023-11-14  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/111233
+	PR tree-optimization/111652
+	PR tree-optimization/111727
+	PR tree-optimization/111838
+	PR tree-optimization/112113
+	* tree-ssa-loop-split.cc (patch_loop_exit): Get the new
+	guard code instead of the old guard stmt.
+	(split_loop): Adjust.
+
+2023-11-14  Richard Biener  <rguenther@suse.de>
+
+	* tree-loop-distribution.cc (loop_distribution::data_dep_in_cycle_p):
+	Consider all loops in the nest when looking for
+	lambda_vector_zerop.
+
+2023-11-14  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/112281
+	* tree-loop-distribution.cc (pg_add_dependence_edges):
+	Preserve stmt order when the innermost loop has exact
+	overlap.
+
+2023-11-14  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/112523
+	PR ada/112514
+	* config/i386/i386.md (<insn><dwi>3_doubleword_lowpart): Move
+	operands[1] aka low part of input rather than operands[3] aka high
+	part of input to output if not the same register.
+
+2023-11-14  Andreas Krebbel  <krebbel@linux.ibm.com>
+
+	* config.gcc: Add s390-gen-builtins.h to target_gtfiles.
+	* config/s390/s390-builtins.h (s390_builtin_types)
+	(s390_builtin_fn_types, s390_builtin_decls): Add GTY marker.
+	* config/s390/t-s390 (EXTRA_GTYPE_DEPS): Add s390-gen-builtins.h.
+	Add build rule for s390-gen-builtins.h.
+
+2023-11-14  Andreas Krebbel  <krebbel@linux.ibm.com>
+
+	* config/s390/s390-c.cc (s390_fn_types_compatible): Add a check
+	for error_mark_node.
+
+2023-11-14  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c/111309
+	* builtins.def (BUILT_IN_CLZG, BUILT_IN_CTZG, BUILT_IN_CLRSBG,
+	BUILT_IN_FFSG, BUILT_IN_PARITYG, BUILT_IN_POPCOUNTG): New
+	builtins.
+	* builtins.cc (fold_builtin_bit_query): New function.
+	(fold_builtin_1): Use it for
+	BUILT_IN_{CLZ,CTZ,CLRSB,FFS,PARITY,POPCOUNT}G.
+	(fold_builtin_2): Use it for BUILT_IN_{CLZ,CTZ}G.
+	* fold-const-call.cc: Fix comment typo on tm.h inclusion.
+	(fold_const_call_ss): Handle
+	CFN_BUILT_IN_{CLZ,CTZ,CLRSB,FFS,PARITY,POPCOUNT}G.
+	(fold_const_call_sss): New function.
+	(fold_const_call_1): Call it for 2 argument functions returning
+	scalar when passed 2 INTEGER_CSTs.
+	* genmatch.cc (cmp_operand): For function calls also compare
+	number of arguments.
+	(fns_cmp): New function.
+	(dt_node::gen_kids): Sort fns and generic_fns.
+	(dt_node::gen_kids_1): Handle fns with the same id but different
+	number of arguments.
+	* match.pd (CLZ simplifications): Drop checks for defined behavior
+	at zero.  Add variant of simplifications for IFN_CLZ with 2 arguments.
+	(CTZ simplifications): Drop checks for defined behavior at zero,
+	don't optimize precisions above MAX_FIXED_MODE_SIZE.  Add variant of
+	simplifications for IFN_CTZ with 2 arguments.
+	(a != 0 ? CLZ(a) : CST -> .CLZ(a)): Use TREE_TYPE (@3) instead of
+	type, add BITINT_TYPE handling, create 2 argument IFN_CLZ rather than
+	one argument.  Add variant for matching CLZ with 2 arguments.
+	(a != 0 ? CTZ(a) : CST -> .CTZ(a)): Similarly.
+	* gimple-lower-bitint.cc (bitint_large_huge::lower_bit_query): New
+	method.
+	(bitint_large_huge::lower_call): Use it for IFN_{CLZ,CTZ,CLRSB,FFS}
+	and IFN_{PARITY,POPCOUNT} calls.
+	* gimple-range-op.cc (cfn_clz::fold_range): Don't check
+	CLZ_DEFINED_VALUE_AT_ZERO for m_gimple_call_internal_p, instead
+	assume defined value at zero if the call has 2 arguments and use
+	second argument value for that case.
+	(cfn_ctz::fold_range): Similarly.
+	(gimple_range_op_handler::maybe_builtin_call): Use op_cfn_clz_internal
+	or op_cfn_ctz_internal only if internal fn call has 2 arguments and
+	set m_op2 in that case.
+	* tree-vect-patterns.cc (vect_recog_ctz_ffs_pattern,
+	vect_recog_popcount_clz_ctz_ffs_pattern): For value defined at zero
+	use second argument of calls if present, otherwise assume UB at zero,
+	create 2 argument .CLZ/.CTZ calls if needed.
+	* tree-vect-stmts.cc (vectorizable_call): Handle 2 argument .CLZ/.CTZ
+	calls.
+	* tree-ssa-loop-niter.cc (build_cltz_expr): Create 2 argument
+	.CLZ/.CTZ calls if needed.
+	* tree-ssa-forwprop.cc (simplify_count_trailing_zeroes): Create 2
+	argument .CTZ calls if needed.
+	* tree-ssa-phiopt.cc (cond_removal_in_builtin_zero_pattern): Handle
+	2 argument .CLZ/.CTZ calls, handle BITINT_TYPE, create 2 argument
+	.CLZ/.CTZ calls.
+	* doc/extend.texi (__builtin_clzg, __builtin_ctzg, __builtin_clrsbg,
+	__builtin_ffsg, __builtin_parityg, __builtin_popcountg): Document.
+
+2023-11-14  Xi Ruoyao  <xry111@xry111.site>
+
+	PR target/112330
+	* config/loongarch/genopts/loongarch.opt.in: Add
+	-m[no]-pass-relax-to-as.  Change the default of -m[no]-relax to
+	account conditional branch relaxation support status.
+	* config/loongarch/loongarch.opt: Regenerate.
+	* configure.ac (gcc_cv_as_loongarch_cond_branch_relax): Check if
+	the assembler supports conditional branch relaxation.
+	* configure: Regenerate.
+	* config.in: Regenerate.  Note that there are some unrelated
+	changes introduced by r14-5424 (which does not contain a
+	config.in regeneration).
+	* config/loongarch/loongarch-opts.h
+	(HAVE_AS_COND_BRANCH_RELAXATION): Define to 0 if not defined.
+	* config/loongarch/loongarch-driver.h (ASM_MRELAX_DEFAULT):
+	Define.
+	(ASM_MRELAX_SPEC): Define.
+	(ASM_SPEC): Use ASM_MRELAX_SPEC instead of "%{mno-relax}".
+	* config/loongarch/loongarch.cc: Take the setting of
+	-m[no-]relax into account when determining the default of
+	-mexplicit-relocs=.
+	* doc/invoke.texi: Document -m[no-]relax and
+	-m[no-]pass-mrelax-to-as for LoongArch.  Update the default
+	value of -mexplicit-relocs=.
+
+2023-11-14  liuhongt  <hongtao.liu@intel.com>
+
+	PR tree-optimization/112496
+	* tree-vect-loop.cc (vectorizable_nonlinear_induction): Return
+	false when !tree_nop_conversion_p (TREE_TYPE (vectype),
+	TREE_TYPE (init_expr)).
+
+2023-11-14  Xi Ruoyao  <xry111@xry111.site>
+
+	* config/loongarch/sync.md (mem_thread_fence): Remove redundant
+	check.
+	(mem_thread_fence_1): Emit finer-grained DBAR hints for
+	different memory models, instead of 0.
+
+2023-11-14  Jakub Jelinek  <jakub@redhat.com>
+
+	PR middle-end/112511
+	* tree.cc (type_contains_placeholder_1): Handle BITINT_TYPE like
+	INTEGER_TYPE.
+
+2023-11-14  Jakub Jelinek  <jakub@redhat.com>
+	    Hu, Lin1  <lin1.hu@intel.com>
+
+	PR target/112435
+	* config/i386/sse.md (avx512vl_shuf_<shuffletype>32x4_1<mask_name>,
+	<mask_codefor>avx512dq_shuf_<shuffletype>64x2_1<mask_name>): Add
+	alternative with just x instead of v constraints and xjm instead of
+	vm and use vblendps as optimization only with that alternative.
+
+2023-11-14  liuhongt  <hongtao.liu@intel.com>
+
+	PR tree-optimization/105735
+	PR tree-optimization/111972
+	* tree-scalar-evolution.cc
+	(analyze_and_compute_bitop_with_inv_effect): Handle bitop with
+	INTEGER_CST.
+
+2023-11-13  Arsen Arsenović  <arsen@aarsen.me>
+
+	* configure: Regenerate.
+	* aclocal.m4: Regenerate.
+	* Makefile.in (LIBDEPS): Remove (potential) ./ prefix from
+	LIBINTL_DEP.
+	* doc/install.texi: Document new (notable) flags added by the
+	optional gettext tree and by AM_GNU_GETTEXT.  Document libintl/libc
+	with gettext dependency.
+
+2023-11-13  Uros Bizjak  <ubizjak@gmail.com>
+
+	* config/i386/i386-expand.h (gen_pushfl): New prototype.
+	(gen_popfl): Ditto.
+	* config/i386/i386-expand.cc (ix86_expand_builtin)
+	[case IX86_BUILTIN_READ_FLAGS]: Use gen_pushfl.
+	[case IX86_BUILTIN_WRITE_FLAGS]: Use gen_popfl.
+	* config/i386/i386.cc (gen_pushfl): New function.
+	(gen_popfl): Ditto.
+	* config/i386/i386.md (unspec): Add UNSPEC_PUSHFL and UNSPEC_POPFL.
+	(@pushfl<mode>2): Rename from *pushfl<mode>2.
+	Rewrite as unspec using UNSPEC_PUSHFL.
+	(@popfl<mode>1): Rename from *popfl<mode>1.
+	Rewrite as unspec using UNSPEC_POPFL.
+
+2023-11-13  Uros Bizjak  <ubizjak@gmail.com>
+
+	PR target/112494
+	* config/i386/i386.cc (ix86_cc_mode) [default]: Return CCmode.
+
+2023-11-13  Robin Dapp  <rdapp@ventanamicro.com>
+
+	* config/riscv/riscv-vsetvl.cc (source_equal_p): Use pointer
+	equality for REG_EQUAL.
+
+2023-11-13  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/112495
+	* tree-data-ref.cc (runtime_alias_check_p): Reject checks
+	between different address spaces.
+
+2023-11-13  Richard Biener  <rguenther@suse.de>
+
+	PR middle-end/112487
+	* tree-inline.cc (setup_one_parameter): When the parameter
+	is unused only insert a debug bind when there's not a gross
+	mismatch in value and declared parameter type.  Do not assert
+	there effectively isn't.
+
+2023-11-13  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-v.cc
+	(rvv_builder::combine_sequence_use_merge_profitable_p): New function.
+	(expand_vector_init_merge_combine_sequence): Ditto.
+	(expand_vec_init): Adapt for new optimization.
+
+2023-11-13  liuhongt  <hongtao.liu@intel.com>
+
+	* config/i386/i386-expand.cc
+	(ix86_expand_vector_init_duplicate): Handle V4HF/V4BF and
+	V2HF/V2BF.
+	(ix86_expand_vector_init_one_nonzero): Ditto.
+	(ix86_expand_vector_init_one_var): Ditto.
+	(ix86_expand_vector_init_general): Ditto.
+	(ix86_expand_vector_set_var): Ditto.
+	(ix86_expand_vector_set): Ditto.
+	(ix86_expand_vector_extract): Ditto.
+	* config/i386/mmx.md
+	(mmxdoublevecmode): Extend to V4HF/V4BF/V2HF/V2BF.
+	(*mmx_pinsrw): Extend to V4FI_64, add a new alternative (&x,
+	x, x), add a new define_split after the pattern.
+	(*mmx_pextrw<mode>): New define_insn.
+	(mmx_pshufw_1): Rename to ..
+	(mmx_pshufw<mode>_1): .. this, extend to V4FI_64.
+	(*mmx_pblendw64): Extend to V4FI_64.
+	(*vec_dup<mode>): New define_insn.
+	(vec_setv4hi): Rename to ..
+	(vec_set<mode>): .. this, and extend to V4FI_64
+	(vec_extractv4hihi): Rename to ..
+	(vec_extract<mode><mmxscalarmodelower>): .. this, and extend
+	to V4FI_64.
+	(vec_init<mode><mmxscalarmodelower>): New define_insn.
+	(*pinsrw): Extend to V2FI_32, add a new alternative (&x,
+	x, x), and add a new define_split after it.
+	(*pextrw<mode>): New define_insn.
+	(vec_setv2hi): Rename to ..
+	(vec_set<mode>): .. this, extend to V2FI_32.
+	(vec_extractv2hihi): Rename to ..
+	(vec_extract<mode><mmxscalarmodelower>): .. this, extend to
+	V2FI_32.
+	(*punpckwd): Extend to V2FI_32.
+	(*pshufw_1): Rename to ..
+	(*pshufw<mode>_1): .. this, extend to V2FI_32.
+	(vec_initv2hihi): Rename to ..
+	(vec_init<mode><mmxscalarmodelower>): .. this, and extend to
+	V2FI_32.
+	(*vec_dup<mode>): New define_insn.
+	* config/i386/sse.md (*vec_extract<mode>): Refine constraint
+	from v to Yw.
+
+2023-11-13  Roger Sayle  <roger@nextmovesoftware.com>
+
+	* config/arc/arc.md (UNSPEC_ARC_CC_NEZ): New UNSPEC that
+	represents the carry flag being set if the operand is non-zero.
+	(adc_f): New define_insn representing adc with updated flags.
+	(ashrdi3): New define_expand that only handles shifts by 1.
+	(ashrdi3_cnt1): New pre-reload define_insn_and_split.
+	(lshrdi3): New define_expand that only handles shifts by 1.
+	(lshrdi3_cnt1): New pre-reload define_insn_and_split.
+	(rrcsi2): New define_insn for rrc (SImode rotate right through carry).
+	(rrcsi2_carry): Likewise for rrc.f, as above but updating flags.
+	(rotldi3): New define_expand that only handles rotates by 1.
+	(rotldi3_cnt1): New pre-reload define_insn_and_split.
+	(rotrdi3): New define_expand that only handles rotates by 1.
+	(rotrdi3_cnt1): New pre-reload define_insn_and_split.
+	(lshrsi3_cnt1_carry): New define_insn for lsr.f.
+	(ashrsi3_cnt1_carry): New define_insn for asr.f.
+	(btst_0_carry): New define_insn for asr.f without result.
+
+2023-11-13  Roger Sayle  <roger@nextmovesoftware.com>
+
+	* config/arc/arc.cc (TARGET_FOLD_BUILTIN): Define to
+	arc_fold_builtin.
+	(arc_fold_builtin): New function.  Convert ARC_BUILTIN_SWAP
+	into a rotate.  Evaluate ARC_BUILTIN_NORM and
+	ARC_BUILTIN_NORMW of constant arguments.
+	* config/arc/arc.md (UNSPEC_ARC_SWAP): Delete.
+	(normw): Make output template/assembler whitespace consistent.
+	(swap): Remove define_insn, only use of SWAP UNSPEC.
+	* config/arc/builtins.def: Tweak indentation.
+	(SWAP): Expand using rotlsi2_cnt16 instead of using swap.
+
+2023-11-13  Roger Sayle  <roger@nextmovesoftware.com>
+
+	* config/i386/i386.md (<insn><dwi>3_doubleword_lowpart): New
+	define_insn_and_split to optimize register usage of doubleword
+	right shifts followed by truncation.
+
+2023-11-13  Jakub Jelinek  <jakub@redhat.com>
+
+	* config/i386/constraints.md: Remove j constraint letter from list of
+	unused letters.
+
+2023-11-13  Xi Ruoyao  <xry111@xry111.site>
+
+	PR rtl-optimization/112483
+	* simplify-rtx.cc (simplify_binary_operation_1) <case COPYSIGN>:
+	Fix the simplification of (fcopysign x, NEGATIVE_CONST).
+
+2023-11-13  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/111967
+	* gimple-range-cache.cc (block_range_cache::set_bb_range): Grow
+	m_ssa_ranges to num_ssa_names rather than num_ssa_names + 1.
+	(block_range_cache::dump): Iterate from 1 rather than 0.  Don't use
+	ssa_name (x) unless m_ssa_ranges[x] is non-NULL.  Iterate to
+	m_ssa_ranges.length () rather than num_ssa_names.
+
+2023-11-13  Xi Ruoyao  <xry111@xry111.site>
+
+	* config/loongarch/loongarch.md (LD_AT_LEAST_32_BIT): New mode
+	iterator.
+	(ST_ANY): New mode iterator.
+	(define_peephole2): Use LD_AT_LEAST_32_BIT instead of GPR and
+	ST_ANY instead of QHWD for applicable patterns.
+
+2023-11-13  Xi Ruoyao  <xry111@xry111.site>
+
+	PR target/112476
+	* config/loongarch/loongarch.cc
+	(loongarch_expand_vec_cond_mask_expr): Call simplify_gen_subreg
+	instead of gen_rtx_SUBREG.
+
+2023-11-13  Pan Li  <pan2.li@intel.com>
+
+	* config/riscv/autovec.md: Add bridge mode to lrint and lround
+	pattern.
+	* config/riscv/riscv-protos.h (expand_vec_lrint): Add new arg
+	bridge machine mode.
+	(expand_vec_lround): Ditto.
+	* config/riscv/riscv-v.cc (emit_vec_widden_cvt_f_f): New helper
+	func impl to emit vfwcvt.f.f.
+	(emit_vec_rounding_to_integer): Handle the HF to DI rounding
+	with the bridge mode.
+	(expand_vec_lrint): Reorder the args.
+	(expand_vec_lround): Ditto.
+	(expand_vec_lceil): Ditto.
+	(expand_vec_lfloor): Ditto.
+	* config/riscv/vector-iterators.md: Add vector HFmode and bridge
+	mode for converting to DI.
+
+2023-11-12  Jeff Law  <jlaw@ventanamicro.com>
+
+	Revert:
+	2023-11-11  Jin Ma  <jinma@linux.alibaba.com>
+
+	* haifa-sched.cc (use_or_clobber_starts_range_p): New.
+	(prune_ready_list): USE or CLOBBER should delay execution
+	if it starts a new live range.
+
+2023-11-12  Uros Bizjak  <ubizjak@gmail.com>
+
+	* config/i386/i386.md (*stack_protect_set_4s_<mode>_di):
+	Remove alternative 0.
+
+2023-11-11  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* ipa-cp.cc (print_ipcp_constant_value): Move to...
+	(values_equal_for_ipcp_p): Deal with VAR_DECLs from the
+	constant pool.
+	* ipa-prop.cc (ipa_print_constant_value): ...here.  Likewise.
+	(ipa_print_node_jump_functions_for_edge): Call the function
+	ipa_print_constant_value to print IPA_JF_CONST elements.
+
+2023-11-11  Jin Ma  <jinma@linux.alibaba.com>
+
+	* haifa-sched.cc (use_or_clobber_starts_range_p): New.
+	(prune_ready_list): USE or CLOBBER should delay execution
+	if it starts a new live range.
+
+2023-11-11  Jakub Jelinek  <jakub@redhat.com>
+
+	PR middle-end/112430
+	* tree-ssa-math-opts.cc (match_uaddc_usubc): Remove temp_stmts in the
+	order they were pushed rather than in reverse order.  Call
+	release_defs after gsi_remove.
+
+2023-11-11  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* target.def (mode_switching.backprop): New hook.
+	* doc/tm.texi.in (TARGET_MODE_BACKPROP): New @hook.
+	* doc/tm.texi: Regenerate.
+	* mode-switching.cc (struct bb_info): Add single_succ.
+	(confluence_info): Add transp field.
+	(single_succ_confluence_n, single_succ_transfer): New functions.
+	(backprop_confluence_n, backprop_transfer): Likewise.
+	(optimize_mode_switching): Use them.  Push mode transitions onto
+	a block's incoming edges, if the backprop hook requires it.
+
+2023-11-11  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* target.def (mode_switching.confluence): New hook.
+	* doc/tm.texi (TARGET_MODE_CONFLUENCE): New @hook.
+	* doc/tm.texi.in: Regenerate.
+	* mode-switching.cc (confluence_info): New variable.
+	(mode_confluence, forward_confluence_n, forward_transfer): New
+	functions.
+	(optimize_mode_switching): Use them to calculate mode_in when
+	TARGET_MODE_CONFLUENCE is defined.
+
+2023-11-11  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* mode-switching.cc (commit_mode_sets): Use 1-based edge aux values.
+
+2023-11-11  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* target.def (mode_switching.after): Add a regs_live parameter.
+	* doc/tm.texi: Regenerate.
+	* config/epiphany/epiphany-protos.h (epiphany_mode_after): Update
+	accordingly.
+	* config/epiphany/epiphany.cc (epiphany_mode_needed): Likewise.
+	(epiphany_mode_after): Likewise.
+	* config/i386/i386.cc (ix86_mode_after): Likewise.
+	* config/riscv/riscv.cc (riscv_mode_after): Likewise.
+	* config/sh/sh.cc (sh_mode_after): Likewise.
+	* mode-switching.cc (optimize_mode_switching): Likewise.
+
+2023-11-11  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* target.def (mode_switching.needed): Add a regs_live parameter.
+	* doc/tm.texi: Regenerate.
+	* config/epiphany/epiphany-protos.h (epiphany_mode_needed): Update
+	accordingly.
+	* config/epiphany/epiphany.cc (epiphany_mode_needed): Likewise.
+	* config/epiphany/mode-switch-use.cc (insert_uses): Likewise.
+	* config/i386/i386.cc (ix86_mode_needed): Likewise.
+	* config/riscv/riscv.cc (riscv_mode_needed): Likewise.
+	* config/sh/sh.cc (sh_mode_needed): Likewise.
+	* mode-switching.cc (optimize_mode_switching): Likewise.
+	(create_pre_exit): Likewise, using the DF simulate functions
+	to calculate the required information.
+
+2023-11-11  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* target.def (mode_switching.eh_handler): New hook.
+	* doc/tm.texi.in (TARGET_MODE_EH_HANDLER): New @hook.
+	* doc/tm.texi: Regenerate.
+	* mode-switching.cc (optimize_mode_switching): Use eh_handler
+	to get the mode on entry to an exception handler.
+
+2023-11-11  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* mode-switching.cc (optimize_mode_switching): Mark the exit
+	block as nontransparent if it requires a specific mode.
+	Handle the entry and exit mode as sibling rather than nested
+	concepts.  Remove outdated comment.
+
+2023-11-11  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* mode-switching.cc (optimize_mode_switching): Initially
+	compute transparency in a bit-per-block bitmap.
+
+2023-11-11  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* mode-switching.cc (seginfo): Add a prev_mode field.
+	(new_seginfo): Take and initialize the prev_mode.
+	(optimize_mode_switching): Update calls accordingly.
+	Use the recorded modes during the emit phase, rather than
+	computing one on the fly.
+
+2023-11-11  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* mode-switching.cc (add_seginfo): Replace head pointer with
+	a pointer to the tail pointer.
+	(optimize_mode_switching): Update calls accordingly.
+
+2023-11-11  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* mode-switching.cc (optimize_mode_switching): Call
+	df_note_add_problem.
+
+2023-11-11  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* target.def: Tweak documentation of mode-switching hooks.
+	* doc/tm.texi.in (OPTIMIZE_MODE_SWITCHING): Tweak documentation.
+	(NUM_MODES_FOR_MODE_SWITCHING): Likewise.
+	* doc/tm.texi: Regenerate.
+
+2023-11-11  Martin Uecker  <uecker@tugraz.at>
+
+	PR c/110815
+	PR c/112428
+	* gimple-ssa-warn-access.cc (pass_waccess::maybe_check_access_sizes):
+	remove warning for parameters declared with `static`.
+
+2023-11-11  Joern Rennecke  <joern.rennecke@embecosm.com>
+
+	* doc/sourcebuild.texi (Scan the assembly output): Document change.
+
+2023-11-10  Mao  <sray@live.com>
+
+	PR middle-end/110983
+	* doc/invoke.texi (Option Summary): Add -fpatchable-function-entry.
+
+2023-11-10  Maciej W. Rozycki  <macro@embecosm.com>
+
+	* config/riscv/riscv.md (length): Fix indentation for branch and
+	jump length calculation expressions.
+
+2023-11-10  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* fold-const.cc (operand_compare::operand_equal_p) <CONSTRUCTOR>:
+	Deal with nonempty constant CONSTRUCTORs.
+	(operand_compare::hash_operand) <CONSTRUCTOR>: Hash DECL_FIELD_OFFSET
+	and DECL_FIELD_BIT_OFFSET for FIELD_DECLs.
+
+2023-11-10  Vladimir N. Makarov  <vmakarov@redhat.com>
+
+	PR target/112337
+	* ira-costs.cc: (validate_autoinc_and_mem_addr_p): New function.
+	(equiv_can_be_consumed_p): Use it.
+
+2023-11-10  Richard Sandiford  <richard.sandiford@arm.com>
+
+	* read-rtl.cc (md_reader::read_mapping): Allow iterators to
+	include other iterators.
+	* doc/md.texi: Document the change.
+	* config/aarch64/iterators.md (DREG2, VQ2, TX2, DX2, SX2): Include
+	the iterator that is being duplicated, rather than reproducing it.
+	(VSTRUCT_D): Redefine using VSTRUCT_[234]D.
+	(VSTRUCT_Q): Likewise VSTRUCT_[234]Q.
+	(VSTRUCT_2QD, VSTRUCT_3QD, VSTRUCT_4QD, VSTRUCT_QD): Redefine using
+	the individual D and Q iterators.
+
+2023-11-10  Uros Bizjak  <ubizjak@gmail.com>
+
+	* config/i386/i386.md (stack_protect_set_1 peephole2):
+	Explicitly check operand 2 for word_mode.
+	(stack_protect_set_1 peephole2 #2): Ditto.
+	(stack_protect_set_2 peephole2): Ditto.
+	(stack_protect_set_3 peephole2): Ditto.
+	(*stack_protect_set_4z_<mode>_di): New insn patter.
+	(*stack_protect_set_4s_<mode>_di): Ditto.
+	(stack_protect_set_4 peephole2): New peephole2 pattern to
+	substitute stack protector scratch register clear with unrelated
+	register initialization involving zero/sign-extend instruction.
+
+2023-11-10  Uros Bizjak  <ubizjak@gmail.com>
+
+	* config/i386/i386.md (shift): Use SAL insted of SLL
+	for ashift insn mnemonic.
+
+2023-11-10  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	PR tree-optimization/112438
+	* tree-vect-loop.cc (vectorizable_induction): Bugfix when
+	LOOP_VINFO_USING_SELECT_VL_P.
+
+2023-11-10  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-protos.h (enum insn_type): New enum.
+	* config/riscv/riscv-v.cc
+	(rvv_builder::combine_sequence_use_slideup_profitable_p): New function.
+	(expand_vector_init_slideup_combine_sequence): Ditto.
+	(expand_vec_init): Add slideup combine optimization.
+
+2023-11-10  Robin Dapp  <rdapp@ventanamicro.com>
+
+	PR tree-optimization/112464
+	* tree-vect-loop.cc (vectorize_fold_left_reduction): Use
+	vect_orig_stmt on scalar_dest_def_info.
+
+2023-11-10  Jin Ma  <jinma@linux.alibaba.com>
+
+	* config/riscv/riscv.cc (riscv_for_each_saved_reg): Place the interrupt
+	operation before the XTheadMemPair.
+
+2023-11-10  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/110221
+	* tree-vect-slp.cc (vect_schedule_slp_node): When loop
+	masking / len is applied make sure to not schedule
+	intenal defs outside of the loop.
+
+2023-11-10  Andrew Stubbs  <ams@codesourcery.com>
+
+	* expr.cc (store_constructor): Add "and" operation to uniform mask
+	generation.
+
+2023-11-10  Andrew Stubbs  <ams@codesourcery.com>
+
+	PR target/112308
+	* config/gcn/gcn-valu.md (add<mode>3<exec_clobber>): Fix B constraint
+	and switch to the new format.
+	(add<mode>3_dup<exec_clobber>): Likewise.
+	(add<mode>3_vcc<exec_vcc>): Likewise.
+	(add<mode>3_vcc_dup<exec_vcc>): Likewise.
+	(add<mode>3_vcc_zext_dup): Likewise.
+	(add<mode>3_vcc_zext_dup_exec): Likewise.
+	(add<mode>3_vcc_zext_dup2): Likewise.
+	(add<mode>3_vcc_zext_dup2_exec): Likewise.
+
+2023-11-10  Richard Biener  <rguenther@suse.de>
+
+	PR middle-end/112469
+	* match.pd (cond ? op a : b -> .COND_op (cond, a, b)): Add
+	missing view_converts.
+
+2023-11-10  Andrew Stubbs  <ams@codesourcery.com>
+
+	* config/gcn/gcn.cc (gcn_expand_reduc_scalar): Add clobber to DImode
+	min/max instructions.
+
+2023-11-10  Chenghui Pan  <panchenghui@loongson.cn>
+
+	* config/loongarch/lsx.md: Fix instruction name typo in
+	lsx_vreplgr2vr_<lsxfmt_f> template.
+
+2023-11-10  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/autovec.md (vec_init<mode><vel>): Split patterns.
+
+2023-11-10  Pan Li  <pan2.li@intel.com>
+
+	Revert:
+	2023-11-10  Pan Li  <pan2.li@intel.com>
+	* config/riscv/riscv-v.cc (expand_vector_init_trailing_same_elem):
+	New fun impl to expand the insn when trailing same elements.
+	(expand_vec_init): Try trailing same elements when vec_init.
+
+2023-11-10  Pan Li  <pan2.li@intel.com>
+
+	* config/riscv/riscv-v.cc (expand_vector_init_trailing_same_elem):
+	New fun impl to expand the insn when trailing same elements.
+	(expand_vec_init): Try trailing same elements when vec_init.
+
+2023-11-10  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/autovec-opt.md (*cond_copysign<mode>): Remove.
+	* config/riscv/autovec.md (cond_copysign<mode>): New pattern.
+
+2023-11-10  Pan Li  <pan2.li@intel.com>
+
+	PR target/112432
+	* internal-fn.def (LRINT): Add FLOATN support.
+	(LROUND): Ditto.
+	(LLRINT): Ditto.
+	(LLROUND): Ditto.
+
+2023-11-10  Jeff Law  <jlaw@ventanamicro.com>
+
+	* config/h8300/combiner.md (single bit sign_extract): Avoid recently
+	added patterns for H8/SX.
+	(single bit zero_extract): New patterns.
+
+2023-11-10  liuhongt  <hongtao.liu@intel.com>
+
+	PR target/112443
+	* config/i386/sse.md (*avx2_pcmp<mode>3_4): Fix swap condition
+	from LT to GT since there's not in the pattern.
+	(*avx2_pcmp<mode>3_5): Ditto.
+
+2023-11-10  Jose E. Marchesi  <jose.marchesi@oracle.com>
+
+	* config/bpf/bpf.cc (bpf_print_register): Accept modifier code 'W'
+	to force emitting register names using the wN form.
+	* config/bpf/bpf.md (*mulsidi3_zeroextend): Force operands to
+	always use wN written form in pseudo-C assembly syntax.
+
+2023-11-09  David Malcolm  <dmalcolm@redhat.com>
+
+	* diagnostic-show-locus.cc (layout::m_line_table): New field.
+	(compatible_locations_p): Convert to...
+	(layout::compatible_locations_p): ...this, replacing uses of
+	line_table global with m_line_table.
+	(layout::layout): Convert "richloc" param from a pointer to a
+	const reference.  Initialize m_line_table member.
+	(layout::maybe_add_location_range):  Replace uses of line_table
+	global with m_line_table.  Pass the latter to
+	linemap_client_expand_location_to_spelling_point.
+	(layout::print_leading_fixits): Pass m_line_table to
+	affects_line_p.
+	(layout::print_trailing_fixits): Likewise.
+	(gcc_rich_location::add_location_if_nearby): Update for change
+	to layout ctor params.
+	(diagnostic_show_locus): Convert to...
+	(diagnostic_context::maybe_show_locus): ...this, converting
+	richloc param from a pointer to a const reference.  Make "loc"
+	const.  Split out printing part of function to...
+	(diagnostic_context::show_locus): ...this.
+	(selftest::test_offset_impl): Update for change to layout ctor
+	params.
+	(selftest::test_layout_x_offset_display_utf8): Likewise.
+	(selftest::test_layout_x_offset_display_tab): Likewise.
+	(selftest::test_tab_expansion): Likewise.
+	* diagnostic.h (diagnostic_context::maybe_show_locus): New decl.
+	(diagnostic_context::show_locus): New decl.
+	(diagnostic_show_locus): Convert from a decl to an inline function.
+	* gdbinit.in (break-on-diagnostic): Update from a breakpoint
+	on diagnostic_show_locus to one on
+	diagnostic_context::maybe_show_locus.
+	* genmatch.cc (linemap_client_expand_location_to_spelling_point):
+	Add "set" param and use it in place of line_table global.
+	* input.cc (expand_location_1): Likewise.
+	(expand_location): Update for new param of expand_location_1.
+	(expand_location_to_spelling_point): Likewise.
+	(linemap_client_expand_location_to_spelling_point): Add "set"
+	param and use it in place of line_table global.
+	* tree-diagnostic-path.cc (event_range::print): Pass line_table
+	for new param of linemap_client_expand_location_to_spelling_point.
+
+2023-11-09  Uros Bizjak  <ubizjak@gmail.com>
+
+	* config/i386/i386.md (@stack_protect_set_1_<PTR:mode>_<W:mode>):
+	Use W mode iterator instead of SWI48.  Output MOV instead of XOR
+	for TARGET_USE_MOV0.
+	(stack_protect_set_1 peephole2): Use integer modes with
+	mode size <= word mode size for operand 3.
+	(stack_protect_set_1 peephole2 #2): New peephole2 pattern to
+	substitute stack protector scratch register clear with unrelated
+	register initialization, originally in front of stack
+	protector sequence.
+	(*stack_protect_set_3_<PTR:mode>_<SWI48:mode>): New insn pattern.
+	(stack_protect_set_1 peephole2): New peephole2 pattern to
+	substitute stack protector scratch register clear with unrelated
+	register initialization involving LEA instruction.
+
+2023-11-09  Vladimir N. Makarov  <vmakarov@redhat.com>
+
+	PR rtl-optimization/110215
+	* ira-lives.cc: (add_conflict_from_region_landing_pads): New
+	function.
+	(process_bb_node_lives): Use it.
+
+2023-11-09  Alexandre Oliva  <oliva@adacore.com>
+
+	* config/i386/i386.cc (symbolic_base_address_p,
+	base_address_p): New, factored out from...
+	(extract_base_offset_in_addr): ... here and extended to
+	recognize REG+GOTOFF, as in gcc.target/i386/sse2-load-multi.c
+	and sse2-store-multi.c with PIE enabled by default.
+
+2023-11-09  Tamar Christina  <tamar.christina@arm.com>
+
+	PR tree-optimization/109154
+	* config/aarch64/aarch64-sve.md (cond_copysign<mode>): New.
+
+2023-11-09  Tamar Christina  <tamar.christina@arm.com>
+
+	PR tree-optimization/109154
+	* config/aarch64/aarch64.md (copysign<GPF:mode>3): Handle
+	copysign (x, -1).
+	* config/aarch64/aarch64-simd.md (copysign<mode>3): Likewise.
+	* config/aarch64/aarch64-sve.md (copysign<mode>3): Likewise.
+
+2023-11-09  Tamar Christina  <tamar.christina@arm.com>
+
+	PR tree-optimization/109154
+	* config/aarch64/aarch64.md (<optab><mode>3): Add SVE split case.
+	* config/aarch64/aarch64-simd.md (ior<mode>3<vczle><vczbe>): Likewise.
+	* config/aarch64/predicates.md(aarch64_orr_imm_sve_advsimd): New.
+
+2023-11-09  Tamar Christina  <tamar.christina@arm.com>
+
+	PR tree-optimization/109154
+	* config/aarch64/aarch64.md (*mov<mode>_aarch64, *movsi_aarch64,
+	*movdi_aarch64): Add new w -> Z case.
+	* config/aarch64/iterators.md (Vbtype): Add QI and HI.
+
+2023-11-09  Tamar Christina  <tamar.christina@arm.com>
+
+	PR tree-optimization/109154
+	* config/aarch64/aarch64-protos.h (aarch64_simd_special_constant_p,
+	aarch64_maybe_generate_simd_constant): New.
+	* config/aarch64/aarch64-simd.md (*aarch64_simd_mov<VQMOV:mode>,
+	*aarch64_simd_mov<VDMOV:mode>): Add new coden for special constants.
+	* config/aarch64/aarch64.cc (aarch64_extract_vec_duplicate_wide_int):
+	Take optional mode.
+	(aarch64_simd_special_constant_p,
+	aarch64_maybe_generate_simd_constant): New.
+	* config/aarch64/aarch64.md (*movdi_aarch64): Add new codegen for
+	special constants.
+	* config/aarch64/constraints.md (Dx): new.
+
+2023-11-09  Tamar Christina  <tamar.christina@arm.com>
+
+	PR tree-optimization/109154
+	* internal-fn.def (COPYSIGN): New.
+	* match.pd (UNCOND_BINARY, COND_BINARY): Map IFN_COPYSIGN to
+	IFN_COND_COPYSIGN.
+	* optabs.def (cond_copysign_optab, cond_len_copysign_optab): New.
+
+2023-11-09  Tamar Christina  <tamar.christina@arm.com>
+
+	PR tree-optimization/109154
+	* match.pd: Add new neg+abs rule, remove inverse copysign rule.
+
+2023-11-09  Tamar Christina  <tamar.christina@arm.com>
+
+	PR tree-optimization/109154
+	* match.pd: expand existing copysign optimizations.
+
+2023-11-09  Tatsuyuki Ishi  <ishitatsuyuki@gmail.com>
+
+	PR driver/111605
+	* collect2.cc (main): Do not prepend target triple to
+	-fuse-ld=lld,mold.
+
+2023-11-09  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/111133
+	* tree-vect-stmts.cc (vect_build_scatter_store_calls):
+	Remove and refactor to ...
+	(vect_build_one_scatter_store_call): ... this new function.
+	(vectorizable_store): Use vect_check_scalar_mask to record
+	the SLP node for the mask operand.  Code generate scatters
+	with builtin decls from the main scatter vectorization
+	path and prepare that for SLP.
+	* tree-vect-slp.cc (vect_get_operand_map): Do not look
+	at the VDEF to decide between scatter or gather since that
+	doesn't work for patterns.  Use the LHS being an SSA_NAME
+	or not instead.
+
+2023-11-09  Pan Li  <pan2.li@intel.com>
+
+	* config/riscv/riscv.cc (riscv_frm_emit_after_bb_end): Only
+	perform once emit when at least one succ edge is abnormal.
+
+2023-11-09  Richard Biener  <rguenther@suse.de>
+
+	* tree-vect-loop.cc (vect_verify_full_masking_avx512):
+	Check we have integer mode masks as required by
+	vect_get_loop_mask.
+
+2023-11-09  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/112444
+	* tree-ssa-sccvn.cc (visit_phi): Avoid using not visited
+	defs as undefined vals.
+
+2023-11-09  YunQiang Su  <yunqiang.su@cipunited.com>
+
+	* config/mips/mips.cc(mips_option_override): Set mips_abs to
+	2008, if mips_abs is default and mips_nan is 2008.
+
+2023-11-09  Florian Weimer  <fweimer@redhat.com>
+
+	* doc/invoke.texi (Warning Options): Document
+	-Wreturn-mismatch.  Update -Wreturn-type documentation.
+
+2023-11-09  Stefan Schulze Frielinghaus  <stefansf@linux.ibm.com>
+
+	* config/s390/s390.md: Remove UNSPEC_VEC_ELTSWAP.
+	* config/s390/vector.md (eltswapv16qi): New expander.
+	(*eltswapv16qi): New insn and splitter.
+	(eltswapv8hi): New insn and splitter.
+	(eltswap<mode>): New insn and splitter for modes V_HW_4 as well
+	as V_HW_2.
+	* config/s390/vx-builtins.md (eltswap<mode>): Remove.
+	(*eltswapv16qi): Remove.
+	(*eltswap<mode>): Remove.
+	(*eltswap<mode>_emu): Remove.
+
+2023-11-09  Stefan Schulze Frielinghaus  <stefansf@linux.ibm.com>
+
+	* config/s390/s390.cc (expand_perm_with_rot): Remove.
+	(expand_perm_reverse_elements): New.
+	(expand_perm_with_vster): Remove.
+	(expand_perm_with_vstbrq): Remove.
+	(vectorize_vec_perm_const_1): Replace removed functions with new
+	one.
+
+2023-11-09  Stefan Schulze Frielinghaus  <stefansf@linux.ibm.com>
+
+	* config/s390/s390.cc (expand_perm_with_merge): Deal with cases
+	where vmr{l,h} are still applicable if the operands are swapped.
+	(expand_perm_with_vpdi): Likewise for vpdi.
+
+2023-11-09  Stefan Schulze Frielinghaus  <stefansf@linux.ibm.com>
+
+	* config/s390/s390.md (VX_CONV_INT): Remove iterator.
+	(gf): Add float mappings.
+	(TOINT, toint): New attribute.
+	(*fixuns_trunc<VX_CONV_BFP:mode><VX_CONV_INT:mode>2_z13):
+	Remove.
+	(*fixuns_trunc<mode><toint>2_z13): Add.
+	(*fix_trunc<VX_CONV_BFP:mode><VX_CONV_INT:mode>2_bfp_z13):
+	Remove.
+	(*fix_trunc<mode><toint>2_bfp_z13): Add.
+	(*floatuns<VX_CONV_INT:mode><VX_CONV_BFP:mode>2_z13): Remove.
+	(*floatuns<toint><mode>2_z13): Add.
+	* config/s390/vector.md (VX_VEC_CONV_INT): Remove iterator.
+	(float<VX_VEC_CONV_INT:mode><VX_VEC_CONV_BFP:mode>2): Remove.
+	(float<tointvec><mode>2): Add.
+	(floatuns<VX_VEC_CONV_INT:mode><VX_VEC_CONV_BFP:mode>2): Remove.
+	(floatuns<tointvec><mode>2): Add.
+	(fix_trunc<VX_VEC_CONV_BFP:mode><VX_VEC_CONV_INT:mode>2):
+	Remove.
+	(fix_trunc<mode><tointvec>2): Add.
+	(fixuns_trunc<VX_VEC_CONV_BFP:mode><VX_VEC_CONV_INT:mode>2):
+	Remove.
+	(fixuns_trunc<VX_VEC_CONV_BFP:mode><tointvec>2): Add.
+
+2023-11-09  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c/112339
+	* attribs.cc (attribute_ignored_p): Only return true for
+	attr_namespace_ignored_p if as is NULL.
+	(decl_attributes): Never add ignored attributes.
+
+2023-11-09  Jin Ma  <jinma@linux.alibaba.com>
+
+	* config/riscv/bitmanip.md: Avoid the conflict between
+	zbb and xtheadmemidx in patterns.
+
+2023-11-09  Richard Biener  <rguenther@suse.de>
+
+	* tree-vect-stmts.cc (vectorizable_simd_clone_call): Record
+	to the correct simd_clone_info.
+
+2023-11-09  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	* config/riscv/riscv-vector-costs.cc (costs::preferred_new_lmul_p): Fix ICE.
+
+2023-11-09  Alexandre Oliva  <oliva@adacore.com>
+
+	* tree-cfg.cc (assign_discriminators): Handle debug stmts.
+
 2023-11-08  Uros Bizjak  <ubizjak@gmail.com>
 
 	PR target/82524
diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP
index aa6461f..6ce2b65 100644
--- a/gcc/DATESTAMP
+++ b/gcc/DATESTAMP
@@ -1 +1 @@
-20231109
+20231119
diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index 7f2df4b..753f2f3 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -1038,6 +1038,7 @@ SYSTEM_H = system.h hwint.h $(srcdir)/../include/libiberty.h \
 	$(HASHTAB_H)
 PREDICT_H = predict.h predict.def
 CPPLIB_H = $(srcdir)/../libcpp/include/line-map.h \
+	$(srcdir)/../libcpp/include/rich-location.h \
 	$(srcdir)/../libcpp/include/cpplib.h
 CODYLIB_H = $(srcdir)/../libcody/cody.hh
 INPUT_H = $(srcdir)/../libcpp/include/line-map.h input.h
@@ -1324,6 +1325,7 @@ ANALYZER_OBJS = \
 	analyzer/engine.o \
 	analyzer/feasible-graph.o \
 	analyzer/function-set.o \
+	analyzer/infinite-loop.o \
 	analyzer/infinite-recursion.o \
 	analyzer/kf.o \
 	analyzer/kf-analyzer.o \
diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog
index 968f6f7..45c3f37 100644
--- a/gcc/ada/ChangeLog
+++ b/gcc/ada/ChangeLog
@@ -1,3 +1,23 @@
+2023-11-16  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gcc-interface/decl.cc (gnat_to_gnu_subprog_type): Also create a
+	TYPE_DECL for the return type built for the CI/CO mechanism.
+
+2023-11-10  Andris Pavēnis  <andris.pavenis@iki.fi>
+
+	* expect.c (__gnat_waitpid): fix syntax errors
+
+2023-11-09  Simon Wright  <simon@pushface.org>
+
+	PR ada/111813
+	* libgnat/a-calfor.adb (Value (2)): Allow values of
+	parameter Elapsed_Time greater than or equal to 24 hours, by doing
+	the hour calculations in Natural rather than Hour_Number (0 ..
+	23). Calculate the result directly rather than by using Seconds_Of
+	(whose Hour parameter is of type Hour_Number).
+	If an exception occurs of type Constraint_Error, re-raise it
+	rather than raising a new CE.
+
 2023-11-07  Joseph Myers  <joseph@codesourcery.com>
 
 	* gcc-interface/utils.cc (flag_isoc2x): Rename to flag_isoc23.
diff --git a/gcc/ada/gcc-interface/decl.cc b/gcc/ada/gcc-interface/decl.cc
index 95fa508..9c7f684 100644
--- a/gcc/ada/gcc-interface/decl.cc
+++ b/gcc/ada/gcc-interface/decl.cc
@@ -6329,6 +6329,12 @@ gnat_to_gnu_subprog_type (Entity_Id gnat_subprog, bool definition,
 
 	  if (debug_info_p)
 	    rest_of_record_type_compilation (gnu_cico_return_type);
+
+	  /* Declare it now since it will never be declared otherwise.  This
+	     is necessary to ensure that its subtrees are properly marked.  */
+	  create_type_decl (TYPE_NAME (gnu_cico_return_type),
+			    gnu_cico_return_type,
+			    true, debug_info_p, gnat_subprog);
 	}
 
       gnu_return_type = gnu_cico_return_type;
diff --git a/gcc/analyzer/ChangeLog b/gcc/analyzer/ChangeLog
index e565870..e92c518 100644
--- a/gcc/analyzer/ChangeLog
+++ b/gcc/analyzer/ChangeLog
@@ -1,3 +1,121 @@
+2023-11-18  David Malcolm  <dmalcolm@redhat.com>
+
+	PR analyzer/106147
+	* analyzer.opt (Wanalyzer-infinite-loop): New option.
+	(fdump-analyzer-infinite-loop): New option.
+	* checker-event.h (start_cfg_edge_event::get_desc): Drop "final".
+	(start_cfg_edge_event::maybe_describe_condition): Convert from
+	private to protected.
+	* checker-path.h (checker_path::get_logger): New.
+	* diagnostic-manager.cc (process_worklist_item): Update for
+	new context param of maybe_update_for_edge.
+	* engine.cc
+	(impl_region_model_context::impl_region_model_context): Add
+	out_could_have_done_work param to both ctors and use it to
+	initialize mm_out_could_have_done_work.
+	(impl_region_model_context::maybe_did_work): New vfunc
+	implementation.
+	(exploded_node::on_stmt): Add out_could_have_done_work param and
+	pass to ctxt ctor.
+	(exploded_node::on_stmt_pre): Treat setjmp and longjmp as "doing
+	work".
+	(exploded_node::on_longjmp): Likewise.
+	(exploded_edge::exploded_edge): Add "could_do_work" param and use
+	it to initialize m_could_do_work_p.
+	(exploded_edge::dump_dot_label): Add result of could_do_work_p.
+	(exploded_graph::add_function_entry): Mark edge as doing no work.
+	(exploded_graph::add_edge): Add "could_do_work" param and pass to
+	exploded_edge ctor.
+	(add_tainted_args_callback): Treat as doing no work.
+	(exploded_graph::process_worklist): Likewise when merging nodes.
+	(maybe_process_run_of_before_supernode_enodes::item): Likewise.
+	(exploded_graph::maybe_create_dynamic_call): Likewise.
+	(exploded_graph::process_node): Likewise for phi nodes.
+	Pass in a "could_have_done_work" bool when handling stmts and use
+	when creating edges.  Assume work is done at bifurcation.
+	(exploded_path::feasible_p): Update for new context param of
+	maybe_update_for_edge.
+	(feasibility_state::feasibility_state): New ctor.
+	(feasibility_state::operator=): New.
+	(feasibility_state::maybe_update_for_edge): Add ctxt param and use
+	it.  Fix missing newline when logging state.
+	(impl_run_checkers): Call exploded_graph::detect_infinite_loops.
+	* exploded-graph.h
+	(impl_region_model_context::impl_region_model_context): Add
+	out_could_have_done_work param to both ctors.
+	(impl_region_model_context::maybe_did_work): New decl.
+	(impl_region_model_context::checking_for_infinite_loop_p): New.
+	(impl_region_model_context::on_unusable_in_infinite_loop): New.
+	(impl_region_model_context::m_out_could_have_done_work): New
+	field.
+	(exploded_node::on_stmt): Add "out_could_have_done_work" param.
+	(exploded_edge::exploded_edge): Add "could_do_work" param.
+	(exploded_edge::could_do_work_p): New accessor.
+	(exploded_edge::m_could_do_work_p): New field.
+	(exploded_graph::add_edge): Add "could_do_work" param.
+	(exploded_graph::detect_infinite_loops): New decl.
+	(feasibility_state::feasibility_state): New ctor.
+	(feasibility_state::operator=): New decl.
+	(feasibility_state::maybe_update_for_edge): Add ctxt param.
+	* infinite-loop.cc: New file.
+	* program-state.cc (program_state::on_edge): Log the rejected
+	constraint when region_model::maybe_update_for_edge fails.
+	* region-model.cc (region_model::on_assignment): Treat any writes
+	other than to the stack as "doing work".
+	(region_model::on_stmt_pre): Treat all asm stmts as "doing work".
+	(region_model::on_call_post): Likewise for all calls to functions
+	with unknown side effects.
+	(region_model::handle_phi): Add svals_changing_meaning param.
+	Mark widening svalue in phi nodes as changing meaning.
+	(unusable_in_infinite_loop_constraint_p): New.
+	(region_model::add_constraint): If we're checking for an infinite
+	loop, bail out on unusable svalues, or if we don't have a definite
+	true/false for the constraint.
+	(region_model::update_for_phis): Gather all svalues changing
+	meaning in phi nodes, and purge constraints involving them.
+	(region_model::replay_call_summary): Treat all call summaries as
+	doing work.
+	(region_model::can_merge_with_p): Purge constraints involving
+	svalues that change meaning.
+	(model_merger::on_widening_reuse): New.
+	(test_iteration_1): Likewise.
+	(selftest::test_iteration_1): Remove assertion that model6 "knows"
+	that i < 157.
+	* region-model.h (region_model::handle_phi): Add
+	svals_changing_meaning param
+	(region_model_context::maybe_did_work): New pure virtual func.
+	(region_model_context::checking_for_infinite_loop_p): Likewise.
+	(region_model_context::on_unusable_in_infinite_loop): Likewise.
+	(noop_region_model_context::maybe_did_work): Implement.
+	(noop_region_model_context::checking_for_infinite_loop_p):
+	Likewise.
+	(noop_region_model_context::on_unusable_in_infinite_loop):
+	Likewise.
+	(region_model_context_decorator::maybe_did_work): Implement.
+	(region_model_context_decorator::checking_for_infinite_loop_p):
+	Likewise.
+	(region_model_context_decorator::on_unusable_in_infinite_loop):
+	Likewise.
+	(model_merger::on_widening_reuse): New decl.
+	(model_merger::m_svals_changing_meaning): New field.
+	* sm-signal.cc (register_signal_handler::impl_transition): Assume
+	the edge "does work".
+	* supergraph.cc (supernode::get_start_location): Use CFG edge's
+	goto_locus if available.
+	(supernode::get_end_location): Likewise.
+	(cfg_superedge::dump_label_to_pp): Dump edges with a "goto_locus"
+	* supergraph.h (cfg_superedge::get_goto_locus): New.
+	* svalue.cc (svalue::can_merge_p): Call on_widening_reuse for
+	widening values.
+	(involvement_visitor::visit_widening_svalue): New.
+	(svalue::involves_p): Update assertion to allow widening svalues.
+
+2023-11-14  David Malcolm  <dmalcolm@redhat.com>
+
+	PR analyzer/103533
+	* sm-taint.cc: Remove "experimental" from comment.
+	* sm.cc (make_checkers): Always add taint state machine.
+
 2023-11-04  David Malcolm  <dmalcolm@redhat.com>
 
 	* bounds-checking.cc: Update for changes to diagnostic_context.
diff --git a/gcc/analyzer/analyzer.h b/gcc/analyzer/analyzer.h
index 777293f..cf32d4b 100644
--- a/gcc/analyzer/analyzer.h
+++ b/gcc/analyzer/analyzer.h
@@ -21,6 +21,7 @@ along with GCC; see the file COPYING3.  If not see
 #ifndef GCC_ANALYZER_ANALYZER_H
 #define GCC_ANALYZER_ANALYZER_H
 
+#include "rich-location.h"
 #include "function.h"
 #include "json.h"
 #include "tristate.h"
@@ -326,7 +327,8 @@ public:
   void impl_call_pre (const call_details &cd) const override;
 };
 
-extern void register_known_functions (known_function_manager &mgr);
+extern void register_known_functions (known_function_manager &kfm,
+				      region_model_manager &rmm);
 extern void register_known_analyzer_functions (known_function_manager &kfm);
 extern void register_known_fd_functions (known_function_manager &kfm);
 extern void register_known_file_functions (known_function_manager &kfm);
diff --git a/gcc/analyzer/analyzer.opt b/gcc/analyzer/analyzer.opt
index 25df89d..a3c30ca 100644
--- a/gcc/analyzer/analyzer.opt
+++ b/gcc/analyzer/analyzer.opt
@@ -134,6 +134,10 @@ Wanalyzer-imprecise-fp-arithmetic
 Common Var(warn_analyzer_imprecise_fp_arithmetic) Init(1) Warning
 Warn about code paths in which floating-point arithmetic is used in locations where precise computation is needed.
 
+Wanalyzer-infinite-loop
+Common Var(warn_analyzer_infinite_loop) Init(1) Warning
+Warn about code paths which appear to lead to an infinite loop.
+
 Wanalyzer-infinite-recursion
 Common Var(warn_analyzer_infinite_recursion) Init(1) Warning
 Warn about code paths which appear to lead to infinite recursion.
@@ -218,6 +222,10 @@ Wanalyzer-tainted-size
 Common Var(warn_analyzer_tainted_size) Init(1) Warning
 Warn about code paths in which an unsanitized value is used as a size.
 
+Wanalyzer-undefined-behavior-strtok
+Common Var(warn_analyzer_undefined_behavior_strtok) Init(1) Warning
+Warn about code paths in in which a call is made to strtok with undefined behavior.
+
 Wanalyzer-use-after-free
 Common Var(warn_analyzer_use_after_free) Init(1) Warning
 Warn about code paths in which a freed value is used.
@@ -354,6 +362,10 @@ fdump-analyzer-feasibility
 Common RejectNegative Var(flag_dump_analyzer_feasibility)
 Dump various analyzer internals to SRCFILE.*.fg.dot and SRCFILE.*.tg.dot.
 
+fdump-analyzer-infinite-loop
+Common RejectNegative Var(flag_dump_analyzer_infinite_loop)
+Dump various analyzer internals to SRCFILE.*.infinite-loop.dot.
+
 fdump-analyzer-json
 Common RejectNegative Var(flag_dump_analyzer_json)
 Dump analyzer-specific data to a SRCFILE.analyzer.json.gz file.
diff --git a/gcc/analyzer/call-summary.cc b/gcc/analyzer/call-summary.cc
index a18a1b1..ecb6fb1 100644
--- a/gcc/analyzer/call-summary.cc
+++ b/gcc/analyzer/call-summary.cc
@@ -585,6 +585,7 @@ call_summary_replay::convert_region_from_summary_1 (const region *summary_reg)
     case RK_STRING:
     case RK_ERRNO:
     case RK_UNKNOWN:
+    case RK_PRIVATE:
       /* We can reuse these regions directly.  */
       return summary_reg;
 
diff --git a/gcc/analyzer/checker-event.h b/gcc/analyzer/checker-event.h
index 7ba92f1..dcb2e27 100644
--- a/gcc/analyzer/checker-event.h
+++ b/gcc/analyzer/checker-event.h
@@ -444,11 +444,12 @@ public:
   {
   }
 
-  label_text get_desc (bool can_colorize) const final override;
+  label_text get_desc (bool can_colorize) const override;
 
- private:
+protected:
   label_text maybe_describe_condition (bool can_colorize) const;
 
+private:
   static label_text maybe_describe_condition (bool can_colorize,
 					      tree lhs,
 					      enum tree_code op,
diff --git a/gcc/analyzer/checker-path.h b/gcc/analyzer/checker-path.h
index 93c807c..055d5e3 100644
--- a/gcc/analyzer/checker-path.h
+++ b/gcc/analyzer/checker-path.h
@@ -65,6 +65,7 @@ public:
   void dump (pretty_printer *pp) const;
   void debug () const;
 
+  logger *get_logger () const { return m_logger; }
   void maybe_log (logger *logger, const char *desc) const;
 
   void add_event (std::unique_ptr<checker_event> event);
diff --git a/gcc/analyzer/diagnostic-manager.cc b/gcc/analyzer/diagnostic-manager.cc
index 972413a..a6755f2 100644
--- a/gcc/analyzer/diagnostic-manager.cc
+++ b/gcc/analyzer/diagnostic-manager.cc
@@ -517,7 +517,7 @@ process_worklist_item (feasible_worklist *worklist,
 
       feasibility_state succ_state (fnode->get_state ());
       std::unique_ptr<rejected_constraint> rc;
-      if (succ_state.maybe_update_for_edge (logger, succ_eedge, &rc))
+      if (succ_state.maybe_update_for_edge (logger, succ_eedge, nullptr, &rc))
 	{
 	  gcc_assert (rc == NULL);
 	  feasible_node *succ_fnode
diff --git a/gcc/analyzer/engine.cc b/gcc/analyzer/engine.cc
index 4861ee5..b4e855f 100644
--- a/gcc/analyzer/engine.cc
+++ b/gcc/analyzer/engine.cc
@@ -85,7 +85,8 @@ impl_region_model_context (exploded_graph &eg,
 			   uncertainty_t *uncertainty,
 			   path_context *path_ctxt,
 			   const gimple *stmt,
-			   stmt_finder *stmt_finder)
+			   stmt_finder *stmt_finder,
+			   bool *out_could_have_done_work)
 : m_eg (&eg), m_logger (eg.get_logger ()),
   m_enode_for_diag (enode_for_diag),
   m_old_state (old_state),
@@ -94,7 +95,8 @@ impl_region_model_context (exploded_graph &eg,
   m_stmt_finder (stmt_finder),
   m_ext_state (eg.get_ext_state ()),
   m_uncertainty (uncertainty),
-  m_path_ctxt (path_ctxt)
+  m_path_ctxt (path_ctxt),
+  m_out_could_have_done_work (out_could_have_done_work)
 {
 }
 
@@ -110,7 +112,8 @@ impl_region_model_context (program_state *state,
   m_stmt_finder (NULL),
   m_ext_state (ext_state),
   m_uncertainty (uncertainty),
-  m_path_ctxt (NULL)
+  m_path_ctxt (NULL),
+  m_out_could_have_done_work (nullptr)
 {
 }
 
@@ -1024,6 +1027,17 @@ impl_region_model_context::on_unexpected_tree_code (tree t,
     m_new_state->m_valid = false;
 }
 
+/* Implementation of region_model_context::maybe_did_work vfunc.
+   Mark that "externally visible work" has occurred, and thus we
+   shouldn't report an infinite loop here.  */
+
+void
+impl_region_model_context::maybe_did_work ()
+{
+  if (m_out_could_have_done_work)
+    *m_out_could_have_done_work = true;
+}
+
 /* struct point_and_state.  */
 
 /* Assert that this object is sane.  */
@@ -1439,6 +1453,7 @@ exploded_node::on_stmt (exploded_graph &eg,
 			const gimple *stmt,
 			program_state *state,
 			uncertainty_t *uncertainty,
+			bool *out_could_have_done_work,
 			path_context *path_ctxt)
 {
   logger *logger = eg.get_logger ();
@@ -1464,7 +1479,8 @@ exploded_node::on_stmt (exploded_graph &eg,
 
   impl_region_model_context ctxt (eg, this,
 				  &old_state, state, uncertainty,
-				  path_ctxt, stmt);
+				  path_ctxt, stmt, nullptr,
+				  out_could_have_done_work);
 
   /* Handle call summaries here.  */
   if (cgraph_edge *cgedge
@@ -1551,12 +1567,16 @@ exploded_node::on_stmt_pre (exploded_graph &eg,
       else if (is_setjmp_call_p (call))
 	{
 	  state->m_region_model->on_setjmp (call, this, ctxt);
+	  if (ctxt)
+	    ctxt->maybe_did_work ();
 	  return;
 	}
       else if (is_longjmp_call_p (call))
 	{
 	  on_longjmp (eg, call, state, ctxt);
 	  *out_terminate_path = true;
+	  if (ctxt)
+	    ctxt->maybe_did_work ();
 	  return;
 	}
     }
@@ -1938,8 +1958,9 @@ exploded_node::on_longjmp (exploded_graph &eg,
   if (next)
     {
       exploded_edge *eedge
-	= eg.add_edge (const_cast<exploded_node *> (this), next, NULL,
-		       make_unique<rewind_info_t> (tmp_setjmp_record, longjmp_call));
+	= eg.add_edge (const_cast<exploded_node *> (this), next, NULL, true,
+		       make_unique<rewind_info_t> (tmp_setjmp_record,
+						   longjmp_call));
 
       /* For any diagnostics that were queued here (such as leaks) we want
 	 the checker_path to show the rewinding events after the "final event"
@@ -2161,10 +2182,11 @@ rewind_info_t::add_events_to_path (checker_path *emission_path,
 /* exploded_edge's ctor.  */
 
 exploded_edge::exploded_edge (exploded_node *src, exploded_node *dest,
-			      const superedge *sedge,
+			      const superedge *sedge, bool could_do_work,
 			      std::unique_ptr<custom_edge_info> custom_info)
 : dedge<eg_traits> (src, dest), m_sedge (sedge),
-  m_custom_info (std::move (custom_info))
+  m_custom_info (std::move (custom_info)),
+  m_could_do_work_p (could_do_work)
 {
 }
 
@@ -2228,6 +2250,9 @@ exploded_edge::dump_dot_label (pretty_printer *pp) const
   else if (m_custom_info)
     m_custom_info->print (pp);
 
+  pp_printf (pp, "%s",
+	     could_do_work_p () ? "(could do work)" : "DOES NO WORK");
+
   //pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/false);
 
   pp_printf (pp, "\"];\n");
@@ -2790,7 +2815,7 @@ exploded_graph::add_function_entry (function *fun)
   if (!enode)
     return NULL;
 
-  add_edge (m_origin, enode, NULL, std::move (edge_info));
+  add_edge (m_origin, enode, NULL, false, std::move (edge_info));
 
   m_functions_with_enodes.add (fun);
 
@@ -2988,19 +3013,20 @@ exploded_graph::get_or_create_node (const program_point &point,
 
 /* Add an exploded_edge from SRC to DEST, recording its association
    with SEDGE (which may be NULL), and, if non-NULL, taking ownership
-   of CUSTOM_INFO.
+   of CUSTOM_INFO.  COULD_DO_WORK is used for detecting infinite loops.
    Return the newly-created eedge.  */
 
 exploded_edge *
 exploded_graph::add_edge (exploded_node *src, exploded_node *dest,
-			  const superedge *sedge,
-			    std::unique_ptr<custom_edge_info> custom_info)
+			  const superedge *sedge, bool could_do_work,
+			  std::unique_ptr<custom_edge_info> custom_info)
 {
   if (get_logger ())
     get_logger ()->log ("creating edge EN: %i -> EN: %i",
 			src->m_index, dest->m_index);
-  exploded_edge *e = new exploded_edge (src, dest, sedge,
-					std::move (custom_info));
+  exploded_edge *e
+    = new exploded_edge (src, dest, sedge, could_do_work,
+			 std::move (custom_info));
   digraph<eg_traits>::add_edge (e);
   return e;
 }
@@ -3249,7 +3275,7 @@ add_tainted_args_callback (exploded_graph *eg, tree field, tree fndecl,
 	}
     }
 
-  eg->add_edge (eg->get_origin (), enode, NULL,
+  eg->add_edge (eg->get_origin (), enode, NULL, false,
 		make_unique<tainted_args_call_info> (field, fndecl, loc));
 }
 
@@ -3403,7 +3429,7 @@ exploded_graph::process_worklist ()
 		    if (merged_state == state)
 		      {
 			/* Then merge node_2 into node by adding an edge.  */
-			add_edge (node_2, node, NULL);
+			add_edge (node_2, node, NULL, false);
 
 			/* Remove node_2 from the worklist.  */
 			m_worklist.take_next ();
@@ -3416,7 +3442,7 @@ exploded_graph::process_worklist ()
 			/* Then merge node into node_2, and leave node_2
 			   in the worklist, to be processed on the next
 			   iteration.  */
-			add_edge (node, node_2, NULL);
+			add_edge (node, node_2, NULL, false);
 			node->set_status (exploded_node::STATUS_MERGER);
 			continue;
 		      }
@@ -3461,7 +3487,7 @@ exploded_graph::process_worklist ()
 			  m_worklist.add_node (merged_enode);
 			else
 			  {
-			    add_edge (node, merged_enode, NULL);
+			    add_edge (node, merged_enode, NULL, false);
 			    node->set_status (exploded_node::STATUS_MERGER);
 			  }
 
@@ -3469,7 +3495,7 @@ exploded_graph::process_worklist ()
 			  m_worklist.add_node (merged_enode);
 			else
 			  {
-			    add_edge (node_2, merged_enode, NULL);
+			    add_edge (node_2, merged_enode, NULL, false);
 			    node_2->set_status (exploded_node::STATUS_MERGER);
 			  }
 
@@ -3704,7 +3730,8 @@ maybe_process_run_of_before_supernode_enodes (exploded_node *enode)
     {
       exploded_node *next = next_enodes[it->m_merger_idx];
       if (next)
-	add_edge (it->m_input_enode, next, NULL);
+	add_edge (it->m_input_enode, next, NULL,
+		  false); /* no "work" is done during merger.  */
       it->m_input_enode->set_status (exploded_node::STATUS_BULK_MERGED);
     }
 
@@ -3847,6 +3874,7 @@ exploded_graph::maybe_create_dynamic_call (const gcall *call,
 						     node);
 	  if (enode)
 	    add_edge (node,enode, NULL,
+		      false, /* No work is done by the call itself.  */
 		      make_unique<dynamic_call_info_t> (call));
 	  return true;
 	}
@@ -4039,7 +4067,8 @@ exploded_graph::process_node (exploded_node *node)
 	program_point next_point (point.get_next ());
 	exploded_node *next = get_or_create_node (next_point, next_state, node);
 	if (next)
-	  add_edge (node, next, NULL);
+	  add_edge (node, next, NULL,
+		    false); /* Assume no work is done at phi nodes.  */
       }
       break;
     case PK_BEFORE_STMT:
@@ -4067,6 +4096,7 @@ exploded_graph::process_node (exploded_node *node)
 
 	impl_path_context path_ctxt (&next_state, logger);
 
+	bool could_have_done_work = false;
 	uncertainty_t uncertainty;
 	const supernode *snode = point.get_supernode ();
 	unsigned stmt_idx;
@@ -4090,7 +4120,7 @@ exploded_graph::process_node (exploded_node *node)
 	    /* Process the stmt.  */
 	    exploded_node::on_stmt_flags flags
 	      = node->on_stmt (*this, snode, stmt, &next_state, &uncertainty,
-			       &path_ctxt);
+			       &could_have_done_work, &path_ctxt);
 	    node->m_num_processed_stmts++;
 
 	    /* If flags.m_terminate_path, stop analyzing; any nodes/edges
@@ -4147,7 +4177,7 @@ exploded_graph::process_node (exploded_node *node)
 		    node->m_num_processed_stmts--;
 		    if (logger)
 		      logger->log ("creating edge to split_enode");
-		    add_edge (node, split_enode, NULL);
+		    add_edge (node, split_enode, NULL, could_have_done_work);
 		    return;
 		  }
 		else
@@ -4174,7 +4204,7 @@ exploded_graph::process_node (exploded_node *node)
 	    exploded_node *next
 	      = get_or_create_node (next_point, next_state, node);
 	    if (next)
-	      add_edge (node, next, NULL);
+	      add_edge (node, next, NULL, could_have_done_work);
 	  }
 
 	/* If we have custom edge infos, "bifurcate" the state
@@ -4212,7 +4242,9 @@ exploded_graph::process_node (exploded_node *node)
 		exploded_node *next2
 		  = get_or_create_node (next_point, bifurcated_new_state, node);
 		if (next2)
-		  add_edge (node, next2, NULL, std::move (edge_info));
+		  add_edge (node, next2, NULL,
+			    true /* assume that work could be done */,
+			    std::move (edge_info));
 	      }
 	    else
 	      {
@@ -4327,7 +4359,8 @@ exploded_graph::process_node (exploded_node *node)
 					    next_state,
 					    node);
 		    if (next)
-		      add_edge (node, next, succ);
+		      add_edge (node, next, succ,
+				true /* assume that work is done */);
 		  }
 	      }
 
@@ -4343,7 +4376,7 @@ exploded_graph::process_node (exploded_node *node)
 						      node);
 	    if (next)
 	      {
-		add_edge (node, next, succ);
+		add_edge (node, next, succ, false);
 
 		/* We might have a function entrypoint.  */
 		detect_infinite_recursion (next);
@@ -4377,7 +4410,7 @@ exploded_graph::process_node (exploded_node *node)
 							   next_state,
 							   node);
 		if (enode)
-		  add_edge (node, enode, NULL,
+		  add_edge (node, enode, NULL, false,
 			    make_unique<dynamic_call_info_t> (call, true));
 	      }
 	  }
@@ -4708,7 +4741,7 @@ exploded_path::feasible_p (logger *logger,
 		     eedge->m_dest->m_index);
 
       std::unique_ptr <rejected_constraint> rc;
-      if (!state.maybe_update_for_edge (logger, eedge, &rc))
+      if (!state.maybe_update_for_edge (logger, eedge, nullptr, &rc))
 	{
 	  gcc_assert (rc);
 	  if (out)
@@ -4835,6 +4868,21 @@ feasibility_state::feasibility_state (const feasibility_state &other)
   bitmap_copy (m_snodes_visited, other.m_snodes_visited);
 }
 
+feasibility_state::feasibility_state (const region_model &model,
+				      const supergraph &sg)
+: m_model (model),
+  m_snodes_visited (sg.m_nodes.length ())
+{
+}
+
+feasibility_state &
+feasibility_state::operator= (const feasibility_state &other)
+{
+  m_model = other.m_model;
+  bitmap_copy (m_snodes_visited, other.m_snodes_visited);
+  return *this;
+}
+
 /* The heart of feasibility-checking.
 
    Attempt to update this state in-place based on traversing EEDGE
@@ -4849,6 +4897,7 @@ bool
 feasibility_state::
 maybe_update_for_edge (logger *logger,
 		       const exploded_edge *eedge,
+		       region_model_context *ctxt,
 		       std::unique_ptr<rejected_constraint> *out_rc)
 {
   const exploded_node &src_enode = *eedge->m_src;
@@ -4887,12 +4936,14 @@ maybe_update_for_edge (logger *logger,
 	}
 
       const gimple *last_stmt = src_point.get_supernode ()->get_last_stmt ();
-      if (!m_model.maybe_update_for_edge (*sedge, last_stmt, NULL, out_rc))
+      if (!m_model.maybe_update_for_edge (*sedge, last_stmt, ctxt, out_rc))
 	{
 	  if (logger)
 	    {
-	      logger->log ("rejecting due to region model");
+	      logger->start_log_line ();
+	      logger->log_partial ("rejecting due to region model: ");
 	      m_model.dump_to_pp (logger->get_printer (), true, false);
+	      logger->end_log_line ();
 	    }
 	  return false;
 	}
@@ -4908,13 +4959,13 @@ maybe_update_for_edge (logger *logger,
 		      == PK_BEFORE_SUPERNODE);
 	  function *fun = eedge->m_dest->get_function ();
 	  gcc_assert (fun);
-	  m_model.push_frame (fun, NULL, NULL);
+	  m_model.push_frame (fun, NULL, ctxt);
 	  if (logger)
 	    logger->log ("  pushing frame for %qD", fun->decl);
 	}
       else if (eedge->m_custom_info)
 	{
-	  eedge->m_custom_info->update_model (&m_model, eedge, NULL);
+	  eedge->m_custom_info->update_model (&m_model, eedge, ctxt);
 	}
     }
 
@@ -4933,7 +4984,7 @@ maybe_update_for_edge (logger *logger,
 	    logger->log ("  update for phis");
 	  m_model.update_for_phis (src_enode.get_supernode (),
 				  last_cfg_superedge,
-				  NULL);
+				  ctxt);
 	  /* If we've entering an snode that we've already visited on this
 	     epath, then we need do fix things up for loops; see the
 	     comment for store::loop_replay_fixup.
@@ -6123,7 +6174,8 @@ impl_run_checkers (logger *logger)
   auto_delete_vec <state_machine> checkers;
   make_checkers (checkers, logger);
 
-  register_known_functions (*eng.get_known_function_manager ());
+  register_known_functions (*eng.get_known_function_manager (),
+			    *eng.get_model_manager ());
 
   plugin_analyzer_init_impl data (&checkers,
 				  eng.get_known_function_manager (),
@@ -6153,6 +6205,9 @@ impl_run_checkers (logger *logger)
   /* Now process the worklist, exploring the <point, state> graph.  */
   eg.process_worklist ();
 
+  if (warn_analyzer_infinite_loop)
+    eg.detect_infinite_loops ();
+
   if (flag_dump_analyzer_exploded_graph)
     {
       auto_timevar tv (TV_ANALYZER_DUMP);
diff --git a/gcc/analyzer/exploded-graph.h b/gcc/analyzer/exploded-graph.h
index cb64c2a..45ee0d1 100644
--- a/gcc/analyzer/exploded-graph.h
+++ b/gcc/analyzer/exploded-graph.h
@@ -49,7 +49,9 @@ class impl_region_model_context : public region_model_context
 			     path_context *path_ctxt,
 
 			     const gimple *stmt,
-			     stmt_finder *stmt_finder = NULL);
+			     stmt_finder *stmt_finder = NULL,
+
+			     bool *out_could_have_done_work = nullptr);
 
   impl_region_model_context (program_state *state,
 			     const extrinsic_state &ext_state,
@@ -110,6 +112,10 @@ class impl_region_model_context : public region_model_context
   const gimple *get_stmt () const override { return m_stmt; }
   const exploded_graph *get_eg () const override { return m_eg; }
 
+  void maybe_did_work () override;
+  bool checking_for_infinite_loop_p () const override { return false; }
+  void on_unusable_in_infinite_loop () override {}
+
   exploded_graph *m_eg;
   log_user m_logger;
   exploded_node *m_enode_for_diag;
@@ -120,6 +126,7 @@ class impl_region_model_context : public region_model_context
   const extrinsic_state &m_ext_state;
   uncertainty_t *m_uncertainty;
   path_context *m_path_ctxt;
+  bool *m_out_could_have_done_work;
 };
 
 /* A <program_point, program_state> pair, used internally by
@@ -260,6 +267,7 @@ class exploded_node : public dnode<eg_traits>
 			 const gimple *stmt,
 			 program_state *state,
 			 uncertainty_t *uncertainty,
+			 bool *out_could_have_done_work,
 			 path_context *path_ctxt);
   void on_stmt_pre (exploded_graph &eg,
 		    const gimple *stmt,
@@ -373,7 +381,7 @@ class exploded_edge : public dedge<eg_traits>
 {
  public:
   exploded_edge (exploded_node *src, exploded_node *dest,
-		 const superedge *sedge,
+		 const superedge *sedge, bool could_do_work,
 		 std::unique_ptr<custom_edge_info> custom_info);
   void dump_dot (graphviz_out *gv, const dump_args_t &args)
     const final override;
@@ -389,8 +397,25 @@ class exploded_edge : public dedge<eg_traits>
      a signal is delivered to a signal-handler.  */
   std::unique_ptr<custom_edge_info> m_custom_info;
 
+  bool could_do_work_p () const { return m_could_do_work_p; }
+
 private:
   DISABLE_COPY_AND_ASSIGN (exploded_edge);
+
+  /* For -Wanalyzer-infinite-loop.
+     Set to true during processing if any of the activity along
+     this edge is "externally-visible work" (and thus ruling this
+     out as being part of an infinite loop.
+
+     For example, given:
+
+     while (1)
+       do_something ();
+
+     although it is an infinite loop, presumably the point of the
+     program is the loop body, and thus reporting this as an infinite
+     loop is likely to be unhelpful to the user.  */
+  bool m_could_do_work_p;
 };
 
 /* Extra data for an exploded_edge that represents dynamic call info ( calls
@@ -804,7 +829,7 @@ public:
 				     const program_state &state,
 				     exploded_node *enode_for_diag);
   exploded_edge *add_edge (exploded_node *src, exploded_node *dest,
-			   const superedge *sedge,
+			   const superedge *sedge, bool could_do_work,
 			   std::unique_ptr<custom_edge_info> custom = NULL);
 
   per_program_point_data *
@@ -856,6 +881,9 @@ public:
 
   void on_escaped_function (tree fndecl);
 
+  /* In infinite-loop.cc */
+  void detect_infinite_loops ();
+
   /* In infinite-recursion.cc */
   void detect_infinite_recursion (exploded_node *enode);
   exploded_node *find_previous_entry_to (function *top_of_stack_fun,
@@ -970,10 +998,15 @@ class feasibility_state
 public:
   feasibility_state (region_model_manager *manager,
 		     const supergraph &sg);
+  feasibility_state (const region_model &model,
+		     const supergraph &sg);
   feasibility_state (const feasibility_state &other);
 
+  feasibility_state &operator= (const feasibility_state &other);
+
   bool maybe_update_for_edge (logger *logger,
 			      const exploded_edge *eedge,
+			      region_model_context *ctxt,
 			      std::unique_ptr<rejected_constraint> *out_rc);
   void update_for_stmt (const gimple *stmt);
 
diff --git a/gcc/analyzer/infinite-loop.cc b/gcc/analyzer/infinite-loop.cc
new file mode 100644
index 0000000..771d698
--- /dev/null
+++ b/gcc/analyzer/infinite-loop.cc
@@ -0,0 +1,565 @@
+/* Detection of infinite loops.
+   Copyright (C) 2022-2023 Free Software Foundation, Inc.
+   Contributed by David Malcolm <dmalcolm@redhat.com>.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 3, or (at your option)
+any later version.
+
+GCC is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+#include "config.h"
+#define INCLUDE_MEMORY
+#define INCLUDE_VECTOR
+#include "system.h"
+#include "coretypes.h"
+#include "tree.h"
+#include "fold-const.h"
+#include "gcc-rich-location.h"
+#include "alloc-pool.h"
+#include "fibonacci_heap.h"
+#include "shortest-paths.h"
+#include "diagnostic-core.h"
+#include "diagnostic-event-id.h"
+#include "diagnostic-path.h"
+#include "diagnostic-metadata.h"
+#include "function.h"
+#include "pretty-print.h"
+#include "sbitmap.h"
+#include "bitmap.h"
+#include "tristate.h"
+#include "ordered-hash-map.h"
+#include "selftest.h"
+#include "json.h"
+#include "analyzer/analyzer.h"
+#include "analyzer/analyzer-logging.h"
+#include "analyzer/call-string.h"
+#include "analyzer/program-point.h"
+#include "analyzer/store.h"
+#include "analyzer/region-model.h"
+#include "analyzer/constraint-manager.h"
+#include "analyzer/sm.h"
+#include "analyzer/pending-diagnostic.h"
+#include "analyzer/diagnostic-manager.h"
+#include "cfg.h"
+#include "basic-block.h"
+#include "gimple.h"
+#include "gimple-iterator.h"
+#include "gimple-pretty-print.h"
+#include "cgraph.h"
+#include "digraph.h"
+#include "analyzer/supergraph.h"
+#include "analyzer/program-state.h"
+#include "analyzer/exploded-graph.h"
+#include "analyzer/checker-path.h"
+#include "analyzer/feasible-graph.h"
+#include "make-unique.h"
+
+/* A bundle of data characterizing a particular infinite loop
+   identified within the exploded graph.  */
+
+struct infinite_loop
+{
+  infinite_loop (const exploded_node &enode,
+		location_t loc,
+		std::vector<const exploded_edge *> eedges,
+		logger *logger)
+  : m_enode (enode),
+    m_loc (loc),
+    m_eedge_vec (eedges)
+  {
+    LOG_SCOPE (logger);
+    if (logger)
+      {
+	logger->start_log_line ();
+	logger->log_partial ("infinite loop: EN: %i", m_enode.m_index);
+	for (auto eedge : m_eedge_vec)
+	  {
+	    logger->log_partial (" ->");
+	    if (const superedge *sedge = eedge->m_sedge)
+	      {
+		sedge->dump_label_to_pp (logger->get_printer (), false);
+	      }
+	    logger->log_partial (" EN: %i", eedge->m_dest->m_index);
+	  }
+	logger->end_log_line ();
+      }
+  }
+
+  bool
+  operator== (const infinite_loop &other) const
+  {
+    /* Compare underlying supernode, rather than enodes, so that
+       we don't get duplicates in functions that are called from
+       elsewhere.  */
+    return (m_enode.get_supernode () == other.m_enode.get_supernode ()
+	    && m_loc == other.m_loc);
+  }
+
+  const exploded_node &m_enode;
+  location_t m_loc;
+  std::vector<const exploded_edge *> m_eedge_vec;
+};
+
+/* A custom subclass of start_cfg_edge_event that rewords the
+   message to indicate that the CFG edge is *always* taken on
+   subsequent iterations, assuming it's been taken once. */
+
+class perpetual_start_cfg_edge_event : public start_cfg_edge_event
+{
+public:
+  perpetual_start_cfg_edge_event (const exploded_edge &eedge,
+				  const event_loc_info &loc_info)
+  : start_cfg_edge_event (eedge, loc_info)
+  {
+  }
+
+  label_text get_desc (bool can_colorize) const final override
+  {
+    bool user_facing = !flag_analyzer_verbose_edges;
+    label_text edge_desc (m_sedge->get_description (user_facing));
+    if (user_facing)
+      {
+	if (edge_desc.get () && strlen (edge_desc.get ()) > 0)
+	  {
+	    label_text cond_desc = maybe_describe_condition (can_colorize);
+	    label_text result;
+	    if (cond_desc.get ())
+	      return make_label_text
+		(can_colorize,
+		 "%s: always following %qs branch...",
+		 cond_desc.get (), edge_desc.get ());
+	    else
+	      return make_label_text
+		(can_colorize,
+		 "if it ever follows %qs branch, it will always do so...",
+		 edge_desc.get ());
+	  }
+      }
+    return start_cfg_edge_event::get_desc (can_colorize);
+  }
+};
+
+/* A subclass of pending_diagnostic for complaining about suspected
+   infinite loops.  */
+
+class infinite_loop_diagnostic
+: public pending_diagnostic_subclass<infinite_loop_diagnostic>
+{
+public:
+  infinite_loop_diagnostic (std::unique_ptr<infinite_loop> inf_loop)
+    : m_inf_loop (std::move (inf_loop))
+  {
+    gcc_assert (m_inf_loop != nullptr);
+  }
+
+  const char *get_kind () const final override
+  {
+    return "infinite_loop_diagnostic";
+  }
+
+  bool operator== (const infinite_loop_diagnostic &other) const
+  {
+    return *m_inf_loop == *other.m_inf_loop;
+  }
+
+  int get_controlling_option () const final override
+  {
+    return OPT_Wanalyzer_infinite_loop;
+  }
+
+  bool emit (rich_location *rich_loc, logger *) final override
+  {
+    /* "CWE-835: Loop with Unreachable Exit Condition ('Infinite Loop')". */
+    diagnostic_metadata m;
+    m.add_cwe (835);
+    return warning_meta (rich_loc, m, get_controlling_option (),
+			 "infinite loop");
+  }
+
+  bool maybe_add_custom_events_for_superedge (const exploded_edge &,
+					      checker_path *)
+    final override
+  {
+    /* Don't add any regular events; instead we add them after pruning as
+       part of the "final" warning.  */
+    return true;
+  }
+
+  label_text describe_final_event (const evdesc::final_event &ev) final override
+  {
+    return ev.formatted_print ("infinite loop here");
+  }
+
+  /* Customize the location where the warning_event appears.  */
+  void add_final_event (const state_machine *,
+			const exploded_node *enode,
+			const gimple *,
+			tree,
+			state_machine::state_t,
+			checker_path *emission_path) final override
+  {
+    emission_path->add_event
+      (make_unique<warning_event>
+       (event_loc_info (m_inf_loop->m_loc,
+			enode->get_function ()->decl,
+			enode->get_stack_depth ()),
+	enode,
+	NULL, NULL, NULL));
+
+    logger *logger = emission_path->get_logger ();
+
+    /* EMISSION_PATH has the path to the entry of the infinite loop.
+       Add extra edges showing the loop itself.  */
+    for (auto eedge : m_inf_loop->m_eedge_vec)
+      {
+	if (logger)
+	  logger->log ("EN: %i -> EN: %i",
+		       eedge->m_src->m_index,
+		       eedge->m_dest->m_index);
+	if (!eedge->m_sedge)
+	  continue;
+
+	const cfg_superedge *cfg_sedge
+	  = eedge->m_sedge->dyn_cast_cfg_superedge ();
+	if (!cfg_sedge)
+	  continue;
+
+	const exploded_node *src_node = eedge->m_src;
+	const program_point &src_point = src_node->get_point ();
+	const exploded_node *dst_node = eedge->m_dest;
+	const program_point &dst_point = dst_node->get_point ();
+	const int src_stack_depth = src_point.get_stack_depth ();
+	const int dst_stack_depth = dst_point.get_stack_depth ();
+	const gimple *last_stmt = src_point.get_supernode ()->get_last_stmt ();
+
+	event_loc_info loc_info_from
+	  (last_stmt ? last_stmt->location : cfg_sedge->get_goto_locus (),
+	   src_point.get_fndecl (),
+	   src_stack_depth);
+	event_loc_info loc_info_to
+	  (dst_point.get_supernode ()->get_start_location (),
+	   dst_point.get_fndecl (),
+	   dst_stack_depth);
+
+	if (const switch_cfg_superedge *switch_cfg_sedge
+	      = cfg_sedge->dyn_cast_switch_cfg_superedge ())
+	  {
+	    if (switch_cfg_sedge->implicitly_created_default_p ())
+	      {
+		emission_path->add_event
+		  (make_unique<perpetual_start_cfg_edge_event> (*eedge,
+								loc_info_from));
+		emission_path->add_event
+		  (make_unique<end_cfg_edge_event>
+		   (*eedge,
+		    loc_info_to));
+	      }
+	  }
+
+	if (cfg_sedge->true_value_p ())
+	  {
+	    emission_path->add_event
+	      (make_unique<perpetual_start_cfg_edge_event> (*eedge,
+							    loc_info_from));
+	    emission_path->add_event
+	      (make_unique<end_cfg_edge_event>
+	       (*eedge,
+		loc_info_to));
+	  }
+	else if (cfg_sedge->false_value_p ())
+	  {
+	    emission_path->add_event
+	      (make_unique<perpetual_start_cfg_edge_event> (*eedge,
+							    loc_info_from));
+	    emission_path->add_event
+	      (make_unique<end_cfg_edge_event>
+	       (*eedge,
+		loc_info_to));
+	  }
+	else if (cfg_sedge->back_edge_p ())
+	  {
+	    emission_path->add_event
+	      (make_unique<precanned_custom_event>
+	       (loc_info_from, "looping back..."));
+	    emission_path->add_event
+	      (make_unique<end_cfg_edge_event>
+	       (*eedge,
+		loc_info_to));
+	  }
+      }
+  }
+
+private:
+  std::unique_ptr<infinite_loop> m_inf_loop;
+};
+
+/* If ENODE has an in-edge corresponding to a CFG backedge, return that
+   exploded in-edge.
+   Otherwise, return nullptr.  */
+
+static const exploded_edge *
+get_in_edge_back_edge (const exploded_node &enode)
+{
+  for (auto in_edge : enode.m_preds)
+    {
+      const superedge *sedge = in_edge->m_sedge;
+      if (!sedge)
+	continue;
+      const cfg_superedge *cfg_sedge = sedge->dyn_cast_cfg_superedge ();
+      if (!cfg_sedge)
+	continue;
+      if (cfg_sedge->back_edge_p ())
+	return in_edge;
+    }
+  return nullptr;
+}
+
+/* Subclass of region_model_context that rejects conditional branches that
+   aren't known for definite.  */
+
+class infinite_loop_checking_context : public noop_region_model_context
+{
+public:
+  infinite_loop_checking_context () : m_unusable (false) {}
+
+  bool checking_for_infinite_loop_p () const override { return true; }
+  void on_unusable_in_infinite_loop () override { m_unusable = true; }
+
+  bool unusable_p () const { return m_unusable; }
+
+private:
+  bool m_unusable;
+};
+
+/* Determine if an infinite loop starts at ENODE.
+   Return the loop if it is found, nullptr otherwise.
+
+   Look for cycles in the exploded graph in which:
+   - no externally visible work occurs
+   - no escape from the cycle
+   - the program state is "sufficiently concrete" at each step:
+     - no unknown activity could be occurring
+     - the worklist was fully drained for each enode in the cycle
+       i.e. every enode in the cycle is processed.  */
+
+static std::unique_ptr<infinite_loop>
+starts_infinite_loop_p (const exploded_node &enode,
+			const exploded_graph &eg,
+			logger *logger)
+{
+  LOG_FUNC_1 (logger, "considering EN: %i", enode.m_index);
+
+  /* Only consider enodes that have a CFG back edge as an in-edge.  */
+  if (const exploded_edge *back_edge = get_in_edge_back_edge (enode))
+    {
+      if (logger)
+	logger->log ("got backedge from EN: %i",
+		     back_edge->m_src->m_index);
+    }
+  else
+    {
+      if (logger)
+	logger->log ("rejecting: no backedge in in-edges");
+      return nullptr;
+    }
+
+  /* Support for dumping an .infinite-loop.dot file visualizing the
+     traversal for this enode.  */
+  std::unique_ptr<feasible_graph> fg;
+  feasible_node *curr_fnode = nullptr;
+
+  if (flag_dump_analyzer_infinite_loop)
+    fg = ::make_unique<feasible_graph> ();
+
+  location_t first_loc = UNKNOWN_LOCATION;
+  const exploded_node *iter = &enode;
+  feasibility_state state (*enode.get_state ().m_region_model,
+			   eg.get_supergraph ());
+
+  if (fg)
+    curr_fnode = fg->add_node (&enode, state, 0);
+
+  hash_set<const exploded_node *> visited;
+  std::vector<const exploded_edge *> eedges;
+  while (1)
+    {
+      if (logger)
+	logger->log ("iter: EN: %i", iter->m_index);
+      /* Analysis bailed out before processing this node.  */
+      if (iter->get_status () == exploded_node::STATUS_WORKLIST)
+	{
+	  if (logger)
+	    logger->log ("rejecting: EN: %i is still in worklist",
+			 iter->m_index);
+	  return nullptr;
+	}
+      if (visited.contains (iter))
+	{
+	  /* We've looped back on ourselves.  ENODE is in the loop
+	     itself if ENODE is the first place we looped back,
+	     as opposed to being on a path to a loop.  */
+	  if (iter == &enode)
+	    {
+	      if (logger)
+		logger->log ("accepting: looped back to EN: %i",
+			     iter->m_index);
+	      if (fg)
+		{
+		  auto_timevar tv (TV_ANALYZER_DUMP);
+		  pretty_printer pp;
+		  pp_printf (&pp, "%s.en%i.infinite-loop.dot",
+			     dump_base_name, enode.m_index);
+		  char *filename = xstrdup (pp_formatted_text (&pp));
+		  feasible_graph::dump_args_t dump_args (eg);
+		  fg->dump_dot (filename, nullptr, dump_args);
+		  free (filename);
+		}
+	      return ::make_unique<infinite_loop> (enode,
+						  first_loc,
+						  eedges,
+						  logger);
+	    }
+	  else
+	    {
+	      if (logger)
+		logger->log ("rejecting: looped back to EN: %i, not to EN: %i",
+			     iter->m_index, enode.m_index);
+	      return nullptr;
+	    }
+	}
+      visited.add (iter);
+      if (first_loc == UNKNOWN_LOCATION)
+	{
+	  location_t enode_loc = iter->get_point ().get_location ();
+	  if (enode_loc != UNKNOWN_LOCATION)
+	    first_loc = enode_loc;
+	}
+
+      /* Find the out-edges that are feasible, given the
+	 constraints here.  */
+      typedef std::pair<feasibility_state, const exploded_edge *> pair_t;
+      std::vector<pair_t> succs;
+      for (auto out_edge : iter->m_succs)
+	{
+	  log_scope s (logger, "considering out-edge",
+		       "EN:%i -> EN:%i",
+		       out_edge->m_src->m_index,
+		       out_edge->m_dest->m_index);
+	  feasibility_state next_state (state);
+
+	  /* Use this context to require edge conditions to be known,
+	     rather than be merely "possible".  */
+	  infinite_loop_checking_context ctxt;
+	  if (next_state.maybe_update_for_edge (logger,
+						out_edge,
+						&ctxt,
+						nullptr))
+	    succs.push_back (pair_t (next_state, out_edge));
+	  if (ctxt.unusable_p ())
+	    {
+	      /* If we get here, then we have e.g. a gcond where
+		 the condition is UNKNOWN, or a condition
+		 based on a widening_svalue.  Reject such paths.  */
+	      if (logger)
+		logger->log ("rejecting: unusable");
+	      return nullptr;
+	    }
+	}
+
+      if (succs.size () != 1)
+	{
+	  if (logger)
+	    logger->log ("rejecting: %i feasible successors",
+			 (int)succs.size ());
+	  return nullptr;
+	}
+      const feasibility_state &next_state = succs[0].first;
+      const exploded_edge *out_eedge = succs[0].second;
+      if (out_eedge->could_do_work_p ())
+	{
+	  if (logger)
+	    logger->log ("rejecting: edge could do work");
+	  return nullptr;
+	}
+      if (fg)
+	{
+	  feasible_node *next_fnode = fg->add_node (out_eedge->m_dest,
+						    next_state,
+						    fg->m_nodes.length ());
+	  fg->add_edge (new feasible_edge (curr_fnode, next_fnode, out_eedge));
+	  curr_fnode = next_fnode;
+	}
+      state = next_state;
+      eedges.push_back (out_eedge);
+      if (first_loc == UNKNOWN_LOCATION)
+	{
+	  if (out_eedge->m_sedge)
+	    if (::edge cfg_edge = out_eedge->m_sedge->get_any_cfg_edge ())
+	      if (cfg_edge->goto_locus > BUILTINS_LOCATION)
+		first_loc = cfg_edge->goto_locus;
+	}
+      iter = out_eedge->m_dest;
+    }
+}
+
+/* Implementation of -Wanalyzer-infinite-loop.  */
+
+void
+exploded_graph::detect_infinite_loops ()
+{
+  LOG_FUNC (get_logger ());
+  auto_timevar tv (TV_ANALYZER_INFINITE_LOOPS);
+
+  /* Track all enodes we've warned for; both the loop entrypoints
+     and all the enodes within those loops.  */
+  hash_set<const exploded_node *> warned_for;
+
+  for (auto enode : m_nodes)
+    {
+      if (get_logger ())
+	get_logger ()->log ("visited: %i out of %i",
+			    (int)warned_for.elements (), m_nodes.length ());
+
+      /* Only warn about the first enode we encounter in each cycle.  */
+      if (warned_for.contains(enode))
+	continue;
+
+      if (std::unique_ptr<infinite_loop> inf_loop
+	    = starts_infinite_loop_p (*enode, *this, get_logger ()))
+	{
+	  const supernode *snode = enode->get_supernode ();
+
+	  if (get_logger ())
+	    get_logger ()->log ("EN: %i from starts_infinite_loop_p",
+				enode->m_index);
+
+	  for (auto iter : inf_loop->m_eedge_vec)
+	    warned_for.add (iter->m_src);
+	  gcc_assert (warned_for.contains(enode));
+
+	  if (inf_loop->m_loc == UNKNOWN_LOCATION)
+	    {
+	      if (get_logger ())
+		get_logger ()->log
+		  ("no location available for reporting infinite loop");
+	      continue;
+	    }
+
+	  pending_location ploc (enode, snode, inf_loop->m_loc);
+	  auto d
+	    = ::make_unique<infinite_loop_diagnostic> (std::move (inf_loop));
+	  get_diagnostic_manager ().add_diagnostic (ploc, std::move (d));
+	}
+    }
+}
diff --git a/gcc/analyzer/kf.cc b/gcc/analyzer/kf.cc
index 9295989..5d8e04d 100644
--- a/gcc/analyzer/kf.cc
+++ b/gcc/analyzer/kf.cc
@@ -40,6 +40,40 @@ along with GCC; see the file COPYING3.  If not see
 
 namespace ana {
 
+/* Abstract subclass for describing undefined behavior of an API.  */
+
+class undefined_function_behavior
+  : public pending_diagnostic_subclass<undefined_function_behavior>
+{
+public:
+  undefined_function_behavior (const call_details &cd)
+  : m_call_stmt (cd.get_call_stmt ()),
+    m_callee_fndecl (cd.get_fndecl_for_call ())
+  {
+    gcc_assert (m_call_stmt);
+    gcc_assert (m_callee_fndecl);
+  }
+
+  const char *get_kind () const final override
+  {
+    return "undefined_behavior";
+  }
+
+  bool operator== (const undefined_function_behavior &other) const
+  {
+    return (m_call_stmt == other.m_call_stmt
+	    && m_callee_fndecl == other.m_callee_fndecl);
+  }
+
+  bool terminate_path_p () const final override { return true; }
+
+  tree get_callee_fndecl () const { return m_callee_fndecl; }
+
+private:
+  const gimple *m_call_stmt;
+  tree m_callee_fndecl;
+};
+
 /* class pure_known_function_with_default_return : public known_function.  */
 
 void
@@ -1679,6 +1713,288 @@ kf_strstr::impl_call_post (const call_details &cd) const
     }
 }
 
+/* Handle calls to "strtok".
+   See e.g.
+     https://en.cppreference.com/w/c/string/byte/strtok
+     https://man7.org/linux/man-pages/man3/strtok.3.html  */
+
+class kf_strtok : public known_function
+{
+public:
+  class undefined_behavior : public undefined_function_behavior
+  {
+  public:
+    undefined_behavior (const call_details &cd)
+    : undefined_function_behavior (cd)
+    {
+    }
+    int get_controlling_option () const final override
+    {
+      return OPT_Wanalyzer_undefined_behavior_strtok;
+    }
+
+    bool emit (rich_location *rich_loc, logger *) final override
+    {
+      /* CWE-476: NULL Pointer Dereference.  */
+      diagnostic_metadata m;
+      m.add_cwe (476);
+      if (warning_meta
+	  (rich_loc, m, get_controlling_option (),
+	   "calling %qD for first time with NULL as argument 1"
+	   " has undefined behavior",
+	   get_callee_fndecl ()))
+	{
+	  inform (rich_loc->get_loc (),
+		  "some implementations of %qD may crash on such input",
+		  get_callee_fndecl ());
+	  return true;
+	}
+      return false;
+    }
+
+    label_text describe_final_event (const evdesc::final_event &ev)
+      final override
+    {
+      return ev.formatted_print
+	("calling %qD for first time with NULL as argument 1"
+	 " has undefined behavior",
+	 get_callee_fndecl ());
+    }
+  };
+
+  /* An outcome of a "strtok" call.
+     We have a four-way bifurcation of the analysis via the
+     4 combinations of two flags:
+     - m_nonnull_str covers whether the "str" param was null or non-null
+     - m_found covers whether the result is null or non-null
+   */
+  class strtok_call_info : public call_info
+  {
+  public:
+    strtok_call_info (const call_details &cd,
+		      const private_region &private_reg,
+		      bool nonnull_str,
+		      bool found)
+    : call_info (cd),
+      m_private_reg (private_reg),
+      m_nonnull_str (nonnull_str),
+      m_found (found)
+    {
+    }
+
+    label_text get_desc (bool can_colorize) const final override
+    {
+      if (m_nonnull_str)
+	{
+	  if (m_found)
+	    return make_label_text
+	      (can_colorize,
+	       "when %qE on non-NULL string returns non-NULL",
+	       get_fndecl ());
+	  else
+	    return make_label_text
+	      (can_colorize,
+	       "when %qE on non-NULL string returns NULL",
+	       get_fndecl ());
+	}
+      else
+	{
+	  if (m_found)
+	    return make_label_text
+	      (can_colorize,
+	       "when %qE with NULL string (using prior) returns non-NULL",
+	       get_fndecl ());
+	  else
+	    return make_label_text
+	      (can_colorize,
+	       "when %qE with NULL string (using prior) returns NULL",
+	       get_fndecl ());
+	}
+    }
+
+    bool update_model (region_model *model,
+		       const exploded_edge *,
+		       region_model_context *ctxt) const final override
+    {
+      region_model_manager *mgr = model->get_manager ();
+      const call_details cd (get_call_details (model, ctxt));
+      const svalue *str_sval = cd.get_arg_svalue (0);
+      /* const svalue *delim_sval = cd.get_arg_svalue (1); */
+
+      cd.check_for_null_terminated_string_arg (1);
+      /* We check that either arg 0 or the private region is null
+	 terminated below.  */
+
+      const svalue *null_ptr_sval
+	= mgr->get_or_create_null_ptr (cd.get_arg_type (0));;
+      if (!model->add_constraint (str_sval,
+				  m_nonnull_str ? NE_EXPR : EQ_EXPR,
+				  null_ptr_sval,
+				  cd.get_ctxt ()))
+	return false;
+
+      if (m_nonnull_str)
+	{
+	  /* Update internal buffer.  */
+	  model->set_value (&m_private_reg,
+			    mgr->get_or_create_unmergeable (str_sval),
+			    ctxt);
+	}
+      else
+	{
+	  /* Read from internal buffer.  */
+	  str_sval = model->get_store_value (&m_private_reg, ctxt);
+
+	  /* The initial value of the private region is NULL when we're
+	     on a path from main.  */
+	  if (const initial_svalue *initial_sval
+		= str_sval->dyn_cast_initial_svalue ())
+	    if (initial_sval->get_region () == &m_private_reg
+		&& model->called_from_main_p ())
+	      {
+		/* Implementations of strtok do not necessarily check for NULL
+		   here, and may crash; see PR analyzer/107573.
+		   Warn for this, if we were definitely passed NULL.  */
+		if (cd.get_arg_svalue (0)->all_zeroes_p ())
+		  {
+		    if (ctxt)
+		      ctxt->warn (::make_unique<undefined_behavior> (cd));
+		  }
+
+		/* Assume that "str" was actually non-null; terminate
+		   this path.  */
+		return false;
+	      }
+
+	  /* Now assume str_sval is non-null.  */
+	  if (!model->add_constraint (str_sval,
+				      NE_EXPR,
+				      null_ptr_sval,
+				      cd.get_ctxt ()))
+	    return false;
+	}
+
+      const region *buf_reg = model->deref_rvalue (str_sval, NULL_TREE, ctxt);
+      model->scan_for_null_terminator (buf_reg,
+				       NULL_TREE,
+				       nullptr,
+				       ctxt);
+
+      if (m_found)
+	{
+	  const region *str_reg
+	    = model->deref_rvalue (str_sval, cd.get_arg_tree (0),
+				   cd.get_ctxt ());
+	  /* We want to figure out the start and nul terminator
+	     for the token.
+	     For each, we want str_sval + OFFSET for some unknown OFFSET.
+	     Use a conjured_svalue to represent the offset,
+	     using the str_reg as the id of the conjured_svalue.  */
+	  const svalue *start_offset
+	    = mgr->get_or_create_conjured_svalue (size_type_node,
+						  cd.get_call_stmt (),
+						  str_reg,
+						  conjured_purge (model,
+								  ctxt),
+						  0);
+	  const svalue *nul_offset
+	    = mgr->get_or_create_conjured_svalue (size_type_node,
+						  cd.get_call_stmt (),
+						  str_reg,
+						  conjured_purge (model,
+								  ctxt),
+						  1);
+
+	  tree char_ptr_type = build_pointer_type (char_type_node);
+	  const svalue *result
+	    = mgr->get_or_create_binop (char_ptr_type, POINTER_PLUS_EXPR,
+					str_sval, start_offset);
+	  cd.maybe_set_lhs (result);
+
+	  /* nul_offset + 1; the offset to use for the next call.  */
+	  const svalue *next_offset
+	    = mgr->get_or_create_binop (size_type_node, PLUS_EXPR,
+					nul_offset,
+					mgr->get_or_create_int_cst
+					(char_type_node, 1));
+
+	  /* Write '\0' to str_sval[nul_offset].  */
+	  const svalue *ptr_to_term
+	    = mgr->get_or_create_binop (char_ptr_type, POINTER_PLUS_EXPR,
+					str_sval, nul_offset);
+	  const region *terminator_reg
+	    = model->deref_rvalue (ptr_to_term, NULL_TREE, cd.get_ctxt ());
+	  model->set_value (terminator_reg,
+			    mgr->get_or_create_unmergeable
+			    (mgr->get_or_create_int_cst (char_type_node,
+							 0)),
+			    cd.get_ctxt ());
+
+	  /* Update saved ptr to be at [nul_offset + 1].  */
+	  const svalue *ptr_to_next
+	    = mgr->get_or_create_binop (cd.get_lhs_type (), POINTER_PLUS_EXPR,
+					str_sval, next_offset);
+	  model->set_value (&m_private_reg, ptr_to_next, ctxt);
+	}
+      else
+	if (tree lhs_type = cd.get_lhs_type ())
+	  {
+	    const svalue *result
+	      = mgr->get_or_create_int_cst (lhs_type, 0);
+	    cd.maybe_set_lhs (result);
+	  }
+      return true;
+    }
+  private:
+    const private_region &m_private_reg;
+    bool m_nonnull_str;
+    bool m_found;
+  }; // class strtok_call_info
+
+  kf_strtok (region_model_manager &mgr)
+  : m_private_reg (mgr.alloc_symbol_id (),
+		   mgr.get_root_region (),
+		   get_region_type (),
+		   "strtok buffer")
+  {
+  }
+
+  bool matches_call_types_p (const call_details &cd) const final override
+  {
+    return (cd.num_args () == 2
+	    && POINTER_TYPE_P (cd.get_arg_type (0))
+	    && POINTER_TYPE_P (cd.get_arg_type (1)));
+  }
+
+  void impl_call_post (const call_details &cd) const final override
+  {
+    if (cd.get_ctxt ())
+      {
+	/* Four-way bifurcation, based on whether:
+	   - the str is non-null
+	   - the result is non-null
+	   Typically the str is either null or non-null at a particular site,
+	   so hopefully this will generally just lead to two out-edges.  */
+	cd.get_ctxt ()->bifurcate
+	  (make_unique<strtok_call_info> (cd, m_private_reg, false, false));
+	cd.get_ctxt ()->bifurcate
+	  (make_unique<strtok_call_info> (cd, m_private_reg, false, true));
+	cd.get_ctxt ()->bifurcate
+	  (make_unique<strtok_call_info> (cd, m_private_reg, true, false));
+	cd.get_ctxt ()->bifurcate
+	  (make_unique<strtok_call_info> (cd, m_private_reg, true, true));
+	cd.get_ctxt ()->terminate_path ();
+      }
+  }
+
+private:
+  static tree get_region_type ()
+  {
+    return build_pointer_type (char_type_node);
+  }
+  const private_region m_private_reg;
+};
+
 class kf_ubsan_bounds : public internal_known_function
 {
   /* Empty.  */
@@ -1823,7 +2139,8 @@ register_atomic_builtins (known_function_manager &kfm)
    analyzer (as opposed to plugins).  */
 
 void
-register_known_functions (known_function_manager &kfm)
+register_known_functions (known_function_manager &kfm,
+			  region_model_manager &rmm)
 {
   /* Debugging/test support functions, all  with a "__analyzer_" prefix.  */
   register_known_analyzer_functions (kfm);
@@ -1911,6 +2228,7 @@ register_known_functions (known_function_manager &kfm)
   {
     kfm.add ("fopen", make_unique<kf_fopen> ());
     kfm.add ("putenv", make_unique<kf_putenv> ());
+    kfm.add ("strtok", make_unique<kf_strtok> (rmm));
 
     register_known_fd_functions (kfm);
     register_known_file_functions (kfm);
diff --git a/gcc/analyzer/program-state.cc b/gcc/analyzer/program-state.cc
index 8dade4b..9bb81e6 100644
--- a/gcc/analyzer/program-state.cc
+++ b/gcc/analyzer/program-state.cc
@@ -1145,15 +1145,22 @@ program_state::on_edge (exploded_graph &eg,
 				  this,
 				  uncertainty, &path_ctxt,
 				  last_stmt);
+  std::unique_ptr<rejected_constraint> rc;
+  logger * const logger = eg.get_logger ();
   if (!m_region_model->maybe_update_for_edge (*succ,
 					      last_stmt,
-					      &ctxt, NULL))
+					      &ctxt,
+					      logger ? &rc : nullptr))
     {
-      logger * const logger = eg.get_logger ();
       if (logger)
-	logger->log ("edge to SN: %i is impossible"
-		     " due to region_model constraints",
-		     succ->m_dest->m_index);
+	{
+	  logger->start_log_line ();
+	  logger->log_partial ("edge to SN: %i is impossible"
+			       " due to region_model constraint: ",
+			       succ->m_dest->m_index);
+	  rc->dump_to_pp (logger->get_printer ());
+	  logger->end_log_line ();
+	}
       return false;
     }
   if (terminated)
diff --git a/gcc/analyzer/region-model-manager.cc b/gcc/analyzer/region-model-manager.cc
index 2224687..921edc5 100644
--- a/gcc/analyzer/region-model-manager.cc
+++ b/gcc/analyzer/region-model-manager.cc
@@ -1261,7 +1261,8 @@ conjured_purge::purge (const conjured_svalue *sval) const
 }
 
 /* Return the svalue * of type TYPE for the value conjured for ID_REG
-   at STMT, creating it if necessary.
+   at STMT (using IDX for any further disambiguation),
+   creating it if necessary.
    Use P to purge existing state from the svalue, for the case where a
    conjured_svalue would be reused along an execution path.  */
 
@@ -1269,9 +1270,10 @@ const svalue *
 region_model_manager::get_or_create_conjured_svalue (tree type,
 						     const gimple *stmt,
 						     const region *id_reg,
-						     const conjured_purge &p)
+						     const conjured_purge &p,
+						     unsigned idx)
 {
-  conjured_svalue::key_t key (type, stmt, id_reg);
+  conjured_svalue::key_t key (type, stmt, id_reg, idx);
   if (conjured_svalue **slot = m_conjured_values_map.get (key))
     {
       const conjured_svalue *sval = *slot;
@@ -1283,7 +1285,7 @@ region_model_manager::get_or_create_conjured_svalue (tree type,
       return sval;
     }
   conjured_svalue *conjured_sval
-    = new conjured_svalue (alloc_symbol_id (), type, stmt, id_reg);
+    = new conjured_svalue (alloc_symbol_id (), type, stmt, id_reg, idx);
   RETURN_UNKNOWN_IF_TOO_COMPLEX (conjured_sval);
   m_conjured_values_map.put (key, conjured_sval);
   return conjured_sval;
diff --git a/gcc/analyzer/region-model-manager.h b/gcc/analyzer/region-model-manager.h
index a528181..2ddd7de 100644
--- a/gcc/analyzer/region-model-manager.h
+++ b/gcc/analyzer/region-model-manager.h
@@ -79,7 +79,8 @@ public:
 					       const binding_map &map);
   const svalue *get_or_create_conjured_svalue (tree type, const gimple *stmt,
 					       const region *id_reg,
-					       const conjured_purge &p);
+					       const conjured_purge &p,
+					       unsigned idx = 0);
   const svalue *
   get_or_create_asm_output_svalue (tree type,
 				   const gasm *asm_stmt,
@@ -105,6 +106,7 @@ public:
   const svalue *create_unique_svalue (tree type);
 
   /* region consolidation.  */
+  const root_region *get_root_region () const { return &m_root_region; }
   const stack_region * get_stack_region () const { return &m_stack_region; }
   const heap_region *get_heap_region () const { return &m_heap_region; }
   const code_region *get_code_region () const { return &m_code_region; }
diff --git a/gcc/analyzer/region-model.cc b/gcc/analyzer/region-model.cc
index dc83440..420c103 100644
--- a/gcc/analyzer/region-model.cc
+++ b/gcc/analyzer/region-model.cc
@@ -1179,6 +1179,15 @@ region_model::on_assignment (const gassign *assign, region_model_context *ctxt)
 
   const region *lhs_reg = get_lvalue (lhs, ctxt);
 
+  /* Any writes other than to the stack are treated
+     as externally visible.  */
+  if (ctxt)
+    {
+      enum memory_space memspace = lhs_reg->get_memory_space ();
+      if (memspace != MEMSPACE_STACK)
+	ctxt->maybe_did_work ();
+    }
+
   /* Most assignments are handled by:
        set_value (lhs_reg, SVALUE, CTXT)
      for some SVALUE.  */
@@ -1277,6 +1286,8 @@ region_model::on_stmt_pre (const gimple *stmt,
       {
 	const gasm *asm_stmt = as_a <const gasm *> (stmt);
 	on_asm_stmt (asm_stmt, ctxt);
+	if (ctxt)
+	  ctxt->maybe_did_work ();
       }
       break;
 
@@ -1701,7 +1712,11 @@ region_model::on_call_post (const gcall *call,
     }
 
   if (unknown_side_effects)
-    handle_unrecognized_call (call, ctxt);
+    {
+      handle_unrecognized_call (call, ctxt);
+      if (ctxt)
+	ctxt->maybe_did_work ();
+    }
 }
 
 /* Purge state involving SVAL from this region_model, using CTXT
@@ -2236,6 +2251,7 @@ void
 region_model::handle_phi (const gphi *phi,
 			  tree lhs, tree rhs,
 			  const region_model &old_state,
+			  hash_set<const svalue *> &svals_changing_meaning,
 			  region_model_context *ctxt)
 {
   /* For now, don't bother tracking the .MEM SSA names.  */
@@ -2247,6 +2263,10 @@ region_model::handle_phi (const gphi *phi,
   const svalue *src_sval = old_state.get_rvalue (rhs, ctxt);
   const region *dst_reg = old_state.get_lvalue (lhs, ctxt);
 
+  const svalue *sval = old_state.get_rvalue (lhs, nullptr);
+  if (sval->get_kind () == SK_WIDENING)
+    svals_changing_meaning.add (sval);
+
   set_value (dst_reg, src_sval, ctxt);
 
   if (ctxt)
@@ -3864,8 +3884,10 @@ region_model::scan_for_null_terminator (const region *reg,
   byte_range bytes_to_read (src_byte_offset, 1);
   const svalue *sval = get_store_bytes (base_reg, bytes_to_read, ctxt);
   tree byte_expr
-    = get_tree_for_byte_offset (expr,
-				src_byte_offset - initial_src_byte_offset);
+    = (expr
+       ? get_tree_for_byte_offset (expr,
+				   src_byte_offset - initial_src_byte_offset)
+       : NULL_TREE);
   check_for_poison (sval, byte_expr, nullptr, ctxt);
   if (base_reg->can_have_initial_svalue_p ())
     {
@@ -4661,6 +4683,14 @@ region_model::add_constraint (tree lhs, enum tree_code op, tree rhs,
   return add_constraint (lhs_sval, op, rhs_sval, ctxt);
 }
 
+static bool
+unusable_in_infinite_loop_constraint_p (const svalue *sval)
+{
+  if (sval->get_kind () == SK_WIDENING)
+    return true;
+  return false;
+}
+
 /* Attempt to add the constraint "LHS OP RHS" to this region_model.
    If it is consistent with existing constraints, add it, and return true.
    Return false if it contradicts existing constraints.
@@ -4672,6 +4702,20 @@ region_model::add_constraint (const svalue *lhs,
 			      const svalue *rhs,
 			      region_model_context *ctxt)
 {
+  const bool checking_for_infinite_loop
+    = ctxt ? ctxt->checking_for_infinite_loop_p () : false;
+
+  if (checking_for_infinite_loop)
+    {
+      if (unusable_in_infinite_loop_constraint_p (lhs)
+	  || unusable_in_infinite_loop_constraint_p (rhs))
+	{
+	  gcc_assert (ctxt);
+	  ctxt->on_unusable_in_infinite_loop ();
+	  return false;
+	}
+    }
+
   tristate t_cond = eval_condition (lhs, op, rhs);
 
   /* If we already have the condition, do nothing.  */
@@ -4683,6 +4727,15 @@ region_model::add_constraint (const svalue *lhs,
   if (t_cond.is_false ())
     return false;
 
+  if (checking_for_infinite_loop)
+    {
+      /* Here, we don't have a definite true/false value, so bail out
+	 when checking for infinite loops.  */
+      gcc_assert (ctxt);
+      ctxt->on_unusable_in_infinite_loop ();
+      return false;
+    }
+
   bool out;
   if (add_constraints_from_binop (lhs, op, rhs, &out, ctxt))
     return out;
@@ -5026,6 +5079,7 @@ region_model::get_representative_path_var_1 (const region *reg,
     case RK_VAR_ARG:
     case RK_ERRNO:
     case RK_UNKNOWN:
+    case RK_PRIVATE:
       return path_var (NULL_TREE, 0);
     }
 }
@@ -5068,6 +5122,8 @@ region_model::update_for_phis (const supernode *snode,
      are effectively handled simultaneously.  */
   const region_model old_state (*this);
 
+  hash_set<const svalue *> svals_changing_meaning;
+
   for (gphi_iterator gpi = const_cast<supernode *>(snode)->start_phis ();
        !gsi_end_p (gpi); gsi_next (&gpi))
     {
@@ -5077,8 +5133,11 @@ region_model::update_for_phis (const supernode *snode,
       tree lhs = gimple_phi_result (phi);
 
       /* Update next_state based on phi and old_state.  */
-      handle_phi (phi, lhs, src, old_state, ctxt);
+      handle_phi (phi, lhs, src, old_state, svals_changing_meaning, ctxt);
     }
+
+  for (auto iter : svals_changing_meaning)
+    m_constraints->purge_state_involving (iter);
 }
 
 /* Attempt to update this model for taking EDGE (where the last statement
@@ -5246,6 +5305,9 @@ region_model::replay_call_summary (call_summary_replay &r,
 
   m_store.replay_call_summary (r, summary.m_store);
 
+  if (r.get_ctxt ())
+    r.get_ctxt ()->maybe_did_work ();
+
   if (!m_constraints->replay_call_summary (r, *summary.m_constraints))
     return false;
 
@@ -5807,6 +5869,9 @@ region_model::can_merge_with_p (const region_model &other_model,
 			      *other_model.m_constraints,
 			      out_model->m_constraints);
 
+  for (auto iter : m.m_svals_changing_meaning)
+    out_model->m_constraints->purge_state_involving (iter);
+
   return true;
 }
 
@@ -6658,6 +6723,14 @@ model_merger::mergeable_svalue_p (const svalue *sval) const
   return true;
 }
 
+/* Mark WIDENING_SVAL as changing meaning during the merge.  */
+
+void
+model_merger::on_widening_reuse (const widening_svalue *widening_sval)
+{
+  m_svals_changing_meaning.add (widening_sval);
+}
+
 } // namespace ana
 
 /* Dump RMODEL fully to stderr (i.e. without summarization).  */
@@ -8364,7 +8437,6 @@ test_iteration_1 ()
   tree int_0 = build_int_cst (integer_type_node, 0);
   tree int_1 = build_int_cst (integer_type_node, 1);
   tree int_256 = build_int_cst (integer_type_node, 256);
-  tree int_257 = build_int_cst (integer_type_node, 257);
   tree i = build_global_decl ("i", integer_type_node);
 
   test_region_model_context ctxt;
@@ -8426,8 +8498,6 @@ test_iteration_1 ()
   ASSERT_TRUE (model5.can_merge_with_p (model2, point, &model6));
   const svalue *merged_widening = model6.get_rvalue (i, &ctxt);
   ASSERT_EQ (merged_widening->get_kind (), SK_WIDENING);
-
-  ASSERT_CONDITION_TRUE (model6, i, LT_EXPR, int_257);
 }
 
 /* Verify that if we mark a pointer to a malloc-ed region as non-NULL,
diff --git a/gcc/analyzer/region-model.h b/gcc/analyzer/region-model.h
index 4d8480d..2e15924 100644
--- a/gcc/analyzer/region-model.h
+++ b/gcc/analyzer/region-model.h
@@ -328,6 +328,7 @@ class region_model
 
   void handle_phi (const gphi *phi, tree lhs, tree rhs,
 		   const region_model &old_state,
+		   hash_set<const svalue *> &svals_changing_meaning,
 		   region_model_context *ctxt);
 
   bool maybe_update_for_edge (const superedge &edge,
@@ -558,6 +559,8 @@ class region_model
 	callback (model, prev_model, retval, ctxt);
   }
 
+  bool called_from_main_p () const;
+
 private:
   const region *get_lvalue_1 (path_var pv, region_model_context *ctxt) const;
   const svalue *get_rvalue_1 (path_var pv, region_model_context *ctxt) const;
@@ -605,7 +608,6 @@ private:
 			   bool nonnull,
 			   region_model_context *ctxt);
 
-  bool called_from_main_p () const;
   const svalue *get_initial_value_for_global (const region *reg) const;
 
   const region * get_region_for_poisoned_expr (tree expr) const;
@@ -804,6 +806,11 @@ class region_model_context
   virtual const gimple *get_stmt () const = 0;
 
   virtual const exploded_graph *get_eg () const = 0;
+
+  /* Hooks for detecting infinite loops.  */
+  virtual void maybe_did_work () = 0;
+  virtual bool checking_for_infinite_loop_p () const = 0;
+  virtual void on_unusable_in_infinite_loop () = 0;
 };
 
 /* A "do nothing" subclass of region_model_context.  */
@@ -861,6 +868,9 @@ public:
 
   const gimple *get_stmt () const override { return NULL; }
   const exploded_graph *get_eg () const override { return NULL; }
+  void maybe_did_work () override {}
+  bool checking_for_infinite_loop_p () const override { return false; }
+  void on_unusable_in_infinite_loop () override {}
 };
 
 /* A subclass of region_model_context for determining if operations fail
@@ -1036,6 +1046,24 @@ class region_model_context_decorator : public region_model_context
 	return nullptr;
   }
 
+  void maybe_did_work () override
+  {
+    if (m_inner)
+      m_inner->maybe_did_work ();
+  }
+
+  bool checking_for_infinite_loop_p () const override
+  {
+    if (m_inner)
+      return m_inner->checking_for_infinite_loop_p ();
+    return false;
+  }
+  void on_unusable_in_infinite_loop () override
+  {
+    if (m_inner)
+      m_inner->on_unusable_in_infinite_loop ();
+  }
+
 protected:
   region_model_context_decorator (region_model_context *inner)
   : m_inner (inner)
@@ -1108,6 +1136,8 @@ struct model_merger
     return m_point.get_function_point ();
   }
 
+  void on_widening_reuse (const widening_svalue *widening_sval);
+
   const region_model *m_model_a;
   const region_model *m_model_b;
   const program_point &m_point;
@@ -1116,6 +1146,8 @@ struct model_merger
   const extrinsic_state *m_ext_state;
   const program_state *m_state_a;
   const program_state *m_state_b;
+
+  hash_set<const svalue *> m_svals_changing_meaning;
 };
 
 /* A record that can (optionally) be written out when
diff --git a/gcc/analyzer/region.cc b/gcc/analyzer/region.cc
index 730dab3..4feb972 100644
--- a/gcc/analyzer/region.cc
+++ b/gcc/analyzer/region.cc
@@ -514,6 +514,8 @@ region::get_memory_space () const
 	  return MEMSPACE_HEAP;
 	case RK_STRING:
 	  return MEMSPACE_READONLY_DATA;
+	case RK_PRIVATE:
+	  return MEMSPACE_PRIVATE;
 	}
       if (iter->get_kind () == RK_CAST)
 	iter = iter->dyn_cast_cast_region ()->get_original_region ();
@@ -543,6 +545,7 @@ region::can_have_initial_svalue_p () const
     case MEMSPACE_CODE:
     case MEMSPACE_GLOBALS:
     case MEMSPACE_READONLY_DATA:
+    case MEMSPACE_PRIVATE:
       /* Such regions have initial_svalues.  */
       return true;
 
@@ -2259,6 +2262,17 @@ errno_region::dump_to_pp (pretty_printer *pp, bool simple) const
     pp_string (pp, "errno_region()");
 }
 
+/* class private_region : public region.  */
+
+void
+private_region::dump_to_pp (pretty_printer *pp, bool simple) const
+{
+  if (simple)
+    pp_printf (pp, "PRIVATE_REG(%qs)", m_desc);
+  else
+    pp_printf (pp, "private_region(%qs)", m_desc);
+}
+
 /* class unknown_region : public region.  */
 
 /* Implementation of region::dump_to_pp vfunc for unknown_region.  */
diff --git a/gcc/analyzer/region.h b/gcc/analyzer/region.h
index 4724238..fee161c 100644
--- a/gcc/analyzer/region.h
+++ b/gcc/analyzer/region.h
@@ -35,7 +35,8 @@ enum memory_space
   MEMSPACE_STACK,
   MEMSPACE_HEAP,
   MEMSPACE_READONLY_DATA,
-  MEMSPACE_THREAD_LOCAL
+  MEMSPACE_THREAD_LOCAL,
+  MEMSPACE_PRIVATE
 };
 
 /* An enum for discriminating between the different concrete subclasses
@@ -65,6 +66,7 @@ enum region_kind
   RK_BIT_RANGE,
   RK_VAR_ARG,
   RK_ERRNO,
+  RK_PRIVATE,
   RK_UNKNOWN,
 };
 
@@ -108,6 +110,7 @@ enum region_kind
      var_arg_region (RK_VAR_ARG): a region for the N-th vararg within a
 				  frame_region for a variadic call
      errno_region (RK_ERRNO): a region for holding "errno"
+     private_region (RK_PRIVATE): a region for internal state of an API
      unknown_region (RK_UNKNOWN): for handling unimplemented tree codes.  */
 
 /* Abstract base class for representing ways of accessing chunks of memory.
@@ -1434,6 +1437,42 @@ is_a_helper <const errno_region *>::test (const region *reg)
 
 namespace ana {
 
+/* Similar to a decl region, but we don't have the decl.
+   For implementing e.g. static buffers of known_functions,
+   or other internal state of an API.
+
+   These are owned by known_function instances, rather than the
+   region_model_manager.  */
+
+class private_region : public region
+{
+public:
+  private_region (unsigned id, const region *parent, tree type,
+		  const char *desc)
+  : region (complexity (parent), id, parent, type),
+    m_desc (desc)
+  {}
+
+  enum region_kind get_kind () const final override { return RK_PRIVATE; }
+
+  void dump_to_pp (pretty_printer *pp, bool simple) const final override;
+
+private:
+  const char *m_desc;
+};
+
+} // namespace ana
+
+template <>
+template <>
+inline bool
+is_a_helper <const private_region *>::test (const region *reg)
+{
+  return reg->get_kind () == RK_PRIVATE;
+}
+
+namespace ana {
+
 /* An unknown region, for handling unimplemented tree codes.  */
 
 class unknown_region : public region
diff --git a/gcc/analyzer/sm-signal.cc b/gcc/analyzer/sm-signal.cc
index e3f9092..9ebcbdb 100644
--- a/gcc/analyzer/sm-signal.cc
+++ b/gcc/analyzer/sm-signal.cc
@@ -279,6 +279,7 @@ public:
 						       src_enode);
     if (dst_enode)
       eg->add_edge (src_enode, dst_enode, NULL, /*state_change (),*/
+		    true, /* assume does work  */
 		    make_unique<signal_delivery_edge_info_t> ());
   }
 
diff --git a/gcc/analyzer/sm-taint.cc b/gcc/analyzer/sm-taint.cc
index 09c1e93..dfd5f7f 100644
--- a/gcc/analyzer/sm-taint.cc
+++ b/gcc/analyzer/sm-taint.cc
@@ -1,4 +1,4 @@
-/* An experimental state machine, for tracking "taint": unsanitized uses
+/* A state machine for tracking "taint": unsanitized uses
    of data potentially under an attacker's control.
 
    Copyright (C) 2019-2023 Free Software Foundation, Inc.
diff --git a/gcc/analyzer/sm.cc b/gcc/analyzer/sm.cc
index 2b88430..c030c27 100644
--- a/gcc/analyzer/sm.cc
+++ b/gcc/analyzer/sm.cc
@@ -188,10 +188,7 @@ make_checkers (auto_delete_vec <state_machine> &out, logger *logger)
   out.safe_push (make_malloc_state_machine (logger));
   out.safe_push (make_fileptr_state_machine (logger));
   out.safe_push (make_fd_state_machine (logger));
-  /* The "taint" checker must be explicitly enabled (as it currently
-     leads to state explosions that stop the other checkers working).  */
-  if (flag_analyzer_checker)
-    out.safe_push (make_taint_state_machine (logger));
+  out.safe_push (make_taint_state_machine (logger));
   out.safe_push (make_sensitive_state_machine (logger));
   out.safe_push (make_signal_state_machine (logger));
   out.safe_push (make_va_list_state_machine (logger));
diff --git a/gcc/analyzer/store.cc b/gcc/analyzer/store.cc
index aeea693..6025085 100644
--- a/gcc/analyzer/store.cc
+++ b/gcc/analyzer/store.cc
@@ -3372,6 +3372,7 @@ store::replay_call_summary_cluster (call_summary_replay &r,
     case RK_HEAP_ALLOCATED:
     case RK_DECL:
     case RK_ERRNO:
+    case RK_PRIVATE:
       {
 	const region *caller_dest_reg
 	  = r.convert_region_from_summary (summary_base_reg);
diff --git a/gcc/analyzer/supergraph.cc b/gcc/analyzer/supergraph.cc
index 31707e7..52cb877 100644
--- a/gcc/analyzer/supergraph.cc
+++ b/gcc/analyzer/supergraph.cc
@@ -790,6 +790,13 @@ supernode::get_start_location () const
   if (return_p ())
     return m_fun->function_end_locus;
 
+  /* We have no locations for stmts.  If we have a single out-edge that's
+     a CFG edge, the goto_locus of that edge is a better location for this
+     than UNKNOWN_LOCATION.  */
+  if (m_succs.length () == 1)
+    if (const cfg_superedge *cfg_sedge = m_succs[0]->dyn_cast_cfg_superedge ())
+      return cfg_sedge->get_goto_locus ();
+
   return UNKNOWN_LOCATION;
 }
 
@@ -813,6 +820,12 @@ supernode::get_end_location () const
   if (return_p ())
     return m_fun->function_end_locus;
 
+  /* If we have a single out-edge that's a CFG edge, use the goto_locus of
+     that edge.  */
+  if (m_succs.length () == 1)
+    if (const cfg_superedge *cfg_sedge = m_succs[0]->dyn_cast_cfg_superedge ())
+      return cfg_sedge->get_goto_locus ();
+
   return UNKNOWN_LOCATION;
 }
 
@@ -1063,6 +1076,9 @@ cfg_superedge::dump_label_to_pp (pretty_printer *pp,
       pp_string (pp, ")");
     }
 
+  if (m_cfg_edge->goto_locus > BUILTINS_LOCATION)
+    pp_string (pp, " (has goto_locus)");
+
   /* Otherwise, no label.  */
 }
 
diff --git a/gcc/analyzer/supergraph.h b/gcc/analyzer/supergraph.h
index 27ebd13..0cafbb5 100644
--- a/gcc/analyzer/supergraph.h
+++ b/gcc/analyzer/supergraph.h
@@ -532,6 +532,8 @@ class cfg_superedge : public superedge
   size_t get_phi_arg_idx () const;
   tree get_phi_arg (const gphi *phi) const;
 
+  location_t get_goto_locus () const { return m_cfg_edge->goto_locus; }
+
  private:
   const ::edge m_cfg_edge;
 };
diff --git a/gcc/analyzer/svalue.cc b/gcc/analyzer/svalue.cc
index 35eb830..e5811bd 100644
--- a/gcc/analyzer/svalue.cc
+++ b/gcc/analyzer/svalue.cc
@@ -251,6 +251,7 @@ svalue::can_merge_p (const svalue *other,
 	   a descending chain of constraints.  */
 	if (other == widen_arg0)
 	  {
+	    merger->on_widening_reuse (widen_arg0);
 	    return widen_arg0;
 	  }
 
@@ -606,6 +607,12 @@ public:
       m_found = true;
   }
 
+  void visit_widening_svalue (const widening_svalue *candidate) final override
+  {
+    if (candidate == m_needle)
+      m_found = true;
+  }
+
   bool found_p () const { return m_found; }
 
 private:
@@ -620,7 +627,8 @@ svalue::involves_p (const svalue *other) const
 {
   /* Currently only implemented for these kinds.  */
   gcc_assert (other->get_kind () == SK_INITIAL
-	      || other->get_kind () == SK_CONJURED);
+	      || other->get_kind () == SK_CONJURED
+	      || other->get_kind () == SK_WIDENING);
 
   involvement_visitor v (other);
   accept (&v);
diff --git a/gcc/analyzer/svalue.h b/gcc/analyzer/svalue.h
index 263a0d7..9415e98 100644
--- a/gcc/analyzer/svalue.h
+++ b/gcc/analyzer/svalue.h
@@ -1360,8 +1360,8 @@ public:
   /* A support class for uniquifying instances of conjured_svalue.  */
   struct key_t
   {
-    key_t (tree type, const gimple *stmt, const region *id_reg)
-    : m_type (type), m_stmt (stmt), m_id_reg (id_reg)
+    key_t (tree type, const gimple *stmt, const region *id_reg, unsigned idx)
+    : m_type (type), m_stmt (stmt), m_id_reg (id_reg), m_idx (idx)
     {}
 
     hashval_t hash () const
@@ -1377,7 +1377,8 @@ public:
     {
       return (m_type == other.m_type
 	      && m_stmt == other.m_stmt
-	      && m_id_reg == other.m_id_reg);
+	      && m_id_reg == other.m_id_reg
+	      && m_idx == other.m_idx);
     }
 
     /* Use m_stmt to mark empty/deleted, as m_type can be NULL for
@@ -1393,12 +1394,13 @@ public:
     tree m_type;
     const gimple *m_stmt;
     const region *m_id_reg;
+    unsigned m_idx;
   };
 
   conjured_svalue (symbol::id_t id, tree type, const gimple *stmt,
-		   const region *id_reg)
+		   const region *id_reg, unsigned idx)
   : svalue (complexity (id_reg), id, type),
-    m_stmt (stmt), m_id_reg (id_reg)
+    m_stmt (stmt), m_id_reg (id_reg), m_idx (idx)
   {
     gcc_assert (m_stmt != NULL);
   }
@@ -1419,6 +1421,7 @@ public:
  private:
   const gimple *m_stmt;
   const region *m_id_reg;
+  unsigned m_idx;
 };
 
 } // namespace ana
diff --git a/gcc/builtins.cc b/gcc/builtins.cc
index cb90bd0..5ece0d2 100644
--- a/gcc/builtins.cc
+++ b/gcc/builtins.cc
@@ -9573,6 +9573,271 @@ fold_builtin_arith_overflow (location_t loc, enum built_in_function fcode,
   return build2_loc (loc, COMPOUND_EXPR, boolean_type_node, store, ovfres);
 }
 
+/* Fold __builtin_{clz,ctz,clrsb,ffs,parity,popcount}g into corresponding
+   internal function.  */
+
+static tree
+fold_builtin_bit_query (location_t loc, enum built_in_function fcode,
+			tree arg0, tree arg1)
+{
+  enum internal_fn ifn;
+  enum built_in_function fcodei, fcodel, fcodell;
+  tree arg0_type = TREE_TYPE (arg0);
+  tree cast_type = NULL_TREE;
+  int addend = 0;
+
+  switch (fcode)
+    {
+    case BUILT_IN_CLZG:
+      if (arg1 && TREE_CODE (arg1) != INTEGER_CST)
+	return NULL_TREE;
+      ifn = IFN_CLZ;
+      fcodei = BUILT_IN_CLZ;
+      fcodel = BUILT_IN_CLZL;
+      fcodell = BUILT_IN_CLZLL;
+      break;
+    case BUILT_IN_CTZG:
+      if (arg1 && TREE_CODE (arg1) != INTEGER_CST)
+	return NULL_TREE;
+      ifn = IFN_CTZ;
+      fcodei = BUILT_IN_CTZ;
+      fcodel = BUILT_IN_CTZL;
+      fcodell = BUILT_IN_CTZLL;
+      break;
+    case BUILT_IN_CLRSBG:
+      ifn = IFN_CLRSB;
+      fcodei = BUILT_IN_CLRSB;
+      fcodel = BUILT_IN_CLRSBL;
+      fcodell = BUILT_IN_CLRSBLL;
+      break;
+    case BUILT_IN_FFSG:
+      ifn = IFN_FFS;
+      fcodei = BUILT_IN_FFS;
+      fcodel = BUILT_IN_FFSL;
+      fcodell = BUILT_IN_FFSLL;
+      break;
+    case BUILT_IN_PARITYG:
+      ifn = IFN_PARITY;
+      fcodei = BUILT_IN_PARITY;
+      fcodel = BUILT_IN_PARITYL;
+      fcodell = BUILT_IN_PARITYLL;
+      break;
+    case BUILT_IN_POPCOUNTG:
+      ifn = IFN_POPCOUNT;
+      fcodei = BUILT_IN_POPCOUNT;
+      fcodel = BUILT_IN_POPCOUNTL;
+      fcodell = BUILT_IN_POPCOUNTLL;
+      break;
+    default:
+      gcc_unreachable ();
+    }
+
+  if (TYPE_PRECISION (arg0_type)
+      <= TYPE_PRECISION (long_long_unsigned_type_node))
+    {
+      if (TYPE_PRECISION (arg0_type) <= TYPE_PRECISION (unsigned_type_node))
+
+	cast_type = (TYPE_UNSIGNED (arg0_type)
+		     ? unsigned_type_node : integer_type_node);
+      else if (TYPE_PRECISION (arg0_type)
+	       <= TYPE_PRECISION (long_unsigned_type_node))
+	{
+	  cast_type = (TYPE_UNSIGNED (arg0_type)
+		       ? long_unsigned_type_node : long_integer_type_node);
+	  fcodei = fcodel;
+	}
+      else
+	{
+	  cast_type = (TYPE_UNSIGNED (arg0_type)
+		       ? long_long_unsigned_type_node
+		       : long_long_integer_type_node);
+	  fcodei = fcodell;
+	}
+    }
+  else if (TYPE_PRECISION (arg0_type) <= MAX_FIXED_MODE_SIZE)
+    {
+      cast_type
+	= build_nonstandard_integer_type (MAX_FIXED_MODE_SIZE,
+					  TYPE_UNSIGNED (arg0_type));
+      gcc_assert (TYPE_PRECISION (cast_type)
+		  == 2 * TYPE_PRECISION (long_long_unsigned_type_node));
+      fcodei = END_BUILTINS;
+    }
+  else
+    fcodei = END_BUILTINS;
+  if (cast_type)
+    {
+      switch (fcode)
+	{
+	case BUILT_IN_CLZG:
+	case BUILT_IN_CLRSBG:
+	  addend = TYPE_PRECISION (arg0_type) - TYPE_PRECISION (cast_type);
+	  break;
+	default:
+	  break;
+	}
+      arg0 = fold_convert (cast_type, arg0);
+      arg0_type = cast_type;
+    }
+
+  if (arg1)
+    arg1 = fold_convert (integer_type_node, arg1);
+
+  tree arg2 = arg1;
+  if (fcode == BUILT_IN_CLZG && addend)
+    {
+      if (arg1)
+	arg0 = save_expr (arg0);
+      arg2 = NULL_TREE;
+    }
+  tree call = NULL_TREE, tem;
+  if (TYPE_PRECISION (arg0_type) == MAX_FIXED_MODE_SIZE
+      && (TYPE_PRECISION (arg0_type)
+	  == 2 * TYPE_PRECISION (long_long_unsigned_type_node)))
+    {
+      /* __int128 expansions using up to 2 long long builtins.  */
+      arg0 = save_expr (arg0);
+      tree type = (TYPE_UNSIGNED (arg0_type)
+		   ? long_long_unsigned_type_node
+		   : long_long_integer_type_node);
+      tree hi = fold_build2 (RSHIFT_EXPR, arg0_type, arg0,
+			     build_int_cst (integer_type_node,
+					    MAX_FIXED_MODE_SIZE / 2));
+      hi = fold_convert (type, hi);
+      tree lo = fold_convert (type, arg0);
+      switch (fcode)
+	{
+	case BUILT_IN_CLZG:
+	  call = fold_builtin_bit_query (loc, fcode, lo, NULL_TREE);
+	  call = fold_build2 (PLUS_EXPR, integer_type_node, call,
+			      build_int_cst (integer_type_node,
+					     MAX_FIXED_MODE_SIZE / 2));
+	  if (arg2)
+	    call = fold_build3 (COND_EXPR, integer_type_node,
+				fold_build2 (NE_EXPR, boolean_type_node,
+					     lo, build_zero_cst (type)),
+				call, arg2);
+	  call = fold_build3 (COND_EXPR, integer_type_node,
+			      fold_build2 (NE_EXPR, boolean_type_node,
+					   hi, build_zero_cst (type)),
+			      fold_builtin_bit_query (loc, fcode, hi,
+						      NULL_TREE),
+			      call);
+	  break;
+	case BUILT_IN_CTZG:
+	  call = fold_builtin_bit_query (loc, fcode, hi, NULL_TREE);
+	  call = fold_build2 (PLUS_EXPR, integer_type_node, call,
+			      build_int_cst (integer_type_node,
+					     MAX_FIXED_MODE_SIZE / 2));
+	  if (arg2)
+	    call = fold_build3 (COND_EXPR, integer_type_node,
+				fold_build2 (NE_EXPR, boolean_type_node,
+					     hi, build_zero_cst (type)),
+				call, arg2);
+	  call = fold_build3 (COND_EXPR, integer_type_node,
+			      fold_build2 (NE_EXPR, boolean_type_node,
+					   lo, build_zero_cst (type)),
+			      fold_builtin_bit_query (loc, fcode, lo,
+						      NULL_TREE),
+			      call);
+	  break;
+	case BUILT_IN_CLRSBG:
+	  tem = fold_builtin_bit_query (loc, fcode, lo, NULL_TREE);
+	  tem = fold_build2 (PLUS_EXPR, integer_type_node, tem,
+			     build_int_cst (integer_type_node,
+					    MAX_FIXED_MODE_SIZE / 2));
+	  tem = fold_build3 (COND_EXPR, integer_type_node,
+			     fold_build2 (LT_EXPR, boolean_type_node,
+					  fold_build2 (BIT_XOR_EXPR, type,
+						       lo, hi),
+					  build_zero_cst (type)),
+			     build_int_cst (integer_type_node,
+					    MAX_FIXED_MODE_SIZE / 2 - 1),
+			     tem);
+	  call = fold_builtin_bit_query (loc, fcode, hi, NULL_TREE);
+	  call = save_expr (call);
+	  call = fold_build3 (COND_EXPR, integer_type_node,
+			      fold_build2 (NE_EXPR, boolean_type_node,
+					   call,
+					   build_int_cst (integer_type_node,
+							  MAX_FIXED_MODE_SIZE
+							  / 2 - 1)),
+			      call, tem);
+	  break;
+	case BUILT_IN_FFSG:
+	  call = fold_builtin_bit_query (loc, fcode, hi, NULL_TREE);
+	  call = fold_build2 (PLUS_EXPR, integer_type_node, call,
+			      build_int_cst (integer_type_node,
+					     MAX_FIXED_MODE_SIZE / 2));
+	  call = fold_build3 (COND_EXPR, integer_type_node,
+			      fold_build2 (NE_EXPR, boolean_type_node,
+					   hi, build_zero_cst (type)),
+			      call, integer_zero_node);
+	  call = fold_build3 (COND_EXPR, integer_type_node,
+			      fold_build2 (NE_EXPR, boolean_type_node,
+					   lo, build_zero_cst (type)),
+			      fold_builtin_bit_query (loc, fcode, lo,
+						      NULL_TREE),
+			      call);
+	  break;
+	case BUILT_IN_PARITYG:
+	  call = fold_builtin_bit_query (loc, fcode,
+					 fold_build2 (BIT_XOR_EXPR, type,
+						      lo, hi), NULL_TREE);
+	  break;
+	case BUILT_IN_POPCOUNTG:
+	  call = fold_build2 (PLUS_EXPR, integer_type_node,
+			      fold_builtin_bit_query (loc, fcode, hi,
+						      NULL_TREE),
+			      fold_builtin_bit_query (loc, fcode, lo,
+						      NULL_TREE));
+	  break;
+	default:
+	  gcc_unreachable ();
+	}
+    }
+  else
+    {
+      /* Only keep second argument to IFN_CLZ/IFN_CTZ if it is the
+	 value defined at zero during GIMPLE, or for large/huge _BitInt
+	 (which are then lowered during bitint lowering).  */
+      if (arg2 && TREE_CODE (TREE_TYPE (arg0)) != BITINT_TYPE)
+	{
+	  int val;
+	  if (fcode == BUILT_IN_CLZG)
+	    {
+	      if (CLZ_DEFINED_VALUE_AT_ZERO (SCALAR_TYPE_MODE (arg0_type),
+					     val) != 2
+		  || wi::to_widest (arg2) != val)
+		arg2 = NULL_TREE;
+	    }
+	  else if (CTZ_DEFINED_VALUE_AT_ZERO (SCALAR_TYPE_MODE (arg0_type),
+					      val) != 2
+		   || wi::to_widest (arg2) != val)
+	    arg2 = NULL_TREE;
+	  if (!direct_internal_fn_supported_p (ifn, arg0_type,
+					       OPTIMIZE_FOR_BOTH))
+	    arg2 = NULL_TREE;
+	}
+      if (fcodei == END_BUILTINS || arg2)
+	call = build_call_expr_internal_loc (loc, ifn, integer_type_node,
+					     arg2 ? 2 : 1, arg0, arg2);
+      else
+	call = build_call_expr_loc (loc, builtin_decl_explicit (fcodei), 1,
+				    arg0);
+    }
+  if (addend)
+    call = fold_build2 (PLUS_EXPR, integer_type_node, call,
+			build_int_cst (integer_type_node, addend));
+  if (arg1 && arg2 == NULL_TREE)
+    call = fold_build3 (COND_EXPR, integer_type_node,
+			fold_build2 (NE_EXPR, boolean_type_node,
+				     arg0, build_zero_cst (arg0_type)),
+			call, arg1);
+
+  return call;
+}
+
 /* Fold __builtin_{add,sub}c{,l,ll} into pair of internal functions
    that return both result of arithmetics and overflowed boolean
    flag in a complex integer result.  */
@@ -9824,6 +10089,14 @@ fold_builtin_1 (location_t loc, tree expr, tree fndecl, tree arg0)
 	return build_empty_stmt (loc);
       break;
 
+    case BUILT_IN_CLZG:
+    case BUILT_IN_CTZG:
+    case BUILT_IN_CLRSBG:
+    case BUILT_IN_FFSG:
+    case BUILT_IN_PARITYG:
+    case BUILT_IN_POPCOUNTG:
+      return fold_builtin_bit_query (loc, fcode, arg0, NULL_TREE);
+
     default:
       break;
     }
@@ -9913,6 +10186,10 @@ fold_builtin_2 (location_t loc, tree expr, tree fndecl, tree arg0, tree arg1)
     case BUILT_IN_ATOMIC_IS_LOCK_FREE:
       return fold_builtin_atomic_is_lock_free (arg0, arg1);
 
+    case BUILT_IN_CLZG:
+    case BUILT_IN_CTZG:
+      return fold_builtin_bit_query (loc, fcode, arg0, arg1);
+
     default:
       break;
     }
diff --git a/gcc/builtins.def b/gcc/builtins.def
index a6fdb22..33e6cad 100644
--- a/gcc/builtins.def
+++ b/gcc/builtins.def
@@ -962,15 +962,18 @@ DEF_GCC_BUILTIN        (BUILT_IN_CLZ, "clz", BT_FN_INT_UINT, ATTR_CONST_NOTHROW_
 DEF_GCC_BUILTIN        (BUILT_IN_CLZIMAX, "clzimax", BT_FN_INT_UINTMAX, ATTR_CONST_NOTHROW_LEAF_LIST)
 DEF_GCC_BUILTIN        (BUILT_IN_CLZL, "clzl", BT_FN_INT_ULONG, ATTR_CONST_NOTHROW_LEAF_LIST)
 DEF_GCC_BUILTIN        (BUILT_IN_CLZLL, "clzll", BT_FN_INT_ULONGLONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN        (BUILT_IN_CLZG, "clzg", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
 DEF_GCC_BUILTIN        (BUILT_IN_CONSTANT_P, "constant_p", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_LEAF_LIST)
 DEF_GCC_BUILTIN        (BUILT_IN_CTZ, "ctz", BT_FN_INT_UINT, ATTR_CONST_NOTHROW_LEAF_LIST)
 DEF_GCC_BUILTIN        (BUILT_IN_CTZIMAX, "ctzimax", BT_FN_INT_UINTMAX, ATTR_CONST_NOTHROW_LEAF_LIST)
 DEF_GCC_BUILTIN        (BUILT_IN_CTZL, "ctzl", BT_FN_INT_ULONG, ATTR_CONST_NOTHROW_LEAF_LIST)
 DEF_GCC_BUILTIN        (BUILT_IN_CTZLL, "ctzll", BT_FN_INT_ULONGLONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN        (BUILT_IN_CTZG, "ctzg", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
 DEF_GCC_BUILTIN        (BUILT_IN_CLRSB, "clrsb", BT_FN_INT_INT, ATTR_CONST_NOTHROW_LEAF_LIST)
 DEF_GCC_BUILTIN        (BUILT_IN_CLRSBIMAX, "clrsbimax", BT_FN_INT_INTMAX, ATTR_CONST_NOTHROW_LEAF_LIST)
 DEF_GCC_BUILTIN        (BUILT_IN_CLRSBL, "clrsbl", BT_FN_INT_LONG, ATTR_CONST_NOTHROW_LEAF_LIST)
 DEF_GCC_BUILTIN        (BUILT_IN_CLRSBLL, "clrsbll", BT_FN_INT_LONGLONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN        (BUILT_IN_CLRSBG, "clrsbg", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
 DEF_EXT_LIB_BUILTIN    (BUILT_IN_DCGETTEXT, "dcgettext", BT_FN_STRING_CONST_STRING_CONST_STRING_INT, ATTR_FORMAT_ARG_2)
 DEF_EXT_LIB_BUILTIN    (BUILT_IN_DGETTEXT, "dgettext", BT_FN_STRING_CONST_STRING_CONST_STRING, ATTR_FORMAT_ARG_2)
 DEF_GCC_BUILTIN        (BUILT_IN_DWARF_CFA, "dwarf_cfa", BT_FN_PTR, ATTR_NULL)
@@ -993,6 +996,7 @@ DEF_EXT_LIB_BUILTIN    (BUILT_IN_FFS, "ffs", BT_FN_INT_INT, ATTR_CONST_NOTHROW_L
 DEF_EXT_LIB_BUILTIN    (BUILT_IN_FFSIMAX, "ffsimax", BT_FN_INT_INTMAX, ATTR_CONST_NOTHROW_LEAF_LIST)
 DEF_EXT_LIB_BUILTIN    (BUILT_IN_FFSL, "ffsl", BT_FN_INT_LONG, ATTR_CONST_NOTHROW_LEAF_LIST)
 DEF_EXT_LIB_BUILTIN    (BUILT_IN_FFSLL, "ffsll", BT_FN_INT_LONGLONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN        (BUILT_IN_FFSG, "ffsg", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
 DEF_EXT_LIB_BUILTIN        (BUILT_IN_FORK, "fork", BT_FN_PID, ATTR_NOTHROW_LIST)
 DEF_GCC_BUILTIN        (BUILT_IN_FRAME_ADDRESS, "frame_address", BT_FN_PTR_UINT, ATTR_NULL)
 /* [trans-mem]: Adjust BUILT_IN_TM_FREE if BUILT_IN_FREE is changed.  */
@@ -1041,10 +1045,12 @@ DEF_GCC_BUILTIN        (BUILT_IN_PARITY, "parity", BT_FN_INT_UINT, ATTR_CONST_NO
 DEF_GCC_BUILTIN        (BUILT_IN_PARITYIMAX, "parityimax", BT_FN_INT_UINTMAX, ATTR_CONST_NOTHROW_LEAF_LIST)
 DEF_GCC_BUILTIN        (BUILT_IN_PARITYL, "parityl", BT_FN_INT_ULONG, ATTR_CONST_NOTHROW_LEAF_LIST)
 DEF_GCC_BUILTIN        (BUILT_IN_PARITYLL, "parityll", BT_FN_INT_ULONGLONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN        (BUILT_IN_PARITYG, "parityg", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
 DEF_GCC_BUILTIN        (BUILT_IN_POPCOUNT, "popcount", BT_FN_INT_UINT, ATTR_CONST_NOTHROW_LEAF_LIST)
 DEF_GCC_BUILTIN        (BUILT_IN_POPCOUNTIMAX, "popcountimax", BT_FN_INT_UINTMAX, ATTR_CONST_NOTHROW_LEAF_LIST)
 DEF_GCC_BUILTIN        (BUILT_IN_POPCOUNTL, "popcountl", BT_FN_INT_ULONG, ATTR_CONST_NOTHROW_LEAF_LIST)
 DEF_GCC_BUILTIN        (BUILT_IN_POPCOUNTLL, "popcountll", BT_FN_INT_ULONGLONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN        (BUILT_IN_POPCOUNTG, "popcountg", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
 DEF_EXT_LIB_BUILTIN    (BUILT_IN_POSIX_MEMALIGN, "posix_memalign", BT_FN_INT_PTRPTR_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF)
 DEF_GCC_BUILTIN        (BUILT_IN_PREFETCH, "prefetch", BT_FN_VOID_CONST_PTR_VAR, ATTR_NOVOPS_LEAF_LIST)
 DEF_LIB_BUILTIN        (BUILT_IN_REALLOC, "realloc", BT_FN_PTR_PTR_SIZE, ATTR_ALLOC_WARN_UNUSED_RESULT_SIZE_2_NOTHROW_LEAF_LIST)
diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog
index cbbfa93..ed26f97 100644
--- a/gcc/c-family/ChangeLog
+++ b/gcc/c-family/ChangeLog
@@ -1,3 +1,72 @@
+2023-11-18  Sebastian Huber  <sebastian.huber@embedded-brains.de>
+
+	* c-cppbuiltin.cc (c_cpp_builtins):  Define
+	__LIBGCC_HAVE_LIBATOMIC for libgcov.
+
+2023-11-18  Sebastian Huber  <sebastian.huber@embedded-brains.de>
+
+	Revert:
+	2021-08-16  Sebastian Huber  <sebastian.huber@embedded-brains.de>
+
+	* c-cppbuiltin.c (c_cpp_builtins): Define
+	__LIBGCC_GCOV_TYPE_SIZE if flag_building_libgcc is true.
+
+2023-11-17  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/107571
+	* c-gimplify.cc (genericize_c_loop): For C++ mark IFN_FALLTHROUGH
+	call at the end of loop body as TREE_NOTHROW.
+
+2023-11-14  Lewis Hyatt  <lhyatt@gmail.com>
+
+	PR pch/9471
+	PR pch/47857
+	* c-opts.cc (c_common_post_options): Set cpp_opts->main_search
+	so libcpp knows it is compiling a header file separately.
+
+2023-11-14  David Malcolm  <dmalcolm@redhat.com>
+
+	* c-warn.cc (conversion_warning): Update call to
+	global_dc->m_option_enabled to use option_enabled_p.
+
+2023-11-14  David Malcolm  <dmalcolm@redhat.com>
+
+	* c-common.cc (c_get_substring_location): Use global_dc's
+	file_cache.
+	* c-format.cc (get_corrected_substring): Likewise.
+	* c-indentation.cc (get_visual_column): Add file_cache param.
+	(get_first_nws_vis_column): Likewise.
+	(detect_intervening_unindent): Likewise.
+	(should_warn_for_misleading_indentation): Use global_dc's
+	file_cache.
+	(assert_get_visual_column_succeeds): Add file_cache param.
+	(ASSERT_GET_VISUAL_COLUMN_SUCCEEDS): Likewise.
+	(assert_get_visual_column_fails): Likewise.
+	(define ASSERT_GET_VISUAL_COLUMN_FAILS): Likewise.
+	(selftest::test_get_visual_column): Create and use a temporary
+	file_cache.
+
+2023-11-14  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c/111309
+	* c-common.cc (check_builtin_function_arguments): Handle
+	BUILT_IN_{CLZ,CTZ,CLRSB,FFS,PARITY,POPCOUNT}G.
+	* c-gimplify.cc (c_gimplify_expr): If __builtin_c[lt]zg second
+	argument hasn't been folded into constant yet, transform it to one
+	argument call inside of a COND_EXPR which for first argument 0
+	returns the second argument.
+
+2023-11-11  Martin Uecker  <uecker@tugraz.at>
+
+	PR c/110815
+	PR c/112428
+	* c-attribs.cc (build_attr_access_from_parms): Synthesize
+	nonnull attribute for parameters declared with `static`.
+
+2023-11-09  Florian Weimer  <fweimer@redhat.com>
+
+	* c.opt (Wreturn-mismatch): New.
+
 2023-11-08  Florian Weimer  <fweimer@redhat.com>
 
 	* c.opt (fpermissive): Enable for C and ObjC.
diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc
index 77faf17..0ea0c4f 100644
--- a/gcc/c-family/c-common.cc
+++ b/gcc/c-family/c-common.cc
@@ -894,7 +894,9 @@ c_get_substring_location (const substring_loc &substr_loc,
   if (tok_type == CPP_OTHER)
     return "unrecognized string type";
 
-  return get_location_within_string (parse_in, g_string_concat_db,
+  return get_location_within_string (parse_in,
+				     global_dc->get_file_cache (),
+				     g_string_concat_db,
 				     substr_loc.get_fmt_string_loc (),
 				     tok_type,
 				     substr_loc.get_caret_idx (),
@@ -6475,14 +6477,14 @@ check_builtin_function_arguments (location_t loc, vec<location_t> arg_loc,
 	      }
 	  if (TREE_CODE (TREE_TYPE (args[2])) == ENUMERAL_TYPE)
 	    {
-	      error_at (ARG_LOCATION (2), "argument 3 in call to function "
-			"%qE has enumerated type", fndecl);
+	      error_at (ARG_LOCATION (2), "argument %u in call to function "
+			"%qE has enumerated type", 3, fndecl);
 	      return false;
 	    }
 	  else if (TREE_CODE (TREE_TYPE (args[2])) == BOOLEAN_TYPE)
 	    {
-	      error_at (ARG_LOCATION (2), "argument 3 in call to function "
-			"%qE has boolean type", fndecl);
+	      error_at (ARG_LOCATION (2), "argument %u in call to function "
+			"%qE has boolean type", 3, fndecl);
 	      return false;
 	    }
 	  return true;
@@ -6522,6 +6524,72 @@ check_builtin_function_arguments (location_t loc, vec<location_t> arg_loc,
 	}
       return false;
 
+    case BUILT_IN_CLZG:
+    case BUILT_IN_CTZG:
+    case BUILT_IN_CLRSBG:
+    case BUILT_IN_FFSG:
+    case BUILT_IN_PARITYG:
+    case BUILT_IN_POPCOUNTG:
+      if (nargs == 2
+	  && (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CLZG
+	      || DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CTZG))
+	{
+	  if (!INTEGRAL_TYPE_P (TREE_TYPE (args[1])))
+	    {
+	      error_at (ARG_LOCATION (1), "argument %u in call to function "
+			"%qE does not have integral type", 2, fndecl);
+	      return false;
+	    }
+	  if ((TYPE_PRECISION (TREE_TYPE (args[1]))
+	       > TYPE_PRECISION (integer_type_node))
+	      || (TYPE_PRECISION (TREE_TYPE (args[1]))
+		  == TYPE_PRECISION (integer_type_node)
+		  && TYPE_UNSIGNED (TREE_TYPE (args[1]))))
+	    {
+	      error_at (ARG_LOCATION (1), "argument %u in call to function "
+			"%qE does not have %<int%> type", 2, fndecl);
+	      return false;
+	    }
+	}
+      else if (!builtin_function_validate_nargs (loc, fndecl, nargs, 1))
+	return false;
+
+      if (!INTEGRAL_TYPE_P (TREE_TYPE (args[0])))
+	{
+	  error_at (ARG_LOCATION (0), "argument %u in call to function "
+		    "%qE does not have integral type", 1, fndecl);
+	  return false;
+	}
+      if (TREE_CODE (TREE_TYPE (args[0])) == ENUMERAL_TYPE)
+	{
+	  error_at (ARG_LOCATION (0), "argument %u in call to function "
+		    "%qE has enumerated type", 1, fndecl);
+	  return false;
+	}
+      if (TREE_CODE (TREE_TYPE (args[0])) == BOOLEAN_TYPE)
+	{
+	  error_at (ARG_LOCATION (0), "argument %u in call to function "
+		    "%qE has boolean type", 1, fndecl);
+	  return false;
+	}
+      if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FFSG
+	  || DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CLRSBG)
+	{
+	  if (TYPE_UNSIGNED (TREE_TYPE (args[0])))
+	    {
+	      error_at (ARG_LOCATION (0), "argument 1 in call to function "
+			"%qE has unsigned type", fndecl);
+	      return false;
+	    }
+	}
+      else if (!TYPE_UNSIGNED (TREE_TYPE (args[0])))
+	{
+	  error_at (ARG_LOCATION (0), "argument 1 in call to function "
+		    "%qE has signed type", fndecl);
+	  return false;
+	}
+      return true;
+
     default:
       return true;
     }
diff --git a/gcc/c-family/c-cppbuiltin.cc b/gcc/c-family/c-cppbuiltin.cc
index e48b5b4..8d2f07a 100644
--- a/gcc/c-family/c-cppbuiltin.cc
+++ b/gcc/c-family/c-cppbuiltin.cc
@@ -1567,8 +1567,8 @@ c_cpp_builtins (cpp_reader *pfile)
       /* For libgcov.  */
       builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
 				     TARGET_VTABLE_USES_DESCRIPTORS);
-      builtin_define_with_int_value ("__LIBGCC_GCOV_TYPE_SIZE",
-				     targetm.gcov_type_size());
+      builtin_define_with_int_value ("__LIBGCC_HAVE_LIBATOMIC",
+				     targetm.have_libatomic);
     }
 
   /* For use in assembly language.  */
diff --git a/gcc/c-family/c-format.cc b/gcc/c-family/c-format.cc
index 1a25141..a6497c6 100644
--- a/gcc/c-family/c-format.cc
+++ b/gcc/c-family/c-format.cc
@@ -4570,7 +4570,8 @@ get_corrected_substring (const substring_loc &fmt_loc,
   if (caret.column > finish.column)
     return NULL;
 
-  char_span line = location_get_source_line (start.file, start.line);
+  char_span line
+    = global_dc->get_file_cache ().get_source_line (start.file, start.line);
   if (!line)
     return NULL;
 
diff --git a/gcc/c-family/c-gimplify.cc b/gcc/c-family/c-gimplify.cc
index 17b0610..694ccf9 100644
--- a/gcc/c-family/c-gimplify.cc
+++ b/gcc/c-family/c-gimplify.cc
@@ -307,6 +307,27 @@ genericize_c_loop (tree *stmt_p, location_t start_locus, tree cond, tree body,
     }
 
   append_to_statement_list (body, &stmt_list);
+  if (c_dialect_cxx ()
+      && stmt_list
+      && TREE_CODE (stmt_list) == STATEMENT_LIST)
+    {
+      tree_stmt_iterator tsi = tsi_last (stmt_list);
+      if (!tsi_end_p (tsi))
+	{
+	  tree t = *tsi;
+	  while (TREE_CODE (t) == CLEANUP_POINT_EXPR
+		 || TREE_CODE (t) == EXPR_STMT
+		 || CONVERT_EXPR_CODE_P (TREE_CODE (t)))
+	    t = TREE_OPERAND (t, 0);
+	  /* For C++, if iteration statement body ends with fallthrough
+	     statement, mark it such that we diagnose it even if next
+	     statement would be labeled statement with case/default label.  */
+	  if (TREE_CODE (t) == CALL_EXPR
+	      && !CALL_EXPR_FN (t)
+	      && CALL_EXPR_IFN (t) == IFN_FALLTHROUGH)
+	    TREE_NOTHROW (t) = 1;
+	}
+    }
   finish_bc_block (&stmt_list, bc_continue, clab);
   if (incr)
     {
@@ -818,6 +839,28 @@ c_gimplify_expr (tree *expr_p, gimple_seq *pre_p ATTRIBUTE_UNUSED,
 	break;
       }
 
+    case CALL_EXPR:
+      {
+	tree fndecl = get_callee_fndecl (*expr_p);
+	if (fndecl
+	    && fndecl_built_in_p (fndecl, BUILT_IN_CLZG, BUILT_IN_CTZG)
+	    && call_expr_nargs (*expr_p) == 2
+	    && TREE_CODE (CALL_EXPR_ARG (*expr_p, 1)) != INTEGER_CST)
+	  {
+	    tree a = save_expr (CALL_EXPR_ARG (*expr_p, 0));
+	    tree c = build_call_expr_loc (EXPR_LOCATION (*expr_p),
+					  fndecl, 1, a);
+	    *expr_p = build3_loc (EXPR_LOCATION (*expr_p), COND_EXPR,
+				  integer_type_node,
+				  build2_loc (EXPR_LOCATION (*expr_p),
+					      NE_EXPR, boolean_type_node, a,
+					      build_zero_cst (TREE_TYPE (a))),
+				  c, CALL_EXPR_ARG (*expr_p, 1));
+	    return GS_OK;
+	  }
+	break;
+      }
+
     default:;
     }
 
diff --git a/gcc/c-family/c-indentation.cc b/gcc/c-family/c-indentation.cc
index 5b4614f..a81dffd 100644
--- a/gcc/c-family/c-indentation.cc
+++ b/gcc/c-family/c-indentation.cc
@@ -45,12 +45,13 @@ next_tab_stop (unsigned int vis_column, unsigned int tab_width)
    on the line (up to or before EXPLOC).  */
 
 static bool
-get_visual_column (expanded_location exploc,
+get_visual_column (file_cache &fc,
+		   expanded_location exploc,
 		   unsigned int *out,
 		   unsigned int *first_nws,
 		   unsigned int tab_width)
 {
-  char_span line = location_get_source_line (exploc.file, exploc.line);
+  char_span line = fc.get_source_line (exploc.file, exploc.line);
   if (!line)
     return false;
   if ((size_t)exploc.column > line.length ())
@@ -87,13 +88,14 @@ get_visual_column (expanded_location exploc,
    Otherwise, return false, leaving *FIRST_NWS untouched.  */
 
 static bool
-get_first_nws_vis_column (const char *file, int line_num,
+get_first_nws_vis_column (file_cache &fc,
+			  const char *file, int line_num,
 			  unsigned int *first_nws,
 			  unsigned int tab_width)
 {
   gcc_assert (first_nws);
 
-  char_span line = location_get_source_line (file, line_num);
+  char_span line = fc.get_source_line (file, line_num);
   if (!line)
     return false;
   unsigned int vis_column = 0;
@@ -158,7 +160,8 @@ get_first_nws_vis_column (const char *file, int line_num,
    Return true if such an unindent/outdent is detected.  */
 
 static bool
-detect_intervening_unindent (const char *file,
+detect_intervening_unindent (file_cache &fc,
+			     const char *file,
 			     int body_line,
 			     int next_stmt_line,
 			     unsigned int vis_column,
@@ -170,7 +173,7 @@ detect_intervening_unindent (const char *file,
   for (int line = body_line + 1; line < next_stmt_line; line++)
     {
       unsigned int line_vis_column;
-      if (get_first_nws_vis_column (file, line, &line_vis_column, tab_width))
+      if (get_first_nws_vis_column (fc, file, line, &line_vis_column, tab_width))
 	if (line_vis_column < vis_column)
 	  return true;
     }
@@ -337,6 +340,8 @@ should_warn_for_misleading_indentation (const token_indent_info &guard_tinfo,
   if (next_stmt_exploc.file != body_exploc.file)
     return false;
 
+  file_cache &fc = global_dc->get_file_cache ();
+
   /* If NEXT_STMT_LOC and BODY_LOC are on the same line, consider
      the location of the guard.
 
@@ -376,7 +381,8 @@ should_warn_for_misleading_indentation (const token_indent_info &guard_tinfo,
 	  gcc_assert (guard_exploc.line == next_stmt_exploc.line);
 	  unsigned int guard_vis_column;
 	  unsigned int guard_line_first_nws;
-	  if (!get_visual_column (guard_exploc,
+	  if (!get_visual_column (fc,
+				  guard_exploc,
 				  &guard_vis_column,
 				  &guard_line_first_nws, tab_width))
 	    return false;
@@ -436,15 +442,18 @@ should_warn_for_misleading_indentation (const token_indent_info &guard_tinfo,
 	 the case for input files containing #line directives, and these
 	 are often for autogenerated sources (e.g. from .md files), where
 	 it's not clear that it's meaningful to look at indentation.  */
-      if (!get_visual_column (next_stmt_exploc,
+      if (!get_visual_column (fc,
+			      next_stmt_exploc,
 			      &next_stmt_vis_column,
 			      &next_stmt_line_first_nws, tab_width))
 	return false;
-      if (!get_visual_column (body_exploc,
+      if (!get_visual_column (fc,
+			      body_exploc,
 			      &body_vis_column,
 			      &body_line_first_nws, tab_width))
 	return false;
-      if (!get_visual_column (guard_exploc,
+      if (!get_visual_column (fc,
+			      guard_exploc,
 			      &guard_vis_column,
 			      &guard_line_first_nws, tab_width))
 	return false;
@@ -528,7 +537,8 @@ should_warn_for_misleading_indentation (const token_indent_info &guard_tinfo,
 
 	  /* Don't warn if there is an unindent between the two statements. */
 	  int vis_column = MIN (next_stmt_vis_column, body_vis_column);
-	  if (detect_intervening_unindent (body_exploc.file, body_exploc.line,
+	  if (detect_intervening_unindent (fc,
+					   body_exploc.file, body_exploc.line,
 					   next_stmt_exploc.line,
 					   vis_column, tab_width))
 	    return false;
@@ -686,6 +696,7 @@ test_next_tab_stop ()
 
 static void
 assert_get_visual_column_succeeds (const location &loc,
+				   file_cache &fc,
 				   const char *file, int line, int column,
 				   const unsigned int tab_width,
 				   unsigned int expected_visual_column,
@@ -699,7 +710,8 @@ assert_get_visual_column_succeeds (const location &loc,
   exploc.sysp = false;
   unsigned int actual_visual_column;
   unsigned int actual_first_nws;
-  bool result = get_visual_column (exploc,
+  bool result = get_visual_column (fc,
+				   exploc,
 				   &actual_visual_column,
 				   &actual_first_nws, tab_width);
   ASSERT_TRUE_AT (loc, result);
@@ -710,12 +722,14 @@ assert_get_visual_column_succeeds (const location &loc,
 /* Verify that the given call to get_visual_column succeeds, with
    the given results.  */
 
-#define ASSERT_GET_VISUAL_COLUMN_SUCCEEDS(FILENAME, LINE, COLUMN,	\
+#define ASSERT_GET_VISUAL_COLUMN_SUCCEEDS(FILE_CACHE,			\
+					  FILENAME, LINE, COLUMN,	\
 					  TAB_WIDTH,			\
 					  EXPECTED_VISUAL_COLUMN,	\
 					  EXPECTED_FIRST_NWS)		\
   SELFTEST_BEGIN_STMT							\
     assert_get_visual_column_succeeds (SELFTEST_LOCATION,		\
+				       FILE_CACHE,			\
 				       FILENAME, LINE, COLUMN,		\
 				       TAB_WIDTH,			\
 				       EXPECTED_VISUAL_COLUMN,		\
@@ -726,6 +740,7 @@ assert_get_visual_column_succeeds (const location &loc,
 
 static void
 assert_get_visual_column_fails (const location &loc,
+				file_cache &fc,
 				const char *file, int line, int column,
 				const unsigned int tab_width)
 {
@@ -737,7 +752,8 @@ assert_get_visual_column_fails (const location &loc,
   exploc.sysp = false;
   unsigned int actual_visual_column;
   unsigned int actual_first_nws;
-  bool result = get_visual_column (exploc,
+  bool result = get_visual_column (fc,
+				   exploc,
 				   &actual_visual_column,
 				   &actual_first_nws, tab_width);
   ASSERT_FALSE_AT (loc, result);
@@ -745,10 +761,12 @@ assert_get_visual_column_fails (const location &loc,
 
 /* Verify that the given call to get_visual_column fails gracefully.  */
 
-#define ASSERT_GET_VISUAL_COLUMN_FAILS(FILENAME, LINE, COLUMN,	\
+#define ASSERT_GET_VISUAL_COLUMN_FAILS(FILE_CACHE,		\
+				       FILENAME, LINE, COLUMN,	\
 				       TAB_WIDTH)		\
   SELFTEST_BEGIN_STMT						\
     assert_get_visual_column_fails (SELFTEST_LOCATION,		\
+				    FILE_CACHE,			\
 				    FILENAME, LINE, COLUMN,	\
 				    TAB_WIDTH);		\
   SELFTEST_END_STMT
@@ -770,6 +788,7 @@ test_get_visual_column ()
 			 "\t line 2\n");
   line_table_test ltt;
   temp_source_file tmp (SELFTEST_LOCATION, ".txt", content);
+  file_cache fc;
 
   const unsigned int tab_width = 8;
   const char *file = tmp.get_filename ();
@@ -777,27 +796,27 @@ test_get_visual_column ()
   /* Line 1 (space-based indentation).  */
   {
     const int line = 1;
-    ASSERT_GET_VISUAL_COLUMN_SUCCEEDS (file, line, 1, tab_width, 0, 0);
-    ASSERT_GET_VISUAL_COLUMN_SUCCEEDS (file, line, 2, tab_width, 1, 1);
-    ASSERT_GET_VISUAL_COLUMN_SUCCEEDS (file, line, 3, tab_width, 2, 2);
+    ASSERT_GET_VISUAL_COLUMN_SUCCEEDS (fc, file, line, 1, tab_width, 0, 0);
+    ASSERT_GET_VISUAL_COLUMN_SUCCEEDS (fc, file, line, 2, tab_width, 1, 1);
+    ASSERT_GET_VISUAL_COLUMN_SUCCEEDS (fc, file, line, 3, tab_width, 2, 2);
     /* first_nws should have stopped increasing.  */
-    ASSERT_GET_VISUAL_COLUMN_SUCCEEDS (file, line, 4, tab_width, 3, 2);
+    ASSERT_GET_VISUAL_COLUMN_SUCCEEDS (fc, file, line, 4, tab_width, 3, 2);
     /* Verify the end-of-line boundary.  */
-    ASSERT_GET_VISUAL_COLUMN_SUCCEEDS (file, line, 8, tab_width, 7, 2);
-    ASSERT_GET_VISUAL_COLUMN_FAILS (file, line, 9, tab_width);
+    ASSERT_GET_VISUAL_COLUMN_SUCCEEDS (fc, file, line, 8, tab_width, 7, 2);
+    ASSERT_GET_VISUAL_COLUMN_FAILS (fc, file, line, 9, tab_width);
   }
 
   /* Line 2 (tab-based indentation).  */
   {
     const int line = 2;
-    ASSERT_GET_VISUAL_COLUMN_SUCCEEDS (file, line, 1, tab_width, 0, 0);
-    ASSERT_GET_VISUAL_COLUMN_SUCCEEDS (file, line, 2, tab_width, 8, 8);
-    ASSERT_GET_VISUAL_COLUMN_SUCCEEDS (file, line, 3, tab_width, 9, 9);
+    ASSERT_GET_VISUAL_COLUMN_SUCCEEDS (fc, file, line, 1, tab_width, 0, 0);
+    ASSERT_GET_VISUAL_COLUMN_SUCCEEDS (fc, file, line, 2, tab_width, 8, 8);
+    ASSERT_GET_VISUAL_COLUMN_SUCCEEDS (fc, file, line, 3, tab_width, 9, 9);
     /* first_nws should have stopped increasing.  */
-    ASSERT_GET_VISUAL_COLUMN_SUCCEEDS (file, line, 4, tab_width, 10, 9);
+    ASSERT_GET_VISUAL_COLUMN_SUCCEEDS (fc, file, line, 4, tab_width, 10, 9);
     /* Verify the end-of-line boundary.  */
-    ASSERT_GET_VISUAL_COLUMN_SUCCEEDS (file, line, 8, tab_width, 14, 9);
-    ASSERT_GET_VISUAL_COLUMN_FAILS (file, line, 9, tab_width);
+    ASSERT_GET_VISUAL_COLUMN_SUCCEEDS (fc, file, line, 8, tab_width, 14, 9);
+    ASSERT_GET_VISUAL_COLUMN_FAILS (fc, file, line, 9, tab_width);
   }
 }
 
diff --git a/gcc/c-family/c-lex.cc b/gcc/c-family/c-lex.cc
index 06c2453..86ec679 100644
--- a/gcc/c-family/c-lex.cc
+++ b/gcc/c-family/c-lex.cc
@@ -31,6 +31,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "file-prefix-map.h" /* remap_macro_filename()  */
 #include "langhooks.h"
 #include "attribs.h"
+#include "rich-location.h"
 
 /* We may keep statistics about how long which files took to compile.  */
 static int header_time, body_time;
diff --git a/gcc/c-family/c-opts.cc b/gcc/c-family/c-opts.cc
index fbabd18..10403c0 100644
--- a/gcc/c-family/c-opts.cc
+++ b/gcc/c-family/c-opts.cc
@@ -1174,6 +1174,9 @@ c_common_post_options (const char **pfilename)
 		       "the %qs debug info cannot be used with "
 		       "pre-compiled headers",
 		       debug_set_names (write_symbols & ~DWARF2_DEBUG));
+	  /* Let libcpp know that the main file is a header so it won't
+	     complain about things like #include_next and #pragma once.  */
+	  cpp_opts->main_search = CMS_header;
 	}
       else if (write_symbols != NO_DEBUG && write_symbols != DWARF2_DEBUG)
 	c_common_no_more_pch ();
diff --git a/gcc/c-family/c-warn.cc b/gcc/c-family/c-warn.cc
index b1bd8ba..d2938b9 100644
--- a/gcc/c-family/c-warn.cc
+++ b/gcc/c-family/c-warn.cc
@@ -1350,9 +1350,7 @@ conversion_warning (location_t loc, tree type, tree expr, tree result)
 	  break;
 
 	if (arith_ops
-	    && global_dc->m_option_enabled (warnopt,
-					    global_dc->m_lang_mask,
-					    global_dc->m_option_state))
+	    && global_dc->option_enabled_p (warnopt))
 	  {
 	    for (int i = 0; i < arith_ops; ++i)
 	      {
diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog
index 7730d1d..64fd993 100644
--- a/gcc/c/ChangeLog
+++ b/gcc/c/ChangeLog
@@ -1,3 +1,21 @@
+2023-11-14  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c/111309
+	* c-typeck.cc (convert_arguments): Don't promote first argument
+	of BUILT_IN_{CLZ,CTZ,CLRSB,FFS,PARITY,POPCOUNT}G.
+
+2023-11-10  Martin Uecker  <uecker@tugraz.at>
+
+	* c-typeck.cc (struct comptypes_data): Add anon_field flag.
+	(comptypes, comptypes_check_unum_int,
+	comptypes_check_different_types): Remove old cache.
+	(tagged_tu_types_compatible_p): Rewrite.
+
+2023-11-09  Florian Weimer  <fweimer@redhat.com>
+
+	* c-typeck.cc (c_finish_return): Use pedwarn with
+	OPT_Wreturn_mismatch for missing/extra return expressions.
+
 2023-11-07  Kwok Cheung Yeung  <kcy@codesourcery.com>
 
 	* c-decl.cc (c_decl_attributes): Add attribute for indirect
diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
index 366ca88..1dbb447 100644
--- a/gcc/c/c-typeck.cc
+++ b/gcc/c/c-typeck.cc
@@ -3416,6 +3416,7 @@ convert_arguments (location_t loc, vec<location_t> arg_loc, tree typelist,
     && lookup_attribute ("type generic", TYPE_ATTRIBUTES (TREE_TYPE (fundecl)));
   bool type_generic_remove_excess_precision = false;
   bool type_generic_overflow_p = false;
+  bool type_generic_bit_query = false;
   tree selector;
 
   /* Change pointer to function to the function itself for
@@ -3471,6 +3472,17 @@ convert_arguments (location_t loc, vec<location_t> arg_loc, tree typelist,
 	    type_generic_overflow_p = true;
 	    break;
 
+	  case BUILT_IN_CLZG:
+	  case BUILT_IN_CTZG:
+	  case BUILT_IN_CLRSBG:
+	  case BUILT_IN_FFSG:
+	  case BUILT_IN_PARITYG:
+	  case BUILT_IN_POPCOUNTG:
+	    /* The first argument of these type-generic builtins
+	       should not be promoted.  */
+	    type_generic_bit_query = true;
+	    break;
+
 	  default:
 	    break;
 	  }
@@ -3606,11 +3618,13 @@ convert_arguments (location_t loc, vec<location_t> arg_loc, tree typelist,
 	    }
 	}
       else if ((excess_precision && !type_generic)
-	       || (type_generic_overflow_p && parmnum == 2))
+	       || (type_generic_overflow_p && parmnum == 2)
+	       || (type_generic_bit_query && parmnum == 0))
 	/* A "double" argument with excess precision being passed
 	   without a prototype or in variable arguments.
 	   The last argument of __builtin_*_overflow_p should not be
-	   promoted.  */
+	   promoted, similarly the first argument of
+	   __builtin_{clz,ctz,clrsb,ffs,parity,popcount}g.  */
 	parmval = convert (valtype, val);
       else if ((invalid_func_diag =
 		targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val)))
diff --git a/gcc/common/config/riscv/riscv-common.cc b/gcc/common/config/riscv/riscv-common.cc
index 526dbb7..5111626 100644
--- a/gcc/common/config/riscv/riscv-common.cc
+++ b/gcc/common/config/riscv/riscv-common.cc
@@ -1017,15 +1017,24 @@ riscv_subset_list::parse_std_ext (const char *p)
       std_ext = *p;
 
       /* Checking canonical order.  */
+      const char *prior_std_exts = std_exts;
+
       while (*std_exts && std_ext != *std_exts)
 	std_exts++;
 
       subset[0] = std_ext;
       if (std_ext != *std_exts && standard_extensions_p (subset))
-	error_at (m_loc,
-		  "%<-march=%s%>: ISA string is not in canonical order. "
-		  "%<%c%>",
-		  m_arch, *p);
+	{
+	  error_at (m_loc,
+		    "%<-march=%s%>: ISA string is not in canonical order. "
+		    "%<%c%>",
+		    m_arch, *p);
+	  /* Extension ordering is invalid.  Ignore this extension and keep
+	     searching for other issues with remaining extensions.  */
+	  std_exts = prior_std_exts;
+	  p++;
+	  continue;
+	}
 
       std_exts++;
 
diff --git a/gcc/config.gcc b/gcc/config.gcc
index ba6d63e..b88591b 100644
--- a/gcc/config.gcc
+++ b/gcc/config.gcc
@@ -546,7 +546,7 @@ riscv*)
 	extra_objs="riscv-builtins.o riscv-c.o riscv-sr.o riscv-shorten-memrefs.o riscv-selftests.o riscv-string.o"
 	extra_objs="${extra_objs} riscv-v.o riscv-vsetvl.o riscv-vector-costs.o riscv-avlprop.o"
 	extra_objs="${extra_objs} riscv-vector-builtins.o riscv-vector-builtins-shapes.o riscv-vector-builtins-bases.o"
-	extra_objs="${extra_objs} thead.o"
+	extra_objs="${extra_objs} thead.o riscv-target-attr.o"
 	d_target_objs="riscv-d.o"
 	extra_headers="riscv_vector.h"
 	target_gtfiles="$target_gtfiles \$(srcdir)/config/riscv/riscv-vector-builtins.cc"
@@ -571,6 +571,7 @@ s390*-*-*)
 	d_target_objs="s390-d.o"
 	extra_options="${extra_options} fused-madd.opt"
 	extra_headers="s390intrin.h htmintrin.h htmxlintrin.h vecintrin.h"
+	target_gtfiles="./s390-gen-builtins.h"
 	;;
 # Note the 'l'; we need to be able to match e.g. "shle" or "shl".
 sh[123456789lbe]*-*-* | sh-*-*)
@@ -5038,7 +5039,7 @@ case "${target}" in
 
 		# Perform initial sanity checks on --with-* options.
 		case ${with_arch} in
-		"" | abi-default | loongarch64 | la464) ;; # OK, append here.
+		"" | abi-default | loongarch64 | la[46]64) ;; # OK, append here.
 		native)
 			if test x${host} != x${target}; then
 				echo "--with-arch=native is illegal for cross-compiler." 1>&2
@@ -5087,7 +5088,7 @@ case "${target}" in
 		case ${abi_base}/${abi_ext} in
 		lp64*/base)
 			# architectures that support lp64* ABI
-			arch_pattern="native|abi-default|loongarch64|la464"
+			arch_pattern="native|abi-default|loongarch64|la[46]64"
 			# default architecture for lp64* ABI
 			arch_default="abi-default"
 			;;
@@ -5162,7 +5163,7 @@ case "${target}" in
 		# Check default with_tune configuration using with_arch.
 		case ${with_arch} in
 		loongarch64)
-			tune_pattern="native|abi-default|loongarch64|la464"
+			tune_pattern="native|abi-default|loongarch64|la[46]64"
 			;;
 		*)
 			# By default, $with_tune == $with_arch
@@ -5218,7 +5219,7 @@ case "${target}" in
 					# Fixed: use the default gcc configuration for all multilib
 					# builds by default.
 					with_multilib_default="" ;;
-				arch,native|arch,loongarch64|arch,la464) # OK, append here.
+				arch,native|arch,loongarch64|arch,la[46]64) # OK, append here.
 					with_multilib_default="/march=${component}" ;;
 				arch,*)
 					with_multilib_default="/march=abi-default"
@@ -5306,7 +5307,7 @@ case "${target}" in
 				if test x${parse_state} = x"arch"; then
 					# -march option
 					case ${component} in
-					native | abi-default | loongarch64 | la464) # OK, append here.
+					native | abi-default | loongarch64 | la[46]64) # OK, append here.
 						# Append -march spec for each multilib variant.
 						loongarch_multilib_list_make="${loongarch_multilib_list_make}/march=${component}"
 						parse_state="opts"
diff --git a/gcc/config.in b/gcc/config.in
index 0509ba7..e100c20 100644
--- a/gcc/config.in
+++ b/gcc/config.in
@@ -386,6 +386,12 @@
 #endif
 
 
+/* Define if your assembler supports conditional branch relaxation. */
+#ifndef USED_FOR_TARGET
+#undef HAVE_AS_COND_BRANCH_RELAXATION
+#endif
+
+
 /* Define if your assembler supports the --debug-prefix-map option. */
 #ifndef USED_FOR_TARGET
 #undef HAVE_AS_DEBUG_PREFIX_MAP
@@ -775,6 +781,12 @@
 #endif
 
 
+/* Define if your assembler supports call36 relocation. */
+#ifndef USED_FOR_TARGET
+#undef HAVE_AS_SUPPORT_CALL36
+#endif
+
+
 /* Define if your assembler and linker support thread-local storage. */
 #ifndef USED_FOR_TARGET
 #undef HAVE_AS_TLS
@@ -820,6 +832,20 @@
 #endif
 
 
+/* Define to 1 if you have the Mac OS X function
+   CFLocaleCopyPreferredLanguages in the CoreFoundation framework. */
+#ifndef USED_FOR_TARGET
+#undef HAVE_CFLOCALECOPYPREFERREDLANGUAGES
+#endif
+
+
+/* Define to 1 if you have the Mac OS X function CFPreferencesCopyAppValue in
+   the CoreFoundation framework. */
+#ifndef USED_FOR_TARGET
+#undef HAVE_CFPREFERENCESCOPYAPPVALUE
+#endif
+
+
 /* Define to 1 if you have the `clearerr_unlocked' function. */
 #ifndef USED_FOR_TARGET
 #undef HAVE_CLEARERR_UNLOCKED
@@ -844,6 +870,13 @@
 #endif
 
 
+/* Define if the GNU dcgettext() function is already present or preinstalled.
+   */
+#ifndef USED_FOR_TARGET
+#undef HAVE_DCGETTEXT
+#endif
+
+
 /* Define to 1 if we found a declaration for 'abort', otherwise define to 0.
    */
 #ifndef USED_FOR_TARGET
@@ -1516,6 +1549,12 @@
 #endif
 
 
+/* Define if the GNU gettext() function is already present or preinstalled. */
+#ifndef USED_FOR_TARGET
+#undef HAVE_GETTEXT
+#endif
+
+
 /* Define to 1 if you have the `gettimeofday' function. */
 #ifndef USED_FOR_TARGET
 #undef HAVE_GETTIMEOFDAY
@@ -1547,7 +1586,7 @@
 #endif
 
 
-/* Define if you have the iconv() function. */
+/* Define if you have the iconv() function and it works. */
 #ifndef USED_FOR_TARGET
 #undef HAVE_ICONV
 #endif
diff --git a/gcc/config/arm/arm.cc b/gcc/config/arm/arm.cc
index 620ef7b..25a1ad7 100644
--- a/gcc/config/arm/arm.cc
+++ b/gcc/config/arm/arm.cc
@@ -13695,8 +13695,11 @@ mve_vector_mem_operand (machine_mode mode, rtx op, bool strict)
     }
   code = GET_CODE (op);
 
-  if (code == POST_INC || code == PRE_DEC
-      || code == PRE_INC || code == POST_DEC)
+  if ((code == POST_INC
+       || code == PRE_DEC
+       || code == PRE_INC
+       || code == POST_DEC)
+      && REG_P (XEXP (op, 0)))
     {
       reg_no = arm_effective_regno (XEXP (op, 0), strict);
       return (((mode == E_V8QImode || mode == E_V4QImode || mode == E_V4HImode)
diff --git a/gcc/config/avr/avr.cc b/gcc/config/avr/avr.cc
index 5e0217d..c3e0995 100644
--- a/gcc/config/avr/avr.cc
+++ b/gcc/config/avr/avr.cc
@@ -10873,7 +10873,12 @@ avr_asm_init_sections (void)
 static void
 avr_asm_named_section (const char *name, unsigned int flags, tree decl)
 {
-  if (flags & AVR_SECTION_PROGMEM)
+  if (flags & AVR_SECTION_PROGMEM
+      // Only use section .progmem*.data if there is no attribute section.
+      && ! (decl
+	    && DECL_SECTION_NAME (decl)
+	    && symtab_node::get (decl)
+	    && ! symtab_node::get (decl)->implicit_section))
     {
       addr_space_t as = (flags & AVR_SECTION_PROGMEM) / SECTION_MACH_DEP;
       const char *old_prefix = ".rodata";
@@ -10942,6 +10947,7 @@ avr_section_type_flags (tree decl, const char *name, int reloc)
       flags |= as * SECTION_MACH_DEP;
       flags &= ~SECTION_WRITE;
       flags &= ~SECTION_BSS;
+      flags &= ~SECTION_NOTYPE;
     }
 
   return flags;
diff --git a/gcc/config/gcn/constraints.md b/gcc/config/gcn/constraints.md
index efe462a..b29dc5b 100644
--- a/gcc/config/gcn/constraints.md
+++ b/gcc/config/gcn/constraints.md
@@ -77,6 +77,9 @@
 (define_register_constraint "v" "VGPR_REGS"
   "VGPR registers")
 
+(define_register_constraint "a" "TARGET_CDNA1_PLUS ? AVGPR_REGS : NO_REGS"
+  "Accumulator VGPR registers")
+
 (define_register_constraint "Sg" "SGPR_REGS"
   "SGPR registers")
 
diff --git a/gcc/config/gcn/gcn-valu.md b/gcc/config/gcn/gcn-valu.md
index 8c44169..23f2bbe 100644
--- a/gcc/config/gcn/gcn-valu.md
+++ b/gcc/config/gcn/gcn-valu.md
@@ -449,12 +449,16 @@
    (set_attr "length" "0")])
 
 (define_insn "*mov<mode>"
-  [(set (match_operand:V_1REG 0 "nonimmediate_operand" "=v,v")
-	(match_operand:V_1REG 1 "general_operand"      "vA,B"))]
-  ""
-  "v_mov_b32\t%0, %1"
-  [(set_attr "type" "vop1,vop1")
-   (set_attr "length" "4,8")])
+  [(set (match_operand:V_1REG 0 "nonimmediate_operand")
+	(match_operand:V_1REG 1 "general_operand"))]
+  ""
+  {@ [cons: =0, 1; attrs: type, length, gcn_version]
+  [v  ,vA;vop1     ,4,*    ] v_mov_b32\t%0, %1
+  [v  ,B ;vop1     ,8,*    ] ^
+  [v  ,a ;vop3p_mai,8,*    ] v_accvgpr_read_b32\t%0, %1
+  [$a ,v ;vop3p_mai,8,*    ] v_accvgpr_write_b32\t%0, %1
+  [a  ,a ;vop1     ,4,cdna2] v_accvgpr_mov_b32\t%0, %1
+  })
 
 (define_insn "mov<mode>_exec"
   [(set (match_operand:V_1REG 0 "nonimmediate_operand")
@@ -493,17 +497,29 @@
 ;   (set_attr "length" "4,8,16,16")])
 
 (define_insn "*mov<mode>"
-  [(set (match_operand:V_2REG 0 "nonimmediate_operand" "=v")
-	(match_operand:V_2REG 1 "general_operand"      "vDB"))]
+  [(set (match_operand:V_2REG 0 "nonimmediate_operand" "=v, v,$a,a")
+	(match_operand:V_2REG 1 "general_operand"      "vDB,a, v,a"))]
   ""
-  {
-    if (!REG_P (operands[1]) || REGNO (operands[0]) <= REGNO (operands[1]))
-      return "v_mov_b32\t%L0, %L1\;v_mov_b32\t%H0, %H1";
-    else
-      return "v_mov_b32\t%H0, %H1\;v_mov_b32\t%L0, %L1";
-  }
-  [(set_attr "type" "vmult")
-   (set_attr "length" "16")])
+  "@
+   * if (!REG_P (operands[1]) || REGNO (operands[0]) <= REGNO (operands[1])) \
+       return \"v_mov_b32\t%L0, %L1\;v_mov_b32\t%H0, %H1\"; \
+     else \
+       return \"v_mov_b32\t%H0, %H1\;v_mov_b32\t%L0, %L1\";
+   * if (REGNO (operands[0]) <= REGNO (operands[1])) \
+       return \"v_accvgpr_read_b32\t%L0, %L1\;v_accvgpr_read_b32\t%H0, %H1\"; \
+     else \
+       return \"v_accvgpr_read_b32\t%H0, %H1\;v_accvgpr_read_b32\t%L0, %L1\";
+   * if (REGNO (operands[0]) <= REGNO (operands[1])) \
+       return \"v_accvgpr_write_b32\t%L0, %L1\;v_accvgpr_write_b32\t%H0, %H1\"; \
+     else \
+       return \"v_accvgpr_write_b32\t%H0, %H1\;v_accvgpr_write_b32\t%L0, %L1\";
+   * if (REGNO (operands[0]) <= REGNO (operands[1])) \
+       return \"v_accvgpr_mov_b32\t%L0, %L1\;v_accvgpr_mov_b32\t%H0, %H1\"; \
+     else \
+       return \"v_accvgpr_mov_b32\t%H0, %H1\;v_accvgpr_mov_b32\t%L0, %L1\";"
+  [(set_attr "type" "vmult,vmult,vmult,vmult")
+   (set_attr "length" "16,16,16,8")
+   (set_attr "gcn_version" "*,*,*,cdna2")])
 
 (define_insn "mov<mode>_exec"
   [(set (match_operand:V_2REG 0 "nonimmediate_operand" "= v,   v,   v, v, m")
@@ -546,17 +562,15 @@
    (set_attr "length" "16,16,16,16,16")])
 
 (define_insn "*mov<mode>_4reg"
-  [(set (match_operand:V_4REG 0 "nonimmediate_operand" "=v")
-	(match_operand:V_4REG 1 "general_operand"      "vDB"))]
+  [(set (match_operand:V_4REG 0 "nonimmediate_operand")
+	(match_operand:V_4REG 1 "general_operand"))]
   ""
-  {
-    return "v_mov_b32\t%L0, %L1\;"
-           "v_mov_b32\t%H0, %H1\;"
-           "v_mov_b32\t%J0, %J1\;"
-           "v_mov_b32\t%K0, %K1\;";
-  }
-  [(set_attr "type" "vmult")
-   (set_attr "length" "16")])
+  {@ [cons: =0, 1; attrs: type, length, gcn_version]
+  [v,vDB;vmult,16,*    ]           v_mov_b32\t%L0, %L1\;          v_mov_b32\t%H0, %H1\;          v_mov_b32\t%J0, %J1\;          v_mov_b32\t%K0, %K1
+  [v,a  ;vmult,32,*    ]  v_accvgpr_read_b32\t%L0, %L1\; v_accvgpr_read_b32\t%H0, %H1\; v_accvgpr_read_b32\t%J0, %J1\; v_accvgpr_read_b32\t%K0, %K1
+  [a,v  ;vmult,32,*    ] v_accvgpr_write_b32\t%L0, %L1\;v_accvgpr_write_b32\t%H0, %H1\;v_accvgpr_write_b32\t%J0, %J1\;v_accvgpr_write_b32\t%K0, %K1
+  [a,a  ;vmult,32,cdna2]   v_accvgpr_mov_b32\t%L0, %L1\;  v_accvgpr_mov_b32\t%H0, %H1\;  v_accvgpr_mov_b32\t%J0, %J1\;  v_accvgpr_mov_b32\t%K0, %K1
+  })
 
 (define_insn "mov<mode>_exec"
   [(set (match_operand:V_4REG 0 "nonimmediate_operand" "= v,   v,   v, v, m")
@@ -641,26 +655,28 @@
 ;   vT += Sv
 ;   flat_load v, vT
 
-(define_insn "mov<mode>_sgprbase"
+(define_insn "@mov<mode>_sgprbase"
   [(set (match_operand:V_1REG 0 "nonimmediate_operand")
 	(unspec:V_1REG
 	  [(match_operand:V_1REG 1 "general_operand")]
 	  UNSPEC_SGPRBASE))
    (clobber (match_operand:<VnDI> 2 "register_operand"))]
   "lra_in_progress || reload_completed"
-  {@ [cons: =0, 1, =2; attrs: type, length]
-  [v,vA,&v;vop1,4 ] v_mov_b32\t%0, %1
-  [v,vB,&v;vop1,8 ] ^
-  [v,m ,&v;*   ,12] #
-  [m,v ,&v;*   ,12] #
+  {@ [cons: =0, 1, =2; attrs: type, length, gcn_version]
+  [v,vA,&v;vop1,4 ,*    ] v_mov_b32\t%0, %1
+  [v,vB,&v;vop1,8 ,*    ] ^
+  [v,m ,&v;*   ,12,*    ] #
+  [m,v ,&v;*   ,12,*    ] #
+  [a,m ,&v;*   ,12,cdna2] #
+  [m,a ,&v;*   ,12,cdna2] #
   })
 
-(define_insn "mov<mode>_sgprbase"
-  [(set (match_operand:V_2REG 0 "nonimmediate_operand" "= v, v, m")
+(define_insn "@mov<mode>_sgprbase"
+  [(set (match_operand:V_2REG 0 "nonimmediate_operand" "= v, v, m, a, m")
 	(unspec:V_2REG
-	  [(match_operand:V_2REG 1 "general_operand"   "vDB, m, v")]
+	  [(match_operand:V_2REG 1 "general_operand"   "vDB, m, v, m, a")]
 	  UNSPEC_SGPRBASE))
-   (clobber (match_operand:<VnDI> 2 "register_operand"  "=&v,&v,&v"))]
+   (clobber (match_operand:<VnDI> 2 "register_operand"  "=&v,&v,&v,&v,&v"))]
   "lra_in_progress || reload_completed"
   "@
    * if (!REG_P (operands[1]) || REGNO (operands[0]) <= REGNO (operands[1])) \
@@ -668,11 +684,14 @@
      else \
        return \"v_mov_b32\t%H0, %H1\;v_mov_b32\t%L0, %L1\";
    #
+   #
+   #
    #"
-  [(set_attr "type" "vmult,*,*")
-   (set_attr "length" "8,12,12")])
+  [(set_attr "type" "vmult,*,*,*,*")
+   (set_attr "length" "8,12,12,12,12")
+   (set_attr "gcn_version" "*,*,*,cdna2,cdna2")])
 
-(define_insn "mov<mode>_sgprbase"
+(define_insn "@mov<mode>_sgprbase"
   [(set (match_operand:V_4REG 0 "nonimmediate_operand")
 	(unspec:V_4REG
 	  [(match_operand:V_4REG 1 "general_operand")]
@@ -685,31 +704,6 @@
   [m,v  ,&v;*    ,12] #
   })
 
-; reload_in was once a standard name, but here it's only referenced by
-; gcn_secondary_reload.  It allows a reload with a scratch register.
-
-(define_expand "reload_in<mode>"
-  [(set (match_operand:V_MOV 0 "register_operand"     "= v")
-	(match_operand:V_MOV 1 "memory_operand"	      "  m"))
-   (clobber (match_operand:<VnDI> 2 "register_operand" "=&v"))]
-  ""
-  {
-    emit_insn (gen_mov<mode>_sgprbase (operands[0], operands[1], operands[2]));
-    DONE;
-  })
-
-; reload_out is similar to reload_in, above.
-
-(define_expand "reload_out<mode>"
-  [(set (match_operand:V_MOV 0 "memory_operand"	      "= m")
-	(match_operand:V_MOV 1 "register_operand"     "  v"))
-   (clobber (match_operand:<VnDI> 2 "register_operand" "=&v"))]
-  ""
-  {
-    emit_insn (gen_mov<mode>_sgprbase (operands[0], operands[1], operands[2]));
-    DONE;
-  })
-
 ; Expand scalar addresses into gather/scatter patterns
 
 (define_split
@@ -1151,13 +1145,13 @@
     {})
 
 (define_insn "gather<mode>_insn_1offset<exec>"
-  [(set (match_operand:V_MOV 0 "register_operand"		   "=v")
+  [(set (match_operand:V_MOV 0 "register_operand"		   "=v,a")
 	(unspec:V_MOV
-	  [(plus:<VnDI> (match_operand:<VnDI> 1 "register_operand" " v")
+	  [(plus:<VnDI> (match_operand:<VnDI> 1 "register_operand" " v,v")
 			(vec_duplicate:<VnDI>
-			  (match_operand 2 "immediate_operand"	   " n")))
-	   (match_operand 3 "immediate_operand"			   " n")
-	   (match_operand 4 "immediate_operand"			   " n")
+			  (match_operand 2 "immediate_operand"	   " n,n")))
+	   (match_operand 3 "immediate_operand"			   " n,n")
+	  (match_operand 4 "immediate_operand"			   " n,n")
 	   (mem:BLK (scratch))]
 	  UNSPEC_GATHER))]
   "(AS_FLAT_P (INTVAL (operands[3]))
@@ -1187,16 +1181,17 @@
     return buf;
   }
   [(set_attr "type" "flat")
-   (set_attr "length" "12")])
+   (set_attr "length" "12")
+   (set_attr "gcn_version" "*,cdna2")])
 
 (define_insn "gather<mode>_insn_1offset_ds<exec>"
-  [(set (match_operand:V_MOV 0 "register_operand"		   "=v")
+  [(set (match_operand:V_MOV 0 "register_operand"		   "=v,a")
 	(unspec:V_MOV
-	  [(plus:<VnSI> (match_operand:<VnSI> 1 "register_operand" " v")
+	  [(plus:<VnSI> (match_operand:<VnSI> 1 "register_operand" " v,v")
 			(vec_duplicate:<VnSI>
-			  (match_operand 2 "immediate_operand"	   " n")))
-	   (match_operand 3 "immediate_operand"			   " n")
-	   (match_operand 4 "immediate_operand"			   " n")
+			  (match_operand 2 "immediate_operand"	   " n,n")))
+	   (match_operand 3 "immediate_operand"			   " n,n")
+	   (match_operand 4 "immediate_operand"			   " n,n")
 	   (mem:BLK (scratch))]
 	  UNSPEC_GATHER))]
   "(AS_ANY_DS_P (INTVAL (operands[3]))
@@ -1209,20 +1204,22 @@
     return buf;
   }
   [(set_attr "type" "ds")
-   (set_attr "length" "12")])
+   (set_attr "length" "12")
+   (set_attr "gcn_version" "*,cdna2")])
 
 (define_insn "gather<mode>_insn_2offsets<exec>"
-  [(set (match_operand:V_MOV 0 "register_operand"			"=v")
+  [(set (match_operand:V_MOV 0 "register_operand"		      "=v,a")
 	(unspec:V_MOV
 	  [(plus:<VnDI>
 	     (plus:<VnDI>
 	       (vec_duplicate:<VnDI>
-		 (match_operand:DI 1 "register_operand"			"Sv"))
+		 (match_operand:DI 1 "register_operand"		      "Sv,Sv"))
 	       (sign_extend:<VnDI>
-		 (match_operand:<VnSI> 2 "register_operand"		" v")))
-	     (vec_duplicate:<VnDI> (match_operand 3 "immediate_operand" " n")))
-	   (match_operand 4 "immediate_operand"				" n")
-	   (match_operand 5 "immediate_operand"				" n")
+		 (match_operand:<VnSI> 2 "register_operand"	      " v,v")))
+	     (vec_duplicate:<VnDI> (match_operand 3 "immediate_operand"
+								      " n,n")))
+	   (match_operand 4 "immediate_operand"			      " n,n")
+	   (match_operand 5 "immediate_operand"			      " n,n")
 	   (mem:BLK (scratch))]
 	  UNSPEC_GATHER))]
   "(AS_GLOBAL_P (INTVAL (operands[4]))
@@ -1241,7 +1238,8 @@
     return buf;
   }
   [(set_attr "type" "flat")
-   (set_attr "length" "12")])
+   (set_attr "length" "12")
+   (set_attr "gcn_version" "*,cdna2")])
 
 (define_expand "scatter_store<mode><vnsi>"
   [(match_operand:DI 0 "register_operand")
@@ -1280,12 +1278,12 @@
 (define_insn "scatter<mode>_insn_1offset<exec_scatter>"
   [(set (mem:BLK (scratch))
 	(unspec:BLK
-	  [(plus:<VnDI> (match_operand:<VnDI> 0 "register_operand" "v")
+	  [(plus:<VnDI> (match_operand:<VnDI> 0 "register_operand" "v,v")
 			(vec_duplicate:<VnDI>
-			  (match_operand 1 "immediate_operand"	   "n")))
-	   (match_operand:V_MOV 2 "register_operand"		   "v")
-	   (match_operand 3 "immediate_operand"			   "n")
-	   (match_operand 4 "immediate_operand"			   "n")]
+			  (match_operand 1 "immediate_operand"	   "n,n")))
+	   (match_operand:V_MOV 2 "register_operand"		   "v,a")
+	   (match_operand 3 "immediate_operand"			   "n,n")
+	   (match_operand 4 "immediate_operand"			   "n,n")]
 	  UNSPEC_SCATTER))]
   "(AS_FLAT_P (INTVAL (operands[3]))
     && (INTVAL(operands[1]) == 0
@@ -1313,17 +1311,18 @@
     return buf;
   }
   [(set_attr "type" "flat")
-   (set_attr "length" "12")])
+   (set_attr "length" "12")
+   (set_attr "gcn_version" "*,cdna2")])
 
 (define_insn "scatter<mode>_insn_1offset_ds<exec_scatter>"
   [(set (mem:BLK (scratch))
 	(unspec:BLK
-	  [(plus:<VnSI> (match_operand:<VnSI> 0 "register_operand" "v")
+	  [(plus:<VnSI> (match_operand:<VnSI> 0 "register_operand" "v,v")
 			(vec_duplicate:<VnSI>
-			  (match_operand 1 "immediate_operand"	   "n")))
-	   (match_operand:V_MOV 2 "register_operand"		   "v")
-	   (match_operand 3 "immediate_operand"			   "n")
-	   (match_operand 4 "immediate_operand"			   "n")]
+			  (match_operand 1 "immediate_operand"	   "n,n")))
+	   (match_operand:V_MOV 2 "register_operand"		   "v,a")
+	   (match_operand 3 "immediate_operand"			   "n,n")
+	   (match_operand 4 "immediate_operand"			   "n,n")]
 	  UNSPEC_SCATTER))]
   "(AS_ANY_DS_P (INTVAL (operands[3]))
     && ((unsigned HOST_WIDE_INT)INTVAL(operands[1]) < 0x10000))"
@@ -1335,7 +1334,8 @@
     return buf;
   }
   [(set_attr "type" "ds")
-   (set_attr "length" "12")])
+   (set_attr "length" "12")
+   (set_attr "gcn_version" "*,cdna2")])
 
 (define_insn "scatter<mode>_insn_2offsets<exec_scatter>"
   [(set (mem:BLK (scratch))
@@ -1343,13 +1343,13 @@
 	  [(plus:<VnDI>
 	     (plus:<VnDI>
 	       (vec_duplicate:<VnDI>
-		 (match_operand:DI 0 "register_operand"			"Sv"))
+		 (match_operand:DI 0 "register_operand"		       "Sv,Sv"))
 	       (sign_extend:<VnDI>
-		 (match_operand:<VnSI> 1 "register_operand"		" v")))
-	     (vec_duplicate:<VnDI> (match_operand 2 "immediate_operand" " n")))
-	   (match_operand:V_MOV 3 "register_operand"			" v")
-	   (match_operand 4 "immediate_operand"				" n")
-	   (match_operand 5 "immediate_operand"				" n")]
+		 (match_operand:<VnSI> 1 "register_operand"		"v,v")))
+	     (vec_duplicate:<VnDI> (match_operand 2 "immediate_operand" "n,n")))
+	   (match_operand:V_MOV 3 "register_operand"			"v,a")
+	   (match_operand 4 "immediate_operand"				"n,n")
+	   (match_operand 5 "immediate_operand"				"n,n")]
 	  UNSPEC_SCATTER))]
   "(AS_GLOBAL_P (INTVAL (operands[4]))
     && (((unsigned HOST_WIDE_INT)INTVAL(operands[2]) + 0x1000) < 0x2000))"
@@ -1366,7 +1366,8 @@
     return buf;
   }
   [(set_attr "type" "flat")
-   (set_attr "length" "12")])
+   (set_attr "length" "12")
+   (set_attr "gcn_version" "*,cdna2")])
 
 ;; }}}
 ;; {{{ Permutations
diff --git a/gcc/config/gcn/gcn.cc b/gcc/config/gcn/gcn.cc
index ac29925..52c8a0e 100644
--- a/gcc/config/gcn/gcn.cc
+++ b/gcc/config/gcn/gcn.cc
@@ -96,6 +96,7 @@ static hash_map<tree, int> lds_allocs;
 
 #define MAX_NORMAL_SGPR_COUNT	62  // i.e. 64 with VCC
 #define MAX_NORMAL_VGPR_COUNT	24
+#define MAX_NORMAL_AVGPR_COUNT	24
 
 /* }}}  */
 /* {{{ Initialization and options.  */
@@ -483,7 +484,8 @@ gcn_class_max_nregs (reg_class_t rclass, machine_mode mode)
 {
   /* Scalar registers are 32bit, vector registers are in fact tuples of
      64 lanes.  */
-  if (rclass == VGPR_REGS)
+  if (rclass == VGPR_REGS || rclass == AVGPR_REGS
+      || rclass == ALL_VGPR_REGS)
     {
       if (vgpr_1reg_mode_p (mode))
 	return 1;
@@ -583,7 +585,7 @@ gcn_hard_regno_mode_ok (unsigned int regno, machine_mode mode)
     return (sgpr_1reg_mode_p (mode)
 	    || (!((regno - FIRST_SGPR_REG) & 1) && sgpr_2reg_mode_p (mode))
 	    || (((regno - FIRST_SGPR_REG) & 3) == 0 && mode == TImode));
-  if (VGPR_REGNO_P (regno))
+  if (VGPR_REGNO_P (regno) || (AVGPR_REGNO_P (regno) && TARGET_CDNA1_PLUS))
     /* Vector instructions do not care about the alignment of register
        pairs, but where there is no 64-bit instruction, many of the
        define_split do not work if the input and output registers partially
@@ -623,6 +625,8 @@ gcn_regno_reg_class (int regno)
     }
   if (VGPR_REGNO_P (regno))
     return VGPR_REGS;
+  if (AVGPR_REGNO_P (regno))
+    return AVGPR_REGS;
   if (SGPR_REGNO_P (regno))
     return SGPR_REGS;
   if (regno < FIRST_VGPR_REG)
@@ -813,7 +817,7 @@ gcn_spill_class (reg_class_t c, machine_mode /*mode */ )
       || c == VCC_CONDITIONAL_REG || c == EXEC_MASK_REG)
     return SGPR_REGS;
   else
-    return NO_REGS;
+    return c == VGPR_REGS && TARGET_CDNA1_PLUS ? AVGPR_REGS : NO_REGS;
 }
 
 /* Implement TARGET_IRA_CHANGE_PSEUDO_ALLOCNO_CLASS.
@@ -1388,64 +1392,6 @@ GEN_VN_NOEXEC (vec_series,si, A(rtx dest, rtx x, rtx c), A(dest, x, c))
 #undef GET_VN_FN
 #undef A
 
-/* Get icode for vector instructions without an optab.  */
-
-#define CODE_FOR(PREFIX, SUFFIX) \
-static int \
-get_code_for_##PREFIX##vN##SUFFIX (int nunits) \
-{ \
-  switch (nunits) \
-    { \
-    case 2: return CODE_FOR_##PREFIX##v2##SUFFIX; \
-    case 4: return CODE_FOR_##PREFIX##v4##SUFFIX; \
-    case 8: return CODE_FOR_##PREFIX##v8##SUFFIX; \
-    case 16: return CODE_FOR_##PREFIX##v16##SUFFIX; \
-    case 32: return CODE_FOR_##PREFIX##v32##SUFFIX; \
-    case 64: return CODE_FOR_##PREFIX##v64##SUFFIX; \
-    } \
-  \
-  gcc_unreachable (); \
-  return CODE_FOR_nothing; \
-}
-
-#define CODE_FOR_OP(PREFIX) \
-	  CODE_FOR (PREFIX, qi) \
-	CODE_FOR (PREFIX, hi) \
-	CODE_FOR (PREFIX, hf) \
-	CODE_FOR (PREFIX, si) \
-	CODE_FOR (PREFIX, sf) \
-	CODE_FOR (PREFIX, di) \
-	CODE_FOR (PREFIX, df) \
-	CODE_FOR (PREFIX, ti) \
-static int \
-get_code_for_##PREFIX (machine_mode mode) \
-{ \
-  int vf = GET_MODE_NUNITS (mode); \
-  machine_mode smode = GET_MODE_INNER (mode); \
-  \
-  switch (smode) \
-    { \
-    case E_QImode: return get_code_for_##PREFIX##vNqi (vf); \
-    case E_HImode: return get_code_for_##PREFIX##vNhi (vf); \
-    case E_HFmode: return get_code_for_##PREFIX##vNhf (vf); \
-    case E_SImode: return get_code_for_##PREFIX##vNsi (vf); \
-    case E_SFmode: return get_code_for_##PREFIX##vNsf (vf); \
-    case E_DImode: return get_code_for_##PREFIX##vNdi (vf); \
-    case E_DFmode: return get_code_for_##PREFIX##vNdf (vf); \
-    case E_TImode: return get_code_for_##PREFIX##vNti (vf); \
-    default: break; \
-    } \
-  \
-  gcc_unreachable (); \
-  return CODE_FOR_nothing; \
-}
-
-CODE_FOR_OP (reload_in)
-CODE_FOR_OP (reload_out)
-
-#undef CODE_FOR_OP
-#undef CODE_FOR
-
 /* Return true if OP is a PARALLEL of CONST_INTs that form a linear
    series with step STEP.  */
 
@@ -2406,12 +2352,15 @@ gcn_sgpr_move_p (rtx op0, rtx op1)
     return true;
   if (MEM_P (op1) && AS_SCALAR_FLAT_P (MEM_ADDR_SPACE (op1)))
     return true;
-  if (!REG_P (op0) || REGNO (op0) >= FIRST_PSEUDO_REGISTER
-      || VGPR_REGNO_P (REGNO (op0)))
+  if (!REG_P (op0)
+      || REGNO (op0) >= FIRST_PSEUDO_REGISTER
+      || VGPR_REGNO_P (REGNO (op0))
+      || AVGPR_REGNO_P (REGNO (op0)))
     return false;
   if (REG_P (op1)
       && REGNO (op1) < FIRST_PSEUDO_REGISTER
-      && !VGPR_REGNO_P (REGNO (op1)))
+      && !VGPR_REGNO_P (REGNO (op1))
+      && !AVGPR_REGNO_P (REGNO (op1)))
     return true;
   return immediate_operand (op1, VOIDmode) || memory_operand (op1, VOIDmode);
 }
@@ -2472,10 +2421,7 @@ gcn_secondary_reload (bool in_p, rtx x, reg_class_t rclass,
 	  if (GET_MODE_CLASS (reload_mode) == MODE_VECTOR_INT
 	      || GET_MODE_CLASS (reload_mode) == MODE_VECTOR_FLOAT)
 	    {
-	      if (in_p)
-		sri->icode = get_code_for_reload_in (reload_mode);
-	      else
-		sri->icode = get_code_for_reload_out (reload_mode);
+	      sri->icode = code_for_mov_sgprbase (reload_mode);
 	      break;
 	    }
 	  /* Fallthrough.  */
@@ -2485,6 +2431,11 @@ gcn_secondary_reload (bool in_p, rtx x, reg_class_t rclass,
 	  result = (rclass == VGPR_REGS ? NO_REGS : VGPR_REGS);
 	  break;
 	}
+
+      /* CDNA1 doesn't have an instruction for going between the accumulator
+	 registers and memory.  Go via a VGPR in this case.  */
+      if (TARGET_CDNA1 && rclass == AVGPR_REGS && result != VGPR_REGS)
+	result = VGPR_REGS;
     }
 
   if (dump_file && (dump_flags & TDF_DETAILS))
@@ -2506,7 +2457,8 @@ gcn_conditional_register_usage (void)
 
   if (cfun->machine->normal_function)
     {
-      /* Restrict the set of SGPRs and VGPRs used by non-kernel functions.  */
+      /* Restrict the set of SGPRs, VGPRs and AVGPRs used by non-kernel
+	 functions.  */
       for (int i = SGPR_REGNO (MAX_NORMAL_SGPR_COUNT);
 	   i <= LAST_SGPR_REG; i++)
 	fixed_regs[i] = 1, call_used_regs[i] = 1;
@@ -2515,6 +2467,9 @@ gcn_conditional_register_usage (void)
 	   i <= LAST_VGPR_REG; i++)
 	fixed_regs[i] = 1, call_used_regs[i] = 1;
 
+      for (int i = AVGPR_REGNO (MAX_NORMAL_AVGPR_COUNT);
+	   i <= LAST_AVGPR_REG; i++)
+	fixed_regs[i] = 1, call_used_regs[i] = 1;
       return;
     }
 
@@ -2568,6 +2523,16 @@ gcn_conditional_register_usage (void)
     fixed_regs[cfun->machine->args.reg[WORK_ITEM_ID_Z_ARG]] = 1;
 }
 
+static bool
+gcn_vgpr_equivalent_register_operand (rtx x, machine_mode mode)
+{
+  if (gcn_vgpr_register_operand (x, mode))
+    return true;
+  if (TARGET_CDNA2_PLUS && gcn_avgpr_register_operand (x, mode))
+    return true;
+  return false;
+}
+
 /* Determine if a load or store is valid, according to the register classes
    and address space.  Used primarily by the machine description to decide
    when to split a move into two steps.  */
@@ -2576,21 +2541,36 @@ bool
 gcn_valid_move_p (machine_mode mode, rtx dest, rtx src)
 {
   if (!MEM_P (dest) && !MEM_P (src))
-    return true;
+    {
+      if (gcn_vgpr_register_operand (src, mode)
+	  && gcn_avgpr_register_operand (dest, mode))
+	return true;
+      if (gcn_avgpr_register_operand (src, mode)
+	  && gcn_vgpr_register_operand (dest, mode))
+	return true;
+      if (TARGET_CDNA2_PLUS
+	  && gcn_avgpr_register_operand (src, mode)
+	  && gcn_avgpr_register_operand (dest, mode))
+	return true;
+      if (gcn_avgpr_hard_register_operand (src, mode)
+	  || gcn_avgpr_hard_register_operand (dest, mode))
+	return false;
+      return true;
+    }
 
   if (MEM_P (dest)
       && AS_FLAT_P (MEM_ADDR_SPACE (dest))
       && (gcn_flat_address_p (XEXP (dest, 0), mode)
 	  || GET_CODE (XEXP (dest, 0)) == SYMBOL_REF
 	  || GET_CODE (XEXP (dest, 0)) == LABEL_REF)
-      && gcn_vgpr_register_operand (src, mode))
+      && gcn_vgpr_equivalent_register_operand (src, mode))
     return true;
   else if (MEM_P (src)
 	   && AS_FLAT_P (MEM_ADDR_SPACE (src))
 	   && (gcn_flat_address_p (XEXP (src, 0), mode)
 	       || GET_CODE (XEXP (src, 0)) == SYMBOL_REF
 	       || GET_CODE (XEXP (src, 0)) == LABEL_REF)
-	   && gcn_vgpr_register_operand (dest, mode))
+	   && gcn_vgpr_equivalent_register_operand (dest, mode))
     return true;
 
   if (MEM_P (dest)
@@ -2598,14 +2578,14 @@ gcn_valid_move_p (machine_mode mode, rtx dest, rtx src)
       && (gcn_global_address_p (XEXP (dest, 0))
 	  || GET_CODE (XEXP (dest, 0)) == SYMBOL_REF
 	  || GET_CODE (XEXP (dest, 0)) == LABEL_REF)
-      && gcn_vgpr_register_operand (src, mode))
+      && gcn_vgpr_equivalent_register_operand (src, mode))
     return true;
   else if (MEM_P (src)
 	   && AS_GLOBAL_P (MEM_ADDR_SPACE (src))
 	   && (gcn_global_address_p (XEXP (src, 0))
 	       || GET_CODE (XEXP (src, 0)) == SYMBOL_REF
 	       || GET_CODE (XEXP (src, 0)) == LABEL_REF)
-	   && gcn_vgpr_register_operand (dest, mode))
+	   && gcn_vgpr_equivalent_register_operand (dest, mode))
     return true;
 
   if (MEM_P (dest)
@@ -2626,12 +2606,12 @@ gcn_valid_move_p (machine_mode mode, rtx dest, rtx src)
   if (MEM_P (dest)
       && AS_ANY_DS_P (MEM_ADDR_SPACE (dest))
       && gcn_ds_address_p (XEXP (dest, 0))
-      && gcn_vgpr_register_operand (src, mode))
+      && gcn_vgpr_equivalent_register_operand (src, mode))
     return true;
   else if (MEM_P (src)
 	   && AS_ANY_DS_P (MEM_ADDR_SPACE (src))
 	   && gcn_ds_address_p (XEXP (src, 0))
-	   && gcn_vgpr_register_operand (dest, mode))
+	   && gcn_vgpr_equivalent_register_operand (dest, mode))
     return true;
 
   return false;
@@ -3067,7 +3047,8 @@ gcn_compute_frame_offsets (void)
     if ((df_regs_ever_live_p (regno) && !call_used_or_fixed_reg_p (regno))
 	|| ((regno & ~1) == HARD_FRAME_POINTER_REGNUM
 	    && frame_pointer_needed))
-      offsets->callee_saves += (VGPR_REGNO_P (regno) ? 256 : 4);
+      offsets->callee_saves += (VGPR_REGNO_P (regno)
+			       	|| AVGPR_REGNO_P (regno) ? 256 : 4);
 
   /* Round up to 64-bit boundary to maintain stack alignment.  */
   offsets->callee_saves = (offsets->callee_saves + 7) & ~7;
@@ -4010,6 +3991,11 @@ gcn_memory_move_cost (machine_mode mode, reg_class_t regclass, bool in)
       if (in)
 	return (LOAD_COST + 2) * nregs;
       return STORE_COST * nregs;
+    case AVGPR_REGS:
+    case ALL_VGPR_REGS:
+      if (in)
+	return (LOAD_COST + (TARGET_CDNA2_PLUS ? 2 : 4)) * nregs;
+      return (STORE_COST + (TARGET_CDNA2_PLUS ? 0 : 2)) * nregs;
     case ALL_REGS:
     case ALL_GPR_REGS:
     case SRCDST_REGS:
@@ -4029,6 +4015,15 @@ gcn_memory_move_cost (machine_mode mode, reg_class_t regclass, bool in)
 static int
 gcn_register_move_cost (machine_mode, reg_class_t dst, reg_class_t src)
 {
+  if (src == AVGPR_REGS)
+    {
+      if (dst == AVGPR_REGS)
+	return TARGET_CDNA1 ? 6 : 2;
+      if (dst != VGPR_REGS)
+	return 6;
+    }
+  if (dst == AVGPR_REGS && src != VGPR_REGS)
+    return 6;
   /* Increase cost of moving from and to vector registers.  While this is
      fast in hardware (I think), it has hidden cost of setting up the exec
      flags.  */
@@ -5735,6 +5730,7 @@ gcn_vmem_insn_p (attr_type type)
     case TYPE_MUBUF:
     case TYPE_MTBUF:
     case TYPE_FLAT:
+    case TYPE_VOP3P_MAI:
       return true;
     case TYPE_UNKNOWN:
     case TYPE_SOP1:
@@ -5974,7 +5970,8 @@ gcn_md_reorg (void)
 		FOR_EACH_SUBRTX (iter, array, PATTERN (insn), NONCONST)
 		  {
 		    const_rtx x = *iter;
-		    if (REG_P (x) && VGPR_REGNO_P (REGNO (x)))
+		    if (REG_P (x) && (VGPR_REGNO_P (REGNO (x))
+				      || AVGPR_REGNO_P (REGNO (x))))
 		      {
 			if (VECTOR_MODE_P (GET_MODE (x)))
 			  {
@@ -6130,17 +6127,16 @@ gcn_md_reorg (void)
 	  if (!prev_insn->insn)
 	    continue;
 
+	  HARD_REG_SET depregs = prev_insn->writes & ireads;
+
 	  /* VALU writes SGPR followed by VMEM reading the same SGPR
 	     requires 5 wait states.  */
 	  if ((prev_insn->age + nops_rqd) < 5
 	      && prev_insn->unit == UNIT_VECTOR
-	      && gcn_vmem_insn_p (itype))
-	    {
-	      HARD_REG_SET regs = prev_insn->writes & ireads;
-	      if (hard_reg_set_intersect_p
-		  (regs, reg_class_contents[(int) SGPR_REGS]))
-		nops_rqd = 5 - prev_insn->age;
-	    }
+	      && gcn_vmem_insn_p (itype)
+	      && hard_reg_set_intersect_p
+		   (depregs, reg_class_contents[(int) SGPR_REGS]))
+	    nops_rqd = 5 - prev_insn->age;
 
 	  /* VALU sets VCC/EXEC followed by VALU uses VCCZ/EXECZ
 	     requires 5 wait states.  */
@@ -6162,15 +6158,12 @@ gcn_md_reorg (void)
 	     SGPR/VCC as lane select requires 4 wait states.  */
 	  if ((prev_insn->age + nops_rqd) < 4
 	      && prev_insn->unit == UNIT_VECTOR
-	      && get_attr_laneselect (insn) == LANESELECT_YES)
-	    {
-	      HARD_REG_SET regs = prev_insn->writes & ireads;
-	      if (hard_reg_set_intersect_p
-		  (regs, reg_class_contents[(int) SGPR_REGS])
+	      && get_attr_laneselect (insn) == LANESELECT_YES
+	      && (hard_reg_set_intersect_p
+		    (depregs, reg_class_contents[(int) SGPR_REGS])
 		  || hard_reg_set_intersect_p
-		     (regs, reg_class_contents[(int) VCC_CONDITIONAL_REG]))
-		nops_rqd = 4 - prev_insn->age;
-	    }
+		       (depregs, reg_class_contents[(int) VCC_CONDITIONAL_REG])))
+	    nops_rqd = 4 - prev_insn->age;
 
 	  /* VALU writes VGPR followed by VALU_DPP reading that VGPR
 	     requires 2 wait states.  */
@@ -6178,9 +6171,8 @@ gcn_md_reorg (void)
 	      && prev_insn->unit == UNIT_VECTOR
 	      && itype == TYPE_VOP_DPP)
 	    {
-	      HARD_REG_SET regs = prev_insn->writes & ireads;
 	      if (hard_reg_set_intersect_p
-		  (regs, reg_class_contents[(int) VGPR_REGS]))
+		  (depregs, reg_class_contents[(int) VGPR_REGS]))
 		nops_rqd = 2 - prev_insn->age;
 	    }
 
@@ -6199,6 +6191,35 @@ gcn_md_reorg (void)
 		  (prev_insn->writes,
 		   reg_class_contents[(int)VCC_CONDITIONAL_REG])))
 	    nops_rqd = ivccwait - prev_insn->age;
+
+	  /* CDNA1: write VGPR before v_accvgpr_write reads it.  */
+	  if (TARGET_CDNA1
+	      && (prev_insn->age + nops_rqd) < 2
+	      && hard_reg_set_intersect_p
+		  (depregs, reg_class_contents[(int) VGPR_REGS])
+	      && hard_reg_set_intersect_p
+		  (iwrites, reg_class_contents[(int) AVGPR_REGS]))
+	    nops_rqd = 2 - prev_insn->age;
+
+	  /* CDNA1: v_accvgpr_write writes AVGPR before v_accvgpr_read.  */
+	  if (TARGET_CDNA1
+	      && (prev_insn->age + nops_rqd) < 3
+	      && hard_reg_set_intersect_p
+		  (depregs, reg_class_contents[(int) AVGPR_REGS])
+	      && hard_reg_set_intersect_p
+		  (iwrites, reg_class_contents[(int) VGPR_REGS]))
+	    nops_rqd = 3 - prev_insn->age;
+
+	  /* CDNA1: Undocumented(?!) read-after-write when restoring values
+	     from AVGPRs to VGPRS.  Observed problem was for address register
+	     of flat_load instruction, but others may be affected?  */
+	  if (TARGET_CDNA1
+	      && (prev_insn->age + nops_rqd) < 2
+	      && hard_reg_set_intersect_p
+		   (prev_insn->reads, reg_class_contents[(int) AVGPR_REGS])
+	      && hard_reg_set_intersect_p
+		   (depregs, reg_class_contents[(int) VGPR_REGS]))
+	    nops_rqd = 2 - prev_insn->age;
 	}
 
       /* Insert the required number of NOPs.  */
@@ -6490,7 +6511,7 @@ output_file_start (void)
 void
 gcn_hsa_declare_function_name (FILE *file, const char *name, tree)
 {
-  int sgpr, vgpr;
+  int sgpr, vgpr, avgpr;
   bool xnack_enabled = TARGET_XNACK;
 
   fputs ("\n\n", file);
@@ -6515,6 +6536,12 @@ gcn_hsa_declare_function_name (FILE *file, const char *name, tree)
     if (df_regs_ever_live_p (FIRST_VGPR_REG + vgpr))
       break;
   vgpr++;
+  for (avgpr = 255; avgpr >= 0; avgpr--)
+    if (df_regs_ever_live_p (FIRST_AVGPR_REG + avgpr))
+      break;
+  avgpr++;
+  vgpr = (vgpr + 3) & ~3;
+  avgpr = (avgpr + 3) & ~3;
 
   if (!leaf_function_p ())
     {
@@ -6523,6 +6550,8 @@ gcn_hsa_declare_function_name (FILE *file, const char *name, tree)
 	vgpr = MAX_NORMAL_VGPR_COUNT;
       if (sgpr < MAX_NORMAL_SGPR_COUNT)
 	sgpr = MAX_NORMAL_SGPR_COUNT;
+      if (avgpr < MAX_NORMAL_AVGPR_COUNT)
+	avgpr = MAX_NORMAL_AVGPR_COUNT;
     }
 
   /* The gfx90a accum_offset field can't represent 0 registers.  */
@@ -6580,6 +6609,11 @@ gcn_hsa_declare_function_name (FILE *file, const char *name, tree)
 	   ? 2
 	   : cfun->machine->args.requested & (1 << WORK_ITEM_ID_Y_ARG)
 	   ? 1 : 0);
+  int next_free_vgpr = vgpr;
+  if (TARGET_CDNA1 && avgpr > vgpr)
+    next_free_vgpr = avgpr;
+  if (TARGET_CDNA2_PLUS)
+    next_free_vgpr += avgpr;
   fprintf (file,
 	   "\t  .amdhsa_next_free_vgpr\t%i\n"
 	   "\t  .amdhsa_next_free_sgpr\t%i\n"
@@ -6590,7 +6624,7 @@ gcn_hsa_declare_function_name (FILE *file, const char *name, tree)
 	   "\t  .amdhsa_group_segment_fixed_size\t%u\n"
 	   "\t  .amdhsa_float_denorm_mode_32\t3\n"
 	   "\t  .amdhsa_float_denorm_mode_16_64\t3\n",
-	   vgpr,
+	   next_free_vgpr,
 	   sgpr,
 	   xnack_enabled,
 	   LDS_SIZE);
@@ -6598,7 +6632,7 @@ gcn_hsa_declare_function_name (FILE *file, const char *name, tree)
     fprintf (file,
 	     "\t  .amdhsa_accum_offset\t%i\n"
 	     "\t  .amdhsa_tg_split\t0\n",
-	     (vgpr+3)&~3); // I think this means the AGPRs come after the VGPRs
+	     vgpr); /* The AGPRs come after the VGPRs.  */
   fputs ("\t.end_amdhsa_kernel\n", file);
 
 #if 1
@@ -6625,9 +6659,9 @@ gcn_hsa_declare_function_name (FILE *file, const char *name, tree)
 	   cfun->machine->kernarg_segment_byte_size,
 	   cfun->machine->kernarg_segment_alignment,
 	   LDS_SIZE,
-	   sgpr, vgpr);
-  if (gcn_arch == PROCESSOR_GFX90a)
-    fprintf (file, "            .agpr_count: 0\n"); // AGPRs are not used, yet
+	   sgpr, next_free_vgpr);
+  if (gcn_arch == PROCESSOR_GFX90a || gcn_arch == PROCESSOR_GFX908)
+    fprintf (file, "            .agpr_count: %i\n", avgpr);
   fputs ("        .end_amdgpu_metadata\n", file);
 #endif
 
@@ -6723,6 +6757,9 @@ print_reg (FILE *file, rtx x)
       else if (VGPR_REGNO_P (REGNO (x)))
 	fprintf (file, "v[%i:%i]", REGNO (x) - FIRST_VGPR_REG,
 		 REGNO (x) - FIRST_VGPR_REG + 1);
+      else if (AVGPR_REGNO_P (REGNO (x)))
+	fprintf (file, "a[%i:%i]", REGNO (x) - FIRST_AVGPR_REG,
+		 REGNO (x) - FIRST_AVGPR_REG + 1);
       else if (REGNO (x) == FLAT_SCRATCH_REG)
 	fprintf (file, "flat_scratch");
       else if (REGNO (x) == EXEC_REG)
@@ -6741,6 +6778,9 @@ print_reg (FILE *file, rtx x)
       else if (VGPR_REGNO_P (REGNO (x)))
 	fprintf (file, "v[%i:%i]", REGNO (x) - FIRST_VGPR_REG,
 		 REGNO (x) - FIRST_VGPR_REG + 3);
+      else if (AVGPR_REGNO_P (REGNO (x)))
+	fprintf (file, "a[%i:%i]", REGNO (x) - FIRST_AVGPR_REG,
+		 REGNO (x) - FIRST_AVGPR_REG + 3);
       else
 	gcc_unreachable ();
     }
@@ -7664,6 +7704,8 @@ gcn_dwarf_register_number (unsigned int regno)
     }
   else if (VGPR_REGNO_P (regno))
     return (regno - FIRST_VGPR_REG + 2560);
+  else if (AVGPR_REGNO_P (regno))
+    return (regno - FIRST_AVGPR_REG + 3072);
 
   /* Otherwise, there's nothing sensible to do.  */
   return regno + 100000;
diff --git a/gcc/config/gcn/gcn.h b/gcc/config/gcn/gcn.h
index 6372f49..cb52be7 100644
--- a/gcc/config/gcn/gcn.h
+++ b/gcc/config/gcn/gcn.h
@@ -146,6 +146,9 @@
 #define FIRST_VGPR_REG	    160
 #define VGPR_REGNO(N)	    ((N)+FIRST_VGPR_REG)
 #define LAST_VGPR_REG	    415
+#define FIRST_AVGPR_REG     416
+#define AVGPR_REGNO(N)      ((N)+FIRST_AVGPR_REG)
+#define LAST_AVGPR_REG      671
 
 /* Frame Registers, and other registers */
 
@@ -157,10 +160,10 @@
 #define RETURN_VALUE_REG	  168	/* Must be divisible by 4.  */
 #define STATIC_CHAIN_REGNUM	  30
 #define WORK_ITEM_ID_Z_REG	  162
-#define SOFT_ARG_REG		  416
-#define FRAME_POINTER_REGNUM	  418
-#define DWARF_LINK_REGISTER	  420
-#define FIRST_PSEUDO_REGISTER	  421
+#define SOFT_ARG_REG		  672
+#define FRAME_POINTER_REGNUM	  674
+#define DWARF_LINK_REGISTER	  676
+#define FIRST_PSEUDO_REGISTER	  677
 
 #define FIRST_PARM_REG (FIRST_SGPR_REG + 24)
 #define FIRST_VPARM_REG (FIRST_VGPR_REG + 8)
@@ -176,6 +179,7 @@
 #define SGPR_OR_VGPR_REGNO_P(N) ((N)>=FIRST_VGPR_REG && (N) <= LAST_SGPR_REG)
 #define SGPR_REGNO_P(N)		((N) <= LAST_SGPR_REG)
 #define VGPR_REGNO_P(N)		((N)>=FIRST_VGPR_REG && (N) <= LAST_VGPR_REG)
+#define AVGPR_REGNO_P(N)        ((N)>=FIRST_AVGPR_REG && (N) <= LAST_AVGPR_REG)
 #define SSRC_REGNO_P(N)		((N) <= SCC_REG && (N) != VCCZ_REG)
 #define SDST_REGNO_P(N)		((N) <= EXEC_HI_REG && (N) != VCCZ_REG)
 #define CC_REG_P(X)		(REG_P (X) && CC_REGNO_P (REGNO (X)))
@@ -206,7 +210,7 @@
     1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, \
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1,		    \
-    /* VGRPs */					    \
+    /* VGPRs */					    \
     0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
@@ -223,6 +227,23 @@
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
+    /* Accumulation VGPRs */			    \
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
     /* Other registers.  */			    \
     1, 1, 1, 1, 1				    \
 }
@@ -244,7 +265,7 @@
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1,		    \
-    /* VGRPs */					    \
+    /* VGPRs */					    \
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
@@ -261,6 +282,23 @@
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
+    /* Accumulation VGPRs */			    \
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
     /* Other registers.  */			    \
     1, 1, 1, 1, 1				    \
 }
@@ -320,6 +358,8 @@ enum reg_class
   SGPR_SRC_REGS,
   GENERAL_REGS,
   VGPR_REGS,
+  AVGPR_REGS,
+  ALL_VGPR_REGS,
   ALL_GPR_REGS,
   SRCDST_REGS,
   AFP_REGS,
@@ -345,6 +385,8 @@ enum reg_class
    "SGPR_SRC_REGS",	    \
    "GENERAL_REGS",	    \
    "VGPR_REGS",		    \
+   "AVGPR_REGS",	    \
+   "ALL_VGPR_REGS",	    \
    "ALL_GPR_REGS",	    \
    "SRCDST_REGS",	    \
    "AFP_REGS",		    \
@@ -358,39 +400,57 @@ enum reg_class
     /* NO_REGS.  */							   \
     {0, 0, 0, 0,							   \
      0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
      0, 0, 0, 0, 0, 0},							   \
     /* SCC_CONDITIONAL_REG.  */						   \
     {0, 0, 0, 0,							   \
      NAMED_REG_MASK2 (SCC_REG), 0, 0, 0,				   \
-     0, 0, 0, 0, 0},							   \
+     0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
+     0, 0, 0, 0, 0, 0},							   \
     /* VCCZ_CONDITIONAL_REG.  */					   \
     {0, 0, 0, NAMED_REG_MASK (VCCZ_REG),				   \
      0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
      0, 0, 0, 0, 0, 0},							   \
     /* VCC_CONDITIONAL_REG.  */						   \
     {0, 0, 0, NAMED_REG_MASK (VCC_LO_REG)|NAMED_REG_MASK (VCC_HI_REG),	   \
      0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
      0, 0, 0, 0, 0, 0},							   \
     /* EXECZ_CONDITIONAL_REG.  */					   \
     {0, 0, 0, 0,							   \
      NAMED_REG_MASK2 (EXECZ_REG), 0, 0, 0,				   \
-     0, 0, 0, 0, 0},							   \
+     0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
+     0, 0, 0, 0, 0, 0},							   \
     /* ALL_CONDITIONAL_REGS.  */					   \
     {0, 0, 0, NAMED_REG_MASK (VCCZ_REG),				   \
      NAMED_REG_MASK2 (EXECZ_REG) | NAMED_REG_MASK2 (SCC_REG), 0, 0, 0,	   \
+     0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
      0, 0, 0, 0, 0, 0},							   \
     /* EXEC_MASK_REG.  */						   \
     {0, 0, 0, NAMED_REG_MASK (EXEC_LO_REG) | NAMED_REG_MASK (EXEC_HI_REG), \
      0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
      0, 0, 0, 0, 0, 0},							   \
     /* SGPR_REGS.  */							   \
     {0xffffffff, 0xffffffff, 0xffffffff, 0xf1,				   \
      0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
      0, 0, 0, 0, 0, 0},							   \
     /* SGPR_EXEC_REGS.	*/						   \
     {0xffffffff, 0xffffffff, 0xffffffff,				   \
       0xf1 | NAMED_REG_MASK (EXEC_LO_REG) | NAMED_REG_MASK (EXEC_HI_REG),  \
      0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
      0, 0, 0, 0, 0, 0},							   \
     /* SGPR_VOP_SRC_REGS.  */						   \
     {0xffffffff, 0xffffffff, 0xffffffff,				   \
@@ -398,12 +458,16 @@ enum reg_class
        -NAMED_REG_MASK (EXEC_LO_REG)					   \
        -NAMED_REG_MASK (EXEC_HI_REG),					   \
      NAMED_REG_MASK2 (SCC_REG), 0, 0, 0,				   \
+     0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
      0, 0, 0, 0, 0, 0},							   \
     /* SGPR_MEM_SRC_REGS.  */						   \
     {0xffffffff, 0xffffffff, 0xffffffff,				   \
      0xffffffff-NAMED_REG_MASK (VCCZ_REG)-NAMED_REG_MASK (M0_REG)	   \
      -NAMED_REG_MASK (EXEC_LO_REG)-NAMED_REG_MASK (EXEC_HI_REG),	   \
      0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
      0, 0, 0, 0, 0, 0},							   \
     /* SGPR_DST_REGS.  */						   \
     {0xffffffff, 0xffffffff, 0xffffffff,				   \
@@ -413,31 +477,57 @@ enum reg_class
     /* SGPR_SRC_REGS.  */						   \
     {0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,			   \
      NAMED_REG_MASK2 (EXECZ_REG) | NAMED_REG_MASK2 (SCC_REG), 0, 0, 0,	   \
+     0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
      0, 0, 0, 0, 0, 0},							   \
     /* GENERAL_REGS.  */						   \
     {0xffffffff, 0xffffffff, 0xffffffff, 0xf1,				   \
      0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
      0, 0, 0, 0, 0, 0},							   \
     /* VGPR_REGS.  */							   \
     {0, 0, 0, 0,							   \
      0,		 0xffffffff, 0xffffffff, 0xffffffff,			   \
+     0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,			   \
+     0xffffffff, 0, 0, 0,						   \
+     0, 0, 0, 0, 0, 0},							   \
+    /* AVGPR_REGS.  */							   \
+    {0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
+     0,		 0xffffffff, 0xffffffff, 0xffffffff,			   \
+     0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0},	   \
+    /* ALL_VGPR_REGS.  */						   \
+    {0, 0, 0, 0,							   \
+     0,          0xffffffff, 0xffffffff, 0xffffffff,			   \
+     0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,			   \
+     0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,			   \
      0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0},	   \
     /* ALL_GPR_REGS.  */						   \
     {0xffffffff, 0xffffffff, 0xffffffff, 0xf1,				   \
      0,		 0xffffffff, 0xffffffff, 0xffffffff,			   \
-     0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0},	   \
+     0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,			   \
+     0xffffffff, 0, 0, 0,						   \
+     0, 0, 0, 0, 0, 0},							   \
     /* SRCDST_REGS.  */							   \
     {0xffffffff, 0xffffffff, 0xffffffff,				   \
      0xffffffff-NAMED_REG_MASK (VCCZ_REG),				   \
      0,		 0xffffffff, 0xffffffff, 0xffffffff,			   \
-     0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0},	   \
+     0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,			   \
+     0xffffffff, 0, 0, 0,						   \
+     0, 0, 0, 0, 0, 0},							   \
     /* AFP_REGS.  */							   \
     {0, 0, 0, 0,							   \
      0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
+     0, 0, 0, 0,							   \
      0, 0, 0, 0, 0, 0xf},						   \
     /* ALL_REGS.  */							   \
     {0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,			   \
      0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,			   \
+     0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,			   \
+     0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,			   \
      0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0 }}
 
 #define REGNO_REG_CLASS(REGNO) gcn_regno_reg_class (REGNO)
@@ -541,6 +631,34 @@ enum gcn_address_spaces
     "v236", "v237", "v238", "v239", "v240", "v241", "v242", "v243", "v244", \
     "v245", "v246", "v247", "v248", "v249", "v250", "v251", "v252", "v253", \
     "v254", "v255",							    \
+    "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8", "a9", "a10",	    \
+    "a11", "a12", "a13", "a14", "a15", "a16", "a17", "a18", "a19", "a20",   \
+    "a21", "a22", "a23", "a24", "a25", "a26", "a27", "a28", "a29", "a30",   \
+    "a31", "a32", "a33", "a34", "a35", "a36", "a37", "a38", "a39", "a40",   \
+    "a41", "a42", "a43", "a44", "a45", "a46", "a47", "a48", "a49", "a50",   \
+    "a51", "a52", "a53", "a54", "a55", "a56", "a57", "a58", "a59", "a60",   \
+    "a61", "a62", "a63", "a64", "a65", "a66", "a67", "a68", "a69", "a70",   \
+    "a71", "a72", "a73", "a74", "a75", "a76", "a77", "a78", "a79", "a80",   \
+    "a81", "a82", "a83", "a84", "a85", "a86", "a87", "a88", "a89", "a90",   \
+    "a91", "a92", "a93", "a94", "a95", "a96", "a97", "a98", "a99", "a100",  \
+    "a101", "a102", "a103", "a104", "a105", "a106", "a107", "a108", "a109", \
+    "a110", "a111", "a112", "a113", "a114", "a115", "a116", "a117", "a118", \
+    "a119", "a120", "a121", "a122", "a123", "a124", "a125", "a126", "a127", \
+    "a128", "a129", "a130", "a131", "a132", "a133", "a134", "a135", "a136", \
+    "a137", "a138", "a139", "a140", "a141", "a142", "a143", "a144", "a145", \
+    "a146", "a147", "a148", "a149", "a150", "a151", "a152", "a153", "a154", \
+    "a155", "a156", "a157", "a158", "a159", "a160", "a161", "a162", "a163", \
+    "a164", "a165", "a166", "a167", "a168", "a169", "a170", "a171", "a172", \
+    "a173", "a174", "a175", "a176", "a177", "a178", "a179", "a180", "a181", \
+    "a182", "a183", "a184", "a185", "a186", "a187", "a188", "a189", "a190", \
+    "a191", "a192", "a193", "a194", "a195", "a196", "a197", "a198", "a199", \
+    "a200", "a201", "a202", "a203", "a204", "a205", "a206", "a207", "a208", \
+    "a209", "a210", "a211", "a212", "a213", "a214", "a215", "a216", "a217", \
+    "a218", "a219", "a220", "a221", "a222", "a223", "a224", "a225", "a226", \
+    "a227", "a228", "a229", "a230", "a231", "a232", "a233", "a234", "a235", \
+    "a236", "a237", "a238", "a239", "a240", "a241", "a242", "a243", "a244", \
+    "a245", "a246", "a247", "a248", "a249", "a250", "a251", "a252", "a253", \
+    "a254", "a255",							    \
     "?ap0", "?ap1", "?fp0", "?fp1", "?dwlr" }
 
 #define PRINT_OPERAND(FILE, X, CODE)  print_operand(FILE, X, CODE)
diff --git a/gcc/config/gcn/gcn.md b/gcc/config/gcn/gcn.md
index e6a9ac6..b7fbbaf 100644
--- a/gcc/config/gcn/gcn.md
+++ b/gcc/config/gcn/gcn.md
@@ -51,13 +51,15 @@
    (EXECZ_REG			 128)
    (SCC_REG			 129)
    (FIRST_VGPR_REG		 160)
-   (LAST_VGPR_REG		 415)])
+   (LAST_VGPR_REG		 415)
+   (FIRST_AVGPR_REG		 416)
+   (LAST_AVGPR_REG		 671)])
 
 (define_constants
   [(SP_REGNUM 16)
    (LR_REGNUM 18)
-   (AP_REGNUM 416)
-   (FP_REGNUM 418)])
+   (AP_REGNUM 672)
+   (FP_REGNUM 674)])
 
 (define_c_enum "unspecv" [
   UNSPECV_PROLOGUE_USE
@@ -171,6 +173,11 @@
 ;	 vdst: vgpr0-255
 ;	 sdst: sgpr0-103/vcc/tba/tma/ttmp0-11
 ;
+; vop3p_mai - vector, three inputs, one vector output
+;        vsrc0,vsrc1,vsrc2: inline constant -16 to -64, fp inline immediate,
+;        (acc or arch) vgpr0-255
+;        vdst: (acc or arch) vgpr0-255
+;
 ; vop_sdwa - second dword for vop1/vop2/vopc for specifying sub-dword address
 ;	 src0: vgpr0-255
 ;	 dst_sel: BYTE_0-3, WORD_0-1, DWORD
@@ -229,7 +236,8 @@
 
 (define_attr "type"
 	     "unknown,sop1,sop2,sopk,sopc,sopp,smem,ds,vop2,vop1,vopc,
-	      vop3a,vop3b,vop_sdwa,vop_dpp,mubuf,mtbuf,flat,mult,vmult"
+	      vop3a,vop3b,vop3p_mai,vop_sdwa,vop_dpp,mubuf,mtbuf,flat,mult,
+	      vmult"
 	     (const_string "unknown"))
 
 ; Set if instruction is executed in scalar or vector unit
@@ -237,7 +245,7 @@
 (define_attr "unit" "unknown,scalar,vector"
   (cond [(eq_attr "type" "sop1,sop2,sopk,sopc,sopp,smem,mult")
 	    (const_string "scalar")
-	 (eq_attr "type" "vop2,vop1,vopc,vop3a,vop3b,ds,
+	 (eq_attr "type" "vop2,vop1,vopc,vop3a,vop3b,ds,vop3p_mai,
 			  vop_sdwa,vop_dpp,flat,vmult")
 	    (const_string "vector")]
 	 (const_string "unknown")))
@@ -284,7 +292,7 @@
 
 ; Disable alternatives that only apply to specific ISA variants.
 
-(define_attr "gcn_version" "gcn3,gcn5" (const_string "gcn3"))
+(define_attr "gcn_version" "gcn3,gcn5,cdna2" (const_string "gcn3"))
 (define_attr "rdna" "any,no,yes" (const_string "any"))
 
 (define_attr "enabled" ""
@@ -297,6 +305,9 @@
 	 (eq_attr "gcn_version" "gcn3") (const_int 1)
 	 (and (eq_attr "gcn_version" "gcn5")
 	      (ne (symbol_ref "TARGET_GCN5_PLUS") (const_int 0)))
+	   (const_int 1)
+	 (and (eq_attr "gcn_version" "cdna2")
+	      (ne (symbol_ref "TARGET_CDNA2_PLUS") (const_int 0)))
 	   (const_int 1)]
 	(const_int 0)))
 
@@ -552,25 +563,32 @@
   [(set (match_operand:SISF 0 "nonimmediate_operand")
 	(match_operand:SISF 1 "gcn_load_operand"))]
   ""
-  {@ [cons: =0, 1; attrs: type, exec, length]
-   [SD  ,SSA ;sop1 ,*   ,4 ] s_mov_b32\t%0, %1
-   [SD  ,J   ;sopk ,*   ,4 ] s_movk_i32\t%0, %1
-   [SD  ,B   ;sop1 ,*   ,8 ] s_mov_b32\t%0, %1
-   [SD  ,RB  ;smem ,*   ,12] s_buffer_load%s0\t%0, s[0:3], %1\;s_waitcnt\tlgkmcnt(0)
-   [RB  ,Sm  ;smem ,*   ,12] s_buffer_store%s1\t%1, s[0:3], %0
-   [Sm  ,RS  ;smem ,*   ,12] s_load_dword\t%0, %A1\;s_waitcnt\tlgkmcnt(0)
-   [RS  ,Sm  ;smem ,*   ,12] s_store_dword\t%1, %A0
-   [v   ,v   ;vop1 ,*   ,4 ] v_mov_b32\t%0, %1
-   [Sg  ,v   ;vop3a,none,8 ] v_readlane_b32\t%0, %1, 0
-   [v   ,Sv  ;vop3a,none,8 ] v_writelane_b32\t%0, %1, 0
-   [v   ,RF  ;flat ,*   ,12] flat_load_dword\t%0, %A1%O1%g1\;s_waitcnt\t0
-   [RF  ,v   ;flat ,*   ,12] flat_store_dword\t%A0, %1%O0%g0
-   [v   ,B   ;vop1 ,*   ,8 ] v_mov_b32\t%0, %1
-   [RLRG,v   ;ds   ,*   ,12] ds_write_b32\t%A0, %1%O0\;s_waitcnt\tlgkmcnt(0)
-   [v   ,RLRG;ds   ,*   ,12] ds_read_b32\t%0, %A1%O1\;s_waitcnt\tlgkmcnt(0)
-   [SD  ,Y   ;sop1 ,*   ,8 ] s_mov_b32\t%0, %1
-   [v   ,RM  ;flat ,*   ,12] global_load_dword\t%0, %A1%O1%g1\;s_waitcnt\tvmcnt(0)
-   [RM  ,v   ;flat ,*   ,12] global_store_dword\t%A0, %1%O0%g0
+  {@ [cons: =0, 1; attrs: type, exec, length, gcn_version]
+   [SD  ,SSA ;sop1 ,*   ,4 ,*    ] s_mov_b32\t%0, %1
+   [SD  ,J   ;sopk ,*   ,4 ,*    ] s_movk_i32\t%0, %1
+   [SD  ,B   ;sop1 ,*   ,8 ,*    ] s_mov_b32\t%0, %1
+   [SD  ,RB  ;smem ,*   ,12,*    ] s_buffer_load%s0\t%0, s[0:3], %1\;s_waitcnt\tlgkmcnt(0)
+   [RB  ,Sm  ;smem ,*   ,12,*    ] s_buffer_store%s1\t%1, s[0:3], %0
+   [Sm  ,RS  ;smem ,*   ,12,*    ] s_load_dword\t%0, %A1\;s_waitcnt\tlgkmcnt(0)
+   [RS  ,Sm  ;smem ,*   ,12,*    ] s_store_dword\t%1, %A0
+   [v   ,v   ;vop1 ,*   ,4 ,*    ] v_mov_b32\t%0, %1
+   [Sg  ,v   ;vop3a,none,8 ,*    ] v_readlane_b32\t%0, %1, 0
+   [v   ,Sv  ;vop3a,none,8 ,*    ] v_writelane_b32\t%0, %1, 0
+   [v   ,^a  ;vop3p_mai,*,8,*    ] v_accvgpr_read_b32\t%0, %1
+   [a   ,v   ;vop3p_mai,*,8,*    ] v_accvgpr_write_b32\t%0, %1
+   [a   ,a   ;vop1 ,*    ,4,cdna2] v_accvgpr_mov_b32\t%0, %1
+   [v   ,RF  ;flat ,*   ,12,*    ] flat_load_dword\t%0, %A1%O1%g1\;s_waitcnt\t0
+   [^a  ,RF  ;flat ,*   ,12,cdna2] ^
+   [RF  ,v   ;flat ,*   ,12,*    ] flat_store_dword\t%A0, %1%O0%g0
+   [RF  ,a   ;flat ,*   ,12,cdna2] ^
+   [v   ,B   ;vop1 ,*   ,8 ,*    ] v_mov_b32\t%0, %1
+   [RLRG,v   ;ds   ,*   ,12,*    ] ds_write_b32\t%A0, %1%O0\;s_waitcnt\tlgkmcnt(0)
+   [v   ,RLRG;ds   ,*   ,12,*    ] ds_read_b32\t%0, %A1%O1\;s_waitcnt\tlgkmcnt(0)
+   [SD  ,Y   ;sop1 ,*   ,8 ,*    ] s_mov_b32\t%0, %1
+   [v   ,RM  ;flat ,*   ,12,*    ] global_load_dword\t%0, %A1%O1%g1\;s_waitcnt\tvmcnt(0)
+   [^a  ,RM  ;flat ,*   ,12,cdna2] ^
+   [RM  ,v   ;flat ,*   ,12,*    ] global_store_dword\t%A0, %1%O0%g0
+   [RM  ,a   ;flat ,*   ,12,cdna2] ^
   })
 
 ; 8/16bit move pattern
@@ -580,20 +598,27 @@
   [(set (match_operand:QIHI 0 "nonimmediate_operand")
 	(match_operand:QIHI 1 "gcn_load_operand"))]
   "gcn_valid_move_p (<MODE>mode, operands[0], operands[1])"
-  {@ [cons: =0, 1; attrs: type, exec, length]
-  [SD  ,SSA ;sop1 ,*   ,4 ] s_mov_b32\t%0, %1
-  [SD  ,J   ;sopk ,*   ,4 ] s_movk_i32\t%0, %1
-  [SD  ,B   ;sop1 ,*   ,8 ] s_mov_b32\t%0, %1
-  [v   ,v   ;vop1 ,*   ,4 ] v_mov_b32\t%0, %1
-  [Sg  ,v   ;vop3a,none,4 ] v_readlane_b32\t%0, %1, 0
-  [v   ,Sv  ;vop3a,none,4 ] v_writelane_b32\t%0, %1, 0
-  [v   ,RF  ;flat ,*   ,12] flat_load%o1\t%0, %A1%O1%g1\;s_waitcnt\t0
-  [RF  ,v   ;flat ,*   ,12] flat_store%s0\t%A0, %1%O0%g0
-  [v   ,B   ;vop1 ,*   ,8 ] v_mov_b32\t%0, %1
-  [RLRG,v   ;ds   ,*   ,12] ds_write%b0\t%A0, %1%O0\;s_waitcnt\tlgkmcnt(0)
-  [v   ,RLRG;ds   ,*   ,12] ds_read%u1\t%0, %A1%O1\;s_waitcnt\tlgkmcnt(0)
-  [v   ,RM  ;flat ,*   ,12] global_load%o1\t%0, %A1%O1%g1\;s_waitcnt\tvmcnt(0)
-  [RM  ,v   ;flat ,*   ,12] global_store%s0\t%A0, %1%O0%g0
+  {@ [cons: =0, 1; attrs: type, exec, length, gcn_version]
+  [SD  ,SSA ;sop1 ,*   ,4 ,*    ] s_mov_b32\t%0, %1
+  [SD  ,J   ;sopk ,*   ,4 ,*    ] s_movk_i32\t%0, %1
+  [SD  ,B   ;sop1 ,*   ,8 ,*    ] s_mov_b32\t%0, %1
+  [v   ,v   ;vop1 ,*   ,4 ,*    ] v_mov_b32\t%0, %1
+  [Sg  ,v   ;vop3a,none,4 ,*    ] v_readlane_b32\t%0, %1, 0
+  [v   ,Sv  ;vop3a,none,4 ,*    ] v_writelane_b32\t%0, %1, 0
+  [v   ,^a  ;vop3p_mai,*,8,*    ] v_accvgpr_read_b32\t%0, %1
+  [a   ,v   ;vop3p_mai,*,8,*    ] v_accvgpr_write_b32\t%0, %1
+  [a   ,a   ;vop1 ,*    ,8,cdna2] v_accvgpr_mov_b32\t%0, %1
+  [v    ,RF ;flat ,*   ,12,*    ] flat_load%o1\t%0, %A1%O1%g1\;s_waitcnt\t0
+  [^a   ,RF ;flat ,*   ,12,cdna2] ^
+  [RF  ,v   ;flat ,*   ,12,*    ] flat_store%s0\t%A0, %1%O0%g0
+  [RF  ,a   ;flat ,*   ,12,cdna2] ^
+  [v   ,B   ;vop1 ,*   ,8 ,*    ] v_mov_b32\t%0, %1
+  [RLRG,v   ;ds   ,*   ,12,*    ] ds_write%b0\t%A0, %1%O0\;s_waitcnt\tlgkmcnt(0)
+  [v   ,RLRG;ds   ,*   ,12,*    ] ds_read%u1\t%0, %A1%O1\;s_waitcnt\tlgkmcnt(0)
+  [v   ,RM  ;flat ,*   ,12,*    ] global_load%o1\t%0, %A1%O1%g1\;s_waitcnt\tvmcnt(0)
+  [^a  ,RM  ;flat ,*   ,12,cdna2] ^
+  [RM  ,v   ;flat ,*   ,12,*    ] global_store%s0\t%A0, %1%O0%g0
+  [RM  ,a   ;flat ,*   ,12,cdna2] ^
   })
 
 ; 64bit move pattern
@@ -602,22 +627,29 @@
   [(set (match_operand:DIDF 0 "nonimmediate_operand")
 	(match_operand:DIDF 1 "general_operand"))]
   "GET_CODE(operands[1]) != SYMBOL_REF"
-  {@ [cons: =0, 1; attrs: type, length]
-  [SD  ,SSA ;sop1 ,4 ] s_mov_b64\t%0, %1
-  [SD  ,C   ;sop1 ,8 ] ^
-  [SD  ,DB  ;mult ,* ] #
-  [RS  ,Sm  ;smem ,12] s_store_dwordx2\t%1, %A0
-  [Sm  ,RS  ;smem ,12] s_load_dwordx2\t%0, %A1\;s_waitcnt\tlgkmcnt(0)
-  [v   ,v   ;vmult,* ] #
-  [v   ,DB  ;vmult,* ] #
-  [Sg  ,v   ;vmult,* ] #
-  [v   ,Sv  ;vmult,* ] #
-  [v   ,RF  ;flat ,12] flat_load_dwordx2\t%0, %A1%O1%g1\;s_waitcnt\t0
-  [RF  ,v   ;flat ,12] flat_store_dwordx2\t%A0, %1%O0%g0
-  [RLRG,v   ;ds   ,12] ds_write_b64\t%A0, %1%O0\;s_waitcnt\tlgkmcnt(0)
-  [v   ,RLRG;ds   ,12] ds_read_b64\t%0, %A1%O1\;s_waitcnt\tlgkmcnt(0)
-  [v   ,RM  ;flat ,12] global_load_dwordx2\t%0, %A1%O1%g1\;s_waitcnt\tvmcnt(0)
-  [RM  ,v   ;flat ,12] global_store_dwordx2\t%A0, %1%O0%g0
+  {@ [cons: =0, 1; attrs: type, length, gcn_version]
+  [SD  ,SSA ;sop1 ,4 ,*    ] s_mov_b64\t%0, %1
+  [SD  ,C   ;sop1 ,8 ,*    ] ^
+  [SD  ,DB  ;mult ,* ,*    ] #
+  [RS  ,Sm  ;smem ,12,*    ] s_store_dwordx2\t%1, %A0
+  [Sm  ,RS  ;smem ,12,*    ] s_load_dwordx2\t%0, %A1\;s_waitcnt\tlgkmcnt(0)
+  [v   ,v   ;vmult,* ,*    ] #
+  [v   ,DB  ;vmult,* ,*    ] #
+  [Sg  ,v   ;vmult,* ,*    ] #
+  [v   ,Sv  ;vmult,* ,*    ] #
+  [v   ,^a  ;vmult,* ,*    ] #
+  [a   ,v   ;vmult,* ,*    ] #
+  [a   ,a   ;vmult,* ,cdna2] #
+  [v   ,RF  ;flat ,12,*    ] flat_load_dwordx2\t%0, %A1%O1%g1\;s_waitcnt\t0
+  [^a  ,RF  ;flat ,12,cdna2] ^
+  [RF  ,v   ;flat ,12,*    ] flat_store_dwordx2\t%A0, %1%O0%g0
+  [RF  ,a   ;flat ,12,cdna2] ^
+  [RLRG,v   ;ds   ,12,*    ] ds_write_b64\t%A0, %1%O0\;s_waitcnt\tlgkmcnt(0)
+  [v   ,RLRG;ds   ,12,*    ] ds_read_b64\t%0, %A1%O1\;s_waitcnt\tlgkmcnt(0)
+  [v   ,RM  ;flat ,12,*    ] global_load_dwordx2\t%0, %A1%O1%g1\;s_waitcnt\tvmcnt(0)
+  [^a  ,RM  ;flat ,12,cdna2] ^
+  [RM  ,v   ;flat ,12,*    ] global_store_dwordx2\t%A0, %1%O0%g0
+  [RM  ,a   ;flat ,12,cdna2] ^
   }
   "reload_completed
    && ((!MEM_P (operands[0]) && !MEM_P (operands[1])
@@ -655,19 +687,26 @@
   [(set (match_operand:TI 0 "nonimmediate_operand")
 	(match_operand:TI 1 "general_operand"  ))]
   ""
-  {@ [cons: =0, 1; attrs: type, delayeduse, length]
-  [SD,SSB;mult ,*  ,* ] #
-  [RS,Sm ;smem ,*  ,12] s_store_dwordx4\t%1, %A0
-  [Sm,RS ;smem ,yes,12] s_load_dwordx4\t%0, %A1\;s_waitcnt\tlgkmcnt(0)
-  [RF,v  ;flat ,*  ,12] flat_store_dwordx4\t%A0, %1%O0%g0
-  [v ,RF ;flat ,*  ,12] flat_load_dwordx4\t%0, %A1%O1%g1\;s_waitcnt\t0
-  [v ,v  ;vmult,*  ,* ] #
-  [v ,Sv ;vmult,*  ,* ] #
-  [SD,v  ;vmult,*  ,* ] #
-  [RM,v  ;flat ,yes,12] global_store_dwordx4\t%A0, %1%O0%g0
-  [v ,RM ;flat ,*  ,12] global_load_dwordx4\t%0, %A1%O1%g1\;s_waitcnt\tvmcnt(0)
-  [RL,v  ;ds   ,*  ,12] ds_write_b128\t%A0, %1%O0\;s_waitcnt\tlgkmcnt(0)
-  [v ,RL ;ds   ,*  ,12] ds_read_b128\t%0, %A1%O1\;s_waitcnt\tlgkmcnt(0)
+  {@ [cons: =0, 1; attrs: type, delayeduse, length, gcn_version]
+  [SD,SSB;mult ,*  ,* ,*    ] #
+  [RS,Sm ;smem ,*  ,12,*    ] s_store_dwordx4\t%1, %A0
+  [Sm,RS ;smem ,yes,12,*    ] s_load_dwordx4\t%0, %A1\;s_waitcnt\tlgkmcnt(0)
+  [RF,v  ;flat ,*  ,12,*    ] flat_store_dwordx4\t%A0, %1%O0%g0
+  [RF,a  ;flat ,*  ,12,cdna2] ^
+  [v ,RF ;flat ,*  ,12,*    ] flat_load_dwordx4\t%0, %A1%O1%g1\;s_waitcnt\t0
+  [^a,RF ;flat ,*  ,12,cdna2] ^
+  [v ,v  ;vmult,*  ,* ,*    ] #
+  [v ,Sv ;vmult,*  ,* ,*    ] #
+  [SD,v  ;vmult,*  ,* ,*    ] #
+  [RM,v  ;flat ,yes,12,*    ] global_store_dwordx4\t%A0, %1%O0%g0
+  [RM,a  ;flat ,yes,12,cdna2] ^
+  [v ,RM ;flat ,*  ,12,*    ] global_load_dwordx4\t%0, %A1%O1%g1\;s_waitcnt\tvmcnt(0)
+  [^a,RM ;flat ,*  ,12,cdna2] ^
+  [RL,v  ;ds   ,*  ,12,*    ] ds_write_b128\t%A0, %1%O0\;s_waitcnt\tlgkmcnt(0)
+  [v ,RL ;ds   ,*  ,12,*    ] ds_read_b128\t%0, %A1%O1\;s_waitcnt\tlgkmcnt(0)
+  [v ,^a ;vmult,*  ,* ,*    ] #
+  [a ,v  ;vmult,*  ,* ,*    ] #
+  [a ,a  ;vmult,*  ,* ,cdna2] #
   }
   "reload_completed
    && REG_P (operands[0])
diff --git a/gcc/config/gcn/mkoffload.cc b/gcc/config/gcn/mkoffload.cc
index 0e224ca..ee8bde3 100644
--- a/gcc/config/gcn/mkoffload.cc
+++ b/gcc/config/gcn/mkoffload.cc
@@ -471,6 +471,26 @@ copy_early_debug_info (const char *infile, const char *outfile)
   return true;
 }
 
+/* CDNA2 devices have twice as many VGPRs compared to older devices,
+   but the AVGPRS are allocated from the same pool.  */
+
+static int
+isa_has_combined_avgprs (int isa)
+{
+  switch (isa)
+    {
+    case EF_AMDGPU_MACH_AMDGCN_GFX803:
+    case EF_AMDGPU_MACH_AMDGCN_GFX900:
+    case EF_AMDGPU_MACH_AMDGCN_GFX906:
+    case EF_AMDGPU_MACH_AMDGCN_GFX908:
+    case EF_AMDGPU_MACH_AMDGCN_GFX1030:
+      return false;
+    case EF_AMDGPU_MACH_AMDGCN_GFX90a:
+      return true;
+    }
+  fatal_error (input_location, "unhandled ISA in isa_has_combined_avgprs");
+}
+
 /* Parse an input assembler file, extract the offload tables etc.,
    and output (1) the assembler code, minus the tables (which can contain
    problematic relocations), and (2) a C file with the offload tables
@@ -496,6 +516,7 @@ process_asm (FILE *in, FILE *out, FILE *cfile)
   {
     int sgpr_count;
     int vgpr_count;
+    int avgpr_count;
     char *kernel_name;
   } regcount = { -1, -1, NULL };
 
@@ -543,6 +564,12 @@ process_asm (FILE *in, FILE *out, FILE *cfile)
 		gcc_assert (regcount.kernel_name);
 		break;
 	      }
+	    else if (sscanf (buf, " .agpr_count: %d\n",
+			     &regcount.avgpr_count) == 1)
+	      {
+		gcc_assert (regcount.kernel_name);
+		break;
+	      }
 
 	    break;
 	  }
@@ -685,6 +712,8 @@ process_asm (FILE *in, FILE *out, FILE *cfile)
 	  {
 	    sgpr_count = regcounts[j].sgpr_count;
 	    vgpr_count = regcounts[j].vgpr_count;
+	    if (isa_has_combined_avgprs (elf_arch))
+	      vgpr_count += regcounts[j].avgpr_count;
 	    break;
 	  }
 
diff --git a/gcc/config/gcn/predicates.md b/gcc/config/gcn/predicates.md
index 5554a06..d3bf83d 100644
--- a/gcc/config/gcn/predicates.md
+++ b/gcc/config/gcn/predicates.md
@@ -70,6 +70,30 @@
   return VGPR_REGNO_P (REGNO (op)) || REGNO (op) >= FIRST_PSEUDO_REGISTER;
 })
 
+(define_predicate "gcn_avgpr_register_operand"
+  (match_operand 0 "register_operand")
+  {
+    if (GET_CODE (op) == SUBREG)
+        op = SUBREG_REG (op);
+
+  if (!REG_P (op))
+      return false;
+
+  return AVGPR_REGNO_P (REGNO (op)) || REGNO (op) >= FIRST_PSEUDO_REGISTER;
+})
+
+(define_predicate "gcn_avgpr_hard_register_operand"
+  (match_operand 0 "register_operand")
+    {
+        if (GET_CODE (op) == SUBREG)
+	        op = SUBREG_REG (op);
+
+  if (!REG_P (op))
+        return false;
+
+  return AVGPR_REGNO_P (REGNO (op));
+})
+
 (define_predicate "gcn_inline_immediate_operand"
   (match_code "const_int,const_double,const_vector")
 {
diff --git a/gcc/config/i386/i386.md b/gcc/config/i386/i386.md
index 29289f4..1b5a794 100644
--- a/gcc/config/i386/i386.md
+++ b/gcc/config/i386/i386.md
@@ -3335,6 +3335,19 @@
    (set_attr "mode" "<MODE>")
    (set_attr "length_immediate" "0")])
 
+(define_insn "*movstrictqi_ext<mode>_1"
+  [(set (strict_low_part
+	  (match_operand:QI 0 "register_operand" "+Q"))
+	  (subreg:QI
+	    (match_operator:SWI248 2 "extract_operator"
+	      [(match_operand 1 "int248_register_operand" "Q")
+	       (const_int 8)
+	       (const_int 8)]) 0))]
+  "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
+  "mov{b}\t{%h1, %0|%0, %h1}"
+  [(set_attr "type" "imov")
+   (set_attr "mode" "QI")])
+
 (define_expand "extv<mode>"
   [(set (match_operand:SWI24 0 "register_operand")
 	(sign_extract:SWI24 (match_operand:SWI24 1 "register_operand")
@@ -6615,6 +6628,69 @@
 	(const_string "alu")))
    (set_attr "mode" "<MODE>")])
 
+;; Alternative 1 is needed to work around LRA limitation, see PR82524.
+(define_insn_and_split "*addqi_ext<mode>_1_slp"
+  [(set (strict_low_part (match_operand:QI 0 "register_operand" "+Q,&Q"))
+	(plus:QI
+	  (subreg:QI
+	    (match_operator:SWI248 3 "extract_operator"
+	      [(match_operand 2 "int248_register_operand" "Q,Q")
+	       (const_int 8)
+	       (const_int 8)]) 0)
+	  (match_operand:QI 1 "nonimmediate_operand" "0,!qm")))
+   (clobber (reg:CC FLAGS_REG))]
+  "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
+  "@
+   add{b}\t{%h2, %0|%0, %h2}
+   #"
+  "&& reload_completed
+   && !rtx_equal_p (operands[0], operands[1])"
+  [(set (strict_low_part (match_dup 0)) (match_dup 1))
+   (parallel
+     [(set (strict_low_part (match_dup 0))
+	   (plus:QI
+	     (subreg:QI
+	       (match_op_dup 3
+		 [(match_dup 2) (const_int 8) (const_int 8)]) 0)
+	     (match_dup 0)))
+      (clobber (reg:CC FLAGS_REG))])]
+  ""
+  [(set_attr "type" "alu")
+   (set_attr "mode" "QI")])
+
+(define_insn_and_split "*addqi_ext<mode>_2_slp"
+  [(set (strict_low_part (match_operand:QI 0 "register_operand" "+&Q"))
+	(plus:QI
+	  (subreg:QI
+	    (match_operator:SWI248 3 "extract_operator"
+	      [(match_operand 1 "int248_register_operand" "Q")
+	       (const_int 8)
+	       (const_int 8)]) 0)
+	  (subreg:QI
+	    (match_operator:SWI248 4 "extract_operator"
+	      [(match_operand 2 "int248_register_operand" "Q")
+	       (const_int 8)
+	       (const_int 8)]) 0)))
+   (clobber (reg:CC FLAGS_REG))]
+  "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
+  "#"
+  "&& reload_completed"
+  [(set (strict_low_part (match_dup 0))
+	(subreg:QI
+	  (match_op_dup 4
+	    [(match_dup 2) (const_int 8) (const_int 8)]) 0))
+   (parallel
+     [(set (strict_low_part (match_dup 0))
+	   (plus:QI
+	     (subreg:QI
+	       (match_op_dup 3
+		 [(match_dup 1) (const_int 8) (const_int 8)]) 0)
+	     (match_dup 0)))
+      (clobber (reg:CC FLAGS_REG))])]
+  ""
+  [(set_attr "type" "alu")
+   (set_attr "mode" "QI")])
+
 ;; Split non destructive adds if we cannot use lea.
 (define_split
   [(set (match_operand:SWI48 0 "register_operand")
@@ -6993,6 +7069,39 @@
    (set_attr "type" "alu")
    (set_attr "mode" "QI")])
 
+(define_insn_and_split "*addqi_ext2<mode>_0"
+  [(set (match_operand:QI 0 "register_operand" "=&Q")
+	(plus:QI
+	  (subreg:QI
+	    (match_operator:SWI248 3 "extract_operator"
+	      [(match_operand 1 "int248_register_operand" "Q")
+	       (const_int 8)
+	       (const_int 8)]) 0)
+	  (subreg:QI
+	    (match_operator:SWI248 4 "extract_operator"
+	      [(match_operand 2 "int248_register_operand" "Q")
+	       (const_int 8)
+	       (const_int 8)]) 0)))
+   (clobber (reg:CC FLAGS_REG))]
+  ""
+  "#"
+  "&& reload_completed"
+  [(set (match_dup 0)
+	(subreg:QI
+	  (match_op_dup 4
+	    [(match_dup 2) (const_int 8) (const_int 8)]) 0))
+   (parallel
+     [(set (match_dup 0)
+	   (plus:QI
+	     (subreg:QI
+	       (match_op_dup 3
+		 [(match_dup 1) (const_int 8) (const_int 8)]) 0)
+	   (match_dup 0)))
+      (clobber (reg:CC FLAGS_REG))])]
+  ""
+  [(set_attr "type" "alu")
+   (set_attr "mode" "QI")])
+
 (define_expand "addqi_ext_1"
   [(parallel
      [(set (zero_extract:HI (match_operand:HI 0 "register_operand")
@@ -7628,6 +7737,69 @@
   [(set_attr "type" "alu")
    (set_attr "mode" "<MODE>")])
 
+;; Alternative 1 is needed to work around LRA limitation, see PR82524.
+(define_insn_and_split "*subqi_ext<mode>_1_slp"
+  [(set (strict_low_part (match_operand:QI 0 "register_operand" "+Q,&Q"))
+	(minus:QI
+	  (match_operand:QI 1 "nonimmediate_operand" "0,!qm")
+	  (subreg:QI
+	    (match_operator:SWI248 3 "extract_operator"
+	      [(match_operand 2 "int248_register_operand" "Q,Q")
+	       (const_int 8)
+	       (const_int 8)]) 0)))
+   (clobber (reg:CC FLAGS_REG))]
+  "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
+  "@
+   sub{b}\t{%h2, %0|%0, %h2}
+   #"
+  "&& reload_completed
+   && !rtx_equal_p (operands[0], operands[1])"
+  [(set (strict_low_part (match_dup 0)) (match_dup 1))
+   (parallel
+     [(set (strict_low_part (match_dup 0))
+	   (minus:QI
+	     (match_dup 0)
+	     (subreg:QI
+	       (match_op_dup 3
+		 [(match_dup 2) (const_int 8) (const_int 8)]) 0)))
+      (clobber (reg:CC FLAGS_REG))])]
+  ""
+  [(set_attr "type" "alu")
+   (set_attr "mode" "QI")])
+
+(define_insn_and_split "*subqi_ext<mode>_2_slp"
+  [(set (strict_low_part (match_operand:QI 0 "register_operand" "+&Q"))
+	(minus:QI
+	  (subreg:QI
+	    (match_operator:SWI248 3 "extract_operator"
+	      [(match_operand 1 "int248_register_operand" "Q")
+	       (const_int 8)
+	       (const_int 8)]) 0)
+	  (subreg:QI
+	    (match_operator:SWI248 4 "extract_operator"
+	      [(match_operand 2 "int248_register_operand" "Q")
+	       (const_int 8)
+	       (const_int 8)]) 0)))
+   (clobber (reg:CC FLAGS_REG))]
+  "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
+  "#"
+  "&& reload_completed"
+  [(set (strict_low_part (match_dup 0))
+	(subreg:QI
+	  (match_op_dup 3
+	    [(match_dup 1) (const_int 8) (const_int 8)]) 0))
+   (parallel
+     [(set (strict_low_part (match_dup 0))
+	   (minus:QI
+	   (match_dup 0)
+	     (subreg:QI
+	       (match_op_dup 4
+		 [(match_dup 2) (const_int 8) (const_int 8)]) 0)))
+      (clobber (reg:CC FLAGS_REG))])]
+  ""
+  [(set_attr "type" "alu")
+   (set_attr "mode" "QI")])
+
 (define_insn "*sub<mode>_2"
   [(set (reg FLAGS_REG)
 	(compare
@@ -7675,6 +7847,39 @@
    (set_attr "type" "alu")
    (set_attr "mode" "QI")])
 
+(define_insn_and_split "*subqi_ext2<mode>_0"
+  [(set (match_operand:QI 0 "register_operand" "=&Q")
+	(minus:QI
+	  (subreg:QI
+	    (match_operator:SWI248 3 "extract_operator"
+	      [(match_operand 1 "int248_register_operand" "Q")
+	       (const_int 8)
+	       (const_int 8)]) 0)
+	  (subreg:QI
+	    (match_operator:SWI248 4 "extract_operator"
+	      [(match_operand 2 "int248_register_operand" "Q")
+	       (const_int 8)
+	       (const_int 8)]) 0)))
+   (clobber (reg:CC FLAGS_REG))]
+  ""
+  "#"
+  "&& reload_completed"
+  [(set (match_dup 0)
+	(subreg:QI
+	  (match_op_dup 3
+	    [(match_dup 1) (const_int 8) (const_int 8)]) 0))
+   (parallel
+     [(set (match_dup 0)
+	   (minus:QI
+	     (match_dup 0)
+	     (subreg:QI
+	       (match_op_dup 4
+		 [(match_dup 2) (const_int 8) (const_int 8)]) 0)))
+      (clobber (reg:CC FLAGS_REG))])]
+  ""
+  [(set_attr "type" "alu")
+   (set_attr "mode" "QI")])
+
 ;; Alternative 1 is needed to work around LRA limitation, see PR82524.
 (define_insn_and_split "*subqi_ext<mode>_1"
   [(set (zero_extract:SWI248
@@ -9858,7 +10063,10 @@
    && REGNO (operands[0]) != REGNO (operands[3])
    && (REGNO (operands[0]) == REGNO (operands[4])
        || REGNO (operands[0]) == REGNO (operands[5])
-       || peep2_reg_dead_p (3, operands[0]))"
+       || peep2_reg_dead_p (3, operands[0]))
+   && (REGNO (operands[2]) == REGNO (operands[4])
+       || REGNO (operands[2]) == REGNO (operands[5])
+       || peep2_reg_dead_p (3, operands[2]))"
   [(set (match_dup 2) (match_dup 1))
    (parallel [(set (match_dup 4)
 		   (mult:DWIH (match_dup 2) (match_dup 3)))
@@ -11423,6 +11631,69 @@
   [(set_attr "type" "alu")
    (set_attr "mode" "<MODE>")])
 
+;; Alternative 1 is needed to work around LRA limitation, see PR82524.
+(define_insn_and_split "*<code>qi_ext<mode>_1_slp"
+  [(set (strict_low_part (match_operand:QI 0 "register_operand" "+Q,&Q"))
+	(any_logic:QI
+	  (subreg:QI
+	    (match_operator:SWI248 3 "extract_operator"
+	      [(match_operand 2 "int248_register_operand" "Q,Q")
+	       (const_int 8)
+	       (const_int 8)]) 0)
+	  (match_operand:QI 1 "nonimmediate_operand" "0,!qm")))
+   (clobber (reg:CC FLAGS_REG))]
+  "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
+  "@
+   <logic>{b}\t{%h2, %0|%0, %h2}
+   #"
+  "&& reload_completed
+   && !rtx_equal_p (operands[0], operands[1])"
+  [(set (strict_low_part (match_dup 0)) (match_dup 1))
+   (parallel
+     [(set (strict_low_part (match_dup 0))
+	   (any_logic:QI
+	     (subreg:QI
+	       (match_op_dup 3
+		 [(match_dup 2) (const_int 8) (const_int 8)]) 0)
+	     (match_dup 0)))
+      (clobber (reg:CC FLAGS_REG))])]
+  ""
+  [(set_attr "type" "alu")
+   (set_attr "mode" "QI")])
+
+(define_insn_and_split "*<code>qi_ext<mode>_2_slp"
+  [(set (strict_low_part (match_operand:QI 0 "register_operand" "+&Q"))
+	(any_logic:QI
+	  (subreg:QI
+	    (match_operator:SWI248 3 "extract_operator"
+	      [(match_operand 1 "int248_register_operand" "Q")
+	       (const_int 8)
+	       (const_int 8)]) 0)
+	  (subreg:QI
+	    (match_operator:SWI248 4 "extract_operator"
+	      [(match_operand 2 "int248_register_operand" "Q")
+	       (const_int 8)
+	       (const_int 8)]) 0)))
+   (clobber (reg:CC FLAGS_REG))]
+  "!TARGET_PARTIAL_REG_STALL || optimize_function_for_size_p (cfun)"
+  "#"
+  "&& reload_completed"
+  [(set (strict_low_part (match_dup 0))
+	(subreg:QI
+	  (match_op_dup 4
+	    [(match_dup 2) (const_int 8) (const_int 8)]) 0))
+   (parallel
+     [(set (strict_low_part (match_dup 0))
+	   (any_logic:QI
+	     (subreg:QI
+	       (match_op_dup 3
+		 [(match_dup 1) (const_int 8) (const_int 8)]) 0)
+	     (match_dup 0)))
+      (clobber (reg:CC FLAGS_REG))])]
+  ""
+  [(set_attr "type" "alu")
+   (set_attr "mode" "QI")])
+
 (define_split
   [(set (match_operand:SWI248 0 "register_operand")
 	(and:SWI248 (match_operand:SWI248 1 "nonimmediate_operand")
@@ -11610,6 +11881,39 @@
    (set_attr "type" "alu")
    (set_attr "mode" "QI")])
 
+(define_insn_and_split "*<code>qi_ext2<mode>_0"
+  [(set (match_operand:QI 0 "register_operand" "=&Q")
+	(any_logic:QI
+	  (subreg:QI
+	    (match_operator:SWI248 3 "extract_operator"
+	      [(match_operand 1 "int248_register_operand" "Q")
+	       (const_int 8)
+	       (const_int 8)]) 0)
+	  (subreg:QI
+	    (match_operator:SWI248 4 "extract_operator"
+	      [(match_operand 2 "int248_register_operand" "Q")
+	       (const_int 8)
+	       (const_int 8)]) 0)))
+   (clobber (reg:CC FLAGS_REG))]
+  ""
+  "#"
+  "&& reload_completed"
+  [(set (match_dup 0)
+	(subreg:QI
+	  (match_op_dup 4
+	    [(match_dup 2) (const_int 8) (const_int 8)]) 0))
+   (parallel
+     [(set (match_dup 0)
+	   (any_logic:QI
+	     (subreg:QI
+	       (match_op_dup 3
+		 [(match_dup 1) (const_int 8) (const_int 8)]) 0)
+	   (match_dup 0)))
+      (clobber (reg:CC FLAGS_REG))])]
+  ""
+  [(set_attr "type" "alu")
+   (set_attr "mode" "QI")])
+
 (define_expand "andqi_ext_1"
   [(parallel
      [(set (zero_extract:HI (match_operand:HI 0 "register_operand")
@@ -14825,8 +15129,8 @@
 {
   split_double_mode (<DWI>mode, &operands[1], 1, &operands[1], &operands[3]);
   operands[4] = GEN_INT ((<MODE_SIZE> * BITS_PER_UNIT) - INTVAL (operands[2]));
-  if (!rtx_equal_p (operands[0], operands[3]))
-    emit_move_insn (operands[0], operands[3]);
+  if (!rtx_equal_p (operands[0], operands[1]))
+    emit_move_insn (operands[0], operands[1]);
 })
 
 (define_insn "x86_64_shrd"
diff --git a/gcc/config/i386/mmx.md b/gcc/config/i386/mmx.md
index a3d08bb..0f16d2a 100644
--- a/gcc/config/i386/mmx.md
+++ b/gcc/config/i386/mmx.md
@@ -1215,7 +1215,7 @@
     }
 }
   [(set_attr "isa" "noavx,noavx,avx")
-   (set_attr "addr" "*,*,gpr16")
+   (set_attr "addr" "gpr16,gpr16,*")
    (set_attr "type" "sselog")
    (set_attr "prefix_data16" "1,1,*")
    (set_attr "prefix_extra" "1")
@@ -5277,8 +5277,8 @@
    (set_attr "mode" "DI,TI")])
 
 (define_insn "*vec_dup<mode>"
-  [(set (match_operand:V4F_64 0 "register_operand" "=Yw")
-	(vec_duplicate:V4F_64
+  [(set (match_operand:V4FI_64 0 "register_operand" "=Yw")
+	(vec_duplicate:V4FI_64
 	  (match_operand:<mmxscalarmode> 1 "register_operand" "Yw")))]
   "TARGET_MMX_WITH_SSE"
   "%vpshuflw\t{$0, %1, %0|%0, %1, 0}"
@@ -5869,8 +5869,8 @@
    (set_attr "mode" "TI")])
 
 (define_insn "*vec_dup<mode>"
-  [(set (match_operand:V2F_32 0 "register_operand" "=Yw")
-	(vec_duplicate:V2F_32
+  [(set (match_operand:V2FI_32 0 "register_operand" "=Yw")
+	(vec_duplicate:V2FI_32
 	  (match_operand:<mmxscalarmode> 1 "register_operand" "Yw")))]
   "TARGET_SSE2"
   "%vpshuflw\t{$0, %1, %0|%0, %1, 0}"
diff --git a/gcc/config/i386/sse.md b/gcc/config/i386/sse.md
index c502582..d250a6c 100644
--- a/gcc/config/i386/sse.md
+++ b/gcc/config/i386/sse.md
@@ -12049,9 +12049,9 @@
    (set_attr "mode" "<sseinsnmode>")])
 
 (define_insn "vec_extract_hi_<mode>"
-  [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=vm")
+  [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=xjm,vm")
 	(vec_select:<ssehalfvecmode>
-	  (match_operand:VI8F_256 1 "register_operand" "v")
+	  (match_operand:VI8F_256 1 "register_operand" "x,v")
 	  (parallel [(const_int 2) (const_int 3)])))]
   "TARGET_AVX"
 {
@@ -12065,7 +12065,9 @@
   else
     return "vextract<i128>\t{$0x1, %1, %0|%0, %1, 0x1}";
 }
-  [(set_attr "type" "sselog1")
+  [(set_attr "isa" "noavx512vl,avx512vl")
+   (set_attr "addr" "gpr16,*")
+   (set_attr "type" "sselog1")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "vex")
@@ -12132,7 +12134,7 @@
    (set_attr "mode" "<sseinsnmode>")])
 
 (define_insn "vec_extract_hi_<mode>"
-  [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=xm, vm")
+  [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=xjm, vm")
 	(vec_select:<ssehalfvecmode>
 	  (match_operand:VI4F_256 1 "register_operand" "x, v")
 	  (parallel [(const_int 4) (const_int 5)
@@ -12141,7 +12143,8 @@
   "@
     vextract<i128>\t{$0x1, %1, %0|%0, %1, 0x1}
     vextract<shuffletype>32x4\t{$0x1, %1, %0|%0, %1, 0x1}"
-  [(set_attr "isa" "*, avx512vl")
+  [(set_attr "isa" "noavx512vl, avx512vl")
+   (set_attr "addr" "gpr16,*")
    (set_attr "prefix" "vex, evex")
    (set_attr "type" "sselog1")
    (set_attr "length_immediate" "1")
@@ -12222,7 +12225,7 @@
   "operands[1] = gen_lowpart (<ssehalfvecmode>mode, operands[1]);")
 
 (define_insn "@vec_extract_hi_<mode>"
-  [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=xm,vm")
+  [(set (match_operand:<ssehalfvecmode> 0 "nonimmediate_operand" "=xjm,vm")
 	(vec_select:<ssehalfvecmode>
 	  (match_operand:V16_256 1 "register_operand" "x,v")
 	  (parallel [(const_int 8) (const_int 9)
@@ -12236,7 +12239,8 @@
   [(set_attr "type" "sselog1")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
-   (set_attr "isa" "*,avx512vl")
+   (set_attr "isa" "noavx512vl,avx512vl")
+   (set_attr "addr" "gpr16,*")
    (set_attr "prefix" "vex,evex")
    (set_attr "mode" "OI")])
 
@@ -19235,11 +19239,11 @@
 })
 
 (define_insn "<mask_codefor>avx512dq_shuf_<shuffletype>64x2_1<mask_name>"
-  [(set (match_operand:VI8F_256 0 "register_operand" "=v")
+  [(set (match_operand:VI8F_256 0 "register_operand" "=x,v")
 	(vec_select:VI8F_256
 	  (vec_concat:<ssedoublemode>
-	    (match_operand:VI8F_256 1 "register_operand" "v")
-	    (match_operand:VI8F_256 2 "nonimmediate_operand" "vm"))
+	    (match_operand:VI8F_256 1 "register_operand" "x,v")
+	    (match_operand:VI8F_256 2 "nonimmediate_operand" "xjm,vm"))
 	  (parallel [(match_operand 3 "const_0_to_3_operand")
 		     (match_operand 4 "const_0_to_3_operand")
 		     (match_operand 5 "const_4_to_7_operand")
@@ -19254,7 +19258,7 @@
   mask = INTVAL (operands[3]) / 2;
   mask |= (INTVAL (operands[5]) - 4) / 2 << 1;
   operands[3] = GEN_INT (mask);
-  if (INTVAL (operands[3]) == 2 && !<mask_applied>)
+  if (INTVAL (operands[3]) == 2 && !<mask_applied> && which_alternative == 0)
     return "vblendps\t{$240, %2, %1, %0|%0, %1, %2, 240}";
   return "vshuf<shuffletype>64x2\t{%3, %2, %1, %0<mask_operand7>|%0<mask_operand7>, %1, %2, %3}";
 }
@@ -19386,11 +19390,11 @@
 })
 
 (define_insn "avx512vl_shuf_<shuffletype>32x4_1<mask_name>"
-  [(set (match_operand:VI4F_256 0 "register_operand" "=v")
+  [(set (match_operand:VI4F_256 0 "register_operand" "=x,v")
 	(vec_select:VI4F_256
 	  (vec_concat:<ssedoublemode>
-	    (match_operand:VI4F_256 1 "register_operand" "v")
-	    (match_operand:VI4F_256 2 "nonimmediate_operand" "vm"))
+	    (match_operand:VI4F_256 1 "register_operand" "x,v")
+	    (match_operand:VI4F_256 2 "nonimmediate_operand" "xjm,vm"))
 	  (parallel [(match_operand 3 "const_0_to_7_operand")
 		     (match_operand 4 "const_0_to_7_operand")
 		     (match_operand 5 "const_0_to_7_operand")
@@ -19414,7 +19418,7 @@
   mask |= (INTVAL (operands[7]) - 8) / 4 << 1;
   operands[3] = GEN_INT (mask);
 
-  if (INTVAL (operands[3]) == 2 && !<mask_applied>)
+  if (INTVAL (operands[3]) == 2 && !<mask_applied> && which_alternative == 0)
     return "vblendps\t{$240, %2, %1, %0|%0, %1, %2, 240}";
 
   return "vshuf<shuffletype>32x4\t{%3, %2, %1, %0<mask_operand11>|%0<mask_operand11>, %1, %2, %3}";
@@ -20465,7 +20469,7 @@
 })
 
 (define_insn "*vec_extractv2ti"
-  [(set (match_operand:TI 0 "nonimmediate_operand" "=xm,vm")
+  [(set (match_operand:TI 0 "nonimmediate_operand" "=xjm,vm")
 	(vec_select:TI
 	  (match_operand:V2TI 1 "register_operand" "x,v")
 	  (parallel
@@ -20477,6 +20481,8 @@
   [(set_attr "type" "sselog")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
+   (set_attr "isa" "noavx512vl,avx512vl")
+   (set_attr "addr" "gpr16,*")
    (set_attr "prefix" "vex,evex")
    (set_attr "mode" "OI")])
 
@@ -27556,12 +27562,12 @@
    (set_attr "mode" "<sseinsnmode>")])
 
 (define_insn "vec_set_hi_<mode><mask_name>"
-  [(set (match_operand:VI8F_256 0 "register_operand" "=v")
+  [(set (match_operand:VI8F_256 0 "register_operand" "=x,v")
 	(vec_concat:VI8F_256
 	  (vec_select:<ssehalfvecmode>
-	    (match_operand:VI8F_256 1 "register_operand" "v")
+	    (match_operand:VI8F_256 1 "register_operand" "x,v")
 	    (parallel [(const_int 0) (const_int 1)]))
-	  (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand" "vm")))]
+	  (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand" "xjm,vm")))]
   "TARGET_AVX && <mask_avx512dq_condition>"
 {
   if (TARGET_AVX512DQ)
@@ -27571,7 +27577,9 @@
   else
     return "vinsert<i128>\t{$0x1, %2, %1, %0|%0, %1, %2, 0x1}";
 }
-  [(set_attr "type" "sselog")
+  [(set_attr "isa" "noavx512vl,avx512vl")
+   (set_attr "addr" "gpr16,*")
+   (set_attr "type" "sselog")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "vex")
diff --git a/gcc/config/loongarch/genopts/genstr.sh b/gcc/config/loongarch/genopts/genstr.sh
index 04e7855..cc83496 100755
--- a/gcc/config/loongarch/genopts/genstr.sh
+++ b/gcc/config/loongarch/genopts/genstr.sh
@@ -25,8 +25,8 @@ cd "$(dirname "$0")"
 # Generate a header containing definitions from the string table.
 gen_defines() {
     cat <<EOF
-/* Generated automatically by "genstr" from "loongarch-strings".
-   Please do not edit this file directly.
+/* Generated automatically by "genstr" from "loongarch-strings" and
+   "isa-evolution.in".  Please do not edit this file directly.
 
    Copyright (C) 2021-2023 Free Software Foundation, Inc.
    Contributed by Loongson Ltd.
@@ -56,6 +56,15 @@ EOF
 	loongarch-strings
 
     echo
+
+	# Generate the strings from isa-evolution.in.
+	awk '{
+	  a=$3
+	  gsub(/-/, "_", a)
+	  print("#define OPTSTR_"toupper(a)"\t\""$3"\"")
+	}' isa-evolution.in
+
+    echo
     echo "#endif /* LOONGARCH_STR_H */"
 }
 
@@ -77,11 +86,12 @@ gen_options() {
 	# print a header
 	cat << EOF
 ; Generated by "genstr" from the template "loongarch.opt.in"
-; and definitions from "loongarch-strings".
+; and definitions from "loongarch-strings" and "isa-evolution.in".
 ;
 ; Please do not edit this file directly.
 ; It will be automatically updated during a gcc build
-; if you change "loongarch.opt.in" or "loongarch-strings".
+; if you change "loongarch.opt.in", "loongarch-strings", or
+; "isa-evolution.in".
 ;
 EOF
 
@@ -91,13 +101,85 @@ EOF
 		eval "echo \"$line\""
 	    done
     }
+
+    # Generate the strings from isa-evolution.in.
+    awk '{
+      print("")
+      print("m"$3)
+      gsub(/-/, "_", $3)
+      print("Target Mask(ISA_"toupper($3)") Var(isa_evolution)")
+      $1=""; $2=""; $3=""
+      sub(/^ */, "", $0)
+      print($0)
+    }' isa-evolution.in
+}
+
+gen_cpucfg_map() {
+    cat <<EOF
+/* Generated automatically by "genstr" from "isa-evolution.in".
+   Please do not edit this file directly.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 3, or (at your option)
+any later version.
+
+GCC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+#ifndef LOONGARCH_CPUCFG_MAP_H
+#define LOONGARCH_CPUCFG_MAP_H
+
+#include "options.h"
+
+static constexpr struct {
+  int cpucfg_word;
+  unsigned int cpucfg_bit;
+  HOST_WIDE_INT isa_evolution_bit;
+} cpucfg_map[] = {
+EOF
+
+    # Generate the strings from isa-evolution.in.
+    awk '{
+      gsub(/-/, "_", $3)
+      print("  { "$1", 1u << "$2", OPTION_MASK_ISA_"toupper($3)" },")
+    }' isa-evolution.in
+
+    echo "};"
+    echo
+    echo "static constexpr int cpucfg_useful_idx[] = {"
+
+    awk 'BEGIN { print("  0,\n  1,\n  2,\n  16,\n  17,\n  18,\n  19,") }
+	 {if ($1+0 > max+0) max=$1; print("  "$1",")}' \
+	isa-evolution.in | sort -n | uniq
+
+    echo "};"
+    echo ""
+
+    awk 'BEGIN { max=19 }
+	 { if ($1+0 > max+0) max=$1 }
+	 END { print "static constexpr int N_CPUCFG_WORDS = "1+max";" }' \
+	isa-evolution.in
+
+    echo "#endif /* LOONGARCH_CPUCFG_MAP_H */"
 }
 
 main() {
     case "$1" in
+	cpucfg-map) gen_cpucfg_map;;
 	header) gen_defines;;
 	opt) gen_options;;
-	*) echo "Unknown Command: \"$1\". Available: header, opt"; exit 1;;
+	*) echo "Unknown Command: \"$1\". Available: cpucfg-map, header, opt"; exit 1;;
     esac
 }
 
diff --git a/gcc/config/loongarch/genopts/isa-evolution.in b/gcc/config/loongarch/genopts/isa-evolution.in
new file mode 100644
index 0000000..a6bc3f8
--- /dev/null
+++ b/gcc/config/loongarch/genopts/isa-evolution.in
@@ -0,0 +1,4 @@
+2	26	div32		Support div.w[u] and mod.w[u] instructions with inputs not sign-extended.
+2	27	lam-bh		Support am{swap/add}[_db].{b/h} instructions.
+2	28	lamcas		Support amcas[_db].{b/h/w/d} instructions.
+3	23	ld-seq-sa	Do not need load-load barriers (dbar 0x700).
diff --git a/gcc/config/loongarch/genopts/loongarch-strings b/gcc/config/loongarch/genopts/loongarch-strings
index 8e412f7..b2070c8 100644
--- a/gcc/config/loongarch/genopts/loongarch-strings
+++ b/gcc/config/loongarch/genopts/loongarch-strings
@@ -26,9 +26,11 @@ STR_CPU_NATIVE	      native
 STR_CPU_ABI_DEFAULT   abi-default
 STR_CPU_LOONGARCH64   loongarch64
 STR_CPU_LA464	      la464
+STR_CPU_LA664	      la664
 
 # Base architecture
 STR_ISA_BASE_LA64V100 la64
+STR_ISA_BASE_LA64V110 la64v1.1
 
 # -mfpu
 OPTSTR_ISA_EXT_FPU    fpu
diff --git a/gcc/config/loongarch/genopts/loongarch.opt.in b/gcc/config/loongarch/genopts/loongarch.opt.in
index e1fe0c7..8af6cc6 100644
--- a/gcc/config/loongarch/genopts/loongarch.opt.in
+++ b/gcc/config/loongarch/genopts/loongarch.opt.in
@@ -32,6 +32,9 @@ Basic ISAs of LoongArch:
 EnumValue
 Enum(isa_base) String(@@STR_ISA_BASE_LA64V100@@) Value(ISA_BASE_LA64V100)
 
+EnumValue
+Enum(isa_base) String(@@STR_ISA_BASE_LA64V110@@) Value(ISA_BASE_LA64V110)
+
 ;; ISA extensions / adjustments
 Enum
 Name(isa_ext_fpu) Type(int)
@@ -107,6 +110,9 @@ Enum(cpu_type) String(@@STR_CPU_LOONGARCH64@@) Value(CPU_LOONGARCH64)
 EnumValue
 Enum(cpu_type) String(@@STR_CPU_LA464@@) Value(CPU_LA464)
 
+EnumValue
+Enum(cpu_type) String(@@STR_CPU_LA664@@) Value(CPU_LA664)
+
 m@@OPTSTR_ARCH@@=
 Target RejectNegative Joined Enum(cpu_type) Var(la_opt_cpu_arch) Init(M_OPT_UNSET)
 -m@@OPTSTR_ARCH@@=PROCESSOR	Generate code for the given PROCESSOR ISA.
@@ -223,10 +229,14 @@ Target Var(TARGET_DIRECT_EXTERN_ACCESS) Init(0)
 Avoid using the GOT to access external symbols.
 
 mrelax
-Target Var(loongarch_mrelax) Init(HAVE_AS_MRELAX_OPTION)
+Target Var(loongarch_mrelax) Init(HAVE_AS_MRELAX_OPTION && HAVE_AS_COND_BRANCH_RELAXATION)
 Take advantage of linker relaxations to reduce the number of instructions
 required to materialize symbol addresses.
 
+mpass-mrelax-to-as
+Target Var(loongarch_pass_mrelax_to_as) Init(HAVE_AS_MRELAX_OPTION)
+Pass -mrelax or -mno-relax option to the assembler.
+
 -param=loongarch-vect-unroll-limit=
 Target Joined UInteger Var(loongarch_vect_unroll_limit) Init(6) IntegerRange(1, 64) Param
 Used to limit unroll factor which indicates how much the autovectorizer may
@@ -237,3 +247,10 @@ Target Undocumented Joined UInteger Var(loongarch_vect_issue_info) Init(4) Integ
 Indicate how many non memory access vector instructions can be issued per
 cycle, it's used in unroll factor determination for autovectorizer.  The
 default value is 4.
+
+; Features added during ISA evolution.  This concept is different from ISA
+; extension, read Section 1.5 of LoongArch v1.10 Volume 1 for the
+; explanation.  These features may be implemented and enumerated with
+; CPUCFG independantly, so we use bit flags to specify them.
+Variable
+HOST_WIDE_INT isa_evolution = 0
diff --git a/gcc/config/loongarch/lasx.md b/gcc/config/loongarch/lasx.md
index f0f2dd0..2e11f06 100644
--- a/gcc/config/loongarch/lasx.md
+++ b/gcc/config/loongarch/lasx.md
@@ -3136,11 +3136,31 @@
 	  (match_operand:FLASX 1 "register_operand")))
    (set (match_dup 5)
 	(and:FLASX (match_dup 3)
-		   (match_operand:FLASX 2 "register_operand")))
+		   (match_operand:FLASX 2 "reg_or_vector_same_val_operand")))
    (set (match_operand:FLASX 0 "register_operand")
 	(ior:FLASX (match_dup 4) (match_dup 5)))]
   "ISA_HAS_LASX"
 {
+  /* copysign (x, -1) should instead be expanded as setting the sign
+     bit.  */
+  if (!REG_P (operands[2]))
+    {
+      rtx op2_elt = unwrap_const_vec_duplicate (operands[2]);
+      if (GET_CODE (op2_elt) == CONST_DOUBLE
+	  && real_isneg (CONST_DOUBLE_REAL_VALUE (op2_elt)))
+	{
+	  rtx n = GEN_INT (8 * GET_MODE_SIZE (<UNITMODE>mode) - 1);
+	  operands[0] = lowpart_subreg (<VIMODE256>mode, operands[0],
+					<MODE>mode);
+	  operands[1] = lowpart_subreg (<VIMODE256>mode, operands[1],
+					<MODE>mode);
+	  emit_insn (gen_lasx_xvbitseti_<lasxfmt> (operands[0],
+						   operands[1], n));
+	  DONE;
+	}
+    }
+
+  operands[2] = force_reg (<MODE>mode, operands[2]);
   operands[3] = loongarch_build_signbit_mask (<MODE>mode, 1, 0);
 
   operands[4] = gen_reg_rtx (<MODE>mode);
diff --git a/gcc/config/loongarch/loongarch-cpu.cc b/gcc/config/loongarch/loongarch-cpu.cc
index 7a2866f..622df47 100644
--- a/gcc/config/loongarch/loongarch-cpu.cc
+++ b/gcc/config/loongarch/loongarch-cpu.cc
@@ -29,12 +29,25 @@ along with GCC; see the file COPYING3.  If not see
 #include "loongarch-def.h"
 #include "loongarch-opts.h"
 #include "loongarch-cpu.h"
+#include "loongarch-cpucfg-map.h"
 #include "loongarch-str.h"
 
+/* loongarch_isa_base_features defined here instead of loongarch-def.c
+   because we need to use options.h.  Pay attention on the order of elements
+   in the initializer becaue ISO C++ does not allow C99 designated
+   initializers!  */
+
+#define ISA_BASE_LA64V110_FEATURES \
+  (OPTION_MASK_ISA_DIV32 | OPTION_MASK_ISA_LD_SEQ_SA \
+   | OPTION_MASK_ISA_LAM_BH | OPTION_MASK_ISA_LAMCAS)
+
+int64_t loongarch_isa_base_features[N_ISA_BASE_TYPES] = {
+  /* [ISA_BASE_LA64V100] = */ 0,
+  /* [ISA_BASE_LA64V110] = */ ISA_BASE_LA64V110_FEATURES,
+};
+
 /* Native CPU detection with "cpucfg" */
-#define N_CPUCFG_WORDS 0x15
 static uint32_t cpucfg_cache[N_CPUCFG_WORDS] = { 0 };
-static const int cpucfg_useful_idx[] = {0, 1, 2, 16, 17, 18, 19};
 
 static uint32_t
 read_cpucfg_word (int wordno)
@@ -56,11 +69,8 @@ read_cpucfg_word (int wordno)
 void
 cache_cpucfg (void)
 {
-  for (unsigned int i = 0; i < sizeof (cpucfg_useful_idx) / sizeof (int); i++)
-    {
-      cpucfg_cache[cpucfg_useful_idx[i]]
-	= read_cpucfg_word (cpucfg_useful_idx[i]);
-    }
+  for (int idx: cpucfg_useful_idx)
+    cpucfg_cache[idx] = read_cpucfg_word (idx);
 }
 
 uint32_t
@@ -106,6 +116,10 @@ fill_native_cpu_config (struct loongarch_target *tgt)
       native_cpu_type = CPU_LA464;
       break;
 
+    case 0x0014d000:   /* LA664 */
+      native_cpu_type = CPU_LA664;
+      break;
+
     default:
       /* Unknown PRID.  */
       if (tune_native_p)
@@ -121,38 +135,36 @@ fill_native_cpu_config (struct loongarch_target *tgt)
       int tmp;
       tgt->cpu_arch = native_cpu_type;
 
+      auto &preset = loongarch_cpu_default_isa[tgt->cpu_arch];
+
       /* Fill: loongarch_cpu_default_isa[tgt->cpu_arch].base
 	 With: base architecture (ARCH)
 	 At:   cpucfg_words[1][1:0] */
 
-      #define PRESET_ARCH (loongarch_cpu_default_isa[tgt->cpu_arch].base)
-      switch (cpucfg_cache[1] & 0x3)
-	{
-	  case 0x02:
-	    tmp = ISA_BASE_LA64V100;
-	    break;
-
-	  default:
-	    fatal_error (UNKNOWN_LOCATION,
-			 "unknown native base architecture %<0x%x%>, "
-			 "%qs failed", (unsigned int) (cpucfg_cache[1] & 0x3),
-			 "-m" OPTSTR_ARCH "=" STR_CPU_NATIVE);
-	}
-
-      /* Check consistency with PRID presets.  */
-      if (native_cpu_type != CPU_NATIVE && tmp != PRESET_ARCH)
-	warning (0, "base architecture %qs differs from PRID preset %qs",
-		 loongarch_isa_base_strings[tmp],
-		 loongarch_isa_base_strings[PRESET_ARCH]);
+      if (native_cpu_type != CPU_NATIVE)
+	tmp = loongarch_cpu_default_isa[native_cpu_type].base;
+      else
+	switch (cpucfg_cache[1] & 0x3)
+	  {
+	    case 0x02:
+	      tmp = ISA_BASE_LA64V100;
+	      break;
+
+	    default:
+	      fatal_error (UNKNOWN_LOCATION,
+			   "unknown native base architecture %<0x%x%>, "
+			   "%qs failed",
+			   (unsigned int) (cpucfg_cache[1] & 0x3),
+			   "-m" OPTSTR_ARCH "=" STR_CPU_NATIVE);
+	  }
 
       /* Use the native value anyways.  */
-      PRESET_ARCH = tmp;
+      preset.base = tmp;
 
       /* Fill: loongarch_cpu_default_isa[tgt->cpu_arch].fpu
 	 With: FPU type (FP, FP_SP, FP_DP)
 	 At:   cpucfg_words[2][2:0] */
 
-      #define PRESET_FPU (loongarch_cpu_default_isa[tgt->cpu_arch].fpu)
       switch (cpucfg_cache[2] & 0x7)
 	{
 	  case 0x07:
@@ -175,20 +187,19 @@ fill_native_cpu_config (struct loongarch_target *tgt)
 	}
 
       /* Check consistency with PRID presets.  */
-      if (native_cpu_type != CPU_NATIVE && tmp != PRESET_FPU)
+      if (native_cpu_type != CPU_NATIVE && tmp != preset.fpu)
 	warning (0, "floating-point unit %qs differs from PRID preset %qs",
 		 loongarch_isa_ext_strings[tmp],
-		 loongarch_isa_ext_strings[PRESET_FPU]);
+		 loongarch_isa_ext_strings[preset.fpu]);
 
       /* Use the native value anyways.  */
-      PRESET_FPU = tmp;
+      preset.fpu = tmp;
 
 
       /* Fill: loongarch_cpu_default_isa[CPU_NATIVE].simd
 	 With: SIMD extension type (LSX, LASX)
 	 At:   cpucfg_words[2][7:6] */
 
-      #define PRESET_SIMD (loongarch_cpu_default_isa[tgt->cpu_arch].simd)
       switch (cpucfg_cache[2] & 0xc0)
 	{
 	  case 0xc0:
@@ -215,14 +226,34 @@ fill_native_cpu_config (struct loongarch_target *tgt)
       /* Check consistency with PRID presets.  */
 
       /*
-      if (native_cpu_type != CPU_NATIVE && tmp != PRESET_SIMD)
+      if (native_cpu_type != CPU_NATIVE && tmp != preset.simd)
 	warning (0, "SIMD extension %qs differs from PRID preset %qs",
 		 loongarch_isa_ext_strings[tmp],
-		 loongarch_isa_ext_strings[PRESET_SIMD]);
+		 loongarch_isa_ext_strings[preset.simd]);
       */
 
       /* Use the native value anyways.  */
-      PRESET_SIMD = tmp;
+      preset.simd = tmp;
+
+      /* Features added during ISA evolution.  */
+      for (const auto &entry: cpucfg_map)
+	if (cpucfg_cache[entry.cpucfg_word] & entry.cpucfg_bit)
+	  preset.evolution |= entry.isa_evolution_bit;
+
+      if (native_cpu_type != CPU_NATIVE)
+	{
+	  /* Check if the local CPU really supports the features of the base
+	     ISA of probed native_cpu_type.  If any feature is not detected,
+	     either GCC or the hardware is buggy.  */
+	  auto base_isa_feature = loongarch_isa_base_features[preset.base];
+	  if ((preset.evolution & base_isa_feature) != base_isa_feature)
+	    warning (0,
+		     "detected base architecture %qs, but some of its "
+		     "features are not detected; the detected base "
+		     "architecture may be unreliable, only detected "
+		     "features will be enabled",
+		     loongarch_isa_base_strings[preset.base]);
+	}
     }
 
   if (tune_native_p)
@@ -233,7 +264,7 @@ fill_native_cpu_config (struct loongarch_target *tgt)
 	 With: cache size info
 	 At:   cpucfg_words[16:20][31:0] */
 
-      #define PRESET_CACHE (loongarch_cpu_cache[tgt->cpu_tune])
+      auto &preset_cache = loongarch_cpu_cache[tgt->cpu_tune];
       struct loongarch_cache native_cache;
       int l1d_present = 0, l1u_present = 0;
       int l2d_present = 0;
@@ -264,8 +295,8 @@ fill_native_cpu_config (struct loongarch_target *tgt)
 	>> 10;					  /* in kibibytes */
 
       /* Use the native value anyways.  */
-      PRESET_CACHE.l1d_line_size = native_cache.l1d_line_size;
-      PRESET_CACHE.l1d_size = native_cache.l1d_size;
-      PRESET_CACHE.l2d_size = native_cache.l2d_size;
+      preset_cache.l1d_line_size = native_cache.l1d_line_size;
+      preset_cache.l1d_size = native_cache.l1d_size;
+      preset_cache.l2d_size = native_cache.l2d_size;
     }
 }
diff --git a/gcc/config/loongarch/loongarch-cpucfg-map.h b/gcc/config/loongarch/loongarch-cpucfg-map.h
new file mode 100644
index 0000000..02ff167
--- /dev/null
+++ b/gcc/config/loongarch/loongarch-cpucfg-map.h
@@ -0,0 +1,50 @@
+/* Generated automatically by "genstr" from "isa-evolution.in".
+   Please do not edit this file directly.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 3, or (at your option)
+any later version.
+
+GCC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+#ifndef LOONGARCH_CPUCFG_MAP_H
+#define LOONGARCH_CPUCFG_MAP_H
+
+#include "options.h"
+
+static constexpr struct {
+  int cpucfg_word;
+  unsigned int cpucfg_bit;
+  HOST_WIDE_INT isa_evolution_bit;
+} cpucfg_map[] = {
+  { 2, 1u << 26, OPTION_MASK_ISA_DIV32 },
+  { 2, 1u << 27, OPTION_MASK_ISA_LAM_BH },
+  { 2, 1u << 28, OPTION_MASK_ISA_LAMCAS },
+  { 3, 1u << 23, OPTION_MASK_ISA_LD_SEQ_SA },
+};
+
+static constexpr int cpucfg_useful_idx[] = {
+  0,
+  1,
+  2,
+  3,
+  16,
+  17,
+  18,
+  19,
+};
+
+static constexpr int N_CPUCFG_WORDS = 20;
+#endif /* LOONGARCH_CPUCFG_MAP_H */
diff --git a/gcc/config/loongarch/loongarch-def.c b/gcc/config/loongarch/loongarch-def.c
index 430ef8b..f22d488 100644
--- a/gcc/config/loongarch/loongarch-def.c
+++ b/gcc/config/loongarch/loongarch-def.c
@@ -28,6 +28,7 @@ loongarch_cpu_strings[N_TUNE_TYPES] = {
   [CPU_ABI_DEFAULT]	  = STR_CPU_ABI_DEFAULT,
   [CPU_LOONGARCH64]	  = STR_CPU_LOONGARCH64,
   [CPU_LA464]		  = STR_CPU_LA464,
+  [CPU_LA664]		  = STR_CPU_LA664,
 };
 
 struct loongarch_isa
@@ -42,6 +43,11 @@ loongarch_cpu_default_isa[N_ARCH_TYPES] = {
       .fpu = ISA_EXT_FPU64,
       .simd = ISA_EXT_SIMD_LASX,
   },
+  [CPU_LA664] = {
+      .base = ISA_BASE_LA64V110,
+      .fpu = ISA_EXT_FPU64,
+      .simd = ISA_EXT_SIMD_LASX,
+  },
 };
 
 struct loongarch_cache
@@ -58,6 +64,12 @@ loongarch_cpu_cache[N_TUNE_TYPES] = {
       .l2d_size = 256,
       .simultaneous_prefetches = 4,
   },
+  [CPU_LA664] = {
+      .l1d_line_size = 64,
+      .l1d_size = 64,
+      .l2d_size = 256,
+      .simultaneous_prefetches = 4,
+  },
 };
 
 struct loongarch_align
@@ -70,6 +82,10 @@ loongarch_cpu_align[N_TUNE_TYPES] = {
     .function = "32",
     .label = "16",
   },
+  [CPU_LA664] = {
+    .function = "32",
+    .label = "16",
+  },
 };
 
 
@@ -104,6 +120,9 @@ loongarch_cpu_rtx_cost_data[N_TUNE_TYPES] = {
   [CPU_LA464] = {
       DEFAULT_COSTS
   },
+  [CPU_LA664] = {
+      DEFAULT_COSTS
+  },
 };
 
 /* RTX costs to use when optimizing for size.  */
@@ -127,6 +146,7 @@ loongarch_cpu_issue_rate[N_TUNE_TYPES] = {
   [CPU_NATIVE]	      = 4,
   [CPU_LOONGARCH64]   = 4,
   [CPU_LA464]	      = 4,
+  [CPU_LA664]	      = 6,
 };
 
 int
@@ -134,6 +154,7 @@ loongarch_cpu_multipass_dfa_lookahead[N_TUNE_TYPES] = {
   [CPU_NATIVE]	      = 4,
   [CPU_LOONGARCH64]   = 4,
   [CPU_LA464]	      = 4,
+  [CPU_LA664]	      = 6,
 };
 
 /* Wiring string definitions from loongarch-str.h to global arrays
@@ -144,6 +165,7 @@ loongarch_cpu_multipass_dfa_lookahead[N_TUNE_TYPES] = {
 const char*
 loongarch_isa_base_strings[N_ISA_BASE_TYPES] = {
   [ISA_BASE_LA64V100] = STR_ISA_BASE_LA64V100,
+  [ISA_BASE_LA64V110] = STR_ISA_BASE_LA64V110,
 };
 
 const char*
diff --git a/gcc/config/loongarch/loongarch-def.h b/gcc/config/loongarch/loongarch-def.h
index 6e2a698..af7bd63 100644
--- a/gcc/config/loongarch/loongarch-def.h
+++ b/gcc/config/loongarch/loongarch-def.h
@@ -46,6 +46,7 @@ along with GCC; see the file COPYING3.  If not see
 #ifndef LOONGARCH_DEF_H
 #define LOONGARCH_DEF_H
 
+#include <stdint.h>
 #include "loongarch-tune.h"
 
 #ifdef __cplusplus
@@ -54,8 +55,16 @@ extern "C" {
 
 /* enum isa_base */
 extern const char* loongarch_isa_base_strings[];
+
+/* LoongArch V1.00.  */
 #define ISA_BASE_LA64V100     0
-#define N_ISA_BASE_TYPES      1
+/* LoongArch V1.10.  */
+#define ISA_BASE_LA64V110     1
+#define N_ISA_BASE_TYPES      2
+
+/* Unlike other arrays, this is defined in loongarch-cpu.cc.  The problem is
+   we cannot use the C++ header options.h in loongarch-def.c.  */
+extern int64_t loongarch_isa_base_features[];
 
 /* enum isa_ext_* */
 extern const char* loongarch_isa_ext_strings[];
@@ -118,6 +127,12 @@ struct loongarch_isa
   int base;	    /* ISA_BASE_ */
   int fpu;	    /* ISA_EXT_FPU_ */
   int simd;	    /* ISA_EXT_SIMD_ */
+
+  /* ISA evolution features implied by -march=, for -march=native probed
+     via CPUCFG.  The features implied by base may be not included here.
+
+     Using int64_t instead of HOST_WIDE_INT for C compatibility.  */
+  int64_t evolution;
 };
 
 struct loongarch_abi
@@ -141,8 +156,9 @@ struct loongarch_target
 #define CPU_ABI_DEFAULT   1
 #define CPU_LOONGARCH64	  2
 #define CPU_LA464	  3
-#define N_ARCH_TYPES	  4
-#define N_TUNE_TYPES	  4
+#define CPU_LA664	  4
+#define N_ARCH_TYPES	  5
+#define N_TUNE_TYPES	  5
 
 /* parallel tables.  */
 extern const char* loongarch_cpu_strings[];
diff --git a/gcc/config/loongarch/loongarch-driver.h b/gcc/config/loongarch/loongarch-driver.h
index d859afc..20d233c 100644
--- a/gcc/config/loongarch/loongarch-driver.h
+++ b/gcc/config/loongarch/loongarch-driver.h
@@ -51,9 +51,23 @@ along with GCC; see the file COPYING3.  If not see
   "%{G*} %{,ada:-gnatea %{mabi=*} -gnatez} " \
   "%(subtarget_cc1_spec)"
 
+#if HAVE_AS_MRELAX_OPTION && HAVE_AS_COND_BRANCH_RELAXATION
+#define ASM_MRELAX_DEFAULT "%{!mrelax:%{!mno-relax:-mrelax}}"
+#else
+#define ASM_MRELAX_DEFAULT "%{!mrelax:%{!mno-relax:-mno-relax}}"
+#endif
+
+#if HAVE_AS_MRELAX_OPTION
+#define ASM_MRELAX_SPEC \
+  "%{!mno-pass-mrelax-to-as:%{mrelax} %{mno-relax} " ASM_MRELAX_DEFAULT "}"
+#else
+#define ASM_MRELAX_SPEC \
+  "%{mpass-mrelax-to-as:%{mrelax} %{mno-relax} " ASM_MRELAX_DEFAULT "}"
+#endif
+
 #undef ASM_SPEC
 #define ASM_SPEC \
-  "%{mabi=*} %{mno-relax} %(subtarget_asm_spec)"
+  "%{mabi=*} " ASM_MRELAX_SPEC " %(subtarget_asm_spec)"
 
 
 extern const char*
diff --git a/gcc/config/loongarch/loongarch-opts.cc b/gcc/config/loongarch/loongarch-opts.cc
index e592118..b5836f1 100644
--- a/gcc/config/loongarch/loongarch-opts.cc
+++ b/gcc/config/loongarch/loongarch-opts.cc
@@ -284,6 +284,9 @@ config_target_isa:
   /* Get default ISA from "-march" or its default value.  */
   t.isa = loongarch_cpu_default_isa[t.cpu_arch];
 
+  if (t.cpu_arch != CPU_NATIVE)
+    t.isa.evolution |= loongarch_isa_base_features[t.isa.base];
+
   /* Apply incremental changes.  */
   /* "-march=native" overrides the default FPU type.  */
 
@@ -552,17 +555,17 @@ isa_default_abi (const struct loongarch_isa *isa)
   switch (isa->fpu)
     {
       case ISA_EXT_FPU64:
-	if (isa->base == ISA_BASE_LA64V100)
+	if (isa->base >= ISA_BASE_LA64V100)
 	  abi.base = ABI_BASE_LP64D;
 	break;
 
       case ISA_EXT_FPU32:
-	if (isa->base == ISA_BASE_LA64V100)
+	if (isa->base >= ISA_BASE_LA64V100)
 	  abi.base = ABI_BASE_LP64F;
 	break;
 
       case ISA_EXT_NONE:
-	if (isa->base == ISA_BASE_LA64V100)
+	if (isa->base >= ISA_BASE_LA64V100)
 	  abi.base = ABI_BASE_LP64S;
 	break;
 
@@ -582,7 +585,7 @@ isa_base_compat_p (const struct loongarch_isa *set1,
   switch (set2->base)
     {
       case ISA_BASE_LA64V100:
-	return (set1->base == ISA_BASE_LA64V100);
+	return (set1->base >= ISA_BASE_LA64V100);
 
       default:
 	gcc_unreachable ();
diff --git a/gcc/config/loongarch/loongarch-opts.h b/gcc/config/loongarch/loongarch-opts.h
index f204828..fa37732 100644
--- a/gcc/config/loongarch/loongarch-opts.h
+++ b/gcc/config/loongarch/loongarch-opts.h
@@ -76,7 +76,8 @@ loongarch_update_gcc_opt_status (struct loongarch_target *target,
 #define TARGET_DOUBLE_FLOAT	  (la_target.isa.fpu == ISA_EXT_FPU64)
 #define TARGET_DOUBLE_FLOAT_ABI	  (la_target.abi.base == ABI_BASE_LP64D)
 
-#define TARGET_64BIT		  (la_target.isa.base == ISA_BASE_LA64V100)
+#define TARGET_64BIT		  (la_target.isa.base == ISA_BASE_LA64V100 \
+				   || la_target.isa.base == ISA_BASE_LA64V110)
 #define TARGET_ABI_LP64		  (la_target.abi.base == ABI_BASE_LP64D	\
 				   || la_target.abi.base == ABI_BASE_LP64F \
 				   || la_target.abi.base == ABI_BASE_LP64S)
@@ -85,9 +86,10 @@ loongarch_update_gcc_opt_status (struct loongarch_target *target,
 				   || la_target.isa.simd == ISA_EXT_SIMD_LASX)
 #define ISA_HAS_LASX		  (la_target.isa.simd == ISA_EXT_SIMD_LASX)
 
-
 /* TARGET_ macros for use in *.md template conditionals */
 #define TARGET_uARCH_LA464	  (la_target.cpu_tune == CPU_LA464)
+#define TARGET_uARCH_LA664	  (la_target.cpu_tune == CPU_LA664)
+#define ISA_BASE_IS_LA64V110	  (la_target.isa.base == ISA_BASE_LA64V110)
 
 /* Note: optimize_size may vary across functions,
    while -m[no]-memcpy imposes a global constraint.  */
@@ -97,10 +99,18 @@ loongarch_update_gcc_opt_status (struct loongarch_target *target,
 #define HAVE_AS_EXPLICIT_RELOCS 0
 #endif
 
+#ifndef HAVE_AS_SUPPORT_CALL36
+#define HAVE_AS_SUPPORT_CALL36 0
+#endif
+
 #ifndef HAVE_AS_MRELAX_OPTION
 #define HAVE_AS_MRELAX_OPTION 0
 #endif
 
+#ifndef HAVE_AS_COND_BRANCH_RELAXATION
+#define HAVE_AS_COND_BRANCH_RELAXATION 0
+#endif
+
 #ifndef HAVE_AS_TLS
 #define HAVE_AS_TLS 0
 #endif
diff --git a/gcc/config/loongarch/loongarch-str.h b/gcc/config/loongarch/loongarch-str.h
index 072558c..0384493 100644
--- a/gcc/config/loongarch/loongarch-str.h
+++ b/gcc/config/loongarch/loongarch-str.h
@@ -1,5 +1,5 @@
-/* Generated automatically by "genstr" from "loongarch-strings".
-   Please do not edit this file directly.
+/* Generated automatically by "genstr" from "loongarch-strings" and
+   "isa-evolution.in".  Please do not edit this file directly.
 
    Copyright (C) 2021-2023 Free Software Foundation, Inc.
    Contributed by Loongson Ltd.
@@ -30,8 +30,10 @@ along with GCC; see the file COPYING3.  If not see
 #define STR_CPU_ABI_DEFAULT "abi-default"
 #define STR_CPU_LOONGARCH64 "loongarch64"
 #define STR_CPU_LA464 "la464"
+#define STR_CPU_LA664 "la664"
 
 #define STR_ISA_BASE_LA64V100 "la64"
+#define STR_ISA_BASE_LA64V110 "la64v1.1"
 
 #define OPTSTR_ISA_EXT_FPU "fpu"
 #define STR_NONE "none"
@@ -67,4 +69,9 @@ along with GCC; see the file COPYING3.  If not see
 #define STR_EXPLICIT_RELOCS_NONE "none"
 #define STR_EXPLICIT_RELOCS_ALWAYS "always"
 
+#define OPTSTR_DIV32	"div32"
+#define OPTSTR_LAM_BH	"lam-bh"
+#define OPTSTR_LAMCAS	"lamcas"
+#define OPTSTR_LD_SEQ_SA	"ld-seq-sa"
+
 #endif /* LOONGARCH_STR_H */
diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc
index 0a2db84..ce601a3 100644
--- a/gcc/config/loongarch/loongarch.cc
+++ b/gcc/config/loongarch/loongarch.cc
@@ -3006,12 +3006,16 @@ loongarch_legitimize_call_address (rtx addr)
 
   enum loongarch_symbol_type symbol_type = loongarch_classify_symbol (addr);
 
-  /* Split function call insn 'bl sym' or 'bl %plt(sym)' to :
-     pcalau12i $rd, %pc_hi20(sym)
-     jr $rd, %pc_lo12(sym).  */
+  /* If add the compilation option '-cmodel=medium', and the assembler does
+     not support call36.  The following sequence of instructions will be
+     used for the function call:
+	pcalau12i $rd, %pc_hi20(sym)
+	jr $rd, %pc_lo12(sym)
+  */
 
   if (TARGET_CMODEL_MEDIUM
-      && TARGET_EXPLICIT_RELOCS
+      && !HAVE_AS_SUPPORT_CALL36
+      && (la_opt_explicit_relocs != EXPLICIT_RELOCS_NONE)
       && (SYMBOL_REF_P (addr) || LABEL_REF_P (addr))
       && (symbol_type == SYMBOL_PCREL
 	  || (symbol_type == SYMBOL_GOT_DISP && flag_plt)))
@@ -3893,11 +3897,9 @@ loongarch_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost,
       case scalar_stmt:
       case scalar_load:
       case vector_stmt:
-      case vector_load:
       case vec_to_scalar:
       case scalar_to_vec:
       case scalar_store:
-      case vector_store:
 	return 1;
 
       case vec_promote_demote:
@@ -3905,6 +3907,8 @@ loongarch_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost,
 	return LASX_SUPPORTED_MODE_P (mode)
 	  && !LSX_SUPPORTED_MODE_P (mode) ? 2 : 1;
 
+      case vector_load:
+      case vector_store:
       case unaligned_load:
       case unaligned_store:
 	return 2;
@@ -5813,16 +5817,12 @@ loongarch_print_operand_punct_valid_p (unsigned char code)
 static bool
 loongarch_memmodel_needs_rel_acq_fence (enum memmodel model)
 {
-  switch (model)
+  switch (memmodel_base (model))
     {
       case MEMMODEL_ACQ_REL:
       case MEMMODEL_SEQ_CST:
-      case MEMMODEL_SYNC_SEQ_CST:
       case MEMMODEL_RELEASE:
-      case MEMMODEL_SYNC_RELEASE:
       case MEMMODEL_ACQUIRE:
-      case MEMMODEL_CONSUME:
-      case MEMMODEL_SYNC_ACQUIRE:
 	return true;
 
       case MEMMODEL_RELAXED:
@@ -5833,27 +5833,27 @@ loongarch_memmodel_needs_rel_acq_fence (enum memmodel model)
     }
 }
 
-/* Return true if a FENCE should be emitted to before a memory access to
-   implement the release portion of memory model MODEL.  */
+/* Return true if a FENCE should be emitted after a failed CAS to
+   implement the acquire semantic of failure_memorder.  */
 
 static bool
-loongarch_memmodel_needs_release_fence (enum memmodel model)
+loongarch_cas_failure_memorder_needs_acquire (enum memmodel model)
 {
-  switch (model)
+  switch (memmodel_base (model))
     {
+    case MEMMODEL_ACQUIRE:
     case MEMMODEL_ACQ_REL:
     case MEMMODEL_SEQ_CST:
-    case MEMMODEL_SYNC_SEQ_CST:
-    case MEMMODEL_RELEASE:
-    case MEMMODEL_SYNC_RELEASE:
       return true;
 
-    case MEMMODEL_ACQUIRE:
-    case MEMMODEL_CONSUME:
-    case MEMMODEL_SYNC_ACQUIRE:
     case MEMMODEL_RELAXED:
+    case MEMMODEL_RELEASE:
       return false;
 
+    /* MEMMODEL_CONSUME is deliberately not handled because it's always
+       replaced by MEMMODEL_ACQUIRE as at now.  If you see an ICE caused by
+       MEMMODEL_CONSUME, read the change (re)introducing it carefully and
+       decide what to do.  See PR 59448 and get_memmodel in builtins.cc.  */
     default:
       gcc_unreachable ();
     }
@@ -5966,7 +5966,8 @@ loongarch_print_operand_reloc (FILE *file, rtx op, bool hi64_part,
    'd'	Print CONST_INT OP in decimal.
    'E'	Print CONST_INT OP element 0 of a replicated CONST_VECTOR in decimal.
    'F'	Print the FPU branch condition for comparison OP.
-   'G'	Print a DBAR insn if the memory model requires a release.
+   'G'	Print a DBAR insn for CAS failure (with an acquire semantic if
+	needed, otherwise a simple load-load barrier).
    'H'  Print address 52-61bit relocation associated with OP.
    'h'  Print the high-part relocation associated with OP.
    'i'	Print i if the operand is not a register.
@@ -6057,8 +6058,11 @@ loongarch_print_operand (FILE *file, rtx op, int letter)
       break;
 
     case 'G':
-      if (loongarch_memmodel_needs_release_fence ((enum memmodel) INTVAL (op)))
-	fputs ("dbar\t0", file);
+      if (loongarch_cas_failure_memorder_needs_acquire (
+	    memmodel_from_int (INTVAL (op))))
+	fputs ("dbar\t0b10100", file);
+      else if (!TARGET_LD_SEQ_SA)
+	fputs ("dbar\t0x700", file);
       break;
 
     case 'h':
@@ -7432,7 +7436,7 @@ loongarch_option_override_internal (struct gcc_options *opts,
 
   if (la_opt_explicit_relocs == M_OPT_UNSET)
     la_opt_explicit_relocs = (HAVE_AS_EXPLICIT_RELOCS
-			      ? (HAVE_AS_MRELAX_OPTION
+			      ? (loongarch_mrelax
 				 ? EXPLICIT_RELOCS_AUTO
 				 : EXPLICIT_RELOCS_ALWAYS)
 			      : EXPLICIT_RELOCS_NONE);
@@ -7451,6 +7455,10 @@ loongarch_option_override_internal (struct gcc_options *opts,
   if (loongarch_branch_cost == 0)
     loongarch_branch_cost = loongarch_cost->branch_cost;
 
+  /* If the user hasn't disabled a feature added during ISA evolution,
+     use the processor's default.  */
+  isa_evolution |= (la_target.isa.evolution &
+		    ~global_options_set.x_isa_evolution);
 
   /* Enable sw prefetching at -O3 and higher.  */
   if (opts->x_flag_prefetch_loop_arrays < 0
@@ -10169,6 +10177,7 @@ loongarch_cpu_sched_reassociation_width (struct loongarch_target *target,
     {
     case CPU_LOONGARCH64:
     case CPU_LA464:
+    case CPU_LA664:
       /* Vector part.  */
       if (LSX_SUPPORTED_MODE_P (mode) || LASX_SUPPORTED_MODE_P (mode))
 	{
@@ -11429,6 +11438,32 @@ loongarch_builtin_support_vector_misalignment (machine_mode mode,
 						      is_packed);
 }
 
+/* If -fverbose-asm, dump some info for debugging.  */
+static void
+loongarch_asm_code_end (void)
+{
+#define DUMP_FEATURE(PRED) \
+  fprintf (asm_out_file, "%s %s: %s\n", ASM_COMMENT_START, #PRED, \
+	   (PRED) ? "enabled" : "disabled")
+
+  if (flag_verbose_asm)
+    {
+      fprintf (asm_out_file, "\n%s CPU: %s\n", ASM_COMMENT_START,
+	       loongarch_cpu_strings [la_target.cpu_arch]);
+      fprintf (asm_out_file, "%s Tune: %s\n", ASM_COMMENT_START,
+	       loongarch_cpu_strings [la_target.cpu_tune]);
+      fprintf (asm_out_file, "%s Base ISA: %s\n", ASM_COMMENT_START,
+	       loongarch_isa_base_strings [la_target.isa.base]);
+      DUMP_FEATURE (TARGET_DIV32);
+      DUMP_FEATURE (TARGET_LAM_BH);
+      DUMP_FEATURE (TARGET_LAMCAS);
+      DUMP_FEATURE (TARGET_LD_SEQ_SA);
+    }
+
+  fputs ("\n\n", asm_out_file);
+#undef DUMP_FEATURE
+}
+
 /* Initialize the GCC target structure.  */
 #undef TARGET_ASM_ALIGNED_HI_OP
 #define TARGET_ASM_ALIGNED_HI_OP "\t.half\t"
@@ -11448,6 +11483,9 @@ loongarch_builtin_support_vector_misalignment (machine_mode mode,
 #undef TARGET_ASM_FUNCTION_RODATA_SECTION
 #define TARGET_ASM_FUNCTION_RODATA_SECTION loongarch_function_rodata_section
 
+#undef TARGET_ASM_CODE_END
+#define TARGET_ASM_CODE_END loongarch_asm_code_end
+
 #undef TARGET_SCHED_INIT
 #define TARGET_SCHED_INIT loongarch_sched_init
 #undef TARGET_SCHED_REORDER
diff --git a/gcc/config/loongarch/loongarch.h b/gcc/config/loongarch/loongarch.h
index ddac8e9..115222e 100644
--- a/gcc/config/loongarch/loongarch.h
+++ b/gcc/config/loongarch/loongarch.h
@@ -1239,3 +1239,8 @@ struct GTY (()) machine_function
 
 #define TARGET_EXPLICIT_RELOCS \
   (la_opt_explicit_relocs == EXPLICIT_RELOCS_ALWAYS)
+
+#define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) \
+  ((VALUE) = GET_MODE_UNIT_BITSIZE (MODE), 2)
+#define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) \
+  ((VALUE) = GET_MODE_UNIT_BITSIZE (MODE), 2)
diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md
index 22814a3..cd4ed49 100644
--- a/gcc/config/loongarch/loongarch.md
+++ b/gcc/config/loongarch/loongarch.md
@@ -408,6 +408,10 @@
 ;; st.w.
 (define_mode_iterator ST_ANY [QHWD ANYF])
 
+;; A mode for anything legal as a input of a div or mod instruction.
+(define_mode_iterator DIV [(DI "TARGET_64BIT")
+			   (SI "!TARGET_64BIT || TARGET_DIV32")])
+
 ;; In GPR templates, a string like "mul.<d>" will expand to "mul.w" in the
 ;; 32-bit version and "mul.d" in the 64-bit version.
 (define_mode_attr d [(SI "w") (DI "d")])
@@ -914,7 +918,7 @@
 		     (match_operand:GPR 2 "register_operand")))]
   ""
 {
- if (GET_MODE (operands[0]) == SImode && TARGET_64BIT)
+ if (GET_MODE (operands[0]) == SImode && TARGET_64BIT && !TARGET_DIV32)
   {
     rtx reg1 = gen_reg_rtx (DImode);
     rtx reg2 = gen_reg_rtx (DImode);
@@ -934,9 +938,9 @@
 })
 
 (define_insn "*<optab><mode>3"
-  [(set (match_operand:X 0 "register_operand" "=r,&r,&r")
-	(any_div:X (match_operand:X 1 "register_operand" "r,r,0")
-		   (match_operand:X 2 "register_operand" "r,r,r")))]
+  [(set (match_operand:DIV 0 "register_operand" "=r,&r,&r")
+	(any_div:DIV (match_operand:DIV 1 "register_operand" "r,r,0")
+		     (match_operand:DIV 2 "register_operand" "r,r,r")))]
   ""
 {
   return loongarch_output_division ("<insn>.<d><u>\t%0,%1,%2", operands);
@@ -949,6 +953,23 @@
 	(const_string "yes")
 	(const_string "no")))])
 
+(define_insn "<optab>si3_extended"
+  [(set (match_operand:DI 0 "register_operand" "=r,&r,&r")
+	(sign_extend
+	  (any_div:SI (match_operand:SI 1 "register_operand" "r,r,0")
+		      (match_operand:SI 2 "register_operand" "r,r,r"))))]
+  "TARGET_64BIT && TARGET_DIV32"
+{
+  return loongarch_output_division ("<insn>.w<u>\t%0,%1,%2", operands);
+}
+  [(set_attr "type" "idiv")
+   (set_attr "mode" "SI")
+   (set (attr "enabled")
+      (if_then_else
+	(match_test "!!which_alternative == loongarch_check_zero_div_p()")
+	(const_string "yes")
+	(const_string "no")))])
+
 (define_insn "<optab>di3_fake"
   [(set (match_operand:DI 0 "register_operand" "=r,&r,&r")
 	(sign_extend:DI
@@ -957,7 +978,7 @@
 	     (any_div:DI (match_operand:DI 1 "register_operand" "r,r,0")
 			 (match_operand:DI 2 "register_operand" "r,r,r")) 0)]
 	  UNSPEC_FAKE_ANY_DIV)))]
-  "TARGET_64BIT"
+  "TARGET_64BIT && !TARGET_DIV32"
 {
   return loongarch_output_division ("<insn>.w<u>\t%0,%1,%2", operands);
 }
@@ -3274,7 +3295,13 @@
 					    XEXP (target, 1),
 					    operands[1]));
   else
-    emit_call_insn (gen_sibcall_internal (target, operands[1]));
+    {
+      rtx call = emit_call_insn (gen_sibcall_internal (target, operands[1]));
+
+      if (TARGET_CMODEL_MEDIUM && !REG_P (target))
+	clobber_reg (&CALL_INSN_FUNCTION_USAGE (call),
+		     gen_rtx_REG (Pmode, T0_REGNUM));
+    }
   DONE;
 })
 
@@ -3282,10 +3309,25 @@
   [(call (mem:SI (match_operand 0 "call_insn_operand" "j,c,b"))
 	 (match_operand 1 "" ""))]
   "SIBLING_CALL_P (insn)"
-  "@
-   jr\t%0
-   b\t%0
-   b\t%%plt(%0)"
+{
+  switch (which_alternative)
+    {
+    case 0:
+      return "jr\t%0";
+    case 1:
+      if (TARGET_CMODEL_MEDIUM)
+	return "pcaddu18i\t$r12,%%call36(%0)\n\tjirl\t$r0,$r12,0";
+      else
+	return "b\t%0";
+    case 2:
+      if (TARGET_CMODEL_MEDIUM)
+	return "pcaddu18i\t$r12,%%call36(%0)\n\tjirl\t$r0,$r12,0";
+      else
+	return "b\t%%plt(%0)";
+    default:
+      gcc_unreachable ();
+    }
+}
   [(set_attr "jirl" "indirect,direct,direct")])
 
 (define_insn "@sibcall_internal_1<mode>"
@@ -3318,9 +3360,17 @@
 							   operands[2],
 							   arg2));
       else
-	emit_call_insn (gen_sibcall_value_multiple_internal (arg1, target,
-							   operands[2],
-							   arg2));
+	{
+	  rtx call
+	    = emit_call_insn (gen_sibcall_value_multiple_internal (arg1,
+								   target,
+								   operands[2],
+								   arg2));
+
+	  if (TARGET_CMODEL_MEDIUM && !REG_P (target))
+	    clobber_reg (&CALL_INSN_FUNCTION_USAGE (call),
+			gen_rtx_REG (Pmode, T0_REGNUM));
+	}
     }
    else
     {
@@ -3334,8 +3384,15 @@
 						  XEXP (target, 1),
 						  operands[2]));
       else
-	emit_call_insn (gen_sibcall_value_internal (operands[0], target,
-						  operands[2]));
+	{
+	  rtx call = emit_call_insn (gen_sibcall_value_internal (operands[0],
+								 target,
+								 operands[2]));
+
+	  if (TARGET_CMODEL_MEDIUM && !REG_P (target))
+	    clobber_reg (&CALL_INSN_FUNCTION_USAGE (call),
+			gen_rtx_REG (Pmode, T0_REGNUM));
+	}
     }
   DONE;
 })
@@ -3345,10 +3402,25 @@
 	(call (mem:SI (match_operand 1 "call_insn_operand" "j,c,b"))
 	      (match_operand 2 "" "")))]
   "SIBLING_CALL_P (insn)"
-  "@
-   jr\t%1
-   b\t%1
-   b\t%%plt(%1)"
+{
+  switch (which_alternative)
+    {
+    case 0:
+      return "jr\t%1";
+    case 1:
+      if (TARGET_CMODEL_MEDIUM)
+	return "pcaddu18i\t$r12,%%call36(%1)\n\tjirl\t$r0,$r12,0";
+      else
+	return "b\t%1";
+    case 2:
+      if (TARGET_CMODEL_MEDIUM)
+	return "pcaddu18i\t$r12,%%call36(%1)\n\tjirl\t$r0,$r12,0";
+      else
+	return "b\t%%plt(%1)";
+    default:
+      gcc_unreachable ();
+    }
+}
   [(set_attr "jirl" "indirect,direct,direct")])
 
 (define_insn "@sibcall_value_internal_1<mode>"
@@ -3368,10 +3440,25 @@
 	(call (mem:SI (match_dup 1))
 	      (match_dup 2)))]
   "SIBLING_CALL_P (insn)"
-  "@
-   jr\t%1
-   b\t%1
-   b\t%%plt(%1)"
+{
+  switch (which_alternative)
+    {
+    case 0:
+      return "jr\t%1";
+    case 1:
+      if (TARGET_CMODEL_MEDIUM)
+	return "pcaddu18i\t$r12,%%call36(%1)\n\tjirl\t$r0,$r12,0";
+      else
+	return "b\t%1";
+    case 2:
+      if (TARGET_CMODEL_MEDIUM)
+	return "pcaddu18i\t$r12,%%call36(%1)\n\tjirl\t$r0,$r12,0";
+      else
+	return "b\t%%plt(%1)";
+    default:
+      gcc_unreachable ();
+    }
+}
   [(set_attr "jirl" "indirect,direct,direct")])
 
 (define_insn "@sibcall_value_multiple_internal_1<mode>"
@@ -3411,10 +3498,25 @@
 	 (match_operand 1 "" ""))
    (clobber (reg:SI RETURN_ADDR_REGNUM))]
   ""
-  "@
-   jirl\t$r1,%0,0
-   bl\t%0
-   bl\t%%plt(%0)"
+{
+  switch (which_alternative)
+    {
+    case 0:
+      return "jirl\t$r1,%0,0";
+    case 1:
+      if (TARGET_CMODEL_MEDIUM)
+	return "pcaddu18i\t$r1,%%call36(%0)\n\tjirl\t$r1,$r1,0";
+      else
+	return "bl\t%0";
+    case 2:
+      if (TARGET_CMODEL_MEDIUM)
+	return "pcaddu18i\t$r1,%%call36(%0)\n\tjirl\t$r1,$r1,0";
+      else
+	return "bl\t%%plt(%0)";
+    default:
+      gcc_unreachable ();
+    }
+}
   [(set_attr "jirl" "indirect,direct,direct")])
 
 (define_insn "@call_internal_1<mode>"
@@ -3473,10 +3575,25 @@
 	      (match_operand 2 "" "")))
    (clobber (reg:SI RETURN_ADDR_REGNUM))]
   ""
-  "@
-   jirl\t$r1,%1,0
-   bl\t%1
-   bl\t%%plt(%1)"
+{
+  switch (which_alternative)
+    {
+    case 0:
+      return "jirl\t$r1,%1,0";
+    case 1:
+      if (TARGET_CMODEL_MEDIUM)
+	return "pcaddu18i\t$r1,%%call36(%1)\n\tjirl\t$r1,$r1,0";
+      else
+	return "bl\t%1";
+    case 2:
+      if (TARGET_CMODEL_MEDIUM)
+	return "pcaddu18i\t$r1,%%call36(%1)\n\tjirl\t$r1,$r1,0";
+      else
+	return "bl\t%%plt(%1)";
+    default:
+      gcc_unreachable ();
+    }
+}
   [(set_attr "jirl" "indirect,direct,direct")])
 
 (define_insn "@call_value_internal_1<mode>"
@@ -3498,10 +3615,25 @@
 	      (match_dup 2)))
    (clobber (reg:SI RETURN_ADDR_REGNUM))]
   ""
-  "@
-   jirl\t$r1,%1,0
-   bl\t%1
-   bl\t%%plt(%1)"
+{
+  switch (which_alternative)
+    {
+    case 0:
+      return "jirl\t$r1,%1,0";
+    case 1:
+      if (TARGET_CMODEL_MEDIUM)
+	return "pcaddu18i\t$r1,%%call36(%1)\n\tjirl\t$r1,$r1,0";
+      else
+	return "bl\t%1";
+    case 2:
+      if (TARGET_CMODEL_MEDIUM)
+	return "pcaddu18i\t$r1,%%call36(%1)\n\tjirl\t$r1,$r1,0";
+      else
+	return "bl\t%%plt(%1)";
+    default:
+      gcc_unreachable ();
+    }
+}
   [(set_attr "jirl" "indirect,direct,direct")])
 
 (define_insn "@call_value_multiple_internal_1<mode>"
diff --git a/gcc/config/loongarch/loongarch.opt b/gcc/config/loongarch/loongarch.opt
index 0294660..4d36e3e 100644
--- a/gcc/config/loongarch/loongarch.opt
+++ b/gcc/config/loongarch/loongarch.opt
@@ -1,9 +1,10 @@
 ; Generated by "genstr" from the template "loongarch.opt.in"
-; and definitions from "loongarch-strings".
+; and definitions from "loongarch-strings" and "isa-evolution.in".
 ;
 ; Please do not edit this file directly.
 ; It will be automatically updated during a gcc build
-; if you change "loongarch.opt.in" or "loongarch-strings".
+; if you change "loongarch.opt.in", "loongarch-strings", or
+; "isa-evolution.in".
 ;
 ; Copyright (C) 2021-2023 Free Software Foundation, Inc.
 ;
@@ -39,6 +40,9 @@ Basic ISAs of LoongArch:
 EnumValue
 Enum(isa_base) String(la64) Value(ISA_BASE_LA64V100)
 
+EnumValue
+Enum(isa_base) String(la64v1.1) Value(ISA_BASE_LA64V110)
+
 ;; ISA extensions / adjustments
 Enum
 Name(isa_ext_fpu) Type(int)
@@ -114,6 +118,9 @@ Enum(cpu_type) String(loongarch64) Value(CPU_LOONGARCH64)
 EnumValue
 Enum(cpu_type) String(la464) Value(CPU_LA464)
 
+EnumValue
+Enum(cpu_type) String(la664) Value(CPU_LA664)
+
 march=
 Target RejectNegative Joined Enum(cpu_type) Var(la_opt_cpu_arch) Init(M_OPT_UNSET)
 -march=PROCESSOR	Generate code for the given PROCESSOR ISA.
@@ -230,10 +237,14 @@ Target Var(TARGET_DIRECT_EXTERN_ACCESS) Init(0)
 Avoid using the GOT to access external symbols.
 
 mrelax
-Target Var(loongarch_mrelax) Init(HAVE_AS_MRELAX_OPTION)
+Target Var(loongarch_mrelax) Init(HAVE_AS_MRELAX_OPTION && HAVE_AS_COND_BRANCH_RELAXATION)
 Take advantage of linker relaxations to reduce the number of instructions
 required to materialize symbol addresses.
 
+mpass-mrelax-to-as
+Target Var(loongarch_pass_mrelax_to_as) Init(HAVE_AS_MRELAX_OPTION)
+Pass -mrelax or -mno-relax option to the assembler.
+
 -param=loongarch-vect-unroll-limit=
 Target Joined UInteger Var(loongarch_vect_unroll_limit) Init(6) IntegerRange(1, 64) Param
 Used to limit unroll factor which indicates how much the autovectorizer may
@@ -244,3 +255,26 @@ Target Undocumented Joined UInteger Var(loongarch_vect_issue_info) Init(4) Integ
 Indicate how many non memory access vector instructions can be issued per
 cycle, it's used in unroll factor determination for autovectorizer.  The
 default value is 4.
+
+; Features added during ISA evolution.  This concept is different from ISA
+; extension, read Section 1.5 of LoongArch v1.10 Volume 1 for the
+; explanation.  These features may be implemented and enumerated with
+; CPUCFG independantly, so we use bit flags to specify them.
+Variable
+HOST_WIDE_INT isa_evolution = 0
+
+mdiv32
+Target Mask(ISA_DIV32) Var(isa_evolution)
+Support div.w[u] and mod.w[u] instructions with inputs not sign-extended.
+
+mlam-bh
+Target Mask(ISA_LAM_BH) Var(isa_evolution)
+Support am{swap/add}[_db].{b/h} instructions.
+
+mlamcas
+Target Mask(ISA_LAMCAS) Var(isa_evolution)
+Support amcas[_db].{b/h/w/d} instructions.
+
+mld-seq-sa
+Target Mask(ISA_LD_SEQ_SA) Var(isa_evolution)
+Do not need load-load barriers (dbar 0x700).
diff --git a/gcc/config/loongarch/lsx.md b/gcc/config/loongarch/lsx.md
index 55c7d79..8ea41c8 100644
--- a/gcc/config/loongarch/lsx.md
+++ b/gcc/config/loongarch/lsx.md
@@ -2873,11 +2873,31 @@
 	  (match_operand:FLSX 1 "register_operand")))
    (set (match_dup 5)
 	(and:FLSX (match_dup 3)
-		  (match_operand:FLSX 2 "register_operand")))
+		  (match_operand:FLSX 2 "reg_or_vector_same_val_operand")))
    (set (match_operand:FLSX 0 "register_operand")
 	(ior:FLSX (match_dup 4) (match_dup 5)))]
   "ISA_HAS_LSX"
 {
+  /* copysign (x, -1) should instead be expanded as setting the sign
+     bit.  */
+  if (!REG_P (operands[2]))
+    {
+      rtx op2_elt = unwrap_const_vec_duplicate (operands[2]);
+      if (GET_CODE (op2_elt) == CONST_DOUBLE
+	  && real_isneg (CONST_DOUBLE_REAL_VALUE (op2_elt)))
+	{
+	  rtx n = GEN_INT (8 * GET_MODE_SIZE (<UNITMODE>mode) - 1);
+	  operands[0] = lowpart_subreg (<VIMODE>mode, operands[0],
+					<MODE>mode);
+	  operands[1] = lowpart_subreg (<VIMODE>mode, operands[1],
+					<MODE>mode);
+	  emit_insn (gen_lsx_vbitseti_<lsxfmt> (operands[0], operands[1],
+						n));
+	  DONE;
+	}
+    }
+
+  operands[2] = force_reg (<MODE>mode, operands[2]);
   operands[3] = loongarch_build_signbit_mask (<MODE>mode, 1, 0);
 
   operands[4] = gen_reg_rtx (<MODE>mode);
diff --git a/gcc/config/loongarch/predicates.md b/gcc/config/loongarch/predicates.md
index 946ed0d..d02e846 100644
--- a/gcc/config/loongarch/predicates.md
+++ b/gcc/config/loongarch/predicates.md
@@ -443,19 +443,20 @@
     {
     case SYMBOL_PCREL:
       if (TARGET_CMODEL_EXTREME
-	  || (TARGET_CMODEL_MEDIUM && !TARGET_EXPLICIT_RELOCS))
+	  || (TARGET_CMODEL_MEDIUM
+	      && (la_opt_explicit_relocs == EXPLICIT_RELOCS_NONE)))
 	return false;
       else
-	return 1;
+	return true;
 
     case SYMBOL_GOT_DISP:
       if (TARGET_CMODEL_EXTREME
 	  || !flag_plt
 	  || (flag_plt && TARGET_CMODEL_MEDIUM
-	      && !TARGET_EXPLICIT_RELOCS))
+	      && (la_opt_explicit_relocs == EXPLICIT_RELOCS_NONE)))
 	return false;
       else
-	return 1;
+	return true;
 
     default:
       return false;
diff --git a/gcc/config/loongarch/sync.md b/gcc/config/loongarch/sync.md
index 9924d52..229fc50 100644
--- a/gcc/config/loongarch/sync.md
+++ b/gcc/config/loongarch/sync.md
@@ -30,6 +30,7 @@
   UNSPEC_SYNC_OLD_OP
   UNSPEC_SYNC_EXCHANGE
   UNSPEC_ATOMIC_STORE
+  UNSPEC_ATOMIC_LOAD
   UNSPEC_MEMORY_BARRIER
 ])
 
@@ -38,7 +39,7 @@
   [(plus "add") (ior "or") (xor "xor") (and "and")])
 
 ;; This attribute gives the format suffix for atomic memory operations.
-(define_mode_attr amo [(SI "w") (DI "d")])
+(define_mode_attr amo [(QI "b") (HI "h") (SI "w") (DI "d")])
 
 ;; <amop> expands to the name of the atomic operand that implements a
 ;; particular code.
@@ -50,36 +51,129 @@
   [(match_operand:SI 0 "const_int_operand" "")] ;; model
   ""
 {
-  if (INTVAL (operands[0]) != MEMMODEL_RELAXED)
-    {
-      rtx mem = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
-      MEM_VOLATILE_P (mem) = 1;
-      emit_insn (gen_mem_thread_fence_1 (mem, operands[0]));
-    }
+  rtx mem = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (Pmode));
+  MEM_VOLATILE_P (mem) = 1;
+  emit_insn (gen_mem_thread_fence_1 (mem, operands[0]));
+
   DONE;
 })
 
-;; Until the LoongArch memory model (hence its mapping from C++) is finalized,
-;; conservatively emit a full FENCE.
+;; DBAR hint encoding for LA664 and later micro-architectures, paraphrased from
+;; the Linux patch revealing it [1]:
+;;
+;; - Bit 4: kind of constraint (0: completion, 1: ordering)
+;; - Bit 3: barrier for previous read (0: true, 1: false)
+;; - Bit 2: barrier for previous write (0: true, 1: false)
+;; - Bit 1: barrier for succeeding read (0: true, 1: false)
+;; - Bit 0: barrier for succeeding write (0: true, 1: false)
+;;
+;; [1]: https://git.kernel.org/torvalds/c/e031a5f3f1ed
+;;
+;; Implementations without support for the finer-granularity hints simply treat
+;; all as the full barrier (DBAR 0), so we can unconditionally start emiting the
+;; more precise hints right away.
 (define_insn "mem_thread_fence_1"
   [(set (match_operand:BLK 0 "" "")
 	(unspec:BLK [(match_dup 0)] UNSPEC_MEMORY_BARRIER))
    (match_operand:SI 1 "const_int_operand" "")] ;; model
   ""
-  "dbar\t0")
+  {
+    enum memmodel model = memmodel_base (INTVAL (operands[1]));
+
+    switch (model)
+      {
+      case MEMMODEL_ACQUIRE:
+	return "dbar\t0b10100";
+      case MEMMODEL_RELEASE:
+	return "dbar\t0b10010";
+      case MEMMODEL_ACQ_REL:
+      case MEMMODEL_SEQ_CST:
+	return "dbar\t0b10000";
+      default:
+	/* GCC internal: "For the '__ATOMIC_RELAXED' model no instructions
+	   need to be issued and this expansion is not invoked."
+
+	   __atomic builtins doc: "Consume is implemented using the
+	   stronger acquire memory order because of a deficiency in C++11's
+	   semantics."  See PR 59448 and get_memmodel in builtins.cc.
+
+	   Other values should not be returned by memmodel_base.  */
+	gcc_unreachable ();
+      }
+  })
 
 ;; Atomic memory operations.
 
+(define_insn "atomic_load<mode>"
+  [(set (match_operand:QHWD 0 "register_operand" "=r")
+    (unspec_volatile:QHWD
+      [(match_operand:QHWD 1 "memory_operand" "+m")
+       (match_operand:SI 2 "const_int_operand")]                        ;; model
+      UNSPEC_ATOMIC_LOAD))]
+  ""
+{
+  enum memmodel model = memmodel_base (INTVAL (operands[2]));
+
+  switch (model)
+    {
+    case MEMMODEL_SEQ_CST:
+      return "dbar\t0x11\\n\\t"
+	     "ld.<size>\t%0,%1\\n\\t"
+	     "dbar\t0x14";
+    case MEMMODEL_ACQUIRE:
+      return "ld.<size>\t%0,%1\\n\\t"
+	     "dbar\t0x14";
+    case MEMMODEL_RELAXED:
+      return TARGET_LD_SEQ_SA ? "ld.<size>\t%0,%1"
+			      : "ld.<size>\t%0,%1\\n\\t"
+				"dbar\t0x700";
+
+    default:
+      /* The valid memory order variants are __ATOMIC_RELAXED, __ATOMIC_SEQ_CST,
+	 __ATOMIC_CONSUME and __ATOMIC_ACQUIRE.
+	 The expand_builtin_atomic_store function converts all invalid memmodels
+	 to MEMMODEL_SEQ_CST.
+
+	 __atomic builtins doc: "Consume is implemented using the
+	 stronger acquire memory order because of a deficiency in C++11's
+	 semantics."  See PR 59448 and get_memmodel in builtins.cc.  */
+      gcc_unreachable ();
+    }
+}
+  [(set (attr "length") (const_int 12))])
+
 ;; Implement atomic stores with amoswap.  Fall back to fences for atomic loads.
 (define_insn "atomic_store<mode>"
-  [(set (match_operand:GPR 0 "memory_operand" "+ZB")
-    (unspec_volatile:GPR
-      [(match_operand:GPR 1 "reg_or_0_operand" "rJ")
+  [(set (match_operand:QHWD 0 "memory_operand" "+m")
+    (unspec_volatile:QHWD
+      [(match_operand:QHWD 1 "reg_or_0_operand" "rJ")
        (match_operand:SI 2 "const_int_operand")]      ;; model
       UNSPEC_ATOMIC_STORE))]
   ""
-  "amswap%A2.<amo>\t$zero,%z1,%0"
-  [(set (attr "length") (const_int 8))])
+{
+  enum memmodel model = memmodel_base (INTVAL (operands[2]));
+
+  switch (model)
+    {
+    case MEMMODEL_SEQ_CST:
+      return "dbar\t0x12\\n\\t"
+	     "st.<size>\t%z1,%0\\n\\t"
+	     "dbar\t0x18\\n\\t";
+    case MEMMODEL_RELEASE:
+      return "dbar\t0x12\\n\\t"
+	     "st.<size>\t%z1,%0\\n\\t";
+    case MEMMODEL_RELAXED:
+      return "st.<size>\t%z1,%0";
+
+    default:
+      /* The valid memory order variants are __ATOMIC_RELAXED, __ATOMIC_SEQ_CST,
+	 and __ATOMIC_RELEASE.
+	 The expand_builtin_atomic_store function converts all invalid memmodels
+	 to MEMMODEL_SEQ_CST.  */
+      gcc_unreachable ();
+    }
+}
+  [(set (attr "length") (const_int 12))])
 
 (define_insn "atomic_<atomic_optab><mode>"
   [(set (match_operand:GPR 0 "memory_operand" "+ZB")
@@ -90,7 +184,18 @@
 	 UNSPEC_SYNC_OLD_OP))]
   ""
   "am<amop>%A2.<amo>\t$zero,%z1,%0"
-  [(set (attr "length") (const_int 8))])
+  [(set (attr "length") (const_int 4))])
+
+(define_insn "atomic_add<mode>"
+  [(set (match_operand:SHORT 0 "memory_operand" "+ZB")
+	(unspec_volatile:SHORT
+	  [(plus:SHORT (match_dup 0)
+		       (match_operand:SHORT 1 "reg_or_0_operand" "rJ"))
+	   (match_operand:SI 2 "const_int_operand")] ;; model
+	 UNSPEC_SYNC_OLD_OP))]
+  "TARGET_LAM_BH"
+  "amadd%A2.<amo>\t$zero,%z1,%0"
+  [(set (attr "length") (const_int 4))])
 
 (define_insn "atomic_fetch_<atomic_optab><mode>"
   [(set (match_operand:GPR 0 "register_operand" "=&r")
@@ -98,12 +203,12 @@
    (set (match_dup 1)
 	(unspec_volatile:GPR
 	  [(any_atomic:GPR (match_dup 1)
-		     (match_operand:GPR 2 "reg_or_0_operand" "rJ"))
+			   (match_operand:GPR 2 "reg_or_0_operand" "rJ"))
 	   (match_operand:SI 3 "const_int_operand")] ;; model
 	 UNSPEC_SYNC_OLD_OP))]
   ""
   "am<amop>%A3.<amo>\t%0,%z2,%1"
-  [(set (attr "length") (const_int 8))])
+  [(set (attr "length") (const_int 4))])
 
 (define_insn "atomic_exchange<mode>"
   [(set (match_operand:GPR 0 "register_operand" "=&r")
@@ -115,7 +220,19 @@
 	(match_operand:GPR 2 "register_operand" "r"))]
   ""
   "amswap%A3.<amo>\t%0,%z2,%1"
-  [(set (attr "length") (const_int 8))])
+  [(set (attr "length") (const_int 4))])
+
+(define_insn "atomic_exchange<mode>_short"
+  [(set (match_operand:SHORT 0 "register_operand" "=&r")
+	(unspec_volatile:SHORT
+	  [(match_operand:SHORT 1 "memory_operand" "+ZB")
+	   (match_operand:SI 3 "const_int_operand")] ;; model
+	  UNSPEC_SYNC_EXCHANGE))
+   (set (match_dup 1)
+	(match_operand:SHORT 2 "register_operand" "r"))]
+  "TARGET_LAM_BH"
+  "amswap%A3.<amo>\t%0,%z2,%1"
+  [(set (attr "length") (const_int 4))])
 
 (define_insn "atomic_cas_value_strong<mode>"
   [(set (match_operand:GPR 0 "register_operand" "=&r")
@@ -123,25 +240,35 @@
    (set (match_dup 1)
 	(unspec_volatile:GPR [(match_operand:GPR 2 "reg_or_0_operand" "rJ")
 			      (match_operand:GPR 3 "reg_or_0_operand" "rJ")
-			      (match_operand:SI 4 "const_int_operand")  ;; mod_s
-			      (match_operand:SI 5 "const_int_operand")] ;; mod_f
+			      (match_operand:SI 4 "const_int_operand")]  ;; mod_s
 	 UNSPEC_COMPARE_AND_SWAP))
-   (clobber (match_scratch:GPR 6 "=&r"))]
+   (clobber (match_scratch:GPR 5 "=&r"))]
   ""
 {
-  return "%G5\\n\\t"
-	 "1:\\n\\t"
+  return "1:\\n\\t"
 	 "ll.<amo>\\t%0,%1\\n\\t"
 	 "bne\\t%0,%z2,2f\\n\\t"
-	 "or%i3\\t%6,$zero,%3\\n\\t"
-	 "sc.<amo>\\t%6,%1\\n\\t"
-	 "beq\\t$zero,%6,1b\\n\\t"
+	 "or%i3\\t%5,$zero,%3\\n\\t"
+	 "sc.<amo>\\t%5,%1\\n\\t"
+	 "beqz\\t%5,1b\\n\\t"
 	 "b\\t3f\\n\\t"
 	 "2:\\n\\t"
-	 "dbar\\t0x700\\n\\t"
+	 "%G4\\n\\t"
 	 "3:\\n\\t";
 }
-  [(set (attr "length") (const_int 32))])
+  [(set (attr "length") (const_int 28))])
+
+(define_insn "atomic_cas_value_strong<mode>_amcas"
+  [(set (match_operand:QHWD 0 "register_operand" "=&r")
+	(match_operand:QHWD 1 "memory_operand" "+ZB"))
+   (set (match_dup 1)
+	(unspec_volatile:QHWD [(match_operand:QHWD 2 "reg_or_0_operand" "rJ")
+			       (match_operand:QHWD 3 "reg_or_0_operand" "rJ")
+			       (match_operand:SI 4 "const_int_operand")]  ;; mod_s
+	 UNSPEC_COMPARE_AND_SWAP))]
+  "TARGET_LAMCAS"
+  "ori\t%0,%z2,0\n\tamcas%A4.<amo>\t%0,%z3,%1"
+  [(set (attr "length") (const_int 8))])
 
 (define_expand "atomic_compare_and_swap<mode>"
   [(match_operand:SI 0 "register_operand" "")   ;; bool output
@@ -154,9 +281,29 @@
    (match_operand:SI 7 "const_int_operand" "")] ;; mod_f
   ""
 {
-  emit_insn (gen_atomic_cas_value_strong<mode> (operands[1], operands[2],
-						operands[3], operands[4],
-						operands[6], operands[7]));
+  rtx mod_s, mod_f;
+
+  mod_s = operands[6];
+  mod_f = operands[7];
+
+  /* Normally the succ memory model must be stronger than fail, but in the
+     unlikely event of fail being ACQUIRE and succ being RELEASE we need to
+     promote succ to ACQ_REL so that we don't lose the acquire semantics.  */
+
+  if (is_mm_acquire (memmodel_base (INTVAL (mod_f)))
+      && is_mm_release (memmodel_base (INTVAL (mod_s))))
+    mod_s = GEN_INT (MEMMODEL_ACQ_REL);
+
+  operands[6] = mod_s;
+
+  if (TARGET_LAMCAS)
+    emit_insn (gen_atomic_cas_value_strong<mode>_amcas (operands[1], operands[2],
+							 operands[3], operands[4],
+							 operands[6]));
+  else
+    emit_insn (gen_atomic_cas_value_strong<mode> (operands[1], operands[2],
+						  operands[3], operands[4],
+						  operands[6]));
 
   rtx compare = operands[1];
   if (operands[3] != const0_rtx)
@@ -234,8 +381,7 @@
    (clobber (match_scratch:GPR 7 "=&r"))]
   ""
 {
-  return "%G6\\n\\t"
-	 "1:\\n\\t"
+  return "1:\\n\\t"
 	 "ll.<amo>\\t%0,%1\\n\\t"
 	 "and\\t%7,%0,%2\\n\\t"
 	 "bne\\t%7,%z4,2f\\n\\t"
@@ -245,10 +391,10 @@
 	 "beq\\t$zero,%7,1b\\n\\t"
 	 "b\\t3f\\n\\t"
 	 "2:\\n\\t"
-	 "dbar\\t0x700\\n\\t"
+	 "%G6\\n\\t"
 	 "3:\\n\\t";
 }
-  [(set (attr "length") (const_int 40))])
+  [(set (attr "length") (const_int 36))])
 
 (define_expand "atomic_compare_and_swap<mode>"
   [(match_operand:SI 0 "register_operand" "")   ;; bool output
@@ -261,31 +407,53 @@
    (match_operand:SI 7 "const_int_operand" "")] ;; mod_f
   ""
 {
-  union loongarch_gen_fn_ptrs generator;
-  generator.fn_7 = gen_atomic_cas_value_cmp_and_7_si;
-  loongarch_expand_atomic_qihi (generator, operands[1], operands[2],
-				operands[3], operands[4], operands[7]);
+  rtx mod_s, mod_f;
 
-  rtx compare = operands[1];
-  if (operands[3] != const0_rtx)
-    {
-      machine_mode mode = GET_MODE (operands[3]);
-      rtx op1 = convert_modes (SImode, mode, operands[1], true);
-      rtx op3 = convert_modes (SImode, mode, operands[3], true);
-      rtx difference = gen_rtx_MINUS (SImode, op1, op3);
-      compare = gen_reg_rtx (SImode);
-      emit_insn (gen_rtx_SET (compare, difference));
-    }
+  mod_s = operands[6];
+  mod_f = operands[7];
 
-  if (word_mode != <MODE>mode)
+  /* Normally the succ memory model must be stronger than fail, but in the
+     unlikely event of fail being ACQUIRE and succ being RELEASE we need to
+     promote succ to ACQ_REL so that we don't lose the acquire semantics.  */
+
+  if (is_mm_acquire (memmodel_base (INTVAL (mod_f)))
+      && is_mm_release (memmodel_base (INTVAL (mod_s))))
+    mod_s = GEN_INT (MEMMODEL_ACQ_REL);
+
+  operands[6] = mod_s;
+
+  if (TARGET_LAMCAS)
+    emit_insn (gen_atomic_cas_value_strong<mode>_amcas (operands[1], operands[2],
+						       operands[3], operands[4],
+						       operands[6]));
+  else
     {
-      rtx reg = gen_reg_rtx (word_mode);
-      emit_insn (gen_rtx_SET (reg, gen_rtx_SIGN_EXTEND (word_mode, compare)));
-      compare = reg;
+      union loongarch_gen_fn_ptrs generator;
+      generator.fn_7 = gen_atomic_cas_value_cmp_and_7_si;
+      loongarch_expand_atomic_qihi (generator, operands[1], operands[2],
+				    operands[3], operands[4], operands[6]);
     }
 
-  emit_insn (gen_rtx_SET (operands[0],
-			  gen_rtx_EQ (SImode, compare, const0_rtx)));
+      rtx compare = operands[1];
+      if (operands[3] != const0_rtx)
+	{
+	  machine_mode mode = GET_MODE (operands[3]);
+	  rtx op1 = convert_modes (SImode, mode, operands[1], true);
+	  rtx op3 = convert_modes (SImode, mode, operands[3], true);
+	  rtx difference = gen_rtx_MINUS (SImode, op1, op3);
+	  compare = gen_reg_rtx (SImode);
+	  emit_insn (gen_rtx_SET (compare, difference));
+	}
+
+      if (word_mode != <MODE>mode)
+	{
+	  rtx reg = gen_reg_rtx (word_mode);
+	  emit_insn (gen_rtx_SET (reg, gen_rtx_SIGN_EXTEND (word_mode, compare)));
+	  compare = reg;
+	}
+
+      emit_insn (gen_rtx_SET (operands[0],
+			      gen_rtx_EQ (SImode, compare, const0_rtx)));
   DONE;
 })
 
@@ -303,8 +471,7 @@
    (clobber (match_scratch:GPR 8 "=&r"))]
   ""
 {
-  return "%G6\\n\\t"
-	 "1:\\n\\t"
+  return "1:\\n\\t"
 	 "ll.<amo>\\t%0,%1\\n\\t"
 	 "and\\t%7,%0,%3\\n\\t"
 	 "add.w\\t%8,%0,%z5\\n\\t"
@@ -314,7 +481,7 @@
 	 "beq\\t$zero,%7,1b";
 }
 
-  [(set (attr "length") (const_int 32))])
+  [(set (attr "length") (const_int 28))])
 
 (define_insn "atomic_cas_value_sub_7_<mode>"
   [(set (match_operand:GPR 0 "register_operand" "=&r")				;; res
@@ -330,8 +497,7 @@
    (clobber (match_scratch:GPR 8 "=&r"))]
   ""
 {
-  return "%G6\\n\\t"
-	 "1:\\n\\t"
+  return "1:\\n\\t"
 	 "ll.<amo>\\t%0,%1\\n\\t"
 	 "and\\t%7,%0,%3\\n\\t"
 	 "sub.w\\t%8,%0,%z5\\n\\t"
@@ -340,7 +506,7 @@
 	 "sc.<amo>\\t%7,%1\\n\\t"
 	 "beq\\t$zero,%7,1b";
 }
-  [(set (attr "length") (const_int 32))])
+  [(set (attr "length") (const_int 28))])
 
 (define_insn "atomic_cas_value_and_7_<mode>"
   [(set (match_operand:GPR 0 "register_operand" "=&r")				;; res
@@ -356,8 +522,7 @@
    (clobber (match_scratch:GPR 8 "=&r"))]
   ""
 {
-  return "%G6\\n\\t"
-	 "1:\\n\\t"
+  return "1:\\n\\t"
 	 "ll.<amo>\\t%0,%1\\n\\t"
 	 "and\\t%7,%0,%3\\n\\t"
 	 "and\\t%8,%0,%z5\\n\\t"
@@ -366,7 +531,7 @@
 	 "sc.<amo>\\t%7,%1\\n\\t"
 	 "beq\\t$zero,%7,1b";
 }
-  [(set (attr "length") (const_int 32))])
+  [(set (attr "length") (const_int 28))])
 
 (define_insn "atomic_cas_value_xor_7_<mode>"
   [(set (match_operand:GPR 0 "register_operand" "=&r")				;; res
@@ -382,8 +547,7 @@
    (clobber (match_scratch:GPR 8 "=&r"))]
   ""
 {
-  return "%G6\\n\\t"
-	 "1:\\n\\t"
+  return "1:\\n\\t"
 	 "ll.<amo>\\t%0,%1\\n\\t"
 	 "and\\t%7,%0,%3\\n\\t"
 	 "xor\\t%8,%0,%z5\\n\\t"
@@ -393,7 +557,7 @@
 	 "beq\\t$zero,%7,1b";
 }
 
-  [(set (attr "length") (const_int 32))])
+  [(set (attr "length") (const_int 28))])
 
 (define_insn "atomic_cas_value_or_7_<mode>"
   [(set (match_operand:GPR 0 "register_operand" "=&r")				;; res
@@ -409,8 +573,7 @@
    (clobber (match_scratch:GPR 8 "=&r"))]
   ""
 {
-  return "%G6\\n\\t"
-	 "1:\\n\\t"
+  return "1:\\n\\t"
 	 "ll.<amo>\\t%0,%1\\n\\t"
 	 "and\\t%7,%0,%3\\n\\t"
 	 "or\\t%8,%0,%z5\\n\\t"
@@ -420,7 +583,7 @@
 	 "beq\\t$zero,%7,1b";
 }
 
-  [(set (attr "length") (const_int 32))])
+  [(set (attr "length") (const_int 28))])
 
 (define_insn "atomic_cas_value_nand_7_<mode>"
   [(set (match_operand:GPR 0 "register_operand" "=&r")				;; res
@@ -436,8 +599,7 @@
    (clobber (match_scratch:GPR 8 "=&r"))]
   ""
 {
-  return "%G6\\n\\t"
-	 "1:\\n\\t"
+  return "1:\\n\\t"
 	 "ll.<amo>\\t%0,%1\\n\\t"
 	 "and\\t%7,%0,%3\\n\\t"
 	 "and\\t%8,%0,%z5\\n\\t"
@@ -446,7 +608,7 @@
 	 "sc.<amo>\\t%7,%1\\n\\t"
 	 "beq\\t$zero,%7,1b";
 }
-  [(set (attr "length") (const_int 32))])
+  [(set (attr "length") (const_int 28))])
 
 (define_insn "atomic_cas_value_exchange_7_<mode>"
   [(set (match_operand:GPR 0 "register_operand" "=&r")
@@ -461,8 +623,7 @@
    (clobber (match_scratch:GPR 7 "=&r"))]
   ""
 {
-  return "%G6\\n\\t"
-	 "1:\\n\\t"
+  return "1:\\n\\t"
 	 "ll.<amo>\\t%0,%1\\n\\t"
 	 "and\\t%7,%0,%z3\\n\\t"
 	 "or%i5\\t%7,%7,%5\\n\\t"
@@ -481,13 +642,31 @@
 	(match_operand:SHORT 2 "register_operand"))]
   ""
 {
-  union loongarch_gen_fn_ptrs generator;
-  generator.fn_7 = gen_atomic_cas_value_exchange_7_si;
-  loongarch_expand_atomic_qihi (generator, operands[0], operands[1],
-				const0_rtx, operands[2], operands[3]);
+  if (TARGET_LAM_BH)
+    emit_insn (gen_atomic_exchange<mode>_short (operands[0], operands[1], operands[2], operands[3]));
+  else
+    {
+      union loongarch_gen_fn_ptrs generator;
+      generator.fn_7 = gen_atomic_cas_value_exchange_7_si;
+      loongarch_expand_atomic_qihi (generator, operands[0], operands[1],
+				    const0_rtx, operands[2], operands[3]);
+    }
   DONE;
 })
 
+(define_insn "atomic_fetch_add<mode>_short"
+  [(set (match_operand:SHORT 0 "register_operand" "=&r")
+	(match_operand:SHORT 1 "memory_operand" "+ZB"))
+   (set (match_dup 1)
+	(unspec_volatile:SHORT
+	  [(plus:SHORT (match_dup 1)
+		     (match_operand:SHORT 2 "reg_or_0_operand" "rJ"))
+	   (match_operand:SI 3 "const_int_operand")] ;; model
+	 UNSPEC_SYNC_OLD_OP))]
+  "TARGET_LAM_BH"
+  "amadd%A3.<amo>\t%0,%z2,%1"
+  [(set (attr "length") (const_int 4))])
+
 (define_expand "atomic_fetch_add<mode>"
   [(set (match_operand:SHORT 0 "register_operand" "=&r")
 	(match_operand:SHORT 1 "memory_operand" "+ZB"))
@@ -499,10 +678,16 @@
 	 UNSPEC_SYNC_OLD_OP))]
   ""
 {
-  union loongarch_gen_fn_ptrs generator;
-  generator.fn_7 = gen_atomic_cas_value_add_7_si;
-  loongarch_expand_atomic_qihi (generator, operands[0], operands[1],
-				operands[1], operands[2], operands[3]);
+  if (TARGET_LAM_BH)
+    emit_insn (gen_atomic_fetch_add<mode>_short (operands[0], operands[1],
+					     operands[2], operands[3]));
+  else
+    {
+      union loongarch_gen_fn_ptrs generator;
+      generator.fn_7 = gen_atomic_cas_value_add_7_si;
+      loongarch_expand_atomic_qihi (generator, operands[0], operands[1],
+				    operands[1], operands[2], operands[3]);
+    }
   DONE;
 })
 
diff --git a/gcc/config/loongarch/t-loongarch b/gcc/config/loongarch/t-loongarch
index 667a6bb..7e65bb6 100644
--- a/gcc/config/loongarch/t-loongarch
+++ b/gcc/config/loongarch/t-loongarch
@@ -18,8 +18,9 @@
 
 
 GTM_H += loongarch-multilib.h
-OPTIONS_H_EXTRA += $(srcdir)/config/loongarch/loongarch-def.h \
-		   $(srcdir)/config/loongarch/loongarch-tune.h
+OPTIONS_H_EXTRA += $(srcdir)/config/loongarch/loongarch-def.h	\
+		   $(srcdir)/config/loongarch/loongarch-tune.h	\
+		   $(srcdir)/config/loongarch/loongarch-cpucfg-map.h
 
 # Canonical target triplet from config.gcc
 LA_MULTIARCH_TRIPLET = $(patsubst LA_MULTIARCH_TRIPLET=%,%,$\
@@ -31,7 +32,8 @@ LA_STR_H = $(srcdir)/config/loongarch/loongarch-str.h
 # String definition header
 $(LA_STR_H): s-loongarch-str ; @true
 s-loongarch-str: $(srcdir)/config/loongarch/genopts/genstr.sh \
-	$(srcdir)/config/loongarch/genopts/loongarch-strings
+	$(srcdir)/config/loongarch/genopts/loongarch-strings  \
+	$(srcdir)/config/loongarch/genopts/isa-evolution.in
 	$(SHELL) $(srcdir)/config/loongarch/genopts/genstr.sh header \
     $(srcdir)/config/loongarch/genopts/loongarch-strings > \
     tmp-loongarch-str.h
@@ -58,7 +60,8 @@ loongarch-driver.o : $(srcdir)/config/loongarch/loongarch-driver.cc $(LA_STR_H)
 loongarch-opts.o: $(srcdir)/config/loongarch/loongarch-opts.cc $(LA_STR_H)
 	$(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $<
 
-loongarch-cpu.o: $(srcdir)/config/loongarch/loongarch-cpu.cc $(LA_STR_H)
+loongarch-cpu.o: $(srcdir)/config/loongarch/loongarch-cpu.cc $(LA_STR_H) \
+		 $(srcdir)/config/loongarch/loongarch-cpucfg-map.h
 	$(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $<
 
 loongarch-def.o: $(srcdir)/config/loongarch/loongarch-def.c $(LA_STR_H)
@@ -67,6 +70,7 @@ loongarch-def.o: $(srcdir)/config/loongarch/loongarch-def.c $(LA_STR_H)
 $(srcdir)/config/loongarch/loongarch.opt: s-loongarch-opt ; @true
 s-loongarch-opt: $(srcdir)/config/loongarch/genopts/genstr.sh \
 	$(srcdir)/config/loongarch/genopts/loongarch.opt.in \
+	$(srcdir)/config/loongarch/genopts/isa-evolution.in \
 	$(srcdir)/config/loongarch/genopts/loongarch-strings $(LA_STR_H)
 	$(SHELL) $(srcdir)/config/loongarch/genopts/genstr.sh opt \
     $(srcdir)/config/loongarch/genopts/loongarch.opt.in \
@@ -74,3 +78,12 @@ s-loongarch-opt: $(srcdir)/config/loongarch/genopts/genstr.sh \
 	$(SHELL) $(srcdir)/../move-if-change tmp-loongarch.opt \
     $(srcdir)/config/loongarch/loongarch.opt
 	$(STAMP) s-loongarch-opt
+
+$(srcdir)/config/loongarch/loongarch-cpucfg-map.h: s-loongarch-cpucfg-map
+	@true
+s-loongarch-cpucfg-map: $(srcdir)/config/loongarch/genopts/genstr.sh \
+	$(srcdir)/config/loongarch/genopts/isa-evolution.in
+	$(SHELL) $< cpucfg-map > tmp-cpucfg.h
+	$(SHELL) $(srcdir)/../move-if-change tmp-cpucfg.h \
+	    $(srcdir)/config/loongarch/loongarch-cpucfg-map.h
+	$(STAMP) $@
diff --git a/gcc/config/nvptx/nvptx.md b/gcc/config/nvptx/nvptx.md
index 1bb9304..7a7c994 100644
--- a/gcc/config/nvptx/nvptx.md
+++ b/gcc/config/nvptx/nvptx.md
@@ -34,8 +34,6 @@
    UNSPEC_FPINT_CEIL
    UNSPEC_FPINT_NEARBYINT
 
-   UNSPEC_BITREV
-
    UNSPEC_ALLOCA
 
    UNSPEC_SET_SOFTSTACK
@@ -636,8 +634,7 @@
 
 (define_insn "bitrev<mode>2"
   [(set (match_operand:SDIM 0 "nvptx_register_operand" "=R")
-	(unspec:SDIM [(match_operand:SDIM 1 "nvptx_register_operand" "R")]
-		     UNSPEC_BITREV))]
+	(bitreverse:SDIM (match_operand:SDIM 1 "nvptx_register_operand" "R")))]
   ""
   "%.\\tbrev.b%T0\\t%0, %1;")
 
diff --git a/gcc/config/pa/pa.cc b/gcc/config/pa/pa.cc
index 218c48b..565c948 100644
--- a/gcc/config/pa/pa.cc
+++ b/gcc/config/pa/pa.cc
@@ -10819,23 +10819,29 @@ pa_legitimate_address_p (machine_mode mode, rtx x, bool strict, code_helper)
 
       if (GET_CODE (index) == CONST_INT)
 	{
+	  /* Short 5-bit displacements always okay.  */
 	  if (INT_5_BITS (index))
 	    return true;
 
-	  /* When INT14_OK_STRICT is false, a secondary reload is needed
-	     to adjust the displacement of SImode and DImode floating point
-	     instructions but this may fail when the register also needs
-	     reloading.  So, we return false when STRICT is true.  We
-	     also reject long displacements for float mode addresses since
-	     the majority of accesses will use floating point instructions
-	     that don't support 14-bit offsets.  */
-	  if (!INT14_OK_STRICT
-	      && (strict || !(reload_in_progress || reload_completed))
-	      && mode != QImode
-	      && mode != HImode)
+	  if (!base14_operand (index, mode))
 	    return false;
 
-	  return base14_operand (index, mode);
+	  /* Long 14-bit displacements always okay for these cases.  */
+	  if (INT14_OK_STRICT
+	      || mode == QImode
+	      || mode == HImode)
+	    return true;
+
+	  /* A secondary reload may be needed to adjust the displacement
+	     of floating-point accesses when STRICT is nonzero.  */
+	  if (strict)
+	    return false;
+
+	  /* We get significantly better code if we allow long displacements
+	     before reload for all accesses.  Instructions must satisfy their
+	     constraints after reload, so we must have an integer access.
+	     Return true for both cases.  */
+	  return true;
 	}
 
       if (!TARGET_DISABLE_INDEXING
diff --git a/gcc/config/pa/pa.h b/gcc/config/pa/pa.h
index e65af52..aba2cec 100644
--- a/gcc/config/pa/pa.h
+++ b/gcc/config/pa/pa.h
@@ -37,6 +37,11 @@ extern unsigned long total_code_bytes;
 #define TARGET_ELF32 0
 #endif
 
+/* Generate code for ELF64 ABI.  */
+#ifndef TARGET_ELF64
+#define TARGET_ELF64 0
+#endif
+
 /* Generate code for SOM 32bit ABI.  */
 #ifndef TARGET_SOM
 #define TARGET_SOM 0
@@ -823,12 +828,11 @@ extern int may_call_alloca;
 
 /* Nonzero if 14-bit offsets can be used for all loads and stores.
    This is not possible when generating PA 1.x code as floating point
-   loads and stores only support 5-bit offsets.  Note that we do not
-   forbid the use of 14-bit offsets for integer modes.  Instead, we
-   use secondary reloads to fix REG+D memory addresses for integer
-   mode floating-point loads and stores.
+   accesses only support 5-bit offsets.  Note that we do not forbid
+   the use of 14-bit offsets prior to reload.  Instead, we use secondary
+   reloads to fix REG+D memory addresses for floating-point accesses.
 
-   FIXME: the ELF32 linker clobbers the LSB of the FP register number
+   FIXME: the GNU ELF linker clobbers the LSB of the FP register number
    in PA 2.0 floating-point insns with long displacements.  This is
    because R_PARISC_DPREL14WR and other relocations like it are not
    yet supported by GNU ld.  For now, we reject long displacements
@@ -836,7 +840,7 @@ extern int may_call_alloca;
 
 #define INT14_OK_STRICT \
   (TARGET_SOFT_FLOAT                                                   \
-   || (TARGET_PA_20 && !TARGET_ELF32))
+   || (TARGET_PA_20 && !TARGET_ELF32 && !TARGET_ELF64))
 
 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
    and check its validity for a certain class.
diff --git a/gcc/config/pa/pa64-linux.h b/gcc/config/pa/pa64-linux.h
index f61c9e16..33fed02 100644
--- a/gcc/config/pa/pa64-linux.h
+++ b/gcc/config/pa/pa64-linux.h
@@ -17,6 +17,10 @@ You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING3.  If not see
 <http://www.gnu.org/licenses/>.  */
 
+/* 64-bit ELF target.  */
+#undef TARGET_ELF64
+#define TARGET_ELF64 1
+
 #if 0 /* needs some work :-( */
 /* If defined, this macro specifies a table of register pairs used to
    eliminate unneeded registers that point into the stack frame.  */
diff --git a/gcc/config/pa/predicates.md b/gcc/config/pa/predicates.md
index 08071b2..1b50020 100644
--- a/gcc/config/pa/predicates.md
+++ b/gcc/config/pa/predicates.md
@@ -267,6 +267,10 @@
   if (!INT_14_BITS (op))
     return false;
 
+  /* Short displacement.  */
+  if (INT_5_BITS (op))
+    return true;
+
   /* Although this may not be necessary, we require that the
      base value is correctly aligned for its mode as this is
      assumed in the instruction encoding.  */
@@ -304,15 +308,12 @@
 
   if (reg_plus_base_memory_operand (op, mode))
     {
-      if (reload_in_progress)
-	return true;
-
       /* Extract CONST_INT operand.  */
       if (GET_CODE (op) == SUBREG)
 	op = SUBREG_REG (op);
       op = XEXP (op, 0);
       op = REG_P (XEXP (op, 0)) ? XEXP (op, 1) : XEXP (op, 0);
-      return base14_operand (op, mode) || INT_5_BITS (op);
+      return base14_operand (op, mode);
     }
 
   if (!MEM_P (op))
@@ -341,17 +342,12 @@
 
   if (reg_plus_base_memory_operand (op, mode))
     {
-      if (reload_in_progress)
-	return true;
-
       /* Extract CONST_INT operand.  */
       if (GET_CODE (op) == SUBREG)
 	op = SUBREG_REG (op);
       op = XEXP (op, 0);
       op = REG_P (XEXP (op, 0)) ? XEXP (op, 1) : XEXP (op, 0);
-      return ((TARGET_PA_20
-	       && !TARGET_ELF32
-	       && base14_operand (op, mode))
+      return ((INT14_OK_STRICT && base14_operand (op, mode))
 	      || INT_5_BITS (op));
     }
 
diff --git a/gcc/config/riscv/riscv-c.cc b/gcc/config/riscv/riscv-c.cc
index b7f9ba2..dd1bd05 100644
--- a/gcc/config/riscv/riscv-c.cc
+++ b/gcc/config/riscv/riscv-c.cc
@@ -109,11 +109,11 @@ riscv_cpu_cpp_builtins (cpp_reader *pfile)
     }
 
   if (riscv_user_wants_strict_align)
-    builtin_define_with_int_value ("__riscv_unaligned_avoid", 1);
+    builtin_define_with_int_value ("__riscv_misaligned_avoid", 1);
   else if (riscv_slow_unaligned_access_p)
-    builtin_define_with_int_value ("__riscv_unaligned_slow", 1);
+    builtin_define_with_int_value ("__riscv_misaligned_slow", 1);
   else
-    builtin_define_with_int_value ("__riscv_unaligned_fast", 1);
+    builtin_define_with_int_value ("__riscv_misaligned_fast", 1);
 
   if (TARGET_MIN_VLEN != 0)
     builtin_define_with_int_value ("__riscv_v_min_vlen", TARGET_MIN_VLEN);
diff --git a/gcc/config/riscv/riscv-protos.h b/gcc/config/riscv/riscv-protos.h
index 8cdfadb..196b53f 100644
--- a/gcc/config/riscv/riscv-protos.h
+++ b/gcc/config/riscv/riscv-protos.h
@@ -124,6 +124,7 @@ extern void riscv_split_doubleword_move (rtx, rtx);
 extern const char *riscv_output_move (rtx, rtx);
 extern const char *riscv_output_return ();
 extern void riscv_declare_function_name (FILE *, const char *, tree);
+extern void riscv_declare_function_size (FILE *, const char *, tree);
 extern void riscv_asm_output_alias (FILE *, const tree, const tree);
 extern void riscv_asm_output_external (FILE *, const tree, const char *);
 extern bool
@@ -647,5 +648,25 @@ extern bool th_print_operand_address (FILE *, machine_mode, rtx);
 
 extern bool riscv_use_divmod_expander (void);
 void riscv_init_cumulative_args (CUMULATIVE_ARGS *, tree, rtx, tree, int);
+extern bool
+riscv_option_valid_attribute_p (tree, tree, tree, int);
+extern void
+riscv_override_options_internal (struct gcc_options *);
+
+struct riscv_tune_param;
+/* Information about one micro-arch we know about.  */
+struct riscv_tune_info {
+  /* This micro-arch canonical name.  */
+  const char *name;
+
+  /* Which automaton to use for tuning.  */
+  enum riscv_microarchitecture_type microarchitecture;
+
+  /* Tuning parameters for this micro-arch.  */
+  const struct riscv_tune_param *tune_param;
+};
+
+const struct riscv_tune_info *
+riscv_parse_tune (const char *, bool);
 
 #endif /* ! GCC_RISCV_PROTOS_H */
diff --git a/gcc/config/riscv/riscv-target-attr.cc b/gcc/config/riscv/riscv-target-attr.cc
new file mode 100644
index 0000000..c4bd99d
--- /dev/null
+++ b/gcc/config/riscv/riscv-target-attr.cc
@@ -0,0 +1,395 @@
+/* Subroutines used for parsing target attribute for RISC-V.
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 3, or (at your option)
+any later version.
+
+GCC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+#define IN_TARGET_CODE 1
+
+#define INCLUDE_MEMORY
+#define INCLUDE_STRING
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "target.h"
+#include "tree.h"
+#include "tm_p.h"
+#include "diagnostic.h"
+#include "opts.h"
+#include "riscv-subset.h"
+
+namespace {
+class riscv_target_attr_parser
+{
+public:
+  riscv_target_attr_parser (location_t loc)
+    : m_found_arch_p (false)
+    , m_found_tune_p (false)
+    , m_found_cpu_p (false)
+    , m_subset_list (nullptr)
+    , m_loc (loc)
+    , m_cpu_info (nullptr)
+    , m_tune (nullptr)
+  {
+  }
+
+  bool handle_arch (const char *);
+  bool handle_cpu (const char *);
+  bool handle_tune (const char *);
+
+  void set_loc (location_t loc) {
+    m_loc = loc;
+  }
+
+  void update_settings (struct gcc_options *opts) const;
+private:
+  const char *m_raw_attr_str;
+  bool parse_arch (const char *);
+
+  bool m_found_arch_p;
+  bool m_found_tune_p;
+  bool m_found_cpu_p;
+  riscv_subset_list *m_subset_list;
+  location_t m_loc;
+  const  riscv_cpu_info *m_cpu_info;
+  const char *m_tune;
+};
+}
+
+/* All the information needed to handle a target attribute.
+   NAME is the name of the attribute.
+   HANDLER is the function that takes the attribute string as an argument.  */
+
+struct riscv_attribute_info
+{
+  const char *name;
+  bool (riscv_target_attr_parser::*handler) (const char *);
+};
+
+/* The target attributes that we support.  */
+
+static const struct riscv_attribute_info riscv_attributes[]
+  = {{"arch", &riscv_target_attr_parser::handle_arch},
+     {"cpu", &riscv_target_attr_parser::handle_cpu},
+     {"tune", &riscv_target_attr_parser::handle_tune}};
+
+bool
+riscv_target_attr_parser::parse_arch (const char *str)
+{
+  if (m_subset_list)
+    delete m_subset_list;
+  /* Check if it's setting full arch string.  */
+  if (strncmp ("rv", str, strlen ("rv")) == 0)
+    {
+      m_subset_list = riscv_subset_list::parse (str, location_t ());
+
+      if (m_subset_list == nullptr)
+	goto fail;
+
+      return true;
+    }
+  else
+    {
+      /* Parsing the extension list like "+<ext>[,+<ext>]*".  */
+      size_t len = strlen (str);
+      std::unique_ptr<char[]> buf (new char[len]);
+      char *str_to_check = buf.get ();
+      strcpy (str_to_check, str);
+      const char *token = strtok_r (str_to_check, ",", &str_to_check);
+      m_subset_list = riscv_current_subset_list ()->clone ();
+      m_subset_list->set_loc (m_loc);
+      while (token)
+	{
+	  if (token[0] != '+')
+	    {
+	      error_at (
+		m_loc,
+		"unexpected arch for %<target()%> attribute: must start "
+		"with + or rv");
+	      goto fail;
+	    }
+	  else
+	    {
+	      const char *result = m_subset_list->parse_single_ext (token + 1);
+	      /* Check parse_single_ext has consume all string.  */
+	      if (*result != '\0')
+		{
+		  error_at (
+		    m_loc,
+		    "unexpected arch for %<target()%> attribute: bad "
+		    "string found %<%s%>", token);
+		  goto fail;
+		}
+	    }
+	  token = strtok_r (NULL, ",", &str_to_check);
+	}
+      return true;
+    }
+fail:
+  if (m_subset_list != nullptr)
+    {
+      delete m_subset_list;
+      m_subset_list = nullptr;
+    }
+  return false;
+}
+
+/* Handle the ARCH_STR argument to the arch= target attribute.  */
+
+bool
+riscv_target_attr_parser::handle_arch (const char *str)
+{
+  if (m_found_arch_p)
+    error_at (m_loc, "%<target()%> attribute: arch appears more than once");
+  m_found_arch_p = true;
+  return parse_arch (str);
+}
+
+/* Handle the CPU_STR argument to the cpu= target attribute.  */
+
+bool
+riscv_target_attr_parser::handle_cpu (const char *str)
+{
+  if (m_found_cpu_p)
+    error_at (m_loc, "%<target()%> attribute: cpu appears more than once");
+
+  m_found_cpu_p = true;
+  const riscv_cpu_info *cpu_info = riscv_find_cpu (str);
+
+  if (!cpu_info)
+    {
+      error_at (m_loc, "%<target()%> attribute: unknown CPU %qs", str);
+      return false;
+    }
+
+  if (m_subset_list == nullptr)
+    {
+      const char *arch_str = cpu_info->arch;
+      m_subset_list = riscv_subset_list::parse (arch_str, m_loc);
+      gcc_assert (m_subset_list);
+    }
+
+  m_cpu_info = cpu_info;
+  return true;
+}
+
+/* Handle the TUNE_STR argument to the tune= target attribute.  */
+
+bool
+riscv_target_attr_parser::handle_tune (const char *str)
+{
+  if (m_found_tune_p)
+    error_at (m_loc, "%<target()%> attribute: tune appears more than once");
+  m_found_tune_p = true;
+  const struct riscv_tune_info *tune = riscv_parse_tune (str, true);
+
+  if (tune == nullptr)
+    {
+      error_at (m_loc, "%<target()%> attribute: unknown TUNE %qs", str);
+      return false;
+    }
+
+  m_tune = tune->name;
+
+  return true;
+}
+
+void
+riscv_target_attr_parser::update_settings (struct gcc_options *opts) const
+{
+  if (m_subset_list)
+    riscv_set_arch_by_subset_list (m_subset_list, opts);
+
+  if (m_cpu_info)
+    opts->x_riscv_cpu_string = m_cpu_info->name;
+
+  if (m_tune)
+    opts->x_riscv_tune_string = m_tune;
+  else
+    {
+      if (m_cpu_info)
+	opts->x_riscv_tune_string = m_cpu_info->tune;
+    }
+}
+
+/* Parse ARG_STR which contains the definition of one target attribute.
+   Show appropriate errors if any or return true if the attribute is valid.  */
+
+static bool
+riscv_process_one_target_attr (char *arg_str,
+			       location_t loc,
+			       riscv_target_attr_parser &attr_parser)
+{
+  size_t len = strlen (arg_str);
+
+  if (len == 0)
+    {
+      error_at (loc, "malformed %<target()%> attribute");
+      return false;
+    }
+
+  std::unique_ptr<char[]> buf (new char[len]);
+  char *str_to_check = buf.get();
+  strcpy (str_to_check, arg_str);
+
+  char *arg = strchr (str_to_check, '=');
+
+  if (!arg)
+    {
+      error_at (
+	loc,
+	"attribute %<target(\"%s\")%> does not accept an argument",
+	str_to_check);
+      return false;
+    }
+
+  arg[0] = '\0';
+  ++arg;
+  for (const auto &attr : riscv_attributes)
+    {
+      /* If the names don't match up, or the user has given an argument
+	 to an attribute that doesn't accept one, or didn't give an argument
+	 to an attribute that expects one, fail to match.  */
+      if (strncmp (str_to_check, attr.name, strlen (attr.name)) != 0)
+	continue;
+
+      return (&attr_parser->*attr.handler) (arg);
+    }
+  error_at (loc, "Got unknown attribute %<target(\"%s\")%>", str_to_check);
+
+  return false;
+}
+
+/* Count how many times the character C appears in
+   NULL-terminated string STR.  */
+
+static unsigned int
+num_occurences_in_str (char c, char *str)
+{
+  unsigned int res = 0;
+  while (*str != '\0')
+    {
+      if (*str == c)
+	res++;
+
+      str++;
+    }
+
+  return res;
+}
+
+/* Parse the tree in ARGS that contains the target attribute information
+   and update the global target options space.  */
+
+static bool
+riscv_process_target_attr (tree args, location_t loc, struct gcc_options *opts)
+{
+  if (TREE_CODE (args) == TREE_LIST)
+    {
+      do
+	{
+	  tree head = TREE_VALUE (args);
+	  if (head)
+	    {
+	      if (!riscv_process_target_attr (head, loc, opts))
+		return false;
+	    }
+	  args = TREE_CHAIN (args);
+      } while (args);
+
+      return true;
+    }
+
+  if (TREE_CODE (args) != STRING_CST)
+    {
+      error_at (loc, "attribute %<target%> argument not a string");
+      return false;
+    }
+  size_t len = strlen (TREE_STRING_POINTER (args));
+
+  /* No need to emit warning or error on empty string here, generic code already
+     handle this case.  */
+  if (len == 0)
+    {
+      return false;
+    }
+
+  std::unique_ptr<char[]> buf (new char[len]);
+  char *str_to_check = buf.get ();
+  strcpy (str_to_check, TREE_STRING_POINTER (args));
+
+  /* Used to catch empty spaces between commas i.e.
+     attribute ((target ("attr1;;attr2"))).  */
+  unsigned int num_commas = num_occurences_in_str (';', str_to_check);
+
+  /* Handle multiple target attributes separated by ','.  */
+  char *token = strtok_r (str_to_check, ";", &str_to_check);
+
+  riscv_target_attr_parser attr_parser (loc);
+  unsigned int num_attrs = 0;
+  while (token)
+    {
+      num_attrs++;
+      riscv_process_one_target_attr (token, loc, attr_parser);
+      token = strtok_r (NULL, ";", &str_to_check);
+    }
+
+  if (num_attrs != num_commas + 1)
+    {
+      error_at (loc, "malformed %<target(\"%s\")%> attribute",
+		TREE_STRING_POINTER (args));
+      return false;
+    }
+
+  /* Apply settings from target attribute.  */
+  attr_parser.update_settings (opts);
+
+  return true;
+}
+
+/* Implement TARGET_OPTION_VALID_ATTRIBUTE_P.  This is used to
+   process attribute ((target ("..."))).  */
+
+bool
+riscv_option_valid_attribute_p (tree fndecl, tree, tree args, int)
+{
+  struct cl_target_option cur_target;
+  bool ret;
+  tree new_target;
+  location_t loc = DECL_SOURCE_LOCATION (fndecl);
+
+  /* Save the current target options to restore at the end.  */
+  cl_target_option_save (&cur_target, &global_options, &global_options_set);
+
+  ret = riscv_process_target_attr (args, loc, &global_options);
+
+  if (ret)
+    {
+      riscv_override_options_internal (&global_options);
+      new_target
+	= build_target_option_node (&global_options, &global_options_set);
+    }
+  else
+    new_target = NULL;
+
+  if (fndecl && ret)
+    {
+      DECL_FUNCTION_SPECIFIC_TARGET (fndecl) = new_target;
+    }
+
+  cl_target_option_restore (&global_options, &global_options_set, &cur_target);
+  return ret;
+}
diff --git a/gcc/config/riscv/riscv-v.cc b/gcc/config/riscv/riscv-v.cc
index 265a298..291f3c7 100644
--- a/gcc/config/riscv/riscv-v.cc
+++ b/gcc/config/riscv/riscv-v.cc
@@ -416,7 +416,7 @@ public:
   bool repeating_sequence_use_merge_profitable_p ();
   bool combine_sequence_use_slideup_profitable_p ();
   bool combine_sequence_use_merge_profitable_p ();
-  rtx get_merge_scalar_mask (unsigned int) const;
+  rtx get_merge_scalar_mask (unsigned int, machine_mode) const;
 
   bool single_step_npatterns_p () const;
   bool npatterns_all_equal_p () const;
@@ -592,7 +592,8 @@ rvv_builder::get_merged_repeating_sequence ()
    To merge "b", the mask should be 0101....
 */
 rtx
-rvv_builder::get_merge_scalar_mask (unsigned int index_in_pattern) const
+rvv_builder::get_merge_scalar_mask (unsigned int index_in_pattern,
+				    machine_mode inner_mode) const
 {
   unsigned HOST_WIDE_INT mask = 0;
   unsigned HOST_WIDE_INT base_mask = (1ULL << index_in_pattern);
@@ -611,7 +612,7 @@ rvv_builder::get_merge_scalar_mask (unsigned int index_in_pattern) const
   for (int i = 0; i < limit; i++)
     mask |= base_mask << (i * npatterns ());
 
-  return gen_int_mode (mask, inner_int_mode ());
+  return gen_int_mode (mask, inner_mode);
 }
 
 /* Return true if the variable-length vector is single step.
@@ -919,17 +920,45 @@ emit_vlmax_decompress_insn (rtx target, rtx op0, rtx op1, rtx mask)
 /* Emit merge instruction.  */
 
 static machine_mode
-get_repeating_sequence_dup_machine_mode (const rvv_builder &builder)
+get_repeating_sequence_dup_machine_mode (const rvv_builder &builder,
+					 machine_mode mask_bit_mode)
 {
-  poly_uint64 dup_nunits = GET_MODE_NUNITS (builder.mode ());
+  unsigned mask_precision = GET_MODE_PRECISION (mask_bit_mode).to_constant ();
+  unsigned mask_scalar_size = mask_precision > builder.inner_bits_size ()
+    ? builder.inner_bits_size () : mask_precision;
 
-  if (known_ge (GET_MODE_SIZE (builder.mode ()), BYTES_PER_RISCV_VECTOR))
+  scalar_mode inner_mode;
+  unsigned minimal_bits_size;
+
+  switch (mask_scalar_size)
     {
-      dup_nunits = exact_div (BYTES_PER_RISCV_VECTOR,
-	builder.inner_bytes_size ());
+      case 8:
+	inner_mode = QImode;
+	minimal_bits_size = TARGET_MIN_VLEN / 8; /* AKA RVVMF8.  */
+	break;
+      case 16:
+	inner_mode = HImode;
+	minimal_bits_size = TARGET_MIN_VLEN / 4; /* AKA RVVMF4.  */
+	break;
+      case 32:
+	inner_mode = SImode;
+	minimal_bits_size = TARGET_MIN_VLEN / 2; /* AKA RVVMF2.  */
+	break;
+      case 64:
+	inner_mode = DImode;
+	minimal_bits_size = TARGET_MIN_VLEN / 1; /* AKA RVVM1.  */
+	break;
+      default:
+	gcc_unreachable ();
+	break;
     }
 
-  return get_vector_mode (builder.inner_int_mode (), dup_nunits).require ();
+  gcc_assert (mask_precision % mask_scalar_size == 0);
+
+  uint64_t dup_nunit = mask_precision > mask_scalar_size
+    ? mask_precision / mask_scalar_size : minimal_bits_size / mask_scalar_size;
+
+  return get_vector_mode (inner_mode, dup_nunit).require ();
 }
 
 /* Expand series const vector.  */
@@ -2004,6 +2033,10 @@ expand_tuple_move (rtx *ops)
 	  offset = ops[2];
 	}
 
+      /* Non-fractional LMUL has whole register moves that don't require a
+	 vsetvl for VLMAX.  */
+      if (fractional_p)
+	emit_vlmax_vsetvl (subpart_mode, ops[4]);
       if (MEM_P (ops[1]))
 	{
 	  /* Load operations.  */
@@ -2130,9 +2163,9 @@ expand_vector_init_merge_repeating_sequence (rtx target,
      since we don't have such instruction in RVV.
      Instead, we should use INT mode (QI/HI/SI/DI) with integer move
      instruction to generate the mask data we want.  */
-  machine_mode mask_int_mode
-    = get_repeating_sequence_dup_machine_mode (builder);
   machine_mode mask_bit_mode = get_mask_mode (builder.mode ());
+  machine_mode mask_int_mode
+    = get_repeating_sequence_dup_machine_mode (builder, mask_bit_mode);
   uint64_t full_nelts = builder.full_nelts ().to_constant ();
 
   /* Step 1: Broadcast the first pattern.  */
@@ -2143,7 +2176,8 @@ expand_vector_init_merge_repeating_sequence (rtx target,
   for (unsigned int i = 1; i < builder.npatterns (); i++)
     {
       /* Step 2-1: Generate mask register v0 for each merge.  */
-      rtx merge_mask = builder.get_merge_scalar_mask (i);
+      rtx merge_mask
+	= builder.get_merge_scalar_mask (i, GET_MODE_INNER (mask_int_mode));
       rtx mask = gen_reg_rtx (mask_bit_mode);
       rtx dup = gen_reg_rtx (mask_int_mode);
 
@@ -2238,6 +2272,47 @@ expand_vector_init_merge_combine_sequence (rtx target,
   emit_vlmax_insn (icode, MERGE_OP, merge_ops);
 }
 
+/* Subroutine of expand_vec_init to handle case
+   when all trailing elements of builder are same.
+   This works as follows:
+   (a) Use expand_insn interface to broadcast last vector element in TARGET.
+   (b) Insert remaining elements in TARGET using insr.
+
+   ??? The heuristic used is to do above if number of same trailing elements
+   is greater than leading_ndups, loosely based on
+   heuristic from mostly_zeros_p.  May need fine-tuning.  */
+
+static bool
+expand_vector_init_trailing_same_elem (rtx target,
+				       const rtx_vector_builder &builder,
+				       int nelts_reqd)
+{
+  int leading_ndups = builder.count_dups (0, nelts_reqd - 1, 1);
+  int trailing_ndups = builder.count_dups (nelts_reqd - 1, -1, -1);
+  machine_mode mode = GET_MODE (target);
+
+  if (trailing_ndups > leading_ndups)
+    {
+      rtx dup = expand_vector_broadcast (mode, builder.elt (nelts_reqd - 1));
+      for (int i = nelts_reqd - trailing_ndups - 1; i >= 0; i--)
+	{
+	  unsigned int unspec
+	    = FLOAT_MODE_P (mode) ? UNSPEC_VFSLIDE1UP : UNSPEC_VSLIDE1UP;
+	  insn_code icode = code_for_pred_slide (unspec, mode);
+	  rtx tmp = gen_reg_rtx (mode);
+	  rtx ops[] = {tmp, dup, builder.elt (i)};
+	  emit_vlmax_insn (icode, BINARY_OP, ops);
+	  /* slide1up need source and dest to be different REG.  */
+	  dup = tmp;
+	}
+
+      emit_move_insn (target, dup);
+      return true;
+    }
+
+  return false;
+}
+
 /* Initialize register TARGET from the elements in PARALLEL rtx VALS.  */
 
 void
@@ -2305,10 +2380,13 @@ expand_vec_init (rtx target, rtx vals)
 	}
     }
 
-  /* Handle common situation by vslide1down. This function can handle any
-     situation of vec_init<mode>. Only the cases that are not optimized above
-     will fall through here.  */
-  expand_vector_init_insert_elems (target, v, nelts);
+  /* Optimize trailing same elements sequence:
+      v = {y, y2, y3, y4, y5, x, x, x, x, x, x, x, x, x, x, x};  */
+  if (!expand_vector_init_trailing_same_elem (target, v, nelts))
+    /* Handle common situation by vslide1down. This function can handle any
+       situation of vec_init<mode>. Only the cases that are not optimized above
+       will fall through here.  */
+    expand_vector_init_insert_elems (target, v, nelts);
 }
 
 /* Get insn code for corresponding comparison.  */
diff --git a/gcc/config/riscv/riscv-vsetvl.cc b/gcc/config/riscv/riscv-vsetvl.cc
index 8466b5d..74367ec 100644
--- a/gcc/config/riscv/riscv-vsetvl.cc
+++ b/gcc/config/riscv/riscv-vsetvl.cc
@@ -3229,6 +3229,41 @@ pre_vsetvl::emit_vsetvl ()
       remove_vsetvl_insn (item);
     }
 
+  /* Insert vsetvl info that was not deleted after lift up.  */
+  for (const bb_info *bb : crtl->ssa->bbs ())
+    {
+      const vsetvl_block_info &block_info = get_block_info (bb);
+      if (!block_info.has_info ())
+	continue;
+
+      const vsetvl_info &footer_info = block_info.get_exit_info ();
+
+      if (footer_info.delete_p ())
+	continue;
+
+      edge eg;
+      edge_iterator eg_iterator;
+      FOR_EACH_EDGE (eg, eg_iterator, bb->cfg_bb ()->succs)
+	{
+	  gcc_assert (!(eg->flags & EDGE_ABNORMAL));
+	  if (dump_file)
+	    {
+	      fprintf (
+		dump_file,
+		"\n  Insert missed vsetvl info at edge(bb %u -> bb %u): ",
+		eg->src->index, eg->dest->index);
+	      footer_info.dump (dump_file, "    ");
+	    }
+	  start_sequence ();
+	  insert_vsetvl_insn (EMIT_DIRECT, footer_info);
+	  rtx_insn *rinsn = get_insns ();
+	  end_sequence ();
+	  default_rtl_profile ();
+	  insert_insn_on_edge (rinsn, eg);
+	  need_commit = true;
+	}
+    }
+
   /* m_insert vsetvl as LCM suggest. */
   for (int ed = 0; ed < NUM_EDGES (m_edges); ed++)
     {
@@ -3267,41 +3302,6 @@ pre_vsetvl::emit_vsetvl ()
       insert_insn_on_edge (rinsn, eg);
     }
 
-  /* Insert vsetvl info that was not deleted after lift up.  */
-  for (const bb_info *bb : crtl->ssa->bbs ())
-    {
-      const vsetvl_block_info &block_info = get_block_info (bb);
-      if (!block_info.has_info ())
-	continue;
-
-      const vsetvl_info &footer_info = block_info.get_exit_info ();
-
-      if (footer_info.delete_p ())
-	continue;
-
-      edge eg;
-      edge_iterator eg_iterator;
-      FOR_EACH_EDGE (eg, eg_iterator, bb->cfg_bb ()->succs)
-	{
-	  gcc_assert (!(eg->flags & EDGE_ABNORMAL));
-	  if (dump_file)
-	    {
-	      fprintf (
-		dump_file,
-		"\n  Insert missed vsetvl info at edge(bb %u -> bb %u): ",
-		eg->src->index, eg->dest->index);
-	      footer_info.dump (dump_file, "    ");
-	    }
-	  start_sequence ();
-	  insert_vsetvl_insn (EMIT_DIRECT, footer_info);
-	  rtx_insn *rinsn = get_insns ();
-	  end_sequence ();
-	  default_rtl_profile ();
-	  insert_insn_on_edge (rinsn, eg);
-	  need_commit = true;
-	}
-    }
-
   if (need_commit)
     commit_edge_insertions ();
 }
diff --git a/gcc/config/riscv/riscv.cc b/gcc/config/riscv/riscv.cc
index ecee7eb..c2bd1c2 100644
--- a/gcc/config/riscv/riscv.cc
+++ b/gcc/config/riscv/riscv.cc
@@ -73,10 +73,12 @@ along with GCC; see the file COPYING3.  If not see
 #include "tree-vectorizer.h"
 #include "gcse.h"
 #include "tree-dfa.h"
+#include "target-globals.h"
 
 /* This file should be included last.  */
 #include "target-def.h"
 #include "riscv-vector-costs.h"
+#include "riscv-subset.h"
 
 /* True if X is an UNSPEC wrapper around a SYMBOL_REF or LABEL_REF.  */
 #define UNSPEC_ADDRESS_P(X)					\
@@ -264,17 +266,6 @@ struct riscv_tune_param
   bool use_divmod_expansion;
 };
 
-/* Information about one micro-arch we know about.  */
-struct riscv_tune_info {
-  /* This micro-arch canonical name.  */
-  const char *name;
-
-  /* Which automaton to use for tuning.  */
-  enum riscv_microarchitecture_type microarchitecture;
-
-  /* Tuning parameters for this micro-arch.  */
-  const struct riscv_tune_param *tune_param;
-};
 
 /* Global variables for machine-dependent things.  */
 
@@ -501,10 +492,23 @@ riscv_min_arithmetic_precision (void)
   return 32;
 }
 
-/* Return the riscv_tune_info entry for the given name string.  */
+template <class T>
+static const char *
+get_tune_str (const T *opts)
+{
+  const char *tune_string = RISCV_TUNE_STRING_DEFAULT;
+  if (opts->x_riscv_tune_string)
+    tune_string = opts->x_riscv_tune_string;
+  else if (opts->x_riscv_cpu_string)
+    tune_string = opts->x_riscv_cpu_string;
+  return tune_string;
+}
+
+/* Return the riscv_tune_info entry for the given name string, return nullptr
+   if NULL_P is true, otherwise return an placeholder and report error.  */
 
-static const struct riscv_tune_info *
-riscv_parse_tune (const char *tune_string)
+const struct riscv_tune_info *
+riscv_parse_tune (const char *tune_string, bool null_p)
 {
   const riscv_cpu_info *cpu = riscv_find_cpu (tune_string);
 
@@ -515,6 +519,9 @@ riscv_parse_tune (const char *tune_string)
     if (strcmp (riscv_tune_info_table[i].name, tune_string) == 0)
       return riscv_tune_info_table + i;
 
+  if (null_p)
+    return nullptr;
+
   error ("unknown cpu %qs for %<-mtune%>", tune_string);
   return riscv_tune_info_table;
 }
@@ -1427,6 +1434,10 @@ static bool
 riscv_legitimate_address_p (machine_mode mode, rtx x, bool strict_p,
 			    code_helper = ERROR_MARK)
 {
+  /* Disallow RVV modes base address.
+     E.g. (mem:SI (subreg:DI (reg:V1DI 155) 0).  */
+  if (SUBREG_P (x) && riscv_v_ext_mode_p (GET_MODE (SUBREG_REG (x))))
+    return false;
   struct riscv_address_info addr;
 
   return riscv_classify_address (&addr, x, mode, strict_p);
@@ -3691,6 +3702,24 @@ riscv_zero_if_equal (rtx cmp0, rtx cmp1)
 		       cmp0, cmp1, 0, 0, OPTAB_DIRECT);
 }
 
+/* Helper function for riscv_extend_comparands to Sign-extend the OP.
+   However if the OP is SI subreg promoted with an inner DI, such as
+       (subreg/s/v:SI (reg/v:DI) 0)
+   just peel off the SUBREG to get DI, avoiding extraneous extension.  */
+
+static void
+riscv_sign_extend_if_not_subreg_prom (rtx *op)
+{
+  if (GET_CODE (*op) == SUBREG
+      && SUBREG_PROMOTED_VAR_P (*op)
+      && SUBREG_PROMOTED_SIGNED_P (*op)
+      && (GET_MODE_SIZE (GET_MODE (XEXP (*op, 0))).to_constant ()
+	  == GET_MODE_SIZE (word_mode)))
+    *op = XEXP (*op, 0);
+  else
+    *op = gen_rtx_SIGN_EXTEND (word_mode, *op);
+}
+
 /* Sign- or zero-extend OP0 and OP1 for integer comparisons.  */
 
 static void
@@ -3720,9 +3749,10 @@ riscv_extend_comparands (rtx_code code, rtx *op0, rtx *op1)
 	}
       else
 	{
-	  *op0 = gen_rtx_SIGN_EXTEND (word_mode, *op0);
+	  riscv_sign_extend_if_not_subreg_prom (op0);
+
 	  if (*op1 != const0_rtx)
-	    *op1 = gen_rtx_SIGN_EXTEND (word_mode, *op1);
+	    riscv_sign_extend_if_not_subreg_prom (op1);
 	}
     }
 }
@@ -5802,6 +5832,10 @@ riscv_save_return_addr_reg_p (void)
   if (riscv_far_jump_used_p ())
     return true;
 
+  /* We need to save it if anyone has used that.  */
+  if (df_regs_ever_live_p (RETURN_ADDR_REGNUM))
+    return true;
+
   /* Need not to use ra for leaf when frame pointer is turned off by
      option whatever the omit-leaf-frame's value.  */
   if (frame_pointer_needed && crtl->is_leaf
@@ -7869,6 +7903,33 @@ riscv_declare_function_name (FILE *stream, const char *name, tree fndecl)
   riscv_asm_output_variant_cc (stream, fndecl, name);
   ASM_OUTPUT_TYPE_DIRECTIVE (stream, name, "function");
   ASM_OUTPUT_LABEL (stream, name);
+  if (DECL_FUNCTION_SPECIFIC_TARGET (fndecl))
+    {
+      fprintf (stream, "\t.option push\n");
+      std::string isa = riscv_current_subset_list ()->to_string (true);
+      fprintf (stream, "\t.option arch, %s\n", isa.c_str ());
+
+      struct cl_target_option *local_cl_target =
+	TREE_TARGET_OPTION (DECL_FUNCTION_SPECIFIC_TARGET (fndecl));
+      struct cl_target_option *global_cl_target =
+	TREE_TARGET_OPTION (target_option_default_node);
+      const char *local_tune_str = get_tune_str (local_cl_target);
+      const char *global_tune_str = get_tune_str (global_cl_target);
+      if (strcmp (local_tune_str, global_tune_str) != 0)
+	fprintf (stream, "\t# tune = %s\n", local_tune_str);
+    }
+}
+
+void
+riscv_declare_function_size (FILE *stream, const char *name, tree fndecl)
+{
+  if (!flag_inhibit_size_directive)
+    ASM_OUTPUT_MEASURED_SIZE (stream, name);
+
+  if (DECL_FUNCTION_SPECIFIC_TARGET (fndecl))
+    {
+      fprintf (stream, "\t.option pop\n");
+    }
 }
 
 /* Implement ASM_OUTPUT_DEF_FROM_DECLS.  */
@@ -8075,16 +8136,18 @@ riscv_override_options_internal (struct gcc_options *opts)
     error ("%<-mdiv%> requires %<-march%> to subsume the %<M%> extension");
 
   /* Likewise floating-point division and square root.  */
-  if ((TARGET_HARD_FLOAT || TARGET_ZFINX) && (target_flags_explicit & MASK_FDIV) == 0)
+  if ((TARGET_HARD_FLOAT_OPTS_P (opts) || TARGET_ZFINX_OPTS_P (opts))
+      && ((target_flags_explicit & MASK_FDIV) == 0))
     opts->x_target_flags |= MASK_FDIV;
 
   /* Handle -mtune, use -mcpu if -mtune is not given, and use default -mtune
      if both -mtune and -mcpu are not given.  */
-  cpu = riscv_parse_tune (opts->x_riscv_tune_string ? opts->x_riscv_tune_string :
-			  (opts->x_riscv_cpu_string ? opts->x_riscv_cpu_string :
-			   RISCV_TUNE_STRING_DEFAULT));
+  const char *tune_string = get_tune_str (opts);
+  cpu = riscv_parse_tune (tune_string, false);
   riscv_microarchitecture = cpu->microarchitecture;
-  tune_param = opts->x_optimize_size ? &optimize_size_tune_info : cpu->tune_param;
+  tune_param = opts->x_optimize_size
+		 ? &optimize_size_tune_info
+		 : cpu->tune_param;
 
   /* Use -mtune's setting for slow_unaligned_access, even when optimizing
      for size.  For architectures that trap and emulate unaligned accesses,
@@ -8096,7 +8159,7 @@ riscv_override_options_internal (struct gcc_options *opts)
   /* Make a note if user explicity passed -mstrict-align for later
      builtin macro generation.  Can't use target_flags_explicitly since
      it is set even for -mno-strict-align.  */
-  riscv_user_wants_strict_align = TARGET_STRICT_ALIGN;
+  riscv_user_wants_strict_align = TARGET_STRICT_ALIGN_OPTS_P (opts);
 
   if ((target_flags_explicit & MASK_STRICT_ALIGN) == 0
       && cpu->tune_param->slow_unaligned_access)
@@ -8254,8 +8317,41 @@ riscv_option_override (void)
   init_machine_status = &riscv_init_machine_status;
 
   riscv_override_options_internal (&global_options);
+
+  /* Save these options as the default ones in case we push and pop them later
+     while processing functions with potential target attributes.  */
+  target_option_default_node = target_option_current_node
+    = build_target_option_node (&global_options, &global_options_set);
+}
+
+/* Restore or save the TREE_TARGET_GLOBALS from or to NEW_TREE.
+   Used by riscv_set_current_function to
+   make sure optab availability predicates are recomputed when necessary.  */
+
+void
+riscv_save_restore_target_globals (tree new_tree)
+{
+  if (TREE_TARGET_GLOBALS (new_tree))
+    restore_target_globals (TREE_TARGET_GLOBALS (new_tree));
+  else if (new_tree == target_option_default_node)
+    restore_target_globals (&default_target_globals);
+  else
+    TREE_TARGET_GLOBALS (new_tree) = save_target_globals_default_opts ();
 }
 
+/* Implements TARGET_OPTION_RESTORE.  Restore the backend codegen decisions
+   using the information saved in PTR.  */
+
+static void
+riscv_option_restore (struct gcc_options *opts,
+		      struct gcc_options * /* opts_set */,
+		      struct cl_target_option * /* ptr */)
+{
+  riscv_override_options_internal (opts);
+}
+
+static GTY (()) tree riscv_previous_fndecl;
+
 /* Implement TARGET_CONDITIONAL_REGISTER_USAGE.  */
 
 static void
@@ -8501,7 +8597,12 @@ riscv_get_interrupt_type (tree decl)
     return MACHINE_MODE;
 }
 
-/* Implement `TARGET_SET_CURRENT_FUNCTION'.  */
+/* Implement `TARGET_SET_CURRENT_FUNCTION'.  Unpack the codegen decisions
+   like tuning and ISA features from the DECL_FUNCTION_SPECIFIC_TARGET
+   of the function, if such exists.  This function may be called multiple
+   times on a single function so use aarch64_previous_fndecl to avoid
+   setting up identical state.  */
+
 /* Sanity cheching for above function attributes.  */
 static void
 riscv_set_current_function (tree decl)
@@ -8509,36 +8610,66 @@ riscv_set_current_function (tree decl)
   if (decl == NULL_TREE
       || current_function_decl == NULL_TREE
       || current_function_decl == error_mark_node
-      || ! cfun->machine
-      || cfun->machine->attributes_checked_p)
+      || ! cfun->machine)
     return;
 
-  cfun->machine->naked_p = riscv_naked_function_p (decl);
-  cfun->machine->interrupt_handler_p
-    = riscv_interrupt_type_p (TREE_TYPE (decl));
+  if (!cfun->machine->attributes_checked_p)
+    {
+      cfun->machine->naked_p = riscv_naked_function_p (decl);
+      cfun->machine->interrupt_handler_p
+	= riscv_interrupt_type_p (TREE_TYPE (decl));
 
-  if (cfun->machine->naked_p && cfun->machine->interrupt_handler_p)
-    error ("function attributes %qs and %qs are mutually exclusive",
-	   "interrupt", "naked");
+      if (cfun->machine->naked_p && cfun->machine->interrupt_handler_p)
+	error ("function attributes %qs and %qs are mutually exclusive",
+	       "interrupt", "naked");
 
-  if (cfun->machine->interrupt_handler_p)
-    {
-      tree ret = TREE_TYPE (TREE_TYPE (decl));
-      tree args = TYPE_ARG_TYPES (TREE_TYPE (decl));
+      if (cfun->machine->interrupt_handler_p)
+	{
+	  tree ret = TREE_TYPE (TREE_TYPE (decl));
+	  tree args = TYPE_ARG_TYPES (TREE_TYPE (decl));
+
+	  if (TREE_CODE (ret) != VOID_TYPE)
+	    error ("%qs function cannot return a value", "interrupt");
 
-      if (TREE_CODE (ret) != VOID_TYPE)
-	error ("%qs function cannot return a value", "interrupt");
+	  if (args && TREE_CODE (TREE_VALUE (args)) != VOID_TYPE)
+	    error ("%qs function cannot have arguments", "interrupt");
 
-      if (args && TREE_CODE (TREE_VALUE (args)) != VOID_TYPE)
-	error ("%qs function cannot have arguments", "interrupt");
+	  cfun->machine->interrupt_mode = riscv_get_interrupt_type (decl);
 
-      cfun->machine->interrupt_mode = riscv_get_interrupt_type (decl);
+	  gcc_assert (cfun->machine->interrupt_mode != UNKNOWN_MODE);
+	}
 
-      gcc_assert (cfun->machine->interrupt_mode != UNKNOWN_MODE);
+      /* Don't print the above diagnostics more than once.  */
+      cfun->machine->attributes_checked_p = 1;
     }
 
-  /* Don't print the above diagnostics more than once.  */
-  cfun->machine->attributes_checked_p = 1;
+  if (!decl || decl == riscv_previous_fndecl)
+    return;
+
+  tree old_tree = (riscv_previous_fndecl
+		     ? DECL_FUNCTION_SPECIFIC_TARGET (riscv_previous_fndecl)
+		     : NULL_TREE);
+
+  tree new_tree = DECL_FUNCTION_SPECIFIC_TARGET (decl);
+
+  /* If current function has no attributes but the previous one did,
+     use the default node.  */
+  if (!new_tree && old_tree)
+    new_tree = target_option_default_node;
+
+  /* If nothing to do, return.  #pragma GCC reset or #pragma GCC pop to
+     the default have been handled by aarch64_save_restore_target_globals from
+     aarch64_pragma_target_parse.  */
+  if (old_tree == new_tree)
+    return;
+
+  riscv_previous_fndecl = decl;
+
+  /* First set the target options.  */
+  cl_target_option_restore (&global_options, &global_options_set,
+			    TREE_TARGET_OPTION (new_tree));
+
+  riscv_save_restore_target_globals (new_tree);
 }
 
 /* Implement TARGET_MERGE_DECL_ATTRIBUTES. */
@@ -9660,6 +9791,12 @@ riscv_preferred_else_value (unsigned ifn, tree vectype, unsigned int nops,
 #undef TARGET_OPTION_OVERRIDE
 #define TARGET_OPTION_OVERRIDE riscv_option_override
 
+#undef TARGET_OPTION_RESTORE
+#define TARGET_OPTION_RESTORE riscv_option_restore
+
+#undef TARGET_OPTION_VALID_ATTRIBUTE_P
+#define TARGET_OPTION_VALID_ATTRIBUTE_P riscv_option_valid_attribute_p
+
 #undef TARGET_LEGITIMIZE_ADDRESS
 #define TARGET_LEGITIMIZE_ADDRESS riscv_legitimize_address
 
diff --git a/gcc/config/riscv/riscv.h b/gcc/config/riscv/riscv.h
index 1e9813b..6205d75 100644
--- a/gcc/config/riscv/riscv.h
+++ b/gcc/config/riscv/riscv.h
@@ -25,6 +25,8 @@ along with GCC; see the file COPYING3.  If not see
 #include <stdbool.h>
 #include "config/riscv/riscv-opts.h"
 
+#define SWITCHABLE_TARGET 1
+
 /* Target CPU builtins.  */
 #define TARGET_CPU_CPP_BUILTINS() riscv_cpu_cpp_builtins (pfile)
 
@@ -1056,6 +1058,10 @@ while (0)
 #define ASM_DECLARE_FUNCTION_NAME(STR, NAME, DECL)                             \
   riscv_declare_function_name (STR, NAME, DECL)
 
+#undef ASM_DECLARE_FUNCTION_SIZE
+#define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL)                           \
+  riscv_declare_function_size (FILE, FNAME, DECL)
+
 /* Add output .variant_cc directive for specific alias definition.  */
 #undef ASM_OUTPUT_DEF_FROM_DECLS
 #define ASM_OUTPUT_DEF_FROM_DECLS(STR, DECL, TARGET)                           \
diff --git a/gcc/config/riscv/riscv.opt b/gcc/config/riscv/riscv.opt
index 70d7815..1bd661a 100644
--- a/gcc/config/riscv/riscv.opt
+++ b/gcc/config/riscv/riscv.opt
@@ -84,11 +84,11 @@ Target RejectNegative Joined Negative(march=)
 lower-case.
 
 mtune=
-Target RejectNegative Joined Var(riscv_tune_string)
+Target RejectNegative Joined Var(riscv_tune_string) Save
 -mtune=PROCESSOR	Optimize the output for PROCESSOR.
 
 mcpu=
-Target RejectNegative Joined Var(riscv_cpu_string)
+Target RejectNegative Joined Var(riscv_cpu_string) Save
 -mcpu=PROCESSOR	Use architecture of and optimize the output for PROCESSOR.
 
 msmall-data-limit=
@@ -106,7 +106,7 @@ memory accesses to be generated as compressed instructions.  Currently targets
 32-bit integer load/stores.
 
 mcmodel=
-Target RejectNegative Joined Enum(code_model) Var(riscv_cmodel) Init(TARGET_DEFAULT_CMODEL)
+Target RejectNegative Joined Enum(code_model) Var(riscv_cmodel) Init(TARGET_DEFAULT_CMODEL) Save
 Specify the code model.
 
 mstrict-align
diff --git a/gcc/config/riscv/t-riscv b/gcc/config/riscv/t-riscv
index 95becfc..3b9686d 100644
--- a/gcc/config/riscv/t-riscv
+++ b/gcc/config/riscv/t-riscv
@@ -115,6 +115,11 @@ riscv-v.o: $(srcdir)/config/riscv/riscv-v.cc \
 	$(COMPILE) $<
 	$(POSTCOMPILE)
 
+riscv-target-attr.o: $(srcdir)/config/riscv/riscv-target-attr.cc $(CONFIG_H) \
+  $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) $(DIAGNOSTIC_CORE_H)
+	$(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \
+		$(srcdir)/config/riscv/riscv-target-attr.cc
+
 thead.o: $(srcdir)/config/riscv/thead.cc \
   $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TARGET_H) backend.h $(RTL_H) \
   memmodel.h $(EMIT_RTL_H) poly-int.h output.h
diff --git a/gcc/config/riscv/vector-iterators.md b/gcc/config/riscv/vector-iterators.md
index f04c7fe..469875c 100644
--- a/gcc/config/riscv/vector-iterators.md
+++ b/gcc/config/riscv/vector-iterators.md
@@ -108,48 +108,49 @@
   UNSPECV_FRM_RESTORE_EXIT
 ])
 
-(define_mode_iterator V [
+(define_mode_iterator VI [
   RVVM8QI RVVM4QI RVVM2QI RVVM1QI RVVMF2QI RVVMF4QI (RVVMF8QI "TARGET_MIN_VLEN > 32")
 
   RVVM8HI RVVM4HI RVVM2HI RVVM1HI RVVMF2HI (RVVMF4HI "TARGET_MIN_VLEN > 32")
 
-  (RVVM8HF "TARGET_VECTOR_ELEN_FP_16") (RVVM4HF "TARGET_VECTOR_ELEN_FP_16") (RVVM2HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVM1HF "TARGET_VECTOR_ELEN_FP_16") (RVVMF2HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVMF4HF "TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN > 32")
-
   RVVM8SI RVVM4SI RVVM2SI RVVM1SI (RVVMF2SI "TARGET_MIN_VLEN > 32")
 
-  (RVVM8SF "TARGET_VECTOR_ELEN_FP_32") (RVVM4SF "TARGET_VECTOR_ELEN_FP_32") (RVVM2SF "TARGET_VECTOR_ELEN_FP_32")
-  (RVVM1SF "TARGET_VECTOR_ELEN_FP_32") (RVVMF2SF "TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN > 32")
-
   (RVVM8DI "TARGET_VECTOR_ELEN_64") (RVVM4DI "TARGET_VECTOR_ELEN_64")
   (RVVM2DI "TARGET_VECTOR_ELEN_64") (RVVM1DI "TARGET_VECTOR_ELEN_64")
+])
+
+;; This iterator is the same as above but with TARGET_VECTOR_ELEN_FP_16
+;; changed to TARGET_ZVFH.  TARGET_VECTOR_ELEN_FP_16 is also true for
+;; TARGET_ZVFHMIN while we actually want to disable all instructions apart
+;; from load, store and convert for it.
+;; It is not enough to set the "enabled" attribute to false
+;; since this will only disable insn alternatives in reload but still
+;; allow the instruction and mode to be matched during combine et al.
+(define_mode_iterator VF [
+  (RVVM8HF "TARGET_ZVFH") (RVVM4HF "TARGET_ZVFH") (RVVM2HF "TARGET_ZVFH")
+  (RVVM1HF "TARGET_ZVFH") (RVVMF2HF "TARGET_ZVFH")
+  (RVVMF4HF "TARGET_ZVFH && TARGET_MIN_VLEN > 32")
+
+  (RVVM8SF "TARGET_VECTOR_ELEN_FP_32") (RVVM4SF "TARGET_VECTOR_ELEN_FP_32") (RVVM2SF "TARGET_VECTOR_ELEN_FP_32")
+  (RVVM1SF "TARGET_VECTOR_ELEN_FP_32") (RVVMF2SF "TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN > 32")
 
   (RVVM8DF "TARGET_VECTOR_ELEN_FP_64") (RVVM4DF "TARGET_VECTOR_ELEN_FP_64")
   (RVVM2DF "TARGET_VECTOR_ELEN_FP_64") (RVVM1DF "TARGET_VECTOR_ELEN_FP_64")
 ])
 
-(define_mode_iterator V_VLS [
-  RVVM8QI RVVM4QI RVVM2QI RVVM1QI RVVMF2QI RVVMF4QI (RVVMF8QI "TARGET_MIN_VLEN > 32")
-
-  RVVM8HI RVVM4HI RVVM2HI RVVM1HI RVVMF2HI (RVVMF4HI "TARGET_MIN_VLEN > 32")
-
+(define_mode_iterator VF_ZVFHMIN [
   (RVVM8HF "TARGET_VECTOR_ELEN_FP_16") (RVVM4HF "TARGET_VECTOR_ELEN_FP_16") (RVVM2HF "TARGET_VECTOR_ELEN_FP_16")
   (RVVM1HF "TARGET_VECTOR_ELEN_FP_16") (RVVMF2HF "TARGET_VECTOR_ELEN_FP_16")
   (RVVMF4HF "TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN > 32")
 
-  RVVM8SI RVVM4SI RVVM2SI RVVM1SI (RVVMF2SI "TARGET_MIN_VLEN > 32")
-
   (RVVM8SF "TARGET_VECTOR_ELEN_FP_32") (RVVM4SF "TARGET_VECTOR_ELEN_FP_32") (RVVM2SF "TARGET_VECTOR_ELEN_FP_32")
   (RVVM1SF "TARGET_VECTOR_ELEN_FP_32") (RVVMF2SF "TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN > 32")
 
-  (RVVM8DI "TARGET_VECTOR_ELEN_64") (RVVM4DI "TARGET_VECTOR_ELEN_64")
-  (RVVM2DI "TARGET_VECTOR_ELEN_64") (RVVM1DI "TARGET_VECTOR_ELEN_64")
-
   (RVVM8DF "TARGET_VECTOR_ELEN_FP_64") (RVVM4DF "TARGET_VECTOR_ELEN_FP_64")
   (RVVM2DF "TARGET_VECTOR_ELEN_FP_64") (RVVM1DF "TARGET_VECTOR_ELEN_FP_64")
+])
 
-  ;; VLS modes.
+(define_mode_iterator VLSI [
   (V1QI "riscv_vector::vls_mode_valid_p (V1QImode)")
   (V2QI "riscv_vector::vls_mode_valid_p (V2QImode)")
   (V4QI "riscv_vector::vls_mode_valid_p (V4QImode)")
@@ -195,7 +196,45 @@
   (V64DI "riscv_vector::vls_mode_valid_p (V64DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 512")
   (V128DI "riscv_vector::vls_mode_valid_p (V128DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 1024")
   (V256DI "riscv_vector::vls_mode_valid_p (V256DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 2048")
-  (V512DI "riscv_vector::vls_mode_valid_p (V512DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 4096")
+  (V512DI "riscv_vector::vls_mode_valid_p (V512DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 4096")])
+
+(define_mode_iterator VLSF [
+  (V1HF "riscv_vector::vls_mode_valid_p (V1HFmode) && TARGET_ZVFH")
+  (V2HF "riscv_vector::vls_mode_valid_p (V2HFmode) && TARGET_ZVFH")
+  (V4HF "riscv_vector::vls_mode_valid_p (V4HFmode) && TARGET_ZVFH")
+  (V8HF "riscv_vector::vls_mode_valid_p (V8HFmode) && TARGET_ZVFH")
+  (V16HF "riscv_vector::vls_mode_valid_p (V16HFmode) && TARGET_ZVFH")
+  (V32HF "riscv_vector::vls_mode_valid_p (V32HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 64")
+  (V64HF "riscv_vector::vls_mode_valid_p (V64HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 128")
+  (V128HF "riscv_vector::vls_mode_valid_p (V128HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 256")
+  (V256HF "riscv_vector::vls_mode_valid_p (V256HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 512")
+  (V512HF "riscv_vector::vls_mode_valid_p (V512HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 1024")
+  (V1024HF "riscv_vector::vls_mode_valid_p (V1024HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 2048")
+  (V2048HF "riscv_vector::vls_mode_valid_p (V2048HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 4096")
+  (V1SF "riscv_vector::vls_mode_valid_p (V1SFmode) && TARGET_VECTOR_ELEN_FP_32")
+  (V2SF "riscv_vector::vls_mode_valid_p (V2SFmode) && TARGET_VECTOR_ELEN_FP_32")
+  (V4SF "riscv_vector::vls_mode_valid_p (V4SFmode) && TARGET_VECTOR_ELEN_FP_32")
+  (V8SF "riscv_vector::vls_mode_valid_p (V8SFmode) && TARGET_VECTOR_ELEN_FP_32")
+  (V16SF "riscv_vector::vls_mode_valid_p (V16SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 64")
+  (V32SF "riscv_vector::vls_mode_valid_p (V32SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 128")
+  (V64SF "riscv_vector::vls_mode_valid_p (V64SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 256")
+  (V128SF "riscv_vector::vls_mode_valid_p (V128SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 512")
+  (V256SF "riscv_vector::vls_mode_valid_p (V256SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 1024")
+  (V512SF "riscv_vector::vls_mode_valid_p (V512SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 2048")
+  (V1024SF "riscv_vector::vls_mode_valid_p (V1024SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 4096")
+  (V1DF "riscv_vector::vls_mode_valid_p (V1DFmode) && TARGET_VECTOR_ELEN_FP_64")
+  (V2DF "riscv_vector::vls_mode_valid_p (V2DFmode) && TARGET_VECTOR_ELEN_FP_64")
+  (V4DF "riscv_vector::vls_mode_valid_p (V4DFmode) && TARGET_VECTOR_ELEN_FP_64")
+  (V8DF "riscv_vector::vls_mode_valid_p (V8DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 64")
+  (V16DF "riscv_vector::vls_mode_valid_p (V16DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 128")
+  (V32DF "riscv_vector::vls_mode_valid_p (V32DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 256")
+  (V64DF "riscv_vector::vls_mode_valid_p (V64DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 512")
+  (V128DF "riscv_vector::vls_mode_valid_p (V128DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 1024")
+  (V256DF "riscv_vector::vls_mode_valid_p (V256DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 2048")
+  (V512DF "riscv_vector::vls_mode_valid_p (V512DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 4096")
+])
+
+(define_mode_iterator VLSF_ZVFHMIN [
   (V1HF "riscv_vector::vls_mode_valid_p (V1HFmode) && TARGET_VECTOR_ELEN_FP_16")
   (V2HF "riscv_vector::vls_mode_valid_p (V2HFmode) && TARGET_VECTOR_ELEN_FP_16")
   (V4HF "riscv_vector::vls_mode_valid_p (V4HFmode) && TARGET_VECTOR_ELEN_FP_16")
@@ -399,196 +438,6 @@
   (V512DF "riscv_vector::vls_mode_valid_p (V512DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 4096")
 ])
 
-(define_mode_iterator VI [
-  RVVM8QI RVVM4QI RVVM2QI RVVM1QI RVVMF2QI RVVMF4QI (RVVMF8QI "TARGET_MIN_VLEN > 32")
-
-  RVVM8HI RVVM4HI RVVM2HI RVVM1HI RVVMF2HI (RVVMF4HI "TARGET_MIN_VLEN > 32")
-
-  RVVM8SI RVVM4SI RVVM2SI RVVM1SI (RVVMF2SI "TARGET_MIN_VLEN > 32")
-
-  (RVVM8DI "TARGET_VECTOR_ELEN_64") (RVVM4DI "TARGET_VECTOR_ELEN_64")
-  (RVVM2DI "TARGET_VECTOR_ELEN_64") (RVVM1DI "TARGET_VECTOR_ELEN_64")
-])
-
-(define_mode_iterator V_VLSI [
-  RVVM8QI RVVM4QI RVVM2QI RVVM1QI RVVMF2QI RVVMF4QI (RVVMF8QI "TARGET_MIN_VLEN > 32")
-
-  RVVM8HI RVVM4HI RVVM2HI RVVM1HI RVVMF2HI (RVVMF4HI "TARGET_MIN_VLEN > 32")
-
-  RVVM8SI RVVM4SI RVVM2SI RVVM1SI (RVVMF2SI "TARGET_MIN_VLEN > 32")
-
-  (RVVM8DI "TARGET_VECTOR_ELEN_64") (RVVM4DI "TARGET_VECTOR_ELEN_64")
-  (RVVM2DI "TARGET_VECTOR_ELEN_64") (RVVM1DI "TARGET_VECTOR_ELEN_64")
-
-  (V1QI "riscv_vector::vls_mode_valid_p (V1QImode)")
-  (V2QI "riscv_vector::vls_mode_valid_p (V2QImode)")
-  (V4QI "riscv_vector::vls_mode_valid_p (V4QImode)")
-  (V8QI "riscv_vector::vls_mode_valid_p (V8QImode)")
-  (V16QI "riscv_vector::vls_mode_valid_p (V16QImode)")
-  (V32QI "riscv_vector::vls_mode_valid_p (V32QImode)")
-  (V64QI "riscv_vector::vls_mode_valid_p (V64QImode) && TARGET_MIN_VLEN >= 64")
-  (V128QI "riscv_vector::vls_mode_valid_p (V128QImode) && TARGET_MIN_VLEN >= 128")
-  (V256QI "riscv_vector::vls_mode_valid_p (V256QImode) && TARGET_MIN_VLEN >= 256")
-  (V512QI "riscv_vector::vls_mode_valid_p (V512QImode) && TARGET_MIN_VLEN >= 512")
-  (V1024QI "riscv_vector::vls_mode_valid_p (V1024QImode) && TARGET_MIN_VLEN >= 1024")
-  (V2048QI "riscv_vector::vls_mode_valid_p (V2048QImode) && TARGET_MIN_VLEN >= 2048")
-  (V4096QI "riscv_vector::vls_mode_valid_p (V4096QImode) && TARGET_MIN_VLEN >= 4096")
-  (V1HI "riscv_vector::vls_mode_valid_p (V1HImode)")
-  (V2HI "riscv_vector::vls_mode_valid_p (V2HImode)")
-  (V4HI "riscv_vector::vls_mode_valid_p (V4HImode)")
-  (V8HI "riscv_vector::vls_mode_valid_p (V8HImode)")
-  (V16HI "riscv_vector::vls_mode_valid_p (V16HImode)")
-  (V32HI "riscv_vector::vls_mode_valid_p (V32HImode) && TARGET_MIN_VLEN >= 64")
-  (V64HI "riscv_vector::vls_mode_valid_p (V64HImode) && TARGET_MIN_VLEN >= 128")
-  (V128HI "riscv_vector::vls_mode_valid_p (V128HImode) && TARGET_MIN_VLEN >= 256")
-  (V256HI "riscv_vector::vls_mode_valid_p (V256HImode) && TARGET_MIN_VLEN >= 512")
-  (V512HI "riscv_vector::vls_mode_valid_p (V512HImode) && TARGET_MIN_VLEN >= 1024")
-  (V1024HI "riscv_vector::vls_mode_valid_p (V1024HImode) && TARGET_MIN_VLEN >= 2048")
-  (V2048HI "riscv_vector::vls_mode_valid_p (V2048HImode) && TARGET_MIN_VLEN >= 4096")
-  (V1SI "riscv_vector::vls_mode_valid_p (V1SImode)")
-  (V2SI "riscv_vector::vls_mode_valid_p (V2SImode)")
-  (V4SI "riscv_vector::vls_mode_valid_p (V4SImode)")
-  (V8SI "riscv_vector::vls_mode_valid_p (V8SImode)")
-  (V16SI "riscv_vector::vls_mode_valid_p (V16SImode) && TARGET_MIN_VLEN >= 64")
-  (V32SI "riscv_vector::vls_mode_valid_p (V32SImode) && TARGET_MIN_VLEN >= 128")
-  (V64SI "riscv_vector::vls_mode_valid_p (V64SImode) && TARGET_MIN_VLEN >= 256")
-  (V128SI "riscv_vector::vls_mode_valid_p (V128SImode) && TARGET_MIN_VLEN >= 512")
-  (V256SI "riscv_vector::vls_mode_valid_p (V256SImode) && TARGET_MIN_VLEN >= 1024")
-  (V512SI "riscv_vector::vls_mode_valid_p (V512SImode) && TARGET_MIN_VLEN >= 2048")
-  (V1024SI "riscv_vector::vls_mode_valid_p (V1024SImode) && TARGET_MIN_VLEN >= 4096")
-  (V1DI "riscv_vector::vls_mode_valid_p (V1DImode) && TARGET_VECTOR_ELEN_64")
-  (V2DI "riscv_vector::vls_mode_valid_p (V2DImode) && TARGET_VECTOR_ELEN_64")
-  (V4DI "riscv_vector::vls_mode_valid_p (V4DImode) && TARGET_VECTOR_ELEN_64")
-  (V8DI "riscv_vector::vls_mode_valid_p (V8DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 64")
-  (V16DI "riscv_vector::vls_mode_valid_p (V16DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 128")
-  (V32DI "riscv_vector::vls_mode_valid_p (V32DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 256")
-  (V64DI "riscv_vector::vls_mode_valid_p (V64DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 512")
-  (V128DI "riscv_vector::vls_mode_valid_p (V128DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 1024")
-  (V256DI "riscv_vector::vls_mode_valid_p (V256DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 2048")
-  (V512DI "riscv_vector::vls_mode_valid_p (V512DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 4096")
-])
-
-(define_mode_iterator V_VLSF [
-  (RVVM8HF "TARGET_ZVFH") (RVVM4HF "TARGET_ZVFH") (RVVM2HF "TARGET_ZVFH")
-  (RVVM1HF "TARGET_ZVFH") (RVVMF2HF "TARGET_ZVFH")
-  (RVVMF4HF "TARGET_ZVFH && TARGET_MIN_VLEN > 32")
-  (RVVM8SF "TARGET_VECTOR_ELEN_FP_32") (RVVM4SF "TARGET_VECTOR_ELEN_FP_32") (RVVM2SF "TARGET_VECTOR_ELEN_FP_32")
-  (RVVM1SF "TARGET_VECTOR_ELEN_FP_32") (RVVMF2SF "TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN > 32")
-  (RVVM8DF "TARGET_VECTOR_ELEN_FP_64") (RVVM4DF "TARGET_VECTOR_ELEN_FP_64")
-  (RVVM2DF "TARGET_VECTOR_ELEN_FP_64") (RVVM1DF "TARGET_VECTOR_ELEN_FP_64")
-
-  (V1HF "riscv_vector::vls_mode_valid_p (V1HFmode) && TARGET_ZVFH")
-  (V2HF "riscv_vector::vls_mode_valid_p (V2HFmode) && TARGET_ZVFH")
-  (V4HF "riscv_vector::vls_mode_valid_p (V4HFmode) && TARGET_ZVFH")
-  (V8HF "riscv_vector::vls_mode_valid_p (V8HFmode) && TARGET_ZVFH")
-  (V16HF "riscv_vector::vls_mode_valid_p (V16HFmode) && TARGET_ZVFH")
-  (V32HF "riscv_vector::vls_mode_valid_p (V32HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 64")
-  (V64HF "riscv_vector::vls_mode_valid_p (V64HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 128")
-  (V128HF "riscv_vector::vls_mode_valid_p (V128HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 256")
-  (V256HF "riscv_vector::vls_mode_valid_p (V256HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 512")
-  (V512HF "riscv_vector::vls_mode_valid_p (V512HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 1024")
-  (V1024HF "riscv_vector::vls_mode_valid_p (V1024HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 2048")
-  (V2048HF "riscv_vector::vls_mode_valid_p (V2048HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 4096")
-  (V1SF "riscv_vector::vls_mode_valid_p (V1SFmode) && TARGET_VECTOR_ELEN_FP_32")
-  (V2SF "riscv_vector::vls_mode_valid_p (V2SFmode) && TARGET_VECTOR_ELEN_FP_32")
-  (V4SF "riscv_vector::vls_mode_valid_p (V4SFmode) && TARGET_VECTOR_ELEN_FP_32")
-  (V8SF "riscv_vector::vls_mode_valid_p (V8SFmode) && TARGET_VECTOR_ELEN_FP_32")
-  (V16SF "riscv_vector::vls_mode_valid_p (V16SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 64")
-  (V32SF "riscv_vector::vls_mode_valid_p (V32SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 128")
-  (V64SF "riscv_vector::vls_mode_valid_p (V64SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 256")
-  (V128SF "riscv_vector::vls_mode_valid_p (V128SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 512")
-  (V256SF "riscv_vector::vls_mode_valid_p (V256SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 1024")
-  (V512SF "riscv_vector::vls_mode_valid_p (V512SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 2048")
-  (V1024SF "riscv_vector::vls_mode_valid_p (V1024SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 4096")
-  (V1DF "riscv_vector::vls_mode_valid_p (V1DFmode) && TARGET_VECTOR_ELEN_FP_64")
-  (V2DF "riscv_vector::vls_mode_valid_p (V2DFmode) && TARGET_VECTOR_ELEN_FP_64")
-  (V4DF "riscv_vector::vls_mode_valid_p (V4DFmode) && TARGET_VECTOR_ELEN_FP_64")
-  (V8DF "riscv_vector::vls_mode_valid_p (V8DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 64")
-  (V16DF "riscv_vector::vls_mode_valid_p (V16DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 128")
-  (V32DF "riscv_vector::vls_mode_valid_p (V32DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 256")
-  (V64DF "riscv_vector::vls_mode_valid_p (V64DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 512")
-  (V128DF "riscv_vector::vls_mode_valid_p (V128DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 1024")
-  (V256DF "riscv_vector::vls_mode_valid_p (V256DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 2048")
-  (V512DF "riscv_vector::vls_mode_valid_p (V512DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 4096")
-])
-
-(define_mode_iterator VF_ZVFHMIN [
-  (RVVM8HF "TARGET_VECTOR_ELEN_FP_16") (RVVM4HF "TARGET_VECTOR_ELEN_FP_16") (RVVM2HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVM1HF "TARGET_VECTOR_ELEN_FP_16") (RVVMF2HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVMF4HF "TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN > 32")
-
-  (RVVM8SF "TARGET_VECTOR_ELEN_FP_32") (RVVM4SF "TARGET_VECTOR_ELEN_FP_32") (RVVM2SF "TARGET_VECTOR_ELEN_FP_32")
-  (RVVM1SF "TARGET_VECTOR_ELEN_FP_32") (RVVMF2SF "TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN > 32")
-
-  (RVVM8DF "TARGET_VECTOR_ELEN_FP_64") (RVVM4DF "TARGET_VECTOR_ELEN_FP_64")
-  (RVVM2DF "TARGET_VECTOR_ELEN_FP_64") (RVVM1DF "TARGET_VECTOR_ELEN_FP_64")
-])
-
-(define_mode_iterator V_VLSF_ZVFHMIN [
-  (RVVM8HF "TARGET_VECTOR_ELEN_FP_16") (RVVM4HF "TARGET_VECTOR_ELEN_FP_16") (RVVM2HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVM1HF "TARGET_VECTOR_ELEN_FP_16") (RVVMF2HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVMF4HF "TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN > 32")
-
-  (RVVM8SF "TARGET_VECTOR_ELEN_FP_32") (RVVM4SF "TARGET_VECTOR_ELEN_FP_32") (RVVM2SF "TARGET_VECTOR_ELEN_FP_32")
-  (RVVM1SF "TARGET_VECTOR_ELEN_FP_32") (RVVMF2SF "TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN > 32")
-
-  (RVVM8DF "TARGET_VECTOR_ELEN_FP_64") (RVVM4DF "TARGET_VECTOR_ELEN_FP_64")
-  (RVVM2DF "TARGET_VECTOR_ELEN_FP_64") (RVVM1DF "TARGET_VECTOR_ELEN_FP_64")
-
-  (V1HF "riscv_vector::vls_mode_valid_p (V1HFmode) && TARGET_VECTOR_ELEN_FP_16")
-  (V2HF "riscv_vector::vls_mode_valid_p (V2HFmode) && TARGET_VECTOR_ELEN_FP_16")
-  (V4HF "riscv_vector::vls_mode_valid_p (V4HFmode) && TARGET_VECTOR_ELEN_FP_16")
-  (V8HF "riscv_vector::vls_mode_valid_p (V8HFmode) && TARGET_VECTOR_ELEN_FP_16")
-  (V16HF "riscv_vector::vls_mode_valid_p (V16HFmode) && TARGET_VECTOR_ELEN_FP_16")
-  (V32HF "riscv_vector::vls_mode_valid_p (V32HFmode) && TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN >= 64")
-  (V64HF "riscv_vector::vls_mode_valid_p (V64HFmode) && TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN >= 128")
-  (V128HF "riscv_vector::vls_mode_valid_p (V128HFmode) && TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN >= 256")
-  (V256HF "riscv_vector::vls_mode_valid_p (V256HFmode) && TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN >= 512")
-  (V512HF "riscv_vector::vls_mode_valid_p (V512HFmode) && TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN >= 1024")
-  (V1024HF "riscv_vector::vls_mode_valid_p (V1024HFmode) && TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN >= 2048")
-  (V2048HF "riscv_vector::vls_mode_valid_p (V2048HFmode) && TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN >= 4096")
-  (V1SF "riscv_vector::vls_mode_valid_p (V1SFmode) && TARGET_VECTOR_ELEN_FP_32")
-  (V2SF "riscv_vector::vls_mode_valid_p (V2SFmode) && TARGET_VECTOR_ELEN_FP_32")
-  (V4SF "riscv_vector::vls_mode_valid_p (V4SFmode) && TARGET_VECTOR_ELEN_FP_32")
-  (V8SF "riscv_vector::vls_mode_valid_p (V8SFmode) && TARGET_VECTOR_ELEN_FP_32")
-  (V16SF "riscv_vector::vls_mode_valid_p (V16SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 64")
-  (V32SF "riscv_vector::vls_mode_valid_p (V32SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 128")
-  (V64SF "riscv_vector::vls_mode_valid_p (V64SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 256")
-  (V128SF "riscv_vector::vls_mode_valid_p (V128SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 512")
-  (V256SF "riscv_vector::vls_mode_valid_p (V256SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 1024")
-  (V512SF "riscv_vector::vls_mode_valid_p (V512SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 2048")
-  (V1024SF "riscv_vector::vls_mode_valid_p (V1024SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 4096")
-  (V1DF "riscv_vector::vls_mode_valid_p (V1DFmode) && TARGET_VECTOR_ELEN_FP_64")
-  (V2DF "riscv_vector::vls_mode_valid_p (V2DFmode) && TARGET_VECTOR_ELEN_FP_64")
-  (V4DF "riscv_vector::vls_mode_valid_p (V4DFmode) && TARGET_VECTOR_ELEN_FP_64")
-  (V8DF "riscv_vector::vls_mode_valid_p (V8DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 64")
-  (V16DF "riscv_vector::vls_mode_valid_p (V16DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 128")
-  (V32DF "riscv_vector::vls_mode_valid_p (V32DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 256")
-  (V64DF "riscv_vector::vls_mode_valid_p (V64DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 512")
-  (V128DF "riscv_vector::vls_mode_valid_p (V128DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 1024")
-  (V256DF "riscv_vector::vls_mode_valid_p (V256DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 2048")
-  (V512DF "riscv_vector::vls_mode_valid_p (V512DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 4096")
-])
-
-;; This iterator is the same as above but with TARGET_VECTOR_ELEN_FP_16
-;; changed to TARGET_ZVFH.  TARGET_VECTOR_ELEN_FP_16 is also true for
-;; TARGET_ZVFHMIN while we actually want to disable all instructions apart
-;; from load, store and convert for it.
-;; It is not enough to set the "enabled" attribute to false
-;; since this will only disable insn alternatives in reload but still
-;; allow the instruction and mode to be matched during combine et al.
-(define_mode_iterator VF [
-  (RVVM8HF "TARGET_ZVFH") (RVVM4HF "TARGET_ZVFH") (RVVM2HF "TARGET_ZVFH")
-  (RVVM1HF "TARGET_ZVFH") (RVVMF2HF "TARGET_ZVFH")
-  (RVVMF4HF "TARGET_ZVFH && TARGET_MIN_VLEN > 32")
-
-  (RVVM8SF "TARGET_VECTOR_ELEN_FP_32") (RVVM4SF "TARGET_VECTOR_ELEN_FP_32") (RVVM2SF "TARGET_VECTOR_ELEN_FP_32")
-  (RVVM1SF "TARGET_VECTOR_ELEN_FP_32") (RVVMF2SF "TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN > 32")
-
-  (RVVM8DF "TARGET_VECTOR_ELEN_FP_64") (RVVM4DF "TARGET_VECTOR_ELEN_FP_64")
-  (RVVM2DF "TARGET_VECTOR_ELEN_FP_64") (RVVM1DF "TARGET_VECTOR_ELEN_FP_64")
-])
-
 (define_mode_iterator VFULLI [
   RVVM8QI RVVM4QI RVVM2QI RVVM1QI RVVMF2QI RVVMF4QI (RVVMF8QI "TARGET_MIN_VLEN > 32")
 
@@ -1011,27 +860,6 @@
   (RVVMF2SF "TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN > 32")
 ])
 
-(define_mode_iterator VB [
-  (RVVMF64BI "TARGET_MIN_VLEN > 32") RVVMF32BI RVVMF16BI RVVMF8BI RVVMF4BI RVVMF2BI RVVM1BI
-])
-
-(define_mode_iterator VB_VLS [
-  (RVVMF64BI "TARGET_MIN_VLEN > 32") RVVMF32BI RVVMF16BI RVVMF8BI RVVMF4BI RVVMF2BI RVVM1BI
-  (V1BI "riscv_vector::vls_mode_valid_p (V1BImode)")
-  (V2BI "riscv_vector::vls_mode_valid_p (V2BImode)")
-  (V4BI "riscv_vector::vls_mode_valid_p (V4BImode)")
-  (V8BI "riscv_vector::vls_mode_valid_p (V8BImode)")
-  (V16BI "riscv_vector::vls_mode_valid_p (V16BImode)")
-  (V32BI "riscv_vector::vls_mode_valid_p (V32BImode)")
-  (V64BI "riscv_vector::vls_mode_valid_p (V64BImode) && TARGET_MIN_VLEN >= 64")
-  (V128BI "riscv_vector::vls_mode_valid_p (V128BImode) && TARGET_MIN_VLEN >= 128")
-  (V256BI "riscv_vector::vls_mode_valid_p (V256BImode) && TARGET_MIN_VLEN >= 256")
-  (V512BI "riscv_vector::vls_mode_valid_p (V512BImode) && TARGET_MIN_VLEN >= 512")
-  (V1024BI "riscv_vector::vls_mode_valid_p (V1024BImode) && TARGET_MIN_VLEN >= 1024")
-  (V2048BI "riscv_vector::vls_mode_valid_p (V2048BImode) && TARGET_MIN_VLEN >= 2048")
-  (V4096BI "riscv_vector::vls_mode_valid_p (V4096BImode) && TARGET_MIN_VLEN >= 4096")
-])
-
 (define_mode_iterator VWEXTI [
   RVVM8HI RVVM4HI RVVM2HI RVVM1HI RVVMF2HI (RVVMF4HI "TARGET_MIN_VLEN > 32")
 
@@ -1253,101 +1081,6 @@
   (V512DI "riscv_vector::vls_mode_valid_p (V512DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 4096")
 ])
 
-(define_mode_iterator VT [
-  RVVM1x8QI RVVMF2x8QI RVVMF4x8QI (RVVMF8x8QI "TARGET_MIN_VLEN > 32")
-  RVVM1x7QI RVVMF2x7QI RVVMF4x7QI (RVVMF8x7QI "TARGET_MIN_VLEN > 32")
-  RVVM1x6QI RVVMF2x6QI RVVMF4x6QI (RVVMF8x6QI "TARGET_MIN_VLEN > 32")
-  RVVM1x5QI RVVMF2x5QI RVVMF4x5QI (RVVMF8x5QI "TARGET_MIN_VLEN > 32")
-  RVVM2x4QI RVVM1x4QI RVVMF2x4QI RVVMF4x4QI (RVVMF8x4QI "TARGET_MIN_VLEN > 32")
-  RVVM2x3QI RVVM1x3QI RVVMF2x3QI RVVMF4x3QI (RVVMF8x3QI "TARGET_MIN_VLEN > 32")
-  RVVM4x2QI RVVM2x2QI RVVM1x2QI RVVMF2x2QI RVVMF4x2QI (RVVMF8x2QI "TARGET_MIN_VLEN > 32")
-
-  RVVM1x8HI RVVMF2x8HI (RVVMF4x8HI "TARGET_MIN_VLEN > 32")
-  RVVM1x7HI RVVMF2x7HI (RVVMF4x7HI "TARGET_MIN_VLEN > 32")
-  RVVM1x6HI RVVMF2x6HI (RVVMF4x6HI "TARGET_MIN_VLEN > 32")
-  RVVM1x5HI RVVMF2x5HI (RVVMF4x5HI "TARGET_MIN_VLEN > 32")
-  RVVM2x4HI RVVM1x4HI RVVMF2x4HI (RVVMF4x4HI "TARGET_MIN_VLEN > 32")
-  RVVM2x3HI RVVM1x3HI RVVMF2x3HI (RVVMF4x3HI "TARGET_MIN_VLEN > 32")
-  RVVM4x2HI RVVM2x2HI RVVM1x2HI RVVMF2x2HI (RVVMF4x2HI "TARGET_MIN_VLEN > 32")
-
-  (RVVM1x8HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVMF2x8HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVMF4x8HF "TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN > 32")
-  (RVVM1x7HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVMF2x7HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVMF4x7HF "TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN > 32")
-  (RVVM1x6HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVMF2x6HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVMF4x6HF "TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN > 32")
-  (RVVM1x5HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVMF2x5HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVMF4x5HF "TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN > 32")
-  (RVVM2x4HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVM1x4HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVMF2x4HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVMF4x4HF "TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN > 32")
-  (RVVM2x3HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVM1x3HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVMF2x3HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVMF4x3HF "TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN > 32")
-  (RVVM4x2HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVM2x2HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVM1x2HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVMF2x2HF "TARGET_VECTOR_ELEN_FP_16")
-  (RVVMF4x2HF "TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN > 32")
-
-  RVVM1x8SI (RVVMF2x8SI "TARGET_MIN_VLEN > 32")
-  RVVM1x7SI (RVVMF2x7SI "TARGET_MIN_VLEN > 32")
-  RVVM1x6SI (RVVMF2x6SI "TARGET_MIN_VLEN > 32")
-  RVVM1x5SI (RVVMF2x5SI "TARGET_MIN_VLEN > 32")
-  RVVM2x4SI RVVM1x4SI (RVVMF2x4SI "TARGET_MIN_VLEN > 32")
-  RVVM2x3SI RVVM1x3SI (RVVMF2x3SI "TARGET_MIN_VLEN > 32")
-  RVVM4x2SI RVVM2x2SI RVVM1x2SI (RVVMF2x2SI "TARGET_MIN_VLEN > 32")
-
-  (RVVM1x8SF "TARGET_VECTOR_ELEN_FP_32")
-  (RVVMF2x8SF "TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN > 32")
-  (RVVM1x7SF "TARGET_VECTOR_ELEN_FP_32")
-  (RVVMF2x7SF "TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN > 32")
-  (RVVM1x6SF "TARGET_VECTOR_ELEN_FP_32")
-  (RVVMF2x6SF "TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN > 32")
-  (RVVM1x5SF "TARGET_VECTOR_ELEN_FP_32")
-  (RVVMF2x5SF "TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN > 32")
-  (RVVM2x4SF "TARGET_VECTOR_ELEN_FP_32")
-  (RVVM1x4SF "TARGET_VECTOR_ELEN_FP_32")
-  (RVVMF2x4SF "TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN > 32")
-  (RVVM2x3SF "TARGET_VECTOR_ELEN_FP_32")
-  (RVVM1x3SF "TARGET_VECTOR_ELEN_FP_32")
-  (RVVMF2x3SF "TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN > 32")
-  (RVVM4x2SF "TARGET_VECTOR_ELEN_FP_32")
-  (RVVM2x2SF "TARGET_VECTOR_ELEN_FP_32")
-  (RVVM1x2SF "TARGET_VECTOR_ELEN_FP_32")
-  (RVVMF2x2SF "TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN > 32")
-
-  (RVVM1x8DI "TARGET_VECTOR_ELEN_64")
-  (RVVM1x7DI "TARGET_VECTOR_ELEN_64")
-  (RVVM1x6DI "TARGET_VECTOR_ELEN_64")
-  (RVVM1x5DI "TARGET_VECTOR_ELEN_64")
-  (RVVM2x4DI "TARGET_VECTOR_ELEN_64")
-  (RVVM1x4DI "TARGET_VECTOR_ELEN_64")
-  (RVVM2x3DI "TARGET_VECTOR_ELEN_64")
-  (RVVM1x3DI "TARGET_VECTOR_ELEN_64")
-  (RVVM4x2DI "TARGET_VECTOR_ELEN_64")
-  (RVVM2x2DI "TARGET_VECTOR_ELEN_64")
-  (RVVM1x2DI "TARGET_VECTOR_ELEN_64")
-
-  (RVVM1x8DF "TARGET_VECTOR_ELEN_FP_64")
-  (RVVM1x7DF "TARGET_VECTOR_ELEN_FP_64")
-  (RVVM1x6DF "TARGET_VECTOR_ELEN_FP_64")
-  (RVVM1x5DF "TARGET_VECTOR_ELEN_FP_64")
-  (RVVM2x4DF "TARGET_VECTOR_ELEN_FP_64")
-  (RVVM1x4DF "TARGET_VECTOR_ELEN_FP_64")
-  (RVVM2x3DF "TARGET_VECTOR_ELEN_FP_64")
-  (RVVM1x3DF "TARGET_VECTOR_ELEN_FP_64")
-  (RVVM4x2DF "TARGET_VECTOR_ELEN_FP_64")
-  (RVVM2x2DF "TARGET_VECTOR_ELEN_FP_64")
-  (RVVM1x2DF "TARGET_VECTOR_ELEN_FP_64")
-])
-
 (define_mode_iterator V1T [
   (RVVMF8x2QI "TARGET_MIN_VLEN > 32")
   (RVVMF8x3QI "TARGET_MIN_VLEN > 32")
@@ -1674,6 +1407,41 @@
   (V1024SF "RVVM1DF")
 ])
 
+(define_mode_iterator VLSB [
+  (V1BI "riscv_vector::vls_mode_valid_p (V1BImode)")
+  (V2BI "riscv_vector::vls_mode_valid_p (V2BImode)")
+  (V4BI "riscv_vector::vls_mode_valid_p (V4BImode)")
+  (V8BI "riscv_vector::vls_mode_valid_p (V8BImode)")
+  (V16BI "riscv_vector::vls_mode_valid_p (V16BImode)")
+  (V32BI "riscv_vector::vls_mode_valid_p (V32BImode)")
+  (V64BI "riscv_vector::vls_mode_valid_p (V64BImode) && TARGET_MIN_VLEN >= 64")
+  (V128BI "riscv_vector::vls_mode_valid_p (V128BImode) && TARGET_MIN_VLEN >= 128")
+  (V256BI "riscv_vector::vls_mode_valid_p (V256BImode) && TARGET_MIN_VLEN >= 256")
+  (V512BI "riscv_vector::vls_mode_valid_p (V512BImode) && TARGET_MIN_VLEN >= 512")
+  (V1024BI "riscv_vector::vls_mode_valid_p (V1024BImode) && TARGET_MIN_VLEN >= 1024")
+  (V2048BI "riscv_vector::vls_mode_valid_p (V2048BImode) && TARGET_MIN_VLEN >= 2048")
+  (V4096BI "riscv_vector::vls_mode_valid_p (V4096BImode) && TARGET_MIN_VLEN >= 4096")])
+  
+(define_mode_iterator VB [
+  (RVVMF64BI "TARGET_MIN_VLEN > 32") RVVMF32BI RVVMF16BI RVVMF8BI RVVMF4BI RVVMF2BI RVVM1BI
+])
+
+(define_mode_iterator VB_VLS [VB VLSB])
+
+(define_mode_iterator VLS [VLSI VLSF_ZVFHMIN])
+
+(define_mode_iterator V [VI VF_ZVFHMIN])
+
+(define_mode_iterator V_VLS [V VLS])
+
+(define_mode_iterator V_VLSI [VI VLSI])
+
+(define_mode_iterator V_VLSF [VF VLSF])
+
+(define_mode_iterator V_VLSF_ZVFHMIN [VF_ZVFHMIN VLSF_ZVFHMIN])
+
+(define_mode_iterator VT [V1T V2T V4T V8T V16T V32T])
+
 (define_int_iterator ANY_REDUC [
   UNSPEC_REDUC_SUM UNSPEC_REDUC_MAXU UNSPEC_REDUC_MAX UNSPEC_REDUC_MINU
   UNSPEC_REDUC_MIN UNSPEC_REDUC_AND UNSPEC_REDUC_OR UNSPEC_REDUC_XOR
@@ -3941,103 +3709,6 @@
 
 (define_code_attr sz [(sign_extend "s") (zero_extend "z")])
 
-;; VLS modes.
-(define_mode_iterator VLS [
-  (V1QI "riscv_vector::vls_mode_valid_p (V1QImode)")
-  (V2QI "riscv_vector::vls_mode_valid_p (V2QImode)")
-  (V4QI "riscv_vector::vls_mode_valid_p (V4QImode)")
-  (V8QI "riscv_vector::vls_mode_valid_p (V8QImode)")
-  (V16QI "riscv_vector::vls_mode_valid_p (V16QImode)")
-  (V32QI "riscv_vector::vls_mode_valid_p (V32QImode)")
-  (V64QI "riscv_vector::vls_mode_valid_p (V64QImode) && TARGET_MIN_VLEN >= 64")
-  (V128QI "riscv_vector::vls_mode_valid_p (V128QImode) && TARGET_MIN_VLEN >= 128")
-  (V256QI "riscv_vector::vls_mode_valid_p (V256QImode) && TARGET_MIN_VLEN >= 256")
-  (V512QI "riscv_vector::vls_mode_valid_p (V512QImode) && TARGET_MIN_VLEN >= 512")
-  (V1024QI "riscv_vector::vls_mode_valid_p (V1024QImode) && TARGET_MIN_VLEN >= 1024")
-  (V2048QI "riscv_vector::vls_mode_valid_p (V2048QImode) && TARGET_MIN_VLEN >= 2048")
-  (V4096QI "riscv_vector::vls_mode_valid_p (V4096QImode) && TARGET_MIN_VLEN >= 4096")
-  (V1HI "riscv_vector::vls_mode_valid_p (V1HImode)")
-  (V2HI "riscv_vector::vls_mode_valid_p (V2HImode)")
-  (V4HI "riscv_vector::vls_mode_valid_p (V4HImode)")
-  (V8HI "riscv_vector::vls_mode_valid_p (V8HImode)")
-  (V16HI "riscv_vector::vls_mode_valid_p (V16HImode)")
-  (V32HI "riscv_vector::vls_mode_valid_p (V32HImode) && TARGET_MIN_VLEN >= 64")
-  (V64HI "riscv_vector::vls_mode_valid_p (V64HImode) && TARGET_MIN_VLEN >= 128")
-  (V128HI "riscv_vector::vls_mode_valid_p (V128HImode) && TARGET_MIN_VLEN >= 256")
-  (V256HI "riscv_vector::vls_mode_valid_p (V256HImode) && TARGET_MIN_VLEN >= 512")
-  (V512HI "riscv_vector::vls_mode_valid_p (V512HImode) && TARGET_MIN_VLEN >= 1024")
-  (V1024HI "riscv_vector::vls_mode_valid_p (V1024HImode) && TARGET_MIN_VLEN >= 2048")
-  (V2048HI "riscv_vector::vls_mode_valid_p (V2048HImode) && TARGET_MIN_VLEN >= 4096")
-  (V1SI "riscv_vector::vls_mode_valid_p (V1SImode)")
-  (V2SI "riscv_vector::vls_mode_valid_p (V2SImode)")
-  (V4SI "riscv_vector::vls_mode_valid_p (V4SImode)")
-  (V8SI "riscv_vector::vls_mode_valid_p (V8SImode)")
-  (V16SI "riscv_vector::vls_mode_valid_p (V16SImode) && TARGET_MIN_VLEN >= 64")
-  (V32SI "riscv_vector::vls_mode_valid_p (V32SImode) && TARGET_MIN_VLEN >= 128")
-  (V64SI "riscv_vector::vls_mode_valid_p (V64SImode) && TARGET_MIN_VLEN >= 256")
-  (V128SI "riscv_vector::vls_mode_valid_p (V128SImode) && TARGET_MIN_VLEN >= 512")
-  (V256SI "riscv_vector::vls_mode_valid_p (V256SImode) && TARGET_MIN_VLEN >= 1024")
-  (V512SI "riscv_vector::vls_mode_valid_p (V512SImode) && TARGET_MIN_VLEN >= 2048")
-  (V1024SI "riscv_vector::vls_mode_valid_p (V1024SImode) && TARGET_MIN_VLEN >= 4096")
-  (V1DI "riscv_vector::vls_mode_valid_p (V1DImode) && TARGET_VECTOR_ELEN_64")
-  (V2DI "riscv_vector::vls_mode_valid_p (V2DImode) && TARGET_VECTOR_ELEN_64")
-  (V4DI "riscv_vector::vls_mode_valid_p (V4DImode) && TARGET_VECTOR_ELEN_64")
-  (V8DI "riscv_vector::vls_mode_valid_p (V8DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 64")
-  (V16DI "riscv_vector::vls_mode_valid_p (V16DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 128")
-  (V32DI "riscv_vector::vls_mode_valid_p (V32DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 256")
-  (V64DI "riscv_vector::vls_mode_valid_p (V64DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 512")
-  (V128DI "riscv_vector::vls_mode_valid_p (V128DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 1024")
-  (V256DI "riscv_vector::vls_mode_valid_p (V256DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 2048")
-  (V512DI "riscv_vector::vls_mode_valid_p (V512DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 4096")
-  (V1HF "riscv_vector::vls_mode_valid_p (V1HFmode) && TARGET_VECTOR_ELEN_FP_16")
-  (V2HF "riscv_vector::vls_mode_valid_p (V2HFmode) && TARGET_VECTOR_ELEN_FP_16")
-  (V4HF "riscv_vector::vls_mode_valid_p (V4HFmode) && TARGET_VECTOR_ELEN_FP_16")
-  (V8HF "riscv_vector::vls_mode_valid_p (V8HFmode) && TARGET_VECTOR_ELEN_FP_16")
-  (V16HF "riscv_vector::vls_mode_valid_p (V16HFmode) && TARGET_VECTOR_ELEN_FP_16")
-  (V32HF "riscv_vector::vls_mode_valid_p (V32HFmode) && TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN >= 64")
-  (V64HF "riscv_vector::vls_mode_valid_p (V64HFmode) && TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN >= 128")
-  (V128HF "riscv_vector::vls_mode_valid_p (V128HFmode) && TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN >= 256")
-  (V256HF "riscv_vector::vls_mode_valid_p (V256HFmode) && TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN >= 512")
-  (V512HF "riscv_vector::vls_mode_valid_p (V512HFmode) && TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN >= 1024")
-  (V1024HF "riscv_vector::vls_mode_valid_p (V1024HFmode) && TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN >= 2048")
-  (V2048HF "riscv_vector::vls_mode_valid_p (V2048HFmode) && TARGET_VECTOR_ELEN_FP_16 && TARGET_MIN_VLEN >= 4096")
-  (V1SF "riscv_vector::vls_mode_valid_p (V1SFmode) && TARGET_VECTOR_ELEN_FP_32")
-  (V2SF "riscv_vector::vls_mode_valid_p (V2SFmode) && TARGET_VECTOR_ELEN_FP_32")
-  (V4SF "riscv_vector::vls_mode_valid_p (V4SFmode) && TARGET_VECTOR_ELEN_FP_32")
-  (V8SF "riscv_vector::vls_mode_valid_p (V8SFmode) && TARGET_VECTOR_ELEN_FP_32")
-  (V16SF "riscv_vector::vls_mode_valid_p (V16SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 64")
-  (V32SF "riscv_vector::vls_mode_valid_p (V32SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 128")
-  (V64SF "riscv_vector::vls_mode_valid_p (V64SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 256")
-  (V128SF "riscv_vector::vls_mode_valid_p (V128SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 512")
-  (V256SF "riscv_vector::vls_mode_valid_p (V256SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 1024")
-  (V512SF "riscv_vector::vls_mode_valid_p (V512SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 2048")
-  (V1024SF "riscv_vector::vls_mode_valid_p (V1024SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 4096")
-  (V1DF "riscv_vector::vls_mode_valid_p (V1DFmode) && TARGET_VECTOR_ELEN_FP_64")
-  (V2DF "riscv_vector::vls_mode_valid_p (V2DFmode) && TARGET_VECTOR_ELEN_FP_64")
-  (V4DF "riscv_vector::vls_mode_valid_p (V4DFmode) && TARGET_VECTOR_ELEN_FP_64")
-  (V8DF "riscv_vector::vls_mode_valid_p (V8DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 64")
-  (V16DF "riscv_vector::vls_mode_valid_p (V16DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 128")
-  (V32DF "riscv_vector::vls_mode_valid_p (V32DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 256")
-  (V64DF "riscv_vector::vls_mode_valid_p (V64DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 512")
-  (V128DF "riscv_vector::vls_mode_valid_p (V128DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 1024")
-  (V256DF "riscv_vector::vls_mode_valid_p (V256DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 2048")
-  (V512DF "riscv_vector::vls_mode_valid_p (V512DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 4096")])
-
-(define_mode_iterator VLSB [
-  (V1BI "riscv_vector::vls_mode_valid_p (V1BImode)")
-  (V2BI "riscv_vector::vls_mode_valid_p (V2BImode)")
-  (V4BI "riscv_vector::vls_mode_valid_p (V4BImode)")
-  (V8BI "riscv_vector::vls_mode_valid_p (V8BImode)")
-  (V16BI "riscv_vector::vls_mode_valid_p (V16BImode)")
-  (V32BI "riscv_vector::vls_mode_valid_p (V32BImode)")
-  (V64BI "riscv_vector::vls_mode_valid_p (V64BImode) && TARGET_MIN_VLEN >= 64")
-  (V128BI "riscv_vector::vls_mode_valid_p (V128BImode) && TARGET_MIN_VLEN >= 128")
-  (V256BI "riscv_vector::vls_mode_valid_p (V256BImode) && TARGET_MIN_VLEN >= 256")
-  (V512BI "riscv_vector::vls_mode_valid_p (V512BImode) && TARGET_MIN_VLEN >= 512")
-  (V1024BI "riscv_vector::vls_mode_valid_p (V1024BImode) && TARGET_MIN_VLEN >= 1024")
-  (V2048BI "riscv_vector::vls_mode_valid_p (V2048BImode) && TARGET_MIN_VLEN >= 2048")
-  (V4096BI "riscv_vector::vls_mode_valid_p (V4096BImode) && TARGET_MIN_VLEN >= 4096")])
-
 ;; VLS modes that has NUNITS < 32.
 (define_mode_iterator VLS_AVL_IMM [
   (V1QI "riscv_vector::vls_mode_valid_p (V1QImode)")
@@ -4137,87 +3808,3 @@
   (V1024BI "riscv_vector::vls_mode_valid_p (V1024BImode) && TARGET_MIN_VLEN >= 1024")
   (V2048BI "riscv_vector::vls_mode_valid_p (V2048BImode) && TARGET_MIN_VLEN >= 2048")
   (V4096BI "riscv_vector::vls_mode_valid_p (V4096BImode) && TARGET_MIN_VLEN >= 4096")])
-
-(define_mode_iterator VLSI [
-  (V1QI "riscv_vector::vls_mode_valid_p (V1QImode)")
-  (V2QI "riscv_vector::vls_mode_valid_p (V2QImode)")
-  (V4QI "riscv_vector::vls_mode_valid_p (V4QImode)")
-  (V8QI "riscv_vector::vls_mode_valid_p (V8QImode)")
-  (V16QI "riscv_vector::vls_mode_valid_p (V16QImode)")
-  (V32QI "riscv_vector::vls_mode_valid_p (V32QImode)")
-  (V64QI "riscv_vector::vls_mode_valid_p (V64QImode) && TARGET_MIN_VLEN >= 64")
-  (V128QI "riscv_vector::vls_mode_valid_p (V128QImode) && TARGET_MIN_VLEN >= 128")
-  (V256QI "riscv_vector::vls_mode_valid_p (V256QImode) && TARGET_MIN_VLEN >= 256")
-  (V512QI "riscv_vector::vls_mode_valid_p (V512QImode) && TARGET_MIN_VLEN >= 512")
-  (V1024QI "riscv_vector::vls_mode_valid_p (V1024QImode) && TARGET_MIN_VLEN >= 1024")
-  (V2048QI "riscv_vector::vls_mode_valid_p (V2048QImode) && TARGET_MIN_VLEN >= 2048")
-  (V4096QI "riscv_vector::vls_mode_valid_p (V4096QImode) && TARGET_MIN_VLEN >= 4096")
-  (V1HI "riscv_vector::vls_mode_valid_p (V1HImode)")
-  (V2HI "riscv_vector::vls_mode_valid_p (V2HImode)")
-  (V4HI "riscv_vector::vls_mode_valid_p (V4HImode)")
-  (V8HI "riscv_vector::vls_mode_valid_p (V8HImode)")
-  (V16HI "riscv_vector::vls_mode_valid_p (V16HImode)")
-  (V32HI "riscv_vector::vls_mode_valid_p (V32HImode) && TARGET_MIN_VLEN >= 64")
-  (V64HI "riscv_vector::vls_mode_valid_p (V64HImode) && TARGET_MIN_VLEN >= 128")
-  (V128HI "riscv_vector::vls_mode_valid_p (V128HImode) && TARGET_MIN_VLEN >= 256")
-  (V256HI "riscv_vector::vls_mode_valid_p (V256HImode) && TARGET_MIN_VLEN >= 512")
-  (V512HI "riscv_vector::vls_mode_valid_p (V512HImode) && TARGET_MIN_VLEN >= 1024")
-  (V1024HI "riscv_vector::vls_mode_valid_p (V1024HImode) && TARGET_MIN_VLEN >= 2048")
-  (V2048HI "riscv_vector::vls_mode_valid_p (V2048HImode) && TARGET_MIN_VLEN >= 4096")
-  (V1SI "riscv_vector::vls_mode_valid_p (V1SImode)")
-  (V2SI "riscv_vector::vls_mode_valid_p (V2SImode)")
-  (V4SI "riscv_vector::vls_mode_valid_p (V4SImode)")
-  (V8SI "riscv_vector::vls_mode_valid_p (V8SImode)")
-  (V16SI "riscv_vector::vls_mode_valid_p (V16SImode) && TARGET_MIN_VLEN >= 64")
-  (V32SI "riscv_vector::vls_mode_valid_p (V32SImode) && TARGET_MIN_VLEN >= 128")
-  (V64SI "riscv_vector::vls_mode_valid_p (V64SImode) && TARGET_MIN_VLEN >= 256")
-  (V128SI "riscv_vector::vls_mode_valid_p (V128SImode) && TARGET_MIN_VLEN >= 512")
-  (V256SI "riscv_vector::vls_mode_valid_p (V256SImode) && TARGET_MIN_VLEN >= 1024")
-  (V512SI "riscv_vector::vls_mode_valid_p (V512SImode) && TARGET_MIN_VLEN >= 2048")
-  (V1024SI "riscv_vector::vls_mode_valid_p (V1024SImode) && TARGET_MIN_VLEN >= 4096")
-  (V1DI "riscv_vector::vls_mode_valid_p (V1DImode) && TARGET_VECTOR_ELEN_64")
-  (V2DI "riscv_vector::vls_mode_valid_p (V2DImode) && TARGET_VECTOR_ELEN_64")
-  (V4DI "riscv_vector::vls_mode_valid_p (V4DImode) && TARGET_VECTOR_ELEN_64")
-  (V8DI "riscv_vector::vls_mode_valid_p (V8DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 64")
-  (V16DI "riscv_vector::vls_mode_valid_p (V16DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 128")
-  (V32DI "riscv_vector::vls_mode_valid_p (V32DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 256")
-  (V64DI "riscv_vector::vls_mode_valid_p (V64DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 512")
-  (V128DI "riscv_vector::vls_mode_valid_p (V128DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 1024")
-  (V256DI "riscv_vector::vls_mode_valid_p (V256DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 2048")
-  (V512DI "riscv_vector::vls_mode_valid_p (V512DImode) && TARGET_VECTOR_ELEN_64 && TARGET_MIN_VLEN >= 4096")])
-
-(define_mode_iterator VLSF [
-  (V1HF "riscv_vector::vls_mode_valid_p (V1HFmode) && TARGET_ZVFH")
-  (V2HF "riscv_vector::vls_mode_valid_p (V2HFmode) && TARGET_ZVFH")
-  (V4HF "riscv_vector::vls_mode_valid_p (V4HFmode) && TARGET_ZVFH")
-  (V8HF "riscv_vector::vls_mode_valid_p (V8HFmode) && TARGET_ZVFH")
-  (V16HF "riscv_vector::vls_mode_valid_p (V16HFmode) && TARGET_ZVFH")
-  (V32HF "riscv_vector::vls_mode_valid_p (V32HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 64")
-  (V64HF "riscv_vector::vls_mode_valid_p (V64HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 128")
-  (V128HF "riscv_vector::vls_mode_valid_p (V128HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 256")
-  (V256HF "riscv_vector::vls_mode_valid_p (V256HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 512")
-  (V512HF "riscv_vector::vls_mode_valid_p (V512HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 1024")
-  (V1024HF "riscv_vector::vls_mode_valid_p (V1024HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 2048")
-  (V2048HF "riscv_vector::vls_mode_valid_p (V2048HFmode) && TARGET_ZVFH && TARGET_MIN_VLEN >= 4096")
-  (V1SF "riscv_vector::vls_mode_valid_p (V1SFmode) && TARGET_VECTOR_ELEN_FP_32")
-  (V2SF "riscv_vector::vls_mode_valid_p (V2SFmode) && TARGET_VECTOR_ELEN_FP_32")
-  (V4SF "riscv_vector::vls_mode_valid_p (V4SFmode) && TARGET_VECTOR_ELEN_FP_32")
-  (V8SF "riscv_vector::vls_mode_valid_p (V8SFmode) && TARGET_VECTOR_ELEN_FP_32")
-  (V16SF "riscv_vector::vls_mode_valid_p (V16SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 64")
-  (V32SF "riscv_vector::vls_mode_valid_p (V32SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 128")
-  (V64SF "riscv_vector::vls_mode_valid_p (V64SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 256")
-  (V128SF "riscv_vector::vls_mode_valid_p (V128SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 512")
-  (V256SF "riscv_vector::vls_mode_valid_p (V256SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 1024")
-  (V512SF "riscv_vector::vls_mode_valid_p (V512SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 2048")
-  (V1024SF "riscv_vector::vls_mode_valid_p (V1024SFmode) && TARGET_VECTOR_ELEN_FP_32 && TARGET_MIN_VLEN >= 4096")
-  (V1DF "riscv_vector::vls_mode_valid_p (V1DFmode) && TARGET_VECTOR_ELEN_FP_64")
-  (V2DF "riscv_vector::vls_mode_valid_p (V2DFmode) && TARGET_VECTOR_ELEN_FP_64")
-  (V4DF "riscv_vector::vls_mode_valid_p (V4DFmode) && TARGET_VECTOR_ELEN_FP_64")
-  (V8DF "riscv_vector::vls_mode_valid_p (V8DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 64")
-  (V16DF "riscv_vector::vls_mode_valid_p (V16DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 128")
-  (V32DF "riscv_vector::vls_mode_valid_p (V32DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 256")
-  (V64DF "riscv_vector::vls_mode_valid_p (V64DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 512")
-  (V128DF "riscv_vector::vls_mode_valid_p (V128DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 1024")
-  (V256DF "riscv_vector::vls_mode_valid_p (V256DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 2048")
-  (V512DF "riscv_vector::vls_mode_valid_p (V512DFmode) && TARGET_VECTOR_ELEN_FP_64 && TARGET_MIN_VLEN >= 4096")
-])
diff --git a/gcc/config/rs6000/altivec.md b/gcc/config/rs6000/altivec.md
index e8a596f..8a4998c 100644
--- a/gcc/config/rs6000/altivec.md
+++ b/gcc/config/rs6000/altivec.md
@@ -2605,6 +2605,48 @@
 }
   [(set_attr "type" "vecperm")])
 
+/* The cbranch_optab doesn't allow FAIL, so old cpus which are
+   inefficient on unaligned vsx are disabled as the cost is high
+   for unaligned load/store.  */
+(define_expand "cbranchv16qi4"
+  [(use (match_operator 0 "equality_operator"
+	[(match_operand:V16QI 1 "reg_or_mem_operand")
+	 (match_operand:V16QI 2 "reg_or_mem_operand")]))
+   (use (match_operand 3))]
+  "VECTOR_MEM_VSX_P (V16QImode)
+   && TARGET_EFFICIENT_UNALIGNED_VSX"
+{
+  /* Use direct move for P8 LE to skip doubleword swap, as the byte
+     order doesn't matter for equality compare.  If any operands are
+     altivec indexed or indirect operands, the load can be implemented
+     directly by altivec aligned load instruction and swap is no
+     need.  */
+  if (!TARGET_P9_VECTOR
+      && !BYTES_BIG_ENDIAN
+      && MEM_P (operands[1])
+      && !altivec_indexed_or_indirect_operand (operands[1], V16QImode)
+      && MEM_P (operands[2])
+      && !altivec_indexed_or_indirect_operand (operands[2], V16QImode))
+    {
+      rtx reg_op1 = gen_reg_rtx (V16QImode);
+      rtx reg_op2 = gen_reg_rtx (V16QImode);
+      rs6000_emit_le_vsx_permute (reg_op1, operands[1], V16QImode);
+      rs6000_emit_le_vsx_permute (reg_op2, operands[2], V16QImode);
+      operands[1] = reg_op1;
+      operands[2] = reg_op2;
+    }
+  else
+    {
+      operands[1] = force_reg (V16QImode, operands[1]);
+      operands[2] = force_reg (V16QImode, operands[2]);
+    }
+
+  rtx_code code = GET_CODE (operands[0]);
+  operands[0] = gen_rtx_fmt_ee (code, V16QImode, operands[1], operands[2]);
+  rs6000_emit_cbranch (V16QImode, operands);
+  DONE;
+})
+
 ;; Compare vectors producing a vector result and a predicate, setting CR6 to
 ;; indicate a combined status
 (define_insn "altivec_vcmpequ<VI_char>_p"
diff --git a/gcc/config/rs6000/rs6000.cc b/gcc/config/rs6000/rs6000.cc
index 5f56c3e..3dfd79c 100644
--- a/gcc/config/rs6000/rs6000.cc
+++ b/gcc/config/rs6000/rs6000.cc
@@ -15472,6 +15472,18 @@ rs6000_generate_compare (rtx cmp, machine_mode mode)
 	  else
 	    emit_insn (gen_stack_protect_testsi (compare_result, op0, op1b));
 	}
+      else if (mode == V16QImode)
+	{
+	  gcc_assert (code == EQ || code == NE);
+
+	  rtx result_vector = gen_reg_rtx (V16QImode);
+	  rtx cc_bit = gen_reg_rtx (SImode);
+	  emit_insn (gen_altivec_vcmpequb_p (result_vector, op0, op1));
+	  emit_insn (gen_cr6_test_for_lt (cc_bit));
+	  emit_insn (gen_rtx_SET (compare_result,
+				  gen_rtx_COMPARE (comp_mode, cc_bit,
+						   const1_rtx)));
+	}
       else
 	emit_insn (gen_rtx_SET (compare_result,
 				gen_rtx_COMPARE (comp_mode, op0, op1)));
diff --git a/gcc/config/rs6000/rs6000.h b/gcc/config/rs6000/rs6000.h
index 22595f6..326c452 100644
--- a/gcc/config/rs6000/rs6000.h
+++ b/gcc/config/rs6000/rs6000.h
@@ -1730,6 +1730,9 @@ typedef struct rs6000_args
    in one reasonably fast instruction.  */
 #define MOVE_MAX (! TARGET_POWERPC64 ? 4 : 8)
 #define MAX_MOVE_MAX 8
+#define MOVE_MAX_PIECES (TARGET_EFFICIENT_UNALIGNED_VSX \
+			 ? 16 : (TARGET_POWERPC64 ? 8 : 4))
+#define STORE_MAX_PIECES (TARGET_POWERPC64 ? 8 : 4)
 
 /* Nonzero if access to memory by bytes is no faster than for words.
    Also nonzero if doing byte operations (specifically shifts) in registers
diff --git a/gcc/config/rs6000/vsx.md b/gcc/config/rs6000/vsx.md
index f3b4022..26fa328 100644
--- a/gcc/config/rs6000/vsx.md
+++ b/gcc/config/rs6000/vsx.md
@@ -414,6 +414,27 @@
 
 ;; VSX moves
 
+;; TImode memory to memory move optimization on LE with p8vector
+(define_insn_and_split "*vsx_le_mem_to_mem_mov_ti"
+  [(set (match_operand:TI 0 "indexed_or_indirect_operand" "=Z")
+	(match_operand:TI 1 "indexed_or_indirect_operand" "Z"))]
+  "!BYTES_BIG_ENDIAN
+   && TARGET_VSX
+   && !TARGET_P9_VECTOR
+   && can_create_pseudo_p ()"
+  "#"
+  "&& 1"
+  [(const_int 0)]
+{
+  rtx tmp = gen_reg_rtx (V2DImode);
+  rtx src =  adjust_address (operands[1], V2DImode, 0);
+  emit_insn (gen_vsx_ld_elemrev_v2di (tmp, src));
+  rtx dest = adjust_address (operands[0], V2DImode, 0);
+  emit_insn (gen_vsx_st_elemrev_v2di (dest, tmp));
+  DONE;
+}
+  [(set_attr "length" "16")])
+
 ;; The patterns for LE permuted loads and stores come before the general
 ;; VSX moves so they match first.
 (define_insn_and_split "*vsx_le_perm_load_<mode>"
diff --git a/gcc/config/rtems.h b/gcc/config/rtems.h
index 8641ea1..2c006e4 100644
--- a/gcc/config/rtems.h
+++ b/gcc/config/rtems.h
@@ -53,6 +53,8 @@
 
 #define TARGET_POSIX_IO
 
+#define TARGET_HAVE_LIBATOMIC true
+
 /* Prefer int for int32_t (see stdint-newlib.h).  */
 #undef STDINT_LONG32
 #define STDINT_LONG32 (INT_TYPE_SIZE != 32 && LONG_TYPE_SIZE == 32)
diff --git a/gcc/config/s390/s390-builtin-types.def b/gcc/config/s390/s390-builtin-types.def
index 3d8b30c..22ee348 100644
--- a/gcc/config/s390/s390-builtin-types.def
+++ b/gcc/config/s390/s390-builtin-types.def
@@ -856,7 +856,7 @@ DEF_OV_TYPE (BT_OV_VOID_V2DI_LONG_LONGLONGPTR, BT_VOID, BT_V2DI, BT_LONG, BT_LON
 DEF_OV_TYPE (BT_OV_VOID_V2DI_UV2DI_LONGLONGPTR_ULONGLONG, BT_VOID, BT_V2DI, BT_UV2DI, BT_LONGLONGPTR, BT_ULONGLONG)
 DEF_OV_TYPE (BT_OV_VOID_V4SF_FLTPTR_UINT, BT_VOID, BT_V4SF, BT_FLTPTR, BT_UINT)
 DEF_OV_TYPE (BT_OV_VOID_V4SF_LONG_FLTPTR, BT_VOID, BT_V4SF, BT_LONG, BT_FLTPTR)
-DEF_OV_TYPE (BT_OV_VOID_V4SF_V4SF_FLTPTR_ULONGLONG, BT_VOID, BT_V4SF, BT_V4SF, BT_FLTPTR, BT_ULONGLONG)
+DEF_OV_TYPE (BT_OV_VOID_V4SF_UV4SI_FLTPTR_ULONGLONG, BT_VOID, BT_V4SF, BT_UV4SI, BT_FLTPTR, BT_ULONGLONG)
 DEF_OV_TYPE (BT_OV_VOID_V4SI_INTPTR_UINT, BT_VOID, BT_V4SI, BT_INTPTR, BT_UINT)
 DEF_OV_TYPE (BT_OV_VOID_V4SI_LONG_INTPTR, BT_VOID, BT_V4SI, BT_LONG, BT_INTPTR)
 DEF_OV_TYPE (BT_OV_VOID_V4SI_UV4SI_INTPTR_ULONGLONG, BT_VOID, BT_V4SI, BT_UV4SI, BT_INTPTR, BT_ULONGLONG)
diff --git a/gcc/config/s390/s390-builtins.def b/gcc/config/s390/s390-builtins.def
index 964d86c..b59fa09 100644
--- a/gcc/config/s390/s390-builtins.def
+++ b/gcc/config/s390/s390-builtins.def
@@ -708,7 +708,7 @@ OB_DEF_VAR (s390_vec_scatter_element_u32,s390_vscef,        0,
 OB_DEF_VAR (s390_vec_scatter_element_s64,s390_vsceg,        0,                  O4_U1,              BT_OV_VOID_V2DI_UV2DI_LONGLONGPTR_ULONGLONG)
 OB_DEF_VAR (s390_vec_scatter_element_b64,s390_vsceg,        0,                  O4_U1,              BT_OV_VOID_BV2DI_UV2DI_ULONGLONGPTR_ULONGLONG)
 OB_DEF_VAR (s390_vec_scatter_element_u64,s390_vsceg,        0,                  O4_U1,              BT_OV_VOID_UV2DI_UV2DI_ULONGLONGPTR_ULONGLONG)
-OB_DEF_VAR (s390_vec_scatter_element_flt,s390_vscef,        B_VXE,              O4_U2,              BT_OV_VOID_V4SF_V4SF_FLTPTR_ULONGLONG)
+OB_DEF_VAR (s390_vec_scatter_element_flt,s390_vscef,        B_VXE,              O4_U2,              BT_OV_VOID_V4SF_UV4SI_FLTPTR_ULONGLONG)
 OB_DEF_VAR (s390_vec_scatter_element_dbl,s390_vsceg,        0,                  O4_U1,              BT_OV_VOID_V2DF_UV2DI_DBLPTR_ULONGLONG)
 
 B_DEF      (s390_vscef,                 vec_scatter_elementv4si,0,              B_VX,               O4_U2,              BT_FN_VOID_UV4SI_UV4SI_UINTPTR_ULONGLONG)
diff --git a/gcc/config/s390/s390-builtins.h b/gcc/config/s390/s390-builtins.h
index 45bba87..84676fe 100644
--- a/gcc/config/s390/s390-builtins.h
+++ b/gcc/config/s390/s390-builtins.h
@@ -88,8 +88,8 @@ enum s390_builtin_ov_type_index
 
 #define MAX_OV_OPERANDS 6
 
-extern tree s390_builtin_types[BT_MAX];
-extern tree s390_builtin_fn_types[BT_FN_MAX];
+extern GTY(()) tree s390_builtin_types[BT_MAX];
+extern GTY(()) tree s390_builtin_fn_types[BT_FN_MAX];
 
   /* Builtins.  */
 
@@ -172,6 +172,6 @@ opflags_for_builtin (int fcode)
     return opflags_builtin[fcode];
 }
 
-extern tree s390_builtin_decls[S390_BUILTIN_MAX +
-			       S390_OVERLOADED_BUILTIN_MAX +
-			       S390_OVERLOADED_BUILTIN_VAR_MAX];
+extern GTY(()) tree s390_builtin_decls[S390_BUILTIN_MAX +
+				       S390_OVERLOADED_BUILTIN_MAX +
+				       S390_OVERLOADED_BUILTIN_VAR_MAX];
diff --git a/gcc/config/s390/s390-c.cc b/gcc/config/s390/s390-c.cc
index 269f4f8..fce56934 100644
--- a/gcc/config/s390/s390-c.cc
+++ b/gcc/config/s390/s390-c.cc
@@ -781,6 +781,9 @@ s390_fn_types_compatible (enum s390_builtin_ov_type_index typeindex,
       tree in_arg = (*arglist)[i];
       tree in_type = TREE_TYPE (in_arg);
 
+      if (in_type == error_mark_node)
+	goto mismatch;
+
       if (VECTOR_TYPE_P (b_arg_type))
 	{
 	  /* Vector types have to match precisely.  */
diff --git a/gcc/config/s390/t-s390 b/gcc/config/s390/t-s390
index 828818b..2e884c3 100644
--- a/gcc/config/s390/t-s390
+++ b/gcc/config/s390/t-s390
@@ -19,6 +19,7 @@
 TM_H += $(srcdir)/config/s390/s390-builtins.def
 TM_H += $(srcdir)/config/s390/s390-builtin-types.def
 PASSES_EXTRA += $(srcdir)/config/s390/s390-passes.def
+EXTRA_GTYPE_DEPS += ./s390-gen-builtins.h
 
 s390-c.o: $(srcdir)/config/s390/s390-c.cc \
   $(srcdir)/config/s390/s390-protos.h $(CONFIG_H) $(SYSTEM_H) coretypes.h \
@@ -30,3 +31,6 @@ s390-c.o: $(srcdir)/config/s390/s390-c.cc \
 s390-d.o: $(srcdir)/config/s390/s390-d.cc
 	$(COMPILE) $<
 	$(POSTCOMPILE)
+
+s390-gen-builtins.h: $(srcdir)/config/s390/s390-builtins.h
+	$(COMPILER) -E -P $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< > $@
diff --git a/gcc/config/sparc/rtemself.h b/gcc/config/sparc/rtemself.h
index bf46822..28400a3 100644
--- a/gcc/config/sparc/rtemself.h
+++ b/gcc/config/sparc/rtemself.h
@@ -40,5 +40,3 @@
 
 /* Use the default */
 #undef LINK_GCC_C_SEQUENCE_SPEC
-
-#define SPARC_GCOV_TYPE_SIZE 32
diff --git a/gcc/config/sparc/sparc.cc b/gcc/config/sparc/sparc.cc
index 82e5795..e90739d 100644
--- a/gcc/config/sparc/sparc.cc
+++ b/gcc/config/sparc/sparc.cc
@@ -972,17 +972,6 @@ char sparc_hard_reg_printed[8];
 #undef TARGET_ZERO_CALL_USED_REGS
 #define TARGET_ZERO_CALL_USED_REGS sparc_zero_call_used_regs
 
-#ifdef SPARC_GCOV_TYPE_SIZE
-static HOST_WIDE_INT
-sparc_gcov_type_size (void)
-{
-  return SPARC_GCOV_TYPE_SIZE;
-}
-
-#undef TARGET_GCOV_TYPE_SIZE
-#define TARGET_GCOV_TYPE_SIZE sparc_gcov_type_size
-#endif
-
 struct gcc_target targetm = TARGET_INITIALIZER;
 
 /* Return the memory reference contained in X if any, zero otherwise.  */
diff --git a/gcc/configure b/gcc/configure
index c37cae7..cc0c3aa 100755
--- a/gcc/configure
+++ b/gcc/configure
@@ -30953,6 +30953,38 @@ $as_echo "#define HAVE_AS_EXPLICIT_RELOCS 1" >>confdefs.h
 
 fi
 
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking assembler for call36 relocation support" >&5
+$as_echo_n "checking assembler for call36 relocation support... " >&6; }
+if ${gcc_cv_as_loongarch_call36+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  gcc_cv_as_loongarch_call36=no
+  if test x$gcc_cv_as != x; then
+    $as_echo 'pcaddu18i $r1, %call36(a)
+       jirl $r1, $r1, 0' > conftest.s
+    if { ac_try='$gcc_cv_as $gcc_cv_as_flags  -o conftest.o conftest.s >&5'
+  { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }
+    then
+	gcc_cv_as_loongarch_call36=yes
+    else
+      echo "configure: failed program was" >&5
+      cat conftest.s >&5
+    fi
+    rm -f conftest.o conftest.s
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gcc_cv_as_loongarch_call36" >&5
+$as_echo "$gcc_cv_as_loongarch_call36" >&6; }
+if test $gcc_cv_as_loongarch_call36 = yes; then
+
+$as_echo "#define HAVE_AS_SUPPORT_CALL36 1" >>confdefs.h
+
+fi
+
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking assembler for eh_frame pcrel encoding support" >&5
 $as_echo_n "checking assembler for eh_frame pcrel encoding support... " >&6; }
 if ${gcc_cv_as_loongarch_eh_frame_pcrel_encoding_support+:} false; then :
@@ -31018,6 +31050,41 @@ $as_echo "#define HAVE_AS_MRELAX_OPTION 1" >>confdefs.h
 
 fi
 
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking assembler for conditional branch relaxation support" >&5
+$as_echo_n "checking assembler for conditional branch relaxation support... " >&6; }
+if ${gcc_cv_as_loongarch_cond_branch_relax+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  gcc_cv_as_loongarch_cond_branch_relax=no
+  if test x$gcc_cv_as != x; then
+    $as_echo 'a:
+       .rept 32769
+       nop
+       .endr
+       beq $a0,$a1,a' > conftest.s
+    if { ac_try='$gcc_cv_as $gcc_cv_as_flags  -o conftest.o conftest.s >&5'
+  { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }
+    then
+	gcc_cv_as_loongarch_cond_branch_relax=yes
+    else
+      echo "configure: failed program was" >&5
+      cat conftest.s >&5
+    fi
+    rm -f conftest.o conftest.s
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gcc_cv_as_loongarch_cond_branch_relax" >&5
+$as_echo "$gcc_cv_as_loongarch_cond_branch_relax" >&6; }
+if test $gcc_cv_as_loongarch_cond_branch_relax = yes; then
+
+$as_echo "#define HAVE_AS_COND_BRANCH_RELAXATION 1" >>confdefs.h
+
+fi
+
     ;;
     s390*-*-*)
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking assembler for .gnu_attribute support" >&5
diff --git a/gcc/configure.ac b/gcc/configure.ac
index 764a33f..d9a3506 100644
--- a/gcc/configure.ac
+++ b/gcc/configure.ac
@@ -5441,6 +5441,12 @@ x:
       [a:pcalau12i $t0,%pc_hi20(a)],,
       [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
 	  [Define if your assembler supports explicit relocation.])])
+    gcc_GAS_CHECK_FEATURE([call36 relocation support],
+      gcc_cv_as_loongarch_call36,,
+      [pcaddu18i $r1, %call36(a)
+       jirl $r1, $r1, 0],,
+      [AC_DEFINE(HAVE_AS_SUPPORT_CALL36, 1,
+	  [Define if your assembler supports call36 relocation.])])
     gcc_GAS_CHECK_FEATURE([eh_frame pcrel encoding support],
       gcc_cv_as_loongarch_eh_frame_pcrel_encoding_support,,
       [.cfi_startproc
@@ -5453,6 +5459,16 @@ x:
       [-mrelax], [.text],,
       [AC_DEFINE(HAVE_AS_MRELAX_OPTION, 1,
 		[Define if your assembler supports -mrelax option.])])
+    gcc_GAS_CHECK_FEATURE([conditional branch relaxation support],
+      gcc_cv_as_loongarch_cond_branch_relax,
+      [],
+      [a:
+       .rept 32769
+       nop
+       .endr
+       beq $a0,$a1,a],,
+      [AC_DEFINE(HAVE_AS_COND_BRANCH_RELAXATION, 1,
+		[Define if your assembler supports conditional branch relaxation.])])
     ;;
     s390*-*-*)
     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
diff --git a/gcc/coretypes.h b/gcc/coretypes.h
index 9848cde..fe5b868 100644
--- a/gcc/coretypes.h
+++ b/gcc/coretypes.h
@@ -156,6 +156,7 @@ struct cl_optimization;
 struct cl_option;
 struct cl_decoded_option;
 struct cl_option_handlers;
+class rich_location;
 class diagnostic_context;
 class pretty_printer;
 class diagnostic_event_id_t;
diff --git a/gcc/coverage.cc b/gcc/coverage.cc
index 7ed3a5d..ad55f0f 100644
--- a/gcc/coverage.cc
+++ b/gcc/coverage.cc
@@ -138,7 +138,7 @@ tree
 get_gcov_type (void)
 {
   scalar_int_mode mode
-    = smallest_int_mode_for_size (targetm.gcov_type_size ());
+    = smallest_int_mode_for_size (LONG_LONG_TYPE_SIZE > 32 ? 64 : 32);
   return lang_hooks.types.type_for_mode (mode, false);
 }
 
diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 6361ac6..1feb5b3 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,136 @@
+2023-11-16  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/112365
+	* class.cc (layout_class_type): Don't
+	SET_DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD on FIELD_DECLs with
+	error_mark_node type.
+
+2023-11-16  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/111703
+	PR c++/107939
+	* constexpr.cc (potential_constant_expression_1) <case CALL_EXPR>:
+	Fix FUNCTION_POINTER_TYPE_P test.
+
+2023-11-16  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/112410
+	* parser.cc (cp_parser_direct_declarator): Maybe call
+	abort_fully_implicit_template if it turned out the parameter list was
+	ill-formed.
+
+2023-11-15  Bernhard Reutner-Fischer  <aldot@gcc.gnu.org>
+
+	* tree.cc (build_cplus_array_type): Revert using the macro
+	CAN_HAVE_LOCATION_P.
+
+2023-11-15  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/112515
+	* decl.cc (is_direct_enum_init): Check type-dependence of the
+	single element.
+
+2023-11-15  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/101043
+	* tree.cc (strip_typedefs_expr) <case TREE_LIST>: Handle
+	non-empty TREE_PURPOSE.
+
+2023-11-15  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/112427
+	* tree.cc (build_min_non_dep): Propagate TREE_SIDE_EFFECTS from
+	the original arguments.
+	(build_min_non_dep_call_vec): Likewise.
+	* typeck2.cc (build_m_component_ref): Use cp_convert, build2 and
+	cp_fully_fold instead of fold_build_pointer_plus and fold_convert.
+	Don't build the POINTER_PLUS_EXPR in a template context.
+
+2023-11-15  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/111703
+	PR c++/112269
+	* constexpr.cc (potential_constant_expression_1) <case VAR_DECL>:
+	Only consider var_in_maybe_constexpr_fn if 'now' is false.
+	<case INDIRECT_REF>: Likewise.
+
+2023-11-15  Jakub Jelinek  <jakub@redhat.com>
+
+	* typeck.cc: Implement C++26 P2864R2 - Remove Deprecated Arithmetic
+	Conversion on Enumerations From C++26.
+	(do_warn_enum_conversions): Return bool rather than void, add COMPLAIN
+	argument.  Use pedwarn rather than warning_at for C++26 and remove
+	" is deprecated" part of the diagnostics in that case.  For SFINAE
+	in C++26 return true on newly erroneous cases.
+	(cp_build_binary_op): For C++26 call do_warn_enum_conversions
+	unconditionally, pass complain argument to it and if it returns true,
+	return error_mark_node.
+	* call.cc (build_conditional_expr): Use pedwarn rather than warning_at
+	for C++26 and remove " is deprecated" part of the diagnostics in that
+	case and check for complain & tf_warning_or_error.  Use emit_diagnostic
+	with cxx_dialect >= cxx26 ? DK_PEDWARN : DK_WARNING.  For SFINAE in
+	C++26 return error_mark_node on newly erroneous cases.
+	(build_new_op): Use emit_diagnostic with cxx_dialect >= cxx26
+	? DK_PEDWARN : DK_WARNING and complain & tf_warning_or_error check
+	for C++26.  For SFINAE in C++26 return error_mark_node on newly
+	erroneous cases.
+
+2023-11-14  Nathaniel Shead  <nathanieloshead@gmail.com>
+
+	PR c++/103499
+	* module.cc (trees_out::decl_node): Write DECL_VINDEX for
+	virtual clones.
+	(trees_in::tree_node): Read DECL_VINDEX for virtual clones.
+
+2023-11-14  Nathaniel Shead  <nathanieloshead@gmail.com>
+
+	PR c++/106849
+	* name-lookup.cc (do_nonmember_using_decl): Handle
+	TEMPLATE_DECLs when checking module attachment.
+
+2023-11-14  David Malcolm  <dmalcolm@redhat.com>
+
+	* decl.cc (finish_function): Update call to
+	global_dc->m_option_enabled to use option_enabled_p.
+
+2023-11-14  David Malcolm  <dmalcolm@redhat.com>
+
+	* contracts.cc (build_comment): Use global_dc's file_cache.
+
+2023-11-14  Jonathan Wakely  <jwakely@redhat.com>
+
+	PR c++/111842
+	PR c++/112498
+	* call.cc (convert_like_internal): Use OPT_Wnarrowing for
+	pedwarns about illformed conversions involving extended
+	floating-point types. Clarify that ISO C++ requires these
+	diagnostics.
+
+2023-11-14  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c/111309
+	* call.cc (magic_varargs_p): Return 4 for
+	BUILT_IN_{CLZ,CTZ,CLRSB,FFS,PARITY,POPCOUNT}G.
+	(build_over_call): Don't promote first argument of
+	BUILT_IN_{CLZ,CTZ,CLRSB,FFS,PARITY,POPCOUNT}G.
+	* cp-gimplify.cc (cp_gimplify_expr): For BUILT_IN_C{L,T}ZG use
+	c_gimplify_expr.
+
+2023-11-10  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/79620
+	* cp-tree.h (STRIP_REFERENCE_REF): Define.
+	* semantics.cc (outer_var_p): Assert REFERENCE_REF_P is false.
+	(finish_decltype_type): Look through implicit INDIRECT_REF when
+	deciding whether to call capture_decltype.
+
+2023-11-10  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/79378
+	PR c++/96917
+	* semantics.cc (finish_decltype_type): Handle an id-expression
+	naming a capture proxy specially.
+
 2023-11-07  Kwok Cheung Yeung  <kcy@codesourcery.com>
 
 	* cp-tree.h (cp_omp_declare_target_attr): Add indirect field.
diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc
index 4516677..81b104f 100644
--- a/gcc/cp/call.cc
+++ b/gcc/cp/call.cc
@@ -6163,19 +6163,36 @@ build_conditional_expr (const op_location_t &loc,
 		  == DECL_CONTEXT (stripped_orig_arg3)))
 	    /* Two enumerators from the same enumeration can have different
 	       types when the enumeration is still being defined.  */;
-          else if (complain & tf_warning)
-	    warning_at (loc, OPT_Wenum_compare, "enumerated mismatch "
-			"in conditional expression: %qT vs %qT",
-			arg2_type, arg3_type);
+	  else if (complain & (cxx_dialect >= cxx26
+			       ? tf_warning_or_error : tf_warning))
+	    emit_diagnostic (cxx_dialect >= cxx26 ? DK_PEDWARN : DK_WARNING,
+			     loc, OPT_Wenum_compare, "enumerated mismatch "
+			     "in conditional expression: %qT vs %qT",
+			     arg2_type, arg3_type);
+	  else if (cxx_dialect >= cxx26)
+	    return error_mark_node;
         }
-      else if ((complain & tf_warning)
-	       && warn_deprecated_enum_float_conv
+      else if ((((complain & (cxx_dialect >= cxx26
+			      ? tf_warning_or_error : tf_warning))
+		 && warn_deprecated_enum_float_conv)
+		|| (cxx_dialect >= cxx26
+		    && (complain & tf_warning_or_error) == 0))
 	       && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
 		    && SCALAR_FLOAT_TYPE_P (arg3_type))
 		   || (SCALAR_FLOAT_TYPE_P (arg2_type)
 		       && TREE_CODE (arg3_type) == ENUMERAL_TYPE)))
 	{
-	  if (TREE_CODE (arg2_type) == ENUMERAL_TYPE)
+	  if (cxx_dialect >= cxx26 && (complain & tf_warning_or_error) == 0)
+	    return error_mark_node;
+	  if (cxx_dialect >= cxx26 && TREE_CODE (arg2_type) == ENUMERAL_TYPE)
+	    pedwarn (loc, OPT_Wdeprecated_enum_float_conversion,
+		     "conditional expression between enumeration type "
+		     "%qT and floating-point type %qT", arg2_type, arg3_type);
+	  else if (cxx_dialect >= cxx26)
+	    pedwarn (loc, OPT_Wdeprecated_enum_float_conversion,
+		     "conditional expression between floating-point type "
+		     "%qT and enumeration type %qT", arg2_type, arg3_type);
+	  else if (TREE_CODE (arg2_type) == ENUMERAL_TYPE)
 	    warning_at (loc, OPT_Wdeprecated_enum_float_conversion,
 			"conditional expression between enumeration type "
 			"%qT and floating-point type %qT is deprecated",
@@ -7258,11 +7275,18 @@ build_new_op (const op_location_t &loc, enum tree_code code, int flags,
 	      if (TREE_CODE (arg1_type) == ENUMERAL_TYPE
 		  && TREE_CODE (arg2_type) == ENUMERAL_TYPE
 		  && (TYPE_MAIN_VARIANT (arg1_type)
-		      != TYPE_MAIN_VARIANT (arg2_type))
-		  && (complain & tf_warning))
-		warning_at (loc, OPT_Wenum_compare,
-			    "comparison between %q#T and %q#T",
-			    arg1_type, arg2_type);
+		      != TYPE_MAIN_VARIANT (arg2_type)))
+		{
+		  if (cxx_dialect >= cxx26
+		      && (complain & tf_warning_or_error) == 0)
+		    result = error_mark_node;
+		  else if (cxx_dialect >= cxx26 || (complain & tf_warning))
+		    emit_diagnostic (cxx_dialect >= cxx26
+				     ? DK_PEDWARN : DK_WARNING,
+				     loc, OPT_Wenum_compare,
+				     "comparison between %q#T and %q#T",
+				     arg1_type, arg2_type);
+		}
 	      break;
 	    default:
 	      break;
@@ -8303,15 +8327,17 @@ convert_like_internal (conversion *convs, tree expr, tree fn, int argnum,
 							    totype))
 	  {
 	  case 2:
-	    if (pedwarn (loc, 0, "converting to %qH from %qI with greater "
-				 "conversion rank", totype, TREE_TYPE (expr)))
+	    if (pedwarn (loc, OPT_Wnarrowing, "ISO C++ does not allow "
+			 "converting to %qH from %qI with greater "
+			 "conversion rank", totype, TREE_TYPE (expr)))
 	      complained = 1;
 	    else if (!complained)
 	      complained = -1;
 	    break;
 	  case 3:
-	    if (pedwarn (loc, 0, "converting to %qH from %qI with unordered "
-				 "conversion ranks", totype, TREE_TYPE (expr)))
+	    if (pedwarn (loc, OPT_Wnarrowing, "ISO C++ does not allow "
+			 "converting to %qH from %qI with unordered "
+			 "conversion rank", totype, TREE_TYPE (expr)))
 	      complained = 1;
 	    else if (!complained)
 	      complained = -1;
@@ -9290,7 +9316,9 @@ convert_for_arg_passing (tree type, tree val, tsubst_flags_t complain)
    This is true for some builtins which don't act like normal functions.
    Return 2 if just decay_conversion and removal of excess precision should
    be done, 1 if just decay_conversion.  Return 3 for special treatment of
-   the 3rd argument for __builtin_*_overflow_p.  */
+   the 3rd argument for __builtin_*_overflow_p.  Return 4 for special
+   treatment of the 1st argument for
+   __builtin_{clz,ctz,clrsb,ffs,parity,popcount}g.  */
 
 int
 magic_varargs_p (tree fn)
@@ -9317,6 +9345,14 @@ magic_varargs_p (tree fn)
       case BUILT_IN_FPCLASSIFY:
 	return 2;
 
+      case BUILT_IN_CLZG:
+      case BUILT_IN_CTZG:
+      case BUILT_IN_CLRSBG:
+      case BUILT_IN_FFSG:
+      case BUILT_IN_PARITYG:
+      case BUILT_IN_POPCOUNTG:
+	return 4;
+
       default:
 	return lookup_attribute ("type generic",
 				 TYPE_ATTRIBUTES (TREE_TYPE (fn))) != 0;
@@ -10122,7 +10158,7 @@ build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
   for (; arg_index < vec_safe_length (args); ++arg_index)
     {
       tree a = (*args)[arg_index];
-      if (magic == 3 && arg_index == 2)
+      if ((magic == 3 && arg_index == 2) || (magic == 4 && arg_index == 0))
 	{
 	  /* Do no conversions for certain magic varargs.  */
 	  a = mark_type_use (a);
diff --git a/gcc/cp/class.cc b/gcc/cp/class.cc
index 9d4d95f..4766b7c 100644
--- a/gcc/cp/class.cc
+++ b/gcc/cp/class.cc
@@ -6962,7 +6962,8 @@ layout_class_type (tree t, tree *virtuals_p)
 	     check_bitfield_decl eventually sets DECL_SIZE (field)
 	     to that width.  */
 	  && (DECL_SIZE (field) == NULL_TREE
-	      || integer_zerop (DECL_SIZE (field))))
+	      || integer_zerop (DECL_SIZE (field)))
+	  && TREE_TYPE (field) != error_mark_node)
 	SET_DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD (field, 1);
       check_non_pod_aggregate (field);
     }
diff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc
index c05760e..344107d 100644
--- a/gcc/cp/constexpr.cc
+++ b/gcc/cp/constexpr.cc
@@ -9547,7 +9547,12 @@ potential_constant_expression_1 (tree t, bool want_rval, bool strict, bool now,
 	  }
 	else if (fun)
           {
-	    if (RECUR (fun, FUNCTION_POINTER_TYPE_P (fun) ? rval : any))
+	    if (TREE_TYPE (fun)
+		&& FUNCTION_POINTER_TYPE_P (TREE_TYPE (fun)))
+	      want_rval = rval;
+	    else
+	      want_rval = any;
+	    if (RECUR (fun, want_rval))
 	      /* Might end up being a constant function pointer.  But it
 		 could also be a function object with constexpr op(), so
 		 we pass 'any' so that the underlying VAR_DECL is deemed
@@ -9623,7 +9628,7 @@ potential_constant_expression_1 (tree t, bool want_rval, bool strict, bool now,
 	  return RECUR (DECL_VALUE_EXPR (t), rval);
 	}
       if (want_rval
-	  && !var_in_maybe_constexpr_fn (t)
+	  && (now || !var_in_maybe_constexpr_fn (t))
 	  && !type_dependent_expression_p (t)
 	  && !decl_maybe_constant_var_p (t)
 	  && (strict
@@ -9737,7 +9742,7 @@ potential_constant_expression_1 (tree t, bool want_rval, bool strict, bool now,
         STRIP_NOPS (x);
         if (is_this_parameter (x) && !is_capture_proxy (x))
 	  {
-	    if (!var_in_maybe_constexpr_fn (x))
+	    if (now || !var_in_maybe_constexpr_fn (x))
 	      {
 		if (flags & tf_error)
 		  constexpr_error (loc, fundef_p, "use of %<this%> in a "
diff --git a/gcc/cp/contracts.cc b/gcc/cp/contracts.cc
index 9d1cb55..66d2298 100644
--- a/gcc/cp/contracts.cc
+++ b/gcc/cp/contracts.cc
@@ -722,7 +722,8 @@ build_comment (cp_expr condition)
 {
   /* Try to get the actual source text for the condition; if that fails pretty
      print the resulting tree.  */
-  char *str = get_source_text_between (condition.get_start (),
+  char *str = get_source_text_between (global_dc->get_file_cache (),
+				       condition.get_start (),
 				       condition.get_finish ());
   if (!str)
     {
diff --git a/gcc/cp/cp-gimplify.cc b/gcc/cp/cp-gimplify.cc
index 9375a11..795c811 100644
--- a/gcc/cp/cp-gimplify.cc
+++ b/gcc/cp/cp-gimplify.cc
@@ -771,6 +771,10 @@ cp_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
 	      default:
 		break;
 	      }
+	  else if (decl
+		   && fndecl_built_in_p (decl, BUILT_IN_CLZG, BUILT_IN_CTZG))
+	    ret = (enum gimplify_status) c_gimplify_expr (expr_p, pre_p,
+							  post_p);
 	}
       break;
 
diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
index 4a07c7e..b8e1098 100644
--- a/gcc/cp/decl.cc
+++ b/gcc/cp/decl.cc
@@ -6614,6 +6614,7 @@ is_direct_enum_init (tree type, tree init)
       && CONSTRUCTOR_NELTS (init) == 1
       /* DR 2374: The single element needs to be implicitly
 	 convertible to the underlying type of the enum.  */
+      && !type_dependent_expression_p (CONSTRUCTOR_ELT (init, 0)->value)
       && can_convert_arg (ENUM_UNDERLYING_TYPE (type),
 			  TREE_TYPE (CONSTRUCTOR_ELT (init, 0)->value),
 			  CONSTRUCTOR_ELT (init, 0)->value,
@@ -18308,9 +18309,7 @@ finish_function (bool inline_p)
 	      && current_class_ref
 	      && same_type_ignoring_top_level_qualifiers_p
 		  (TREE_TYPE (valtype), TREE_TYPE (current_class_ref))
-	      && global_dc->m_option_enabled (OPT_Wreturn_type,
-					      global_dc->m_lang_mask,
-					      global_dc->m_option_state))
+	      && global_dc->option_enabled_p (OPT_Wreturn_type))
 	    add_return_star_this_fixit (&richloc, fndecl);
 	}
       if (cxx_dialect >= cxx14
diff --git a/gcc/cp/mapper-client.cc b/gcc/cp/mapper-client.cc
index 9272719..f1a0c4c 100644
--- a/gcc/cp/mapper-client.cc
+++ b/gcc/cp/mapper-client.cc
@@ -31,6 +31,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "system.h"
 
 #include "line-map.h"
+#include "rich-location.h"
 #include "diagnostic-core.h"
 #include "mapper-client.h"
 #include "intl.h"
diff --git a/gcc/cp/module.cc b/gcc/cp/module.cc
index c1c8c22..4f5b6e2 100644
--- a/gcc/cp/module.cc
+++ b/gcc/cp/module.cc
@@ -8648,6 +8648,8 @@ trees_out::decl_node (tree decl, walk_kind ref)
 
       tree_node (target);
       tree_node (DECL_NAME (decl));
+      if (DECL_VIRTUAL_P (decl))
+	tree_node (DECL_VINDEX (decl));
       int tag = insert (decl);
       if (streaming_p ())
 	dump (dumper::TREE)
@@ -9869,6 +9871,10 @@ trees_in::tree_node (bool is_use)
 		}
 	  }
 
+	/* A clone might have a different vtable entry.  */
+	if (res && DECL_VIRTUAL_P (res))
+	  DECL_VINDEX (res) = tree_node ();
+
 	if (!res)
 	  set_overrun ();
 	int tag = insert (res);
diff --git a/gcc/cp/name-lookup.cc b/gcc/cp/name-lookup.cc
index a8b9229..50aeb77 100644
--- a/gcc/cp/name-lookup.cc
+++ b/gcc/cp/name-lookup.cc
@@ -4846,12 +4846,16 @@ do_nonmember_using_decl (name_lookup &lookup, bool fn_scope_p,
 	  bool exporting = revealing_p && module_exporting_p ();
 	  if (exporting)
 	    {
+	      /* Module flags for templates are on the template_result.  */
+	      tree decl = STRIP_TEMPLATE (new_fn);
+
 	      /* If the using decl is exported, the things it refers
-		 to must also be exported (or not habve module attachment).  */
-	      if (!DECL_MODULE_EXPORT_P (new_fn)
-		  && (DECL_LANG_SPECIFIC (new_fn)
-		      && DECL_MODULE_ATTACH_P (new_fn)))
+		 to must also be exported (or not have module attachment).  */
+	      if (!DECL_MODULE_EXPORT_P (decl)
+		  && (DECL_LANG_SPECIFIC (decl)
+		      && DECL_MODULE_ATTACH_P (decl)))
 		{
+		  auto_diagnostic_group d;
 		  error ("%q#D does not have external linkage", new_fn);
 		  inform (DECL_SOURCE_LOCATION (new_fn),
 			  "%q#D declared here", new_fn);
diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
index 5116bcb..d110433 100644
--- a/gcc/cp/parser.cc
+++ b/gcc/cp/parser.cc
@@ -23594,6 +23594,19 @@ cp_parser_direct_declarator (cp_parser* parser,
 	      /* Consume the `)'.  */
 	      parens.require_close (parser);
 
+	      /* For code like
+		  int x(auto(42));
+		  A a(auto(i), 42);
+		 we have synthesized an implicit template parameter and marked
+		 what we thought was a function as an implicit function template.
+		 But now, having seen the whole parameter list, we know it's not
+		 a function declaration, so undo that.  */
+	      if (cp_parser_error_occurred (parser)
+		  && parser->fully_implicit_function_template_p
+		  /* Don't do this for the inner ().  */
+		  && parser->default_arg_ok_p)
+		abort_fully_implicit_template (parser);
+
 	      /* If all went well, parse the cv-qualifier-seq,
 		 ref-qualifier and the exception-specification.  */
 	      if (member_p || cp_parser_parse_definitely (parser))
diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc
index 417c92b..5279579 100644
--- a/gcc/cp/tree.cc
+++ b/gcc/cp/tree.cc
@@ -1171,7 +1171,7 @@ build_cplus_array_type (tree elt_type, tree index_type, int dependent)
     }
 
   /* Avoid spurious warnings with VLAs (c++/54583).  */
-  if (CAN_HAVE_LOCATION_P (TYPE_SIZE (t)))
+  if (TYPE_SIZE (t) && EXPR_P (TYPE_SIZE (t)))
     suppress_warning (TYPE_SIZE (t), OPT_Wunused);
 
   /* Push these needs up to the ARRAY_TYPE so that initialization takes
@@ -1911,19 +1911,24 @@ strip_typedefs_expr (tree t, bool *remove_attributes, unsigned int flags)
     case TREE_LIST:
       {
 	bool changed = false;
-	releasing_vec vec;
+	auto_vec<tree_pair, 4> vec;
 	r = t;
 	for (; t; t = TREE_CHAIN (t))
 	  {
-	    gcc_assert (!TREE_PURPOSE (t));
-	    tree elt = strip_typedefs (TREE_VALUE (t),
-				       remove_attributes, flags);
-	    if (elt != TREE_VALUE (t))
+	    tree purpose = strip_typedefs (TREE_PURPOSE (t),
+					   remove_attributes, flags);
+	    tree value = strip_typedefs (TREE_VALUE (t),
+					 remove_attributes, flags);
+	    if (purpose != TREE_PURPOSE (t) || value != TREE_VALUE (t))
 	      changed = true;
-	    vec_safe_push (vec, elt);
+	    vec.safe_push ({purpose, value});
 	  }
 	if (changed)
-	  r = build_tree_list_vec (vec);
+	  {
+	    r = NULL_TREE;
+	    for (int i = vec.length () - 1; i >= 0; i--)
+	      r = tree_cons (vec[i].first, vec[i].second, r);
+	  }
 	return r;
       }
 
@@ -3601,7 +3606,12 @@ build_min_non_dep (enum tree_code code, tree non_dep, ...)
   TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
 
   for (i = 0; i < length; i++)
-    TREE_OPERAND (t, i) = va_arg (p, tree);
+    {
+      tree x = va_arg (p, tree);
+      TREE_OPERAND (t, i) = x;
+      if (x && !TYPE_P (x))
+	TREE_SIDE_EFFECTS (t) |= TREE_SIDE_EFFECTS (x);
+    }
 
   va_end (p);
   return convert_from_reference (t);
@@ -3636,6 +3646,10 @@ build_min_non_dep_call_vec (tree non_dep, tree fn, vec<tree, va_gc> *argvec)
     non_dep = TREE_OPERAND (non_dep, 0);
   TREE_TYPE (t) = TREE_TYPE (non_dep);
   TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
+  if (argvec)
+    for (tree x : *argvec)
+      if (x && !TYPE_P (x))
+	TREE_SIDE_EFFECTS (t) |= TREE_SIDE_EFFECTS (x);
   return convert_from_reference (t);
 }
 
diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
index 49afbd8..e995fb6 100644
--- a/gcc/cp/typeck.cc
+++ b/gcc/cp/typeck.cc
@@ -4940,16 +4940,25 @@ warn_for_null_address (location_t location, tree op, tsubst_flags_t complain)
    type, this behavior is deprecated ([depr.arith.conv.enum]).  CODE is the
    code of the binary operation, TYPE0 and TYPE1 are the types of the operands,
    and LOC is the location for the whole binary expression.
+   For C++26 this is ill-formed rather than deprecated.
+   Return true for SFINAE errors.
    TODO: Consider combining this with -Wenum-compare in build_new_op_1.  */
 
-static void
+static bool
 do_warn_enum_conversions (location_t loc, enum tree_code code, tree type0,
-			  tree type1)
+			  tree type1, tsubst_flags_t complain)
 {
   if (TREE_CODE (type0) == ENUMERAL_TYPE
       && TREE_CODE (type1) == ENUMERAL_TYPE
       && TYPE_MAIN_VARIANT (type0) != TYPE_MAIN_VARIANT (type1))
     {
+      if (cxx_dialect >= cxx26)
+	{
+	  if ((complain & tf_warning_or_error) == 0)
+	    return true;
+	}
+      else if ((complain & tf_warning) == 0)
+	return false;
       /* In C++20, -Wdeprecated-enum-enum-conversion is on by default.
 	 Otherwise, warn if -Wenum-conversion is on.  */
       enum opt_code opt;
@@ -4958,7 +4967,7 @@ do_warn_enum_conversions (location_t loc, enum tree_code code, tree type0,
       else if (warn_enum_conversion)
 	opt = OPT_Wenum_conversion;
       else
-	return;
+	return false;
 
       switch (code)
 	{
@@ -4969,21 +4978,29 @@ do_warn_enum_conversions (location_t loc, enum tree_code code, tree type0,
 	case EQ_EXPR:
 	case NE_EXPR:
 	  /* Comparisons are handled by -Wenum-compare.  */
-	  return;
+	  return false;
 	case SPACESHIP_EXPR:
 	  /* This is invalid, don't warn.  */
-	  return;
+	  return false;
 	case BIT_AND_EXPR:
 	case BIT_IOR_EXPR:
 	case BIT_XOR_EXPR:
-	  warning_at (loc, opt, "bitwise operation between different "
-		      "enumeration types %qT and %qT is deprecated",
-		      type0, type1);
-	  return;
+	  if (cxx_dialect >= cxx26)
+	    pedwarn (loc, opt, "bitwise operation between different "
+		     "enumeration types %qT and %qT", type0, type1);
+	  else
+	    warning_at (loc, opt, "bitwise operation between different "
+			"enumeration types %qT and %qT is deprecated",
+			type0, type1);
+	  return false;
 	default:
-	  warning_at (loc, opt, "arithmetic between different enumeration "
-		      "types %qT and %qT is deprecated", type0, type1);
-	  return;
+	  if (cxx_dialect >= cxx26)
+	    pedwarn (loc, opt, "arithmetic between different enumeration "
+		     "types %qT and %qT", type0, type1);
+	  else
+	    warning_at (loc, opt, "arithmetic between different enumeration "
+			"types %qT and %qT is deprecated", type0, type1);
+	  return false;
 	}
     }
   else if ((TREE_CODE (type0) == ENUMERAL_TYPE
@@ -4991,6 +5008,13 @@ do_warn_enum_conversions (location_t loc, enum tree_code code, tree type0,
 	   || (SCALAR_FLOAT_TYPE_P (type0)
 	       && TREE_CODE (type1) == ENUMERAL_TYPE))
     {
+      if (cxx_dialect >= cxx26)
+	{
+	  if ((complain & tf_warning_or_error) == 0)
+	    return true;
+	}
+      else if ((complain & tf_warning) == 0)
+	return false;
       const bool enum_first_p = TREE_CODE (type0) == ENUMERAL_TYPE;
       /* In C++20, -Wdeprecated-enum-float-conversion is on by default.
 	 Otherwise, warn if -Wenum-conversion is on.  */
@@ -5000,7 +5024,7 @@ do_warn_enum_conversions (location_t loc, enum tree_code code, tree type0,
       else if (warn_enum_conversion)
 	opt = OPT_Wenum_conversion;
       else
-	return;
+	return false;
 
       switch (code)
 	{
@@ -5010,7 +5034,13 @@ do_warn_enum_conversions (location_t loc, enum tree_code code, tree type0,
 	case LE_EXPR:
 	case EQ_EXPR:
 	case NE_EXPR:
-	  if (enum_first_p)
+	  if (enum_first_p && cxx_dialect >= cxx26)
+	    pedwarn (loc, opt, "comparison of enumeration type %qT with "
+		     "floating-point type %qT", type0, type1);
+	  else if (cxx_dialect >= cxx26)
+	    pedwarn (loc, opt, "comparison of floating-point type %qT "
+		      "with enumeration type %qT", type0, type1);
+	  else if (enum_first_p)
 	    warning_at (loc, opt, "comparison of enumeration type %qT with "
 			"floating-point type %qT is deprecated",
 			type0, type1);
@@ -5018,12 +5048,18 @@ do_warn_enum_conversions (location_t loc, enum tree_code code, tree type0,
 	    warning_at (loc, opt, "comparison of floating-point type %qT "
 			"with enumeration type %qT is deprecated",
 			type0, type1);
-	  return;
+	  return false;
 	case SPACESHIP_EXPR:
 	  /* This is invalid, don't warn.  */
-	  return;
+	  return false;
 	default:
-	  if (enum_first_p)
+	  if (enum_first_p && cxx_dialect >= cxx26)
+	    pedwarn (loc, opt, "arithmetic between enumeration type %qT "
+		     "and floating-point type %qT", type0, type1);
+	  else if (cxx_dialect >= cxx26)
+	    pedwarn (loc, opt, "arithmetic between floating-point type %qT "
+		     "and enumeration type %qT", type0, type1);
+	  else if (enum_first_p)
 	    warning_at (loc, opt, "arithmetic between enumeration type %qT "
 			"and floating-point type %qT is deprecated",
 			type0, type1);
@@ -5031,9 +5067,10 @@ do_warn_enum_conversions (location_t loc, enum tree_code code, tree type0,
 	    warning_at (loc, opt, "arithmetic between floating-point type %qT "
 			"and enumeration type %qT is deprecated",
 			type0, type1);
-	  return;
+	  return false;
 	}
     }
+  return false;
 }
 
 /* Build a binary-operation expression without default conversions.
@@ -6163,15 +6200,13 @@ cp_build_binary_op (const op_location_t &location,
 	  return error_mark_node;
 	}
       if (complain & tf_warning)
-	{
-	  do_warn_double_promotion (result_type, type0, type1,
-				    "implicit conversion from %qH to %qI "
-				    "to match other operand of binary "
-				    "expression",
-				    location);
-	  do_warn_enum_conversions (location, code, TREE_TYPE (orig_op0),
-				    TREE_TYPE (orig_op1));
-	}
+	do_warn_double_promotion (result_type, type0, type1,
+				  "implicit conversion from %qH to %qI "
+				  "to match other operand of binary "
+				  "expression", location);
+      if (do_warn_enum_conversions (location, code, TREE_TYPE (orig_op0),
+				    TREE_TYPE (orig_op1), complain))
+	return error_mark_node;
     }
   if (may_need_excess_precision
       && (orig_type0 != type0 || orig_type1 != type1)
diff --git a/gcc/cp/typeck2.cc b/gcc/cp/typeck2.cc
index 309903a..a75f4f8 100644
--- a/gcc/cp/typeck2.cc
+++ b/gcc/cp/typeck2.cc
@@ -2378,7 +2378,11 @@ build_m_component_ref (tree datum, tree component, tsubst_flags_t complain)
       /* Build an expression for "object + offset" where offset is the
 	 value stored in the pointer-to-data-member.  */
       ptype = build_pointer_type (type);
-      datum = fold_build_pointer_plus (fold_convert (ptype, datum), component);
+      datum = cp_convert (ptype, datum, complain);
+      if (!processing_template_decl)
+	datum = build2 (POINTER_PLUS_EXPR, ptype,
+			datum, convert_to_ptrofftype (component));
+      datum = cp_fully_fold (datum);
       datum = cp_build_fold_indirect_ref (datum);
       if (datum == error_mark_node)
 	return error_mark_node;
diff --git a/gcc/diagnostic-format-json.cc b/gcc/diagnostic-format-json.cc
index 8321c48..141075b 100644
--- a/gcc/diagnostic-format-json.cc
+++ b/gcc/diagnostic-format-json.cc
@@ -94,8 +94,8 @@ json_from_expanded_location (diagnostic_context *context, location_t loc)
   expanded_location exploc = expand_location (loc);
   json::object *result = new json::object ();
   if (exploc.file)
-    result->set ("file", new json::string (exploc.file));
-  result->set ("line", new json::integer_number (exploc.line));
+    result->set_string ("file", exploc.file);
+  result->set_integer ("line", exploc.line);
 
   const enum diagnostics_column_unit orig_unit = context->m_column_unit;
   struct
@@ -111,12 +111,12 @@ json_from_expanded_location (diagnostic_context *context, location_t loc)
     {
       context->m_column_unit = column_fields[i].unit;
       const int col = context->converted_column (exploc);
-      result->set (column_fields[i].name, new json::integer_number (col));
+      result->set_integer (column_fields[i].name, col);
       if (column_fields[i].unit == orig_unit)
 	the_column = col;
     }
   gcc_assert (the_column != INT_MIN);
-  result->set ("column", new json::integer_number (the_column));
+  result->set_integer ("column", the_column);
   context->m_column_unit = orig_unit;
   return result;
 }
@@ -148,7 +148,7 @@ json_from_location_range (diagnostic_context *context,
     {
       label_text text (loc_range->m_label->get_text (range_idx));
       if (text.get ())
-	result->set ("label", new json::string (text.get ()));
+	result->set_string ("label", text.get ());
     }
 
   return result;
@@ -165,7 +165,7 @@ json_from_fixit_hint (diagnostic_context *context, const fixit_hint *hint)
   fixit_obj->set ("start", json_from_expanded_location (context, start_loc));
   location_t next_loc = hint->get_next_loc ();
   fixit_obj->set ("next", json_from_expanded_location (context, next_loc));
-  fixit_obj->set ("string", new json::string (hint->get_string ()));
+  fixit_obj->set_string ("string", hint->get_string ());
 
   return fixit_obj;
 }
@@ -178,8 +178,7 @@ json_from_metadata (const diagnostic_metadata *metadata)
   json::object *metadata_obj = new json::object ();
 
   if (metadata->get_cwe ())
-    metadata_obj->set ("cwe",
-		       new json::integer_number (metadata->get_cwe ()));
+    metadata_obj->set_integer ("cwe", metadata->get_cwe ());
 
   return metadata_obj;
 }
@@ -210,33 +209,26 @@ json_output_format::on_end_diagnostic (diagnostic_info *diagnostic,
     gcc_assert (kind_text[len - 1] == ' ');
     char *rstrip = xstrdup (kind_text);
     rstrip[len - 2] = '\0';
-    diag_obj->set ("kind", new json::string (rstrip));
+    diag_obj->set_string ("kind", rstrip);
     free (rstrip);
   }
 
   // FIXME: encoding of the message (json::string requires UTF-8)
-  diag_obj->set ("message",
-		 new json::string (pp_formatted_text (m_context.printer)));
+  diag_obj->set_string ("message", pp_formatted_text (m_context.printer));
   pp_clear_output_area (m_context.printer);
 
-  char *option_text;
-  option_text = m_context.m_option_name (&m_context, diagnostic->option_index,
-					 orig_diag_kind, diagnostic->kind);
-  if (option_text)
+  if (char *option_text = m_context.make_option_name (diagnostic->option_index,
+						      orig_diag_kind,
+						      diagnostic->kind))
     {
-      diag_obj->set ("option", new json::string (option_text));
+      diag_obj->set_string ("option", option_text);
       free (option_text);
     }
 
-  if (m_context.m_get_option_url)
+  if (char *option_url = m_context.make_option_url (diagnostic->option_index))
     {
-      char *option_url = m_context.m_get_option_url (&m_context,
-						     diagnostic->option_index);
-      if (option_url)
-	{
-	  diag_obj->set ("option_url", new json::string (option_url));
-	  free (option_url);
-	}
+      diag_obj->set_string ("option_url", option_url);
+      free (option_url);
     }
 
   /* If we've already emitted a diagnostic within this auto_diagnostic_group,
@@ -254,8 +246,7 @@ json_output_format::on_end_diagnostic (diagnostic_info *diagnostic,
       m_cur_group = diag_obj;
       m_cur_children_array = new json::array ();
       diag_obj->set ("children", m_cur_children_array);
-      diag_obj->set ("column-origin",
-		     new json::integer_number (m_context.m_column_origin));
+      diag_obj->set_integer ("column-origin", m_context.m_column_origin);
     }
 
   const rich_location *richloc = diagnostic->richloc;
diff --git a/gcc/diagnostic-format-sarif.cc b/gcc/diagnostic-format-sarif.cc
index 25f6239..1bb7286 100644
--- a/gcc/diagnostic-format-sarif.cc
+++ b/gcc/diagnostic-format-sarif.cc
@@ -289,7 +289,7 @@ void
 sarif_invocation::prepare_to_flush (diagnostic_context *context)
 {
   /* "executionSuccessful" property (SARIF v2.1.0 section 3.20.14).  */
-  set ("executionSuccessful", new json::literal (m_success));
+  set_bool ("executionSuccessful", m_success);
 
   /* "toolExecutionNotifications" property (SARIF v2.1.0 section 3.20.21).  */
   set ("toolExecutionNotifications", m_notifications_arr);
@@ -380,7 +380,7 @@ sarif_ice_notification::sarif_ice_notification (diagnostic_context *context,
   set ("message", message_obj);
 
   /* "level" property (SARIF v2.1.0 section 3.58.6).  */
-  set ("level", new json::string ("error"));
+  set_string ("level", "error");
 }
 
 /* class sarif_thread_flow : public sarif_object.  */
@@ -389,7 +389,7 @@ sarif_thread_flow::sarif_thread_flow (const diagnostic_thread &thread)
 {
   /* "id" property (SARIF v2.1.0 section 3.37.2).  */
   label_text name (thread.get_name (false));
-  set ("id", new json::string (name.get ()));
+  set_string ("id", name.get ());
 
   /* "locations" property (SARIF v2.1.0 section 3.37.6).  */
   m_locations_arr = new json::array ();
@@ -536,12 +536,12 @@ sarif_builder::make_result_object (diagnostic_context *context,
   /* "ruleId" property (SARIF v2.1.0 section 3.27.5).  */
   /* Ideally we'd have an option_name for these.  */
   if (char *option_text
-	= context->m_option_name (context, diagnostic->option_index,
-				  orig_diag_kind, diagnostic->kind))
+	= context->make_option_name (diagnostic->option_index,
+				     orig_diag_kind, diagnostic->kind))
     {
       /* Lazily create reportingDescriptor objects for and add to m_rules_arr.
 	 Set ruleId referencing them.  */
-      result_obj->set ("ruleId", new json::string (option_text));
+      result_obj->set_string ("ruleId", option_text);
       if (m_rule_id_set.contains (option_text))
 	free (option_text);
       else
@@ -565,7 +565,7 @@ sarif_builder::make_result_object (diagnostic_context *context,
 	 has a ruleId.
 	 We don't bother creating reportingDescriptor objects for these.  */
       char *rule_id = make_rule_id_for_diagnostic_kind (orig_diag_kind);
-      result_obj->set ("ruleId", new json::string (rule_id));
+      result_obj->set_string ("ruleId", rule_id);
       free (rule_id);
     }
 
@@ -582,7 +582,7 @@ sarif_builder::make_result_object (diagnostic_context *context,
 
   /* "level" property (SARIF v2.1.0 section 3.27.10).  */
   if (const char *sarif_level = maybe_get_sarif_level (diagnostic->kind))
-    result_obj->set ("level", new json::string (sarif_level));
+    result_obj->set_string ("level", sarif_level);
 
   /* "message" property (SARIF v2.1.0 section 3.27.11).  */
   json::object *message_obj
@@ -633,21 +633,16 @@ make_reporting_descriptor_object_for_warning (diagnostic_context *context,
   json::object *reporting_desc = new json::object ();
 
   /* "id" property (SARIF v2.1.0 section 3.49.3).  */
-  reporting_desc->set ("id", new json::string (option_text));
+  reporting_desc->set_string ("id", option_text);
 
   /* We don't implement "name" property (SARIF v2.1.0 section 3.49.7), since
      it seems redundant compared to "id".  */
 
   /* "helpUri" property (SARIF v2.1.0 section 3.49.12).  */
-  if (context->m_get_option_url)
+  if (char *option_url = context->make_option_url (diagnostic->option_index))
     {
-      char *option_url
-	= context->m_get_option_url (context, diagnostic->option_index);
-      if (option_url)
-	{
-	  reporting_desc->set ("helpUri", new json::string (option_url));
-	  free (option_url);
-	}
+      reporting_desc->set_string ("helpUri", option_url);
+      free (option_url);
     }
 
   return reporting_desc;
@@ -665,13 +660,13 @@ sarif_builder::make_reporting_descriptor_object_for_cwe_id (int cwe_id) const
   {
     pretty_printer pp;
     pp_printf (&pp, "%i", cwe_id);
-    reporting_desc->set ("id", new json::string (pp_formatted_text (&pp)));
+    reporting_desc->set_string ("id", pp_formatted_text (&pp));
   }
 
   /* "helpUri" property (SARIF v2.1.0 section 3.49.12).  */
   {
     char *url = get_cwe_url (cwe_id);
-    reporting_desc->set ("helpUri", new json::string (url));
+    reporting_desc->set_string ("helpUri", url);
     free (url);
   }
 
@@ -692,7 +687,7 @@ make_reporting_descriptor_reference_object_for_cwe_id (int cwe_id)
   {
     pretty_printer pp;
     pp_printf (&pp, "%i", cwe_id);
-    desc_ref_obj->set ("id", new json::string (pp_formatted_text (&pp)));
+    desc_ref_obj->set_string ("id", pp_formatted_text (&pp));
   }
 
   /* "toolComponent" property (SARIF v2.1.0 section 3.52.7).  */
@@ -716,7 +711,7 @@ make_tool_component_reference_object_for_cwe () const
   json::object *comp_ref_obj = new json::object ();
 
   /* "name" property  (SARIF v2.1.0 section 3.54.3).  */
-  comp_ref_obj->set ("name", new json::string ("cwe"));
+  comp_ref_obj->set_string ("name", "cwe");
 
   return comp_ref_obj;
 }
@@ -858,13 +853,13 @@ sarif_builder::make_artifact_location_object (const char *filename)
   json::object *artifact_loc_obj = new json::object ();
 
   /* "uri" property (SARIF v2.1.0 section 3.4.3).  */
-  artifact_loc_obj->set ("uri", new json::string (filename));
+  artifact_loc_obj->set_string ("uri", filename);
 
   if (filename[0] != '/')
     {
       /* If we have a relative path, set the "uriBaseId" property
 	 (SARIF v2.1.0 section 3.4.4).  */
-      artifact_loc_obj->set ("uriBaseId", new json::string (PWD_PROPERTY_NAME));
+      artifact_loc_obj->set_string ("uriBaseId", PWD_PROPERTY_NAME);
       m_seen_any_relative_paths = true;
     }
 
@@ -908,7 +903,7 @@ sarif_builder::make_artifact_location_object_for_pwd () const
     {
       gcc_assert (strlen (pwd) > 0);
       gcc_assert (pwd[strlen (pwd) - 1] == '/');
-      artifact_loc_obj->set ("uri", new json::string (pwd));
+      artifact_loc_obj->set_string ("uri", pwd);
       free (pwd);
     }
 
@@ -921,7 +916,8 @@ int
 sarif_builder::get_sarif_column (expanded_location exploc) const
 {
   cpp_char_column_policy policy (m_tabstop, cpp_wcwidth);
-  return location_compute_display_column (exploc, policy);
+  return location_compute_display_column (m_context->get_file_cache (),
+					  exploc, policy);
 }
 
 /* Make a region object (SARIF v2.1.0 section 3.30) for LOC,
@@ -950,21 +946,20 @@ sarif_builder::maybe_make_region_object (location_t loc) const
   json::object *region_obj = new json::object ();
 
   /* "startLine" property (SARIF v2.1.0 section 3.30.5) */
-  region_obj->set ("startLine", new json::integer_number (exploc_start.line));
+  region_obj->set_integer ("startLine", exploc_start.line);
 
   /* "startColumn" property (SARIF v2.1.0 section 3.30.6) */
-  region_obj->set ("startColumn",
-		   new json::integer_number (get_sarif_column (exploc_start)));
+  region_obj->set_integer ("startColumn", get_sarif_column (exploc_start));
 
   /* "endLine" property (SARIF v2.1.0 section 3.30.7) */
   if (exploc_finish.line != exploc_start.line)
-    region_obj->set ("endLine", new json::integer_number (exploc_finish.line));
+    region_obj->set_integer ("endLine", exploc_finish.line);
 
   /* "endColumn" property (SARIF v2.1.0 section 3.30.8).
      This expresses the column immediately beyond the range.  */
   {
     int next_column = sarif_builder::get_sarif_column (exploc_finish) + 1;
-    region_obj->set ("endColumn", new json::integer_number (next_column));
+    region_obj->set_integer ("endColumn", next_column);
   }
 
   return region_obj;
@@ -1001,11 +996,11 @@ sarif_builder::maybe_make_region_object_for_context (location_t loc) const
   json::object *region_obj = new json::object ();
 
   /* "startLine" property (SARIF v2.1.0 section 3.30.5) */
-  region_obj->set ("startLine", new json::integer_number (exploc_start.line));
+  region_obj->set_integer ("startLine", exploc_start.line);
 
   /* "endLine" property (SARIF v2.1.0 section 3.30.7) */
   if (exploc_finish.line != exploc_start.line)
-    region_obj->set ("endLine", new json::integer_number (exploc_finish.line));
+    region_obj->set_integer ("endLine", exploc_finish.line);
 
   /* "snippet" property (SARIF v2.1.0 section 3.30.13).  */
   if (json::object *artifact_content_obj
@@ -1032,21 +1027,20 @@ sarif_builder::make_region_object_for_hint (const fixit_hint &hint) const
   json::object *region_obj = new json::object ();
 
   /* "startLine" property (SARIF v2.1.0 section 3.30.5) */
-  region_obj->set ("startLine", new json::integer_number (exploc_start.line));
+  region_obj->set_integer ("startLine", exploc_start.line);
 
   /* "startColumn" property (SARIF v2.1.0 section 3.30.6) */
   int start_col = get_sarif_column (exploc_start);
-  region_obj->set ("startColumn",
-		   new json::integer_number (start_col));
+  region_obj->set_integer ("startColumn", start_col);
 
   /* "endLine" property (SARIF v2.1.0 section 3.30.7) */
   if (exploc_next.line != exploc_start.line)
-    region_obj->set ("endLine", new json::integer_number (exploc_next.line));
+    region_obj->set_integer ("endLine", exploc_next.line);
 
   /* "endColumn" property (SARIF v2.1.0 section 3.30.8).
      This expresses the column immediately beyond the range.  */
   int next_col =  get_sarif_column (exploc_next);
-  region_obj->set ("endColumn", new json::integer_number (next_col));
+  region_obj->set_integer ("endColumn", next_col);
 
   return region_obj;
 }
@@ -1095,21 +1089,20 @@ make_logical_location_object (const logical_location &logical_loc) const
 
   /* "name" property (SARIF v2.1.0 section 3.33.4).  */
   if (const char *short_name = logical_loc.get_short_name ())
-    logical_loc_obj->set ("name", new json::string (short_name));
+    logical_loc_obj->set_string ("name", short_name);
 
   /* "fullyQualifiedName" property (SARIF v2.1.0 section 3.33.5).  */
   if (const char *name_with_scope = logical_loc.get_name_with_scope ())
-    logical_loc_obj->set ("fullyQualifiedName",
-			  new json::string (name_with_scope));
+    logical_loc_obj->set_string ("fullyQualifiedName", name_with_scope);
 
   /* "decoratedName" property (SARIF v2.1.0 section 3.33.6).  */
   if (const char *internal_name = logical_loc.get_internal_name ())
-    logical_loc_obj->set ("decoratedName", new json::string (internal_name));
+    logical_loc_obj->set_string ("decoratedName", internal_name);
 
   /* "kind" property (SARIF v2.1.0 section 3.33.7).  */
   enum logical_location_kind kind = logical_loc.get_kind ();
   if (const char *sarif_kind_str = maybe_get_sarif_kind (kind))
-    logical_loc_obj->set ("kind", new json::string (sarif_kind_str));
+    logical_loc_obj->set_string ("kind", sarif_kind_str);
 
   return logical_loc_obj;
 }
@@ -1172,13 +1165,11 @@ sarif_builder::make_thread_flow_location_object (const diagnostic_event &ev,
     thread_flow_loc_obj->set ("kinds", kinds_arr);
 
   /* "nestingLevel" property (SARIF v2.1.0 section 3.38.10).  */
-  thread_flow_loc_obj->set ("nestingLevel",
-			    new json::integer_number (ev.get_stack_depth ()));
+  thread_flow_loc_obj->set_integer ("nestingLevel", ev.get_stack_depth ());
 
   /* "executionOrder" property (SARIF v2.1.0 3.38.11).
      Offset by 1 to match the human-readable values emitted by %@.  */
-  thread_flow_loc_obj->set ("executionOrder",
-			    new json::integer_number (path_event_idx + 1));
+  thread_flow_loc_obj->set_integer ("executionOrder", path_event_idx + 1);
 
   /* It might be nice to eventually implement the following for -fanalyzer:
      - the "stack" property (SARIF v2.1.0 section 3.38.5)
@@ -1222,7 +1213,7 @@ sarif_builder::make_message_object (const char *msg) const
   json::object *message_obj = new json::object ();
 
   /* "text" property (SARIF v2.1.0 section 3.11.8).  */
-  message_obj->set ("text", new json::string (msg));
+  message_obj->set_string ("text", msg);
 
   return message_obj;
 }
@@ -1238,7 +1229,7 @@ sarif_builder::make_message_object_for_diagram (diagnostic_context *context,
   json::object *message_obj = new json::object ();
 
   /* "text" property (SARIF v2.1.0 section 3.11.8).  */
-  message_obj->set ("text", new json::string (diagram.get_alt_text ()));
+  message_obj->set_string ("text", diagram.get_alt_text ());
 
   char *saved_prefix = pp_take_prefix (context->printer);
   pp_set_prefix (context->printer, NULL);
@@ -1250,8 +1241,7 @@ sarif_builder::make_message_object_for_diagram (diagnostic_context *context,
   pp_set_prefix (context->printer, saved_prefix);
 
   /* "markdown" property (SARIF v2.1.0 section 3.11.9).  */
-  message_obj->set ("markdown",
-		    new json::string (pp_formatted_text (context->printer)));
+  message_obj->set_string ("markdown", pp_formatted_text (context->printer));
 
   pp_clear_output_area (context->printer);
 
@@ -1267,7 +1257,7 @@ sarif_builder::make_multiformat_message_string (const char *msg) const
   json::object *message_obj = new json::object ();
 
   /* "text" property (SARIF v2.1.0 section 3.12.3).  */
-  message_obj->set ("text", new json::string (msg));
+  message_obj->set_string ("text", msg);
 
   return message_obj;
 }
@@ -1285,10 +1275,10 @@ sarif_builder::make_top_level_object (sarif_invocation *invocation_obj,
   json::object *log_obj = new json::object ();
 
   /* "$schema" property (SARIF v2.1.0 section 3.13.3) .  */
-  log_obj->set ("$schema", new json::string (SARIF_SCHEMA));
+  log_obj->set_string ("$schema", SARIF_SCHEMA);
 
   /* "version" property (SARIF v2.1.0 section 3.13.2).  */
-  log_obj->set ("version", new json::string (SARIF_VERSION));
+  log_obj->set_string ("version", SARIF_VERSION);
 
   /* "runs" property (SARIF v2.1.0 section 3.13.4).  */
   json::array *run_arr = new json::array ();
@@ -1376,15 +1366,15 @@ sarif_builder::make_tool_object () const
 
 	    /* "name" property (SARIF v2.1.0 section 3.19.8).  */
 	    if (const char *short_name = p.get_short_name ())
-	      plugin_obj->set ("name", new json::string (short_name));
+	      plugin_obj->set_string ("name", short_name);
 
 	    /* "fullName" property (SARIF v2.1.0 section 3.19.9).  */
 	    if (const char *full_name = p.get_full_name ())
-	      plugin_obj->set ("fullName", new json::string (full_name));
+	      plugin_obj->set_string ("fullName", full_name);
 
 	    /* "version" property (SARIF v2.1.0 section 3.19.13).  */
 	    if (const char *version = p.get_version ())
-	      plugin_obj->set ("version", new json::string (version));
+	      plugin_obj->set_string ("version", version);
 	  }
 	  auto_vec <json::object *> m_plugin_objs;
 	};
@@ -1419,23 +1409,23 @@ sarif_builder::make_driver_tool_component_object () const
       {
 	/* "name" property (SARIF v2.1.0 section 3.19.8).  */
 	if (const char *name = vinfo->get_tool_name ())
-	  driver_obj->set ("name", new json::string (name));
+	  driver_obj->set_string ("name", name);
 
 	/* "fullName" property (SARIF v2.1.0 section 3.19.9).  */
 	if (char *full_name = vinfo->maybe_make_full_name ())
 	  {
-	    driver_obj->set ("fullName", new json::string (full_name));
+	    driver_obj->set_string ("fullName", full_name);
 	    free (full_name);
 	  }
 
 	/* "version" property (SARIF v2.1.0 section 3.19.13).  */
 	if (const char *version = vinfo->get_version_string ())
-	  driver_obj->set ("version", new json::string (version));
+	  driver_obj->set_string ("version", version);
 
 	/* "informationUri" property (SARIF v2.1.0 section 3.19.17).  */
 	if (char *version_url =  vinfo->maybe_make_version_url ())
 	  {
-	    driver_obj->set ("informationUri", new json::string (version_url));
+	    driver_obj->set_string ("informationUri", version_url);
 	    free (version_url);
 	  }
       }
@@ -1480,13 +1470,13 @@ sarif_builder::maybe_make_cwe_taxonomy_object () const
   json::object *taxonomy_obj = new json::object ();
 
   /* "name" property (SARIF v2.1.0 section 3.19.8).  */
-  taxonomy_obj->set ("name", new json::string ("CWE"));
+  taxonomy_obj->set_string ("name", "CWE");
 
   /* "version" property (SARIF v2.1.0 section 3.19.13).  */
-  taxonomy_obj->set ("version", new json::string ("4.7"));
+  taxonomy_obj->set_string ("version", "4.7");
 
   /* "organization" property (SARIF v2.1.0 section 3.19.18).  */
-  taxonomy_obj->set ("organization", new json::string ("MITRE"));
+  taxonomy_obj->set_string ("organization", "MITRE");
 
   /* "shortDescription" property (SARIF v2.1.0 section 3.19.19).  */
   json::object *short_desc
@@ -1527,7 +1517,7 @@ sarif_builder::make_artifact_object (const char *filename)
   if (auto client_data_hooks = m_context->get_client_data_hooks ())
     if (const char *source_lang
 	= client_data_hooks->maybe_get_sarif_source_language (filename))
-      artifact_obj->set ("sourceLanguage", new json::string (source_lang));
+      artifact_obj->set_string ("sourceLanguage", source_lang);
 
   return artifact_obj;
 }
@@ -1540,7 +1530,7 @@ sarif_builder::maybe_make_artifact_content_object (const char *filename) const
 {
   /* Let input.cc handle any charset conversion.  */
   char_span utf8_content
-    = m_context->get_file_cache ()->get_source_file_content (filename);
+    = m_context->get_file_cache ().get_source_file_content (filename);
   if (!utf8_content)
     return NULL;
 
@@ -1568,7 +1558,7 @@ sarif_builder::get_source_lines (const char *filename,
   for (int line = start_line; line <= end_line; line++)
     {
       char_span line_content
-	= m_context->get_file_cache ()->get_source_line (filename, line);
+	= m_context->get_file_cache ().get_source_line (filename, line);
       if (!line_content.get_buffer ())
 	return NULL;
       result.reserve (line_content.length () + 1);
@@ -1602,7 +1592,7 @@ sarif_builder::maybe_make_artifact_content_object (const char *filename,
     }
 
   json::object *artifact_content_obj = new json::object ();
-  artifact_content_obj->set ("text", new json::string (text_utf8));
+  artifact_content_obj->set_string ("text", text_utf8);
   free (text_utf8);
 
   return artifact_content_obj;
@@ -1676,7 +1666,7 @@ sarif_builder::make_artifact_content_object (const char *text) const
   json::object *content_obj = new json::object ();
 
   /* "text" property (SARIF v2.1.0 section 3.3.2).  */
-  content_obj->set ("text", new json::string (text));
+  content_obj->set_string ("text", text);
 
   return content_obj;
 }
diff --git a/gcc/diagnostic-show-locus.cc b/gcc/diagnostic-show-locus.cc
index 5edc319..563d282 100644
--- a/gcc/diagnostic-show-locus.cc
+++ b/gcc/diagnostic-show-locus.cc
@@ -175,11 +175,12 @@ enum column_unit {
 class exploc_with_display_col : public expanded_location
 {
  public:
-  exploc_with_display_col (const expanded_location &exploc,
+  exploc_with_display_col (file_cache &fc,
+			   const expanded_location &exploc,
 			   const cpp_char_column_policy &policy,
 			   enum location_aspect aspect)
   : expanded_location (exploc),
-    m_display_col (location_compute_display_column (exploc, policy))
+    m_display_col (location_compute_display_column (fc, exploc, policy))
   {
     if (exploc.column > 0)
       {
@@ -190,7 +191,7 @@ class exploc_with_display_col : public expanded_location
 	    expanded_location prev_exploc (exploc);
 	    prev_exploc.column--;
 	    int prev_display_col
-	      = (location_compute_display_column (prev_exploc, policy));
+	      = (location_compute_display_column (fc, prev_exploc, policy));
 	    m_display_col = prev_display_col + 1;
 	  }
       }
@@ -432,6 +433,7 @@ class layout
 
   const diagnostic_source_printing_options &m_options;
   const line_maps *m_line_table;
+  file_cache &m_file_cache;
   pretty_printer *m_pp;
   char_display_policy m_policy;
   location_t m_primary_loc;
@@ -707,18 +709,22 @@ static cpp_char_column_policy def_policy ()
    e.g. in test_diagnostic_show_locus_one_liner_utf8().  */
 
 static layout_range
-make_range (int start_line, int start_col, int end_line, int end_col)
+make_range (file_cache &fc,
+	    int start_line, int start_col, int end_line, int end_col)
 {
   const expanded_location start_exploc
     = {"", start_line, start_col, NULL, false};
   const expanded_location finish_exploc
     = {"", end_line, end_col, NULL, false};
-  return layout_range (exploc_with_display_col (start_exploc, def_policy (),
+  return layout_range (exploc_with_display_col (fc,
+						start_exploc, def_policy (),
 						LOCATION_ASPECT_START),
-		       exploc_with_display_col (finish_exploc, def_policy (),
+		       exploc_with_display_col (fc,
+						finish_exploc, def_policy (),
 						LOCATION_ASPECT_FINISH),
 		       SHOW_RANGE_WITHOUT_CARET,
-		       exploc_with_display_col (start_exploc, def_policy (),
+		       exploc_with_display_col (fc,
+						start_exploc, def_policy (),
 						LOCATION_ASPECT_CARET),
 		       0, NULL);
 }
@@ -732,7 +738,8 @@ make_range (int start_line, int start_col, int end_line, int end_col)
 static void
 test_layout_range_for_single_point ()
 {
-  layout_range point = make_range (7, 10, 7, 10);
+  file_cache fc;
+  layout_range point = make_range (fc, 7, 10, 7, 10);
 
   /* Tests for layout_range::contains_point.  */
 
@@ -768,7 +775,8 @@ test_layout_range_for_single_point ()
 static void
 test_layout_range_for_single_line ()
 {
-  layout_range example_a = make_range (2, 22, 2, 38);
+  file_cache fc;
+  layout_range example_a = make_range (fc, 2, 22, 2, 38);
 
   /* Tests for layout_range::contains_point.  */
 
@@ -810,7 +818,8 @@ test_layout_range_for_single_line ()
 static void
 test_layout_range_for_multiple_lines ()
 {
-  layout_range example_b = make_range (3, 14, 5, 8);
+  file_cache fc;
+  layout_range example_b = make_range (fc, 3, 14, 5, 8);
 
   /* Tests for layout_range::contains_point.  */
 
@@ -1188,10 +1197,12 @@ layout::layout (const diagnostic_context &context,
 		pretty_printer *pp)
 : m_options (context.m_source_printing),
   m_line_table (richloc.get_line_table ()),
+  m_file_cache (context.get_file_cache ()),
   m_pp (pp ? pp : context.printer),
   m_policy (make_policy (context, richloc)),
   m_primary_loc (richloc.get_range (0)->m_loc),
-  m_exploc (richloc.get_expanded_location (0), m_policy,
+  m_exploc (m_file_cache,
+	    richloc.get_expanded_location (0), m_policy,
 	    LOCATION_ASPECT_CARET),
   m_colorizer (m_pp, diagnostic_kind),
   m_diagnostic_path_p (diagnostic_kind == DK_DIAGNOSTIC_PATH),
@@ -1286,12 +1297,15 @@ layout::maybe_add_location_range (const location_range *loc_range,
 
   /* Everything is now known to be in the correct source file,
      but it may require further sanitization.  */
-  layout_range ri (exploc_with_display_col (start, m_policy,
+  layout_range ri (exploc_with_display_col (m_file_cache,
+					    start, m_policy,
 					    LOCATION_ASPECT_START),
-		   exploc_with_display_col (finish, m_policy,
+		   exploc_with_display_col (m_file_cache,
+					    finish, m_policy,
 					    LOCATION_ASPECT_FINISH),
 		   loc_range->m_range_display_kind,
-		   exploc_with_display_col (caret, m_policy,
+		   exploc_with_display_col (m_file_cache,
+					    caret, m_policy,
 					    LOCATION_ASPECT_CARET),
 		   original_idx, loc_range->m_label);
 
@@ -1614,8 +1628,8 @@ layout::calculate_x_offset_display ()
       return;
     }
 
-  const char_span line = location_get_source_line (m_exploc.file,
-						   m_exploc.line);
+  const char_span line = m_file_cache.get_source_line (m_exploc.file,
+						       m_exploc.line);
   if (!line)
     {
       /* Nothing to do, we couldn't find the source line.  */
@@ -2252,7 +2266,8 @@ public:
 
 /* Get the range of bytes or display columns that HINT would affect.  */
 static column_range
-get_affected_range (const cpp_char_column_policy &policy,
+get_affected_range (file_cache &fc,
+		    const cpp_char_column_policy &policy,
 		    const fixit_hint *hint, enum column_unit col_unit)
 {
   expanded_location exploc_start = expand_location (hint->get_start_loc ());
@@ -2263,11 +2278,12 @@ get_affected_range (const cpp_char_column_policy &policy,
   int finish_column;
   if (col_unit == CU_DISPLAY_COLS)
     {
-      start_column = location_compute_display_column (exploc_start, policy);
+      start_column = location_compute_display_column (fc, exploc_start, policy);
       if (hint->insertion_p ())
 	finish_column = start_column - 1;
       else
-	finish_column = location_compute_display_column (exploc_finish, policy);
+	finish_column
+	  = location_compute_display_column (fc, exploc_finish, policy);
     }
   else
     {
@@ -2280,11 +2296,12 @@ get_affected_range (const cpp_char_column_policy &policy,
 /* Get the range of display columns that would be printed for HINT.  */
 
 static column_range
-get_printed_columns (const cpp_char_column_policy &policy,
+get_printed_columns (file_cache &fc,
+		     const cpp_char_column_policy &policy,
 		     const fixit_hint *hint)
 {
   expanded_location exploc = expand_location (hint->get_start_loc ());
-  int start_column = location_compute_display_column (exploc, policy);
+  int start_column = location_compute_display_column (fc, exploc, policy);
   int hint_width = cpp_display_width (hint->get_string (), hint->get_length (),
 				      policy);
   int final_hint_column = start_column + hint_width - 1;
@@ -2296,7 +2313,7 @@ get_printed_columns (const cpp_char_column_policy &policy,
     {
       exploc = expand_location (hint->get_next_loc ());
       --exploc.column;
-      int finish_column = location_compute_display_column (exploc, policy);
+      int finish_column = location_compute_display_column (fc, exploc, policy);
       return column_range (start_column,
 			   MAX (finish_column, final_hint_column));
     }
@@ -2402,15 +2419,18 @@ correction::ensure_terminated ()
 class line_corrections
 {
 public:
-  line_corrections (const char_display_policy &policy,
+  line_corrections (file_cache &fc,
+		    const char_display_policy &policy,
 		    const char *filename,
 		    linenum_type row)
-  : m_policy (policy), m_filename (filename), m_row (row)
+  : m_file_cache (fc),
+    m_policy (policy), m_filename (filename), m_row (row)
   {}
   ~line_corrections ();
 
   void add_hint (const fixit_hint *hint);
 
+  file_cache &m_file_cache;
   const char_display_policy &m_policy;
   const char *m_filename;
   linenum_type m_row;
@@ -2433,7 +2453,7 @@ line_corrections::~line_corrections ()
 class source_line
 {
 public:
-  source_line (const char *filename, int line);
+  source_line (file_cache &fc, const char *filename, int line);
 
   char_span as_span () { return char_span (chars, width); }
 
@@ -2443,9 +2463,9 @@ public:
 
 /* source_line's ctor.  */
 
-source_line::source_line (const char *filename, int line)
+source_line::source_line (file_cache &fc, const char *filename, int line)
 {
-  char_span span = location_get_source_line (filename, line);
+  char_span span = fc.get_source_line (filename, line);
   chars = span.get_buffer ();
   width = span.length ();
 }
@@ -2457,10 +2477,12 @@ source_line::source_line (const char *filename, int line)
 void
 line_corrections::add_hint (const fixit_hint *hint)
 {
-  column_range affected_bytes = get_affected_range (m_policy, hint, CU_BYTES);
-  column_range affected_columns = get_affected_range (m_policy, hint,
-						      CU_DISPLAY_COLS);
-  column_range printed_columns = get_printed_columns (m_policy, hint);
+  column_range affected_bytes
+    = get_affected_range (m_file_cache, m_policy, hint, CU_BYTES);
+  column_range affected_columns
+    = get_affected_range (m_file_cache, m_policy, hint, CU_DISPLAY_COLS);
+  column_range printed_columns
+    = get_printed_columns (m_file_cache, m_policy, hint);
 
   /* Potentially consolidate.  */
   if (!m_corrections.is_empty ())
@@ -2489,7 +2511,7 @@ line_corrections::add_hint (const fixit_hint *hint)
 				affected_bytes.start - 1);
 
 	  /* Try to read the source.  */
-	  source_line line (m_filename, m_row);
+	  source_line line (m_file_cache, m_filename, m_row);
 	  if (line.chars && between.finish < line.width)
 	    {
 	      /* Consolidate into the last correction:
@@ -2545,7 +2567,7 @@ layout::print_trailing_fixits (linenum_type row)
 {
   /* Build a list of correction instances for the line,
      potentially consolidating hints (for the sake of readability).  */
-  line_corrections corrections (m_policy, m_exploc.file, row);
+  line_corrections corrections (m_file_cache, m_policy, m_exploc.file, row);
   for (unsigned int i = 0; i < m_fixit_hints.length (); i++)
     {
       const fixit_hint *hint = m_fixit_hints[i];
@@ -2783,7 +2805,7 @@ layout::show_ruler (int max_column) const
 void
 layout::print_line (linenum_type row)
 {
-  char_span line = location_get_source_line (m_exploc.file, row);
+  char_span line = m_file_cache.get_source_line (m_exploc.file, row);
   if (!line)
     return;
 
@@ -2882,7 +2904,7 @@ diagnostic_context::show_locus (const rich_location &richloc,
 	    {
 	      expanded_location exploc
 		= layout.get_expanded_location (line_span);
-	      m_text_callbacks.start_span (this, exploc);
+	      m_text_callbacks.m_start_span (this, exploc);
 	    }
 	}
       /* Iterate over the lines within this span (using linenum_arith_t to
@@ -3005,6 +3027,7 @@ test_layout_x_offset_display_utf8 (const line_table_case &case_)
   const int emoji_col = 102;
 
   temp_source_file tmp (SELFTEST_LOCATION, ".c", content);
+  file_cache fc;
   line_table_test ltt (case_);
 
   linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 1);
@@ -3019,12 +3042,13 @@ test_layout_x_offset_display_utf8 (const line_table_case &case_)
   ASSERT_EQ (1, LOCATION_LINE (line_end));
   ASSERT_EQ (line_bytes, LOCATION_COLUMN (line_end));
 
-  char_span lspan = location_get_source_line (tmp.get_filename (), 1);
+  char_span lspan = fc.get_source_line (tmp.get_filename (), 1);
   ASSERT_EQ (line_display_cols,
 	     cpp_display_width (lspan.get_buffer (), lspan.length (),
 				def_policy ()));
   ASSERT_EQ (line_display_cols,
-	     location_compute_display_column (expand_location (line_end),
+	     location_compute_display_column (fc,
+					      expand_location (line_end),
 					      def_policy ()));
   ASSERT_EQ (0, memcmp (lspan.get_buffer () + (emoji_col - 1),
 			"\xf0\x9f\x98\x82\xf0\x9f\x98\x82", 8));
@@ -3160,6 +3184,7 @@ test_layout_x_offset_display_tab (const line_table_case &case_)
   ASSERT_EQ (7, extra_width[10]);
 
   temp_source_file tmp (SELFTEST_LOCATION, ".c", content);
+  file_cache fc;
   line_table_test ltt (case_);
 
   linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 1);
@@ -3171,7 +3196,7 @@ test_layout_x_offset_display_tab (const line_table_case &case_)
     return;
 
   /* Check that cpp_display_width handles the tabs as expected.  */
-  char_span lspan = location_get_source_line (tmp.get_filename (), 1);
+  char_span lspan = fc.get_source_line (tmp.get_filename (), 1);
   ASSERT_EQ ('\t', *(lspan.get_buffer () + (tab_col - 1)));
   for (int tabstop = 1; tabstop != num_tabstops; ++tabstop)
     {
@@ -3180,7 +3205,8 @@ test_layout_x_offset_display_tab (const line_table_case &case_)
 		 cpp_display_width (lspan.get_buffer (), lspan.length (),
 				    policy));
       ASSERT_EQ (line_bytes + extra_width[tabstop],
-		 location_compute_display_column (expand_location (line_end),
+		 location_compute_display_column (fc,
+						  expand_location (line_end),
 						  policy));
     }
 
@@ -4389,6 +4415,7 @@ test_diagnostic_show_locus_one_liner_utf8 (const line_table_case &case_)
        1111222233334444567890122223333456789999000011112222345678999900001
        Byte columns.  */
   temp_source_file tmp (SELFTEST_LOCATION, ".c", content);
+  file_cache fc;
   line_table_test ltt (case_);
 
   linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 1);
@@ -4403,10 +4430,11 @@ test_diagnostic_show_locus_one_liner_utf8 (const line_table_case &case_)
   ASSERT_EQ (1, LOCATION_LINE (line_end));
   ASSERT_EQ (31, LOCATION_COLUMN (line_end));
 
-  char_span lspan = location_get_source_line (tmp.get_filename (), 1);
+  char_span lspan = fc.get_source_line (tmp.get_filename (), 1);
   ASSERT_EQ (25, cpp_display_width (lspan.get_buffer (), lspan.length (),
 				    def_policy ()));
-  ASSERT_EQ (25, location_compute_display_column (expand_location (line_end),
+  ASSERT_EQ (25, location_compute_display_column (fc,
+						  expand_location (line_end),
 						  def_policy ()));
 
   test_one_liner_simple_caret_utf8 ();
@@ -4440,7 +4468,12 @@ test_add_location_if_nearby (const line_table_case &case_)
        "  double x;\n"                              /* line 4.  */
        "  double y;\n"                              /* line 5.  */
        ";\n");                                      /* line 6.  */
-  temp_source_file tmp (SELFTEST_LOCATION, ".c", content);
+  temp_source_file tmp (SELFTEST_LOCATION, ".c", content,
+
+			/* gcc_rich_location::add_location_if_nearby implicitly
+			   uses global_dc's file_cache, so we need to evict
+			   tmp when we're done.  */
+			&global_dc->get_file_cache ());
   line_table_test ltt (case_);
 
   const line_map_ordinary *ord_map
@@ -4748,6 +4781,7 @@ test_overlapped_fixit_printing (const line_table_case &case_)
   const char *content
     = ("  foo *f = (foo *)ptr->field;\n");
   temp_source_file tmp (SELFTEST_LOCATION, ".C", content);
+  file_cache fc;
   line_table_test ltt (case_);
 
   const line_map_ordinary *ord_map
@@ -4797,27 +4831,27 @@ test_overlapped_fixit_printing (const line_table_case &case_)
     ASSERT_EQ (3, richloc.get_num_fixit_hints ());
     const fixit_hint *hint_0 = richloc.get_fixit_hint (0);
     ASSERT_EQ (column_range (12, 12),
-	       get_affected_range (policy, hint_0, CU_BYTES));
+	       get_affected_range (fc, policy, hint_0, CU_BYTES));
     ASSERT_EQ (column_range (12, 12),
-	       get_affected_range (policy, hint_0, CU_DISPLAY_COLS));
-    ASSERT_EQ (column_range (12, 22), get_printed_columns (policy, hint_0));
+	       get_affected_range (fc, policy, hint_0, CU_DISPLAY_COLS));
+    ASSERT_EQ (column_range (12, 22), get_printed_columns (fc, policy, hint_0));
     const fixit_hint *hint_1 = richloc.get_fixit_hint (1);
     ASSERT_EQ (column_range (18, 18),
-	       get_affected_range (policy, hint_1, CU_BYTES));
+	       get_affected_range (fc, policy, hint_1, CU_BYTES));
     ASSERT_EQ (column_range (18, 18),
-	       get_affected_range (policy, hint_1, CU_DISPLAY_COLS));
-    ASSERT_EQ (column_range (18, 20), get_printed_columns (policy, hint_1));
+	       get_affected_range (fc, policy, hint_1, CU_DISPLAY_COLS));
+    ASSERT_EQ (column_range (18, 20), get_printed_columns (fc, policy, hint_1));
     const fixit_hint *hint_2 = richloc.get_fixit_hint (2);
     ASSERT_EQ (column_range (29, 28),
-	       get_affected_range (policy, hint_2, CU_BYTES));
+	       get_affected_range (fc, policy, hint_2, CU_BYTES));
     ASSERT_EQ (column_range (29, 28),
-	       get_affected_range (policy, hint_2, CU_DISPLAY_COLS));
-    ASSERT_EQ (column_range (29, 29), get_printed_columns (policy, hint_2));
+	       get_affected_range (fc, policy, hint_2, CU_DISPLAY_COLS));
+    ASSERT_EQ (column_range (29, 29), get_printed_columns (fc, policy, hint_2));
 
     /* Add each hint in turn to a line_corrections instance,
        and verify that they are consolidated into one correction instance
        as expected.  */
-    line_corrections lc (policy, tmp.get_filename (), 1);
+    line_corrections lc (fc, policy, tmp.get_filename (), 1);
 
     /* The first replace hint by itself.  */
     lc.add_hint (hint_0);
@@ -4991,6 +5025,7 @@ test_overlapped_fixit_printing_utf8 (const line_table_case &case_)
   /* Example where 3 fix-it hints are printed as one.  */
   {
     test_diagnostic_context dc;
+    file_cache &fc = dc.get_file_cache ();
     rich_location richloc (line_table, expr);
     richloc.add_fixit_replace (open_paren, "const_cast<");
     richloc.add_fixit_replace (close_paren, "> (");
@@ -5013,27 +5048,27 @@ test_overlapped_fixit_printing_utf8 (const line_table_case &case_)
     ASSERT_EQ (3, richloc.get_num_fixit_hints ());
     const fixit_hint *hint_0 = richloc.get_fixit_hint (0);
     ASSERT_EQ (column_range (14, 14),
-	       get_affected_range (policy, hint_0, CU_BYTES));
+	       get_affected_range (fc, policy, hint_0, CU_BYTES));
     ASSERT_EQ (column_range (12, 12),
-	       get_affected_range (policy, hint_0, CU_DISPLAY_COLS));
-    ASSERT_EQ (column_range (12, 22), get_printed_columns (policy, hint_0));
+	       get_affected_range (fc, policy, hint_0, CU_DISPLAY_COLS));
+    ASSERT_EQ (column_range (12, 22), get_printed_columns (fc, policy, hint_0));
     const fixit_hint *hint_1 = richloc.get_fixit_hint (1);
     ASSERT_EQ (column_range (22, 22),
-	       get_affected_range (policy, hint_1, CU_BYTES));
+	       get_affected_range (fc, policy, hint_1, CU_BYTES));
     ASSERT_EQ (column_range (18, 18),
-	       get_affected_range (policy, hint_1, CU_DISPLAY_COLS));
-    ASSERT_EQ (column_range (18, 20), get_printed_columns (policy, hint_1));
+	       get_affected_range (fc, policy, hint_1, CU_DISPLAY_COLS));
+    ASSERT_EQ (column_range (18, 20), get_printed_columns (fc, policy, hint_1));
     const fixit_hint *hint_2 = richloc.get_fixit_hint (2);
     ASSERT_EQ (column_range (35, 34),
-	       get_affected_range (policy, hint_2, CU_BYTES));
+	       get_affected_range (fc, policy, hint_2, CU_BYTES));
     ASSERT_EQ (column_range (30, 29),
-	       get_affected_range (policy, hint_2, CU_DISPLAY_COLS));
-    ASSERT_EQ (column_range (30, 30), get_printed_columns (policy, hint_2));
+	       get_affected_range (fc, policy, hint_2, CU_DISPLAY_COLS));
+    ASSERT_EQ (column_range (30, 30), get_printed_columns (fc, policy, hint_2));
 
     /* Add each hint in turn to a line_corrections instance,
        and verify that they are consolidated into one correction instance
        as expected.  */
-    line_corrections lc (policy, tmp.get_filename (), 1);
+    line_corrections lc (fc, policy, tmp.get_filename (), 1);
 
     /* The first replace hint by itself.  */
     lc.add_hint (hint_0);
@@ -5221,6 +5256,7 @@ test_overlapped_fixit_printing_2 (const line_table_case &case_)
   /* Two insertions, in the wrong order.  */
   {
     test_diagnostic_context dc;
+    file_cache &fc = dc.get_file_cache ();
 
     rich_location richloc (line_table, col_20);
     richloc.add_fixit_insert_before (col_23, "{");
@@ -5231,12 +5267,12 @@ test_overlapped_fixit_printing_2 (const line_table_case &case_)
     ASSERT_EQ (2, richloc.get_num_fixit_hints ());
     const fixit_hint *hint_0 = richloc.get_fixit_hint (0);
     ASSERT_EQ (column_range (23, 22),
-	       get_affected_range (policy, hint_0, CU_BYTES));
-    ASSERT_EQ (column_range (23, 23), get_printed_columns (policy, hint_0));
+	       get_affected_range (fc, policy, hint_0, CU_BYTES));
+    ASSERT_EQ (column_range (23, 23), get_printed_columns (fc, policy, hint_0));
     const fixit_hint *hint_1 = richloc.get_fixit_hint (1);
     ASSERT_EQ (column_range (21, 20),
-	       get_affected_range (policy, hint_1, CU_BYTES));
-    ASSERT_EQ (column_range (21, 21), get_printed_columns (policy, hint_1));
+	       get_affected_range (fc, policy, hint_1, CU_BYTES));
+    ASSERT_EQ (column_range (21, 21), get_printed_columns (fc, policy, hint_1));
 
     /* Verify that they're printed correctly.  */
     diagnostic_show_locus (&dc, &richloc, DK_ERROR);
diff --git a/gcc/diagnostic.cc b/gcc/diagnostic.cc
index addd660..b4ebcd2 100644
--- a/gcc/diagnostic.cc
+++ b/gcc/diagnostic.cc
@@ -211,7 +211,7 @@ diagnostic_context::initialize (int n_opts)
   this->printer = XNEW (pretty_printer);
   new (this->printer) pretty_printer ();
 
-  m_file_cache = nullptr;
+  m_file_cache = new file_cache ();
   memset (m_diagnostic_count, 0, sizeof m_diagnostic_count);
   m_warning_as_error_requested = false;
   m_n_opts = n_opts;
@@ -235,13 +235,13 @@ diagnostic_context::initialize (int n_opts)
   m_warn_system_headers = false;
   m_max_errors = 0;
   m_internal_error = nullptr;
-  m_text_callbacks.begin_diagnostic = default_diagnostic_starter;
-  m_text_callbacks.start_span = default_diagnostic_start_span_fn;
-  m_text_callbacks.end_diagnostic = default_diagnostic_finalizer;
-  m_option_enabled = nullptr;
-  m_option_state = nullptr;
-  m_option_name = nullptr;
-  m_get_option_url = nullptr;
+  m_text_callbacks.m_begin_diagnostic = default_diagnostic_starter;
+  m_text_callbacks.m_start_span = default_diagnostic_start_span_fn;
+  m_text_callbacks.m_end_diagnostic = default_diagnostic_finalizer;
+  m_option_callbacks.m_option_enabled_cb = nullptr;
+  m_option_callbacks.m_option_state = nullptr;
+  m_option_callbacks.m_make_option_name_cb = nullptr;
+  m_option_callbacks.m_make_option_url_cb = nullptr;
   m_urlifier = nullptr;
   m_last_location = UNKNOWN_LOCATION;
   m_last_module = nullptr;
@@ -352,8 +352,6 @@ diagnostic_context::
 initialize_input_context (diagnostic_input_charset_callback ccb,
 			  bool should_skip_bom)
 {
-  if (!m_file_cache)
-    m_file_cache = new file_cache;
   m_file_cache->initialize_input_context (ccb, should_skip_bom);
 }
 
@@ -421,6 +419,21 @@ diagnostic_context::set_client_data_hooks (diagnostic_client_data_hooks *hooks)
 }
 
 void
+diagnostic_context::
+set_option_hooks (diagnostic_option_enabled_cb option_enabled_cb,
+		  void *option_state,
+		  diagnostic_make_option_name_cb make_option_name_cb,
+		  diagnostic_make_option_url_cb make_option_url_cb,
+		  unsigned lang_mask)
+{
+  m_option_callbacks.m_option_enabled_cb = option_enabled_cb;
+  m_option_callbacks.m_option_state = option_state;
+  m_option_callbacks.m_make_option_name_cb = make_option_name_cb;
+  m_option_callbacks.m_make_option_url_cb = make_option_url_cb;
+  m_option_callbacks.m_lang_mask = lang_mask;
+}
+
+void
 diagnostic_context::set_urlifier (urlifier *urlifier)
 {
   /* Ideally we'd use a std::unique_ptr here.  */
@@ -432,7 +445,8 @@ void
 diagnostic_context::create_edit_context ()
 {
   delete m_edit_context_ptr;
-  m_edit_context_ptr = new edit_context ();
+  gcc_assert (m_file_cache);
+  m_edit_context_ptr = new edit_context (*m_file_cache);
 }
 
 /* Initialize DIAGNOSTIC, where the message MSG has already been
@@ -485,7 +499,8 @@ diagnostic_get_color_for_kind (diagnostic_t kind)
    Return -1 if the column is invalid (<= 0).  */
 
 static int
-convert_column_unit (enum diagnostics_column_unit column_unit,
+convert_column_unit (file_cache &fc,
+		     enum diagnostics_column_unit column_unit,
 		     int tabstop,
 		     expanded_location s)
 {
@@ -500,7 +515,7 @@ convert_column_unit (enum diagnostics_column_unit column_unit,
     case DIAGNOSTICS_COLUMN_UNIT_DISPLAY:
       {
 	cpp_char_column_policy policy (tabstop, cpp_wcwidth);
-	return location_compute_display_column (s, policy);
+	return location_compute_display_column (fc, s, policy);
       }
 
     case DIAGNOSTICS_COLUMN_UNIT_BYTE:
@@ -514,7 +529,8 @@ convert_column_unit (enum diagnostics_column_unit column_unit,
 int
 diagnostic_context::converted_column (expanded_location s) const
 {
-  int one_based_col = convert_column_unit (m_column_unit, m_tabstop, s);
+  int one_based_col = convert_column_unit (get_file_cache (),
+					   m_column_unit, m_tabstop, s);
   if (one_based_col <= 0)
     return -1;
   return one_based_col + (m_column_origin - 1);
@@ -1123,9 +1139,7 @@ classify_diagnostic (const diagnostic_context *context,
       /* Record the command-line status, so we can reset it back on DK_POP. */
       if (old_kind == DK_UNSPECIFIED)
 	{
-	  old_kind = !context->m_option_enabled (option_index,
-						 context->m_lang_mask,
-						 context->m_option_state)
+	  old_kind = !context->option_enabled_p (option_index)
 	    ? DK_IGNORED : (context->warning_as_error_requested_p ()
 			    ? DK_ERROR : DK_WARNING);
 	  m_classify_diagnostic[option_index] = old_kind;
@@ -1205,7 +1219,8 @@ print_escaped_string (pretty_printer *pp, const char *text)
    Use TABSTOP when handling DIAGNOSTICS_COLUMN_UNIT_DISPLAY.  */
 
 static void
-print_parseable_fixits (pretty_printer *pp, rich_location *richloc,
+print_parseable_fixits (file_cache &fc,
+			pretty_printer *pp, rich_location *richloc,
 			enum diagnostics_column_unit column_unit,
 			int tabstop)
 {
@@ -1226,9 +1241,9 @@ print_parseable_fixits (pretty_printer *pp, rich_location *richloc,
       location_t next_loc = hint->get_next_loc ();
       expanded_location next_exploc = expand_location (next_loc);
       int start_col
-	= convert_column_unit (column_unit, tabstop, start_exploc);
+	= convert_column_unit (fc, column_unit, tabstop, start_exploc);
       int next_col
-	= convert_column_unit (column_unit, tabstop, next_exploc);
+	= convert_column_unit (fc, column_unit, tabstop, next_exploc);
       pp_printf (pp, ":{%i:%i-%i:%i}:",
 		 start_exploc.line, start_col,
 		 next_exploc.line, next_col);
@@ -1410,18 +1425,12 @@ void
 diagnostic_context::print_option_information (const diagnostic_info &diagnostic,
 					      diagnostic_t orig_diag_kind)
 {
-  char *option_text;
-
-  option_text = m_option_name (this, diagnostic.option_index,
-			       orig_diag_kind, diagnostic.kind);
-
-  if (option_text)
+  if (char *option_text = make_option_name (diagnostic.option_index,
+					    orig_diag_kind, diagnostic.kind))
     {
-      char *option_url = NULL;
-      if (m_get_option_url
-	  && this->printer->url_format != URL_FORMAT_NONE)
-	option_url = m_get_option_url (this,
-				       diagnostic.option_index);
+      char *option_url = nullptr;
+      if (this->printer->url_format != URL_FORMAT_NONE)
+	option_url = make_option_url (diagnostic.option_index);
       pretty_printer * const pp = this->printer;
       pp_string (pp, " [");
       pp_string (pp, colorize_start (pp_show_color (pp),
@@ -1456,9 +1465,7 @@ diagnostic_context::diagnostic_enabled (diagnostic_info *diagnostic)
 
   /* This tests if the user provided the appropriate -Wfoo or
      -Wno-foo option.  */
-  if (! m_option_enabled (diagnostic->option_index,
-			  m_lang_mask,
-			  m_option_state))
+  if (!option_enabled_p (diagnostic->option_index))
     return false;
 
   /* This tests for #pragma diagnostic changes.  */
@@ -1613,13 +1620,15 @@ diagnostic_context::report_diagnostic (diagnostic_info *diagnostic)
     default:
       break;
     case EXTRA_DIAGNOSTIC_OUTPUT_fixits_v1:
-      print_parseable_fixits (this->printer, diagnostic->richloc,
+      print_parseable_fixits (get_file_cache (),
+			      this->printer, diagnostic->richloc,
 			      DIAGNOSTICS_COLUMN_UNIT_BYTE,
 			      m_tabstop);
       pp_flush (this->printer);
       break;
     case EXTRA_DIAGNOSTIC_OUTPUT_fixits_v2:
-      print_parseable_fixits (this->printer, diagnostic->richloc,
+      print_parseable_fixits (get_file_cache (),
+			      this->printer, diagnostic->richloc,
 			      DIAGNOSTICS_COLUMN_UNIT_DISPLAY,
 			      m_tabstop);
       pp_flush (this->printer);
@@ -2687,9 +2696,10 @@ static void
 test_print_parseable_fixits_none ()
 {
   pretty_printer pp;
+  file_cache fc;
   rich_location richloc (line_table, UNKNOWN_LOCATION);
 
-  print_parseable_fixits (&pp, &richloc, DIAGNOSTICS_COLUMN_UNIT_BYTE, 8);
+  print_parseable_fixits (fc, &pp, &richloc, DIAGNOSTICS_COLUMN_UNIT_BYTE, 8);
   ASSERT_STREQ ("", pp_formatted_text (&pp));
 }
 
@@ -2700,6 +2710,7 @@ static void
 test_print_parseable_fixits_insert ()
 {
   pretty_printer pp;
+  file_cache fc;
   rich_location richloc (line_table, UNKNOWN_LOCATION);
 
   linemap_add (line_table, LC_ENTER, false, "test.c", 0);
@@ -2708,7 +2719,7 @@ test_print_parseable_fixits_insert ()
   location_t where = linemap_position_for_column (line_table, 10);
   richloc.add_fixit_insert_before (where, "added content");
 
-  print_parseable_fixits (&pp, &richloc, DIAGNOSTICS_COLUMN_UNIT_BYTE, 8);
+  print_parseable_fixits (fc, &pp, &richloc, DIAGNOSTICS_COLUMN_UNIT_BYTE, 8);
   ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:10}:\"added content\"\n",
 		pp_formatted_text (&pp));
 }
@@ -2720,6 +2731,7 @@ static void
 test_print_parseable_fixits_remove ()
 {
   pretty_printer pp;
+  file_cache fc;
   rich_location richloc (line_table, UNKNOWN_LOCATION);
 
   linemap_add (line_table, LC_ENTER, false, "test.c", 0);
@@ -2730,7 +2742,7 @@ test_print_parseable_fixits_remove ()
   where.m_finish = linemap_position_for_column (line_table, 20);
   richloc.add_fixit_remove (where);
 
-  print_parseable_fixits (&pp, &richloc, DIAGNOSTICS_COLUMN_UNIT_BYTE, 8);
+  print_parseable_fixits (fc, &pp, &richloc, DIAGNOSTICS_COLUMN_UNIT_BYTE, 8);
   ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:21}:\"\"\n",
 		pp_formatted_text (&pp));
 }
@@ -2742,6 +2754,7 @@ static void
 test_print_parseable_fixits_replace ()
 {
   pretty_printer pp;
+  file_cache fc;
   rich_location richloc (line_table, UNKNOWN_LOCATION);
 
   linemap_add (line_table, LC_ENTER, false, "test.c", 0);
@@ -2752,7 +2765,7 @@ test_print_parseable_fixits_replace ()
   where.m_finish = linemap_position_for_column (line_table, 20);
   richloc.add_fixit_replace (where, "replacement");
 
-  print_parseable_fixits (&pp, &richloc, DIAGNOSTICS_COLUMN_UNIT_BYTE, 8);
+  print_parseable_fixits (fc, &pp, &richloc, DIAGNOSTICS_COLUMN_UNIT_BYTE, 8);
   ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:21}:\"replacement\"\n",
 		pp_formatted_text (&pp));
 }
@@ -2772,6 +2785,7 @@ test_print_parseable_fixits_bytes_vs_display_columns ()
   const int tabstop = 8;
 
   temp_source_file tmp (SELFTEST_LOCATION, ".c", content);
+  file_cache fc;
   const char *const fname = tmp.get_filename ();
 
   linemap_add (line_table, LC_ENTER, false, fname, 0);
@@ -2792,7 +2806,8 @@ test_print_parseable_fixits_bytes_vs_display_columns ()
 
   {
     pretty_printer pp;
-    print_parseable_fixits (&pp, &richloc, DIAGNOSTICS_COLUMN_UNIT_BYTE,
+    print_parseable_fixits (fc, &pp, &richloc,
+			    DIAGNOSTICS_COLUMN_UNIT_BYTE,
 			    tabstop);
     snprintf (expected, buf_len,
 	      "fix-it:%s:{1:12-1:18}:\"color\"\n", escaped_fname);
@@ -2800,7 +2815,8 @@ test_print_parseable_fixits_bytes_vs_display_columns ()
   }
   {
     pretty_printer pp;
-    print_parseable_fixits (&pp, &richloc, DIAGNOSTICS_COLUMN_UNIT_DISPLAY,
+    print_parseable_fixits (fc, &pp, &richloc,
+			    DIAGNOSTICS_COLUMN_UNIT_DISPLAY,
 			    tabstop);
     snprintf (expected, buf_len,
 	      "fix-it:%s:{1:10-1:16}:\"color\"\n", escaped_fname);
diff --git a/gcc/diagnostic.h b/gcc/diagnostic.h
index 6a32282..cbd2554 100644
--- a/gcc/diagnostic.h
+++ b/gcc/diagnostic.h
@@ -21,6 +21,7 @@ along with GCC; see the file COPYING3.  If not see
 #ifndef GCC_DIAGNOSTIC_H
 #define GCC_DIAGNOSTIC_H
 
+#include "rich-location.h"
 #include "pretty-print.h"
 #include "diagnostic-core.h"
 
@@ -179,6 +180,14 @@ typedef void (*diagnostic_finalizer_fn) (diagnostic_context *,
 					 diagnostic_info *,
 					 diagnostic_t);
 
+typedef int (*diagnostic_option_enabled_cb) (int, unsigned, void *);
+typedef char *(*diagnostic_make_option_name_cb) (const diagnostic_context *,
+						 int,
+						 diagnostic_t,
+						 diagnostic_t);
+typedef char *(*diagnostic_make_option_url_cb) (const diagnostic_context *,
+						int);
+
 class edit_context;
 namespace json { class value; }
 class diagnostic_client_data_hooks;
@@ -352,6 +361,14 @@ struct diagnostic_source_printing_options
 class diagnostic_context
 {
 public:
+  /* Give access to m_text_callbacks.  */
+  friend diagnostic_starter_fn &
+  diagnostic_starter (diagnostic_context *context);
+  friend diagnostic_start_span_fn &
+  diagnostic_start_span (diagnostic_context *context);
+  friend diagnostic_finalizer_fn &
+  diagnostic_finalizer (diagnostic_context *context);
+
   typedef void (*ice_handler_callback_t) (diagnostic_context *);
   typedef void (*set_locations_callback_t) (diagnostic_context *,
 					    diagnostic_info *);
@@ -360,8 +377,6 @@ public:
   void color_init (int value);
   void urls_init (int value);
 
-  void file_cache_init ();
-
   void finish ();
 
   void set_set_locations_callback (set_locations_callback_t cb)
@@ -461,10 +476,11 @@ public:
     return m_escape_format;
   }
 
-  file_cache *
+  file_cache &
   get_file_cache () const
   {
-    return m_file_cache;
+    gcc_assert (m_file_cache);
+    return *m_file_cache;
   }
 
   edit_context *get_edit_context () const
@@ -484,6 +500,47 @@ public:
     return m_diagnostic_count[kind];
   }
 
+  /* Option-related member functions.  */
+  inline bool option_enabled_p (int option_index) const
+  {
+    if (!m_option_callbacks.m_option_enabled_cb)
+      return true;
+    return m_option_callbacks.m_option_enabled_cb
+      (option_index,
+       m_option_callbacks.m_lang_mask,
+       m_option_callbacks.m_option_state);
+  }
+
+  inline char *make_option_name (int option_index,
+				diagnostic_t orig_diag_kind,
+				diagnostic_t diag_kind) const
+  {
+    if (!m_option_callbacks.m_make_option_name_cb)
+      return nullptr;
+    return m_option_callbacks.m_make_option_name_cb (this, option_index,
+						     orig_diag_kind,
+						     diag_kind);
+  }
+
+  inline char *make_option_url (int option_index) const
+  {
+    if (!m_option_callbacks.m_make_option_url_cb)
+      return nullptr;
+    return m_option_callbacks.m_make_option_url_cb (this, option_index);
+  }
+
+  void
+  set_option_hooks (diagnostic_option_enabled_cb option_enabled_cb,
+		    void *option_state,
+		    diagnostic_make_option_name_cb make_option_name_cb,
+		    diagnostic_make_option_url_cb make_option_url_cb,
+		    unsigned lang_mask);
+
+  unsigned get_lang_mask () const
+  {
+    return m_option_callbacks.m_lang_mask;
+  }
+
 private:
   bool includes_seen_p (const line_map_ordinary *map);
 
@@ -575,7 +632,6 @@ private:
   /* Maximum number of errors to report.  */
   int m_max_errors;
 
-public:
   /* Client-supplied callbacks for use in text output.  */
   struct {
     /* This function is called before any message is printed out.  It is
@@ -585,46 +641,50 @@ public:
        from "/home/gdr/src/nifty_printer.h:56:
        ...
     */
-    diagnostic_starter_fn begin_diagnostic;
+    diagnostic_starter_fn m_begin_diagnostic;
 
     /* This function is called by diagnostic_show_locus in between
        disjoint spans of source code, so that the context can print
        something to indicate that a new span of source code has begun.  */
-    diagnostic_start_span_fn start_span;
+    diagnostic_start_span_fn m_start_span;
 
     /* This function is called after the diagnostic message is printed.  */
-    diagnostic_finalizer_fn end_diagnostic;
+    diagnostic_finalizer_fn m_end_diagnostic;
   } m_text_callbacks;
 
+public:
   /* Client hook to report an internal error.  */
   void (*m_internal_error) (diagnostic_context *, const char *, va_list *);
 
-  /* Client hook to say whether the option controlling a diagnostic is
-     enabled.  Returns nonzero if enabled, zero if disabled.  */
-  int (*m_option_enabled) (int, unsigned, void *);
-
-  /* Client information to pass as second argument to
-     option_enabled.  */
-  void *m_option_state;
-
-  /* Client hook to return the name of an option that controls a
-     diagnostic.  Returns malloced memory.  The first diagnostic_t
-     argument is the kind of diagnostic before any reclassification
-     (of warnings as errors, etc.); the second is the kind after any
-     reclassification.  May return NULL if no name is to be printed.
-     May be passed 0 as well as the index of a particular option.  */
-  char *(*m_option_name) (diagnostic_context *,
-			  int,
-			  diagnostic_t,
-			  diagnostic_t);
-
-  /* Client hook to return a URL describing the option that controls
-     a diagnostic.  Returns malloced memory.  May return NULL if no URL
-     is available.  May be passed 0 as well as the index of a
-     particular option.  */
-  char *(*m_get_option_url) (diagnostic_context *, int);
-
 private:
+  /* Client-supplied callbacks for working with options.  */
+  struct {
+    /* Client hook to say whether the option controlling a diagnostic is
+       enabled.  Returns nonzero if enabled, zero if disabled.  */
+    diagnostic_option_enabled_cb m_option_enabled_cb;
+
+    /* Client information to pass as second argument to
+       m_option_enabled_cb.  */
+    void *m_option_state;
+
+    /* Client hook to return the name of an option that controls a
+       diagnostic.  Returns malloced memory.  The first diagnostic_t
+       argument is the kind of diagnostic before any reclassification
+       (of warnings as errors, etc.); the second is the kind after any
+       reclassification.  May return NULL if no name is to be printed.
+       May be passed 0 as well as the index of a particular option.  */
+    diagnostic_make_option_name_cb m_make_option_name_cb;
+
+    /* Client hook to return a URL describing the option that controls
+       a diagnostic.  Returns malloced memory.  May return NULL if no URL
+       is available.  May be passed 0 as well as the index of a
+       particular option.  */
+    diagnostic_make_option_url_cb m_make_option_url_cb;
+
+    /* A copy of lang_hooks.option_lang_mask ().  */
+    unsigned m_lang_mask;
+  } m_option_callbacks;
+
   /* An optional hook for adding URLs to quoted text strings in
      diagnostics.  Only used for the main diagnostic message.  */
   urlifier *m_urlifier;
@@ -648,9 +708,6 @@ private:
   int m_lock;
 
 public:
-  /* A copy of lang_hooks.option_lang_mask ().  */
-  unsigned m_lang_mask;
-
   bool m_inhibit_notes_p;
 
   diagnostic_source_printing_options m_source_printing;
@@ -735,11 +792,28 @@ diagnostic_inhibit_notes (diagnostic_context * context)
 
 /* Client supplied function to announce a diagnostic
    (for text-based diagnostic output).  */
-#define diagnostic_starter(DC) (DC)->m_text_callbacks.begin_diagnostic
+inline diagnostic_starter_fn &
+diagnostic_starter (diagnostic_context *context)
+{
+  return context->m_text_callbacks.m_begin_diagnostic;
+}
+
+/* Client supplied function called between disjoint spans of source code,
+   so that the context can print
+   something to indicate that a new span of source code has begun.  */
+inline diagnostic_start_span_fn &
+diagnostic_start_span (diagnostic_context *context)
+{
+  return context->m_text_callbacks.m_start_span;
+}
 
 /* Client supplied function called after a diagnostic message is
    displayed (for text-based diagnostic output).  */
-#define diagnostic_finalizer(DC) (DC)->m_text_callbacks.end_diagnostic
+inline diagnostic_finalizer_fn &
+diagnostic_finalizer (diagnostic_context *context)
+{
+  return context->m_text_callbacks.m_end_diagnostic;
+}
 
 /* Extension hooks for client.  */
 #define diagnostic_context_auxiliary_data(DC) (DC)->m_client_aux_data
@@ -765,7 +839,11 @@ extern diagnostic_context *global_dc;
 
 /* Returns whether the diagnostic framework has been intialized already and is
    ready for use.  */
-#define diagnostic_ready_p() (global_dc->printer != NULL)
+inline bool
+diagnostic_ready_p ()
+{
+  return global_dc->printer != nullptr;
+}
 
 /* The number of errors that have been issued so far.  Ideally, these
    would take a diagnostic_context as an argument.  */
diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
index 7cdfdf8..8293a7b 100644
--- a/gcc/doc/extend.texi
+++ b/gcc/doc/extend.texi
@@ -6295,8 +6295,66 @@ void f (void) __attribute__ ((interrupt ("user")));
 Permissible values for this parameter are @code{user}, @code{supervisor},
 and @code{machine}.  If there is no parameter, then it defaults to
 @code{machine}.
+
 @end table
 
+The following target-specific function attributes are available for the
+RISC-V target.  For the most part, these options mirror the behavior of
+similar command-line options (@pxref{RISC-V Options}), but on a
+per-function basis.
+
+@table @code
+@cindex @code{arch=} function attribute, RISC-V
+@item arch=
+Specifies the architecture version and architectural extensions to use
+for this function.  The behavior and permissible arguments are the same as
+for the @option{-march=} command-line option, in addtion, it also support
+extension enablement list, a list of extension name and prefixed with @code{+},
+like @code{arch=+zba} means enable @code{zba} extension.
+Multiple extension can be enabled by separating them with a comma.  For example:
+@code{arch=+zba,+zbb}.
+
+@cindex @code{tune=} function attribute, RISC-V
+@item tune=
+Specifies the core for which to tune the performance of this function.
+The behavior and permissible arguments are the same as for the @option{-mtune=}
+command-line option.
+
+@cindex @code{cpu=} function attribute, RISC-V
+@item cpu=
+Specifies the core for which to tune the performance of this function and also
+whose architectural features to use.  The behavior and valid arguments are the
+same as for the @option{-mcpu=} command-line option.
+
+@end table
+
+The above target attributes can be specified as follows:
+
+@smallexample
+__attribute__((target("@var{attr-string}")))
+int
+f (int a)
+@{
+  return a + 5;
+@}
+@end smallexample
+
+where @code{@var{attr-string}} is one of the attribute strings specified above.
+
+Multiple target function attributes can be specified by separating them with
+a semicolon.  For example:
+@smallexample
+__attribute__((target("arch=+zba,+zbb;tune=rocket")))
+int
+foo (int a)
+@{
+  return a + 5;
+@}
+@end smallexample
+
+is valid and compiles function @code{foo} with @code{zba}
+and @code{zbb} extensions and tunes it for @code{rocket}.
+
 @node RL78 Function Attributes
 @subsection RL78 Function Attributes
 
@@ -14960,6 +15018,48 @@ Similar to @code{__builtin_parity}, except the argument type is
 @code{unsigned long long}.
 @enddefbuiltin
 
+@defbuiltin{int __builtin_ffsg (...)}
+Similar to @code{__builtin_ffs}, except the argument is type-generic
+signed integer (standard, extended or bit-precise).  No integral argument
+promotions are performed on the argument.
+@enddefbuiltin
+
+@defbuiltin{int __builtin_clzg (...)}
+Similar to @code{__builtin_clz}, except the argument is type-generic
+unsigned integer (standard, extended or bit-precise) and there is
+optional second argument with int type.  No integral argument promotions
+are performed on the first argument.  If two arguments are specified,
+and first argument is 0, the result is the second argument.  If only
+one argument is specified and it is 0, the result is undefined.
+@enddefbuiltin
+
+@defbuiltin{int __builtin_ctzg (...)}
+Similar to @code{__builtin_ctz}, except the argument is type-generic
+unsigned integer (standard, extended or bit-precise) and there is
+optional second argument with int type.  No integral argument promotions
+are performed on the first argument.  If two arguments are specified,
+and first argument is 0, the result is the second argument.  If only
+one argument is specified and it is 0, the result is undefined.
+@enddefbuiltin
+
+@defbuiltin{int __builtin_clrsbg (...)}
+Similar to @code{__builtin_clrsb}, except the argument is type-generic
+signed integer (standard, extended or bit-precise).  No integral argument
+promotions are performed on the argument.
+@enddefbuiltin
+
+@defbuiltin{int __builtin_popcountg (...)}
+Similar to @code{__builtin_popcount}, except the argument is type-generic
+unsigned integer (standard, extended or bit-precise).  No integral argument
+promotions are performed on the argument.
+@enddefbuiltin
+
+@defbuiltin{int __builtin_parityg (...)}
+Similar to @code{__builtin_parity}, except the argument is type-generic
+unsigned integer (standard, extended or bit-precise).  No integral argument
+promotions are performed on the argument.
+@enddefbuiltin
+
 @defbuiltin{double __builtin_powi (double, int)}
 @defbuiltinx{float __builtin_powif (float, int)}
 @defbuiltinx{{long double} __builtin_powil (long double, int)}
@@ -18429,7 +18529,6 @@ These built-in functions are available for the Nvidia PTX target:
 
 @defbuiltin{unsigned int __builtin_nvptx_brev (unsigned int @var{x})}
 Reverse the bit order of a 32-bit unsigned integer.
-Disable global interrupt.
 @enddefbuiltin
 
 @defbuiltin{unsigned long long __builtin_nvptx_brevll (unsigned long long @var{x})}
diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
index f1a5722..1f10967 100644
--- a/gcc/doc/invoke.texi
+++ b/gcc/doc/invoke.texi
@@ -448,6 +448,7 @@ Objective-C and Objective-C++ Dialects}.
 -fdump-analyzer-exploded-nodes-3
 -fdump-analyzer-exploded-paths
 -fdump-analyzer-feasibility
+-fdump-analyzer-infinite-loop
 -fdump-analyzer-json
 -fdump-analyzer-state-purge
 -fdump-analyzer-stderr
@@ -467,6 +468,7 @@ Objective-C and Objective-C++ Dialects}.
 -Wno-analyzer-file-leak
 -Wno-analyzer-free-of-non-heap
 -Wno-analyzer-imprecise-fp-arithmetic
+-Wno-analyzer-infinite-loop
 -Wno-analyzer-infinite-recursion
 -Wno-analyzer-jump-through-null
 -Wno-analyzer-malloc-leak
@@ -488,6 +490,7 @@ Objective-C and Objective-C++ Dialects}.
 -Wno-analyzer-tainted-offset
 -Wno-analyzer-tainted-size
 -Wanalyzer-too-complex
+-Wno-analyzer-undefined-behavior-strtok
 -Wno-analyzer-unsafe-call-within-signal-handler
 -Wno-analyzer-use-after-free
 -Wno-analyzer-use-of-pointer-in-stale-stack-frame
@@ -1045,7 +1048,7 @@ Objective-C and Objective-C++ Dialects}.
 -mmax-inline-memcpy-size=@var{n}
 -mexplicit-relocs=@var{style} -mexplicit-relocs -mno-explicit-relocs
 -mdirect-extern-access -mno-direct-extern-access
--mcmodel=@var{code-model}}
+-mcmodel=@var{code-model} -mrelax -mpass-mrelax-to-as}
 
 @emph{M32R/D Options}
 @gccoptlist{-m32r2  -m32rx  -m32r
@@ -10401,6 +10404,7 @@ Enabling this option effectively enables the following warnings:
 -Wanalyzer-file-leak
 -Wanalyzer-free-of-non-heap
 -Wanalyzer-imprecise-fp-arithmetic
+-Wanalyzer-infinite-loop
 -Wanalyzer-infinite-recursion
 -Wanalyzer-jump-through-null
 -Wanalyzer-malloc-leak
@@ -10415,6 +10419,13 @@ Enabling this option effectively enables the following warnings:
 -Wanalyzer-shift-count-negative
 -Wanalyzer-shift-count-overflow
 -Wanalyzer-stale-setjmp-buffer
+-Wanalyzer-tainted-allocation-size
+-Wanalyzer-tainted-array-index
+-Wanalyzer-tainted-assertion
+-Wanalyzer-tainted-divisor
+-Wanalyzer-tainted-offset
+-Wanalyzer-tainted-size
+-Wanalyzer-undefined-behavior-strtok
 -Wanalyzer-unsafe-call-within-signal-handler
 -Wanalyzer-use-after-free
 -Wanalyzer-use-of-pointer-in-stale-stack-frame
@@ -10426,13 +10437,6 @@ Enabling this option effectively enables the following warnings:
 -Wanalyzer-write-to-const
 -Wanalyzer-write-to-string-literal
 }
-@ignore
--Wanalyzer-tainted-allocation-size
--Wanalyzer-tainted-array-index
--Wanalyzer-tainted-divisor
--Wanalyzer-tainted-offset
--Wanalyzer-tainted-size
-@end ignore
 
 This option is only available if GCC was configured with analyzer
 support enabled.
@@ -10667,6 +10671,57 @@ arithmetic is used in locations where precise computation is needed.  This
 diagnostic only warns on use of floating-point operands inside the
 calculation of an allocation size at the moment.
 
+@opindex Wanalyzer-infinite-loop
+@opindex Wno-analyzer-infinite-loop
+@item -Wno-analyzer-infinite-loop
+This warning requires @option{-fanalyzer}, which enables it; use
+@option{-Wno-analyzer-infinite-loop} to disable it.
+
+This diagnostics warns for paths through the code which appear to
+lead to an infinite loop.
+
+Specifically, the analyzer will issue this warning when it "sees" a loop
+in which:
+@itemize @bullet
+@item
+no externally-visible work could be being done within the loop
+@item
+there is no way to escape from the loop
+@item
+the analyzer is sufficiently confident about the program state
+throughout the loop to know that the above are true
+@end itemize
+
+One way for this warning to be emitted is when there is an execution
+path through a loop for which taking the path on one iteration implies
+that the same path will be taken on all subsequent iterations.
+
+For example, consider:
+
+@smallexample
+  while (1)
+    @{
+      char opcode = *cpu_state.pc;
+      switch (opcode)
+       @{
+       case OPCODE_FOO:
+         handle_opcode_foo (&cpu_state);
+         break;
+       case OPCODE_BAR:
+         handle_opcode_bar (&cpu_state);
+         break;
+       @}
+    @}
+@end smallexample
+
+The analyzer will complain for the above case because if @code{opcode}
+ever matches none of the cases, the @code{switch} will follow the
+implicit @code{default} case, making the body of the loop be a ``no-op''
+with @code{cpu_state.pc} unchanged, and thus using the same value of
+@code{opcode} on all subseqent iterations, leading to an infinite loop.
+
+See @uref{https://cwe.mitre.org/data/definitions/835.html, CWE-835: Loop with Unreachable Exit Condition ('Infinite Loop')}.
+
 @opindex Wanalyzer-infinite-recursion
 @opindex Wno-analyzer-infinite-recursion
 @item -Wno-analyzer-infinite-recursion
@@ -10691,6 +10746,8 @@ this diagnostic.
 Compare with @option{-Winfinite-recursion}, which provides a similar
 diagnostic, but is implemented in a different way.
 
+See @uref{https://cwe.mitre.org/data/definitions/674.html, CWE-674: Uncontrolled Recursion}.
+
 @opindex Wanalyzer-jump-through-null
 @opindex Wno-analyzer-jump-through-null
 @item -Wno-analyzer-jump-through-null
@@ -10880,8 +10937,7 @@ no longer exists, and likely lead to a crash (or worse).
 @opindex Wanalyzer-tainted-allocation-size
 @opindex Wno-analyzer-tainted-allocation-size
 @item -Wno-analyzer-tainted-allocation-size
-This warning requires both @option{-fanalyzer} and
-@option{-fanalyzer-checker=taint} to enable it;
+This warning requires @option{-fanalyzer} which enables it;
 use @option{-Wno-analyzer-tainted-allocation-size} to disable it.
 
 This diagnostic warns for paths through the code in which a value
@@ -10896,8 +10952,7 @@ See @uref{https://cwe.mitre.org/data/definitions/789.html, CWE-789: Memory Alloc
 @opindex Wno-analyzer-tainted-assertion
 @item -Wno-analyzer-tainted-assertion
 
-This warning requires both @option{-fanalyzer} and
-@option{-fanalyzer-checker=taint} to enable it;
+This warning requires @option{-fanalyzer} which enables it;
 use @option{-Wno-analyzer-tainted-assertion} to disable it.
 
 This diagnostic warns for paths through the code in which a value
@@ -10958,8 +11013,7 @@ despite the above not being an assertion failure, strictly speaking.
 @opindex Wanalyzer-tainted-array-index
 @opindex Wno-analyzer-tainted-array-index
 @item -Wno-analyzer-tainted-array-index
-This warning requires both @option{-fanalyzer} and
-@option{-fanalyzer-checker=taint} to enable it;
+This warning requires @option{-fanalyzer} which enables it;
 use @option{-Wno-analyzer-tainted-array-index} to disable it.
 
 This diagnostic warns for paths through the code in which a value
@@ -10972,8 +11026,7 @@ See @uref{https://cwe.mitre.org/data/definitions/129.html, CWE-129: Improper Val
 @opindex Wanalyzer-tainted-divisor
 @opindex Wno-analyzer-tainted-divisor
 @item -Wno-analyzer-tainted-divisor
-This warning requires both @option{-fanalyzer} and
-@option{-fanalyzer-checker=taint} to enable it;
+This warning requires @option{-fanalyzer} which enables it;
 use @option{-Wno-analyzer-tainted-divisor} to disable it.
 
 This diagnostic warns for paths through the code in which a value
@@ -10986,8 +11039,7 @@ See @uref{https://cwe.mitre.org/data/definitions/369.html, CWE-369: Divide By Ze
 @opindex Wanalyzer-tainted-offset
 @opindex Wno-analyzer-tainted-offset
 @item -Wno-analyzer-tainted-offset
-This warning requires both @option{-fanalyzer} and
-@option{-fanalyzer-checker=taint} to enable it;
+This warning requires @option{-fanalyzer} which enables it;
 use @option{-Wno-analyzer-tainted-offset} to disable it.
 
 This diagnostic warns for paths through the code in which a value
@@ -11000,8 +11052,7 @@ See @uref{https://cwe.mitre.org/data/definitions/823.html, CWE-823: Use of Out-o
 @opindex Wanalyzer-tainted-size
 @opindex Wno-analyzer-tainted-size
 @item -Wno-analyzer-tainted-size
-This warning requires both @option{-fanalyzer} and
-@option{-fanalyzer-checker=taint} to enable it;
+This warning requires @option{-fanalyzer} which enables it;
 use @option{-Wno-analyzer-tainted-size} to disable it.
 
 This diagnostic warns for paths through the code in which a value
@@ -11011,6 +11062,18 @@ attacker could inject an out-of-bounds access.
 
 See @uref{https://cwe.mitre.org/data/definitions/129.html, CWE-129: Improper Validation of Array Index}.
 
+@opindex Wanalyzer-undefined-behavior-strtok
+@opindex Wno-analyzer-undefined-behavior-strtok
+@item -Wno-analyzer-undefined-behavior-strtok
+This warning requires @option{-fanalyzer}, which enables it; use
+@option{-Wno-analyzer-undefined-behavior-strtok} to disable it.
+
+This diagnostic warns for paths through the code in which a
+call is made to @code{strtok} with undefined behavior.
+
+Specifically, passing NULL as the first parameter for the initial
+call to @code{strtok} within a process has undefined behavior.
+
 @opindex Wanalyzer-unsafe-call-within-signal-handler
 @opindex Wno-analyzer-unsafe-call-within-signal-handler
 @item -Wno-analyzer-unsafe-call-within-signal-handler
@@ -11251,38 +11314,6 @@ call site, and that are sufficiently complicated (as per
 @item -fanalyzer-checker=@var{name}
 Restrict the analyzer to run just the named checker, and enable it.
 
-Some checkers are disabled by default (even with @option{-fanalyzer}),
-such as the @code{taint} checker that implements
-@option{-Wanalyzer-tainted-array-index}, and this option is required
-to enable them.
-
-@emph{Note:} currently, @option{-fanalyzer-checker=taint} disables the
-following warnings from @option{-fanalyzer}:
-
-@gccoptlist{
--Wanalyzer-deref-before-check
--Wanalyzer-double-fclose
--Wanalyzer-double-free
--Wanalyzer-exposure-through-output-file
--Wanalyzer-fd-access-mode-mismatch
--Wanalyzer-fd-double-close
--Wanalyzer-fd-leak
--Wanalyzer-fd-use-after-close
--Wanalyzer-fd-use-without-check
--Wanalyzer-file-leak
--Wanalyzer-free-of-non-heap
--Wanalyzer-malloc-leak
--Wanalyzer-mismatching-deallocation
--Wanalyzer-null-argument
--Wanalyzer-null-dereference
--Wanalyzer-possible-null-argument
--Wanalyzer-possible-null-dereference
--Wanalyzer-unsafe-call-within-signal-handler
--Wanalyzer-use-after-free
--Wanalyzer-va-list-leak
--Wanalyzer-va-list-use-after-va-end
-}
-
 @opindex fanalyzer-debug-text-art
 @opindex fno-analyzer-debug-text-art
 @item -fanalyzer-debug-text-art-headings
@@ -11494,6 +11525,12 @@ The details are written in a form suitable for viewing with GraphViz
 to filenames of the form @file{@var{file}.*.fg.dot},
 @file{@var{file}.*.tg.dot}, and @file{@var{file}.*.fpath.txt}.
 
+@opindex dump-analyzer-infinite-loop
+@item -fdump-analyzer-infinite-loop
+Dump internal details about the analyzer's search for infinite loops.
+The details are written in a form suitable for viewing with GraphViz
+to filenames of the form @file{@var{file}.*.infinite-loop.dot}.
+
 @opindex fdump-analyzer-json
 @item -fdump-analyzer-json
 Dump a compressed JSON representation of analyzer internals to
@@ -16959,7 +16996,24 @@ while the second one prevents profile corruption by emitting thread-safe code.
 Using @samp{prefer-atomic} would be transformed either to @samp{atomic},
 when supported by a target, or to @samp{single} otherwise.  The GCC driver
 automatically selects @samp{prefer-atomic} when @option{-pthread}
-is present in the command line.
+is present in the command line, otherwise the default method is @samp{single}.
+
+If @samp{atomic} is selected, then the profile information is updated using
+atomic operations on a best-effort basis.  Ideally, the profile information is
+updated through atomic operations in hardware.  If the target platform does not
+support the required atomic operations in hardware, however, @file{libatomic}
+is available, then the profile information is updated through calls to
+@file{libatomic}.  If the target platform neither supports the required atomic
+operations in hardware nor @file{libatomic}, then the profile information is
+not atomically updated and a warning is issued.  In this case, the obtained
+profiling information may be corrupt for multi-threaded applications.
+
+For performance reasons, if 64-bit counters are used for the profiling
+information and the target platform only supports 32-bit atomic operations in
+hardware, then the performance critical profiling updates are done using two
+32-bit atomic operations for each counter update.  If a signal interrupts these
+two operations updating a counter, then the profiling information may be in an
+inconsistent state.
 
 @opindex fprofile-filter-files
 @item -fprofile-filter-files=@var{regex}
@@ -26356,16 +26410,14 @@ with @option{-mexplicit-relocs=always} the assembler relocation operators
 are always used, with @option{-mexplicit-relocs=auto} the compiler will
 use the relocation operators where the linker relaxation is impossible to
 improve the code quality, and macros elsewhere.  The default
-value for the option is determined during GCC build-time by detecting
-corresponding assembler support:
+value for the option is determined with the assembler capability detected
+during GCC build-time and the setting of @option{-mrelax}:
 @option{-mexplicit-relocs=none} if the assembler does not support
 relocation operators at all,
 @option{-mexplicit-relocs=always} if the assembler supports relocation
-operators but does not support relaxation,
-@option{-mexplicit-relocs=auto} if the assembler supports both relocation
-operators and relaxation.  This option is mostly useful for
-debugging, or interoperation with assemblers different from the build-time
-one.
+operators but @option{-mrelax} is not enabled,
+@option{-mexplicit-relocs=auto} if the assembler supports relocation
+operators and @option{-mrelax} is enabled.
 
 @opindex mexplicit-relocs
 @item -mexplicit-relocs
@@ -26389,6 +26441,28 @@ kernels, executables linked with @option{-static} or @option{-static-pie}.
 @option{-mdirect-extern-access} is not compatible with @option{-fPIC} or
 @option{-fpic}.
 
+@item -mrelax
+@itemx -mno-relax
+Take (do not take) advantage of linker relaxations.  If
+@option{-mpass-mrelax-to-as} is enabled, this option is also passed to
+the assembler.  The default is determined during GCC build-time by
+detecting corresponding assembler support:
+@option{-mrelax} if the assembler supports both the @option{-mrelax}
+option and the conditional branch relaxation (it's required or the
+@code{.align} directives and conditional branch instructions in the
+assembly code outputted by GCC may be rejected by the assembler because
+of a relocation overflow), @option{-mno-relax} otherwise.
+
+@item -mpass-mrelax-to-as
+@itemx -mno-pass-mrelax-to-as
+Pass (do not pass) the @option{-mrelax} or @option{-mno-relax} option
+to the assembler.  The default is determined during GCC build-time by
+detecting corresponding assembler support:
+@option{-mpass-mrelax-to-as} if the assembler supports the
+@option{-mrelax} option, @option{-mno-pass-mrelax-to-as} otherwise.
+This option is mostly useful for debugging, or interoperation with
+assemblers different from the build-time one.
+
 @item loongarch-vect-unroll-limit
 The vectorizer will use available tuning information to determine whether it
 would be beneficial to unroll the main vectorized loop and by how much.  This
diff --git a/gcc/doc/md.texi b/gcc/doc/md.texi
index 5d86152..e01cdcb 100644
--- a/gcc/doc/md.texi
+++ b/gcc/doc/md.texi
@@ -2010,6 +2010,9 @@ Any @code{symbol_ref} or @code{label_ref}
 @item v
 VGPR register
 
+@item a
+Accelerator VGPR register (CDNA1 onwards)
+
 @item Sg
 SGPR register
 
diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi
index d83ca73..dcf7735 100644
--- a/gcc/doc/tm.texi
+++ b/gcc/doc/tm.texi
@@ -12601,18 +12601,12 @@ Store the result in @var{target} if convenient.
 The default clears the top byte of the original pointer.
 @end deftypefn
 
-@deftypefn {Target Hook} HOST_WIDE_INT TARGET_GCOV_TYPE_SIZE (void)
-Returns the gcov type size in bits.  This type is used for example for
-counters incremented by profiling and code-coverage events.  The default
-value is 64, if the type size of long long is greater than 32, otherwise the
-default value is 32.  A 64-bit type is recommended to avoid overflows of the
-counters.  If the @option{-fprofile-update=atomic} is used, then the
-counters are incremented using atomic operations.  Targets not supporting
-64-bit atomic operations may override the default value and request a 32-bit
-type.
-@end deftypefn
-
 @deftypevr {Target Hook} bool TARGET_HAVE_SHADOW_CALL_STACK
 This value is true if the target platform supports
 @option{-fsanitize=shadow-call-stack}.  The default value is false.
 @end deftypevr
+
+@deftypevr {Target Hook} bool TARGET_HAVE_LIBATOMIC
+This value is true if the target platform supports
+libatomic.  The default value is false.
+@end deftypevr
diff --git a/gcc/doc/tm.texi.in b/gcc/doc/tm.texi.in
index 3d3ae12..b61a59f 100644
--- a/gcc/doc/tm.texi.in
+++ b/gcc/doc/tm.texi.in
@@ -8040,6 +8040,6 @@ maintainer is familiar with.
 
 @hook TARGET_MEMTAG_UNTAGGED_POINTER
 
-@hook TARGET_GCOV_TYPE_SIZE
-
 @hook TARGET_HAVE_SHADOW_CALL_STACK
+
+@hook TARGET_HAVE_LIBATOMIC
diff --git a/gcc/dwarf2out.cc b/gcc/dwarf2out.cc
index 9850d09..d187be9 100644
--- a/gcc/dwarf2out.cc
+++ b/gcc/dwarf2out.cc
@@ -4908,6 +4908,9 @@ add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_
 {
   dw_attr_node attr;
   gcc_checking_assert (targ_die != NULL);
+  gcc_assert (targ_die != die
+	      || (attr_kind != DW_AT_abstract_origin
+		  && attr_kind != DW_AT_specification));
 
   /* With LTO we can end up trying to reference something we didn't create
      a DIE for.  Avoid crashing later on a NULL referenced DIE.  */
diff --git a/gcc/edit-context.cc b/gcc/edit-context.cc
index 09b000c..ee28bf6 100644
--- a/gcc/edit-context.cc
+++ b/gcc/edit-context.cc
@@ -64,7 +64,7 @@ public:
 class edited_file
 {
  public:
-  edited_file (const char *filename);
+  edited_file (edit_context &ec, const char *filename);
   static void delete_cb (edited_file *file);
 
   const char *get_filename () const { return m_filename; }
@@ -84,6 +84,11 @@ class edited_file
     return 0;
   }
 
+  file_cache &get_file_cache () const
+  {
+    return m_edit_context.get_file_cache ();
+  }
+
  private:
   bool print_content (pretty_printer *pp);
   void print_diff (pretty_printer *pp, bool show_filenames);
@@ -100,6 +105,7 @@ class edited_file
 				   int start_of_run,
 				   int end_of_run);
 
+  edit_context &m_edit_context;
   const char *m_filename;
   typed_splay_tree<int, edited_line *> m_edited_lines;
   int m_num_lines;
@@ -163,7 +169,7 @@ class line_event
 class edited_line
 {
  public:
-  edited_line (const char *filename, int line_num);
+  edited_line (file_cache &fc, const char *filename, int line_num);
   ~edited_line ();
   static void delete_cb (edited_line *el);
 
@@ -208,8 +214,9 @@ print_diff_line (pretty_printer *pp, char prefix_char,
 
 /* edit_context's ctor.  */
 
-edit_context::edit_context ()
-: m_valid (true),
+edit_context::edit_context (file_cache &fc)
+: m_file_cache (fc),
+  m_valid (true),
   m_files (strcmp, NULL, edited_file::delete_cb)
 {}
 
@@ -334,7 +341,7 @@ edit_context::get_or_insert_file (const char *filename)
     return *file;
 
   /* Not found.  */
-  file = new edited_file (filename);
+  file = new edited_file (*this, filename);
   m_files.insert (filename, file);
   return *file;
 }
@@ -350,8 +357,9 @@ static int line_comparator (int a, int b)
 
 /* edited_file's constructor.  */
 
-edited_file::edited_file (const char *filename)
-: m_filename (filename),
+edited_file::edited_file (edit_context &ec, const char *filename)
+: m_edit_context (ec),
+  m_filename (filename),
   m_edited_lines (line_comparator, NULL, edited_line::delete_cb),
   m_num_lines (-1)
 {
@@ -422,7 +430,8 @@ edited_file::print_content (pretty_printer *pp)
 	el->print_content (pp);
       else
 	{
-	  char_span line = location_get_source_line (m_filename, line_num);
+	  char_span line
+	    = get_file_cache ().get_source_line (m_filename, line_num);
 	  if (!line)
 	    return false;
 	  for (size_t i = 0; i < line.length (); i++)
@@ -547,7 +556,8 @@ edited_file::print_diff_hunk (pretty_printer *pp, int old_start_of_hunk,
       else
 	{
 	  /* Unchanged line.  */
-	  char_span old_line = location_get_source_line (m_filename, line_num);
+	  char_span old_line
+	    = get_file_cache ().get_source_line (m_filename, line_num);
 	  print_diff_line (pp, ' ', old_line.get_buffer (), old_line.length ());
 	  line_num++;
 	}
@@ -576,7 +586,8 @@ edited_file::print_run_of_changed_lines (pretty_printer *pp,
       gcc_assert (el_in_run);
       if (el_in_run->actually_edited_p ())
 	{
-	  char_span old_line = location_get_source_line (m_filename, line_num);
+	  char_span old_line
+	    = get_file_cache ().get_source_line (m_filename, line_num);
 	  print_diff_line (pp, '-', old_line.get_buffer (),
 			   old_line.length ());
 	}
@@ -649,7 +660,7 @@ edited_file::get_or_insert_line (int line)
   edited_line *el = get_line (line);
   if (el)
     return el;
-  el = new edited_line (m_filename, line);
+  el = new edited_line (get_file_cache (), m_filename, line);
   if (el->get_content () == NULL)
     {
       delete el;
@@ -673,14 +684,15 @@ edited_file::get_num_lines (bool *missing_trailing_newline)
       while (true)
 	{
 	  char_span line
-	    = location_get_source_line (m_filename, m_num_lines + 1);
+	    = get_file_cache ().get_source_line (m_filename, m_num_lines + 1);
 	  if (line)
 	    m_num_lines++;
 	  else
 	    break;
 	}
     }
-  *missing_trailing_newline = location_missing_trailing_newline (m_filename);
+  *missing_trailing_newline
+    = get_file_cache ().missing_trailing_newline_p (m_filename);
   return m_num_lines;
 }
 
@@ -688,13 +700,13 @@ edited_file::get_num_lines (bool *missing_trailing_newline)
 
 /* edited_line's ctor.  */
 
-edited_line::edited_line (const char *filename, int line_num)
+edited_line::edited_line (file_cache &fc, const char *filename, int line_num)
 : m_line_num (line_num),
   m_content (NULL), m_len (0), m_alloc_sz (0),
   m_line_events (),
   m_predecessors ()
 {
-  char_span line = location_get_source_line (filename, line_num);
+  char_span line = fc.get_source_line (filename, line_num);
   if (!line)
     return;
   m_len = line.length ();
@@ -913,7 +925,8 @@ test_get_content ()
   {
     const char *content = ("");
     temp_source_file tmp (SELFTEST_LOCATION, ".c", content);
-    edit_context edit;
+    file_cache fc;
+    edit_context edit (fc);
     auto_free <char *> result = edit.get_content (tmp.get_filename ());
     ASSERT_STREQ ("", result);
   }
@@ -924,7 +937,8 @@ test_get_content ()
 			   "foo = bar.field;\n"
 			   "/* after */\n");
     temp_source_file tmp (SELFTEST_LOCATION, ".c", content);
-    edit_context edit;
+    file_cache fc;
+    edit_context edit (fc);
     auto_free <char *> result = edit.get_content (tmp.get_filename ());
     ASSERT_STREQ ("/* before */\n"
 		  "foo = bar.field;\n"
@@ -937,7 +951,8 @@ test_get_content ()
 			   "foo = bar.field;\n"
 			   "/* after */");
     temp_source_file tmp (SELFTEST_LOCATION, ".c", content);
-    edit_context edit;
+    file_cache fc;
+    edit_context edit (fc);
     auto_free <char *> result = edit.get_content (tmp.get_filename ());
     /* We should respect the omitted trailing newline.  */
     ASSERT_STREQ ("/* before */\n"
@@ -970,7 +985,8 @@ test_applying_fixits_insert_before (const line_table_case &case_)
   if (start > LINE_MAP_MAX_LOCATION_WITH_COLS)
     return;
 
-  edit_context edit;
+  file_cache fc;
+  edit_context edit (fc);
   edit.add_fixits (&richloc);
   auto_free <char *> new_content = edit.get_content (filename);
   if (start <= LINE_MAP_MAX_LOCATION_WITH_COLS)
@@ -1028,7 +1044,8 @@ test_applying_fixits_insert_after (const line_table_case &case_)
     return;
 
   /* Verify that the text was inserted after the end of "field". */
-  edit_context edit;
+  file_cache fc;
+  edit_context edit (fc);
   edit.add_fixits (&richloc);
   auto_free <char *> new_content = edit.get_content (filename);
   ASSERT_STREQ ("/* before */\n"
@@ -1070,7 +1087,8 @@ test_applying_fixits_insert_after_at_line_end (const line_table_case &case_)
   if (loc > LINE_MAP_MAX_LOCATION_WITH_COLS)
     return;
 
-  edit_context edit;
+  file_cache fc;
+  edit_context edit (fc);
   edit.add_fixits (&richloc);
   auto_free <char *> new_content = edit.get_content (filename);
   ASSERT_STREQ ("/* before */\n"
@@ -1128,7 +1146,8 @@ test_applying_fixits_insert_after_failure (const line_table_case &case_)
   richloc.add_fixit_insert_after ("/* inserted */");
   ASSERT_TRUE (richloc.seen_impossible_fixit_p ());
 
-  edit_context edit;
+  file_cache fc;
+  edit_context edit (fc);
   edit.add_fixits (&richloc);
   ASSERT_FALSE (edit.valid_p ());
   ASSERT_EQ (NULL, edit.get_content (filename));
@@ -1165,7 +1184,8 @@ test_applying_fixits_insert_containing_newline (const line_table_case &case_)
   if (case_finish > LINE_MAP_MAX_LOCATION_WITH_COLS)
     return;
 
-  edit_context edit;
+  file_cache fc;
+  edit_context edit (fc);
   edit.add_fixits (&richloc);
   auto_free <char *> new_content = edit.get_content (filename);
   ASSERT_STREQ (("    case 'a':\n"
@@ -1209,7 +1229,8 @@ test_applying_fixits_growing_replace (const line_table_case &case_)
   rich_location richloc (line_table, field);
   richloc.add_fixit_replace ("m_field");
 
-  edit_context edit;
+  file_cache fc;
+  edit_context edit (fc);
   edit.add_fixits (&richloc);
   auto_free <char *> new_content = edit.get_content (filename);
   if (finish <= LINE_MAP_MAX_LOCATION_WITH_COLS)
@@ -1254,7 +1275,8 @@ test_applying_fixits_shrinking_replace (const line_table_case &case_)
   rich_location richloc (line_table, m_field);
   richloc.add_fixit_replace ("field");
 
-  edit_context edit;
+  file_cache fc;
+  edit_context edit (fc);
   edit.add_fixits (&richloc);
   auto_free <char *> new_content = edit.get_content (filename);
   if (finish <= LINE_MAP_MAX_LOCATION_WITH_COLS)
@@ -1308,7 +1330,8 @@ test_applying_fixits_replace_containing_newline (const line_table_case &case_)
   if (finish > LINE_MAP_MAX_LOCATION_WITH_COLS)
     return;
 
-  edit_context edit;
+  file_cache fc;
+  edit_context edit (fc);
   edit.add_fixits (&richloc);
   auto_free <char *> new_content = edit.get_content (filename);
   //ASSERT_STREQ ("foo\n  = bar ();\n", new_content);
@@ -1339,7 +1362,8 @@ test_applying_fixits_remove (const line_table_case &case_)
   range.m_finish = finish;
   richloc.add_fixit_remove (range);
 
-  edit_context edit;
+  file_cache fc;
+  edit_context edit (fc);
   edit.add_fixits (&richloc);
   auto_free <char *> new_content = edit.get_content (filename);
   if (finish <= LINE_MAP_MAX_LOCATION_WITH_COLS)
@@ -1404,7 +1428,8 @@ test_applying_fixits_multiple (const line_table_case &case_)
   replace_b.add_fixit_replace (source_range::from_locations (c11, c15),
 			       "meadow");
 
-  edit_context edit;
+  file_cache fc;
+  edit_context edit (fc);
   edit.add_fixits (&insert_a);
   ASSERT_EQ (100, edit.get_effective_column (filename, 1, 100));
   ASSERT_EQ (1, edit.get_effective_column (filename, 2, 1));
@@ -1506,7 +1531,8 @@ test_applying_fixits_multiple_lines (const line_table_case &case_)
   linemap_add (line_table, LC_ENTER, false, filename, 1);
   linemap_position_for_column (line_table, 127);
 
-  edit_context edit;
+  file_cache fc;
+  edit_context edit (fc);
 
   /* A run of consecutive lines.  */
   change_line (edit, 2);
@@ -1594,7 +1620,8 @@ test_applying_fixits_modernize_named_init (const line_table_case &case_)
 
   /* The order should not matter.  Do r1 then r2. */
   {
-    edit_context edit;
+    file_cache fc;
+    edit_context edit (fc);
     edit.add_fixits (&r1);
 
     /* Verify state after first replacement.  */
@@ -1627,7 +1654,8 @@ test_applying_fixits_modernize_named_init (const line_table_case &case_)
 
   /* Try again, doing r2 then r1; the new_content should be the same.  */
   {
-    edit_context edit;
+    file_cache fc;
+    edit_context edit (fc);
     edit.add_fixits (&r2);
     edit.add_fixits (&r1);
     auto_free <char *> new_content = edit.get_content (tmp.get_filename ());
@@ -1655,7 +1683,8 @@ test_applying_fixits_unreadable_file ()
   insert.add_fixit_insert_before ("change 1");
   insert.add_fixit_insert_before ("change 2");
 
-  edit_context edit;
+  file_cache fc;
+  edit_context edit (fc);
   /* Attempting to add the fixits affecting the unreadable file
      should transition the edit from valid to invalid.  */
   ASSERT_TRUE (edit.valid_p ());
@@ -1688,7 +1717,8 @@ test_applying_fixits_line_out_of_range ()
 
   /* Verify that attempting the insertion puts an edit_context
      into an invalid state.  */
-  edit_context edit;
+  file_cache fc;
+  edit_context edit (fc);
   ASSERT_TRUE (edit.valid_p ());
   edit.add_fixits (&insert);
   ASSERT_FALSE (edit.valid_p ());
@@ -1725,7 +1755,8 @@ test_applying_fixits_column_validation (const line_table_case &case_)
 
     /* Col 15 is at the end of the line, so the insertion
        should succeed.  */
-    edit_context edit;
+    file_cache fc;
+    edit_context edit (fc);
     edit.add_fixits (&richloc);
     auto_free <char *> new_content = edit.get_content (tmp.get_filename ());
     if (c15 <= LINE_MAP_MAX_LOCATION_WITH_COLS)
@@ -1741,7 +1772,8 @@ test_applying_fixits_column_validation (const line_table_case &case_)
 
     /* Col 16 is beyond the end of the line, so the insertion
        should fail gracefully.  */
-    edit_context edit;
+    file_cache fc;
+    edit_context edit (fc);
     ASSERT_TRUE (edit.valid_p ());
     edit.add_fixits (&richloc);
     ASSERT_FALSE (edit.valid_p ());
@@ -1759,7 +1791,8 @@ test_applying_fixits_column_validation (const line_table_case &case_)
 
     /* Col 14 is at the end of the line, so the replacement
        should succeed.  */
-    edit_context edit;
+    file_cache fc;
+    edit_context edit (fc);
     edit.add_fixits (&richloc);
     auto_free <char *> new_content = edit.get_content (tmp.get_filename ());
     if (c14 <= LINE_MAP_MAX_LOCATION_WITH_COLS)
@@ -1776,7 +1809,8 @@ test_applying_fixits_column_validation (const line_table_case &case_)
 
     /* Col 15 is after the end of the line, so the replacement
        should fail; verify that the attempt fails gracefully.  */
-    edit_context edit;
+    file_cache fc;
+    edit_context edit (fc);
     ASSERT_TRUE (edit.valid_p ());
     edit.add_fixits (&richloc);
     ASSERT_FALSE (edit.valid_p ());
diff --git a/gcc/edit-context.h b/gcc/edit-context.h
index f2e69a6..71735c8 100644
--- a/gcc/edit-context.h
+++ b/gcc/edit-context.h
@@ -22,6 +22,7 @@ along with GCC; see the file COPYING3.  If not see
 
 #include "typed-splay-tree.h"
 
+class fixit_hint;
 class edit_context;
 class edited_file;
 
@@ -42,7 +43,7 @@ class edited_file;
 class edit_context
 {
  public:
-  edit_context ();
+  edit_context (file_cache &);
 
   bool valid_p () const { return m_valid; }
 
@@ -55,11 +56,14 @@ class edit_context
   char *generate_diff (bool show_filenames);
   void print_diff (pretty_printer *pp, bool show_filenames);
 
+  file_cache &get_file_cache () const { return m_file_cache; }
+
  private:
   bool apply_fixit (const fixit_hint *hint);
   edited_file *get_file (const char *filename);
   edited_file &get_or_insert_file (const char *filename);
 
+  file_cache &m_file_cache;
   bool m_valid;
   typed_splay_tree<const char *, edited_file *> m_files;
 };
diff --git a/gcc/expr.cc b/gcc/expr.cc
index 3e2a678..556bcf7 100644
--- a/gcc/expr.cc
+++ b/gcc/expr.cc
@@ -7489,7 +7489,7 @@ store_constructor (tree exp, rtx target, int cleared, poly_int64 size,
 	    if (maybe_ne (GET_MODE_PRECISION (mode), nunits))
 	      tmp = expand_binop (mode, and_optab, tmp,
 				  GEN_INT ((1 << nunits) - 1), target,
-				  true, OPTAB_DIRECT);
+				  true, OPTAB_WIDEN);
 	    if (tmp != target)
 	      emit_move_insn (target, tmp);
 	    break;
diff --git a/gcc/final.cc b/gcc/final.cc
index dd3e225..e6f1b1e 100644
--- a/gcc/final.cc
+++ b/gcc/final.cc
@@ -82,6 +82,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "print-rtl.h"
 #include "function-abi.h"
 #include "common/common-target.h"
+#include "diagnostic.h"
 
 #include "dwarf2out.h"
 
@@ -2103,7 +2104,8 @@ asm_show_source (const char *filename, int linenum)
   if (!filename)
     return;
 
-  char_span line = location_get_source_line (filename, linenum);
+  char_span line
+    = global_dc->get_file_cache ().get_source_line (filename, linenum);
   if (!line)
     return;
 
diff --git a/gcc/fold-const-call.cc b/gcc/fold-const-call.cc
index 04be3d2..36f4ecc 100644
--- a/gcc/fold-const-call.cc
+++ b/gcc/fold-const-call.cc
@@ -27,7 +27,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "fold-const.h"
 #include "fold-const-call.h"
 #include "case-cfn-macros.h"
-#include "tm.h" /* For C[LT]Z_DEFINED_AT_ZERO.  */
+#include "tm.h" /* For C[LT]Z_DEFINED_VALUE_AT_ZERO.  */
 #include "builtins.h"
 #include "gimple-expr.h"
 #include "tree-vector-builder.h"
@@ -1017,14 +1017,18 @@ fold_const_call_ss (wide_int *result, combined_fn fn, const wide_int_ref &arg,
   switch (fn)
     {
     CASE_CFN_FFS:
+    case CFN_BUILT_IN_FFSG:
       *result = wi::shwi (wi::ffs (arg), precision);
       return true;
 
     CASE_CFN_CLZ:
+    case CFN_BUILT_IN_CLZG:
       {
 	int tmp;
 	if (wi::ne_p (arg, 0))
 	  tmp = wi::clz (arg);
+	else if (TREE_CODE (arg_type) == BITINT_TYPE)
+	  tmp = TYPE_PRECISION (arg_type);
 	else if (!CLZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (arg_type),
 					     tmp))
 	  tmp = TYPE_PRECISION (arg_type);
@@ -1033,10 +1037,13 @@ fold_const_call_ss (wide_int *result, combined_fn fn, const wide_int_ref &arg,
       }
 
     CASE_CFN_CTZ:
+    case CFN_BUILT_IN_CTZG:
       {
 	int tmp;
 	if (wi::ne_p (arg, 0))
 	  tmp = wi::ctz (arg);
+	else if (TREE_CODE (arg_type) == BITINT_TYPE)
+	  tmp = TYPE_PRECISION (arg_type);
 	else if (!CTZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (arg_type),
 					     tmp))
 	  tmp = TYPE_PRECISION (arg_type);
@@ -1045,14 +1052,17 @@ fold_const_call_ss (wide_int *result, combined_fn fn, const wide_int_ref &arg,
       }
 
     CASE_CFN_CLRSB:
+    case CFN_BUILT_IN_CLRSBG:
       *result = wi::shwi (wi::clrsb (arg), precision);
       return true;
 
     CASE_CFN_POPCOUNT:
+    case CFN_BUILT_IN_POPCOUNTG:
       *result = wi::shwi (wi::popcount (arg), precision);
       return true;
 
     CASE_CFN_PARITY:
+    case CFN_BUILT_IN_PARITYG:
       *result = wi::shwi (wi::parity (arg), precision);
       return true;
 
@@ -1531,6 +1541,49 @@ fold_const_call_sss (real_value *result, combined_fn fn,
 
 /* Try to evaluate:
 
+      *RESULT = FN (ARG0, ARG1)
+
+   where ARG_TYPE is the type of ARG0 and PRECISION is the number of bits in
+   the result.  Return true on success.  */
+
+static bool
+fold_const_call_sss (wide_int *result, combined_fn fn,
+		     const wide_int_ref &arg0, const wide_int_ref &arg1,
+		     unsigned int precision, tree arg_type ATTRIBUTE_UNUSED)
+{
+  switch (fn)
+    {
+    case CFN_CLZ:
+    case CFN_BUILT_IN_CLZG:
+      {
+	int tmp;
+	if (wi::ne_p (arg0, 0))
+	  tmp = wi::clz (arg0);
+	else
+	  tmp = arg1.to_shwi ();
+	*result = wi::shwi (tmp, precision);
+	return true;
+      }
+
+    case CFN_CTZ:
+    case CFN_BUILT_IN_CTZG:
+      {
+	int tmp;
+	if (wi::ne_p (arg0, 0))
+	  tmp = wi::ctz (arg0);
+	else
+	  tmp = arg1.to_shwi ();
+	*result = wi::shwi (tmp, precision);
+	return true;
+      }
+
+    default:
+      return false;
+    }
+}
+
+/* Try to evaluate:
+
       RESULT = fn (ARG0, ARG1)
 
    where FORMAT is the format of the real and imaginary parts of RESULT
@@ -1565,6 +1618,19 @@ fold_const_call_1 (combined_fn fn, tree type, tree arg0, tree arg1)
   machine_mode arg0_mode = TYPE_MODE (TREE_TYPE (arg0));
   machine_mode arg1_mode = TYPE_MODE (TREE_TYPE (arg1));
 
+  if (integer_cst_p (arg0) && integer_cst_p (arg1))
+    {
+      if (SCALAR_INT_MODE_P (mode))
+	{
+	  wide_int result;
+	  if (fold_const_call_sss (&result, fn, wi::to_wide (arg0),
+				   wi::to_wide (arg1), TYPE_PRECISION (type),
+				   TREE_TYPE (arg0)))
+	    return wide_int_to_tree (type, result);
+	}
+      return NULL_TREE;
+    }
+
   if (mode == arg0_mode
       && real_cst_p (arg0)
       && real_cst_p (arg1))
diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog
index fae7521..686c771 100644
--- a/gcc/fortran/ChangeLog
+++ b/gcc/fortran/ChangeLog
@@ -1,3 +1,19 @@
+2023-11-17  Tobias Burnus  <tobias@codesourcery.com>
+
+	* gfortran.texi (_gfortran_set_options): Document GFC_STD_F2023.
+	* invoke.texi (std,pedantic,Wampersand,Wtabs): Add -std=2023.
+	* lang.opt (std=f2023): Add.
+	* libgfortran.h (GFC_STD_F2023, GFC_STD_OPT_F23): Add.
+	* options.cc (set_default_std_flags): Add GFC_STD_F2023.
+	(gfc_init_options): Set max_continue_free to 1,000,000.
+	(gfc_post_options): Set flag_free_line_length if unset.
+	(gfc_handle_option): Add OPT_std_f2023, set max_continue_free = 255
+	for -std=f2003, f2008 and f2018.
+
+2023-11-14  David Malcolm  <dmalcolm@redhat.com>
+
+	* error.cc (gfc_diagnostics_init): Use diagnostic_start_span.
+
 2023-11-07  Joseph Myers  <joseph@codesourcery.com>
 
 	* gfortran.h (gfc_real_info): Refer to C23 instead of C2X in
diff --git a/gcc/fortran/error.cc b/gcc/fortran/error.cc
index ca31775..2ac51e9 100644
--- a/gcc/fortran/error.cc
+++ b/gcc/fortran/error.cc
@@ -1637,7 +1637,7 @@ void
 gfc_diagnostics_init (void)
 {
   diagnostic_starter (global_dc) = gfc_diagnostic_starter;
-  global_dc->m_text_callbacks.start_span = gfc_diagnostic_start_span;
+  diagnostic_start_span (global_dc) = gfc_diagnostic_start_span;
   diagnostic_finalizer (global_dc) = gfc_diagnostic_finalizer;
   diagnostic_format_decoder (global_dc) = gfc_format_decoder;
   global_dc->m_source_printing.caret_chars[0] = '1';
diff --git a/gcc/fortran/gfortran.texi b/gcc/fortran/gfortran.texi
index e7ffc29..41857cc 100644
--- a/gcc/fortran/gfortran.texi
+++ b/gcc/fortran/gfortran.texi
@@ -3477,11 +3477,12 @@ standard.  Possible values are (bitwise or-ed) @code{GFC_STD_F77} (1),
 @code{GFC_STD_F95} (8), @code{GFC_STD_F2003} (16), @code{GFC_STD_GNU}
 (32), @code{GFC_STD_LEGACY} (64), @code{GFC_STD_F2008} (128),
 @code{GFC_STD_F2008_OBS} (256), @code{GFC_STD_F2008_TS} (512),
-@code{GFC_STD_F2018} (1024), @code{GFC_STD_F2018_OBS} (2048), and
-@code{GFC_STD=F2018_DEL} (4096). Default: @code{GFC_STD_F95_OBS |
-GFC_STD_F95_DEL | GFC_STD_F95 | GFC_STD_F2003 | GFC_STD_F2008 |
-GFC_STD_F2008_TS | GFC_STD_F2008_OBS | GFC_STD_F77 | GFC_STD_F2018 |
-GFC_STD_F2018_OBS | GFC_STD_F2018_DEL | GFC_STD_GNU | GFC_STD_LEGACY}.
+@code{GFC_STD_F2018} (1024), @code{GFC_STD_F2018_OBS} (2048),
+@code{GFC_STD=F2018_DEL} (4096), and @code{GFC_STD=F2023} (8192).
+Default: @code{GFC_STD_F95_OBS | GFC_STD_F95_DEL | GFC_STD_F95 |
+GFC_STD_F2003 | GFC_STD_F2008 | GFC_STD_F2008_TS | GFC_STD_F2008_OBS
+| GFC_STD_F77 | GFC_STD_F2018 | GFC_STD_F2018_OBS | GFC_STD_F2018_DEL
+| GFC_STD_F2023 | GFC_STD_GNU | GFC_STD_LEGACY}.
 @item @var{option}[1] @tab Standard-warning flag; prints a warning to
 standard error.  Default: @code{GFC_STD_F95_DEL | GFC_STD_LEGACY}.
 @item @var{option}[2] @tab If non zero, enable pedantic checking.
diff --git a/gcc/fortran/invoke.texi b/gcc/fortran/invoke.texi
index 10387e3..2f1d1f2 100644
--- a/gcc/fortran/invoke.texi
+++ b/gcc/fortran/invoke.texi
@@ -542,17 +542,17 @@ intermediate representation of the translated Fortran code, produced by
 @opindex @code{std=}@var{std} option
 @item -std=@var{std}
 Specify the standard to which the program is expected to conform,
-which may be one of @samp{f95}, @samp{f2003}, @samp{f2008},
-@samp{f2018}, @samp{gnu}, or @samp{legacy}.  The default value for
+which may be one of @samp{f95}, @samp{f2003}, @samp{f2008}, @samp{f2018},
+@samp{f2023}, @samp{gnu}, or @samp{legacy}.  The default value for
 @var{std} is @samp{gnu}, which specifies a superset of the latest
 Fortran standard that includes all of the extensions supported by GNU
 Fortran, although warnings will be given for obsolete extensions not
 recommended for use in new code.  The @samp{legacy} value is
 equivalent but without the warnings for obsolete extensions, and may
-be useful for old non-standard programs.  The @samp{f95},
-@samp{f2003}, @samp{f2008}, and @samp{f2018} values specify strict
-conformance to the Fortran 95, Fortran 2003, Fortran 2008 and Fortran
-2018 standards, respectively; errors are given for all extensions
+be useful for old non-standard programs.  The @samp{f95}, @samp{f2003},
+@samp{f2008}, @samp{f2018}, and @samp{f2023} values specify strict
+conformance to the Fortran 95, Fortran 2003, Fortran 2008, Fortran 2018
+and Fortran 2023 standards, respectively; errors are given for all extensions
 beyond the relevant language standard, and warnings are given for the
 Fortran 77 features that are permitted but obsolescent in later
 standards. The deprecated option @samp{-std=f2008ts} acts as an alias for
@@ -910,7 +910,8 @@ nonstandard practices, but not all.
 However, improvements to GNU Fortran in this area are welcome.
 
 This should be used in conjunction with @option{-std=f95},
-@option{-std=f2003}, @option{-std=f2008} or @option{-std=f2018}.
+@option{-std=f2003}, @option{-std=f2008}, @option{-std=f2018}
+or @option{-std=f2023}.
 
 @opindex @code{pedantic-errors}
 @item -pedantic-errors
@@ -958,8 +959,8 @@ The following example will trigger the warning.
 @item -Wampersand
 Warn about missing ampersand in continued character constants. The
 warning is given with @option{-Wampersand}, @option{-pedantic},
-@option{-std=f95}, @option{-std=f2003}, @option{-std=f2008} and
-@option{-std=f2018}. Note: With no ampersand given in a continued
+@option{-std=f95}, @option{-std=f2003}, @option{-std=f2008}, @option{-std=f2018}
+and @option{-std=f2023}. Note: With no ampersand given in a continued
 character constant, GNU Fortran assumes continuation at the first
 non-comment, non-whitespace character after the ampersand that
 initiated the continuation.
@@ -1108,7 +1109,7 @@ of the Fortran Character Set.  For continuation lines, a tab followed
 by a digit between 1 and 9 is supported.  @option{-Wtabs} will cause a
 warning to be issued if a tab is encountered. Note, @option{-Wtabs} is
 active for @option{-pedantic}, @option{-std=f95}, @option{-std=f2003},
-@option{-std=f2008}, @option{-std=f2018} and
+@option{-std=f2008}, @option{-std=f2018}, @option{-std=f2023} and
 @option{-Wall}.
 
 @opindex @code{Wundefined-do-loop}
diff --git a/gcc/fortran/lang.opt b/gcc/fortran/lang.opt
index 7236351..08c7539 100644
--- a/gcc/fortran/lang.opt
+++ b/gcc/fortran/lang.opt
@@ -883,6 +883,10 @@ std=f2018
 Fortran
 Conform to the ISO Fortran 2018 standard.
 
+std=f2023
+Fortran
+Conform to the ISO Fortran 2023 standard.
+
 std=f95
 Fortran
 Conform to the ISO Fortran 95 standard.
diff --git a/gcc/fortran/libgfortran.h b/gcc/fortran/libgfortran.h
index cb84b59..bdddb31 100644
--- a/gcc/fortran/libgfortran.h
+++ b/gcc/fortran/libgfortran.h
@@ -19,9 +19,10 @@ along with GCC; see the file COPYING3.  If not see
 
 
 /* Flags to specify which standard/extension contains a feature.
-   Note that no features were obsoleted nor deleted in F2003.
+   Note that no features were obsoleted nor deleted in F2003 nor in F2023.
    Please remember to keep those definitions in sync with
    gfortran.texi.  */
+#define GFC_STD_F2023		(1<<12)	/* New in F2023.  */
 #define GFC_STD_F2018_DEL	(1<<11)	/* Deleted in F2018.  */
 #define GFC_STD_F2018_OBS	(1<<10)	/* Obsolescent in F2018.  */
 #define GFC_STD_F2018		(1<<9)	/* New in F2018.  */
@@ -45,6 +46,7 @@ along with GCC; see the file COPYING3.  If not see
 #define GFC_STD_OPT_F08		(GFC_STD_OPT_F03 | GFC_STD_F2008)
 #define GFC_STD_OPT_F18		((GFC_STD_OPT_F08 | GFC_STD_F2018) \
 				& (~GFC_STD_F2018_DEL))
+#define GFC_STD_OPT_F23		(GFC_STD_OPT_F18 | GFC_STD_F2023)
 
 /* Bitmasks for the various FPE that can be enabled.  These need to be straight integers
    e.g., 8 instead of (1<<3), because they will be included in Fortran source.  */
diff --git a/gcc/fortran/options.cc b/gcc/fortran/options.cc
index cfb1957..b788521 100644
--- a/gcc/fortran/options.cc
+++ b/gcc/fortran/options.cc
@@ -57,7 +57,7 @@ set_default_std_flags (void)
   gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F95_DEL
     | GFC_STD_F2003 | GFC_STD_F2008 | GFC_STD_F95 | GFC_STD_F77
     | GFC_STD_F2008_OBS | GFC_STD_GNU | GFC_STD_LEGACY
-    | GFC_STD_F2018 | GFC_STD_F2018_DEL | GFC_STD_F2018_OBS;
+    | GFC_STD_F2018 | GFC_STD_F2018_DEL | GFC_STD_F2018_OBS | GFC_STD_F2023;
   gfc_option.warn_std = GFC_STD_F2018_DEL | GFC_STD_F95_DEL | GFC_STD_LEGACY;
 }
 
@@ -143,8 +143,11 @@ gfc_init_options (unsigned int decoded_options_count,
   gfc_source_file = NULL;
   gfc_option.module_dir = NULL;
   gfc_option.source_form = FORM_UNKNOWN;
-  gfc_option.max_continue_fixed = 255;
-  gfc_option.max_continue_free = 255;
+  /* The following is not quite right as Fortran since 2023 has: "A statement
+      shall not have more than one million characters."  This can already be
+      reached by 'just' 100 lines with 10,000 characters each.  */
+  gfc_option.max_continue_fixed = 1000000;
+  gfc_option.max_continue_free = 1000000;
   gfc_option.max_identifier_length = GFC_MAX_SYMBOL_LEN;
   gfc_option.max_errors = 25;
 
@@ -266,6 +269,10 @@ gfc_post_options (const char **pfilename)
 		       cpp_warn_missing_include_dirs, 1);
   gfc_check_include_dirs (verbose_missing_dir_warn);
 
+  SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+		       flag_free_line_length,
+		       (gfc_option.allow_std & GFC_STD_F2023) ? 10000 : 132);
+
   /* Finalize DEC flags.  */
   post_dec_flags (flag_dec);
 
@@ -769,6 +776,8 @@ gfc_handle_option (size_t scode, const char *arg, HOST_WIDE_INT value,
     case OPT_std_f2003:
       gfc_option.allow_std = GFC_STD_OPT_F03;
       gfc_option.warn_std = GFC_STD_F95_OBS;
+      gfc_option.max_continue_fixed = 255;
+      gfc_option.max_continue_free = 255;
       gfc_option.max_identifier_length = 63;
       warn_ampersand = 1;
       warn_tabs = 1;
@@ -777,6 +786,8 @@ gfc_handle_option (size_t scode, const char *arg, HOST_WIDE_INT value,
     case OPT_std_f2008:
       gfc_option.allow_std = GFC_STD_OPT_F08;
       gfc_option.warn_std = GFC_STD_F95_OBS | GFC_STD_F2008_OBS;
+      gfc_option.max_continue_free = 255;
+      gfc_option.max_continue_fixed = 255;
       gfc_option.max_identifier_length = 63;
       warn_ampersand = 1;
       warn_tabs = 1;
@@ -787,6 +798,17 @@ gfc_handle_option (size_t scode, const char *arg, HOST_WIDE_INT value,
       gfc_option.allow_std = GFC_STD_OPT_F18;
       gfc_option.warn_std = GFC_STD_F95_OBS | GFC_STD_F2008_OBS
 	| GFC_STD_F2018_OBS;
+      gfc_option.max_continue_free = 255;
+      gfc_option.max_continue_fixed = 255;
+      gfc_option.max_identifier_length = 63;
+      warn_ampersand = 1;
+      warn_tabs = 1;
+      break;
+
+    case OPT_std_f2023:
+      gfc_option.allow_std = GFC_STD_OPT_F23;
+      gfc_option.warn_std = GFC_STD_F95_OBS | GFC_STD_F2008_OBS
+	| GFC_STD_F2018_OBS;
       gfc_option.max_identifier_length = 63;
       warn_ampersand = 1;
       warn_tabs = 1;
diff --git a/gcc/gcc-rich-location.cc b/gcc/gcc-rich-location.cc
index edecf07..2fb0cc7 100644
--- a/gcc/gcc-rich-location.cc
+++ b/gcc/gcc-rich-location.cc
@@ -75,10 +75,11 @@ gcc_rich_location::add_fixit_misspelled_id (location_t misspelled_token_loc,
 /* Return true if there is nothing on LOC's line before LOC.  */
 
 static bool
-blank_line_before_p (location_t loc)
+blank_line_before_p (file_cache &fc,
+		     location_t loc)
 {
   expanded_location exploc = expand_location (loc);
-  char_span line = location_get_source_line (exploc.file, exploc.line);
+  char_span line = fc.get_source_line (exploc.file, exploc.line);
   if (!line)
     return false;
   if (line.length () < (size_t)exploc.column)
@@ -96,7 +97,8 @@ blank_line_before_p (location_t loc)
    If true is returned then *OUT_START_OF_LINE is written to.  */
 
 static bool
-use_new_line (location_t insertion_point, location_t indent,
+use_new_line (file_cache &fc,
+	      location_t insertion_point, location_t indent,
 	      location_t *out_start_of_line)
 {
   if (indent == UNKNOWN_LOCATION)
@@ -105,7 +107,7 @@ use_new_line (location_t insertion_point, location_t indent,
   if (linemap_macro_expansion_map_p (indent_map))
     return false;
 
-  if (!blank_line_before_p (insertion_point))
+  if (!blank_line_before_p (fc, insertion_point))
     return false;
 
   /* Locate the start of the line containing INSERTION_POINT.  */
@@ -162,7 +164,8 @@ gcc_rich_location::add_fixit_insert_formatted (const char *content,
 					       location_t indent)
 {
   location_t start_of_line;
-  if (use_new_line (insertion_point, indent, &start_of_line))
+  if (use_new_line (global_dc->get_file_cache (),
+		    insertion_point, indent, &start_of_line))
     {
       /* Add CONTENT on its own line, using the indentation of INDENT.  */
 
@@ -200,7 +203,7 @@ maybe_range_label_for_tree_type_mismatch::get_text (unsigned range_idx) const
   tree expr_type = TREE_TYPE (m_expr);
 
   tree other_type = NULL_TREE;
-  if (CAN_HAVE_LOCATION_P (m_other_expr))
+  if (m_other_expr && EXPR_P (m_other_expr))
     other_type = TREE_TYPE (m_other_expr);
 
   range_label_for_type_mismatch inner (expr_type, other_type);
diff --git a/gcc/gcc-rich-location.h b/gcc/gcc-rich-location.h
index ffba4b8..e42daa4 100644
--- a/gcc/gcc-rich-location.h
+++ b/gcc/gcc-rich-location.h
@@ -20,6 +20,8 @@ along with GCC; see the file COPYING3.  If not see
 #ifndef GCC_RICH_LOCATION_H
 #define GCC_RICH_LOCATION_H
 
+#include "rich-location.h"
+
 /* A gcc_rich_location is libcpp's rich_location with additional
    helper methods for working with gcc's types.  The class is not
    copyable or assignable because rich_location isn't. */
diff --git a/gcc/gcov.cc b/gcc/gcov.cc
index 2fad6aa..8b4748d 100644
--- a/gcc/gcov.cc
+++ b/gcc/gcov.cc
@@ -1109,12 +1109,11 @@ output_intermediate_json_line (json::array *object,
     return;
 
   json::object *lineo = new json::object ();
-  lineo->set ("line_number", new json::integer_number (line_num));
+  lineo->set_integer ("line_number", line_num);
   if (function_name != NULL)
-    lineo->set ("function_name", new json::string (function_name));
-  lineo->set ("count", new json::integer_number (line->count));
-  lineo->set ("unexecuted_block",
-	      new json::literal (line->has_unexecuted_block));
+    lineo->set_string ("function_name", function_name);
+  lineo->set_integer ("count", line->count);
+  lineo->set_bool ("unexecuted_block", line->has_unexecuted_block);
 
   json::array *bb_ids = new json::array ();
   for (const block_info *block : line->blocks)
@@ -1135,25 +1134,20 @@ output_intermediate_json_line (json::array *object,
 	if (!(*it)->is_unconditional && !(*it)->is_call_non_return)
 	  {
 	    json::object *branch = new json::object ();
-	    branch->set ("count", new json::integer_number ((*it)->count));
-	    branch->set ("throw", new json::literal ((*it)->is_throw));
-	    branch->set ("fallthrough",
-			 new json::literal ((*it)->fall_through));
-	    branch->set ("source_block_id",
-			 new json::integer_number ((*it)->src->id));
-	    branch->set ("destination_block_id",
-			 new json::integer_number ((*it)->dst->id));
+	    branch->set_integer ("count", (*it)->count);
+	    branch->set_bool ("throw", (*it)->is_throw);
+	    branch->set_bool ("fallthrough", (*it)->fall_through);
+	    branch->set_integer ("source_block_id", (*it)->src->id);
+	    branch->set_integer ("destination_block_id", (*it)->dst->id);
 	    branches->append (branch);
 	  }
 	else if ((*it)->is_call_non_return)
 	  {
 	    json::object *call = new json::object ();
 	    gcov_type returns = (*it)->src->count - (*it)->count;
-	    call->set ("source_block_id",
-		       new json::integer_number ((*it)->src->id));
-	    call->set ("destination_block_id",
-		       new json::integer_number ((*it)->dst->id));
-	    call->set ("returned", new json::integer_number (returns));
+	    call->set_integer ("source_block_id", (*it)->src->id);
+	    call->set_integer ("destination_block_id", (*it)->dst->id);
+	    call->set_integer ("returned", returns);
 	    calls->append (call);
 	  }
       }
@@ -1236,7 +1230,7 @@ output_json_intermediate_file (json::array *json_files, source_info *src)
   json::object *root = new json::object ();
   json_files->append (root);
 
-  root->set ("file", new json::string (src->name));
+  root->set_string ("file", src->name);
 
   json::array *functions = new json::array ();
   root->set ("functions", functions);
@@ -1247,22 +1241,15 @@ output_json_intermediate_file (json::array *json_files, source_info *src)
        it != src->functions.end (); it++)
     {
       json::object *function = new json::object ();
-      function->set ("name", new json::string ((*it)->m_name));
-      function->set ("demangled_name",
-		     new json::string ((*it)->get_demangled_name ()));
-      function->set ("start_line",
-		     new json::integer_number ((*it)->start_line));
-      function->set ("start_column",
-		     new json::integer_number ((*it)->start_column));
-      function->set ("end_line", new json::integer_number ((*it)->end_line));
-      function->set ("end_column",
-		     new json::integer_number ((*it)->end_column));
-      function->set ("blocks",
-		     new json::integer_number ((*it)->get_block_count ()));
-      function->set ("blocks_executed",
-		     new json::integer_number ((*it)->blocks_executed));
-      function->set ("execution_count",
-		     new json::integer_number ((*it)->blocks[0].count));
+      function->set_string ("name", (*it)->m_name);
+      function->set_string ("demangled_name", (*it)->get_demangled_name ());
+      function->set_integer ("start_line", (*it)->start_line);
+      function->set_integer ("start_column", (*it)->start_column);
+      function->set_integer ("end_line", (*it)->end_line);
+      function->set_integer ("end_column", (*it)->end_column);
+      function->set_integer ("blocks", (*it)->get_block_count ());
+      function->set_integer ("blocks_executed", (*it)->blocks_executed);
+      function->set_integer ("execution_count", (*it)->blocks[0].count);
 
       functions->append (function);
     }
@@ -1549,12 +1536,12 @@ generate_results (const char *file_name)
   gcov_intermediate_filename = get_gcov_intermediate_filename (file_name);
 
   json::object *root = new json::object ();
-  root->set ("format_version", new json::string (GCOV_JSON_FORMAT_VERSION));
-  root->set ("gcc_version", new json::string (version_string));
+  root->set_string ("format_version", GCOV_JSON_FORMAT_VERSION);
+  root->set_string ("gcc_version", version_string);
 
   if (bbg_cwd != NULL)
-    root->set ("current_working_directory", new json::string (bbg_cwd));
-  root->set ("data_file", new json::string (file_name));
+    root->set_string ("current_working_directory", bbg_cwd);
+  root->set_string ("data_file", file_name);
 
   json::array *json_files = new json::array ();
   root->set ("files", json_files);
diff --git a/gcc/genmatch.cc b/gcc/genmatch.cc
index 4572342..98268ee 100644
--- a/gcc/genmatch.cc
+++ b/gcc/genmatch.cc
@@ -25,6 +25,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "system.h"
 #include "coretypes.h"
 #include <cpplib.h>
+#include "rich-location.h"
 #include "errors.h"
 #include "hash-table.h"
 #include "hash-set.h"
@@ -1896,8 +1897,14 @@ cmp_operand (operand *o1, operand *o2)
     {
       expr *e1 = static_cast<expr *>(o1);
       expr *e2 = static_cast<expr *>(o2);
-      return (e1->operation == e2->operation
-	      && e1->is_generic == e2->is_generic);
+      if (e1->operation != e2->operation
+	  || e1->is_generic != e2->is_generic)
+	return false;
+      if (e1->operation->kind == id_base::FN
+	  /* For function calls also compare number of arguments.  */
+	  && e1->ops.length () != e2->ops.length ())
+	return false;
+      return true;
     }
   else
     return false;
@@ -3071,6 +3078,26 @@ dt_operand::gen_generic_expr (FILE *f, int indent, const char *opname)
   return 0;
 }
 
+/* Compare 2 fns or generic_fns vector entries for vector sorting.
+   Same operation entries with different number of arguments should
+   be adjacent.  */
+
+static int
+fns_cmp (const void *p1, const void *p2)
+{
+  dt_operand *op1 = *(dt_operand *const *) p1;
+  dt_operand *op2 = *(dt_operand *const *) p2;
+  expr *e1 = as_a <expr *> (op1->op);
+  expr *e2 = as_a <expr *> (op2->op);
+  id_base *b1 = e1->operation;
+  id_base *b2 = e2->operation;
+  if (b1->hashval < b2->hashval)
+    return -1;
+  if (b1->hashval > b2->hashval)
+    return 1;
+  return strcmp (b1->id, b2->id);
+}
+
 /* Generate matching code for the children of the decision tree node.  */
 
 void
@@ -3144,6 +3171,8 @@ dt_node::gen_kids (FILE *f, int indent, bool gimple, int depth)
 	     Like DT_TRUE, DT_MATCH serves as a barrier as it can cause
 	     dependent matches to get out-of-order.  Generate code now
 	     for what we have collected sofar.  */
+	  fns.qsort (fns_cmp);
+	  generic_fns.qsort (fns_cmp);
 	  gen_kids_1 (f, indent, gimple, depth, gimple_exprs, generic_exprs,
 		      fns, generic_fns, preds, others);
 	  /* And output the true operand itself.  */
@@ -3160,6 +3189,8 @@ dt_node::gen_kids (FILE *f, int indent, bool gimple, int depth)
     }
 
   /* Generate code for the remains.  */
+  fns.qsort (fns_cmp);
+  generic_fns.qsort (fns_cmp);
   gen_kids_1 (f, indent, gimple, depth, gimple_exprs, generic_exprs,
 	      fns, generic_fns, preds, others);
 }
@@ -3257,14 +3288,21 @@ dt_node::gen_kids_1 (FILE *f, int indent, bool gimple, int depth,
 
 	  indent += 4;
 	  fprintf_indent (f, indent, "{\n");
+	  id_base *last_op = NULL;
 	  for (unsigned i = 0; i < fns_len; ++i)
 	    {
 	      expr *e = as_a <expr *>(fns[i]->op);
-	      if (user_id *u = dyn_cast <user_id *> (e->operation))
-		for (auto id : u->substitutes)
-		  fprintf_indent (f, indent, "case %s:\n", id->id);
-	      else
-		fprintf_indent (f, indent, "case %s:\n", e->operation->id);
+	      if (e->operation != last_op)
+		{
+		  if (i)
+		    fprintf_indent (f, indent, "  break;\n");
+		  if (user_id *u = dyn_cast <user_id *> (e->operation))
+		    for (auto id : u->substitutes)
+		      fprintf_indent (f, indent, "case %s:\n", id->id);
+		  else
+		    fprintf_indent (f, indent, "case %s:\n", e->operation->id);
+		}
+	      last_op = e->operation;
 	      /* We need to be defensive against bogus prototypes allowing
 		 calls with not enough arguments.  */
 	      fprintf_indent (f, indent,
@@ -3273,9 +3311,9 @@ dt_node::gen_kids_1 (FILE *f, int indent, bool gimple, int depth,
 	      fprintf_indent (f, indent, "    {\n");
 	      fns[i]->gen (f, indent + 6, true, depth);
 	      fprintf_indent (f, indent, "    }\n");
-	      fprintf_indent (f, indent, "  break;\n");
 	    }
 
+	  fprintf_indent (f, indent, "  break;\n");
 	  fprintf_indent (f, indent, "default:;\n");
 	  fprintf_indent (f, indent, "}\n");
 	  indent -= 4;
@@ -3335,18 +3373,25 @@ dt_node::gen_kids_1 (FILE *f, int indent, bool gimple, int depth,
 		      "    {\n");
       indent += 4;
 
+      id_base *last_op = NULL;
       for (unsigned j = 0; j < generic_fns.length (); ++j)
 	{
 	  expr *e = as_a <expr *>(generic_fns[j]->op);
 	  gcc_assert (e->operation->kind == id_base::FN);
 
-	  fprintf_indent (f, indent, "case %s:\n", e->operation->id);
+	  if (e->operation != last_op)
+	    {
+	      if (j)
+		fprintf_indent (f, indent, "  break;\n");
+	      fprintf_indent (f, indent, "case %s:\n", e->operation->id);
+	    }
+	  last_op = e->operation;
 	  fprintf_indent (f, indent, "  if (call_expr_nargs (%s) == %d)\n"
 				     "    {\n", kid_opname, e->ops.length ());
 	  generic_fns[j]->gen (f, indent + 6, false, depth);
-	  fprintf_indent (f, indent, "    }\n"
-				     "  break;\n");
+	  fprintf_indent (f, indent, "    }\n");
 	}
+      fprintf_indent (f, indent, "  break;\n");
       fprintf_indent (f, indent, "default:;\n");
 
       indent -= 4;
diff --git a/gcc/gimple-lower-bitint.cc b/gcc/gimple-lower-bitint.cc
index 6655859..c429cb2 100644
--- a/gcc/gimple-lower-bitint.cc
+++ b/gcc/gimple-lower-bitint.cc
@@ -427,6 +427,7 @@ struct bitint_large_huge
   void lower_mul_overflow (tree, gimple *);
   void lower_cplxpart_stmt (tree, gimple *);
   void lower_complexexpr_stmt (gimple *);
+  void lower_bit_query (gimple *);
   void lower_call (tree, gimple *);
   void lower_asm (gimple *);
   void lower_stmt (gimple *);
@@ -4455,6 +4456,524 @@ bitint_large_huge::lower_complexexpr_stmt (gimple *stmt)
   insert_before (g);
 }
 
+/* Lower a .{CLZ,CTZ,CLRSB,FFS,PARITY,POPCOUNT} call with one large/huge _BitInt
+   argument.  */
+
+void
+bitint_large_huge::lower_bit_query (gimple *stmt)
+{
+  tree arg0 = gimple_call_arg (stmt, 0);
+  tree arg1 = (gimple_call_num_args (stmt) == 2
+	       ? gimple_call_arg (stmt, 1) : NULL_TREE);
+  tree lhs = gimple_call_lhs (stmt);
+  gimple *g;
+
+  if (!lhs)
+    {
+      gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
+      gsi_remove (&gsi, true);
+      return;
+    }
+  tree type = TREE_TYPE (arg0);
+  gcc_assert (TREE_CODE (type) == BITINT_TYPE);
+  bitint_prec_kind kind = bitint_precision_kind (type);
+  gcc_assert (kind >= bitint_prec_large);
+  enum internal_fn ifn = gimple_call_internal_fn (stmt);
+  enum built_in_function fcode = END_BUILTINS;
+  gcc_assert (TYPE_PRECISION (unsigned_type_node) == limb_prec
+	      || TYPE_PRECISION (long_unsigned_type_node) == limb_prec
+	      || TYPE_PRECISION (long_long_unsigned_type_node) == limb_prec);
+  switch (ifn)
+    {
+    case IFN_CLZ:
+      if (TYPE_PRECISION (unsigned_type_node) == limb_prec)
+	fcode = BUILT_IN_CLZ;
+      else if (TYPE_PRECISION (long_unsigned_type_node) == limb_prec)
+	fcode = BUILT_IN_CLZL;
+      else
+	fcode = BUILT_IN_CLZLL;
+      break;
+    case IFN_FFS:
+      /* .FFS (X) is .CTZ (X, -1) + 1, though under the hood
+	 we don't add the addend at the end.  */
+      arg1 = integer_zero_node;
+      /* FALLTHRU */
+    case IFN_CTZ:
+      if (TYPE_PRECISION (unsigned_type_node) == limb_prec)
+	fcode = BUILT_IN_CTZ;
+      else if (TYPE_PRECISION (long_unsigned_type_node) == limb_prec)
+	fcode = BUILT_IN_CTZL;
+      else
+	fcode = BUILT_IN_CTZLL;
+      m_upwards = true;
+      break;
+    case IFN_CLRSB:
+      if (TYPE_PRECISION (unsigned_type_node) == limb_prec)
+	fcode = BUILT_IN_CLRSB;
+      else if (TYPE_PRECISION (long_unsigned_type_node) == limb_prec)
+	fcode = BUILT_IN_CLRSBL;
+      else
+	fcode = BUILT_IN_CLRSBLL;
+      break;
+    case IFN_PARITY:
+      if (TYPE_PRECISION (unsigned_type_node) == limb_prec)
+	fcode = BUILT_IN_PARITY;
+      else if (TYPE_PRECISION (long_unsigned_type_node) == limb_prec)
+	fcode = BUILT_IN_PARITYL;
+      else
+	fcode = BUILT_IN_PARITYLL;
+      m_upwards = true;
+      break;
+    case IFN_POPCOUNT:
+      if (TYPE_PRECISION (unsigned_type_node) == limb_prec)
+	fcode = BUILT_IN_POPCOUNT;
+      else if (TYPE_PRECISION (long_unsigned_type_node) == limb_prec)
+	fcode = BUILT_IN_POPCOUNTL;
+      else
+	fcode = BUILT_IN_POPCOUNTLL;
+      m_upwards = true;
+      break;
+    default:
+      gcc_unreachable ();
+    }
+  tree fndecl = builtin_decl_explicit (fcode), res = NULL_TREE;
+  unsigned cnt = 0, rem = 0, end = 0, prec = TYPE_PRECISION (type);
+  struct bq_details { edge e; tree val, addend; } *bqp = NULL;
+  basic_block edge_bb = NULL;
+  if (m_upwards)
+    {
+      tree idx = NULL_TREE, idx_first = NULL_TREE, idx_next = NULL_TREE;
+      if (kind == bitint_prec_large)
+	cnt = CEIL (prec, limb_prec);
+      else
+	{
+	  rem = (prec % (2 * limb_prec));
+	  end = (prec - rem) / limb_prec;
+	  cnt = 2 + CEIL (rem, limb_prec);
+	  idx = idx_first = create_loop (size_zero_node, &idx_next);
+	}
+
+      if (ifn == IFN_CTZ || ifn == IFN_FFS)
+	{
+	  gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
+	  gsi_prev (&gsi);
+	  edge e = split_block (gsi_bb (gsi), gsi_stmt (gsi));
+	  edge_bb = e->src;
+	  if (kind == bitint_prec_large)
+	    {
+	      m_gsi = gsi_last_bb (edge_bb);
+	      if (!gsi_end_p (m_gsi))
+		gsi_next (&m_gsi);
+	    }
+	  bqp = XALLOCAVEC (struct bq_details, cnt);
+	}
+      else
+	m_after_stmt = stmt;
+      if (kind != bitint_prec_large)
+	m_upwards_2limb = end;
+
+      for (unsigned i = 0; i < cnt; i++)
+	{
+	  m_data_cnt = 0;
+	  if (kind == bitint_prec_large)
+	    idx = size_int (i);
+	  else if (i >= 2)
+	    idx = size_int (end + (i > 2));
+
+	  tree rhs1 = handle_operand (arg0, idx);
+	  if (!useless_type_conversion_p (m_limb_type, TREE_TYPE (rhs1)))
+	    {
+	      if (!TYPE_UNSIGNED (TREE_TYPE (rhs1)))
+		rhs1 = add_cast (unsigned_type_for (TREE_TYPE (rhs1)), rhs1);
+	      rhs1 = add_cast (m_limb_type, rhs1);
+	    }
+
+	  tree in, out, tem;
+	  if (ifn == IFN_PARITY)
+	    in = prepare_data_in_out (build_zero_cst (m_limb_type), idx, &out);
+	  else if (ifn == IFN_FFS)
+	    in = prepare_data_in_out (integer_one_node, idx, &out);
+	  else
+	    in = prepare_data_in_out (integer_zero_node, idx, &out);
+
+	  switch (ifn)
+	    {
+	    case IFN_CTZ:
+	    case IFN_FFS:
+	      g = gimple_build_cond (NE_EXPR, rhs1,
+				     build_zero_cst (m_limb_type),
+				     NULL_TREE, NULL_TREE);
+	      insert_before (g);
+	      edge e1, e2;
+	      e1 = split_block (gsi_bb (m_gsi), g);
+	      e1->flags = EDGE_FALSE_VALUE;
+	      e2 = make_edge (e1->src, gimple_bb (stmt), EDGE_TRUE_VALUE);
+	      e1->probability = profile_probability::unlikely ();
+	      e2->probability = e1->probability.invert ();
+	      if (i == 0)
+		set_immediate_dominator (CDI_DOMINATORS, e2->dest, e2->src);
+	      m_gsi = gsi_after_labels (e1->dest);
+	      bqp[i].e = e2;
+	      bqp[i].val = rhs1;
+	      if (tree_fits_uhwi_p (idx))
+		bqp[i].addend
+		  = build_int_cst (integer_type_node,
+				   tree_to_uhwi (idx) * limb_prec
+				   + (ifn == IFN_FFS));
+	      else
+		{
+		  bqp[i].addend = in;
+		  if (i == 1)
+		    res = out;
+		  else
+		    res = make_ssa_name (integer_type_node);
+		  g = gimple_build_assign (res, PLUS_EXPR, in,
+					   build_int_cst (integer_type_node,
+							  limb_prec));
+		  insert_before (g);
+		  m_data[m_data_cnt] = res;
+		}
+	      break;
+	    case IFN_PARITY:
+	      if (!integer_zerop (in))
+		{
+		  if (kind == bitint_prec_huge && i == 1)
+		    res = out;
+		  else
+		    res = make_ssa_name (m_limb_type);
+		  g = gimple_build_assign (res, BIT_XOR_EXPR, in, rhs1);
+		  insert_before (g);
+		}
+	      else
+		res = rhs1;
+	      m_data[m_data_cnt] = res;
+	      break;
+	    case IFN_POPCOUNT:
+	      g = gimple_build_call (fndecl, 1, rhs1);
+	      tem = make_ssa_name (integer_type_node);
+	      gimple_call_set_lhs (g, tem);
+	      insert_before (g);
+	      if (!integer_zerop (in))
+		{
+		  if (kind == bitint_prec_huge && i == 1)
+		    res = out;
+		  else
+		    res = make_ssa_name (integer_type_node);
+		  g = gimple_build_assign (res, PLUS_EXPR, in, tem);
+		  insert_before (g);
+		}
+	      else
+		res = tem;
+	      m_data[m_data_cnt] = res;
+	      break;
+	    default:
+	      gcc_unreachable ();
+	    }
+
+	  m_first = false;
+	  if (kind == bitint_prec_huge && i <= 1)
+	    {
+	      if (i == 0)
+		{
+		  idx = make_ssa_name (sizetype);
+		  g = gimple_build_assign (idx, PLUS_EXPR, idx_first,
+					   size_one_node);
+		  insert_before (g);
+		}
+	      else
+		{
+		  g = gimple_build_assign (idx_next, PLUS_EXPR, idx_first,
+					   size_int (2));
+		  insert_before (g);
+		  g = gimple_build_cond (NE_EXPR, idx_next, size_int (end),
+					 NULL_TREE, NULL_TREE);
+		  insert_before (g);
+		  if (ifn == IFN_CTZ || ifn == IFN_FFS)
+		    m_gsi = gsi_after_labels (edge_bb);
+		  else
+		    m_gsi = gsi_for_stmt (stmt);
+		}
+	    }
+	}
+    }
+  else
+    {
+      tree idx = NULL_TREE, idx_next = NULL_TREE, first = NULL_TREE;
+      int sub_one = 0;
+      if (kind == bitint_prec_large)
+	cnt = CEIL (prec, limb_prec);
+      else
+	{
+	  rem = prec % limb_prec;
+	  if (rem == 0 && (!TYPE_UNSIGNED (type) || ifn == IFN_CLRSB))
+	    rem = limb_prec;
+	  end = (prec - rem) / limb_prec;
+	  cnt = 1 + (rem != 0);
+	  if (ifn == IFN_CLRSB)
+	    sub_one = 1;
+	}
+
+      gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
+      gsi_prev (&gsi);
+      edge e = split_block (gsi_bb (gsi), gsi_stmt (gsi));
+      edge_bb = e->src;
+      m_gsi = gsi_last_bb (edge_bb);
+      if (!gsi_end_p (m_gsi))
+	gsi_next (&m_gsi);
+
+      if (ifn == IFN_CLZ)
+	bqp = XALLOCAVEC (struct bq_details, cnt);
+      else
+	{
+	  gsi = gsi_for_stmt (stmt);
+	  gsi_prev (&gsi);
+	  e = split_block (gsi_bb (gsi), gsi_stmt (gsi));
+	  edge_bb = e->src;
+	  bqp = XALLOCAVEC (struct bq_details, 2 * cnt);
+	}
+
+      for (unsigned i = 0; i < cnt; i++)
+	{
+	  m_data_cnt = 0;
+	  if (kind == bitint_prec_large)
+	    idx = size_int (cnt - i - 1);
+	  else if (i == cnt - 1)
+	    idx = create_loop (size_int (end - 1), &idx_next);
+	  else
+	    idx = size_int (end);
+
+	  tree rhs1 = handle_operand (arg0, idx);
+	  if (!useless_type_conversion_p (m_limb_type, TREE_TYPE (rhs1)))
+	    {
+	      if (ifn == IFN_CLZ && !TYPE_UNSIGNED (TREE_TYPE (rhs1)))
+		rhs1 = add_cast (unsigned_type_for (TREE_TYPE (rhs1)), rhs1);
+	      else if (ifn == IFN_CLRSB && TYPE_UNSIGNED (TREE_TYPE (rhs1)))
+		rhs1 = add_cast (signed_type_for (TREE_TYPE (rhs1)), rhs1);
+	      rhs1 = add_cast (m_limb_type, rhs1);
+	    }
+
+	  if (ifn == IFN_CLZ)
+	    {
+	      g = gimple_build_cond (NE_EXPR, rhs1,
+				     build_zero_cst (m_limb_type),
+				     NULL_TREE, NULL_TREE);
+	      insert_before (g);
+	      edge e1 = split_block (gsi_bb (m_gsi), g);
+	      e1->flags = EDGE_FALSE_VALUE;
+	      edge e2 = make_edge (e1->src, gimple_bb (stmt), EDGE_TRUE_VALUE);
+	      e1->probability = profile_probability::unlikely ();
+	      e2->probability = e1->probability.invert ();
+	      if (i == 0)
+		set_immediate_dominator (CDI_DOMINATORS, e2->dest, e2->src);
+	      m_gsi = gsi_after_labels (e1->dest);
+	      bqp[i].e = e2;
+	      bqp[i].val = rhs1;
+	    }
+	  else
+	    {
+	      if (i == 0)
+		{
+		  first = rhs1;
+		  g = gimple_build_assign (make_ssa_name (m_limb_type),
+					   PLUS_EXPR, rhs1,
+					   build_int_cst (m_limb_type, 1));
+		  insert_before (g);
+		  g = gimple_build_cond (GT_EXPR, gimple_assign_lhs (g),
+					 build_int_cst (m_limb_type, 1),
+					 NULL_TREE, NULL_TREE);
+		  insert_before (g);
+		}
+	      else
+		{
+		  g = gimple_build_assign (make_ssa_name (m_limb_type),
+					   BIT_XOR_EXPR, rhs1, first);
+		  insert_before (g);
+		  tree stype = signed_type_for (m_limb_type);
+		  g = gimple_build_cond (LT_EXPR,
+					 add_cast (stype,
+						   gimple_assign_lhs (g)),
+					 build_zero_cst (stype),
+					 NULL_TREE, NULL_TREE);
+		  insert_before (g);
+		  edge e1 = split_block (gsi_bb (m_gsi), g);
+		  e1->flags = EDGE_FALSE_VALUE;
+		  edge e2 = make_edge (e1->src, gimple_bb (stmt),
+				       EDGE_TRUE_VALUE);
+		  e1->probability = profile_probability::unlikely ();
+		  e2->probability = e1->probability.invert ();
+		  if (i == 1)
+		    set_immediate_dominator (CDI_DOMINATORS, e2->dest,
+					     e2->src);
+		  m_gsi = gsi_after_labels (e1->dest);
+		  bqp[2 * i].e = e2;
+		  g = gimple_build_cond (NE_EXPR, rhs1, first,
+					 NULL_TREE, NULL_TREE);
+		  insert_before (g);
+		}
+	      edge e1 = split_block (gsi_bb (m_gsi), g);
+	      e1->flags = EDGE_FALSE_VALUE;
+	      edge e2 = make_edge (e1->src, edge_bb, EDGE_TRUE_VALUE);
+	      e1->probability = profile_probability::unlikely ();
+	      e2->probability = e1->probability.invert ();
+	      if (i == 0)
+		set_immediate_dominator (CDI_DOMINATORS, e2->dest, e2->src);
+	      m_gsi = gsi_after_labels (e1->dest);
+	      bqp[2 * i + 1].e = e2;
+	      bqp[i].val = rhs1;
+	    }
+	  if (tree_fits_uhwi_p (idx))
+	    bqp[i].addend
+	      = build_int_cst (integer_type_node,
+			       (int) prec
+			       - (((int) tree_to_uhwi (idx) + 1)
+				  * limb_prec) - sub_one);
+	  else
+	    {
+	      tree in, out;
+	      in = build_int_cst (integer_type_node, rem - sub_one);
+	      m_first = true;
+	      in = prepare_data_in_out (in, idx, &out);
+	      out = m_data[m_data_cnt + 1];
+	      bqp[i].addend = in;
+	      g = gimple_build_assign (out, PLUS_EXPR, in,
+				       build_int_cst (integer_type_node,
+						      limb_prec));
+	      insert_before (g);
+	      m_data[m_data_cnt] = out;
+	    }
+
+	  m_first = false;
+	  if (kind == bitint_prec_huge && i == cnt - 1)
+	    {
+	      g = gimple_build_assign (idx_next, PLUS_EXPR, idx,
+				       size_int (-1));
+	      insert_before (g);
+	      g = gimple_build_cond (NE_EXPR, idx, size_zero_node,
+				     NULL_TREE, NULL_TREE);
+	      insert_before (g);
+	      edge true_edge, false_edge;
+	      extract_true_false_edges_from_block (gsi_bb (m_gsi),
+						   &true_edge, &false_edge);
+	      m_gsi = gsi_after_labels (false_edge->dest);
+	    }
+	}
+    }
+  switch (ifn)
+    {
+    case IFN_CLZ:
+    case IFN_CTZ:
+    case IFN_FFS:
+      gphi *phi1, *phi2, *phi3;
+      basic_block bb;
+      bb = gsi_bb (m_gsi);
+      remove_edge (find_edge (bb, gimple_bb (stmt)));
+      phi1 = create_phi_node (make_ssa_name (m_limb_type),
+			      gimple_bb (stmt));
+      phi2 = create_phi_node (make_ssa_name (integer_type_node),
+			      gimple_bb (stmt));
+      for (unsigned i = 0; i < cnt; i++)
+	{
+	  add_phi_arg (phi1, bqp[i].val, bqp[i].e, UNKNOWN_LOCATION);
+	  add_phi_arg (phi2, bqp[i].addend, bqp[i].e, UNKNOWN_LOCATION);
+	}
+      if (arg1 == NULL_TREE)
+	{
+	  g = gimple_build_builtin_unreachable (m_loc);
+	  insert_before (g);
+	}
+      m_gsi = gsi_for_stmt (stmt);
+      g = gimple_build_call (fndecl, 1, gimple_phi_result (phi1));
+      gimple_call_set_lhs (g, make_ssa_name (integer_type_node));
+      insert_before (g);
+      if (arg1 == NULL_TREE)
+	g = gimple_build_assign (lhs, PLUS_EXPR,
+				 gimple_phi_result (phi2),
+				 gimple_call_lhs (g));
+      else
+	{
+	  g = gimple_build_assign (make_ssa_name (integer_type_node),
+				   PLUS_EXPR, gimple_phi_result (phi2),
+				   gimple_call_lhs (g));
+	  insert_before (g);
+	  edge e1 = split_block (gimple_bb (stmt), g);
+	  edge e2 = make_edge (bb, e1->dest, EDGE_FALLTHRU);
+	  e2->probability = profile_probability::always ();
+	  set_immediate_dominator (CDI_DOMINATORS, e1->dest,
+				   get_immediate_dominator (CDI_DOMINATORS,
+							    e1->src));
+	  phi3 = create_phi_node (make_ssa_name (integer_type_node), e1->dest);
+	  add_phi_arg (phi3, gimple_assign_lhs (g), e1, UNKNOWN_LOCATION);
+	  add_phi_arg (phi3, arg1, e2, UNKNOWN_LOCATION);
+	  m_gsi = gsi_for_stmt (stmt);
+	  g = gimple_build_assign (lhs, gimple_phi_result (phi3));
+	}
+      gsi_replace (&m_gsi, g, true);
+      break;
+    case IFN_CLRSB:
+      bb = gsi_bb (m_gsi);
+      remove_edge (find_edge (bb, edge_bb));
+      edge e;
+      e = make_edge (bb, gimple_bb (stmt), EDGE_FALLTHRU);
+      e->probability = profile_probability::always ();
+      set_immediate_dominator (CDI_DOMINATORS, gimple_bb (stmt),
+			       get_immediate_dominator (CDI_DOMINATORS,
+							edge_bb));
+      phi1 = create_phi_node (make_ssa_name (m_limb_type),
+			      edge_bb);
+      phi2 = create_phi_node (make_ssa_name (integer_type_node),
+			      edge_bb);
+      phi3 = create_phi_node (make_ssa_name (integer_type_node),
+			      gimple_bb (stmt));
+      for (unsigned i = 0; i < cnt; i++)
+	{
+	  add_phi_arg (phi1, bqp[i].val, bqp[2 * i + 1].e, UNKNOWN_LOCATION);
+	  add_phi_arg (phi2, bqp[i].addend, bqp[2 * i + 1].e,
+		       UNKNOWN_LOCATION);
+	  tree a = bqp[i].addend;
+	  if (i && kind == bitint_prec_large)
+	    a = int_const_binop (PLUS_EXPR, a, integer_minus_one_node);
+	  if (i)
+	    add_phi_arg (phi3, a, bqp[2 * i].e, UNKNOWN_LOCATION);
+	}
+      add_phi_arg (phi3, build_int_cst (integer_type_node, prec - 1), e,
+		   UNKNOWN_LOCATION);
+      m_gsi = gsi_after_labels (edge_bb);
+      g = gimple_build_call (fndecl, 1,
+			     add_cast (signed_type_for (m_limb_type),
+				       gimple_phi_result (phi1)));
+      gimple_call_set_lhs (g, make_ssa_name (integer_type_node));
+      insert_before (g);
+      g = gimple_build_assign (make_ssa_name (integer_type_node),
+			       PLUS_EXPR, gimple_call_lhs (g),
+			       gimple_phi_result (phi2));
+      insert_before (g);
+      if (kind != bitint_prec_large)
+	{
+	  g = gimple_build_assign (make_ssa_name (integer_type_node),
+				   PLUS_EXPR, gimple_assign_lhs (g),
+				   integer_one_node);
+	  insert_before (g);
+	}
+      add_phi_arg (phi3, gimple_assign_lhs (g),
+		   find_edge (edge_bb, gimple_bb (stmt)), UNKNOWN_LOCATION);
+      m_gsi = gsi_for_stmt (stmt);
+      g = gimple_build_assign (lhs, gimple_phi_result (phi3));
+      gsi_replace (&m_gsi, g, true);
+      break;
+    case IFN_PARITY:
+      g = gimple_build_call (fndecl, 1, res);
+      gimple_call_set_lhs (g, lhs);
+      gsi_replace (&m_gsi, g, true);
+      break;
+    case IFN_POPCOUNT:
+      g = gimple_build_assign (lhs, res);
+      gsi_replace (&m_gsi, g, true);
+      break;
+    default:
+      gcc_unreachable ();
+    }
+}
+
 /* Lower a call statement with one or more large/huge _BitInt
    arguments or large/huge _BitInt return value.  */
 
@@ -4476,6 +4995,14 @@ bitint_large_huge::lower_call (tree obj, gimple *stmt)
       case IFN_UBSAN_CHECK_MUL:
 	lower_mul_overflow (obj, stmt);
 	return;
+      case IFN_CLZ:
+      case IFN_CTZ:
+      case IFN_CLRSB:
+      case IFN_FFS:
+      case IFN_PARITY:
+      case IFN_POPCOUNT:
+	lower_bit_query (stmt);
+	return;
       default:
 	break;
       }
diff --git a/gcc/gimple-range-op.cc b/gcc/gimple-range-op.cc
index 67b3c3d..26c42da 100644
--- a/gcc/gimple-range-op.cc
+++ b/gcc/gimple-range-op.cc
@@ -908,39 +908,34 @@ public:
   cfn_clz (bool internal) { m_gimple_call_internal_p = internal; }
   using range_operator::fold_range;
   virtual bool fold_range (irange &r, tree type, const irange &lh,
-			   const irange &, relation_trio) const;
+			   const irange &rh, relation_trio) const;
 private:
   bool m_gimple_call_internal_p;
 } op_cfn_clz (false), op_cfn_clz_internal (true);
 
 bool
 cfn_clz::fold_range (irange &r, tree type, const irange &lh,
-		     const irange &, relation_trio) const
+		     const irange &rh, relation_trio) const
 {
   // __builtin_c[lt]z* return [0, prec-1], except when the
   // argument is 0, but that is undefined behavior.
   //
   // For __builtin_c[lt]z* consider argument of 0 always undefined
-  // behavior, for internal fns depending on C?Z_DEFINED_VALUE_AT_ZERO.
+  // behavior, for internal fns likewise, unless it has 2 arguments,
+  // then the second argument is the value at zero.
   if (lh.undefined_p ())
     return false;
   int prec = TYPE_PRECISION (lh.type ());
   int mini = 0;
   int maxi = prec - 1;
-  int zerov = 0;
-  scalar_int_mode mode = SCALAR_INT_TYPE_MODE (lh.type ());
   if (m_gimple_call_internal_p)
     {
-      if (optab_handler (clz_optab, mode) != CODE_FOR_nothing
-	  && CLZ_DEFINED_VALUE_AT_ZERO (mode, zerov) == 2)
-	{
-	  // Only handle the single common value.
-	  if (zerov == prec)
-	    maxi = prec;
-	  else
-	    // Magic value to give up, unless we can prove arg is non-zero.
-	    mini = -2;
-	}
+      // Only handle the single common value.
+      if (rh.lower_bound () == prec)
+	maxi = prec;
+      else
+	// Magic value to give up, unless we can prove arg is non-zero.
+	mini = -2;
     }
 
   // From clz of minimum we can compute result maximum.
@@ -985,37 +980,31 @@ public:
   cfn_ctz (bool internal) { m_gimple_call_internal_p = internal; }
   using range_operator::fold_range;
   virtual bool fold_range (irange &r, tree type, const irange &lh,
-			   const irange &, relation_trio) const;
+			   const irange &rh, relation_trio) const;
 private:
   bool m_gimple_call_internal_p;
 } op_cfn_ctz (false), op_cfn_ctz_internal (true);
 
 bool
 cfn_ctz::fold_range (irange &r, tree type, const irange &lh,
-		     const irange &, relation_trio) const
+		     const irange &rh, relation_trio) const
 {
   if (lh.undefined_p ())
     return false;
   int prec = TYPE_PRECISION (lh.type ());
   int mini = 0;
   int maxi = prec - 1;
-  int zerov = 0;
-  scalar_int_mode mode = SCALAR_INT_TYPE_MODE (lh.type ());
 
   if (m_gimple_call_internal_p)
     {
-      if (optab_handler (ctz_optab, mode) != CODE_FOR_nothing
-	  && CTZ_DEFINED_VALUE_AT_ZERO (mode, zerov) == 2)
-	{
-	  // Handle only the two common values.
-	  if (zerov == -1)
-	    mini = -1;
-	  else if (zerov == prec)
-	    maxi = prec;
-	  else
-	    // Magic value to give up, unless we can prove arg is non-zero.
-	    mini = -2;
-	}
+      // Handle only the two common values.
+      if (rh.lower_bound () == -1)
+	mini = -1;
+      else if (rh.lower_bound () == prec)
+	maxi = prec;
+      else
+	// Magic value to give up, unless we can prove arg is non-zero.
+	mini = -2;
     }
   // If arg is non-zero, then use [0, prec - 1].
   if (!range_includes_zero_p (&lh))
@@ -1288,16 +1277,24 @@ gimple_range_op_handler::maybe_builtin_call ()
 
     CASE_CFN_CLZ:
       m_op1 = gimple_call_arg (call, 0);
-      if (gimple_call_internal_p (call))
-	m_operator = &op_cfn_clz_internal;
+      if (gimple_call_internal_p (call)
+	  && gimple_call_num_args (call) == 2)
+	{
+	  m_op2 = gimple_call_arg (call, 1);
+	  m_operator = &op_cfn_clz_internal;
+	}
       else
 	m_operator = &op_cfn_clz;
       break;
 
     CASE_CFN_CTZ:
       m_op1 = gimple_call_arg (call, 0);
-      if (gimple_call_internal_p (call))
-	m_operator = &op_cfn_ctz_internal;
+      if (gimple_call_internal_p (call)
+	  && gimple_call_num_args (call) == 2)
+	{
+	  m_op2 = gimple_call_arg (call, 1);
+	  m_operator = &op_cfn_ctz_internal;
+	}
       else
 	m_operator = &op_cfn_ctz;
       break;
diff --git a/gcc/gimple-walk.cc b/gcc/gimple-walk.cc
index 9516d61..20df7e2 100644
--- a/gcc/gimple-walk.cc
+++ b/gcc/gimple-walk.cc
@@ -56,11 +56,21 @@ walk_gimple_seq_mod (gimple_seq *pseq, walk_stmt_fn callback_stmt,
 	  gcc_assert (wi);
 	  wi->callback_result = ret;
 
-	  return wi->removed_stmt ? NULL : gsi_stmt (gsi);
+	  gimple *g;
+	  if (!wi->removed_stmt)
+	    g = gsi_stmt (gsi);
+	  else
+	    {
+	      g = NULL;
+	      wi->removed_stmt = false;
+	    }
+	  return g;
 	}
 
       if (!wi->removed_stmt)
 	gsi_next (&gsi);
+      else
+	wi->removed_stmt = false;
     }
 
   if (wi)
diff --git a/gcc/gimplify.cc b/gcc/gimplify.cc
index 77f07af..d52d71b 100644
--- a/gcc/gimplify.cc
+++ b/gcc/gimplify.cc
@@ -2791,17 +2791,33 @@ expand_FALLTHROUGH_r (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
       *handled_ops_p = false;
       break;
     case GIMPLE_CALL:
+      static_cast<location_t *>(wi->info)[0] = UNKNOWN_LOCATION;
       if (gimple_call_internal_p (stmt, IFN_FALLTHROUGH))
 	{
+	  location_t loc = gimple_location (stmt);
 	  gsi_remove (gsi_p, true);
+	  wi->removed_stmt = true;
+
+	  /* nothrow flag is added by genericize_c_loop to mark fallthrough
+	     statement at the end of some loop's body.  Those should be
+	     always diagnosed, either because they indeed don't precede
+	     a case label or default label, or because the next statement
+	     is not within the same iteration statement.  */
+	  if ((stmt->subcode & GF_CALL_NOTHROW) != 0)
+	    {
+	      pedwarn (loc, 0, "attribute %<fallthrough%> not preceding "
+			       "a case label or default label");
+	      break;
+	    }
+
 	  if (gsi_end_p (*gsi_p))
 	    {
-	      *static_cast<location_t *>(wi->info) = gimple_location (stmt);
-	      return integer_zero_node;
+	      static_cast<location_t *>(wi->info)[0] = BUILTINS_LOCATION;
+	      static_cast<location_t *>(wi->info)[1] = loc;
+	      break;
 	    }
 
 	  bool found = false;
-	  location_t loc = gimple_location (stmt);
 
 	  gimple_stmt_iterator gsi2 = *gsi_p;
 	  stmt = gsi_stmt (gsi2);
@@ -2851,6 +2867,7 @@ expand_FALLTHROUGH_r (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
 	}
       break;
     default:
+      static_cast<location_t *>(wi->info)[0] = UNKNOWN_LOCATION;
       break;
     }
   return NULL_TREE;
@@ -2862,14 +2879,16 @@ static void
 expand_FALLTHROUGH (gimple_seq *seq_p)
 {
   struct walk_stmt_info wi;
-  location_t loc;
+  location_t loc[2];
   memset (&wi, 0, sizeof (wi));
-  wi.info = (void *) &loc;
+  loc[0] = UNKNOWN_LOCATION;
+  loc[1] = UNKNOWN_LOCATION;
+  wi.info = (void *) &loc[0];
   walk_gimple_seq_mod (seq_p, expand_FALLTHROUGH_r, NULL, &wi);
-  if (wi.callback_result == integer_zero_node)
+  if (loc[0] != UNKNOWN_LOCATION)
     /* We've found [[fallthrough]]; at the end of a switch, which the C++
        standard says is ill-formed; see [dcl.attr.fallthrough].  */
-    pedwarn (loc, 0, "attribute %<fallthrough%> not preceding "
+    pedwarn (loc[1], 0, "attribute %<fallthrough%> not preceding "
 	     "a case label or default label");
 }
 
diff --git a/gcc/input.cc b/gcc/input.cc
index 1b22922..b520264 100644
--- a/gcc/input.cc
+++ b/gcc/input.cc
@@ -288,23 +288,6 @@ expand_location_1 (const line_maps *set,
   return xloc;
 }
 
-/* Initialize the set of cache used for files accessed by caret
-   diagnostic.  */
-
-static void
-diagnostic_file_cache_init (void)
-{
-  gcc_assert (global_dc);
-  global_dc->file_cache_init ();
-}
-
-void
-diagnostic_context::file_cache_init ()
-{
-  if (m_file_cache == nullptr)
-    m_file_cache = new file_cache ();
-}
-
 /* Return the total lines number that have been read so far by the
    line map (in the preprocessor) so far.  For languages like C++ that
    entirely preprocess the input file before starting to parse, this
@@ -356,17 +339,6 @@ file_cache::lookup_file (const char *file_path)
    with tempfiles.  */
 
 void
-diagnostics_file_cache_forcibly_evict_file (const char *file_path)
-{
-  gcc_assert (file_path);
-
-  auto file_cache = global_dc->get_file_cache ();
-  if (!file_cache)
-    return;
-  file_cache->forcibly_evict_file (file_path);
-}
-
-void
 file_cache::forcibly_evict_file (const char *file_path)
 {
   gcc_assert (file_path);
@@ -379,6 +351,19 @@ file_cache::forcibly_evict_file (const char *file_path)
   r->evict ();
 }
 
+/* Determine if FILE_PATH missing a trailing newline on its final line.
+   Only valid to call once all of the file has been loaded, by
+   requesting a line number beyond the end of the file.  */
+
+bool
+file_cache::missing_trailing_newline_p (const char *file_path)
+{
+  gcc_assert (file_path);
+
+  file_cache_slot *r = lookup_or_add_file (file_path);
+  return r->missing_trailing_newline_p ();
+}
+
 void
 file_cache_slot::evict ()
 {
@@ -403,8 +388,6 @@ file_cache_slot::evict ()
 file_cache_slot*
 file_cache::evicted_cache_tab_entry (unsigned *highest_use_count)
 {
-  diagnostic_file_cache_init ();
-
   file_cache_slot *to_evict = &m_file_slots[0];
   unsigned huc = to_evict->get_use_count ();
   for (unsigned i = 1; i < num_file_slots; ++i)
@@ -968,19 +951,12 @@ file_cache::get_source_line (const char *file_path, int line)
   return char_span (buffer, len);
 }
 
-char_span
-location_get_source_line (const char *file_path, int line)
-{
-  diagnostic_file_cache_init ();
-  return global_dc->get_file_cache ()->get_source_line (file_path, line);
-}
-
 /* Return a NUL-terminated copy of the source text between two locations, or
    NULL if the arguments are invalid.  The caller is responsible for freeing
    the return value.  */
 
 char *
-get_source_text_between (location_t start, location_t end)
+get_source_text_between (file_cache &fc, location_t start, location_t end)
 {
   expanded_location expstart =
     expand_location_to_spelling_point (start, LOCATION_ASPECT_START);
@@ -1005,7 +981,7 @@ get_source_text_between (location_t start, location_t end)
   /* For a single line we need to trim both edges.  */
   if (expstart.line == expend.line)
     {
-      char_span line = location_get_source_line (expstart.file, expstart.line);
+      char_span line = fc.get_source_line (expstart.file, expstart.line);
       if (line.length () < 1)
 	return NULL;
       int s = expstart.column - 1;
@@ -1022,7 +998,7 @@ get_source_text_between (location_t start, location_t end)
      parts of the start and end lines off depending on column values.  */
   for (int lnum = expstart.line; lnum <= expend.line; ++lnum)
     {
-      char_span line = location_get_source_line (expstart.file, lnum);
+      char_span line = fc.get_source_line (expstart.file, lnum);
       if (line.length () < 1 && (lnum != expstart.line && lnum != expend.line))
 	continue;
 
@@ -1077,33 +1053,6 @@ file_cache::get_source_file_content (const char *file_path)
   return c->get_full_file_content ();
 }
 
-
-/* Get a borrowed char_span to the full content of FILE_PATH
-   as decoded according to the input charset, encoded as UTF-8.  */
-
-char_span
-get_source_file_content (const char *file_path)
-{
-  diagnostic_file_cache_init ();
-  return global_dc->get_file_cache ()->get_source_file_content (file_path);
-}
-
-/* Determine if FILE_PATH missing a trailing newline on its final line.
-   Only valid to call once all of the file has been loaded, by
-   requesting a line number beyond the end of the file.  */
-
-bool
-location_missing_trailing_newline (const char *file_path)
-{
-  diagnostic_file_cache_init ();
-
-  file_cache_slot *c = global_dc->get_file_cache ()->lookup_or_add_file (file_path);
-  if (c == NULL)
-    return false;
-
-  return c->missing_trailing_newline_p ();
-}
-
 /* Test if the location originates from the spelling location of a
    builtin-tokens.  That is, return TRUE if LOC is a (possibly
    virtual) location of a built-in token that appears in the expansion
@@ -1236,12 +1185,13 @@ make_location (location_t caret, source_range src_range)
    source line in order to calculate the display width.  If that cannot be done
    for any reason, then returns the byte column as a fallback.  */
 int
-location_compute_display_column (expanded_location exploc,
+location_compute_display_column (file_cache &fc,
+				 expanded_location exploc,
 				 const cpp_char_column_policy &policy)
 {
   if (!(exploc.file && *exploc.file && exploc.line && exploc.column))
     return exploc.column;
-  char_span line = location_get_source_line (exploc.file, exploc.line);
+  char_span line = fc.get_source_line (exploc.file, exploc.line);
   /* If line is NULL, this function returns exploc.column which is the
      desired fallback.  */
   return cpp_byte_column_to_display_column (line.get_buffer (), line.length (),
@@ -1386,6 +1336,8 @@ dump_labelled_location_range (FILE *stream,
 void
 dump_location_info (FILE *stream)
 {
+  file_cache fc;
+
   /* Visualize the reserved locations.  */
   dump_labelled_location_range (stream, "RESERVED LOCATIONS",
 				0, RESERVED_LOCATION_COUNT);
@@ -1456,8 +1408,8 @@ dump_location_info (FILE *stream)
 	    {
 	      /* Beginning of a new source line: draw the line.  */
 
-	      char_span line_text = location_get_source_line (exploc.file,
-							      exploc.line);
+	      char_span line_text = fc.get_source_line (exploc.file,
+							exploc.line);
 	      if (!line_text)
 		break;
 	      fprintf (stream,
@@ -1705,6 +1657,7 @@ class auto_cpp_string_vec :  public auto_vec <cpp_string>
 
 static const char *
 get_substring_ranges_for_loc (cpp_reader *pfile,
+			      file_cache &fc,
 			      string_concat_db *concats,
 			      location_t strloc,
 			      enum cpp_ttype type,
@@ -1784,7 +1737,7 @@ get_substring_ranges_for_loc (cpp_reader *pfile,
       if (start.column > finish.column)
 	return "range endpoints are reversed";
 
-      char_span line = location_get_source_line (start.file, start.line);
+      char_span line = fc.get_source_line (start.file, start.line);
       if (!line)
 	return "unable to read source line";
 
@@ -1872,6 +1825,7 @@ get_substring_ranges_for_loc (cpp_reader *pfile,
 
 const char *
 get_location_within_string (cpp_reader *pfile,
+			    file_cache &fc,
 			    string_concat_db *concats,
 			    location_t strloc,
 			    enum cpp_ttype type,
@@ -1885,7 +1839,7 @@ get_location_within_string (cpp_reader *pfile,
 
   cpp_substring_ranges ranges;
   const char *err
-    = get_substring_ranges_for_loc (pfile, concats, strloc, type, ranges);
+    = get_substring_ranges_for_loc (pfile, fc, concats, strloc, type, ranges);
   if (err)
     return err;
 
@@ -1954,6 +1908,7 @@ namespace selftest {
 
 static const char *
 get_source_range_for_char (cpp_reader *pfile,
+			   file_cache &fc,
 			   string_concat_db *concats,
 			   location_t strloc,
 			   enum cpp_ttype type,
@@ -1965,7 +1920,7 @@ get_source_range_for_char (cpp_reader *pfile,
 
   cpp_substring_ranges ranges;
   const char *err
-    = get_substring_ranges_for_loc (pfile, concats, strloc, type, ranges);
+    = get_substring_ranges_for_loc (pfile, fc, concats, strloc, type, ranges);
   if (err)
     return err;
 
@@ -1981,6 +1936,7 @@ get_source_range_for_char (cpp_reader *pfile,
 
 static const char *
 get_num_source_ranges_for_substring (cpp_reader *pfile,
+				     file_cache &fc,
 				     string_concat_db *concats,
 				     location_t strloc,
 				     enum cpp_ttype type,
@@ -1990,7 +1946,7 @@ get_num_source_ranges_for_substring (cpp_reader *pfile,
 
   cpp_substring_ranges ranges;
   const char *err
-    = get_substring_ranges_for_loc (pfile, concats, strloc, type, ranges);
+    = get_substring_ranges_for_loc (pfile, fc, concats, strloc, type, ranges);
 
   if (err)
     return err;
@@ -2313,23 +2269,24 @@ test_reading_source_line ()
 			"01234567890123456789\n"
 			"This is the test text\n"
 			"This is the 3rd line");
+  file_cache fc;
 
   /* Read back a specific line from the tempfile.  */
-  char_span source_line = location_get_source_line (tmp.get_filename (), 3);
+  char_span source_line = fc.get_source_line (tmp.get_filename (), 3);
   ASSERT_TRUE (source_line);
   ASSERT_TRUE (source_line.get_buffer () != NULL);
   ASSERT_EQ (20, source_line.length ());
   ASSERT_TRUE (!strncmp ("This is the 3rd line",
 			 source_line.get_buffer (), source_line.length ()));
 
-  source_line = location_get_source_line (tmp.get_filename (), 2);
+  source_line = fc.get_source_line (tmp.get_filename (), 2);
   ASSERT_TRUE (source_line);
   ASSERT_TRUE (source_line.get_buffer () != NULL);
   ASSERT_EQ (21, source_line.length ());
   ASSERT_TRUE (!strncmp ("This is the test text",
 			 source_line.get_buffer (), source_line.length ()));
 
-  source_line = location_get_source_line (tmp.get_filename (), 4);
+  source_line = fc.get_source_line (tmp.get_filename (), 4);
   ASSERT_FALSE (source_line);
   ASSERT_TRUE (source_line.get_buffer () == NULL);
 }
@@ -2490,6 +2447,7 @@ public:
   line_table_test m_ltt;
   cpp_reader_ptr m_parser;
   temp_source_file m_tempfile;
+  file_cache m_file_cache;
   string_concat_db m_concats;
   bool m_implicitly_expect_EOF;
 };
@@ -2681,7 +2639,8 @@ assert_char_at_range (const location &loc,
 
   source_range actual_range = source_range();
   const char *err
-    = get_source_range_for_char (pfile, concats, strloc, type, idx,
+    = get_source_range_for_char (pfile, test.m_file_cache,
+				 concats, strloc, type, idx,
 				 &actual_range);
   if (should_have_column_data_p (strloc))
     ASSERT_EQ_AT (loc, NULL, err);
@@ -2736,7 +2695,8 @@ assert_num_substring_ranges (const location &loc,
 
   int actual_num_ranges = -1;
   const char *err
-    = get_num_source_ranges_for_substring (pfile, concats, strloc, type,
+    = get_num_source_ranges_for_substring (pfile, test.m_file_cache,
+					   concats, strloc, type,
 					   &actual_num_ranges);
   if (should_have_column_data_p (strloc))
     ASSERT_EQ_AT (loc, NULL, err);
@@ -2773,7 +2733,7 @@ assert_has_no_substring_ranges (const location &loc,
   string_concat_db *concats = &test.m_concats;
   cpp_substring_ranges ranges;
   const char *actual_err
-    = get_substring_ranges_for_loc (pfile, concats, strloc,
+    = get_substring_ranges_for_loc (pfile, test.m_file_cache, concats, strloc,
 				    type, ranges);
   if (should_have_column_data_p (strloc))
     ASSERT_STREQ_AT (loc, expected_err, actual_err);
@@ -3542,7 +3502,8 @@ test_lexer_string_locations_concatenation_2 (const line_table_case &case_)
 	 this case.  */
       source_range actual_range;
       const char *err
-	= get_source_range_for_char (test.m_parser, &test.m_concats,
+	= get_source_range_for_char (test.m_parser, test.m_file_cache,
+				     &test.m_concats,
 				     initial_loc, type, 0, &actual_range);
       ASSERT_STREQ ("range starts after LINE_MAP_MAX_LOCATION_WITH_COLS", err);
       return;
diff --git a/gcc/input.h b/gcc/input.h
index 5eac1dc..9cc9d58 100644
--- a/gcc/input.h
+++ b/gcc/input.h
@@ -23,6 +23,8 @@ along with GCC; see the file COPYING3.  If not see
 
 #include "line-map.h"
 
+class file_cache;
+
 extern GTY(()) class line_maps *line_table;
 extern GTY(()) class line_maps *saved_line_table;
 
@@ -67,7 +69,8 @@ extern expanded_location expand_location (location_t);
 class cpp_char_column_policy;
 
 extern int
-location_compute_display_column (expanded_location exploc,
+location_compute_display_column (file_cache &fc,
+				 expanded_location exploc,
 				 const cpp_char_column_policy &policy);
 
 /* A class capturing the bounds of a buffer, to allow for run-time
@@ -113,11 +116,8 @@ class char_span
   size_t m_n_elts;
 };
 
-extern char_span location_get_source_line (const char *file_path, int line);
-extern char *get_source_text_between (location_t, location_t);
-extern char_span get_source_file_content (const char *file_path);
-
-extern bool location_missing_trailing_newline (const char *file_path);
+extern char *
+get_source_text_between (file_cache &, location_t, location_t);
 
 /* Forward decl of slot within file_cache, so that the definition doesn't
    need to be in this header.  */
@@ -152,6 +152,7 @@ class file_cache
 
   char_span get_source_file_content (const char *file_path);
   char_span get_source_line (const char *file_path, int line);
+  bool missing_trailing_newline_p (const char *file_path);
 
  private:
   file_cache_slot *evicted_cache_tab_entry (unsigned *highest_use_count);
@@ -254,8 +255,6 @@ void dump_line_table_statistics (void);
 
 void dump_location_info (FILE *stream);
 
-void diagnostics_file_cache_forcibly_evict_file (const char *file_path);
-
 class GTY(()) string_concat
 {
 public:
diff --git a/gcc/internal-fn.def b/gcc/internal-fn.def
index 319e0ab..3d5aca0 100644
--- a/gcc/internal-fn.def
+++ b/gcc/internal-fn.def
@@ -533,7 +533,9 @@ DEF_INTERNAL_FN (ATOMIC_AND_FETCH_CMP_0, ECF_LEAF, NULL)
 DEF_INTERNAL_FN (ATOMIC_OR_FETCH_CMP_0, ECF_LEAF, NULL)
 DEF_INTERNAL_FN (ATOMIC_XOR_FETCH_CMP_0, ECF_LEAF, NULL)
 
-/* To implement [[fallthrough]].  */
+/* To implement [[fallthrough]].  If the TREE_NOTHROW or GF_CALL_NOTHROW flag
+   is set on the call (normally redundant with ECF_NOTHROW), it marks
+   [[fallthrough]] at the end of C++ loop body.  */
 DEF_INTERNAL_FN (FALLTHROUGH, ECF_LEAF | ECF_NOTHROW, NULL)
 
 /* To implement __builtin_launder.  */
diff --git a/gcc/jit/ChangeLog b/gcc/jit/ChangeLog
index f8f332f..4435195 100644
--- a/gcc/jit/ChangeLog
+++ b/gcc/jit/ChangeLog
@@ -1,3 +1,7 @@
+2023-11-09  Guillaume Gomez  <guillaume1.gomez@gmail.com>
+
+	* libgccjit++.h:
+
 2023-11-04  David Malcolm  <dmalcolm@redhat.com>
 
 	* jit-playback.cc: Update for changes to diagnostic_context.
diff --git a/gcc/json.cc b/gcc/json.cc
index 741e97b..d0f157f 100644
--- a/gcc/json.cc
+++ b/gcc/json.cc
@@ -128,6 +128,42 @@ object::get (const char *key) const
     return NULL;
 }
 
+/* Set value of KEY within this object to a JSON
+   string value based on UTF8_VALUE.  */
+
+void
+object::set_string (const char *key, const char *utf8_value)
+{
+  set (key, new json::string (utf8_value));
+}
+
+/* Set value of KEY within this object to a JSON
+   integer value based on V.  */
+
+void
+object::set_integer (const char *key, long v)
+{
+  set (key, new json::integer_number (v));
+}
+
+/* Set value of KEY within this object to a JSON
+   floating point value based on V.  */
+
+void
+object::set_float (const char *key, double v)
+{
+  set (key, new json::float_number (v));
+}
+
+/* Set value of KEY within this object to the JSON
+   literal true or false, based on V.  */
+
+void
+object::set_bool (const char *key, bool v)
+{
+  set (key, new json::literal (v));
+}
+
 /* class json::array, a subclass of json::value, representing
    an ordered collection of values.  */
 
@@ -286,13 +322,16 @@ namespace selftest {
 /* Verify that JV->print () prints EXPECTED_JSON.  */
 
 static void
-assert_print_eq (const json::value &jv, const char *expected_json)
+assert_print_eq (const location &loc, const json::value &jv, const char *expected_json)
 {
   pretty_printer pp;
   jv.print (&pp);
-  ASSERT_STREQ (expected_json, pp_formatted_text (&pp));
+  ASSERT_STREQ_AT (loc, expected_json, pp_formatted_text (&pp));
 }
 
+#define ASSERT_PRINT_EQ(JV, EXPECTED_JSON) \
+  assert_print_eq (SELFTEST_LOCATION, JV, EXPECTED_JSON)
+
 /* Verify that object::get works as expected.  */
 
 static void
@@ -311,11 +350,11 @@ static void
 test_writing_objects ()
 {
   object obj;
-  obj.set ("foo", new json::string ("bar"));
-  obj.set ("baz", new json::string ("quux"));
+  obj.set_string ("foo", "bar");
+  obj.set_string ("baz", "quux");
   /* This test relies on json::object writing out key/value pairs
      in key-insertion order.  */
-  assert_print_eq (obj, "{\"foo\": \"bar\", \"baz\": \"quux\"}");
+  ASSERT_PRINT_EQ (obj, "{\"foo\": \"bar\", \"baz\": \"quux\"}");
 }
 
 /* Verify that JSON arrays are written correctly.  */
@@ -324,13 +363,13 @@ static void
 test_writing_arrays ()
 {
   array arr;
-  assert_print_eq (arr, "[]");
+  ASSERT_PRINT_EQ (arr, "[]");
 
   arr.append (new json::string ("foo"));
-  assert_print_eq (arr, "[\"foo\"]");
+  ASSERT_PRINT_EQ (arr, "[\"foo\"]");
 
   arr.append (new json::string ("bar"));
-  assert_print_eq (arr, "[\"foo\", \"bar\"]");
+  ASSERT_PRINT_EQ (arr, "[\"foo\", \"bar\"]");
 }
 
 /* Verify that JSON numbers are written correctly.  */
@@ -338,20 +377,20 @@ test_writing_arrays ()
 static void
 test_writing_float_numbers ()
 {
-  assert_print_eq (float_number (0), "0");
-  assert_print_eq (float_number (42), "42");
-  assert_print_eq (float_number (-100), "-100");
-  assert_print_eq (float_number (123456789), "1.23457e+08");
+  ASSERT_PRINT_EQ (float_number (0), "0");
+  ASSERT_PRINT_EQ (float_number (42), "42");
+  ASSERT_PRINT_EQ (float_number (-100), "-100");
+  ASSERT_PRINT_EQ (float_number (123456789), "1.23457e+08");
 }
 
 static void
 test_writing_integer_numbers ()
 {
-  assert_print_eq (integer_number (0), "0");
-  assert_print_eq (integer_number (42), "42");
-  assert_print_eq (integer_number (-100), "-100");
-  assert_print_eq (integer_number (123456789), "123456789");
-  assert_print_eq (integer_number (-123456789), "-123456789");
+  ASSERT_PRINT_EQ (integer_number (0), "0");
+  ASSERT_PRINT_EQ (integer_number (42), "42");
+  ASSERT_PRINT_EQ (integer_number (-100), "-100");
+  ASSERT_PRINT_EQ (integer_number (123456789), "123456789");
+  ASSERT_PRINT_EQ (integer_number (-123456789), "-123456789");
 }
 
 /* Verify that JSON strings are written correctly.  */
@@ -360,16 +399,16 @@ static void
 test_writing_strings ()
 {
   string foo ("foo");
-  assert_print_eq (foo, "\"foo\"");
+  ASSERT_PRINT_EQ (foo, "\"foo\"");
 
   string contains_quotes ("before \"quoted\" after");
-  assert_print_eq (contains_quotes, "\"before \\\"quoted\\\" after\"");
+  ASSERT_PRINT_EQ (contains_quotes, "\"before \\\"quoted\\\" after\"");
 
   const char data[] = {'a', 'b', 'c', 'd', '\0', 'e', 'f'};
   string not_terminated (data, 3);
-  assert_print_eq (not_terminated, "\"abc\"");
+  ASSERT_PRINT_EQ (not_terminated, "\"abc\"");
   string embedded_null (data, sizeof data);
-  assert_print_eq (embedded_null, "\"abcd\\0ef\"");
+  ASSERT_PRINT_EQ (embedded_null, "\"abcd\\0ef\"");
 }
 
 /* Verify that JSON literals are written correctly.  */
@@ -377,12 +416,12 @@ test_writing_strings ()
 static void
 test_writing_literals ()
 {
-  assert_print_eq (literal (JSON_TRUE), "true");
-  assert_print_eq (literal (JSON_FALSE), "false");
-  assert_print_eq (literal (JSON_NULL), "null");
+  ASSERT_PRINT_EQ (literal (JSON_TRUE), "true");
+  ASSERT_PRINT_EQ (literal (JSON_FALSE), "false");
+  ASSERT_PRINT_EQ (literal (JSON_NULL), "null");
 
-  assert_print_eq (literal (true), "true");
-  assert_print_eq (literal (false), "false");
+  ASSERT_PRINT_EQ (literal (true), "true");
+  ASSERT_PRINT_EQ (literal (false), "false");
 }
 
 /* Run all of the selftests within this file.  */
diff --git a/gcc/json.h b/gcc/json.h
index 6cc58c8..6fadd11 100644
--- a/gcc/json.h
+++ b/gcc/json.h
@@ -102,6 +102,13 @@ class object : public value
   void set (const char *key, value *v);
   value *get (const char *key) const;
 
+  void set_string (const char *key, const char *utf8_value);
+  void set_integer (const char *key, long v);
+  void set_float (const char *key, double v);
+
+  /* Set to literal true/false.  */
+  void set_bool (const char *key, bool v);
+
  private:
   typedef hash_map <char *, value *,
     simple_hashmap_traits<nofree_string_hash, value *> > map_t;
diff --git a/gcc/lto-wrapper.cc b/gcc/lto-wrapper.cc
index a92fed3..7b01ecc 100644
--- a/gcc/lto-wrapper.cc
+++ b/gcc/lto-wrapper.cc
@@ -1355,7 +1355,7 @@ void
 print_lto_docs_link ()
 {
   bool print_url = global_dc->printer->url_format != URL_FORMAT_NONE;
-  const char *url = global_dc->m_get_option_url (global_dc, OPT_flto);
+  const char *url = global_dc->make_option_url (OPT_flto);
 
   pretty_printer pp;
   pp.url_format = URL_FORMAT_DEFAULT;
@@ -2146,7 +2146,11 @@ main (int argc, char *argv[])
   diagnostic_initialize (global_dc, 0);
   diagnostic_color_init (global_dc);
   diagnostic_urls_init (global_dc);
-  global_dc->m_get_option_url = get_option_url;
+  global_dc->set_option_hooks (nullptr,
+			       nullptr,
+			       nullptr,
+			       get_option_url,
+			       0);
 
   if (atexit (lto_wrapper_cleanup) != 0)
     fatal_error (input_location, "%<atexit%> failed");
diff --git a/gcc/match.pd b/gcc/match.pd
index 281c6c0..b30de36 100644
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -8536,31 +8536,34 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
    (op (clz:s@2 @0) INTEGER_CST@1)
    (if (integer_zerop (@1) && single_use (@2))
     /* clz(X) == 0 is (int)X < 0 and clz(X) != 0 is (int)X >= 0.  */
-    (with { tree type0 = TREE_TYPE (@0);
-	    tree stype = signed_type_for (type0);
-	    HOST_WIDE_INT val = 0;
-	    /* Punt on hypothetical weird targets.  */
-	    if (clz == CFN_CLZ
-		&& CLZ_DEFINED_VALUE_AT_ZERO (SCALAR_TYPE_MODE (type0),
-					      val) == 2
-		&& val == 0)
-	      stype = NULL_TREE;
-	  }
-     (if (stype)
-      (cmp (convert:stype @0) { build_zero_cst (stype); })))
+    (with { tree stype = signed_type_for (TREE_TYPE (@0)); }
+     (cmp (convert:stype @0) { build_zero_cst (stype); }))
     /* clz(X) == (prec-1) is X == 1 and clz(X) != (prec-1) is X != 1.  */
-    (with { bool ok = true;
-	    HOST_WIDE_INT val = 0;
-	    tree type0 = TREE_TYPE (@0);
-	    /* Punt on hypothetical weird targets.  */
-	    if (clz == CFN_CLZ
-		&& CLZ_DEFINED_VALUE_AT_ZERO (SCALAR_TYPE_MODE (type0),
-					      val) == 2
-		&& val == TYPE_PRECISION (type0) - 1)
-	      ok = false;
-	  }
-     (if (ok && wi::to_wide (@1) == (TYPE_PRECISION (type0) - 1))
-      (op @0 { build_one_cst (type0); })))))))
+    (if (wi::to_wide (@1) == TYPE_PRECISION (TREE_TYPE (@0)) - 1)
+     (op @0 { build_one_cst (TREE_TYPE (@0)); }))))))
+(for op (eq ne)
+     cmp (lt ge)
+ (simplify
+  (op (IFN_CLZ:s@2 @0 @3) INTEGER_CST@1)
+  (if (integer_zerop (@1) && single_use (@2))
+   /* clz(X) == 0 is (int)X < 0 and clz(X) != 0 is (int)X >= 0.  */
+   (with { tree type0 = TREE_TYPE (@0);
+	   tree stype = signed_type_for (TREE_TYPE (@0));
+	   /* Punt if clz(0) == 0.  */
+	   if (integer_zerop (@3))
+	     stype = NULL_TREE;
+	 }
+    (if (stype)
+     (cmp (convert:stype @0) { build_zero_cst (stype); })))
+   /* clz(X) == (prec-1) is X == 1 and clz(X) != (prec-1) is X != 1.  */
+   (with { bool ok = true;
+	   tree type0 = TREE_TYPE (@0);
+	   /* Punt if clz(0) == prec - 1.  */
+	   if (wi::to_widest (@3) == TYPE_PRECISION (type0) - 1)
+	     ok = false;
+	 }
+    (if (ok && wi::to_wide (@1) == (TYPE_PRECISION (type0) - 1))
+     (op @0 { build_one_cst (type0); }))))))
 
 /* CTZ simplifications.  */
 (for ctz (CTZ)
@@ -8585,22 +8588,14 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
 		      val++;
 		  }
 	      }
-	    bool zero_res = false;
-	    HOST_WIDE_INT zero_val = 0;
 	    tree type0 = TREE_TYPE (@0);
 	    int prec = TYPE_PRECISION (type0);
-	    if (ctz == CFN_CTZ
-		&& CTZ_DEFINED_VALUE_AT_ZERO (SCALAR_TYPE_MODE (type0),
-					      zero_val) == 2)
-	      zero_res = true;
 	  }
-     (if (val <= 0)
-      (if (ok && (!zero_res || zero_val >= val))
-       { constant_boolean_node (cmp == EQ_EXPR ? true : false, type); })
-      (if (val >= prec)
-       (if (ok && (!zero_res || zero_val < val))
-	{ constant_boolean_node (cmp == EQ_EXPR ? false : true, type); })
-       (if (ok && (!zero_res || zero_val < 0 || zero_val >= prec))
+     (if (ok && prec <= MAX_FIXED_MODE_SIZE)
+      (if (val <= 0)
+       { constant_boolean_node (cmp == EQ_EXPR ? true : false, type); }
+       (if (val >= prec)
+	{ constant_boolean_node (cmp == EQ_EXPR ? false : true, type); }
 	(cmp (bit_and @0 { wide_int_to_tree (type0,
 					     wi::mask (val, false, prec)); })
 	     { build_zero_cst (type0); })))))))
@@ -8608,19 +8603,68 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
   (simplify
    /* __builtin_ctz (x) == C -> (x & ((1 << (C + 1)) - 1)) == (1 << C).  */
    (op (ctz:s @0) INTEGER_CST@1)
-    (with { bool zero_res = false;
-	    HOST_WIDE_INT zero_val = 0;
-	    tree type0 = TREE_TYPE (@0);
+    (with { tree type0 = TREE_TYPE (@0);
 	    int prec = TYPE_PRECISION (type0);
-	    if (ctz == CFN_CTZ
-		&& CTZ_DEFINED_VALUE_AT_ZERO (SCALAR_TYPE_MODE (type0),
-					      zero_val) == 2)
-	      zero_res = true;
 	  }
+     (if (prec <= MAX_FIXED_MODE_SIZE)
+      (if (tree_int_cst_sgn (@1) < 0 || wi::to_widest (@1) >= prec)
+       { constant_boolean_node (op == EQ_EXPR ? false : true, type); }
+       (op (bit_and @0 { wide_int_to_tree (type0,
+					   wi::mask (tree_to_uhwi (@1) + 1,
+						     false, prec)); })
+	   { wide_int_to_tree (type0,
+			       wi::shifted_mask (tree_to_uhwi (@1), 1,
+						 false, prec)); })))))))
+(for op (ge gt le lt)
+     cmp (eq eq ne ne)
+ (simplify
+  /* __builtin_ctz (x) >= C -> (x & ((1 << C) - 1)) == 0.  */
+  (op (IFN_CTZ:s @0 @2) INTEGER_CST@1)
+   (with { bool ok = true;
+	   HOST_WIDE_INT val = 0;
+	   if (!tree_fits_shwi_p (@1))
+	     ok = false;
+	   else
+	     {
+	       val = tree_to_shwi (@1);
+	       /* Canonicalize to >= or <.  */
+	       if (op == GT_EXPR || op == LE_EXPR)
+		 {
+		   if (val == HOST_WIDE_INT_MAX)
+		     ok = false;
+		   else
+		     val++;
+		 }
+	     }
+	   HOST_WIDE_INT zero_val = tree_to_shwi (@2);
+	   tree type0 = TREE_TYPE (@0);
+	   int prec = TYPE_PRECISION (type0);
+	   if (prec > MAX_FIXED_MODE_SIZE)
+	     ok = false;
+	  }
+     (if (val <= 0)
+      (if (ok && zero_val >= val)
+       { constant_boolean_node (cmp == EQ_EXPR ? true : false, type); })
+      (if (val >= prec)
+       (if (ok && zero_val < val)
+	{ constant_boolean_node (cmp == EQ_EXPR ? false : true, type); })
+       (if (ok && (zero_val < 0 || zero_val >= prec))
+	(cmp (bit_and @0 { wide_int_to_tree (type0,
+					     wi::mask (val, false, prec)); })
+	     { build_zero_cst (type0); })))))))
+(for op (eq ne)
+ (simplify
+  /* __builtin_ctz (x) == C -> (x & ((1 << (C + 1)) - 1)) == (1 << C).  */
+  (op (IFN_CTZ:s @0 @2) INTEGER_CST@1)
+   (with { HOST_WIDE_INT zero_val = tree_to_shwi (@2);
+	   tree type0 = TREE_TYPE (@0);
+	   int prec = TYPE_PRECISION (type0);
+	 }
+    (if (prec <= MAX_FIXED_MODE_SIZE)
      (if (tree_int_cst_sgn (@1) < 0 || wi::to_widest (@1) >= prec)
-      (if (!zero_res || zero_val != wi::to_widest (@1))
+      (if (zero_val != wi::to_widest (@1))
        { constant_boolean_node (op == EQ_EXPR ? false : true, type); })
-      (if (!zero_res || zero_val < 0 || zero_val >= prec)
+      (if (zero_val < 0 || zero_val >= prec)
        (op (bit_and @0 { wide_int_to_tree (type0,
 					   wi::mask (tree_to_uhwi (@1) + 1,
 						     false, prec)); })
@@ -8628,6 +8672,50 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
 			       wi::shifted_mask (tree_to_uhwi (@1), 1,
 						 false, prec)); })))))))
 
+#if GIMPLE
+/* ctz(ext(X)) == ctz(X).  Valid just for the UB at zero cases though.  */
+(simplify
+  (CTZ (convert@1 @0))
+  (if (INTEGRAL_TYPE_P (TREE_TYPE (@1))
+       && INTEGRAL_TYPE_P (TREE_TYPE (@0))
+       && TYPE_PRECISION (TREE_TYPE (@1)) > TYPE_PRECISION (TREE_TYPE (@0)))
+   (with { combined_fn cfn = CFN_LAST;
+	   tree type0 = TREE_TYPE (@0);
+	   if (TREE_CODE (type0) == BITINT_TYPE)
+	     {
+	       if (TYPE_PRECISION (type0) > MAX_FIXED_MODE_SIZE)
+		 cfn = CFN_CTZ;
+	       else
+		 type0
+		   = build_nonstandard_integer_type (TYPE_PRECISION (type0),
+						     1);
+	     }
+	   type0 = unsigned_type_for (type0);
+	   if (cfn == CFN_LAST
+	       && direct_internal_fn_supported_p (IFN_CTZ, type0,
+						  OPTIMIZE_FOR_BOTH))
+	     cfn = CFN_CTZ;
+	   if (cfn == CFN_LAST
+	       && TYPE_PRECISION (TREE_TYPE (@1)) > BITS_PER_WORD
+	       && !direct_internal_fn_supported_p (IFN_CTZ,
+						   TREE_TYPE (@1),
+						   OPTIMIZE_FOR_BOTH))
+	     {
+	       if (TYPE_PRECISION (type0)
+		   == TYPE_PRECISION (unsigned_type_node))
+		 cfn = CFN_BUILT_IN_CTZ;
+	       else if (TYPE_PRECISION (type0)
+			== TYPE_PRECISION (long_long_unsigned_type_node))
+		 cfn = CFN_BUILT_IN_CTZLL;
+	     } }
+    (if (cfn == CFN_CTZ)
+     (IFN_CTZ (convert:type0 @0))
+     (if (cfn == CFN_BUILT_IN_CTZ)
+      (BUILT_IN_CTZ (convert:type0 @0))
+      (if (cfn == CFN_BUILT_IN_CTZLL)
+       (BUILT_IN_CTZLL (convert:type0 @0))))))))
+#endif
+
 /* POPCOUNT simplifications.  */
 /* popcount(X) + popcount(Y) is popcount(X|Y) when X&Y must be zero.  */
 (simplify
@@ -8698,6 +8786,50 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
 	      (popcount:s @1))
       (popcount (log2 @0 @1)))))
 
+#if GIMPLE
+/* popcount(zext(X)) == popcount(X).  */
+(simplify
+  (POPCOUNT (convert@1 @0))
+  (if (INTEGRAL_TYPE_P (TREE_TYPE (@1))
+       && INTEGRAL_TYPE_P (TREE_TYPE (@0))
+       && TYPE_UNSIGNED (TREE_TYPE (@0))
+       && TYPE_PRECISION (TREE_TYPE (@1)) > TYPE_PRECISION (TREE_TYPE (@0)))
+   (with { combined_fn cfn = CFN_LAST;
+	   tree type0 = TREE_TYPE (@0);
+	   if (TREE_CODE (type0) == BITINT_TYPE)
+	     {
+	       if (TYPE_PRECISION (type0) > MAX_FIXED_MODE_SIZE)
+		 cfn = CFN_POPCOUNT;
+	       else
+		 type0
+		   = build_nonstandard_integer_type (TYPE_PRECISION (type0),
+						     1);
+	     }
+	   if (cfn == CFN_LAST
+	       && direct_internal_fn_supported_p (IFN_POPCOUNT, type0,
+						  OPTIMIZE_FOR_BOTH))
+	     cfn = CFN_POPCOUNT;
+	   if (cfn == CFN_LAST
+	       && TYPE_PRECISION (TREE_TYPE (@1)) > BITS_PER_WORD
+	       && !direct_internal_fn_supported_p (IFN_POPCOUNT,
+						   TREE_TYPE (@1),
+						   OPTIMIZE_FOR_BOTH))
+	     {
+	       if (TYPE_PRECISION (type0)
+		   == TYPE_PRECISION (unsigned_type_node))
+		 cfn = CFN_BUILT_IN_POPCOUNT;
+	       else if (TYPE_PRECISION (type0)
+			== TYPE_PRECISION (long_long_unsigned_type_node))
+		 cfn = CFN_BUILT_IN_POPCOUNTLL;
+	     } }
+    (if (cfn == CFN_POPCOUNT)
+     (IFN_POPCOUNT (convert:type0 @0))
+     (if (cfn == CFN_BUILT_IN_POPCOUNT)
+      (BUILT_IN_POPCOUNT (convert:type0 @0))
+      (if (cfn == CFN_BUILT_IN_POPCOUNTLL)
+       (BUILT_IN_POPCOUNTLL (convert:type0 @0))))))))
+#endif
+
 /* PARITY simplifications.  */
 /* parity(~X) is parity(X).  */
 (simplify
@@ -8736,6 +8868,54 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
   (bit_xor (PARITY:s @0) (PARITY:s @1))
   (PARITY (bit_xor @0 @1)))
 
+#if GIMPLE
+/* parity(zext(X)) == parity(X).  */
+/* parity(sext(X)) == parity(X) if the difference in precision is even.  */
+(simplify
+  (PARITY (convert@1 @0))
+  (if (INTEGRAL_TYPE_P (TREE_TYPE (@1))
+       && INTEGRAL_TYPE_P (TREE_TYPE (@0))
+       && TYPE_PRECISION (TREE_TYPE (@1)) > TYPE_PRECISION (TREE_TYPE (@0))
+       && (TYPE_UNSIGNED (TREE_TYPE (@0))
+	   || ((TYPE_PRECISION (TREE_TYPE (@1))
+		- TYPE_PRECISION (TREE_TYPE (@0))) & 1) == 0))
+   (with { combined_fn cfn = CFN_LAST;
+	   tree type0 = TREE_TYPE (@0);
+	   if (TREE_CODE (type0) == BITINT_TYPE)
+	     {
+	       if (TYPE_PRECISION (type0) > MAX_FIXED_MODE_SIZE)
+		 cfn = CFN_PARITY;
+	       else
+		 type0
+		   = build_nonstandard_integer_type (TYPE_PRECISION (type0),
+						     1);
+	     }
+	   type0 = unsigned_type_for (type0);
+	   if (cfn == CFN_LAST
+	       && direct_internal_fn_supported_p (IFN_PARITY, type0,
+						  OPTIMIZE_FOR_BOTH))
+	     cfn = CFN_PARITY;
+	   if (cfn == CFN_LAST
+	       && TYPE_PRECISION (TREE_TYPE (@1)) > BITS_PER_WORD
+	       && !direct_internal_fn_supported_p (IFN_PARITY,
+						   TREE_TYPE (@1),
+						   OPTIMIZE_FOR_BOTH))
+	     {
+	       if (TYPE_PRECISION (type0)
+		   == TYPE_PRECISION (unsigned_type_node))
+		 cfn = CFN_BUILT_IN_PARITY;
+	       else if (TYPE_PRECISION (type0)
+			== TYPE_PRECISION (long_long_unsigned_type_node))
+		 cfn = CFN_BUILT_IN_PARITYLL;
+	     } }
+    (if (cfn == CFN_PARITY)
+     (IFN_PARITY (convert:type0 @0))
+     (if (cfn == CFN_BUILT_IN_PARITY)
+      (BUILT_IN_PARITY (convert:type0 @0))
+      (if (cfn == CFN_BUILT_IN_PARITYLL)
+       (BUILT_IN_PARITYLL (convert:type0 @0))))))))
+#endif
+
 /* a != 0 ? FUN(a) : 0 -> Fun(a) for some builtin functions. */
 (for func (POPCOUNT BSWAP FFS PARITY)
  (simplify
@@ -8757,13 +8937,38 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
   (cond (ne @0 integer_zerop@1) (func (convert?@3 @0)) INTEGER_CST@2)
   (with { int val;
 	  internal_fn ifn = IFN_LAST;
-	  if (direct_internal_fn_supported_p (IFN_CLZ, type, OPTIMIZE_FOR_BOTH)
-	      && CLZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (type),
-					    val) == 2)
+	  if (TREE_CODE (TREE_TYPE (@3)) == BITINT_TYPE)
+	    {
+	      if (tree_fits_shwi_p (@2))
+		{
+		  HOST_WIDE_INT valw = tree_to_shwi (@2);
+		  if ((int) valw == valw)
+		    {
+		      val = valw;
+		      ifn = IFN_CLZ;
+		    }
+		}
+	    }
+	  else if (direct_internal_fn_supported_p (IFN_CLZ, TREE_TYPE (@3),
+						   OPTIMIZE_FOR_BOTH)
+		   && CLZ_DEFINED_VALUE_AT_ZERO
+			(SCALAR_INT_TYPE_MODE (TREE_TYPE (@3)), val) == 2)
 	    ifn = IFN_CLZ;
 	}
    (if (ifn == IFN_CLZ && wi::to_widest (@2) == val)
-    (IFN_CLZ @3)))))
+    (IFN_CLZ @3 @2)))))
+(simplify
+ (cond (ne @0 integer_zerop@1) (IFN_CLZ (convert?@3 @0) INTEGER_CST@2) @2)
+  (with { int val;
+	  internal_fn ifn = IFN_LAST;
+	  if (TREE_CODE (TREE_TYPE (@3)) == BITINT_TYPE)
+	    ifn = IFN_CLZ;
+	  else if (direct_internal_fn_supported_p (IFN_CLZ, TREE_TYPE (@3),
+						   OPTIMIZE_FOR_BOTH))
+	    ifn = IFN_CLZ;
+	}
+   (if (ifn == IFN_CLZ)
+    (IFN_CLZ @3 @2))))
 
 /* a != 0 ? CTZ(a) : CST -> .CTZ(a) where CST is the result of the internal function for 0. */
 (for func (CTZ)
@@ -8771,13 +8976,38 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
   (cond (ne @0 integer_zerop@1) (func (convert?@3 @0)) INTEGER_CST@2)
   (with { int val;
 	  internal_fn ifn = IFN_LAST;
-	  if (direct_internal_fn_supported_p (IFN_CTZ, type, OPTIMIZE_FOR_BOTH)
-	      && CTZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (type),
-					    val) == 2)
+	  if (TREE_CODE (TREE_TYPE (@3)) == BITINT_TYPE)
+	    {
+	      if (tree_fits_shwi_p (@2))
+		{
+		  HOST_WIDE_INT valw = tree_to_shwi (@2);
+		  if ((int) valw == valw)
+		    {
+		      val = valw;
+		      ifn = IFN_CTZ;
+		    }
+		}
+	    }
+	  else if (direct_internal_fn_supported_p (IFN_CTZ, TREE_TYPE (@3),
+						   OPTIMIZE_FOR_BOTH)
+		   && CTZ_DEFINED_VALUE_AT_ZERO
+			(SCALAR_INT_TYPE_MODE (TREE_TYPE (@3)), val) == 2)
 	    ifn = IFN_CTZ;
 	}
    (if (ifn == IFN_CTZ && wi::to_widest (@2) == val)
-    (IFN_CTZ @3)))))
+    (IFN_CTZ @3 @2)))))
+(simplify
+ (cond (ne @0 integer_zerop@1) (IFN_CTZ (convert?@3 @0) INTEGER_CST@2) @2)
+  (with { int val;
+	  internal_fn ifn = IFN_LAST;
+	  if (TREE_CODE (TREE_TYPE (@3)) == BITINT_TYPE)
+	    ifn = IFN_CTZ;
+	  else if (direct_internal_fn_supported_p (IFN_CTZ, TREE_TYPE (@3),
+						   OPTIMIZE_FOR_BOTH))
+	    ifn = IFN_CTZ;
+	}
+   (if (ifn == IFN_CTZ)
+    (IFN_CTZ @3 @2))))
 #endif
 
 /* Common POPCOUNT/PARITY simplifications.  */
@@ -8893,8 +9123,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
    (plus (CTZ:type (convert:utype @0)) { build_one_cst (type); }))))
 #endif
 
-(for ffs (BUILT_IN_FFS BUILT_IN_FFSL BUILT_IN_FFSLL
-	  BUILT_IN_FFSIMAX)
+(for ffs (FFS)
  /* __builtin_ffs (X) == 0 -> X == 0.
     __builtin_ffs (X) == 6 -> (X & 63) == 32.  */
  (for cmp (eq ne)
@@ -8942,6 +9171,50 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
 		     { build_zero_cst (TREE_TYPE (@0)); }))))))))
 
 #if GIMPLE
+/* ffs(ext(X)) == ffs(X).  */
+(simplify
+  (FFS (convert@1 @0))
+  (if (INTEGRAL_TYPE_P (TREE_TYPE (@1))
+       && INTEGRAL_TYPE_P (TREE_TYPE (@0))
+       && TYPE_PRECISION (TREE_TYPE (@1)) > TYPE_PRECISION (TREE_TYPE (@0)))
+   (with { combined_fn cfn = CFN_LAST;
+	   tree type0 = TREE_TYPE (@0);
+	   if (TREE_CODE (type0) == BITINT_TYPE)
+	     {
+	       if (TYPE_PRECISION (type0) > MAX_FIXED_MODE_SIZE)
+		 cfn = CFN_FFS;
+	       else
+		 type0
+		   = build_nonstandard_integer_type (TYPE_PRECISION (type0),
+						     0);
+	     }
+	   type0 = signed_type_for (type0);
+	   if (cfn == CFN_LAST
+	       && direct_internal_fn_supported_p (IFN_FFS, type0,
+						  OPTIMIZE_FOR_BOTH))
+	     cfn = CFN_FFS;
+	   if (cfn == CFN_LAST
+	       && TYPE_PRECISION (TREE_TYPE (@1)) > BITS_PER_WORD
+	       && !direct_internal_fn_supported_p (IFN_FFS,
+						   TREE_TYPE (@1),
+						   OPTIMIZE_FOR_BOTH))
+	     {
+	       if (TYPE_PRECISION (type0)
+		   == TYPE_PRECISION (integer_type_node))
+		 cfn = CFN_BUILT_IN_FFS;
+	       else if (TYPE_PRECISION (type0)
+			== TYPE_PRECISION (long_long_integer_type_node))
+		 cfn = CFN_BUILT_IN_FFSLL;
+	     } }
+    (if (cfn == CFN_FFS)
+     (IFN_FFS (convert:type0 @0))
+     (if (cfn == CFN_BUILT_IN_FFS)
+      (BUILT_IN_FFS (convert:type0 @0))
+      (if (cfn == CFN_BUILT_IN_FFSLL)
+       (BUILT_IN_FFSLL (convert:type0 @0))))))))
+#endif
+
+#if GIMPLE
 
 /* Simplify:
      a = op a1
diff --git a/gcc/optinfo-emit-json.cc b/gcc/optinfo-emit-json.cc
index a4e8faa..11cad42 100644
--- a/gcc/optinfo-emit-json.cc
+++ b/gcc/optinfo-emit-json.cc
@@ -58,14 +58,14 @@ optrecord_json_writer::optrecord_json_writer ()
   /* Populate with metadata; compare with toplev.cc: print_version.  */
   json::object *metadata = new json::object ();
   m_root_tuple->append (metadata);
-  metadata->set ("format", new json::string ("1"));
+  metadata->set_string ("format", "1");
   json::object *generator = new json::object ();
   metadata->set ("generator", generator);
-  generator->set ("name", new json::string (lang_hooks.name));
-  generator->set ("pkgversion", new json::string (pkgversion_string));
-  generator->set ("version", new json::string (version_string));
+  generator->set_string ("name", lang_hooks.name);
+  generator->set_string ("pkgversion", pkgversion_string);
+  generator->set_string ("version", version_string);
   /* TARGET_NAME is passed in by the Makefile.  */
-  generator->set ("target", new json::string (TARGET_NAME));
+  generator->set_string ("target", TARGET_NAME);
 
   /* TODO: capture command-line?
      see gen_producer_string in dwarf2out.cc (currently static).  */
@@ -180,10 +180,10 @@ json::object *
 optrecord_json_writer::impl_location_to_json (dump_impl_location_t loc)
 {
   json::object *obj = new json::object ();
-  obj->set ("file", new json::string (loc.m_file));
-  obj->set ("line", new json::integer_number (loc.m_line));
+  obj->set_string ("file", loc.m_file);
+  obj->set_integer ("line", loc.m_line);
   if (loc.m_function)
-    obj->set ("function", new json::string (loc.m_function));
+    obj->set_string ("function", loc.m_function);
   return obj;
 }
 
@@ -195,9 +195,9 @@ optrecord_json_writer::location_to_json (location_t loc)
   gcc_assert (LOCATION_LOCUS (loc) != UNKNOWN_LOCATION);
   expanded_location exploc = expand_location (loc);
   json::object *obj = new json::object ();
-  obj->set ("file", new json::string (exploc.file));
-  obj->set ("line", new json::integer_number (exploc.line));
-  obj->set ("column", new json::integer_number (exploc.column));
+  obj->set_string ("file", exploc.file);
+  obj->set_integer ("line", exploc.line);
+  obj->set_integer ("column", exploc.column);
   return obj;
 }
 
@@ -207,9 +207,8 @@ json::object *
 optrecord_json_writer::profile_count_to_json (profile_count count)
 {
   json::object *obj = new json::object ();
-  obj->set ("value", new json::integer_number (count.to_gcov_type ()));
-  obj->set ("quality",
-	    new json::string (profile_quality_as_string (count.quality ())));
+  obj->set_integer ("value", count.to_gcov_type ());
+  obj->set_string ("quality", profile_quality_as_string (count.quality ()));
   return obj;
 }
 
@@ -250,8 +249,8 @@ optrecord_json_writer::pass_to_json (opt_pass *pass)
       break;
     }
   obj->set ("id", get_id_value_for_pass (pass));
-  obj->set ("type", new json::string (type));
-  obj->set ("name", new json::string (pass->name));
+  obj->set_string ("type", type);
+  obj->set_string ("name", pass->name);
   /* Represent the optgroup flags as an array.  */
   {
     json::array *optgroups = new json::array ();
@@ -262,7 +261,7 @@ optrecord_json_writer::pass_to_json (opt_pass *pass)
 	  && (pass->optinfo_flags & optgroup->value))
 	optgroups->append (new json::string (optgroup->name));
   }
-  obj->set ("num", new json::integer_number (pass->static_pass_number));
+  obj->set_integer ("num", pass->static_pass_number);
   return obj;
 }
 
@@ -315,7 +314,7 @@ optrecord_json_writer::inlining_chain_to_json (location_t loc)
 	  json::object *obj = new json::object ();
 	  const char *printable_name
 	    = lang_hooks.decl_printable_name (fndecl, 2);
-	  obj->set ("fndecl", new json::string (printable_name));
+	  obj->set_string ("fndecl", printable_name);
 	  if (LOCATION_LOCUS (*locus) != UNKNOWN_LOCATION)
 	    obj->set ("site", location_to_json (*locus));
 	  array->append (obj);
@@ -336,7 +335,7 @@ optrecord_json_writer::optinfo_to_json (const optinfo *optinfo)
 	    impl_location_to_json (optinfo->get_impl_location ()));
 
   const char *kind_str = optinfo_kind_to_string (optinfo->get_kind ());
-  obj->set ("kind", new json::string (kind_str));
+  obj->set_string ("kind", kind_str);
   json::array *message = new json::array ();
   obj->set ("message", message);
   for (unsigned i = 0; i < optinfo->num_items (); i++)
@@ -354,7 +353,7 @@ optrecord_json_writer::optinfo_to_json (const optinfo *optinfo)
 	case OPTINFO_ITEM_KIND_TREE:
 	  {
 	    json::object *json_item = new json::object ();
-	    json_item->set ("expr", new json::string (item->get_text ()));
+	    json_item->set_string ("expr", item->get_text ());
 
 	    /* Capture any location for the node.  */
 	    if (LOCATION_LOCUS (item->get_location ()) != UNKNOWN_LOCATION)
@@ -367,7 +366,7 @@ optrecord_json_writer::optinfo_to_json (const optinfo *optinfo)
 	case OPTINFO_ITEM_KIND_GIMPLE:
 	  {
 	    json::object *json_item = new json::object ();
-	    json_item->set ("stmt", new json::string (item->get_text ()));
+	    json_item->set_string ("stmt", item->get_text ());
 
 	    /* Capture any location for the stmt.  */
 	    if (LOCATION_LOCUS (item->get_location ()) != UNKNOWN_LOCATION)
@@ -380,7 +379,7 @@ optrecord_json_writer::optinfo_to_json (const optinfo *optinfo)
 	case OPTINFO_ITEM_KIND_SYMTAB_NODE:
 	  {
 	    json::object *json_item = new json::object ();
-	    json_item->set ("symtab_node", new json::string (item->get_text ()));
+	    json_item->set_string ("symtab_node", item->get_text ());
 
 	    /* Capture any location for the node.  */
 	    if (LOCATION_LOCUS (item->get_location ()) != UNKNOWN_LOCATION)
@@ -413,7 +412,7 @@ optrecord_json_writer::optinfo_to_json (const optinfo *optinfo)
     {
       const char *fnname
 	= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
-      obj->set ("function", new json::string (fnname));
+      obj->set_string ("function", fnname);
     }
 
   if (loc != UNKNOWN_LOCATION)
diff --git a/gcc/opts-diagnostic.h b/gcc/opts-diagnostic.h
index b36fb46..8c3b695 100644
--- a/gcc/opts-diagnostic.h
+++ b/gcc/opts-diagnostic.h
@@ -20,9 +20,10 @@ along with GCC; see the file COPYING3.  If not see
 #ifndef GCC_OPTS_DIAGNOSTIC_H
 #define GCC_OPTS_DIAGNOSTIC_H
 
-extern char *option_name (diagnostic_context *context, int option_index,
+extern char *option_name (const diagnostic_context *context, int option_index,
 			  diagnostic_t orig_diag_kind, diagnostic_t diag_kind);
 
-extern char *get_option_url (diagnostic_context *context, int option_index);
+extern char *get_option_url (const diagnostic_context *context,
+			     int option_index);
 
 #endif
diff --git a/gcc/opts.cc b/gcc/opts.cc
index 32fdfc3..33165c9 100644
--- a/gcc/opts.cc
+++ b/gcc/opts.cc
@@ -3615,7 +3615,7 @@ enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
    as -Werror.  */
 
 char *
-option_name (diagnostic_context *context, int option_index,
+option_name (const diagnostic_context *context, int option_index,
 	     diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
 {
   if (option_index)
@@ -3674,7 +3674,7 @@ get_option_html_page (int option_index)
    which enabled a diagnostic (context CONTEXT).  */
 
 char *
-get_option_url (diagnostic_context *, int option_index)
+get_option_url (const diagnostic_context *, int option_index)
 {
   if (option_index)
     return concat (/* DOCUMENTATION_ROOT_URL should be supplied via
diff --git a/gcc/pretty-print.h b/gcc/pretty-print.h
index 9ba2c0a..138c582 100644
--- a/gcc/pretty-print.h
+++ b/gcc/pretty-print.h
@@ -22,6 +22,7 @@ along with GCC; see the file COPYING3.  If not see
 #define GCC_PRETTY_PRINT_H
 
 #include "obstack.h"
+#include "rich-location.h"
 #include "diagnostic-url.h"
 
 /* Maximum number of format string arguments.  */
diff --git a/gcc/rust/rust-location.h b/gcc/rust/rust-location.h
index 9d04643..db756dd 100644
--- a/gcc/rust/rust-location.h
+++ b/gcc/rust/rust-location.h
@@ -21,6 +21,7 @@
 #ifndef RUST_LOCATION_H
 #define RUST_LOCATION_H
 
+#include "rich-location.h"
 #include "rust-system.h"
 
 // A location in an input source file.
diff --git a/gcc/selftest-diagnostic.cc b/gcc/selftest-diagnostic.cc
index 37e98ed..f9a1852 100644
--- a/gcc/selftest-diagnostic.cc
+++ b/gcc/selftest-diagnostic.cc
@@ -39,7 +39,7 @@ test_diagnostic_context::test_diagnostic_context ()
   m_source_printing.enabled = true;
   m_source_printing.show_labels_p = true;
   m_show_column = true;
-  m_text_callbacks.start_span = start_span_cb;
+  diagnostic_start_span (this) = start_span_cb;
   m_source_printing.min_margin_width = 6;
   m_source_printing.max_width = 80;
 }
diff --git a/gcc/selftest.cc b/gcc/selftest.cc
index 20c10bbd..2d0181b 100644
--- a/gcc/selftest.cc
+++ b/gcc/selftest.cc
@@ -161,10 +161,12 @@ assert_str_startswith (const location &loc,
 
 /* Constructor.  Generate a name for the file.  */
 
-named_temp_file::named_temp_file (const char *suffix)
+named_temp_file::named_temp_file (const char *suffix,
+				  file_cache *fc)
 {
   m_filename = make_temp_file (suffix);
   ASSERT_NE (m_filename, NULL);
+  m_file_cache = fc;
 }
 
 /* Destructor.  Delete the tempfile.  */
@@ -172,7 +174,8 @@ named_temp_file::named_temp_file (const char *suffix)
 named_temp_file::~named_temp_file ()
 {
   unlink (m_filename);
-  diagnostics_file_cache_forcibly_evict_file (m_filename);
+  if (m_file_cache)
+    m_file_cache->forcibly_evict_file (m_filename);
   free (m_filename);
 }
 
@@ -182,8 +185,9 @@ named_temp_file::~named_temp_file ()
 
 temp_source_file::temp_source_file (const location &loc,
 				    const char *suffix,
-				    const char *content)
-: named_temp_file (suffix)
+				    const char *content,
+				    file_cache *fc)
+: named_temp_file (suffix, fc)
 {
   FILE *out = fopen (get_filename (), "w");
   if (!out)
diff --git a/gcc/selftest.h b/gcc/selftest.h
index b0a4142..3bb4885 100644
--- a/gcc/selftest.h
+++ b/gcc/selftest.h
@@ -25,6 +25,8 @@ along with GCC; see the file COPYING3.  If not see
 
 #if CHECKING_P
 
+class file_cache;
+
 namespace selftest {
 
 /* A struct describing the source-location of a selftest, to make it
@@ -91,17 +93,20 @@ extern void assert_str_startswith (const location &loc,
 /* A named temporary file for use in selftests.
    Usable for writing out files, and as the base class for
    temp_source_file.
-   The file is unlinked in the destructor.  */
+   The file is unlinked in the destructor.
+   If the file_cache is non-null, the filename is evicted from
+   the file_cache when the named_temp_file is destroyed.  */
 
 class named_temp_file
 {
  public:
-  named_temp_file (const char *suffix);
+  named_temp_file (const char *suffix, file_cache *fc = nullptr);
   ~named_temp_file ();
   const char *get_filename () const { return m_filename; }
 
  private:
   char *m_filename;
+  file_cache *m_file_cache;
 };
 
 /* A class for writing out a temporary sourcefile for use in selftests
@@ -111,7 +116,7 @@ class temp_source_file : public named_temp_file
 {
  public:
   temp_source_file (const location &loc, const char *suffix,
-		    const char *content);
+		    const char *content, file_cache *fc = nullptr);
   temp_source_file (const location &loc, const char *suffix,
 		    const char *content, size_t sz);
 };
diff --git a/gcc/simplify-rtx.cc b/gcc/simplify-rtx.cc
index 2d2e5a3..f3745d8 100644
--- a/gcc/simplify-rtx.cc
+++ b/gcc/simplify-rtx.cc
@@ -4392,7 +4392,7 @@ simplify_ashift:
 	  real_convert (&f1, mode, CONST_DOUBLE_REAL_VALUE (trueop1));
 	  rtx tmp = simplify_gen_unary (ABS, mode, op0, mode);
 	  if (REAL_VALUE_NEGATIVE (f1))
-	    tmp = simplify_gen_unary (NEG, mode, tmp, mode);
+	    tmp = simplify_unary_operation (NEG, mode, tmp, mode);
 	  return tmp;
 	}
       if (GET_CODE (op0) == NEG || GET_CODE (op0) == ABS)
diff --git a/gcc/substring-locations.h b/gcc/substring-locations.h
index ce99957..ec49215 100644
--- a/gcc/substring-locations.h
+++ b/gcc/substring-locations.h
@@ -116,6 +116,7 @@ class format_string_diagnostic_t
    LANG_HOOKS_GET_SUBSTRING_LOCATION.  */
 
 extern const char *get_location_within_string (cpp_reader *pfile,
+					       file_cache &fc,
 					       string_concat_db *concats,
 					       location_t strloc,
 					       enum cpp_ttype type,
diff --git a/gcc/target.def b/gcc/target.def
index 0996da0..475c55c 100644
--- a/gcc/target.def
+++ b/gcc/target.def
@@ -7243,18 +7243,6 @@ DEFHOOK
  void, (void),
  NULL)
 
-DEFHOOK
-(gcov_type_size,
- "Returns the gcov type size in bits.  This type is used for example for\n\
-counters incremented by profiling and code-coverage events.  The default\n\
-value is 64, if the type size of long long is greater than 32, otherwise the\n\
-default value is 32.  A 64-bit type is recommended to avoid overflows of the\n\
-counters.  If the @option{-fprofile-update=atomic} is used, then the\n\
-counters are incremented using atomic operations.  Targets not supporting\n\
-64-bit atomic operations may override the default value and request a 32-bit\n\
-type.",
- HOST_WIDE_INT, (void), default_gcov_type_size)
-
 /* This value represents whether the shadow call stack is implemented on
    the target platform.  */
 DEFHOOKPOD
@@ -7263,6 +7251,14 @@ DEFHOOKPOD
 @option{-fsanitize=shadow-call-stack}.  The default value is false.",
  bool, false)
 
+/* This value represents whether libatomic is available on
+   the target platform.  */
+DEFHOOKPOD
+(have_libatomic,
+ "This value is true if the target platform supports\n\
+libatomic.  The default value is false.",
+ bool, false)
+
 /* Close the 'struct gcc_target' definition.  */
 HOOK_VECTOR_END (C90_EMPTY_HACK)
 
diff --git a/gcc/targhooks.cc b/gcc/targhooks.cc
index 4f5b240..6b5173b 100644
--- a/gcc/targhooks.cc
+++ b/gcc/targhooks.cc
@@ -2778,11 +2778,4 @@ default_memtag_untagged_pointer (rtx tagged_pointer, rtx target)
   return untagged_base;
 }
 
-/* The default implementation of TARGET_GCOV_TYPE_SIZE.  */
-HOST_WIDE_INT
-default_gcov_type_size (void)
-{
-  return TYPE_PRECISION (long_long_integer_type_node) > 32 ? 64 : 32;
-}
-
 #include "gt-targhooks.h"
diff --git a/gcc/targhooks.h b/gcc/targhooks.h
index 189549c..0b35e8a 100644
--- a/gcc/targhooks.h
+++ b/gcc/targhooks.h
@@ -302,6 +302,4 @@ extern rtx default_memtag_set_tag (rtx, rtx, rtx);
 extern rtx default_memtag_extract_tag (rtx, rtx);
 extern rtx default_memtag_untagged_pointer (rtx, rtx);
 
-extern HOST_WIDE_INT default_gcov_type_size (void);
-
 #endif /* GCC_TARGHOOKS_H */
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 520b1f0..53e7e89 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,3098 @@
+2023-11-18  Xi Ruoyao  <xry111@xry111.site>
+
+	* gcc.target/loongarch/div-div32.c: New test.
+	* gcc.target/loongarch/div-no-div32.c: New test.
+
+2023-11-18  Francois-Xavier Coudert  <fxcoudert@gcc.gnu.org>
+
+	* gfortran.dg/coarray/caf.exp: Remove unused variable.
+	* gfortran.dg/dg.exp: Remove unused variable.
+
+2023-11-18  Lulu Cheng  <chenglulu@loongson.cn>
+	    Xi Ruoyao  <xry111@xry111.site>
+
+	* gcc.target/loongarch/func-call-medium-5.c: If the assembler supports call36,
+	the test is abandoned.
+	* gcc.target/loongarch/func-call-medium-6.c: Likewise.
+	* gcc.target/loongarch/func-call-medium-7.c: Likewise.
+	* gcc.target/loongarch/func-call-medium-8.c: Likewise.
+	* lib/target-supports.exp: Added a function to see if the assembler supports
+	the call36 relocation.
+	* gcc.target/loongarch/func-call-medium-call36-1.c: New test.
+	* gcc.target/loongarch/func-call-medium-call36.c: New test.
+
+2023-11-18  David Malcolm  <dmalcolm@redhat.com>
+
+	PR analyzer/106147
+	* c-c++-common/analyzer/gzio-2.c: Add dg-warning for infinite
+	loop, marked as xfail.
+	* c-c++-common/analyzer/infinite-loop-2.c: New test.
+	* c-c++-common/analyzer/infinite-loop-4.c: New test.
+	* c-c++-common/analyzer/infinite-loop-crc32c.c: New test.
+	* c-c++-common/analyzer/infinite-loop-doom-d_main-IdentifyVersion.c:
+	New test.
+	* c-c++-common/analyzer/infinite-loop-doom-v_video.c: New test.
+	* c-c++-common/analyzer/infinite-loop-g_error.c: New test.
+	* c-c++-common/analyzer/infinite-loop-linked-list.c: New test.
+	* c-c++-common/analyzer/infinite-recursion-inlining.c: Add
+	dg-warning directives for infinite loop.
+	* c-c++-common/analyzer/inlining-4-multiline.c: Update expected
+	paths for event 5 having a location.
+	* gcc.dg/analyzer/boxed-malloc-1.c: Add dg-warning for infinite
+	loop.
+	* gcc.dg/analyzer/data-model-20.c: Likewise.  Add comment about
+	suspect code, and create...
+	* gcc.dg/analyzer/data-model-20a.c: ...this new test by cleaning
+	it up.
+	* gcc.dg/analyzer/edges-1.c: Add a placeholder statement to avoid
+	the "...to here" from the if stmt occurring at the "while", and
+	thus being treated as a bogus event.
+	* gcc.dg/analyzer/explode-2a.c: Add dg-warning for infinite loop.
+	* gcc.dg/analyzer/infinite-loop-1.c: New test.
+	* gcc.dg/analyzer/malloc-1.c: Add dg-warning for infinite loop.
+	* gcc.dg/analyzer/out-of-bounds-coreutils.c: Add TODO.
+	* gcc.dg/analyzer/paths-4.c: Add dg-warning for infinite loop.
+	* gcc.dg/analyzer/pr103892.c: Likewise.
+	* gcc.dg/analyzer/pr93546.c: Likewise.
+
+2023-11-17  Robin Dapp  <rdapp@ventanamicro.com>
+
+	* gcc.target/aarch64/pr112406.c: New test.
+	* gcc.target/riscv/rvv/autovec/pr112552.c: New test.
+
+2023-11-17  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/107571
+	* g++.dg/DRs/dr2406.C: New test.
+
+2023-11-17  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/112566
+	PR tree-optimization/83171
+	* gcc.dg/pr112566-1.c: New test.
+	* gcc.dg/pr112566-2.c: New test.
+	* gcc.target/i386/pr78057.c (foo): Pass another long long argument
+	and use it in __builtin_ia32_*zcnt_u64 instead of the int one.
+
+2023-11-17  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/112374
+	* gcc.dg/pr112374-1.c: New test.
+	* gcc.dg/pr112374-2.c: New test.
+	* g++.dg/opt/pr112374.C: New test.
+
+2023-11-17  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/112585
+	* gcc.dg/torture/pr112585.c: New testcase.
+
+2023-11-17  Richard Biener  <rguenther@suse.de>
+
+	Revert:
+	2023-11-17  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/112281
+	* gcc.dg/torture/pr112281.c: New testcase.
+
+2023-11-17  Tobias Burnus  <tobias@codesourcery.com>
+
+	* gfortran.dg/goacc/warn_truncated.f90: Add -std=f2018 option.
+	* gfortran.dg/gomp/warn_truncated.f90: Likewise.
+	* gfortran.dg/line_length_10.f90: Likewise.
+	* gfortran.dg/line_length_11.f90: Likewise.
+	* gfortran.dg/line_length_2.f90: Likewise.
+	* gfortran.dg/line_length_5.f90: Likewise.
+	* gfortran.dg/line_length_6.f90: Likewise.
+	* gfortran.dg/line_length_7.f90: Likewise.
+	* gfortran.dg/line_length_8.f90: Likewise.
+	* gfortran.dg/line_length_9.f90: Likewise.
+	* gfortran.dg/continuation_17.f90: New test.
+	* gfortran.dg/continuation_18.f90: New test.
+	* gfortran.dg/continuation_19.f: New test.
+	* gfortran.dg/line_length_12.f90: New test.
+	* gfortran.dg/line_length_13.f90: New test.
+
+2023-11-17  Georg-Johann Lay  <avr@gjlay.de>
+
+	PR target/53372
+	* gcc.target/avr/pr53372-1.c: New test.
+	* gcc.target/avr/pr53372-2.c: New test.
+
+2023-11-17  Francois-Xavier Coudert  <fxcoudert@gcc.gnu.org>
+
+	* gfortran.dg/coarray/caf.exp: Remove some output.
+	* gfortran.dg/dg.exp: Remove some output.
+
+2023-11-17  Xi Ruoyao  <xry111@xry111.site>
+
+	* g++.target/loongarch/vect-copysign-negconst.C: New test.
+	* g++.target/loongarch/vect-copysign-negconst-run.C: New test.
+
+2023-11-17  Haochen Gui  <guihaoc@gcc.gnu.org>
+
+	PR target/111449
+	* gcc.target/powerpc/pr111449-2.c: New.
+
+2023-11-17  Haochen Gui  <guihaoc@gcc.gnu.org>
+
+	PR target/111449
+	* gcc.target/powerpc/pr111449-1.c: New.
+	* gcc.dg/tree-ssa/sra-17.c: Add additional options for 32-bit powerpc.
+	* gcc.dg/tree-ssa/sra-18.c: Likewise.
+
+2023-11-17  Li Wei  <liwei@loongson.cn>
+
+	* gcc.dg/pr90838.c: add clz/ctz test support on LoongArch.
+
+2023-11-17  Jiahao Xu  <xujiahao@loongson.cn>
+
+	* gcc.target/loongarch/vector/lasx/lasx-vcond-1.c: Adjust assembler times.
+	* gcc.target/loongarch/vector/lasx/lasx-vcond-2.c: Ditto.
+	* gcc.target/loongarch/vector/lsx/lsx-vcond-1.c: Ditto.
+	* gcc.target/loongarch/vector/lsx/lsx-vcond-2.c: Ditto.
+
+2023-11-16  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gnat.dg/varsize4.adb (Func): Initialize Byte_Read parameter.
+
+2023-11-16  Edwin Lu  <ewlu@rivosinc.com>
+
+	PR target/111557
+	* gcc.target/riscv/attribute-1.c: update macro name
+	* gcc.target/riscv/attribute-4.c: ditto
+	* gcc.target/riscv/attribute-5.c: ditto
+	* gcc.target/riscv/predef-align-1.c: ditto
+	* gcc.target/riscv/predef-align-2.c: ditto
+	* gcc.target/riscv/predef-align-3.c: ditto
+	* gcc.target/riscv/predef-align-4.c: ditto
+	* gcc.target/riscv/predef-align-5.c: ditto
+	* gcc.target/riscv/predef-align-6.c: ditto
+
+2023-11-16  Uros Bizjak  <ubizjak@gmail.com>
+
+	PR target/78904
+	* gcc.target/i386/pr78904-10.c: New test.
+	* gcc.target/i386/pr78904-10a.c: New test.
+	* gcc.target/i386/pr78904-10b.c: New test.
+
+2023-11-16  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gnat.dg/varsize4.ads, gnat.dg/varsize4.adb: New test.
+	* gnat.dg/varsize4_pkg.ads: New helper.
+
+2023-11-16  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/112365
+	* g++.dg/cpp0x/pr112365.C: New test.
+
+2023-11-16  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/98614
+	PR c++/104802
+	* g++.dg/cpp1z/nontype-auto22.C: New test.
+	* g++.dg/cpp2a/concepts-partial-spec14.C: New test.
+
+2023-11-16  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/111703
+	PR c++/107939
+	* g++.dg/cpp2a/concepts-fn8.C: Extend test.
+	* g++.dg/diagnostic/constexpr4.C: New test.
+
+2023-11-16  Tamar Christina  <tamar.christina@arm.com>
+
+	PR tree-optimization/111878
+	* gcc.dg/graphite/pr111878.c: New test.
+
+2023-11-16  Florian Weimer  <fweimer@redhat.com>
+
+	* gcc.c-torture/execute/931004-13.c (main): Fix mistakenly swapped
+	int/void types.
+
+2023-11-16  Kito Cheng  <kito.cheng@sifive.com>
+
+	* gcc.target/riscv/target-attr-01.c: New.
+	* gcc.target/riscv/target-attr-02.c: Ditto.
+	* gcc.target/riscv/target-attr-03.c: Ditto.
+	* gcc.target/riscv/target-attr-04.c: Ditto.
+	* gcc.target/riscv/target-attr-05.c: Ditto.
+	* gcc.target/riscv/target-attr-06.c: Ditto.
+	* gcc.target/riscv/target-attr-07.c: Ditto.
+	* gcc.target/riscv/target-attr-bad-01.c: Ditto.
+	* gcc.target/riscv/target-attr-bad-02.c: Ditto.
+	* gcc.target/riscv/target-attr-bad-03.c: Ditto.
+	* gcc.target/riscv/target-attr-bad-04.c: Ditto.
+	* gcc.target/riscv/target-attr-bad-05.c: Ditto.
+	* gcc.target/riscv/target-attr-bad-06.c: Ditto.
+	* gcc.target/riscv/target-attr-bad-07.c: Ditto.
+	* gcc.target/riscv/target-attr-bad-08.c: Ditto.
+	* gcc.target/riscv/target-attr-bad-09.c: Ditto.
+	* gcc.target/riscv/target-attr-bad-10.c: Ditto.
+
+2023-11-16  Kito Cheng  <kito.cheng@sifive.com>
+
+	PR target/112478
+	* gcc.target/riscv/pr112478.c: New.
+
+2023-11-16  liuhongt  <hongtao.liu@intel.com>
+
+	* gcc.target/i386/pr112532.c: New test.
+
+2023-11-16  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/112526
+	* gcc.target/i386/bmi2-pr112526.c: New test.
+
+2023-11-16  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/112536
+	* gcc.dg/pr112536.c: New test.
+
+2023-11-16  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/112282
+	* gcc.dg/torture/pr112282.c: Do not use __assert_fail.
+
+2023-11-16  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	PR middle-end/112554
+	* gcc.target/riscv/rvv/autovec/pr112554.c: New test.
+
+2023-11-16  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/112410
+	* g++.dg/cpp23/auto-fncast13.C: New test.
+	* g++.dg/cpp23/auto-fncast14.C: New test.
+
+2023-11-15  Uros Bizjak  <ubizjak@gmail.com>
+
+	PR target/78904
+	* gcc.target/i386/pr78904-8.c: New test.
+	* gcc.target/i386/pr78904-8a.c: New test.
+	* gcc.target/i386/pr78904-8b.c: New test.
+	* gcc.target/i386/pr78904-9.c: New test.
+	* gcc.target/i386/pr78904-9a.c: New test.
+	* gcc.target/i386/pr78904-9b.c: New test.
+
+2023-11-15  Patrick O'Neill  <patrick@rivosinc.com>
+
+	* gcc.target/riscv/arch-27.c: New test.
+	* gcc.target/riscv/arch-28.c: New test.
+
+2023-11-15  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/112515
+	* g++.dg/template/non-dependent30.C: New test.
+
+2023-11-15  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/101043
+	* g++.dg/cpp2a/concepts-requires37.C: New test.
+
+2023-11-15  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/112427
+	* g++.dg/template/non-dependent29.C: New test.
+
+2023-11-15  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/111703
+	PR c++/112269
+	* g++.dg/cpp2a/concepts-fn8.C: New test.
+
+2023-11-15  Roger Sayle  <roger@nextmovesoftware.com>
+	    Thomas Schwinge  <thomas@codesourcery.com>
+
+	* gcc.target/nvptx/brev-2-O2.c: Adjust.
+	* gcc.target/nvptx/brevll-2-O2.c: Likewise.
+
+2023-11-15  Thomas Schwinge  <thomas@codesourcery.com>
+
+	* gcc.target/nvptx/brev-1.c: Extend.
+	* gcc.target/nvptx/brev-2.c: Rename to...
+	* gcc.target/nvptx/brev-2-O2.c: ... this, and extend.  Copy to...
+	* gcc.target/nvptx/brev-2-O0.c: ... this, and adapt for '-O0'.
+	* gcc.target/nvptx/brevll-1.c: Extend.
+	* gcc.target/nvptx/brevll-2.c: Rename to...
+	* gcc.target/nvptx/brevll-2-O2.c: ... this, and extend.  Copy to...
+	* gcc.target/nvptx/brevll-2-O0.c: ... this, and adapt for '-O0'.
+
+2023-11-15  Andrew Stubbs  <ams@codesourcery.com>
+	    Andrew Jenner   <andrew@codesourcery.com>
+
+	* gcc.target/gcn/avgpr-mem-double.c: New test.
+	* gcc.target/gcn/avgpr-mem-int.c: New test.
+	* gcc.target/gcn/avgpr-mem-long.c: New test.
+	* gcc.target/gcn/avgpr-mem-short.c: New test.
+	* gcc.target/gcn/avgpr-spill-double.c: New test.
+	* gcc.target/gcn/avgpr-spill-int.c: New test.
+	* gcc.target/gcn/avgpr-spill-long.c: New test.
+	* gcc.target/gcn/avgpr-spill-short.c: New test.
+
+2023-11-15  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/112282
+	* gcc.dg/torture/pr112282.c: New testcase.
+
+2023-11-15  Jakub Jelinek  <jakub@redhat.com>
+
+	* c-c++-common/asan/sanity-check-pure-c-1.c: Adjust for interceptor_
+	or wrap_ substrings possibly not being emitted in newer libasan.
+
+2023-11-15  Xi Ruoyao  <xry111@xry111.site>
+
+	* gcc.target/loongarch/cas-acquire.c: New test.
+
+2023-11-15  Richard Earnshaw  <rearnsha@arm.com>
+
+	* lib/target-supports.exp (check_effective_target_arm_arch_v6t2_hw_ok):
+	Rename to...
+	(check_effective_target_arm_arch_v6t2_hw): ... this.  Fix checks.
+	* gcc.target/arm/acle/data-intrinsics-armv6.c: Update pre-check.
+	* gcc.target/arm/acle/data-intrinsics-rbit.c: Likewise.
+
+2023-11-15  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/autovec/vls/def.h: Add trailing tests.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/trailing-1.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/trailing-2.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/trailing_run-1.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/trailing_run-2.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/trailing-1.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/trailing-2.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/trailing-3.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/trailing-4.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/trailing-5.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/trailing-6.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/trailing-7.c: New test.
+
+2023-11-15  Jakub Jelinek  <jakub@redhat.com>
+
+	* gcc.dg/cpp/if-2.c: Adjust expected diagnostics for 16-bit targets.
+
+2023-11-15  Pan Li  <pan2.li@intel.com>
+
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-10.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-11.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-12.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-13.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-14.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-15.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-6.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-7.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-8.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-9.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-0.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-1.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-2.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-3.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-4.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-5.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-6.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-7.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-8.c: New test.
+
+2023-11-15  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	PR target/112535
+	* gcc.target/riscv/rvv/autovec/pr112535.c: New test.
+
+2023-11-15  Jakub Jelinek  <jakub@redhat.com>
+
+	* g++.dg/cpp26/enum-conv1.C: New test.
+	* g++.dg/cpp2a/enum-conv1.C: Adjust expected diagnostics in C++26.
+	* g++.dg/diagnostic/enum3.C: Likewise.
+	* g++.dg/parse/attr3.C: Likewise.
+	* g++.dg/cpp0x/linkage2.C: Likewise.
+
+2023-11-15  Alexandre Oliva  <oliva@adacore.com>
+
+	* g++.dg/tsan/pthread_cond_clockwait.C: Add fallback overload.
+
+2023-11-15  Alexandre Oliva  <oliva@adacore.com>
+
+	* gcc.target/i386/pr95126-m32-3.c: Add
+	-mno-accumulate-outgoing-args.
+	* gcc.target/i386/pr95126-m32-4.c: Likewise.
+
+2023-11-14  Lewis Hyatt  <lhyatt@gmail.com>
+
+	PR pch/9471
+	PR pch/47857
+	* g++.dg/pch/main-file-warnings.C: New test.
+	* g++.dg/pch/main-file-warnings.Hs: New test.
+	* gcc.dg/pch/main-file-warnings.c: New test.
+	* gcc.dg/pch/main-file-warnings.hs: New test.
+
+2023-11-14  David Malcolm  <dmalcolm@redhat.com>
+
+	PR analyzer/103533
+	* c-c++-common/analyzer/attr-tainted_args-1.c: Remove use of
+	-fanalyzer-checker=taint.
+	* c-c++-common/analyzer/fread-1.c: Likewise.
+	* c-c++-common/analyzer/pr104029.c: Likewise.
+	* gcc.dg/analyzer/pr93032-mztools-signed-char.c: Add params to
+	work around state explosion.
+	* gcc.dg/analyzer/pr93032-mztools-unsigned-char.c: Likewise.
+	* gcc.dg/analyzer/pr93382.c: Remove use of
+	-fanalyzer-checker=taint.
+	* gcc.dg/analyzer/switch-enum-taint-1.c: Likewise.
+	* gcc.dg/analyzer/taint-CVE-2011-2210-1.c: Likewise.
+	* gcc.dg/analyzer/taint-CVE-2020-13143-1.c: Likewise.
+	* gcc.dg/analyzer/taint-CVE-2020-13143-2.c: Likewise.
+	* gcc.dg/analyzer/taint-CVE-2020-13143.h: Likewise.
+	* gcc.dg/analyzer/taint-alloc-1.c: Likewise.
+	* gcc.dg/analyzer/taint-alloc-2.c: Likewise.
+	* gcc.dg/analyzer/taint-alloc-3.c: Likewise.
+	* gcc.dg/analyzer/taint-alloc-4.c: Likewise.
+	* gcc.dg/analyzer/taint-alloc-5.c: Likewise.
+	* gcc.dg/analyzer/taint-assert-BUG_ON.c: Likewise.
+	* gcc.dg/analyzer/taint-assert-macro-expansion.c: Likewise.
+	* gcc.dg/analyzer/taint-assert-system-header.c: Likewise.
+	* gcc.dg/analyzer/taint-assert.c: Likewise.
+	* gcc.dg/analyzer/taint-divisor-1.c: Likewise.
+	* gcc.dg/analyzer/taint-divisor-2.c: Likewise.
+	* gcc.dg/analyzer/taint-merger.c: Likewise.
+	* gcc.dg/analyzer/taint-ops.c: Delete this test: it was a
+	duplicate of material in operations.c and data-model-1.c, with
+	-fanalyzer-checker=taint added.
+	* gcc.dg/analyzer/taint-read-index-1.c: Remove use of
+	-fanalyzer-checker=taint.
+	* gcc.dg/analyzer/taint-read-offset-1.c: Likewise.
+	* gcc.dg/analyzer/taint-realloc.c: Likewise.  Add missing
+	dg-warning for leak now that the malloc state machine is also
+	active.
+	* gcc.dg/analyzer/taint-size-1.c: Remove use of
+	-fanalyzer-checker=taint.
+	* gcc.dg/analyzer/taint-size-access-attr-1.c: Likewise.
+	* gcc.dg/analyzer/taint-write-index-1.c: Likewise.
+	* gcc.dg/analyzer/taint-write-offset-1.c: Likewise.
+	* gcc.dg/analyzer/torture/taint-read-index-2.c: Likewise.
+	* gcc.dg/analyzer/torture/taint-read-index-3.c: Likewise.
+	* gcc.dg/plugin/taint-CVE-2011-0521-1-fixed.c: Likewise.  Add
+	-Wno-pedantic.
+	* gcc.dg/plugin/taint-CVE-2011-0521-1.c: Likewise.
+	* gcc.dg/plugin/taint-CVE-2011-0521-2-fixed.c: Likewise.
+	* gcc.dg/plugin/taint-CVE-2011-0521-2.c: Likewise.
+	* gcc.dg/plugin/taint-CVE-2011-0521-3-fixed.c: Likewise.
+	* gcc.dg/plugin/taint-CVE-2011-0521-3.c: Likewise.  Fix C++-style
+	comment.
+	* gcc.dg/plugin/taint-CVE-2011-0521-4.c: Remove use of
+	-fanalyzer-checker=taint and add -Wno-pedantic. Remove xfail and
+	add missing dg-warning.
+	* gcc.dg/plugin/taint-CVE-2011-0521-5-fixed.c: Remove use of
+	-fanalyzer-checker=taint and add -Wno-pedantic.
+	* gcc.dg/plugin/taint-CVE-2011-0521-5.c: Likewise.
+	* gcc.dg/plugin/taint-CVE-2011-0521-6.c: Likewise.
+	* gcc.dg/plugin/taint-antipatterns-1.c: : Remove use of
+	-fanalyzer-checker=taint.
+
+2023-11-14  Dimitar Dimitrov  <dimitar@dinux.eu>
+
+	* gcc.dg/20020206-1.c: Prune warning that
+	-fprefetch-loop-arrays is not supported.
+
+2023-11-14  Nathaniel Shead  <nathanieloshead@gmail.com>
+
+	PR c++/103499
+	* g++.dg/modules/pr103499_a.C: New test.
+	* g++.dg/modules/pr103499_b.C: New test.
+
+2023-11-14  Nathaniel Shead  <nathanieloshead@gmail.com>
+
+	PR c++/106849
+	* g++.dg/modules/using-9.C: New test.
+
+2023-11-14  David Malcolm  <dmalcolm@redhat.com>
+
+	* gcc.dg/plugin/diagnostic_group_plugin.c: Use
+	diagnostic_start_span.
+
+2023-11-14  Uros Bizjak  <ubizjak@gmail.com>
+
+	PR target/78904
+	* gcc.target/i386/pr78904-7.c: New test.
+	* gcc.target/i386/pr78904-7a.c: New test.
+	* gcc.target/i386/pr78904-7b.c: New test.
+
+2023-11-14  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/110341
+	* g++.dg/cpp26/literals1.C: New test.
+	* g++.dg/cpp26/literals2.C: New test.
+	* g++.dg/cpp23/wchar-multi1.C: Adjust expected diagnostic wordings.
+	* g++.dg/cpp23/wchar-multi2.C: Likewise.
+	* gcc.dg/c23-utf8char-3.c: Likewise.
+	* gcc.dg/cpp/charconst-4.c: Likewise.
+	* gcc.dg/cpp/charconst.c: Likewise.
+	* gcc.dg/cpp/if-2.c: Likewise.
+	* gcc.dg/utf16-4.c: Likewise.
+	* gcc.dg/utf32-4.c: Likewise.
+	* g++.dg/cpp1z/utf8-neg.C: Likewise.
+	* g++.dg/cpp2a/ucn2.C: Likewise.
+	* g++.dg/ext/utf16-4.C: Likewise.
+	* g++.dg/ext/utf32-4.C: Likewise.
+
+2023-11-14  David Malcolm  <dmalcolm@redhat.com>
+
+	* gcc.dg/plugin/diagnostic_plugin_test_show_locus.c: Use
+	global_dc's file cache.
+	* gcc.dg/plugin/expensive_selftests_plugin.c: Likewise.
+
+2023-11-14  Andrew MacLeod  <amacleod@redhat.com>
+
+	PR tree-optimization/112509
+	* gcc.dg/pr112509.c: New.
+
+2023-11-14  Saurabh Jha  <saurabh.jha@arm.com>
+
+	PR target/112337
+	* gcc.target/arm/mve/pr112337.c: Test for REG_P check for INC and DEC
+	operations.
+
+2023-11-14  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/111233
+	PR tree-optimization/111652
+	PR tree-optimization/111727
+	PR tree-optimization/111838
+	PR tree-optimization/112113
+	* gcc.dg/torture/pr111233.c: New testcase.
+	* gcc.dg/torture/pr111652.c: Likewise.
+	* gcc.dg/torture/pr111727.c: Likewise.
+	* gcc.dg/torture/pr111838.c: Likewise.
+	* gcc.dg/torture/pr112113.c: Likewise.
+
+2023-11-14  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/112281
+	* gcc.dg/torture/pr112281.c: New testcase.
+
+2023-11-14  Lehua Ding  <lehua.ding@rivai.ai>
+
+	* gcc.target/i386/apx-spill_to_egprs-1.c: Make sure that no local
+	variables are stored on the stack.
+
+2023-11-14  Andreas Krebbel  <krebbel@linux.ibm.com>
+
+	* g++.target/s390/zvec-templ-1.C: New test.
+
+2023-11-14  Jonathan Wakely  <jwakely@redhat.com>
+
+	PR c++/111842
+	PR c++/112498
+	* g++.dg/cpp23/ext-floating16.C: New test.
+	* g++.dg/cpp23/ext-floating17.C: New test.
+
+2023-11-14  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c/111309
+	* c-c++-common/pr111309-1.c: New test.
+	* c-c++-common/pr111309-2.c: New test.
+	* gcc.dg/torture/bitint-43.c: New test.
+	* gcc.dg/torture/bitint-44.c: New test.
+
+2023-11-14  liuhongt  <hongtao.liu@intel.com>
+
+	* gcc.target/i386/pr112496.c: New test.
+
+2023-11-14  Jakub Jelinek  <jakub@redhat.com>
+
+	PR middle-end/112511
+	* gcc.dg/pr112511.c: New test.
+
+2023-11-14  Jakub Jelinek  <jakub@redhat.com>
+	    Hu, Lin1  <lin1.hu@intel.com>
+
+	PR target/112435
+	* gcc.target/i386/avx512vl-pr112435-1.c: New test.
+	* gcc.target/i386/avx512vl-pr112435-2.c: New test.
+	* gcc.target/i386/avx512vl-pr112435-3.c: New test.
+
+2023-11-14  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/autovec/vls/init-2.c: Fix vid.v check.
+
+2023-11-14  liuhongt  <hongtao.liu@intel.com>
+
+	* gcc.target/i386/pr105735-3.c: New test.
+
+2023-11-13  Uros Bizjak  <ubizjak@gmail.com>
+
+	PR target/112494
+	* gcc.target/i386/pr112494.c: New test.
+
+2023-11-13  Brendan Shanks  <bshanks@codeweavers.com>
+
+	* g++.dg/modules/bad-mapper-1.C: Also accept posix_spawn.
+
+2023-11-13  Robin Dapp  <rdapp@ventanamicro.com>
+
+	* gcc.target/riscv/rvv/autovec/partial/multiple_rgroup_zbb.c: New test.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* lib/target-supports.exp (v7a_neon): New feature-test target.
+	* gcc.dg/debug/pr57351.c: Use it.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* lib/target-supports.exp (check_effective_target_arm_arch_FUNC_ok):
+	Add test for v7a_arm.
+	* gcc.target/arm/pr60650-2.c: Use require-effective-target and
+	add-options.
+	* gcc.target/arm/pr60657.c: Likewise.
+	* gcc.target/arm/pr60663.c: Likewise.
+	* gcc.target/arm/pr81863.c: Likewise.
+	* gcc.target/arm/pr97969.c: Likewise.
+	* gcc.target/arm/pr98931.c: Likewise.
+	* gcc.target/arm/tail-long-call.c: Likewise.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* lib/target-supports.exp (check_effective_target_arm_arch_FUNC_ok):
+	For instruction-set specific tests, check that __thumb__ is, or
+	isn't defined as appropriate.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* gcc.target/arm/pr59575.c: Use dg-require-effective-target and
+	dg-add-options.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* gcc.target/arm/pr19599.c: Add +fp to the architecture.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* gcc.target/arm/optional_thumb-1.c: Force a soft-float ABI.
+	* gcc.target/arm/optional_thumb-3.c: Check for armv7e-m compatibility,
+	then set the architecture explicitly.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* gcc.target/arm/macro_defs0.c: Use dg-effective-target and
+	dg-add-options.
+	* gcc.target/arm/macro_defs1.c: Likewise.
+	* gcc.target/arm/macro_defs2.c: Likewise.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* lib/target-supports.exp (check_effective_target_arm_arch_FUNC_ok):
+	Use soft-float ABI for armv7m.
+	* gcc.target/arm/ftest-armv7m-thumb.c: Use dg-require-effective-target
+	to check flag compatibility.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* gcc.target/arm/scd42-2.c: Use modern dg- flags.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* gcc.target/arm/pragma_arch_switch_2.c: Use testsuite infrastructure
+	to set the architecture flags.  Add +fp to the pragma that changes the
+	architecture.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* gcc.target/arm/pragma_arch_attribute.c: Add +simd to pragmas that
+	set an explicit architecture.
+	* gcc.target/arm/pragma_arch_attribute_2.c: Likewise.
+	* gcc.target/arm/pragma_arch_attribute_3.c: Likewise.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* gcc.target/arm/pr88648-asm-syntax-unified.c: It isn't necessary
+	to try to override the architecture flags specified by arm_arch_v7a.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* gcc.target/arm/pr78353-1.c: Use dg-add-options to manage target
+	flags.
+	* gcc.target/arm/pr78353-2.c: Likewise.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* gcc.target/arm/pr65647-2.c: Use dg-add-options to manage target
+	flags.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* gcc.target/arm/lto/pr96939_1.c: Add +simd to the architecture
+	specification.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* lib/target-supports.exp (check_effective_target_arm_arch_FUNC_ok):
+	Add entry to check for xscale.
+	* gcc.target/arm/g2.c: Use it.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* gcc.target/arm/attr_thumb-static2.c: Add +fp to the -march
+	specification.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* gcc.target/arm/attr-crypto.c: Add +simd to the -march
+	specification.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* gcc.target/arm/acle/pacbti-m-predef-11.c: Add +fp to the -march
+	specification.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* lib/target-supports.exp (check_effective_target_arm_arch_FUNC_ok):
+	Add base FPU specifications to all architectures that can support
+	one.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* lib/target-supports.exp (check_effective_target_hard_float): Add
+	arm-specific test.
+
+2023-11-13  Richard Earnshaw  <rearnsha@arm.com>
+
+	* lib/target-supports.exp (check_effective_target_arm_arch_v6t2_hw_ok):
+	New function.
+	* gcc.target/arm/acle/data-intrinsics-armv6.c: Use it.
+	* gcc.target/arm/acle/data-intrinsics-rbit.c: Likewise.
+
+2023-11-13  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/112495
+	* gcc.target/i386/pr112495.c: New testcase.
+
+2023-11-13  Richard Biener  <rguenther@suse.de>
+
+	PR middle-end/112487
+	* gcc.dg/torture/pr112487.c: New testcase.
+
+2023-11-13  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/111792
+	PR tree-optimization/111000
+	* gcc.dg/torture/pr111792.c: New testcase.
+
+2023-11-13  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/autovec/vls/def.h: Fix init test.
+	* gcc.target/riscv/rvv/autovec/vls/init-1.c: Ditto.
+	* gcc.target/riscv/rvv/autovec/vls/init-2.c: Ditto.
+	* gcc.target/riscv/rvv/autovec/vls/init-3.c: Ditto.
+	* gcc.target/riscv/rvv/autovec/vls/init-4.c: Ditto.
+	* gcc.target/riscv/rvv/autovec/vls/init-5.c: Ditto.
+	* gcc.target/riscv/rvv/autovec/vls/init-6.c: Ditto.
+	* gcc.target/riscv/rvv/autovec/vls/init-7.c: Ditto.
+
+2023-11-13  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/combine-merge-1.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/combine-merge-2.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/combine-merge_run-1.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/combine-merge_run-2.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-merge-1.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-merge-10.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-merge-11.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-merge-12.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-merge-13.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-merge-14.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-merge-2.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-merge-3.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-merge-4.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-merge-5.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-merge-6.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-merge-7.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-merge-8.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-merge-9.c: New test.
+
+2023-11-13  liuhongt  <hongtao.liu@intel.com>
+
+	* gcc.target/i386/part-vect-vec_elem-1.c: New test.
+	* gcc.target/i386/part-vect-vec_elem-2.c: New test.
+
+2023-11-13  Roger Sayle  <roger@nextmovesoftware.com>
+
+	* gcc.target/arc/ashrdi3-1.c: New test case.
+	* gcc.target/arc/lshrdi3-1.c: Likewise.
+	* gcc.target/arc/rotldi3-1.c: Likewise.
+	* gcc.target/arc/rotrdi3-1.c: Likewise.
+
+2023-11-13  Roger Sayle  <roger@nextmovesoftware.com>
+
+	* gcc.target/arc/builtin_norm-1.c: New test case.
+	* gcc.target/arc/builtin_norm-2.c: Likewise.
+	* gcc.target/arc/builtin_normw-1.c: Likewise.
+	* gcc.target/arc/builtin_normw-2.c: Likewise.
+	* gcc.target/arc/builtin_swap-1.c: Likewise.
+	* gcc.target/arc/builtin_swap-2.c: Likewise.
+	* gcc.target/arc/builtin_swap-3.c: Likewise.
+
+2023-11-13  Florian Weimer  <fweimer@redhat.com>
+
+	* gcc.c-torture/execute/20000112-1.c (main): Add missing
+	int and void types.
+	* gcc.c-torture/execute/20000113-1.c (foobar): Add missing
+	void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/20000314-2.c (main): Likewise.
+	* gcc.c-torture/execute/20000402-1.c (main): Likewise.
+	* gcc.c-torture/execute/20000403-1.c (main): Likewise.
+	* gcc.c-torture/execute/20000503-1.c (main): Likewise.
+	* gcc.c-torture/execute/20000605-2.c (main): Likewise.
+	* gcc.c-torture/execute/20000717-1.c (main): Likewise.
+	* gcc.c-torture/execute/20000717-5.c (main): Likewise.
+	* gcc.c-torture/execute/20000726-1.c (main): Likewise.
+	* gcc.c-torture/execute/20000914-1.c(blah): Add missing
+	void types.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/20001009-1.c (main): Likewise.
+	* gcc.c-torture/execute/20001013-1.c (main): Likewise.
+	* gcc.c-torture/execute/20001031-1.c (main): Likewise.
+	* gcc.c-torture/execute/20010221-1.c (main): Likewise.
+	* gcc.c-torture/execute/20010723-1.c (main): Likewise.
+	* gcc.c-torture/execute/20010915-1.c (s): Call
+	__builtin_strcmp instead of strcmp.
+	* gcc.c-torture/execute/20010924-1.c (main): Add missing
+	int and void types.
+	* gcc.c-torture/execute/20011128-1.c (main): Likewise.
+	* gcc.c-torture/execute/20020226-1.c (main): Likewise.
+	* gcc.c-torture/execute/20020328-1.c (foo): Add missing
+	void types.
+	* gcc.c-torture/execute/20020406-1.c (DUPFFexgcd): Call
+	__builtin_printf instead of printf.
+	(main): Likewise.
+	* gcc.c-torture/execute/20020508-1.c (main): Add missing
+	int and void types.
+	* gcc.c-torture/execute/20020508-2.c (main): Likewise.
+	* gcc.c-torture/execute/20020508-3.c (main): Likewise.
+	* gcc.c-torture/execute/20020611-1.c (main): Likewise.
+	* gcc.c-torture/execute/20021010-2.c (main): Likewise.
+	* gcc.c-torture/execute/20021113-1.c (foo): Add missing
+	void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/20021120-3.c (foo): Call
+	__builtin_sprintf instead of sprintf.
+	* gcc.c-torture/execute/20030125-1.c (main): Add missing
+	int and void types.
+	* gcc.c-torture/execute/20030216-1.c (main): Likewise.
+	* gcc.c-torture/execute/20030404-1.c (main): Likewise.
+	* gcc.c-torture/execute/20030606-1.c (main): Likewise.
+	Call __builtin_memset instead of memset.
+	* gcc.c-torture/execute/20030828-1.c (main): Add missing int
+	and void types.
+	* gcc.c-torture/execute/20030828-2.c (main): Likewise.
+	* gcc.c-torture/execute/20031012-1.c: Call __builtin_strlen
+	instead of strlen.
+	* gcc.c-torture/execute/20031211-1.c (main): Add missing int
+	and void types.
+	* gcc.c-torture/execute/20040319-1.c (main): Likewise.
+	* gcc.c-torture/execute/20040411-1.c (sub1): Call
+	__builtin_memcpy instead of memcpy.
+	* gcc.c-torture/execute/20040423-1.c (sub1): Likewise.
+	* gcc.c-torture/execute/20040917-1.c (main): Add missing int
+	and void types.
+	* gcc.c-torture/execute/20050131-1.c (main): Likewise.
+	* gcc.c-torture/execute/20051113-1.c (main): Likewise.
+	* gcc.c-torture/execute/20121108-1.c (main): Call
+	__builtin_printf instead of printf.
+	* gcc.c-torture/execute/20170401-2.c (main): Add missing int
+	and void types.
+	* gcc.c-torture/execute/900409-1.c (main): Likewise.
+	* gcc.c-torture/execute/920202-1.c (f): Add int return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/920302-1.c (execute): Add void return
+	type.
+	(main): Add missing int	and void types.
+	* gcc.c-torture/execute/920410-1.c (main): Likewise.
+	* gcc.c-torture/execute/920501-2.c (main): Likewise.
+	* gcc.c-torture/execute/920501-3.c (execute): Add void return
+	type.
+	(main): Add missing int	and void types.
+	* gcc.c-torture/execute/920501-5.c (x): Add int return type.
+	(main): Add missing int	and void types.
+	* gcc.c-torture/execute/920501-6.c (main): Add int return
+	type.
+	* gcc.c-torture/execute/920501-8.c (main): Add missing
+	int and void types.  Call __builtin_strcmp instead of strcmp.
+	* gcc.c-torture/execute/920506-1.c (main): Add missing
+	int and void types.
+	* gcc.c-torture/execute/920612-2.c (main): Likewise.
+	* gcc.c-torture/execute/920618-1.c (main): Likewise.
+	* gcc.c-torture/execute/920625-1.c (main): Likewise.
+	* gcc.c-torture/execute/920710-1.c (main): Likewise.
+	* gcc.c-torture/execute/920721-1.c (main): Likewise.
+	* gcc.c-torture/execute/920721-4.c (main): Likewise.
+	* gcc.c-torture/execute/920726-1.c (first, second): Call
+	__builtin_strlen instead of strlen.
+	(main): Add missing int	and void types.  Call __builtin_strcmp
+	instead of strcmp.
+	* gcc.c-torture/execute/920810-1.c (main): Add missing
+	int and void types.
+	* gcc.c-torture/execute/920829-1.c (main): Likewise.
+	* gcc.c-torture/execute/920908-1.c (main): Likewise.
+	* gcc.c-torture/execute/920922-1.c (main): Likewise.
+	* gcc.c-torture/execute/920929-1.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/921006-1.c (main): Likewise.  Call
+	__builtin_strcmp instead of strcmp.
+	* gcc.c-torture/execute/921007-1.c (main): Add missing
+	int and void types.
+	* gcc.c-torture/execute/921016-1.c (main): Likewise.
+	* gcc.c-torture/execute/921019-1.c (main): Likewise.
+	* gcc.c-torture/execute/921019-2.c (main): Likewise.
+	* gcc.c-torture/execute/921029-1.c (main): Likewise.
+	* gcc.c-torture/execute/921104-1.c (main): Likewise.
+	* gcc.c-torture/execute/921112-1.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/921113-1.c (w, f1, f2, gitter): Add
+	void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/921117-1.c (check): Call
+	__builtin_strcmp instead of strcmp.
+	(main): Add missing int and void types.  Call __builtin_strcpy
+	instead of strcpy.
+	* gcc.c-torture/execute/921123-2.c (main): Add missing
+	int and void types.
+	* gcc.c-torture/execute/921202-2.c (main): Likewise.
+	* gcc.c-torture/execute/921204-1.c (main): Likewise.
+	* gcc.c-torture/execute/921208-1.c (main): Likewise.
+	* gcc.c-torture/execute/930123-1.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/930126-1.c (main): Likewise.
+	* gcc.c-torture/execute/930406-1.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/930408-1.c (p, f): Add missing void
+	types.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/930429-1.c (main): Likewise.
+	* gcc.c-torture/execute/930603-2.c (f): Add missing void
+	types.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/930608-1.c (main): Likewise.
+	* gcc.c-torture/execute/930614-1.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/930614-2.c (main): Likewise.
+	* gcc.c-torture/execute/930622-2.c (main): Likewise.
+	* gcc.c-torture/execute/930628-1.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/930725-1.c (main): Likewise.  Call
+	__builtin_strcmp instead of strcmp.
+	* gcc.c-torture/execute/930930-2.c (main): Add missing
+	int and void types.
+	* gcc.c-torture/execute/931002-1.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/931004-1.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/931004-10.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/931004-11.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/931004-12.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/931004-13.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/931004-14.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/931004-2.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/931004-3.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/931004-4.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/931004-5.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/931004-6.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/931004-7.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/931004-8.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/931004-9.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/931005-1.c (main): Likewise.
+	* gcc.c-torture/execute/931110-1.c (main): Likewise.
+	* gcc.c-torture/execute/931110-2.c (main): Likewise.
+	* gcc.c-torture/execute/941014-1.c (main): Likewise.
+	* gcc.c-torture/execute/941014-2.c (main): Likewise.
+	* gcc.c-torture/execute/941015-1.c (main): Likewise.
+	* gcc.c-torture/execute/941021-1.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/941025-1.c (main): Likewise.
+	* gcc.c-torture/execute/941031-1.c (main): Likewise.
+	* gcc.c-torture/execute/950221-1.c (g2): Add int return type.
+	(f): Add missing void types.  Call __builtin_strcpy instead
+	of strcpy.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/950426-2.c (main): Likewise.
+	* gcc.c-torture/execute/950503-1.c (main): Likewise.
+	* gcc.c-torture/execute/950511-1.c (main): Likewise.
+	* gcc.c-torture/execute/950607-1.c (main): Likewise.
+	* gcc.c-torture/execute/950607-2.c (main): Likewise.
+	* gcc.c-torture/execute/950612-1.c (main): Likewise.
+	* gcc.c-torture/execute/950628-1.c (main): Likewise.
+	* gcc.c-torture/execute/950704-1.c (main): Likewise.
+	* gcc.c-torture/execute/950706-1.c (main): Likewise.
+	* gcc.c-torture/execute/950710-1.c (main): Likewise.
+	* gcc.c-torture/execute/950714-1.c (main): Likewise.
+	* gcc.c-torture/execute/950809-1.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/950906-1.c (g, f): Add void return
+	type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/950915-1.c (main): Likewise.
+	* gcc.c-torture/execute/950929-1.c (main): Likewise.
+	* gcc.c-torture/execute/951003-1.c (f): Add missing int
+	parameter type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/951115-1.c (g, f): Add void return
+	type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/951204-1.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/960116-1.c (p): Add int return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/960117-1.c (main): Likewise.
+	* gcc.c-torture/execute/960209-1.c (main): Likewise.
+	* gcc.c-torture/execute/960215-1.c (main): Likewise.
+	* gcc.c-torture/execute/960219-1.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/960301-1.c (main): Likewise.
+	* gcc.c-torture/execute/960302-1.c (foo, main): Add missing
+	int and void types.
+	* gcc.c-torture/execute/960311-1.c (main): Likewise.
+	* gcc.c-torture/execute/960311-2.c (main): Likewise.
+	* gcc.c-torture/execute/960311-3.c (main): Likewise.
+	* gcc.c-torture/execute/960312-1.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/960317-1.c (main): Likewise.
+	* gcc.c-torture/execute/960321-1.c (main): Likewise.
+	* gcc.c-torture/execute/960326-1.c (main): Likewise.
+	* gcc.c-torture/execute/960327-1.c (g, main): Add missing
+	int and void types.
+	(f): Add missing void types.
+	* gcc.c-torture/execute/960405-1.c (main): Add missing
+	int and void types.
+	* gcc.c-torture/execute/960416-1.c (main): Likewise.
+	* gcc.c-torture/execute/960419-1.c (main): Likewise.
+	* gcc.c-torture/execute/960419-2.c (main): Likewise.
+	* gcc.c-torture/execute/960512-1.c (main): Likewise.
+	* gcc.c-torture/execute/960513-1.c (main): Likewise.
+	* gcc.c-torture/execute/960521-1.c (f): Add missing void
+	types.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/960608-1.c (f): Add int return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/960801-1.c (main): Likewise.
+	* gcc.c-torture/execute/960802-1.c (main): Likewise.
+	* gcc.c-torture/execute/960909-1.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/961004-1.c (main): Likewise.
+	* gcc.c-torture/execute/961017-1.c (main): Likewise.
+	* gcc.c-torture/execute/961017-2.c (main): Likewise.
+	* gcc.c-torture/execute/961026-1.c (main): Likewise.
+	* gcc.c-torture/execute/961122-1.c (addhi, subhi): Add void
+	return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/961122-2.c (main): Likewise.
+	* gcc.c-torture/execute/961125-1.c (main): Likewise.
+	* gcc.c-torture/execute/961206-1.c (main): Likewise.
+	* gcc.c-torture/execute/961213-1.c (main): Likewise.
+	* gcc.c-torture/execute/970214-1.c (main): Likewise.
+	* gcc.c-torture/execute/970214-2.c (main): Likewise.
+	* gcc.c-torture/execute/970217-1.c (sub): Add int return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/970923-1.c (main): Likewise.
+	* gcc.c-torture/execute/980223.c (main): Likewise.
+	* gcc.c-torture/execute/980506-1.c (main): Likewise.
+	* gcc.c-torture/execute/980506-2.c (main): Likewise.
+	* gcc.c-torture/execute/980506-3.c (build_lookup): Call
+	__builtin_strlen instead of strlen and __builtin_memset
+	instead of memset.
+	* gcc.c-torture/execute/980526-3.c (main): Likewise.
+	* gcc.c-torture/execute/980602-1.c (main): Likewise.
+	* gcc.c-torture/execute/980604-1.c (main): Likewise.
+	* gcc.c-torture/execute/980605-1.c (dummy): Add missing int
+	parameter type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/980701-1.c (ns_name_skip): Add missing
+	int return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/980709-1.c (main): Likewise.
+	* gcc.c-torture/execute/990117-1.c (main): Likewise.
+	* gcc.c-torture/execute/990127-1.c (main): Likewise.
+	* gcc.c-torture/execute/990128-1.c (main): Likewise.
+	* gcc.c-torture/execute/990130-1.c (main): Likewise.
+	* gcc.c-torture/execute/990324-1.c (main): Likewise.
+	* gcc.c-torture/execute/990524-1.c (main): Likewise.
+	* gcc.c-torture/execute/990531-1.c (main): Likewise.
+	* gcc.c-torture/execute/990628-1.c (fetch, load_data): Call
+	__builtin_memset instead of memset.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/991019-1.c (main): Likewise.
+	* gcc.c-torture/execute/991023-1.c (foo, main): Likewise.
+	* gcc.c-torture/execute/991112-1.c (isprint): Declare.
+	* gcc.c-torture/execute/991118-1.c (main): Add missing
+	int and void types.
+	* gcc.c-torture/execute/alias-1.c (ptr2): Add cast to float *
+	in initializer.
+	(typepun): Add missing void types.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/alias-2.c (main): Likewise.
+	* gcc.c-torture/execute/alias-3.c (inc): Add missing
+	void types.
+	* gcc.c-torture/execute/alias-4.c (main): Add missing int
+	return type.
+	* gcc.c-torture/execute/arith-1.c (main): Add missing
+	int and void types.
+	* gcc.c-torture/execute/arith-rand-ll.c (main): Likewise.
+	* gcc.c-torture/execute/arith-rand.c (main): Likewise.
+	* gcc.c-torture/execute/bf-layout-1.c (main): Likewise.
+	* gcc.c-torture/execute/bf-pack-1.c (foo): Add missing
+	void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/bf-sign-1.c (main): Likewise.
+	* gcc.c-torture/execute/bf-sign-2.c (main): Likewise.
+	* gcc.c-torture/execute/bf64-1.c (main): Likewise.
+	* gcc.c-torture/execute/builtin-prefetch-2.c (stat_int_arr):
+	Add missing int array element type.
+	* gcc.c-torture/execute/builtin-prefetch-3.c (stat_int_arr):
+	Likewise.
+	* gcc.c-torture/execute/cbrt.c (main): Add missing int and
+	void types.
+	* gcc.c-torture/execute/complex-1.c (main): Likewise.
+	* gcc.c-torture/execute/complex-2.c (main): Likewise.
+	* gcc.c-torture/execute/complex-3.c (main): Likewise.
+	* gcc.c-torture/execute/complex-4.c (main): Likewise.
+	* gcc.c-torture/execute/complex-5.c (main): Likewise.
+	* gcc.c-torture/execute/compndlit-1.c (main): Likewise.
+	* gcc.c-torture/execute/conversion.c (test_integer_to_float)
+	(test_longlong_integer_to_float, test_float_to_integer)
+	(test_float_to_longlong_integer): Add missing void return
+	type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/cvt-1.c (main): Likewise.
+	* gcc.c-torture/execute/divconst-1.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/divconst-2.c (main): Likewise.
+	* gcc.c-torture/execute/divconst-3.c (main): Likewise.
+	* gcc.c-torture/execute/enum-1.c (main): Likewise.
+	* gcc.c-torture/execute/func-ptr-1.c (main): Likewise.
+	* gcc.c-torture/execute/ieee/20011123-1.c (main): Likewise.
+	* gcc.c-torture/execute/ieee/920518-1.c (main): Likewise.
+	* gcc.c-torture/execute/ieee/920810-1.c (main): Likewise.
+	Call __builtin_strcmp instead of strcmp.
+	* gcc.c-torture/execute/ieee/930529-1.c (main): Add missing
+	int and void types.
+	* gcc.c-torture/execute/ieee/fp-cmp-1.c (main): Likewise.
+	* gcc.c-torture/execute/ieee/fp-cmp-2.c (main): Likewise.
+	* gcc.c-torture/execute/ieee/fp-cmp-3.c (main): Likewise.
+	* gcc.c-torture/execute/ieee/fp-cmp-6.c (main): Likewise.
+	* gcc.c-torture/execute/ieee/fp-cmp-9.c (main): Likewise.
+	* gcc.c-torture/execute/ieee/minuszero.c (main): Likewise.
+	* gcc.c-torture/execute/ieee/mzero2.c (expect): Call
+	__builtin_memcmp instead of memcmp.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/ieee/mzero3.c (main): Likewise.
+	(expectd, expectf): Call __builtin_memcmp instead of memcmp.
+	* gcc.c-torture/execute/ieee/mzero5.c (negzero_check):
+	Likewise.
+	* gcc.c-torture/execute/ieee/rbug.c (main): Add missing
+	int and void types.
+	* gcc.c-torture/execute/index-1.c (main): Likewise.
+	* gcc.c-torture/execute/loop-1.c (main): Likewise.
+	* gcc.c-torture/execute/loop-2b.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/loop-6.c (main): Likewise.
+	* gcc.c-torture/execute/loop-7.c (main): Likewise.
+	* gcc.c-torture/execute/lto-tbaa-1.c (use_a, set_b, use_c):
+	Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/memcpy-1.c (main): Likewise.
+	* gcc.c-torture/execute/memcpy-2.c (main): Likewise.
+	* gcc.c-torture/execute/memcpy-bi.c (main): Likewise.
+	* gcc.c-torture/execute/memset-1.c (main): Likewise.
+	* gcc.c-torture/execute/memset-2.c: Include <string.h>.
+	* gcc.c-torture/execute/memset-3.c: Likewise.
+	* gcc.c-torture/execute/nest-stdar-1.c (main): Add missing
+	int and void types.
+	* gcc.c-torture/execute/nestfunc-1.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/packed-1.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/pr15262-1.c (main): Likewise.  Call
+	__builtin_malloc instead of malloc.
+	* gcc.c-torture/execute/pr15262-2.c (foo): Add int return
+	type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/pr15262.c (main): Likewise.
+	* gcc.c-torture/execute/pr17252.c (main): Likewise.
+	* gcc.c-torture/execute/pr21331.c (main): Likewise.
+	* gcc.c-torture/execute/pr34176.c (foo): Add missing int
+	type to definition of foo.
+	* gcc.c-torture/execute/pr42231.c (max): Add missing int type
+	to definition.
+	* gcc.c-torture/execute/pr42614.c (expect_func): Call
+	__builtin_abs instead of abs.
+	* gcc.c-torture/execute/pr54937.c (t): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/ptr-arith-1.c (main): Likewise.
+	* gcc.c-torture/execute/regstack-1.c (main): Likewise.
+	* gcc.c-torture/execute/scope-1.c (f): Add missing void types.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/simd-5.c (main): Call __builtin_memcmp
+	instead of memcmp.
+	* gcc.c-torture/execute/strcmp-1.c (main): Add missing
+	int and void types.
+	* gcc.c-torture/execute/strcpy-1.c (main): Likewise.
+	* gcc.c-torture/execute/strct-pack-1.c (main): Likewise.
+	* gcc.c-torture/execute/strct-pack-2.c (main): Likewise.
+	* gcc.c-torture/execute/strct-pack-4.c (main): Likewise.
+	* gcc.c-torture/execute/strct-stdarg-1.c (f): Add void return
+	type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/strct-varg-1.c (f): Add void return
+	type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/strlen-1.c (main): Likewise.
+	* gcc.c-torture/execute/strncmp-1.c (main): Likewise.
+	* gcc.c-torture/execute/struct-ini-1.c (main): Likewise.
+	* gcc.c-torture/execute/struct-ini-2.c (main): Likewise.
+	* gcc.c-torture/execute/struct-ini-3.c (main): Likewise.
+	* gcc.c-torture/execute/struct-ini-4.c (main): Likewise.
+	* gcc.c-torture/execute/struct-ret-1.c (main): Likewise.
+	* gcc.c-torture/execute/struct-ret-2.c (main): Likewise.
+	* gcc.c-torture/execute/va-arg-1.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/va-arg-10.c (main): Likewise.
+	* gcc.c-torture/execute/va-arg-2.c (main): Likewise.
+	* gcc.c-torture/execute/va-arg-4.c (main): Likewise.
+	* gcc.c-torture/execute/va-arg-5.c (va_double)
+	(va_long_double): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/va-arg-6.c (f): Add void return type.
+	(main): Add missing int and void types.
+	* gcc.c-torture/execute/va-arg-9.c (main): Likewise.
+	* gcc.c-torture/execute/widechar-1.c (main): Likewise.
+
+2023-11-13  Florian Weimer  <fweimer@redhat.com>
+
+	* gcc.c-torture/execute/20000112-1.c: Declare exit and abort
+	as appropriate.
+	* gcc.c-torture/execute/20000113-1.c: Likewise.
+	* gcc.c-torture/execute/20000205-1.c: Likewise.
+	* gcc.c-torture/execute/20000217-1.c: Likewise.
+	* gcc.c-torture/execute/20000223-1.c: Likewise.
+	* gcc.c-torture/execute/20000224-1.c: Likewise.
+	* gcc.c-torture/execute/20000225-1.c: Likewise.
+	* gcc.c-torture/execute/20000227-1.c: Likewise.
+	* gcc.c-torture/execute/20000313-1.c: Likewise.
+	* gcc.c-torture/execute/20000314-1.c: Likewise.
+	* gcc.c-torture/execute/20000314-2.c: Likewise.
+	* gcc.c-torture/execute/20000314-3.c: Likewise.
+	* gcc.c-torture/execute/20000402-1.c: Likewise.
+	* gcc.c-torture/execute/20000403-1.c: Likewise.
+	* gcc.c-torture/execute/20000412-1.c: Likewise.
+	* gcc.c-torture/execute/20000412-2.c: Likewise.
+	* gcc.c-torture/execute/20000412-4.c: Likewise.
+	* gcc.c-torture/execute/20000412-5.c: Likewise.
+	* gcc.c-torture/execute/20000412-6.c: Likewise.
+	* gcc.c-torture/execute/20000419-1.c: Likewise.
+	* gcc.c-torture/execute/20000422-1.c: Likewise.
+	* gcc.c-torture/execute/20000503-1.c: Likewise.
+	* gcc.c-torture/execute/20000511-1.c: Likewise.
+	* gcc.c-torture/execute/20000519-1.c: Likewise.
+	* gcc.c-torture/execute/20000519-2.c: Likewise.
+	* gcc.c-torture/execute/20000523-1.c: Likewise.
+	* gcc.c-torture/execute/20000528-1.c: Likewise.
+	* gcc.c-torture/execute/20000603-1.c: Likewise.
+	* gcc.c-torture/execute/20000605-1.c: Likewise.
+	* gcc.c-torture/execute/20000605-2.c: Likewise.
+	* gcc.c-torture/execute/20000605-3.c: Likewise.
+	* gcc.c-torture/execute/20000622-1.c: Likewise.
+	* gcc.c-torture/execute/20000717-1.c: Likewise.
+	* gcc.c-torture/execute/20000717-2.c: Likewise.
+	* gcc.c-torture/execute/20000717-5.c: Likewise.
+	* gcc.c-torture/execute/20000722-1.c: Likewise.
+	* gcc.c-torture/execute/20000726-1.c: Likewise.
+	* gcc.c-torture/execute/20000731-1.c: Likewise.
+	* gcc.c-torture/execute/20000731-2.c: Likewise.
+	* gcc.c-torture/execute/20000801-3.c: Likewise.
+	* gcc.c-torture/execute/20000801-4.c: Likewise.
+	* gcc.c-torture/execute/20000808-1.c: Likewise.
+	* gcc.c-torture/execute/20000815-1.c: Likewise.
+	* gcc.c-torture/execute/20000818-1.c: Likewise.
+	* gcc.c-torture/execute/20000819-1.c: Likewise.
+	* gcc.c-torture/execute/20000822-1.c: Likewise.
+	* gcc.c-torture/execute/20000914-1.c: Likewise.
+	* gcc.c-torture/execute/20000917-1.c: Likewise.
+	* gcc.c-torture/execute/20001009-1.c: Likewise.
+	* gcc.c-torture/execute/20001009-2.c: Likewise.
+	* gcc.c-torture/execute/20001013-1.c: Likewise.
+	* gcc.c-torture/execute/20001017-1.c: Likewise.
+	* gcc.c-torture/execute/20001017-2.c: Likewise.
+	* gcc.c-torture/execute/20001024-1.c: Likewise.
+	* gcc.c-torture/execute/20001027-1.c: Likewise.
+	* gcc.c-torture/execute/20001101.c: Likewise.
+	* gcc.c-torture/execute/20001108-1.c: Likewise.
+	* gcc.c-torture/execute/20001112-1.c: Likewise.
+	* gcc.c-torture/execute/20001124-1.c: Likewise.
+	* gcc.c-torture/execute/20001130-1.c: Likewise.
+	* gcc.c-torture/execute/20001130-2.c: Likewise.
+	* gcc.c-torture/execute/20001203-2.c: Likewise.
+	* gcc.c-torture/execute/20001221-1.c: Likewise.
+	* gcc.c-torture/execute/20001228-1.c: Likewise.
+	* gcc.c-torture/execute/20001229-1.c: Likewise.
+	* gcc.c-torture/execute/20010106-1.c: Likewise.
+	* gcc.c-torture/execute/20010118-1.c: Likewise.
+	* gcc.c-torture/execute/20010119-1.c: Likewise.
+	* gcc.c-torture/execute/20010206-1.c: Likewise.
+	* gcc.c-torture/execute/20010209-1.c: Likewise.
+	* gcc.c-torture/execute/20010221-1.c: Likewise.
+	* gcc.c-torture/execute/20010222-1.c: Likewise.
+	* gcc.c-torture/execute/20010329-1.c: Likewise.
+	* gcc.c-torture/execute/20010403-1.c: Likewise.
+	* gcc.c-torture/execute/20010409-1.c: Likewise.
+	* gcc.c-torture/execute/20010422-1.c: Likewise.
+	* gcc.c-torture/execute/20010518-1.c: Likewise.
+	* gcc.c-torture/execute/20010518-2.c: Likewise.
+	* gcc.c-torture/execute/20010520-1.c: Likewise.
+	* gcc.c-torture/execute/20010604-1.c: Likewise.
+	* gcc.c-torture/execute/20010711-1.c: Likewise.
+	* gcc.c-torture/execute/20010723-1.c: Likewise.
+	* gcc.c-torture/execute/20010904-1.c: Likewise.
+	* gcc.c-torture/execute/20010904-2.c: Likewise.
+	* gcc.c-torture/execute/20010915-1.c: Likewise.
+	* gcc.c-torture/execute/20010924-1.c: Likewise.
+	* gcc.c-torture/execute/20011024-1.c: Likewise.
+	* gcc.c-torture/execute/20011109-1.c: Likewise.
+	* gcc.c-torture/execute/20011109-2.c: Likewise.
+	* gcc.c-torture/execute/20011114-1.c: Likewise.
+	* gcc.c-torture/execute/20011121-1.c: Likewise.
+	* gcc.c-torture/execute/20011126-1.c: Likewise.
+	* gcc.c-torture/execute/20011128-1.c: Likewise.
+	* gcc.c-torture/execute/20011217-1.c: Likewise.
+	* gcc.c-torture/execute/20020213-1.c: Likewise.
+	* gcc.c-torture/execute/20020215-1.c: Likewise.
+	* gcc.c-torture/execute/20020225-2.c: Likewise.
+	* gcc.c-torture/execute/20020226-1.c: Likewise.
+	* gcc.c-torture/execute/20020227-1.c: Likewise.
+	* gcc.c-torture/execute/20020307-1.c: Likewise.
+	* gcc.c-torture/execute/20020328-1.c: Likewise.
+	* gcc.c-torture/execute/20020404-1.c: Likewise.
+	* gcc.c-torture/execute/20020406-1.c: Likewise.
+	* gcc.c-torture/execute/20020413-1.c: Likewise.
+	* gcc.c-torture/execute/20020418-1.c: Likewise.
+	* gcc.c-torture/execute/20020508-1.c: Likewise.
+	* gcc.c-torture/execute/20020508-2.c: Likewise.
+	* gcc.c-torture/execute/20020508-3.c: Likewise.
+	* gcc.c-torture/execute/20020529-1.c: Likewise.
+	* gcc.c-torture/execute/20020611-1.c: Likewise.
+	* gcc.c-torture/execute/20020615-1.c: Likewise.
+	* gcc.c-torture/execute/20020619-1.c: Likewise.
+	* gcc.c-torture/execute/20020904-1.c: Likewise.
+	* gcc.c-torture/execute/20020916-1.c: Likewise.
+	* gcc.c-torture/execute/20021010-1.c: Likewise.
+	* gcc.c-torture/execute/20021113-1.c: Likewise.
+	* gcc.c-torture/execute/20021118-1.c: Likewise.
+	* gcc.c-torture/execute/20021118-2.c: Likewise.
+	* gcc.c-torture/execute/20021120-1.c: Likewise.
+	* gcc.c-torture/execute/20021120-2.c: Likewise.
+	* gcc.c-torture/execute/20021120-3.c: Likewise.
+	* gcc.c-torture/execute/20030105-1.c: Likewise.
+	* gcc.c-torture/execute/20030109-1.c: Likewise.
+	* gcc.c-torture/execute/20030117-1.c: Likewise.
+	* gcc.c-torture/execute/20030120-1.c: Likewise.
+	* gcc.c-torture/execute/20030125-1.c: Likewise.
+	* gcc.c-torture/execute/20030128-1.c: Likewise.
+	* gcc.c-torture/execute/20030209-1.c: Likewise.
+	* gcc.c-torture/execute/20030222-1.c: Likewise.
+	* gcc.c-torture/execute/20030316-1.c: Likewise.
+	* gcc.c-torture/execute/20030403-1.c: Likewise.
+	* gcc.c-torture/execute/20030404-1.c: Likewise.
+	* gcc.c-torture/execute/20030501-1.c: Likewise.
+	* gcc.c-torture/execute/20030606-1.c: Likewise.
+	* gcc.c-torture/execute/20030828-1.c: Likewise.
+	* gcc.c-torture/execute/20030828-2.c: Likewise.
+	* gcc.c-torture/execute/20030903-1.c: Likewise.
+	* gcc.c-torture/execute/20030910-1.c: Likewise.
+	* gcc.c-torture/execute/20030913-1.c: Likewise.
+	* gcc.c-torture/execute/20030914-1.c: Likewise.
+	* gcc.c-torture/execute/20030914-2.c: Likewise.
+	* gcc.c-torture/execute/20030916-1.c: Likewise.
+	* gcc.c-torture/execute/20030928-1.c: Likewise.
+	* gcc.c-torture/execute/20031010-1.c: Likewise.
+	* gcc.c-torture/execute/20031201-1.c: Likewise.
+	* gcc.c-torture/execute/20031204-1.c: Likewise.
+	* gcc.c-torture/execute/20031211-1.c: Likewise.
+	* gcc.c-torture/execute/20040208-1.c: Likewise.
+	* gcc.c-torture/execute/20040218-1.c: Likewise.
+	* gcc.c-torture/execute/20040307-1.c: Likewise.
+	* gcc.c-torture/execute/20040319-1.c: Likewise.
+	* gcc.c-torture/execute/20040411-1.c: Likewise.
+	* gcc.c-torture/execute/20040423-1.c: Likewise.
+	* gcc.c-torture/execute/20040625-1.c: Likewise.
+	* gcc.c-torture/execute/20040703-1.c: Likewise.
+	* gcc.c-torture/execute/20040706-1.c: Likewise.
+	* gcc.c-torture/execute/20040707-1.c: Likewise.
+	* gcc.c-torture/execute/20040805-1.c: Likewise.
+	* gcc.c-torture/execute/20040917-1.c: Likewise.
+	* gcc.c-torture/execute/20041011-1.c: Likewise.
+	* gcc.c-torture/execute/20041113-1.c: Likewise.
+	* gcc.c-torture/execute/20041124-1.c: Likewise.
+	* gcc.c-torture/execute/20041210-1.c: Likewise.
+	* gcc.c-torture/execute/20041212-1.c: Likewise.
+	* gcc.c-torture/execute/20050410-1.c: Likewise.
+	* gcc.c-torture/execute/20051113-1.c: Likewise.
+	* gcc.c-torture/execute/20070623-1.c: Likewise.
+	* gcc.c-torture/execute/20091229-1.c: Likewise.
+	* gcc.c-torture/execute/20101025-1.c: Likewise.
+	* gcc.c-torture/execute/20120817-1.c: Likewise.
+	* gcc.c-torture/execute/20170401-2.c: Likewise.
+	* gcc.c-torture/execute/900409-1.c: Likewise.
+	* gcc.c-torture/execute/920202-1.c: Likewise.
+	* gcc.c-torture/execute/920302-1.c: Likewise.
+	* gcc.c-torture/execute/920410-1.c: Likewise.
+	* gcc.c-torture/execute/920501-2.c: Likewise.
+	* gcc.c-torture/execute/920501-3.c: Likewise.
+	* gcc.c-torture/execute/920501-4.c: Likewise.
+	* gcc.c-torture/execute/920501-5.c: Likewise.
+	* gcc.c-torture/execute/920501-6.c: Likewise.
+	* gcc.c-torture/execute/920501-8.c: Likewise.
+	* gcc.c-torture/execute/920506-1.c: Likewise.
+	* gcc.c-torture/execute/920604-1.c: Likewise.
+	* gcc.c-torture/execute/920612-2.c: Likewise.
+	* gcc.c-torture/execute/920618-1.c: Likewise.
+	* gcc.c-torture/execute/920625-1.c: Likewise.
+	* gcc.c-torture/execute/920710-1.c: Likewise.
+	* gcc.c-torture/execute/920721-1.c: Likewise.
+	* gcc.c-torture/execute/920721-4.c: Likewise.
+	* gcc.c-torture/execute/920726-1.c: Likewise.
+	* gcc.c-torture/execute/920829-1.c: Likewise.
+	* gcc.c-torture/execute/920908-1.c: Likewise.
+	* gcc.c-torture/execute/920922-1.c: Likewise.
+	* gcc.c-torture/execute/920929-1.c: Likewise.
+	* gcc.c-torture/execute/921006-1.c: Likewise.
+	* gcc.c-torture/execute/921007-1.c: Likewise.
+	* gcc.c-torture/execute/921016-1.c: Likewise.
+	* gcc.c-torture/execute/921019-1.c: Likewise.
+	* gcc.c-torture/execute/921019-2.c: Likewise.
+	* gcc.c-torture/execute/921029-1.c: Likewise.
+	* gcc.c-torture/execute/921104-1.c: Likewise.
+	* gcc.c-torture/execute/921112-1.c: Likewise.
+	* gcc.c-torture/execute/921113-1.c: Likewise.
+	* gcc.c-torture/execute/921117-1.c: Likewise.
+	* gcc.c-torture/execute/921123-2.c: Likewise.
+	* gcc.c-torture/execute/921202-2.c: Likewise.
+	* gcc.c-torture/execute/921204-1.c: Likewise.
+	* gcc.c-torture/execute/921208-1.c: Likewise.
+	* gcc.c-torture/execute/930123-1.c: Likewise.
+	* gcc.c-torture/execute/930126-1.c: Likewise.
+	* gcc.c-torture/execute/930406-1.c: Likewise.
+	* gcc.c-torture/execute/930408-1.c: Likewise.
+	* gcc.c-torture/execute/930429-1.c: Likewise.
+	* gcc.c-torture/execute/930603-2.c: Likewise.
+	* gcc.c-torture/execute/930608-1.c: Likewise.
+	* gcc.c-torture/execute/930614-1.c: Likewise.
+	* gcc.c-torture/execute/930614-2.c: Likewise.
+	* gcc.c-torture/execute/930622-2.c: Likewise.
+	* gcc.c-torture/execute/930628-1.c: Likewise.
+	* gcc.c-torture/execute/930725-1.c: Likewise.
+	* gcc.c-torture/execute/930930-2.c: Likewise.
+	* gcc.c-torture/execute/931002-1.c: Likewise.
+	* gcc.c-torture/execute/931004-1.c: Likewise.
+	* gcc.c-torture/execute/931004-10.c: Likewise.
+	* gcc.c-torture/execute/931004-11.c: Likewise.
+	* gcc.c-torture/execute/931004-12.c: Likewise.
+	* gcc.c-torture/execute/931004-13.c: Likewise.
+	* gcc.c-torture/execute/931004-14.c: Likewise.
+	* gcc.c-torture/execute/931004-2.c: Likewise.
+	* gcc.c-torture/execute/931004-3.c: Likewise.
+	* gcc.c-torture/execute/931004-4.c: Likewise.
+	* gcc.c-torture/execute/931004-5.c: Likewise.
+	* gcc.c-torture/execute/931004-6.c: Likewise.
+	* gcc.c-torture/execute/931004-7.c: Likewise.
+	* gcc.c-torture/execute/931004-8.c: Likewise.
+	* gcc.c-torture/execute/931004-9.c: Likewise.
+	* gcc.c-torture/execute/931005-1.c: Likewise.
+	* gcc.c-torture/execute/931110-1.c: Likewise.
+	* gcc.c-torture/execute/931110-2.c: Likewise.
+	* gcc.c-torture/execute/941014-1.c: Likewise.
+	* gcc.c-torture/execute/941015-1.c: Likewise.
+	* gcc.c-torture/execute/941021-1.c: Likewise.
+	* gcc.c-torture/execute/941025-1.c: Likewise.
+	* gcc.c-torture/execute/941031-1.c: Likewise.
+	* gcc.c-torture/execute/950221-1.c: Likewise.
+	* gcc.c-torture/execute/950426-2.c: Likewise.
+	* gcc.c-torture/execute/950503-1.c: Likewise.
+	* gcc.c-torture/execute/950511-1.c: Likewise.
+	* gcc.c-torture/execute/950607-1.c: Likewise.
+	* gcc.c-torture/execute/950607-2.c: Likewise.
+	* gcc.c-torture/execute/950612-1.c: Likewise.
+	* gcc.c-torture/execute/950628-1.c: Likewise.
+	* gcc.c-torture/execute/950704-1.c: Likewise.
+	* gcc.c-torture/execute/950706-1.c: Likewise.
+	* gcc.c-torture/execute/950710-1.c: Likewise.
+	* gcc.c-torture/execute/950714-1.c: Likewise.
+	* gcc.c-torture/execute/950809-1.c: Likewise.
+	* gcc.c-torture/execute/950906-1.c: Likewise.
+	* gcc.c-torture/execute/950915-1.c: Likewise.
+	* gcc.c-torture/execute/950929-1.c: Likewise.
+	* gcc.c-torture/execute/951003-1.c: Likewise.
+	* gcc.c-torture/execute/951115-1.c: Likewise.
+	* gcc.c-torture/execute/951204-1.c: Likewise.
+	* gcc.c-torture/execute/960116-1.c: Likewise.
+	* gcc.c-torture/execute/960117-1.c: Likewise.
+	* gcc.c-torture/execute/960209-1.c: Likewise.
+	* gcc.c-torture/execute/960215-1.c: Likewise.
+	* gcc.c-torture/execute/960219-1.c: Likewise.
+	* gcc.c-torture/execute/960301-1.c: Likewise.
+	* gcc.c-torture/execute/960302-1.c: Likewise.
+	* gcc.c-torture/execute/960311-1.c: Likewise.
+	* gcc.c-torture/execute/960311-2.c: Likewise.
+	* gcc.c-torture/execute/960311-3.c: Likewise.
+	* gcc.c-torture/execute/960312-1.c: Likewise.
+	* gcc.c-torture/execute/960317-1.c: Likewise.
+	* gcc.c-torture/execute/960321-1.c: Likewise.
+	* gcc.c-torture/execute/960326-1.c: Likewise.
+	* gcc.c-torture/execute/960327-1.c: Likewise.
+	* gcc.c-torture/execute/960405-1.c: Likewise.
+	* gcc.c-torture/execute/960416-1.c: Likewise.
+	* gcc.c-torture/execute/960419-1.c: Likewise.
+	* gcc.c-torture/execute/960419-2.c: Likewise.
+	* gcc.c-torture/execute/960512-1.c: Likewise.
+	* gcc.c-torture/execute/960513-1.c: Likewise.
+	* gcc.c-torture/execute/960608-1.c: Likewise.
+	* gcc.c-torture/execute/960801-1.c: Likewise.
+	* gcc.c-torture/execute/960802-1.c: Likewise.
+	* gcc.c-torture/execute/960909-1.c: Likewise.
+	* gcc.c-torture/execute/961004-1.c: Likewise.
+	* gcc.c-torture/execute/961017-1.c: Likewise.
+	* gcc.c-torture/execute/961017-2.c: Likewise.
+	* gcc.c-torture/execute/961026-1.c: Likewise.
+	* gcc.c-torture/execute/961122-1.c: Likewise.
+	* gcc.c-torture/execute/961122-2.c: Likewise.
+	* gcc.c-torture/execute/961125-1.c: Likewise.
+	* gcc.c-torture/execute/961206-1.c: Likewise.
+	* gcc.c-torture/execute/961213-1.c: Likewise.
+	* gcc.c-torture/execute/970214-1.c: Likewise.
+	* gcc.c-torture/execute/970214-2.c: Likewise.
+	* gcc.c-torture/execute/970217-1.c: Likewise.
+	* gcc.c-torture/execute/970923-1.c: Likewise.
+	* gcc.c-torture/execute/980205.c: Likewise.
+	* gcc.c-torture/execute/980223.c: Likewise.
+	* gcc.c-torture/execute/980424-1.c: Likewise.
+	* gcc.c-torture/execute/980505-1.c: Likewise.
+	* gcc.c-torture/execute/980505-2.c: Likewise.
+	* gcc.c-torture/execute/980506-1.c: Likewise.
+	* gcc.c-torture/execute/980506-2.c: Likewise.
+	* gcc.c-torture/execute/980506-3.c: Likewise.
+	* gcc.c-torture/execute/980526-1.c: Likewise.
+	* gcc.c-torture/execute/980526-2.c: Likewise.
+	* gcc.c-torture/execute/980526-3.c: Likewise.
+	* gcc.c-torture/execute/980602-1.c: Likewise.
+	* gcc.c-torture/execute/980602-2.c: Likewise.
+	* gcc.c-torture/execute/980604-1.c: Likewise.
+	* gcc.c-torture/execute/980605-1.c: Likewise.
+	* gcc.c-torture/execute/980612-1.c: Likewise.
+	* gcc.c-torture/execute/980617-1.c: Likewise.
+	* gcc.c-torture/execute/980618-1.c: Likewise.
+	* gcc.c-torture/execute/980701-1.c: Likewise.
+	* gcc.c-torture/execute/980709-1.c: Likewise.
+	* gcc.c-torture/execute/980716-1.c: Likewise.
+	* gcc.c-torture/execute/980929-1.c: Likewise.
+	* gcc.c-torture/execute/981001-1.c: Likewise.
+	* gcc.c-torture/execute/981019-1.c: Likewise.
+	* gcc.c-torture/execute/981130-1.c: Likewise.
+	* gcc.c-torture/execute/981206-1.c: Likewise.
+	* gcc.c-torture/execute/990106-2.c: Likewise.
+	* gcc.c-torture/execute/990117-1.c: Likewise.
+	* gcc.c-torture/execute/990128-1.c: Likewise.
+	* gcc.c-torture/execute/990130-1.c: Likewise.
+	* gcc.c-torture/execute/990208-1.c: Likewise.
+	* gcc.c-torture/execute/990222-1.c: Likewise.
+	* gcc.c-torture/execute/990324-1.c: Likewise.
+	* gcc.c-torture/execute/990326-1.c: Likewise.
+	* gcc.c-torture/execute/990404-1.c: Likewise.
+	* gcc.c-torture/execute/990513-1.c: Likewise.
+	* gcc.c-torture/execute/990524-1.c: Likewise.
+	* gcc.c-torture/execute/990525-1.c: Likewise.
+	* gcc.c-torture/execute/990525-2.c: Likewise.
+	* gcc.c-torture/execute/990527-1.c: Likewise.
+	* gcc.c-torture/execute/990531-1.c: Likewise.
+	* gcc.c-torture/execute/990604-1.c: Likewise.
+	* gcc.c-torture/execute/990804-1.c: Likewise.
+	* gcc.c-torture/execute/990811-1.c: Likewise.
+	* gcc.c-torture/execute/990826-0.c: Likewise.
+	* gcc.c-torture/execute/990827-1.c: Likewise.
+	* gcc.c-torture/execute/990829-1.c: Likewise.
+	* gcc.c-torture/execute/990923-1.c: Likewise.
+	* gcc.c-torture/execute/991014-1.c: Likewise.
+	* gcc.c-torture/execute/991016-1.c: Likewise.
+	* gcc.c-torture/execute/991019-1.c: Likewise.
+	* gcc.c-torture/execute/991023-1.c: Likewise.
+	* gcc.c-torture/execute/991030-1.c: Likewise.
+	* gcc.c-torture/execute/991112-1.c: Likewise.
+	* gcc.c-torture/execute/991118-1.c: Likewise.
+	* gcc.c-torture/execute/991201-1.c: Likewise.
+	* gcc.c-torture/execute/991202-1.c: Likewise.
+	* gcc.c-torture/execute/991202-2.c: Likewise.
+	* gcc.c-torture/execute/991202-3.c: Likewise.
+	* gcc.c-torture/execute/991216-1.c: Likewise.
+	* gcc.c-torture/execute/991216-2.c: Likewise.
+	* gcc.c-torture/execute/991216-4.c: Likewise.
+	* gcc.c-torture/execute/991221-1.c: Likewise.
+	* gcc.c-torture/execute/991227-1.c: Likewise.
+	* gcc.c-torture/execute/991228-1.c: Likewise.
+	* gcc.c-torture/execute/align-1.c: Likewise.
+	* gcc.c-torture/execute/align-2.c: Likewise.
+	* gcc.c-torture/execute/align-3.c: Likewise.
+	* gcc.c-torture/execute/alloca-1.c: Likewise.
+	* gcc.c-torture/execute/anon-1.c: Likewise.
+	* gcc.c-torture/execute/arith-1.c: Likewise.
+	* gcc.c-torture/execute/arith-rand-ll.c: Likewise.
+	* gcc.c-torture/execute/arith-rand.c: Likewise.
+	* gcc.c-torture/execute/bf-layout-1.c: Likewise.
+	* gcc.c-torture/execute/bf-pack-1.c: Likewise.
+	* gcc.c-torture/execute/bf-sign-1.c: Likewise.
+	* gcc.c-torture/execute/bf-sign-2.c: Likewise.
+	* gcc.c-torture/execute/bf64-1.c: Likewise.
+	* gcc.c-torture/execute/builtin-constant.c: Likewise.
+	* gcc.c-torture/execute/builtin-prefetch-1.c: Likewise.
+	* gcc.c-torture/execute/builtin-prefetch-2.c: Likewise.
+	* gcc.c-torture/execute/builtin-prefetch-3.c: Likewise.
+	* gcc.c-torture/execute/builtin-prefetch-4.c: Likewise.
+	* gcc.c-torture/execute/builtin-prefetch-5.c: Likewise.
+	* gcc.c-torture/execute/builtin-prefetch-6.c: Likewise.
+	* gcc.c-torture/execute/builtin-types-compatible-p.c: Likewise.
+	* gcc.c-torture/execute/cbrt.c: Likewise.
+	* gcc.c-torture/execute/complex-1.c: Likewise.
+	* gcc.c-torture/execute/complex-2.c: Likewise.
+	* gcc.c-torture/execute/complex-3.c: Likewise.
+	* gcc.c-torture/execute/complex-4.c: Likewise.
+	* gcc.c-torture/execute/complex-5.c: Likewise.
+	* gcc.c-torture/execute/compndlit-1.c: Likewise.
+	* gcc.c-torture/execute/conversion.c: Likewise.
+	* gcc.c-torture/execute/cvt-1.c: Likewise.
+	* gcc.c-torture/execute/divconst-1.c: Likewise.
+	* gcc.c-torture/execute/divconst-2.c: Likewise.
+	* gcc.c-torture/execute/divconst-3.c: Likewise.
+	* gcc.c-torture/execute/enum-1.c: Likewise.
+	* gcc.c-torture/execute/enum-2.c: Likewise.
+	* gcc.c-torture/execute/extzvsi.c: Likewise.
+	* gcc.c-torture/execute/frame-address.c: Likewise.
+	* gcc.c-torture/execute/func-ptr-1.c: Likewise.
+	* gcc.c-torture/execute/gofast.c: Likewise.
+	* gcc.c-torture/execute/ieee/20000320-1.c: Likewise.
+	* gcc.c-torture/execute/ieee/20001122-1.c: Likewise.
+	* gcc.c-torture/execute/ieee/20010226-1.c: Likewise.
+	* gcc.c-torture/execute/ieee/20011123-1.c: Likewise.
+	* gcc.c-torture/execute/ieee/920518-1.c: Likewise.
+	* gcc.c-torture/execute/ieee/920810-1.c: Likewise.
+	* gcc.c-torture/execute/ieee/930529-1.c: Likewise.
+	* gcc.c-torture/execute/ieee/980619-1.c: Likewise.
+	* gcc.c-torture/execute/ieee/acc1.c: Likewise.
+	* gcc.c-torture/execute/ieee/acc2.c: Likewise.
+	* gcc.c-torture/execute/ieee/fp-cmp-1.c: Likewise.
+	* gcc.c-torture/execute/ieee/fp-cmp-2.c: Likewise.
+	* gcc.c-torture/execute/ieee/fp-cmp-3.c: Likewise.
+	* gcc.c-torture/execute/ieee/fp-cmp-4.c: Likewise.
+	* gcc.c-torture/execute/ieee/fp-cmp-5.c: Likewise.
+	* gcc.c-torture/execute/ieee/fp-cmp-6.c: Likewise.
+	* gcc.c-torture/execute/ieee/fp-cmp-8.c: Likewise.
+	* gcc.c-torture/execute/ieee/fp-cmp-9.c: Likewise.
+	* gcc.c-torture/execute/ieee/hugeval.c: Likewise.
+	* gcc.c-torture/execute/ieee/minuszero.c: Likewise.
+	* gcc.c-torture/execute/ieee/mul-subnormal-single-1.c: Likewise.
+	* gcc.c-torture/execute/ieee/mzero2.c: Likewise.
+	* gcc.c-torture/execute/ieee/mzero3.c: Likewise.
+	* gcc.c-torture/execute/ieee/mzero5.c: Likewise.
+	* gcc.c-torture/execute/ieee/mzero6.c: Likewise.
+	* gcc.c-torture/execute/ieee/pr28634.c: Likewise.
+	* gcc.c-torture/execute/ieee/rbug.c: Likewise.
+	* gcc.c-torture/execute/index-1.c: Likewise.
+	* gcc.c-torture/execute/longlong.c: Likewise.
+	* gcc.c-torture/execute/loop-1.c: Likewise.
+	* gcc.c-torture/execute/loop-10.c: Likewise.
+	* gcc.c-torture/execute/loop-11.c: Likewise.
+	* gcc.c-torture/execute/loop-13.c: Likewise.
+	* gcc.c-torture/execute/loop-14.c: Likewise.
+	* gcc.c-torture/execute/loop-15.c: Likewise.
+	* gcc.c-torture/execute/loop-2b.c: Likewise.
+	* gcc.c-torture/execute/loop-2e.c: Likewise.
+	* gcc.c-torture/execute/loop-4.c: Likewise.
+	* gcc.c-torture/execute/loop-4b.c: Likewise.
+	* gcc.c-torture/execute/loop-5.c: Likewise.
+	* gcc.c-torture/execute/loop-6.c: Likewise.
+	* gcc.c-torture/execute/loop-7.c: Likewise.
+	* gcc.c-torture/execute/loop-8.c: Likewise.
+	* gcc.c-torture/execute/memcpy-1.c: Likewise.
+	* gcc.c-torture/execute/memcpy-2.c: Likewise.
+	* gcc.c-torture/execute/memcpy-bi.c: Likewise.
+	* gcc.c-torture/execute/memset-1.c: Likewise.
+	* gcc.c-torture/execute/memset-2.c: Likewise.
+	* gcc.c-torture/execute/memset-3.c: Likewise.
+	* gcc.c-torture/execute/multdi-1.c: Likewise.
+	* gcc.c-torture/execute/multi-ix.c: Likewise.
+	* gcc.c-torture/execute/nest-stdar-1.c: Likewise.
+	* gcc.c-torture/execute/nestfunc-1.c: Likewise.
+	* gcc.c-torture/execute/nestfunc-2.c: Likewise.
+	* gcc.c-torture/execute/nestfunc-3.c: Likewise.
+	* gcc.c-torture/execute/nestfunc-4.c: Likewise.
+	* gcc.c-torture/execute/packed-1.c: Likewise.
+	* gcc.c-torture/execute/pending-4.c: Likewise.
+	* gcc.c-torture/execute/pr15262-1.c: Likewise.
+	* gcc.c-torture/execute/pr15262-2.c: Likewise.
+	* gcc.c-torture/execute/pr15262.c: Likewise.
+	* gcc.c-torture/execute/pr15296.c: Likewise.
+	* gcc.c-torture/execute/pr17252.c: Likewise.
+	* gcc.c-torture/execute/pr17377.c: Likewise.
+	* gcc.c-torture/execute/pr19606.c: Likewise.
+	* gcc.c-torture/execute/pr21964-1.c: Likewise.
+	* gcc.c-torture/execute/pr22061-2.c: Likewise.
+	* gcc.c-torture/execute/pr22061-3.c: Likewise.
+	* gcc.c-torture/execute/pr22061-4.c: Likewise.
+	* gcc.c-torture/execute/pr23467.c: Likewise.
+	* gcc.c-torture/execute/pr27073.c: Likewise.
+	* gcc.c-torture/execute/pr27364.c: Likewise.
+	* gcc.c-torture/execute/pr28403.c: Likewise.
+	* gcc.c-torture/execute/pr31605.c: Likewise.
+	* gcc.c-torture/execute/pr38969.c: Likewise.
+	* gcc.c-torture/execute/pr40657.c: Likewise.
+	* gcc.c-torture/execute/pr44575.c: Likewise.
+	* gcc.c-torture/execute/pr56799.c: Likewise.
+	* gcc.c-torture/execute/pr58640.c: Likewise.
+	* gcc.c-torture/execute/pr71335.c: Likewise.
+	* gcc.c-torture/execute/ptr-arith-1.c: Likewise.
+	* gcc.c-torture/execute/regstack-1.c: Likewise.
+	* gcc.c-torture/execute/scope-1.c: Likewise.
+	* gcc.c-torture/execute/simd-1.c: Likewise.
+	* gcc.c-torture/execute/simd-2.c: Likewise.
+	* gcc.c-torture/execute/simd-4.c: Likewise.
+	* gcc.c-torture/execute/simd-5.c: Likewise.
+	* gcc.c-torture/execute/strcmp-1.c: Likewise.
+	* gcc.c-torture/execute/strcpy-1.c: Likewise.
+	* gcc.c-torture/execute/strct-pack-1.c: Likewise.
+	* gcc.c-torture/execute/strct-pack-2.c: Likewise.
+	* gcc.c-torture/execute/strct-pack-4.c: Likewise.
+	* gcc.c-torture/execute/strct-stdarg-1.c: Likewise.
+	* gcc.c-torture/execute/strct-varg-1.c: Likewise.
+	* gcc.c-torture/execute/strlen-1.c: Likewise.
+	* gcc.c-torture/execute/strncmp-1.c: Likewise.
+	* gcc.c-torture/execute/struct-ini-1.c: Likewise.
+	* gcc.c-torture/execute/struct-ini-2.c: Likewise.
+	* gcc.c-torture/execute/struct-ini-3.c: Likewise.
+	* gcc.c-torture/execute/struct-ini-4.c: Likewise.
+	* gcc.c-torture/execute/struct-ret-1.c: Likewise.
+	* gcc.c-torture/execute/struct-ret-2.c: Likewise.
+	* gcc.c-torture/execute/usmul.c: Likewise.
+	* gcc.c-torture/execute/va-arg-1.c: Likewise.
+	* gcc.c-torture/execute/va-arg-10.c: Likewise.
+	* gcc.c-torture/execute/va-arg-11.c: Likewise.
+	* gcc.c-torture/execute/va-arg-12.c: Likewise.
+	* gcc.c-torture/execute/va-arg-13.c: Likewise.
+	* gcc.c-torture/execute/va-arg-14.c: Likewise.
+	* gcc.c-torture/execute/va-arg-15.c: Likewise.
+	* gcc.c-torture/execute/va-arg-16.c: Likewise.
+	* gcc.c-torture/execute/va-arg-17.c: Likewise.
+	* gcc.c-torture/execute/va-arg-18.c: Likewise.
+	* gcc.c-torture/execute/va-arg-19.c: Likewise.
+	* gcc.c-torture/execute/va-arg-2.c: Likewise.
+	* gcc.c-torture/execute/va-arg-20.c: Likewise.
+	* gcc.c-torture/execute/va-arg-23.c: Likewise.
+	* gcc.c-torture/execute/va-arg-26.c: Likewise.
+	* gcc.c-torture/execute/va-arg-4.c: Likewise.
+	* gcc.c-torture/execute/va-arg-5.c: Likewise.
+	* gcc.c-torture/execute/va-arg-6.c: Likewise.
+	* gcc.c-torture/execute/va-arg-9.c: Likewise.
+	* gcc.c-torture/execute/widechar-1.c: Likewise.
+	* gcc.c-torture/execute/widechar-2.c: Likewise.
+
+2023-11-13  Florian Weimer  <fweimer@redhat.com>
+
+	* gcc.c-torture/compile/386.c: Compile with -std=gnu89.
+	* gcc.c-torture/compile/BUG1.c: Likewise.
+	* gcc.c-torture/compile/BUG11.c: Likewise.
+	* gcc.c-torture/compile/BUG16.c: Likewise.
+	* gcc.c-torture/compile/BUG2.c: Likewise.
+	* gcc.c-torture/compile/BUG24.c: Likewise.
+	* gcc.c-torture/compile/BUG25.c: Likewise.
+	* gcc.c-torture/compile/BUG3.c: Likewise.
+	* gcc.c-torture/compile/DFcmp.c: Likewise.
+	* gcc.c-torture/compile/HIcmp.c: Likewise.
+	* gcc.c-torture/compile/HIset.c: Likewise.
+	* gcc.c-torture/compile/QIcmp.c: Likewise.
+	* gcc.c-torture/compile/QIset.c: Likewise.
+	* gcc.c-torture/compile/SFset.c: Likewise.
+	* gcc.c-torture/compile/SIcmp.c: Likewise.
+	* gcc.c-torture/compile/SIset.c: Likewise.
+	* gcc.c-torture/compile/UHIcmp.c: Likewise.
+	* gcc.c-torture/compile/UQIcmp.c: Likewise.
+	* gcc.c-torture/compile/USIcmp.c: Likewise.
+	* gcc.c-torture/compile/a.c: Likewise.
+	* gcc.c-torture/compile/a1.c: Likewise.
+	* gcc.c-torture/compile/a3.c: Likewise.
+	* gcc.c-torture/compile/aa.c: Likewise.
+	* gcc.c-torture/compile/aaa.c: Likewise.
+	* gcc.c-torture/compile/abs.c: Likewise.
+	* gcc.c-torture/compile/ac.c: Likewise.
+	* gcc.c-torture/compile/acc.c: Likewise.
+	* gcc.c-torture/compile/add.c: Likewise.
+	* gcc.c-torture/compile/add386.c: Likewise.
+	* gcc.c-torture/compile/addcc.c: Likewise.
+	* gcc.c-torture/compile/andm.c: Likewise.
+	* gcc.c-torture/compile/andmem.c: Likewise.
+	* gcc.c-torture/compile/andn.c: Likewise.
+	* gcc.c-torture/compile/andok.c: Likewise.
+	* gcc.c-torture/compile/andsi.c: Likewise.
+	* gcc.c-torture/compile/andsparc.c: Likewise.
+	* gcc.c-torture/compile/aos.c: Likewise.
+	* gcc.c-torture/compile/arr.c: Likewise.
+	* gcc.c-torture/compile/as.c: Likewise.
+	* gcc.c-torture/compile/ase.c: Likewise.
+	* gcc.c-torture/compile/band.c: Likewise.
+	* gcc.c-torture/compile/bb0.c: Likewise.
+	* gcc.c-torture/compile/bb1.c: Likewise.
+	* gcc.c-torture/compile/bc.c: Likewise.
+	* gcc.c-torture/compile/bcopy.c: Likewise.
+	* gcc.c-torture/compile/bfx.c: Likewise.
+	* gcc.c-torture/compile/bge.c: Likewise.
+	* gcc.c-torture/compile/bit.c: Likewise.
+	* gcc.c-torture/compile/bitf.c: Likewise.
+	* gcc.c-torture/compile/bitw.c: Likewise.
+	* gcc.c-torture/compile/blk.c: Likewise.
+	* gcc.c-torture/compile/bt386.c: Likewise.
+	* gcc.c-torture/compile/bug.c: Likewise.
+	* gcc.c-torture/compile/buns.c: Likewise.
+	* gcc.c-torture/compile/c.c: Likewise.
+	* gcc.c-torture/compile/c2.c: Likewise.
+	* gcc.c-torture/compile/call.c: Likewise.
+	* gcc.c-torture/compile/callind.c: Likewise.
+	* gcc.c-torture/compile/calls-void.c: Likewise.
+	* gcc.c-torture/compile/calls.c: Likewise.
+	* gcc.c-torture/compile/cc.c: Likewise.
+	* gcc.c-torture/compile/cmb.c: Likewise.
+	* gcc.c-torture/compile/cmpsi386.c: Likewise.
+	* gcc.c-torture/compile/cmul.c: Likewise.
+	* gcc.c-torture/compile/comb.c: Likewise.
+	* gcc.c-torture/compile/consec.c: Likewise.
+	* gcc.c-torture/compile/const.c: Likewise.
+	* gcc.c-torture/compile/conv_tst.c: Likewise.
+	* gcc.c-torture/compile/cvt.c: Likewise.
+	* gcc.c-torture/compile/dbl_parm.c: Likewise.
+	* gcc.c-torture/compile/dblbug.c: Likewise.
+	* gcc.c-torture/compile/dead.c: Likewise.
+	* gcc.c-torture/compile/delay.c: Likewise.
+	* gcc.c-torture/compile/di.c: Likewise.
+	* gcc.c-torture/compile/div.c: Likewise.
+	* gcc.c-torture/compile/dm.c: Likewise.
+	* gcc.c-torture/compile/dshift.c: Likewise.
+	* gcc.c-torture/compile/e.c: Likewise.
+	* gcc.c-torture/compile/ex.c: Likewise.
+	* gcc.c-torture/compile/ext.c: Likewise.
+	* gcc.c-torture/compile/flo.c: Likewise.
+	* gcc.c-torture/compile/forgetcc.c: Likewise.
+	* gcc.c-torture/compile/g.c: Likewise.
+	* gcc.c-torture/compile/gen_tst.c: Likewise.
+	* gcc.c-torture/compile/gronk.c: Likewise.
+	* gcc.c-torture/compile/hi.c: Likewise.
+	* gcc.c-torture/compile/i.c: Likewise.
+	* gcc.c-torture/compile/icmp.c: Likewise.
+	* gcc.c-torture/compile/ifreg.c: Likewise.
+	* gcc.c-torture/compile/jumptab.c: Likewise.
+	* gcc.c-torture/compile/l.c: Likewise.
+	* gcc.c-torture/compile/layout.c: Likewise.
+	* gcc.c-torture/compile/lll.c: Likewise.
+	* gcc.c-torture/compile/load8.c: Likewise.
+	* gcc.c-torture/compile/loadhicc.c: Likewise.
+	* gcc.c-torture/compile/log2.c: Likewise.
+	* gcc.c-torture/compile/logic.c: Likewise.
+	* gcc.c-torture/compile/loop-1.c: Likewise.
+	* gcc.c-torture/compile/loop386.c: Likewise.
+	* gcc.c-torture/compile/lop.c: Likewise.
+	* gcc.c-torture/compile/m1.c: Likewise.
+	* gcc.c-torture/compile/m5.c: Likewise.
+	* gcc.c-torture/compile/m68.c: Likewise.
+	* gcc.c-torture/compile/mbyte.c: Likewise.
+	* gcc.c-torture/compile/mcmp.c: Likewise.
+	* gcc.c-torture/compile/mm.c: Likewise.
+	* gcc.c-torture/compile/mod.c: Likewise.
+	* gcc.c-torture/compile/modcc.c: Likewise.
+	* gcc.c-torture/compile/move.c: Likewise.
+	* gcc.c-torture/compile/move_qhi.c: Likewise.
+	* gcc.c-torture/compile/mregtst.c: Likewise.
+	* gcc.c-torture/compile/mu.c: Likewise.
+	* gcc.c-torture/compile/mword.c: Likewise.
+	* gcc.c-torture/compile/n.c: Likewise.
+	* gcc.c-torture/compile/n1.c: Likewise.
+	* gcc.c-torture/compile/nand.c: Likewise.
+	* gcc.c-torture/compile/neg.c: Likewise.
+	* gcc.c-torture/compile/o.c: Likewise.
+	* gcc.c-torture/compile/omit.c: Likewise.
+	* gcc.c-torture/compile/opout.c: Likewise.
+	* gcc.c-torture/compile/opt.c: Likewise.
+	* gcc.c-torture/compile/or.c: Likewise.
+	* gcc.c-torture/compile/or386.c: Likewise.
+	* gcc.c-torture/compile/p.c: Likewise.
+	* gcc.c-torture/compile/parms.c: Likewise.
+	* gcc.c-torture/compile/pass.c: Likewise.
+	* gcc.c-torture/compile/pp.c: Likewise.
+	* gcc.c-torture/compile/pret-arg.c: Likewise.
+	* gcc.c-torture/compile/pyr.c: Likewise.
+	* gcc.c-torture/compile/pyr2.c: Likewise.
+	* gcc.c-torture/compile/r.c: Likewise.
+	* gcc.c-torture/compile/r1.c: Likewise.
+	* gcc.c-torture/compile/rmsc.c: Likewise.
+	* gcc.c-torture/compile/round.c: Likewise.
+	* gcc.c-torture/compile/sc.c: Likewise.
+	* gcc.c-torture/compile/scal.c: Likewise.
+	* gcc.c-torture/compile/scc.c: Likewise.
+	* gcc.c-torture/compile/scond.c: Likewise.
+	* gcc.c-torture/compile/seq.c: Likewise.
+	* gcc.c-torture/compile/set386.c: Likewise.
+	* gcc.c-torture/compile/set88.c: Likewise.
+	* gcc.c-torture/compile/sh.c: Likewise.
+	* gcc.c-torture/compile/shand.c: Likewise.
+	* gcc.c-torture/compile/shft.c: Likewise.
+	* gcc.c-torture/compile/shift.c: Likewise.
+	* gcc.c-torture/compile/signext.c: Likewise.
+	* gcc.c-torture/compile/signext2.c: Likewise.
+	* gcc.c-torture/compile/simple.c: Likewise.
+	* gcc.c-torture/compile/sparcbug.c: Likewise.
+	* gcc.c-torture/compile/stor.c: Likewise.
+	* gcc.c-torture/compile/str.c: Likewise.
+	* gcc.c-torture/compile/structret.c: Likewise.
+	* gcc.c-torture/compile/sub32.c: Likewise.
+	* gcc.c-torture/compile/subcc.c: Likewise.
+	* gcc.c-torture/compile/subcse.c: Likewise.
+	* gcc.c-torture/compile/sym.c: Likewise.
+	* gcc.c-torture/compile/symconst.c: Likewise.
+	* gcc.c-torture/compile/t.c: Likewise.
+	* gcc.c-torture/compile/test-flow.c: Likewise.
+	* gcc.c-torture/compile/test-loop.c: Likewise.
+	* gcc.c-torture/compile/test.c: Likewise.
+	* gcc.c-torture/compile/tmp.c: Likewise.
+	* gcc.c-torture/compile/trivial.c: Likewise.
+	* gcc.c-torture/compile/trunc.c: Likewise.
+	* gcc.c-torture/compile/u.c: Likewise.
+	* gcc.c-torture/compile/uns.c: Likewise.
+	* gcc.c-torture/compile/uns_tst.c: Likewise.
+	* gcc.c-torture/compile/uuarg.c: Likewise.
+	* gcc.c-torture/compile/volatile-1.c: Likewise.
+	* gcc.c-torture/compile/ww.c: Likewise.
+	* gcc.c-torture/compile/x.c: Likewise.
+	* gcc.c-torture/compile/xb.c: Likewise.
+	* gcc.c-torture/compile/xc.c: Likewise.
+	* gcc.c-torture/compile/xdi.c: Likewise.
+	* gcc.c-torture/compile/xfoo.c: Likewise.
+	* gcc.c-torture/compile/xi.c: Likewise.
+	* gcc.c-torture/compile/xlop.c: Likewise.
+	* gcc.c-torture/compile/xneg.c: Likewise.
+	* gcc.c-torture/compile/xopt.c: Likewise.
+	* gcc.c-torture/compile/xor.c: Likewise.
+	* gcc.c-torture/compile/xorn.c: Likewise.
+	* gcc.c-torture/compile/xp.c: Likewise.
+	* gcc.c-torture/compile/xpp.c: Likewise.
+	* gcc.c-torture/compile/xs.c: Likewise.
+	* gcc.c-torture/compile/xsh.c: Likewise.
+	* gcc.c-torture/compile/xzz.c: Likewise.
+	* gcc.c-torture/compile/zero-strct-1.c: Likewise.
+	* gcc.c-torture/execute/20000717-3.c: Likewise.
+	* gcc.c-torture/execute/920409-1.c: Likewise.
+	* gcc.c-torture/execute/920411-1.c: Likewise.
+	* gcc.c-torture/execute/920415-1.c: Likewise.
+	* gcc.c-torture/execute/920428-1.c: Likewise.
+	* gcc.c-torture/execute/920428-2.c: Likewise.
+	* gcc.c-torture/execute/920429-1.c: Likewise.
+	* gcc.c-torture/execute/920501-1.c: Likewise.
+	* gcc.c-torture/execute/920501-7.c: Likewise.
+	* gcc.c-torture/execute/920501-9.c: Likewise.
+	* gcc.c-torture/execute/920520-1.c: Likewise.
+	* gcc.c-torture/execute/920603-1.c: Likewise.
+	* gcc.c-torture/execute/920721-2.c: Likewise.
+	* gcc.c-torture/execute/920721-3.c: Likewise.
+	* gcc.c-torture/execute/920728-1.c: Likewise.
+	* gcc.c-torture/execute/920730-1.c: Likewise.
+	* gcc.c-torture/execute/920731-1.c: Likewise.
+	* gcc.c-torture/execute/920812-1.c: Likewise.
+	* gcc.c-torture/execute/920909-1.c: Likewise.
+	* gcc.c-torture/execute/921013-1.c: Likewise.
+	* gcc.c-torture/execute/921017-1.c: Likewise.
+	* gcc.c-torture/execute/921123-1.c: Likewise.
+	* gcc.c-torture/execute/921124-1.c: Likewise.
+	* gcc.c-torture/execute/921202-1.c: Likewise.
+	* gcc.c-torture/execute/921207-1.c: Likewise.
+	* gcc.c-torture/execute/921208-2.c: Likewise.
+	* gcc.c-torture/execute/921215-1.c: Likewise.
+	* gcc.c-torture/execute/921218-1.c: Likewise.
+	* gcc.c-torture/execute/921218-2.c: Likewise.
+	* gcc.c-torture/execute/930106-1.c: Likewise.
+	* gcc.c-torture/execute/930429-2.c: Likewise.
+	* gcc.c-torture/execute/930513-1.c: Likewise.
+	* gcc.c-torture/execute/930513-2.c: Likewise.
+	* gcc.c-torture/execute/930518-1.c: Likewise.
+	* gcc.c-torture/execute/930527-1.c: Likewise.
+	* gcc.c-torture/execute/930603-1.c: Likewise.
+	* gcc.c-torture/execute/930603-3.c: Likewise.
+	* gcc.c-torture/execute/930621-1.c: Likewise.
+	* gcc.c-torture/execute/930622-1.c: Likewise.
+	* gcc.c-torture/execute/930630-1.c: Likewise.
+	* gcc.c-torture/execute/930713-1.c: Likewise.
+	* gcc.c-torture/execute/930718-1.c: Likewise.
+	* gcc.c-torture/execute/930719-1.c: Likewise.
+	* gcc.c-torture/execute/930916-1.c: Likewise.
+	* gcc.c-torture/execute/930921-1.c: Likewise.
+	* gcc.c-torture/execute/930929-1.c: Likewise.
+	* gcc.c-torture/execute/930930-1.c: Likewise.
+	* gcc.c-torture/execute/931009-1.c: Likewise.
+	* gcc.c-torture/execute/931012-1.c: Likewise.
+	* gcc.c-torture/execute/931031-1.c: Likewise.
+	* gcc.c-torture/execute/931102-1.c: Likewise.
+	* gcc.c-torture/execute/931102-2.c: Likewise.
+	* gcc.c-torture/execute/931228-1.c: Likewise.
+	* gcc.c-torture/execute/940115-1.c: Likewise.
+	* gcc.c-torture/execute/940122-1.c: Likewise.
+	* gcc.c-torture/execute/941202-1.c: Likewise.
+	* gcc.c-torture/execute/950605-1.c: Likewise.
+	* gcc.c-torture/execute/960830-1.c: Likewise.
+	* gcc.c-torture/execute/961112-1.c: Likewise.
+	* gcc.c-torture/execute/990106-1.c: Likewise.
+	* gcc.c-torture/execute/cmpdi-1.c: Likewise.
+	* gcc.c-torture/execute/comp-goto-2.c: Likewise.
+	* gcc.c-torture/execute/dbra-1.c: Likewise.
+	* gcc.c-torture/execute/inst-check.c: Likewise.
+	* gcc.c-torture/execute/int-compare.c: Likewise.
+	* gcc.c-torture/execute/loop-2.c: Likewise.
+	* gcc.c-torture/execute/loop-2d.c: Likewise.
+	* gcc.c-torture/execute/loop-3.c: Likewise.
+	* gcc.c-torture/execute/loop-3b.c: Likewise.
+	* gcc.c-torture/execute/loop-3c.c: Likewise.
+	* gcc.c-torture/execute/mod-1.c: Likewise.
+	* gcc.c-torture/execute/strct-pack-3.c: Likewise.
+	* gcc.c-torture/execute/tstdi-1.c: Likewise.
+
+2023-11-13  Florian Weimer  <fweimer@redhat.com>
+
+	* gcc.c-torture/compile/BUG17.c (main): Add missing int
+	return type and missing void type.
+	* gcc.c-torture/compile/BUG18.c (main): Likewise.  Call
+	__builtin_printf instead of printf.
+	* gcc.c-torture/compile/BUG21.c (Nase): Add missing void
+	types.
+	* gcc.c-torture/compile/BUG23.c (main): Add missing int
+	return type and missing void type.
+	* gcc.c-torture/compile/BUG5.c (bar): Call
+	__builtin_printf instead of printf.
+	* gcc.c-torture/compile/BUG6.c (main): Likewise.  Add missing
+	int return type and missing void type.
+	* gcc.c-torture/compile/b.c (main): Add missing int
+	return type and missing void type.
+	* gcc.c-torture/compile/b1.c (main): Likewise.  Call
+	__builtin_printf instead of printf.
+	* gcc.c-torture/compile/b88.c (main): Add missing int
+	return type and missing void type.
+	* gcc.c-torture/compile/bbb.c (flset): Add missing void
+	return type and switch to prototype style.
+	* gcc.c-torture/compile/bf.c (clr, atoi): Declare.
+	(main): Add missing int return type.  Call
+	__builtin_printf instead of printf.
+	* gcc.c-torture/compile/bt.c (main): Add missing int
+	return type and missing void type.
+	* gcc.c-torture/compile/charmtst.c (foo, bar): Declare.
+	(c_move_tst): Add missing int return type.
+	* gcc.c-torture/compile/cmpdi-1.c (f, g): Add missing int
+	return type.
+	* gcc.c-torture/compile/cmphi.c (foo): Likewise.
+	* gcc.c-torture/compile/conv.c (main): Likewise.  Add missing
+	void type.  Call __builtin_printf instead of printf.
+	* gcc.c-torture/compile/ddd.c (main): Add missing int
+	return type and missing void type.
+	* gcc.c-torture/compile/dilayout.c (str, ll): Add missing
+	void return type.
+	* gcc.c-torture/compile/dimove.c (foo): Likewise.
+	* gcc.c-torture/compile/f2.c (foo): Likewise.
+	* gcc.c-torture/compile/flatten.c  (main): Add missing int
+	return type and missing void type.
+	* gcc.c-torture/compile/fnul.c (main): Likewise.
+	Call __builtin_printf instead of printf.
+	* gcc.c-torture/compile/fq.c (expand_to_ascii): Add missing
+	void return type.
+	* gcc.c-torture/compile/funcptr-1.c (g): Call __builtin_printf
+	instead of printf.
+	(f): Likewise.  Add missing void types.
+	* gcc.c-torture/compile/glob.c (foo): Add missing void types.
+	* gcc.c-torture/compile/goto-1.c (f): Likewise.
+	* gcc.c-torture/compile/i++.c (main): Call __builtin_printf
+	instead of printf.
+	* gcc.c-torture/compile/ic.c (foo): Add missing int return
+	type.
+	* gcc.c-torture/compile/iftrap-1.c (bar, baz): Declare.
+	(f4, f6): Call __builtin_abort instead of abort.
+	* gcc.c-torture/compile/iftrap-2.c (bar): Declare.
+	* gcc.c-torture/compile/jmp.c (foo): Add missing int types.
+	* gcc.c-torture/compile/labels-1.c (f): Add missing int
+	return type and missing void type.  Call __builtin_abort
+	instead of abort.
+	* gcc.c-torture/compile/labels-2.c (f): Likewise.
+	* gcc.c-torture/compile/lbug.c (main): Add missing int
+	return type and missing void type.
+	* gcc.c-torture/compile/memtst.c (memtst): Add missing void
+	return type.
+	(main): Add missing int	return type and missing void type.
+	Call __builtin_bzero instead of bzero.
+	* gcc.c-torture/compile/miscomp.c (main): Add missing int
+	return type and missing void type.  Call __builtin_printf
+	instead of printf.
+	* gcc.c-torture/compile/msp.c (bar): Declare.
+	(foo): Add missing void types.
+	* gcc.c-torture/compile/mtst.c (foo): Add missing int return
+	type.
+	* gcc.c-torture/compile/packed-1.c (f): Add missing void
+	types.
+	* gcc.c-torture/compile/pr17119.c (func1, func2): Declare.
+	* gcc.c-torture/compile/pr18712.c (foo, foo1): Declare.
+	* gcc.c-torture/compile/pr20412.c (bar1, bar2, bar3): Declare.
+	* gcc.c-torture/compile/pr21532.c (foo): Declare.
+	* gcc.c-torture/compile/pr22398.c (main): Call __builtin_exit
+	instead of exit.
+	* gcc.c-torture/compile/pr24883.c (orec_str_list): Add missing
+	void return type.
+	* gcc.c-torture/compile/pr25311.c (use): Declare.
+	* gcc.c-torture/compile/pr25514.c (foo): Declare.
+	* gcc.c-torture/compile/pr26425.c (key_put): Declare.
+	* gcc.c-torture/compile/pr27087.c (g): Declare.
+	* gcc.c-torture/compile/pr27282.c (colrow_equal): Add missing
+	int return type.
+	* gcc.c-torture/compile/pr27907.c (fann_run): Add missing
+	void return type.
+	* gcc.c-torture/compile/pr28489.c (c_compile): Likewise.
+	* gcc.c-torture/compile/pr28776-1.c
+	(tree_contains_struct_check_failed): Declare.
+	* gcc.c-torture/compile/pr29128.c (process_main): Add missing
+	void return type.
+	* gcc.c-torture/compile/pr29945.c (unget_char): Declare.
+	(main) Add missing void return type.
+	* gcc.c-torture/compile/pr33382.c (show_configuration): Add
+	missing int types.
+	* gcc.c-torture/compile/pr36141.c (ffi_prep_closure_loc): Add
+	missing return type.
+	* gcc.c-torture/compile/pr36988.c (__writel): Declare.
+	* gcc.c-torture/compile/pr37026.c (foo): Declare.
+	* gcc.c-torture/compile/pr37285.c (_bfd_abort): Declare.
+	(_bfd_xcoff_canonicalize_dynamic_reloc): Add missing void
+	return type.
+	* gcc.c-torture/compile/pr38554.c (applyFunction): Add missing
+	void return type.
+	* gcc.c-torture/compile/pr42164.c (swp_offset, __BUG_ON):
+	Declare.
+	* gcc.c-torture/compile/pr44788.c (foo): Declare.
+	* gcc.c-torture/compile/pr47364-1.c (arc4_init): Add missing
+	void return type.
+	* gcc.c-torture/compile/pr48596.c (_nrrdCenter): Declare.
+	* gcc.c-torture/compile/rel.c (foo): Add missing int return
+	type.
+	* gcc.c-torture/compile/run.c (main): Likewise.  Add missing
+	void type.
+	* gcc.c-torture/compile/sar.c (main): Likewise.
+	* gcc.c-torture/compile/selfrec.c (foo): Add missing int
+	parameter type.
+	* gcc.c-torture/compile/shloop.c (main): Add missing int
+	return type and missing void type.
+	* gcc.c-torture/compile/shm.c (foo): Add missing int return
+	type.
+	* gcc.c-torture/compile/sim.c (main): Likewise.  Add missing
+	void type.
+	* gcc.c-torture/compile/simd-5.c (main): Add missing int
+	return type and missing void type.  Call __builtin_printf
+	instead of printf.
+	* gcc.c-torture/compile/sne.c (foo): Add missing int return
+	type.
+	* gcc.c-torture/compile/sound.c (write): Declare.
+	(main): Add missing int return type and missing void type.
+	* gcc.c-torture/compile/speed.c (main): Likewise.
+	* gcc.c-torture/compile/store0.c (foo): Add missing void
+	return type.
+	* gcc.c-torture/compile/storecc.c (foo): Add missing int
+	return type.
+	* gcc.c-torture/compile/strcpy-1.c (rezero): Add missing
+	void types.
+	* gcc.c-torture/compile/stru.c (foo): Add missing void return
+	type.
+	* gcc.c-torture/compile/stuct.c (main): Add missing int return
+	type and missing void type.
+	* gcc.c-torture/compile/time.c (main): Likewise.
+	* gcc.c-torture/compile/unalign-1.c (f): Declare.
+	* gcc.c-torture/compile/v.c (main): Add missing int return
+	type.
+	* gcc.c-torture/compile/xcsebug.c (foo): Add missing void
+	types.
+	* gcc.c-torture/compile/xmtst.c (p2, p3, p4): Add missing
+	int return type.
+	* gcc.c-torture/compile/xz.c (foo): Add missing void return
+	type.
+	* gcc.c-torture/execute/loop-2f.c (f): Add missing void
+	return type.
+	(main): Return instead of calling exit.  Call __builtin_abort
+	instead of abort.
+	* gcc.c-torture/execute/loop-2g.c (f): Add missing void
+	return type.
+	(main): Return instead of calling exit.  Call __builtin_abort
+	instead of abort.
+	* gcc.dg/20020206-1.c: Build without -w.
+	(main): Call __builtin_abort instead of abort and
+	__builtin_exit instead of exit.
+	* gcc.dg/ipa/20040703-wpa.c (main): Call __builtin_abort
+	instead of abort and __builtin_exit instead of exit.
+	* gcc.dg/torture/pr84528.c (main): Add missing int and void
+	types.  Call __builtin_abort instead of abort, and
+	__builtin_exit instead of exit.
+	* gcc.dg/tree-ssa/pr68619-2.c (vector_type_mode, real_inf):
+	Declare.
+	* gcc.dg/tree-ssa/pr68619-3.c (iterative_hash): Declare.
+	(e_hash): Call __builtin_abort instead of abort.
+	* gcc.dg/tree-ssa/pr68619-4.c (rhs_regno, foop, arf): Declare.
+	* gcc.dg/tree-ssa/pr68619-5.c (invert_tree_comparison)
+	(vector_type_mode): Declare.
+	* gcc.dg/tree-ssa/pr69270-2.c (arf, gimple_debug_bind_p)
+	(gimple_bb, gimple_assign_rhs_to_tree)
+	(is_gimple_min_invariant, unshare_expr): Declare.
+	* gcc.dg/tree-ssa/pr69270-3.c: (end_imm_use_stmt_p)
+	(next_imm_use_stmt, arf, boo, update_stmt): Declare.
+	* gcc.dg/tree-ssa/ranger-threader-2.c (gimple_call_arg):
+	Declare.
+	(gimple_op): Call __builtin_abort instead of abort.
+	* gcc.dg/tree-ssa/ranger-threader-3.c (expand_binop): Declare.
+	* gcc.dg/tree-ssa/ssa-dom-branch-1.c (arf, foo): Declare.
+	(try_combine): Add casts to rtx.
+	* gcc.dg/tree-ssa/split-path-3.c (vec_heap_o_reserve)
+	(VEC_int_base_length, bmp_iter_and_compl_init)
+	(bmp_iter_and_compl, bmp_iter_next, VEC_int_heap_free):
+	Declare.
+	* gcc.dg/tree-ssa/split-path-7.c (linit): Call
+	__builtin_strcmp instead of strcmp.
+	* gcc.dg/tree-ssa/ssa-dom-thread-12.c (gimple_call_arg):
+	Declare.
+	(gimple_op): Call __builtin_abort instead of abort.
+	* gcc.dg/tree-ssa/ssa-dom-thread-13.c (arf, error): Declare.
+	(convert): Call __builtin_abort instead of abort.
+	* gcc.dg/tree-ssa/ssa-dom-thread-14.c (exand_binop): Declare.
+	* gcc.dg/tree-ssa/ssa-dom-thread-15.c
+	(ix86_target_stack_probe, pro_epilogue_adjust_stack)
+	(gen_rtx_CONST_INT, fancy_abort): Declare.
+	* gcc.dg/tree-ssa/ssa-dse-25.c (foo): Call __builtin_memset
+	instead of memset.
+	* gcc.target/aarch64/aapcs64/va_arg-17.c
+	(init_data): Call __builtin_memset instead of memset.
+	* gcc.target/i386/pr69030.c (fn1): Call __builtin_printf instead
+	of printf.
+
+2023-11-13  Florian Weimer  <fweimer@redhat.com>
+
+	* gcc.c-torture/compile/20080613-1.c (hop_sendmsg): Call
+	__builtin_memcpy instead of memcpy.
+	* gcc.c-torture/compile/complex-6.c (bar): Declare.
+	* gcc.c-torture/compile/pr23445.c (__brelse): Declare.
+	* gcc.c-torture/compile/pr23946.c (long2str): Declare.
+	(avi_parse_comments): Call __builtin_memset instead of
+	memset.  __builtin_malloc instead of malloc.  Call
+	__builtin_memcpy instead of memcpy.  Call
+	__builtin_free instead of free.
+	* gcc.c-torture/compile/pr31953.c (toggle_hexedit_mode):
+	Add missing void return type.
+	* gcc.c-torture/compile/pr32372.c (MPV_encode_init): Add
+	missing void return type.
+	* gcc.c-torture/compile/pr32355.c (sigemptyset): Declare.
+	(doSignalsSetup): Add missing void return type.
+	* gcc.c-torture/compile/pr32453.c (__assert_fail): Declare.
+	* gcc.c-torture/compile/pr32571.c (mthca_is_memfree)
+	(mthca_arbel_fmr_unmap, mthca_tavor_fmr_unmap)
+	(mthca_unmap_fmr): Declare.
+	* gcc.c-torture/compile/pr32584.c (sortpin): Add missing
+	void types.
+	* gcc.c-torture/compile/pr32919.c (read_int, _itoa_word)
+	(__strnlen): Declare.
+	* gcc.c-torture/compile/pr33173.c (test_dir_format): Add
+	missing void return type.  Add missing int types.
+	* gcc.c-torture/compile/pr33855.c (cabsl): Declare.
+	* gcc.c-torture/compile/pr34334.c (__strsep_1c)
+	(__strsep_2c): Add missing void return type.
+	* gcc.c-torture/compile/pr35006.c (grub_putchar)
+	(cl_set_pos, cl_print, grub_memmove, cl_delete): Declare.
+	(grub_cmdline_get): Add missing void return type.
+	* gcc.c-torture/compile/pr35595.c (__kernel_sinf):
+	Declare.
+	* gcc.c-torture/compile/pr35869.c (f): Add missing void
+	return type.
+	* gcc.c-torture/compile/pr36172.c (FcCharSetFreeze): Add
+	missing return value.
+	* gcc.c-torture/compile/pr36238.c (lshift_s_s): Declare.
+	* gcc.c-torture/compile/pr37207.c (func_81, func_98):
+	Declare.
+	* gcc.c-torture/compile/pr37258.c (mod_rhs, lshift_s_s)
+	(func_112, func_23): Declare.
+	* gcc.c-torture/compile/pr37305.c (safe_mod_u_u): Declare.
+	* gcc.c-torture/compile/pr37327.c (func_93, func_59)
+	(func_124, func_117, safe_add_uint64_t_u_u)
+	(safe_mul_int32_t_s_s): Declare.
+	* gcc.c-torture/compile/pr37387.c (FuncMakeConsequencesPres):
+	Call __builtin_abort instead of ErrorQuit.
+	* gcc.c-torture/compile/pr37432.c (print_wkb_bytes): Declare.
+	* gcc.c-torture/compile/pr37713.c (sdp_seq_alloc): Declare.
+	* gcc.c-torture/compile/pr39886.c (func): Declare.
+	* gcc.c-torture/compile/pr39941.c (stop): Declare.
+	* gcc.c-torture/compile/pr41016.c (CompareRNAStructures):
+	Call __builtin_abort instead of Die.
+	* gcc.c-torture/compile/pr42632.c (___pskb_trim): Add
+	forward declaration.
+	* gcc.c-torture/compile/pr49710.c (baz): Add forward
+	declaration and missing void types.
+	(bar): Add missing void type.
+	* gcc.c-torture/compile/pr52437.c (fn2): Declare.
+	* gcc.c-torture/compile/pr57441.c (func_1): Add missing void
+	return type.
+	* gcc.c-torture/compile/pr87110.c (struct d): Add missing
+	semicolon.
+	(g, h): Define as int.
+	(i): Add missing void types.
+	* gcc.c-torture/compile/pr87468.c (a): Define as int.
+	(e, f): Declare.
+	(b): Add missing void types.
+	* gcc.c-torture/execute/pr79043.c (ptr2): Use cast in
+	initializer.
+	(typepun): Add missing void return type.
+	(main): Add missing int return type and missing void type.
+	* gcc.dg/pr100349.c (b): Add missing void return type.
+	* gcc.dg/pr106189.c (T): Declare.
+	* gcc.dg/pr110777.c (_setjmp): Declare
+	* gcc.dg/pr45506.c (dynvec, relative_relocp, atexit): Declare.
+	(fini_array): Cast result of relative_relocp from int to int *.
+	* gcc.dg/pr97359.c: Compile with -Wno-pointer-to-int-cast.
+	(b): Cast point to int to avoid int-conversion warning.
+	* gcc.dg/uninit-pr78548.c: Call __builtin_printf instead
+	of printf.
+	* gcc.dg/torture/pr39829.c (f): Declare.
+	* gcc.dg/torture/pr44977.c (int329): Cast bar from pointer
+	to short.
+	* gcc.dg/torture/pr53703.c (ifa_sa_len): Declare.
+	(usagi_getifaddrs): Call __builtin_memset instead of memset
+	and __builtin_memcmp instead of memcmp.
+	* gcc.dg/torture/pr68625.c (z9): Explicitly cast
+	pointers to int.
+	* gcc.dg/torture/pr55964.c (f): Cast q to the expected type.
+	* gcc.dg/torture/pr70623.c (h9): Fix pointer cast in assignment
+	of av.
+	* gcc.dg/torture/pr81118.c (c): Return zero instead of
+	nothing.
+	* gcc.dg/torture/pr81510.c (e): Add cast from int to pointer.
+	* gcc.dg/torture/pr99694.c (d): Add missing casts between
+	pointers and integers.
+	* gcc.dg/tree-ssa/pr102563.c: Define as void (*) (void).
+	(_bdf_parse_glyphs_p): Define with prototype.
+	* gcc.dg/tree-ssa/pr92085-1.c (di): Add cast to initialization
+	of fq.
+	* gcc.dg/tree-ssa/pr92085-2.c (c1): Add casts to
+	initializations of th, lq.
+	* gcc.dg/tree-ssa/reassoc-43.c
+	(c_parser_next_token_is_keyword, chainon)
+	(c_parser_attributes): Declare.
+	* gcc.dg/tree-ssa/split-path-4.c (powi_lookup_cost): Declare.
+	(powi_cost): Add missing void return type.
+	* gcc.dg/tree-ssa/split-path-6.c (strtosichar)
+	(ichartosstr, treeinsert, stop, __srget_r): Declare
+	(givehelp, oof, lookharder): Convert to prototypes.
+	* gcc.target/i386/pr71621-1.c (y8): Cast to expected
+	pointer type in assignment of t6.
+	* gcc.target/i386/pr79571.c (g): Add missing int type.
+	(j): Add missing void types and pointer cast.
+	* gcc.target/i386/pr87246.c (s2): Add cast from integer
+	to pointer type.
+	* gcc.target/i386/pr87759.c (rc): Cast to the expected
+	pointer time in initialization of ar.
+	* gcc.target/i386/pr99454.c (tg3_start_xmit): Add
+	missing cast from int to int *.
+
+2023-11-13  Florian Weimer  <fweimer@redhat.com>
+
+	* c-c++-common/Wduplicated-branches-11.c: Compile with
+	-fpermissive.
+	* c-c++-common/Wduplicated-branches-12.c: Likewise.
+	* c-c++-common/builtins.c: Likewise.
+	* c-c++-common/pointer-to-fn1.c: Likewise.
+	* gcc.c-torture/compile/20010320-1.c: Likewise.
+	* gcc.c-torture/compile/20050105-1.c: Likewise.
+	* gcc.c-torture/compile/20080704-1.c: Likewise.
+	* gcc.c-torture/compile/20080910-1.c: Likewise.
+	* gcc.c-torture/compile/20090917-1.c: Likewise.
+	* gcc.c-torture/compile/20100915-1.c: Likewise.
+	* gcc.c-torture/compile/20101216-1.c: Likewise.
+	* gcc.c-torture/compile/20121027-1.c: Likewise.
+	* gcc.c-torture/compile/20180605-1.c: Likewise.
+	* gcc.c-torture/compile/950816-2.c: Likewise.
+	* gcc.c-torture/compile/dse.c: Likewise.
+	* gcc.c-torture/compile/pr100576.c: Likewise.
+	* gcc.c-torture/compile/pr17408.c: Likewise.
+	* gcc.c-torture/compile/pr19121.c: Likewise.
+	* gcc.c-torture/compile/pr26213.c: Likewise.
+	* gcc.c-torture/compile/pr27341-2.c: Likewise.
+	* gcc.c-torture/compile/pr28776-2.c: Likewise.
+	* gcc.c-torture/compile/pr33133.c: Likewise.
+	* gcc.c-torture/compile/pr34091.c: Likewise.
+	* gcc.c-torture/compile/pr36154.c: Likewise.
+	* gcc.c-torture/compile/pr37381.c: Likewise.
+	* gcc.c-torture/compile/pr38360.c: Likewise.
+	* gcc.c-torture/compile/pr40291.c: Likewise.
+	* gcc.c-torture/compile/pr41182-1.c: Likewise.
+	* gcc.c-torture/compile/pr43635.c: Likewise.
+	* gcc.c-torture/compile/pr44043.c: Likewise.
+	* gcc.c-torture/compile/pr44063.c: Likewise.
+	* gcc.c-torture/compile/pr44246.c: Likewise.
+	* gcc.c-torture/compile/pr45535.c: Likewise.
+	* gcc.c-torture/compile/pr46934.c: Likewise.
+	* gcc.c-torture/compile/pr47428.c: Likewise.
+	* gcc.c-torture/compile/pr49145.c: Likewise.
+	* gcc.c-torture/compile/pr49206.c: Likewise.
+	* gcc.c-torture/compile/pr51694.c: Likewise.
+	* gcc.c-torture/compile/pr53886.c: Likewise.
+	* gcc.c-torture/compile/pr65241.c: Likewise.
+	* gcc.c-torture/compile/pr72802.c: Likewise.
+	* gcc.c-torture/compile/pr81360.c: Likewise.
+	* gcc.c-torture/compile/pr82052.c: Likewise.
+	* gcc.c-torture/compile/pr90275-2.c: Likewise.
+	* gcc.c-torture/compile/pr90275.c: Likewise.
+	* gcc.c-torture/compile/pr96796.c: Likewise.
+	* gcc.c-torture/compile/regs-arg-size.c: Likewise.
+	* gcc.c-torture/compile/udivmod4.c: Likewise.
+	* gcc.c-torture/compile/widechar-1.c: Likewise.
+	* gcc.c-torture/execute/20000412-3.c: Likewise.
+	* gcc.c-torture/execute/20010605-2.c: Likewise.
+	* gcc.c-torture/execute/20020314-1.c: Likewise.
+	* gcc.c-torture/execute/20020819-1.c: Likewise.
+	* gcc.c-torture/execute/20031211-2.c: Likewise.
+	* gcc.c-torture/execute/20040223-1.c: Likewise.
+	* gcc.c-torture/execute/20041019-1.c: Likewise.
+	* gcc.c-torture/execute/20120427-1.c: Likewise.
+	* gcc.c-torture/execute/20120427-2.c: Likewise.
+	* gcc.c-torture/execute/920908-2.c: Likewise.
+	* gcc.c-torture/execute/921110-1.c: Likewise.
+	* gcc.c-torture/execute/930111-1.c: Likewise.
+	* gcc.c-torture/execute/930208-1.c: Likewise.
+	* gcc.c-torture/execute/930702-1.c: Likewise.
+	* gcc.c-torture/execute/930818-1.c: Likewise.
+	* gcc.c-torture/execute/931017-1.c: Likewise.
+	* gcc.c-torture/execute/931018-1.c: Likewise.
+	* gcc.c-torture/execute/931208-1.c: Likewise.
+	* gcc.c-torture/execute/941101-1.c: Likewise.
+	* gcc.c-torture/execute/941110-1.c: Likewise.
+	* gcc.c-torture/execute/950322-1.c: Likewise.
+	* gcc.c-torture/execute/950426-1.c: Likewise.
+	* gcc.c-torture/execute/950512-1.c: Likewise.
+	* gcc.c-torture/execute/950621-1.c: Likewise.
+	* gcc.c-torture/execute/960218-1.c: Likewise.
+	* gcc.c-torture/execute/960402-1.c: Likewise.
+	* gcc.c-torture/execute/cmpsf-1.c: Likewise.
+	* gcc.c-torture/execute/cmpsi-1.c: Likewise.
+	* gcc.c-torture/execute/cmpsi-2.c: Likewise.
+	* gcc.c-torture/execute/divmod-1.c: Likewise.
+	* gcc.c-torture/execute/pr22061-1.c: Likewise.
+	* gcc.c-torture/execute/pr55875.c: Likewise.
+	* gcc.dg/20050629-1.c: Likewise.
+	* gcc.dg/20080615-1.c: Likewise.
+	* gcc.dg/Walloca-14.c: Likewise.
+	* gcc.dg/Wbuiltin-declaration-mismatch-3.c: Likewise.
+	* gcc.dg/Wbuiltin-declaration-mismatch-9.c: Likewise.
+	* gcc.dg/Wdouble-promotion.c: Likewise.
+	* gcc.dg/Wrestrict-5.c: Likewise.
+	* gcc.dg/Wstringop-overflow-13.c: Likewise.
+	* gcc.dg/analyzer/fd-bind-pr107783.c: Likewise.
+	* gcc.dg/array-5.c: Likewise.
+	* gcc.dg/asan/pr56417.c: Likewise.
+	* gcc.dg/attr-access-read-only.c: Likewise.
+	* gcc.dg/attr-access-read-write.c: Likewise.
+	* gcc.dg/attr-access-write-only.c: Likewise.
+	* gcc.dg/bitint-36.c: Likewise.
+	* gcc.dg/builtin-bswap-10.c: Likewise.
+	* gcc.dg/cleanup-1.c: Likewise.
+	* gcc.dg/cpp/pr60014-1.c: Likewise.
+	* gcc.dg/cpp/pr60014-2.c: Likewise.
+	* gcc.dg/cpp/pr60014-3.c: Likewise.
+	* gcc.dg/ipa/ipa-bit-cp-1.c: Likewise.
+	* gcc.dg/ipa/ipa-bit-cp-2.c: Likewise.
+	* gcc.dg/ipa/ipa-bit-cp.c: Likewise.
+	* gcc.dg/ipa/pr105639.c: Likewise.
+	* gcc.dg/ipa/pr71981.c: Likewise.
+	* gcc.dg/lto/20081109_0.c: Likewise.
+	* gcc.dg/lto/pr54702_1.c: Likewise.
+	* gcc.dg/lto/pr55525_0.c: Likewise.
+	* gcc.dg/noncompile/20020213-1.c:: Likewise.
+	* gcc.dg/noncompile/pr71426.c: Likewise.
+	* gcc.dg/noncompile/undeclared-1.c: Likewise.
+	* gcc.dg/overflow-warn-2.c: Likewise.
+	* gcc.dg/pr100142.c: Likewise.
+	* gcc.dg/pr100790.c: Likewise.
+	* gcc.dg/pr100791.c: Likewise.
+	* gcc.dg/pr103093.c: Likewise.
+	* gcc.dg/pr105140.c: Likewise.
+	* gcc.dg/pr105250.c: Likewise.
+	* gcc.dg/pr105853.c: Likewise.
+	* gcc.dg/pr105856.c: Likewise.
+	* gcc.dg/pr26865.c: Likewise.
+	* gcc.dg/pr40989.c: Likewise.
+	* gcc.dg/pr42715.c: Likewise.
+	* gcc.dg/pr44971.c: Likewise.
+	* gcc.dg/pr46571.c: Likewise.
+	* gcc.dg/pr54363.c: Likewise.
+	* gcc.dg/pr56724-2.c: Likewise.
+	* gcc.dg/pr59630.c: Likewise.
+	* gcc.dg/pr67043.c: Likewise.
+	* gcc.dg/pr67730-1.c: Likewise.
+	* gcc.dg/pr67730-2.c: Likewise.
+	* gcc.dg/pr68320.c: Likewise.
+	* gcc.dg/pr69156.c: Likewise.
+	* gcc.dg/pr69824.c: Likewise.
+	* gcc.dg/pr70174.c: Likewise.
+	* gcc.dg/pr70281.c: Likewise.
+	* gcc.dg/pr77862.c: Likewise.
+	* gcc.dg/pr82765.c: Likewise.
+	* gcc.dg/pr83852.c: Likewise.
+	* gcc.dg/pr84206.c: Likewise.
+	* gcc.dg/pr85164-1.c: Likewise.
+	* gcc.dg/pr85955.c: Likewise.
+	* gcc.dg/pr86271.c: Likewise.
+	* gcc.dg/pr86928.c: Likewise.
+	* gcc.dg/pr99122-1.c: Likewise.
+	* gcc.dg/pr99136.c: Likewise.
+	* gcc.dg/redecl-19.c: Likewise.
+	* gcc.dg/redecl-24.c: Likewise.
+	* gcc.dg/torture/pr39204.c: Likewise.
+	* gcc.dg/torture/pr57676.c: Likewise.
+	* gcc.dg/torture/pr67222.c: Likewise.
+	* gcc.dg/torture/pr77677-2.c: Likewise.
+	* gcc.dg/torture/pr79125.c: Likewise.
+	* gcc.dg/torture/pr94479.c: Likewise.
+	* gcc.dg/tree-ssa/20070815.c:  Likewise.
+	* gcc.dg/tree-ssa/builtin-sprintf-29.c: Likewise.
+	* gcc.dg/tree-ssa/builtins-folding-gimple-ub.c: Likewise.
+	* gcc.dg/tree-ssa/pr22051-2.c: Likewise.
+	* gcc.dg/tree-ssa/ssa-dse-10.c: Likewise.
+	* gcc.target/aarch64/pr60697.c: Likewise.
+	* gcc.target/aarch64/pr87305.c: Likewise.
+	* gcc.target/aarch64/sve/pr96357.c: Likewise.
+	* gcc.target/i386/attr-nocf-check-1a.c: Likewise.
+	* gcc.target/i386/attr-nocf-check-3a.c: Likewise.
+	* gcc.target/i386/avx512bf16-pr108881.c: Likewise.
+	* gcc.target/i386/cet-notrack-2a.c: Likewise.
+	* gcc.target/i386/cet-notrack-2b.c: Likewise.
+	* gcc.target/i386/cet-notrack-5b.c: Likewise.
+	* gcc.target/i386/cet-notrack-6a.c: Likewise.
+	* gcc.target/i386/cet-notrack-6b.c: Likewise.
+	* gcc.target/i386/pr70325.c: Likewise.
+	* gcc.target/i386/pr70858.c: Likewise.
+	* gcc.target/i386/pr83488.c: Likewise.
+	* gcc.target/i386/pr85511.c: Likewise.
+	* gcc.target/i386/pr87572.c: Likewise.
+	* gcc.target/i386/pr88195.c: Likewise.
+
+2023-11-13  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/111967
+	* gcc.dg/tree-ssa/pr111967.c: New test.
+
+2023-11-13  Xi Ruoyao  <xry111@xry111.site>
+
+	PR target/112476
+	* gcc.target/loongarch/pr112476-1.c: New test.
+	* gcc.target/loongarch/pr112476-2.c: New test.
+
+2023-11-13  Pan Li  <pan2.li@intel.com>
+
+	* gcc.target/riscv/rvv/base/float-point-dynamic-frm-54.c: Adjust
+	the asm checker.
+	* gcc.target/riscv/rvv/base/float-point-dynamic-frm-57.c: Ditto.
+	* gcc.target/riscv/rvv/base/float-point-dynamic-frm-58.c: Ditto.
+
+2023-11-13  Pan Li  <pan2.li@intel.com>
+
+	* gcc.target/riscv/rvv/autovec/unop/math-llrintf16-0.c: New test.
+	* gcc.target/riscv/rvv/autovec/unop/math-llroundf16-0.c: New test.
+	* gcc.target/riscv/rvv/autovec/unop/math-lrintf16-rv32-0.c: New test.
+	* gcc.target/riscv/rvv/autovec/unop/math-lrintf16-rv64-0.c: New test.
+	* gcc.target/riscv/rvv/autovec/unop/math-lroundf16-rv32-0.c: New test.
+	* gcc.target/riscv/rvv/autovec/unop/math-lroundf16-rv64-0.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/math-llrintf16-0.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/math-llroundf16-0.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/math-lrintf16-rv32-0.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/math-lrintf16-rv64-0.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/math-lroundf16-rv32-0.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/math-lroundf16-rv64-0.c: New test.
+
+2023-11-11  Jakub Jelinek  <jakub@redhat.com>
+
+	PR middle-end/112430
+	* gcc.dg/pr112430.c: New test.
+
+2023-11-11  Martin Uecker  <uecker@tugraz.at>
+
+	PR c/110815
+	PR c/112428
+	* gcc.dg/Wnonnull-8.c: Adapt test.
+	* gcc.dg/Wnonnull-9.c: New test.
+
+2023-11-11  Joern Rennecke  <joern.rennecke@embecosm.com>
+
+	* lib/scanasm.exp (scan-assembler-times): Disregard LTO sections.
+	(scan-assembler-dem, scan-assembler-dem-not): Likewise.
+	(dg-scan): Likewise, if name starts with scan-assembler.
+	(scan-raw-assembler): New proc.
+	* gcc.dg/pr61868.c: Use scan-raw-assembler.
+	* gcc.dg/scantest-lto.c: New test.
+
+2023-11-11  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	PR target/112469
+	* gcc.target/riscv/rvv/autovec/pr112469.c: New test.
+
+2023-11-11  Marek Polacek  <polacek@redhat.com>
+
+	* g++.dg/cpp0x/lambda/lambda-decltype3.C: Check __cpp_init_captures.
+
+2023-11-10  Patrick O'Neill  <patrick@rivosinc.com>
+
+	* g++.dg/vect/pr102788.cc: Remove dg-do run directive.
+
+2023-11-10  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gnat.dg/opt103.ads, gnat.dg/opt103.adb: New test.
+
+2023-11-10  Vladimir N. Makarov  <vmakarov@redhat.com>
+
+	PR target/112337
+	* gcc.target/arm/pr112337.c: New.
+
+2023-11-10  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/79620
+	* g++.dg/cpp0x/lambda/lambda-decltype3.C: New test.
+
+2023-11-10  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/79378
+	PR c++/96917
+	* g++.dg/cpp1y/decltype-auto7.C: New test.
+	* g++.dg/cpp1y/lambda-init20.C: New test.
+
+2023-11-10  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	PR tree-optimization/112438
+	* gcc.target/riscv/rvv/autovec/pr112438.c: New test.
+
+2023-11-10  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.target/riscv/rvv/autovec/vls/def.h: Add combine test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/combine-1.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-1.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-2.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-3.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-4.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-5.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-6.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/combine-7.c: New test.
+
+2023-11-10  Robin Dapp  <rdapp@ventanamicro.com>
+
+	* gcc.target/riscv/rvv/autovec/binop/vmul-zvfh-run.c: Adjust.
+	* gcc.target/riscv/rvv/autovec/binop/vsub-zvfh-run.c: Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_narrow_shift_run-3.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/pr111401.c: Ditto.
+	* gcc.target/riscv/rvv/autovec/conversions/vfcvt-itof-zvfh-run.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/conversions/vfcvt_rtz-zvfh-run.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/conversions/vfncvt-ftoi-zvfh-run.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/conversions/vfncvt-itof-template.h:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/conversions/vfncvt-itof-zvfh-run.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/conversions/vfncvt-zvfh-run.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/conversions/vfwcvt-ftoi-zvfh-run.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/conversions/vfwcvt-itof-zvfh-run.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/conversions/vfwcvt-zvfh-run.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/slp-mask-run-1.c: Ditto.
+	* gcc.target/riscv/rvv/autovec/ternop/ternop_run_zvfh-1.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/ternop/ternop_run_zvfh-10.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/ternop/ternop_run_zvfh-11.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/ternop/ternop_run_zvfh-12.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/ternop/ternop_run_zvfh-2.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/ternop/ternop_run_zvfh-3.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/ternop/ternop_run_zvfh-4.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/ternop/ternop_run_zvfh-5.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/ternop/ternop_run_zvfh-6.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/ternop/ternop_run_zvfh-7.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/ternop/ternop_run_zvfh-8.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/ternop/ternop_run_zvfh-9.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/unop/vfsqrt-run.c: Ditto.
+	* gcc.target/riscv/rvv/autovec/unop/vfsqrt-rv32gcv.c: Ditto.
+	* gcc.target/riscv/rvv/autovec/unop/vfsqrt-rv64gcv.c: Ditto.
+	* gcc.target/riscv/rvv/autovec/unop/vfsqrt-template.h: Ditto.
+	* gcc.target/riscv/rvv/autovec/unop/vfsqrt-zvfh-run.c: Ditto.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/vec_extract-zvfh-run.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/vec_set-zvfh-run.c:
+	Ditto.
+
+2023-11-10  Robin Dapp  <rdapp@ventanamicro.com>
+
+	* gcc.target/i386/pr112464.c: New test.
+
+2023-11-10  Jin Ma  <jinma@linux.alibaba.com>
+
+	* gcc.target/riscv/xtheadmempair-interrupt-fcsr.c: New file.
+
+2023-11-10  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/110221
+	* gfortran.dg/pr110221.f: New testcase.
+
+2023-11-10  Richard Biener  <rguenther@suse.de>
+
+	PR middle-end/112469
+	* gcc.dg/torture/pr112469.c: New testcase.
+
+2023-11-10  Pan Li  <pan2.li@intel.com>
+
+	Revert:
+	2023-11-10  Pan Li  <pan2.li@intel.com>
+
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-same-tail-1.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-same-tail-2.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-same-tail-3.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-same-tail-4.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-same-tail-5.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-same-tail-run-1.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-same-tail-run-2.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-same-tail-run-3.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-same-tail-1.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-same-tail-2.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-same-tail-3.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-same-tail-4.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-same-tail-5.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-same-tail-6.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-same-tail-7.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-same-tail-8.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-same-tail-9.c: New test.
+
+2023-11-10  Pan Li  <pan2.li@intel.com>
+
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-same-tail-1.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-same-tail-2.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-same-tail-3.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-same-tail-4.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-same-tail-5.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-same-tail-run-1.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-same-tail-run-2.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls-vlmax/init-same-tail-run-3.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-same-tail-1.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-same-tail-2.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-same-tail-3.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-same-tail-4.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-same-tail-5.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-same-tail-6.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-same-tail-7.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-same-tail-8.c: New test.
+	* gcc.target/riscv/rvv/autovec/vls/init-same-tail-9.c: New test.
+
+2023-11-10  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.dg/vect/pr97428.c: Add additional compile option for riscv.
+
+2023-11-10  liuhongt  <hongtao.liu@intel.com>
+
+	* g++.target/i386/pr112443.C: New test.
+
+2023-11-10  Jose E. Marchesi  <jose.marchesi@oracle.com>
+
+	* gcc.target/bpf/mulsidi3-zeroextend-pseudoc.c: New test.
+
+2023-11-09  Jose E. Marchesi  <jose.marchesi@oracle.com>
+
+	* gcc.target/bpf/ldxdw.c: Fix regexp with expected result.
+
+2023-11-09  Robin Dapp  <rdapp@ventanamicro.com>
+
+	* gcc.target/riscv/rvv/autovec/binop/fmax_zvfh-1.c: Adjust.
+	* gcc.target/riscv/rvv/autovec/binop/fmax_zvfh_run-1.c: Ditto.
+	* gcc.target/riscv/rvv/autovec/binop/fmin_zvfh-1.c: Ditto.
+	* gcc.target/riscv/rvv/autovec/binop/fmin_zvfh_run-1.c: Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_convert_float2int-1.h:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_convert_float2int-2.h:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_convert_float2int-rv32-1.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_convert_float2int-rv32-2.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_convert_float2int-rv64-1.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_convert_float2int-rv64-2.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_convert_float2int_run-1.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_convert_float2int_run-2.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_convert_int2float_run-1.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_convert_int2float_run-2.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_fmax_zvfh_run-1.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_fmax_zvfh_run-2.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_fmax_zvfh_run-3.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_fmax_zvfh_run-4.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_fmin_zvfh_run-1.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_fmin_zvfh_run-2.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_fmin_zvfh_run-3.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_fmin_zvfh_run-4.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_sqrt_run-zvfh-1.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_sqrt_run-zvfh-2.c:
+	Ditto.
+	* gcc.target/riscv/rvv/autovec/reduc/reduc_zvfh-10.c: Ditto.
+	* gcc.target/riscv/rvv/autovec/reduc/reduc_zvfh_run-10.c: Ditto.
+	* gcc.target/riscv/rvv/autovec/cond/cond_convert_float2int_zvfh-1.h: New test.
+	* gcc.target/riscv/rvv/autovec/cond/cond_convert_float2int_zvfh-2.h: New test.
+	* gcc.target/riscv/rvv/autovec/cond/cond_convert_float2int_zvfh-rv32-1.c: New test.
+	* gcc.target/riscv/rvv/autovec/cond/cond_convert_float2int_zvfh-rv32-2.c: New test.
+	* gcc.target/riscv/rvv/autovec/cond/cond_convert_float2int_zvfh-rv64-1.c: New test.
+	* gcc.target/riscv/rvv/autovec/cond/cond_convert_float2int_zvfh-rv64-2.c: New test.
+	* gcc.target/riscv/rvv/autovec/cond/cond_convert_float2int_zvfh_run-1.c: New test.
+	* gcc.target/riscv/rvv/autovec/cond/cond_convert_float2int_zvfh_run-2.c: New test.
+
+2023-11-09  Alexandre Oliva  <oliva@adacore.com>
+
+	* gcc.dg/tree-ssa/scev-3.c: xfail on ia32.
+	* gcc.dg/tree-ssa/scev-5.c: Likewise.
+
+2023-11-09  Tamar Christina  <tamar.christina@arm.com>
+
+	PR tree-optimization/109154
+	* gcc.target/aarch64/sve/fneg-abs_5.c: New test.
+
+2023-11-09  Tamar Christina  <tamar.christina@arm.com>
+
+	PR tree-optimization/109154
+	* gcc.target/aarch64/sve/fneg-abs_1.c: Updated.
+	* gcc.target/aarch64/sve/fneg-abs_2.c: Updated.
+	* gcc.target/aarch64/sve/fneg-abs_4.c: Updated.
+
+2023-11-09  Tamar Christina  <tamar.christina@arm.com>
+
+	PR tree-optimization/109154
+	* gcc.target/aarch64/fneg-abs_2.c: Updated.
+	* gcc.target/aarch64/fneg-abs_4.c: Updated.
+	* gcc.target/aarch64/dbl_mov_immediate_1.c: Updated.
+
+2023-11-09  Tamar Christina  <tamar.christina@arm.com>
+
+	PR tree-optimization/109154
+	* gcc.target/aarch64/fneg-abs_1.c: Updated.
+	* gcc.target/aarch64/fneg-abs_2.c: Updated.
+	* gcc.target/aarch64/fneg-abs_4.c: Updated.
+	* gcc.target/aarch64/dbl_mov_immediate_1.c: Updated.
+
+2023-11-09  Tamar Christina  <tamar.christina@arm.com>
+
+	PR tree-optimization/109154
+	* gcc.dg/fold-copysign-1.c: Updated.
+	* gcc.dg/pr55152-2.c: Updated.
+	* gcc.dg/tree-ssa/abs-4.c: Updated.
+	* gcc.dg/tree-ssa/backprop-6.c: Updated.
+	* gcc.dg/tree-ssa/copy-sign-2.c: Updated.
+	* gcc.dg/tree-ssa/mult-abs-2.c: Updated.
+	* gcc.target/aarch64/fneg-abs_1.c: New test.
+	* gcc.target/aarch64/fneg-abs_2.c: New test.
+	* gcc.target/aarch64/fneg-abs_3.c: New test.
+	* gcc.target/aarch64/fneg-abs_4.c: New test.
+	* gcc.target/aarch64/sve/fneg-abs_1.c: New test.
+	* gcc.target/aarch64/sve/fneg-abs_2.c: New test.
+	* gcc.target/aarch64/sve/fneg-abs_3.c: New test.
+	* gcc.target/aarch64/sve/fneg-abs_4.c: New test.
+
+2023-11-09  Simon Wright  <simon@pushface.org>
+
+	PR ada/111813
+	* gnat.dg/calendar_format_value.adb: New test.
+
+2023-11-09  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	PR target/112450
+	* gcc.target/riscv/rvv/autovec/pr112450.c: New test.
+
+2023-11-09  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/112444
+	* gcc.dg/torture/pr112444.c: New testcase.
+
+2023-11-09  YunQiang Su  <yunqiang.su@cipunited.com>
+
+	* gcc.target/mips/fabs-nan2008.c: New test.
+	* gcc.target/mips/fabsf-nan2008.c: New test.
+
+2023-11-09  Florian Weimer  <fweimer@redhat.com>
+
+	* gcc.target/x86_64/abi/avx/avx-check.h (main): Call
+	__builtin_printf instead of printf.
+	* gcc.target/x86_64/abi/avx/test_passing_m256.c
+	(fun_check_passing_m256_8_values): Add missing void return
+	type.
+	* gcc.target/x86_64/abi/avx512f/avx512f-check.h (main): Call
+	__builtin_printf instead of printf.
+	* gcc.target/x86_64/abi/avx512f/test_passing_m512.c
+	(fun_check_passing_m512_8_values): Add missing void return
+	type.
+	* gcc.target/x86_64/abi/bf16/bf16-check.h (main): Call
+	__builtin_printf instead of printf.
+	* gcc.target/x86_64/abi/bf16/m256bf16/bf16-ymm-check.h (main):
+	Likewise.
+	* gcc.target/x86_64/abi/bf16/m256bf16/test_passing_m256.c
+	(fun_check_passing_m256bf16_8_values): Add missing void
+	return type.
+	* gcc.target/x86_64/abi/bf16/m512bf16/bf16-zmm-check.h (main):
+	Call __builtin_printf instead of printf.
+	* gcc.target/x86_64/abi/bf16/m512bf16/test_passing_m512.c
+	(fun_check_passing_m512bf16_8_values): Add missign void
+	return type.
+
+2023-11-09  Florian Weimer  <fweimer@redhat.com>
+
+	* gcc.dg/Wreturn-mismatch-1.c: New.
+	* gcc.dg/Wreturn-mismatch-2.c: New.
+	* gcc.dg/Wreturn-mismatch-3.c: New.
+	* gcc.dg/Wreturn-mismatch-4.c: New.
+	* gcc.dg/Wreturn-mismatch-5.c: New.
+	* gcc.dg/Wreturn-mismatch-6.c: New.
+	* gcc.dg/noncompile/pr55976-1.c: Change -Werror=return-type
+	to -Werror=return-mismatch.
+	* gcc.dg/noncompile/pr55976-2.c: Change -Wreturn-type
+	to -Wreturn-mismatch.
+
+2023-11-09  Florian Weimer  <fweimer@redhat.com>
+
+	* gcc.dg/Wmissing-parameter-type.c: Build with -std=gnu89
+	to trigger the -Wmissing-parameter-type warning
+	and not the default -Wimplicit warning.  Also match
+	against -Wmissing-parameter-type.
+	* gcc.dg/Wmissing-parameter-type-Wextra.c: Likewise.
+
+2023-11-09  Stefan Schulze Frielinghaus  <stefansf@linux.ibm.com>
+
+	* gcc.target/s390/zvector/vec-reve-load-halfword-z14.c: Remove
+	vperm and substitude by vpdi et al.
+	* gcc.target/s390/zvector/vec-reve-load-halfword.c: Likewise.
+	* gcc.target/s390/vector/reverse-elements-1.c: New test.
+	* gcc.target/s390/vector/reverse-elements-2.c: New test.
+	* gcc.target/s390/vector/reverse-elements-3.c: New test.
+	* gcc.target/s390/vector/reverse-elements-4.c: New test.
+	* gcc.target/s390/vector/reverse-elements-5.c: New test.
+	* gcc.target/s390/vector/reverse-elements-6.c: New test.
+	* gcc.target/s390/vector/reverse-elements-7.c: New test.
+
+2023-11-09  Jakub Jelinek  <jakub@redhat.com>
+
+	PR libgcc/65833
+	* gcc.dg/dfp/int128-1.c: New test.
+	* gcc.dg/dfp/int128-2.c: New test.
+	* gcc.dg/dfp/int128-3.c: New test.
+	* gcc.dg/dfp/int128-4.c: New test.
+
+2023-11-09  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c/112339
+	* c-c++-common/ubsan/Wno-attributes-1.c: New test.
+
+2023-11-09  Jin Ma  <jinma@linux.alibaba.com>
+
+	* gcc.target/riscv/xtheadfmemidx-uindex-zbb.c: New test.
+
+2023-11-09  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul-ice-1.c: New test.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul-ice-2.c: New test.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul-ice-3.c: New test.
+
+2023-11-09  Alexandre Oliva  <oliva@adacore.com>
+
+	* g++.dg/gomp/declare-target-3.C: Adjust for 32-bit targets.
+
+2023-11-09  Alexandre Oliva  <oliva@adacore.com>
+
+	* g++.dg/pr58245-1.C: Disable PIC/PIE.
+
+2023-11-09  Juzhe-Zhong  <juzhe.zhong@rivai.ai>
+
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul-mixed-1.c: Adapt test.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-1.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-2.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-3.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-4.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-5.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-6.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-7.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-1.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-2.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-3.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-4.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-5.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-6.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-7.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-1.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-2.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-3.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-4.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-5.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-6.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-7.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-8.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-9.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-1.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-10.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-2.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-3.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-4.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-5.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-6.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-7.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-8.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-9.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/no-dynamic-lmul-1.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/pr111848.c: Ditto.
+	* gcc.dg/vect/costmodel/riscv/rvv/rvv-costmodel-vect.exp: Run all tests.
+
 2023-11-08  Uros Bizjak  <ubizjak@gmail.com>
 
 	PR target/82524
diff --git a/gcc/testsuite/c-c++-common/analyzer/attr-tainted_args-1.c b/gcc/testsuite/c-c++-common/analyzer/attr-tainted_args-1.c
index 0ff3446..3525e84 100644
--- a/gcc/testsuite/c-c++-common/analyzer/attr-tainted_args-1.c
+++ b/gcc/testsuite/c-c++-common/analyzer/attr-tainted_args-1.c
@@ -1,6 +1,3 @@
-// TODO: remove need for this option
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 #include "../../gcc.dg/analyzer/analyzer-decls.h"
 
 struct arg_buf
diff --git a/gcc/testsuite/c-c++-common/analyzer/fread-1.c b/gcc/testsuite/c-c++-common/analyzer/fread-1.c
index 593cb7f..467467e 100644
--- a/gcc/testsuite/c-c++-common/analyzer/fread-1.c
+++ b/gcc/testsuite/c-c++-common/analyzer/fread-1.c
@@ -1,5 +1,3 @@
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 typedef __SIZE_TYPE__ size_t;
 
 extern size_t fread (void *, size_t, size_t, void *);
diff --git a/gcc/testsuite/c-c++-common/analyzer/gzio-2.c b/gcc/testsuite/c-c++-common/analyzer/gzio-2.c
index 855ecc8..a0dd112 100644
--- a/gcc/testsuite/c-c++-common/analyzer/gzio-2.c
+++ b/gcc/testsuite/c-c++-common/analyzer/gzio-2.c
@@ -6,6 +6,6 @@ void gzseek (long offset, int whence)
     offset -= 1;
   if (offset < 0)
     return;
-  while (offset > 0) {
+  while (offset > 0) { /* { dg-warning "infinite loop" "" { xfail *-*-* } } */
   }
 }
diff --git a/gcc/testsuite/c-c++-common/analyzer/infinite-loop-2.c b/gcc/testsuite/c-c++-common/analyzer/infinite-loop-2.c
new file mode 100644
index 0000000..f2825d6
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/analyzer/infinite-loop-2.c
@@ -0,0 +1,34 @@
+extern int do_stuff (void);
+
+/* Various misleading "while" loops that look like do-whiles due
+   to proximity to another clause, but are actually empty.  */
+
+void not_a_do_while_1 (int flag)
+{
+  if (flag) {
+    do_stuff ();
+    flag = 0;
+  } while (flag); // TODO: should we complain here?
+}
+
+void not_a_do_while_2 (int flag)
+{
+  if (!flag) {
+    do_stuff ();
+    flag = 1;
+  } while (flag); // TODO: should we complain here?
+}
+
+void not_a_do_while_3 (int flag)
+{
+  while (!flag) {
+    flag = do_stuff ();
+  } while (flag); // TODO: should we complain here? 
+}
+
+void not_a_do_while_4 (int flag)
+{
+  while (flag) {
+    flag = do_stuff ();
+  } while (flag); // TODO: should we complain here? 
+}
diff --git a/gcc/testsuite/c-c++-common/analyzer/infinite-loop-4.c b/gcc/testsuite/c-c++-common/analyzer/infinite-loop-4.c
new file mode 100644
index 0000000..032f7fd
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/analyzer/infinite-loop-4.c
@@ -0,0 +1,71 @@
+/* Various tests for loops that aren't infinite, strictly speaking,
+   but look bogus.  */
+
+// TODO: should we complain about these?
+
+extern int maybe_useful_work ();
+
+/* Loop iteration going the wrong way, with a signed iterator
+
+   Not infinite, as will eventually overflow and bail out, but probably
+   not what the user intended.  */
+
+void test_wrong_way_signed_1 (int n)
+{
+  for (int i = 0; i < n; i--)
+    {
+    }
+}
+
+void test_wrong_way_signed_2 (int n)
+{
+  for (int i = 0; i < n; i--)
+    maybe_useful_work ();
+}
+
+int test_wrong_way_signed_3 (int *arr, int n)
+{
+  int sum = 0;
+  for (int i = 0; i < n; i--)
+    sum += arr[i];
+  return sum;
+}
+
+
+/* As above, but with an unsigned iterator.
+
+   Not infinite, as will immediately overflow and bail out, but probably
+   not what the user intended.  */
+
+void test_wrong_way_unsigned_1 (unsigned n)
+{
+  for (unsigned i = 0; i < n; i--)
+    {
+    }
+}
+
+void test_wrong_way_unsigned_2 (unsigned n)
+{
+  for (unsigned i = 0; i < n; i--)
+    maybe_useful_work ();
+}
+
+int test_wrong_way_unsigned_3 (int *arr, unsigned n)
+{
+  int sum = 0;
+  for (unsigned i = 0; i < n; i--)
+    sum += arr[i];
+  return sum;
+}
+
+/* BUG: "n" never changes, so loop is never entered.  */
+
+void test_1 (void)
+{
+  int n = 0;
+
+  /* [...snip...]  */
+
+  for (int i = 0; i < n; i++)
+    maybe_useful_work ();
+}
diff --git a/gcc/testsuite/c-c++-common/analyzer/infinite-loop-crc32c.c b/gcc/testsuite/c-c++-common/analyzer/infinite-loop-crc32c.c
new file mode 100644
index 0000000..01d4e4d
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/analyzer/infinite-loop-crc32c.c
@@ -0,0 +1,14 @@
+/* Based on qemu's util/crc32c.c, in turn based on the
+   Linux kernel cryptographic crc32c module.  */
+
+#include <stdint.h>
+
+extern const uint32_t crc32c_table[256];
+
+uint32_t crc32c(uint32_t crc, const uint8_t *data, unsigned int length)
+{
+    while (length--) {  /* { dg-bogus "infinite loop" } */
+        crc = crc32c_table[(crc ^ *data++) & 0xFFL] ^ (crc >> 8);
+    }
+    return crc^0xffffffff;
+}
diff --git a/gcc/testsuite/c-c++-common/analyzer/infinite-loop-doom-d_main-IdentifyVersion.c b/gcc/testsuite/c-c++-common/analyzer/infinite-loop-doom-d_main-IdentifyVersion.c
new file mode 100644
index 0000000..166d6da
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/analyzer/infinite-loop-doom-d_main-IdentifyVersion.c
@@ -0,0 +1,26 @@
+/* Reduced from a -Wanalyzer-infinite-loop false positive seen in Doom's
+   d_main.c, which is under the GPLv2 or later.  */
+
+extern char* wadfiles[20];
+
+void
+D_AddFile(const char* file)
+{
+  int numwadfiles;
+  char* newfile;
+
+  for (numwadfiles = 0; wadfiles[numwadfiles]; numwadfiles++) /* { dg-bogus "infinite loop" } */
+    ;
+
+  newfile = (char *)__builtin_malloc(__builtin_strlen(file) + 1);
+  __builtin_strcpy(newfile, file); /* { dg-warning "possibly-NULL" } */
+
+  wadfiles[numwadfiles] = newfile;
+}
+
+void
+IdentifyVersion(void)
+{
+  D_AddFile("doom1.wad");
+  D_AddFile("data_se/texture1.lmp");
+}
diff --git a/gcc/testsuite/c-c++-common/analyzer/infinite-loop-doom-v_video.c b/gcc/testsuite/c-c++-common/analyzer/infinite-loop-doom-v_video.c
new file mode 100644
index 0000000..35f4206
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/analyzer/infinite-loop-doom-v_video.c
@@ -0,0 +1,31 @@
+/* Reduced from a -Wanalyzer-infinite-loop false positive seen in Doom's
+   v_video.c, which is under the GPLv2 or later.  */
+
+typedef unsigned char byte;
+
+byte*				screens[5];
+
+#define SCREENWIDTH 320
+
+void
+V_DrawBlock
+( int		x,
+  int		y,
+  int		scrn,
+  int		width,
+  int		height,
+  byte*		src ) 
+{ 
+    byte*	dest; 
+
+    /* [...snip...] */
+ 
+    dest = screens[scrn] + y*SCREENWIDTH+x; 
+
+    while (height--) /* { dg-bogus "infinite loop" } */
+    { 
+	__builtin_memcpy (dest, src, width); 
+	src += width; 
+	dest += SCREENWIDTH; 
+    } 
+} 
diff --git a/gcc/testsuite/c-c++-common/analyzer/infinite-loop-g_error.c b/gcc/testsuite/c-c++-common/analyzer/infinite-loop-g_error.c
new file mode 100644
index 0000000..5a267be
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/analyzer/infinite-loop-g_error.c
@@ -0,0 +1,19 @@
+/* Reduced from glib, which has a g_error macro with this infinite
+   loop in it:
+     for (;;) ;
+
+   Make sure we provide a readable warning for this case.  */
+
+extern void g_log_structured_standard (const char *);
+
+#define g_error(MSG)				\
+  do {						\
+    g_log_structured_standard (MSG);		\
+    for (;;) ;					\
+  } while (0)
+/* { dg-message "5: infinite loop" "" { target *-*-* } .-2 } */
+
+void test_g_error (void)
+{
+  g_error ("something went wrong"); /* { dg-message "in expansion of macro 'g_error'" } */
+}
diff --git a/gcc/testsuite/c-c++-common/analyzer/infinite-loop-linked-list.c b/gcc/testsuite/c-c++-common/analyzer/infinite-loop-linked-list.c
new file mode 100644
index 0000000..aaa387f
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/analyzer/infinite-loop-linked-list.c
@@ -0,0 +1,131 @@
+/* Various correct and incorrect ways to walk a linked list, accumulating
+   a value.  */
+
+/* { dg-additional-options "-O0" } */
+
+extern int maybe_useful_work ();
+
+struct node
+{
+  struct node *next;
+  int val;
+};
+
+/* Various "while" loops.  */
+
+int correct_while_loop (struct node *n)
+{
+  int sum = 0;
+  while (n)
+    {
+      sum += n->val;
+      n = n->next;
+    }
+  return sum;
+}
+
+int while_loop_missing_next (struct node *n)
+{
+  int sum = 0;
+  while (n) /* { dg-line "while_loop_missing_next_WHILE_LINE" } */
+    {
+      sum += n->val; /* { dg-line "while_loop_missing_next_LOOP_BODY" } */
+      /* We're missing: "n = n->next;", so n does not change  */
+    }
+  return sum;
+
+  /* { dg-warning "10: infinite loop" "" { target *-*-* } while_loop_missing_next_WHILE_LINE } */
+  /* { dg-message "10: \\(2\\) when 'n' is non-NULL: always following 'true' branch\.\.\." "" { target *-*-* } while_loop_missing_next_WHILE_LINE } */
+  /* { dg-message "\\(3\\) \.\.\.to here" "" { target *-*-* } while_loop_missing_next_LOOP_BODY } */
+  /* { dg-message "\\(4\\) looping back\.\.\." "" { target *-*-* } while_loop_missing_next_LOOP_BODY } */
+  /* { dg-message "\\(5\\) \.\.\.to here" "" { target *-*-* } while_loop_missing_next_WHILE_LINE } */
+}
+
+int while_loop_missing_next_with_work (struct node *n)
+{
+  int sum = 0;
+  while (n) /* { dg-bogus "infinite loop" } */
+    {
+      sum += n->val; 
+      /* We're missing: "n = n->next;", so n does not change  */
+      /* But here we do something that could be doing useful work.  */
+      maybe_useful_work ();
+    }
+  return sum;
+}
+
+/* BUG: missing: "sum += ", so sum does not change.  */
+
+int while_loop_missing_add (struct node *n)
+{
+  int sum = 0;
+  while (n) /* { dg-warning "infinite loop" } */
+    n->val;
+  return sum;
+}
+
+/* Various "for" loops.  */
+
+int correct_for_loop (struct node *n)
+{
+  int sum = 0;
+  for (struct node *iter = n; iter; iter = iter->next)
+    sum += n->val;
+  return sum;
+}
+
+int for_loop_missing_condition (struct node *n)
+{
+  int sum = 0;
+  for (struct node *iter = n; ; iter = iter->next)
+    sum += n->val; /* { dg-warning "infinite loop" } */
+  return sum;
+}
+
+int for_loop_missing_next (struct node *n)
+{
+  int sum = 0;
+  for (struct node *iter = n; iter; ) /* { dg-warning "infinite loop" } */
+    sum += n->val;
+  return sum;
+}
+
+/* BUG: missing: "sum += ", so sum does not change.
+   Not an infinite loop though, as we do iterate to the
+   end of the list.  */
+
+int for_loop_missing_add (struct node *n)
+{
+  int sum = 0;
+  for (struct node *iter = n; iter; iter = iter->next)
+    n->val; /* { dg-bogus "infinite loop" } */
+  return sum;
+}
+
+/* BUG: "iter->next" should be "iter = iter->next".  */
+
+int for_loop_noop_next (struct node *n)
+{
+  int sum = 0;
+  for (struct node *iter = n; iter; iter->next) /* { dg-line for_loop_noop_next_FOR_LINE } */
+    sum += n->val; /* { dg-line for_loop_noop_next_LOOP_BODY } */
+  return sum;
+
+  /* { dg-warning "31: infinite loop" "" { target *-*-* } for_loop_noop_next_FOR_LINE } */
+  /* { dg-message "31: \\(2\\) when 'iter' is non-NULL: always following 'true' branch\.\.\." "" { target *-*-* } for_loop_noop_next_FOR_LINE } */
+  /* { dg-message "\\(3\\) \.\.\.to here" "" { target *-*-* } for_loop_noop_next_LOOP_BODY } */
+  /* { dg-message "\\(4\\) looping back\.\.\." "" { target *-*-* } for_loop_noop_next_LOOP_BODY } */
+  /* { dg-message "\\(5\\) \.\.\.to here" "" { target *-*-* } for_loop_noop_next_FOR_LINE } */
+}
+
+/* BUG: "iter = n->next" should be "iter = iter->next"
+   and so it becomes an infinite loop at the 2nd element.  */
+
+int for_loop_wrong_next (struct node *n)
+{
+  int sum = 0;
+  for (struct node *iter = n; iter; iter = n->next) /* { dg-warning "infinite loop" "" { xfail *-*-* } } */
+    /* TODO: xfail.  */
+    sum += n->val; 
+  return sum;
+}
diff --git a/gcc/testsuite/c-c++-common/analyzer/infinite-recursion-inlining.c b/gcc/testsuite/c-c++-common/analyzer/infinite-recursion-inlining.c
index c885c92..9dd5590 100644
--- a/gcc/testsuite/c-c++-common/analyzer/infinite-recursion-inlining.c
+++ b/gcc/testsuite/c-c++-common/analyzer/infinite-recursion-inlining.c
@@ -11,13 +11,13 @@
 
 void test_direct (void)
 {
-  test_direct (); /* Ideally would warn here, but it becomes an infinite loop.  */
-}
+  test_direct ();
+} /* { dg-warning "infinite-loop" } */
 
 void test_guarded (int flag)
 {
-  if (flag)
-    test_guarded (flag);  /* Ideally would warn here, but it becomes an infinite loop.  */
+  if (flag) /* { dg-warning "infinite-loop" } */
+    test_guarded (flag);
 }
 
 void test_flipped_guard (int flag)
@@ -34,7 +34,7 @@ void test_param_variant (int depth)
 
 void test_unguarded_param_variant (int depth)
 {
-  test_unguarded_param_variant (depth - 1); /* Ideally would warn here, but it becomes an infinite loop.  */
+  test_unguarded_param_variant (depth - 1); /* { dg-warning "infinite-loop" } */
 }
 
 int g;
@@ -90,27 +90,23 @@ int test_do_while_postdecrement_param (int n)
 
 /* Various cases of decrementing "n" as the recursion proceeds where
    not every path recurses, but we're not actually checking "n", so
-   if "flag" is true it's an infinite recursion.  */
+   if "flag" is true it's an infinite recursion (which looks like an
+   infinite loop after inlining).  */
 
 void test_partially_guarded_postdecrement (int flag, int n)
 {
-  /* Ideally we'd catch this, but it becomes an infinite loop.  */
-  if (flag)
+  if (flag) /* { dg-warning "infinite loop" } */
     test_partially_guarded_postdecrement (flag, n--);
 }
 
 void test_partially_guarded_predecrement (int flag, int n)
 {
-  /* We fail to report this; we see that "n" is changing,
-     though it isn't relevant to whether we recurse.  */
-  if (flag)
-    test_partially_guarded_predecrement (flag, --n); /* { dg-warning "infinite recursion" "TODO" { xfail *-*-* } } */
+  if (flag) /* { dg-warning "infinite loop" } */
+    test_partially_guarded_predecrement (flag, --n);
 }
 
 void test_partially_guarded_subtract (int flag, int n)
 {
-  /* We fail to report this; we see that "n" is changing,
-     though it isn't relevant to whether we recurse.  */
-  if (flag)
-    test_partially_guarded_subtract (flag, n - 1); /* { dg-warning "infinite recursion" "TODO" { xfail *-*-* } } */
+  if (flag) /* { dg-warning "infinite loop" } */
+    test_partially_guarded_subtract (flag, n - 1);
 }
diff --git a/gcc/testsuite/c-c++-common/analyzer/inlining-4-multiline.c b/gcc/testsuite/c-c++-common/analyzer/inlining-4-multiline.c
index c870a9f..5c971c5 100644
--- a/gcc/testsuite/c-c++-common/analyzer/inlining-4-multiline.c
+++ b/gcc/testsuite/c-c++-common/analyzer/inlining-4-multiline.c
@@ -56,13 +56,20 @@ outer (int flag)
                   |      |
                   |      (4) following 'true' branch (when 'flag != 0')...
                   |
+                'inner': event 5 (depth 3)
+                  |
+                  |
+                  | #define NULL ((void *)0)
+                  |              ^
+                  |              |
+                  |              (5) ...to here
+   { dg-end-multiline-output "" { target c } } */
+/* { dg-begin-multiline-output "" }
+                  |     return NULL;
+                  |            ^~~~
+                  |
     <-------------+
     |
-  'outer': event 5 (depth 1)
-    |
-    |cc1:
-    | (5): ...to here
-    |
   'outer': event 6 (depth 1)
     |
     |   return *middle (flag);
@@ -100,13 +107,20 @@ outer (int flag)
                   |   |
                   |   (4) following 'true' branch (when 'flag != 0')...
                   |
+                'const char* inner(int)': event 5 (depth 3)
+                  |
+                  |
+                  | #define NULL
+                  |
+                  |              |
+                  |              (5) ...to here
+   { dg-end-multiline-output "" { target c++ } } */
+/* { dg-begin-multiline-output "" }
+                  |     return NULL;
+                  |            ^~~~
+                  |
     <-------------+
     |
-  'char outer(int)': event 5 (depth 1)
-    |
-    |cc1plus:
-    | (5): ...to here
-    |
   'char outer(int)': event 6 (depth 1)
     |
     |   return *middle (flag);
diff --git a/gcc/testsuite/c-c++-common/analyzer/pr104029.c b/gcc/testsuite/c-c++-common/analyzer/pr104029.c
index 873f0eb..04b9ef8 100644
--- a/gcc/testsuite/c-c++-common/analyzer/pr104029.c
+++ b/gcc/testsuite/c-c++-common/analyzer/pr104029.c
@@ -1,6 +1,3 @@
-// TODO: remove need for this option
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 typedef __SIZE_TYPE__ size_t;
 typedef const void *t_comptype;
 typedef int (*t_compfunc)(t_comptype, t_comptype);
diff --git a/gcc/testsuite/c-c++-common/analyzer/strtok-1.c b/gcc/testsuite/c-c++-common/analyzer/strtok-1.c
new file mode 100644
index 0000000..33150ce
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/analyzer/strtok-1.c
@@ -0,0 +1,62 @@
+/* { dg-additional-options "-fpermissive" { target c++ } } */
+
+#include "../../gcc.dg/analyzer/analyzer-decls.h"
+
+typedef __SIZE_TYPE__ size_t;
+
+extern char *strtok (char *str, const char *delim)
+  __attribute__((nonnull (2)));
+
+char *
+test_passthrough (char *str, const char *delim)
+{
+  return strtok (str, delim);
+}
+
+char *
+test_null_str (const char *delim)
+{
+  return strtok (NULL, delim);
+}
+
+char *
+test_null_delim (char *str)
+{
+  return strtok (str, NULL); /* { dg-warning "use of NULL where non-null expected" } */
+  /* This is from the attribute.  */
+}
+
+char *
+test_write_to_literal (void)
+{
+  const char *str = "hello world";
+  return strtok ((char *)str, " "); /* { dg-warning "write to string literal" } */
+}
+
+char *
+test_unterminated_str (const char *delim)
+{
+  char str[3] = "abc"; /* { dg-warning "initializer-string for '\[^\n\]*' is too long" "" { target c++ } } */
+  return strtok (str, delim); /* { dg-warning "stack-based buffer over-read" } */
+}
+
+char *
+test_unterminated_delimstr (char *str)
+{
+  char delim[3] = "abc"; /* { dg-warning "initializer-string for '\[^\n\]*' is too long" "" { target c++ } } */
+  return strtok (str, delim); /* { dg-warning "stack-based buffer over-read" } */
+  /* { dg-message "while looking for null terminator for argument 2" "" { target *-*-* } .-1 } */
+}
+
+size_t
+test_use_after_free_via_null_2 (char *p)
+{
+  strtok (p, " ");
+  __builtin_free (p);
+
+  char *q = strtok (NULL, " "); /* TODO: should complain about this.  */
+  if (q)
+    return __builtin_strlen (q); /* TODO: should complain about this.  */
+  else
+    return 0;
+}
diff --git a/gcc/testsuite/c-c++-common/analyzer/strtok-2.c b/gcc/testsuite/c-c++-common/analyzer/strtok-2.c
new file mode 100644
index 0000000..0336bf0
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/analyzer/strtok-2.c
@@ -0,0 +1,18 @@
+#include "../../gcc.dg/analyzer/analyzer-decls.h"
+
+extern char *strtok (char *str, const char *delim)
+  __attribute__((nonnull (2)));
+
+int
+main(int argc, char *argv[])
+{
+  char *cmd;
+  char *arg;
+
+  if (argc < 2)
+    return -1;
+
+  cmd = strtok (argv[1], " "); /* { dg-bogus "undefined behavior" } */
+  arg = strtok (NULL, " ");
+  return 0;  
+}
diff --git a/gcc/testsuite/c-c++-common/analyzer/strtok-3.c b/gcc/testsuite/c-c++-common/analyzer/strtok-3.c
new file mode 100644
index 0000000..f18f1a9
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/analyzer/strtok-3.c
@@ -0,0 +1,26 @@
+#include "../../gcc.dg/analyzer/analyzer-decls.h"
+
+extern char *strtok (char *str, const char *delim)
+  __attribute__((nonnull (2)));
+
+int
+main (int argc, char *argv[])
+{
+  char *cmd;
+  char *arg;
+
+  if (argc < 2)
+    return -1;
+
+  cmd = strtok (NULL, " "); /* { dg-line "first_call" } */
+  arg = strtok (NULL, " ");
+  return 0;
+
+  /* C:
+     { dg-warning "calling 'strtok' for first time with NULL as argument 1 has undefined behavior \\\[CWE-476\\\] \\\[-Wanalyzer-undefined-behavior-strtok\\\]" "" { target c } first_call }
+     { dg-message "some implementations of 'strtok' may crash on such input" "" { target c } first_call } */
+
+  /* C++:
+     { dg-warning "calling 'char\\* strtok\\(char\\*, const char\\*\\)' for first time with NULL as argument 1 has undefined behavior \\\[CWE-476\\\] \\\[-Wanalyzer-undefined-behavior-strtok\\\]" "" { target c++ } first_call }
+     { dg-message "some implementations of 'char\\* strtok\\(char\\*, const char\\*\\)' may crash on such input" "" { target c++ } first_call }  */
+}
diff --git a/gcc/testsuite/c-c++-common/analyzer/strtok-4.c b/gcc/testsuite/c-c++-common/analyzer/strtok-4.c
new file mode 100644
index 0000000..b6b7d49
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/analyzer/strtok-4.c
@@ -0,0 +1,42 @@
+#include "../../gcc.dg/analyzer/analyzer-decls.h"
+
+extern char *strtok (char *str, const char *delim);
+
+void test (void)
+{
+  char buffer[] = { 'a', 'x', 'b', 'y', 'c', '\0' };
+
+  char *p1 = strtok (buffer, "x");
+  /* Should result in:
+      | buffer[] = { 'a', '\0', 'b', 'y', 'c', '\0' },
+      |               ^    ^     ^
+      |               |    |     |
+      |               |    |     internal ptr
+      |               p1   modified.  */
+
+  char *p2 = strtok (NULL, "y"); /* note new delimiter.  */
+  /* Should result in:
+      | buffer[] = { 'a', '\0', 'b', '\0', 'c', '\0' },
+      |                          ^    ^     ^
+      |                          |    |     |
+      |                          |    |     internal ptr
+      |                          p2   modified.  */
+
+  char *p3 = strtok (NULL, "z"); /* again new delimiter.  */
+  /* Should result in:
+      | buffer[] = { 'a', '\0', 'b', '\0', 'c', '\0' },
+      |                                     ^    ^~
+      |                                     |    |
+      |                                     |    internal ptr
+      |                                     p3.  */
+
+  char *p4 = strtok (NULL, "z");
+  /* Should result in p4 == NULL, and:
+      | buffer[] = { 'a', '\0', 'b', '\0', 'c', '\0' },
+      |                                          ^~
+      |                                          |
+      |                                         internal ptr.  */
+
+  /* We don't yet model strtok closely enough to capture
+     these exact behaviors.  */
+}
diff --git a/gcc/testsuite/c-c++-common/analyzer/strtok-cppreference.c b/gcc/testsuite/c-c++-common/analyzer/strtok-cppreference.c
new file mode 100644
index 0000000..a2e9123
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/analyzer/strtok-cppreference.c
@@ -0,0 +1,50 @@
+/* Example of strtok adapted from:
+     https://en.cppreference.com/w/c/string/byte/strtok
+   which is 
+    "licensed under Creative Commons Attribution-Sharealike 3.0
+     Unported License (CC-BY-SA) and by the GNU Free Documentation License
+     (GFDL) (unversioned, with no invariant sections, front-cover texts, or
+     back-cover texts). That means that you can use this site in almost any way
+     you like, including mirroring, copying, translating, etc. All we would ask
+     is to provide link back to cppreference.com so that people know where to
+     get the most up-to-date content. In addition to that, any modified content
+     should be released under an equivalent license so that everyone could
+     benefit from the modified versions. "  */
+
+#define __STDC_WANT_LIB_EXT1__ 0
+#include <string.h>
+#include <stdio.h>
+ 
+int main(void)
+{
+    char input[] = "A bird came down the walk";
+    printf("Parsing the input string '%s'\n", input);
+    char *token = strtok(input, " ");
+    while(token) {
+        puts(token);
+        token = strtok(NULL, " ");
+    }
+ 
+    printf("Contents of the input string now: '");
+    for(size_t n = 0; n < sizeof input; ++n)
+        input[n] ? putchar(input[n]) : fputs("\\0", stdout);
+    puts("'");
+ 
+#ifdef __STDC_LIB_EXT1__
+    char str[] = "A bird came down the walk";
+    rsize_t strmax = sizeof str;
+    const char *delim = " ";
+    char *next_token;
+    printf("Parsing the input string '%s'\n", str);
+    token = strtok_s(str, &strmax, delim, &next_token);
+    while(token) {
+        puts(token);
+        token = strtok_s(NULL, &strmax, delim, &next_token);
+    }
+ 
+    printf("Contents of the input string now: '");
+    for(size_t n = 0; n < sizeof str; ++n)
+        str[n] ? putchar(str[n]) : fputs("\\0", stdout);
+    puts("'");
+#endif
+}
diff --git a/gcc/testsuite/c-c++-common/asan/sanity-check-pure-c-1.c b/gcc/testsuite/c-c++-common/asan/sanity-check-pure-c-1.c
index 219fcf8..434d568 100644
--- a/gcc/testsuite/c-c++-common/asan/sanity-check-pure-c-1.c
+++ b/gcc/testsuite/c-c++-common/asan/sanity-check-pure-c-1.c
@@ -10,7 +10,7 @@ int main() {
 }
 
 /* { dg-output "heap-use-after-free.*(\n|\r\n|\r)" } */
-/* { dg-output "    #0 \[^\n\r]*(in _*(interceptor_|wrap_)free|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */
+/* { dg-output "    #0 \[^\n\r]*(in _*(interceptor_|wrap_)?free|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */
 /* { dg-output "    #1 \[^\n\r]*(in _*main (\[^\n\r]*sanity-check-pure-c-1.c:8|\[^\n\r]*:0)|\[(\]).*(\n|\r\n|\r)" } */
-/* { dg-output "    #0 \[^\n\r]*(in _*(interceptor_|wrap_)malloc|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */
+/* { dg-output "    #0 \[^\n\r]*(in _*(interceptor_|wrap_)?malloc|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */
 /* { dg-output "    #1 \[^\n\r]*(in _*main (\[^\n\r]*sanity-check-pure-c-1.c:7|\[^\n\r]*:0)|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */
diff --git a/gcc/testsuite/c-c++-common/pr111309-1.c b/gcc/testsuite/c-c++-common/pr111309-1.c
new file mode 100644
index 0000000..fdf3bf1
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/pr111309-1.c
@@ -0,0 +1,470 @@
+/* PR c/111309 */
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+__attribute__((noipa)) int
+clzc (unsigned char x)
+{
+  return __builtin_clzg (x);
+}
+
+__attribute__((noipa)) int
+clzc2 (unsigned char x, int y)
+{
+  return __builtin_clzg (x, y);
+}
+
+__attribute__((noipa)) int
+clzs (unsigned short x)
+{
+  return __builtin_clzg (x);
+}
+
+__attribute__((noipa)) int
+clzs2 (unsigned short x)
+{
+  return __builtin_clzg (x, -2);
+}
+
+__attribute__((noipa)) int
+clzi (unsigned int x)
+{
+  return __builtin_clzg (x);
+}
+
+__attribute__((noipa)) int
+clzi2 (unsigned int x, int y)
+{
+  return __builtin_clzg (x, y);
+}
+
+__attribute__((noipa)) int
+clzl (unsigned long x)
+{
+  return __builtin_clzg (x);
+}
+
+__attribute__((noipa)) int
+clzl2 (unsigned long x)
+{
+  return __builtin_clzg (x, -1);
+}
+
+__attribute__((noipa)) int
+clzL (unsigned long long x)
+{
+  return __builtin_clzg (x);
+}
+
+__attribute__((noipa)) int
+clzL2 (unsigned long long x, int y)
+{
+  return __builtin_clzg (x, y);
+}
+
+#ifdef __SIZEOF_INT128__
+__attribute__((noipa)) int
+clzI (unsigned __int128 x)
+{
+  return __builtin_clzg (x);
+}
+
+__attribute__((noipa)) int
+clzI2 (unsigned __int128 x, int y)
+{
+  return __builtin_clzg (x, y);
+}
+#endif
+
+__attribute__((noipa)) int
+ctzc (unsigned char x)
+{
+  return __builtin_ctzg (x);
+}
+
+__attribute__((noipa)) int
+ctzc2 (unsigned char x, int y)
+{
+  return __builtin_ctzg (x, y);
+}
+
+__attribute__((noipa)) int
+ctzs (unsigned short x)
+{
+  return __builtin_ctzg (x);
+}
+
+__attribute__((noipa)) int
+ctzs2 (unsigned short x, int y)
+{
+  return __builtin_ctzg (x, y);
+}
+
+__attribute__((noipa)) int
+ctzi (unsigned int x)
+{
+  return __builtin_ctzg (x);
+}
+
+__attribute__((noipa)) int
+ctzi2 (unsigned int x, int y)
+{
+  return __builtin_ctzg (x, y);
+}
+
+__attribute__((noipa)) int
+ctzl (unsigned long x)
+{
+  return __builtin_ctzg (x);
+}
+
+__attribute__((noipa)) int
+ctzl2 (unsigned long x, int y)
+{
+  return __builtin_ctzg (x, y);
+}
+
+__attribute__((noipa)) int
+ctzL (unsigned long long x)
+{
+  return __builtin_ctzg (x);
+}
+
+__attribute__((noipa)) int
+ctzL2 (unsigned long long x, int y)
+{
+  return __builtin_ctzg (x, y);
+}
+
+#ifdef __SIZEOF_INT128__
+__attribute__((noipa)) int
+ctzI (unsigned __int128 x)
+{
+  return __builtin_ctzg (x);
+}
+
+__attribute__((noipa)) int
+ctzI2 (unsigned __int128 x)
+{
+  return __builtin_ctzg (x, __SIZEOF_INT128__ * __CHAR_BIT__);
+}
+#endif
+
+__attribute__((noipa)) int
+clrsbc (signed char x)
+{
+  return __builtin_clrsbg (x);
+}
+
+__attribute__((noipa)) int
+clrsbs (signed short x)
+{
+  return __builtin_clrsbg (x);
+}
+
+__attribute__((noipa)) int
+clrsbi (signed int x)
+{
+  return __builtin_clrsbg (x);
+}
+
+__attribute__((noipa)) int
+clrsbl (signed long x)
+{
+  return __builtin_clrsbg (x);
+}
+
+__attribute__((noipa)) int
+clrsbL (signed long long x)
+{
+  return __builtin_clrsbg (x);
+}
+
+#ifdef __SIZEOF_INT128__
+__attribute__((noipa)) int
+clrsbI (signed __int128 x)
+{
+  return __builtin_clrsbg (x);
+}
+#endif
+
+__attribute__((noipa)) int
+ffsc (signed char x)
+{
+  return __builtin_ffsg (x);
+}
+
+__attribute__((noipa)) int
+ffss (signed short x)
+{
+  return __builtin_ffsg (x);
+}
+
+__attribute__((noipa)) int
+ffsi (signed int x)
+{
+  return __builtin_ffsg (x);
+}
+
+__attribute__((noipa)) int
+ffsl (signed long x)
+{
+  return __builtin_ffsg (x);
+}
+
+__attribute__((noipa)) int
+ffsL (signed long long x)
+{
+  return __builtin_ffsg (x);
+}
+
+#ifdef __SIZEOF_INT128__
+__attribute__((noipa)) int
+ffsI (signed __int128 x)
+{
+  return __builtin_ffsg (x);
+}
+#endif
+
+__attribute__((noipa)) int
+parityc (unsigned char x)
+{
+  return __builtin_parityg (x);
+}
+
+__attribute__((noipa)) int
+paritys (unsigned short x)
+{
+  return __builtin_parityg (x);
+}
+
+__attribute__((noipa)) int
+parityi (unsigned int x)
+{
+  return __builtin_parityg (x);
+}
+
+__attribute__((noipa)) int
+parityl (unsigned long x)
+{
+  return __builtin_parityg (x);
+}
+
+__attribute__((noipa)) int
+parityL (unsigned long long x)
+{
+  return __builtin_parityg (x);
+}
+
+#ifdef __SIZEOF_INT128__
+__attribute__((noipa)) int
+parityI (unsigned __int128 x)
+{
+  return __builtin_parityg (x);
+}
+#endif
+
+__attribute__((noipa)) int
+popcountc (unsigned char x)
+{
+  return __builtin_popcountg (x);
+}
+
+__attribute__((noipa)) int
+popcounts (unsigned short x)
+{
+  return __builtin_popcountg (x);
+}
+
+__attribute__((noipa)) int
+popcounti (unsigned int x)
+{
+  return __builtin_popcountg (x);
+}
+
+__attribute__((noipa)) int
+popcountl (unsigned long x)
+{
+  return __builtin_popcountg (x);
+}
+
+__attribute__((noipa)) int
+popcountL (unsigned long long x)
+{
+  return __builtin_popcountg (x);
+}
+
+#ifdef __SIZEOF_INT128__
+__attribute__((noipa)) int
+popcountI (unsigned __int128 x)
+{
+  return __builtin_popcountg (x);
+}
+#endif
+
+int
+main ()
+{
+  if (__builtin_clzg ((unsigned char) 1) != __CHAR_BIT__ - 1
+      || __builtin_clzg ((unsigned short) 2, -2) != __SIZEOF_SHORT__ * __CHAR_BIT__ - 2
+      || __builtin_clzg (0U, 42) != 42
+      || __builtin_clzg (0U, -1) != -1
+      || __builtin_clzg (1U) != __SIZEOF_INT__ * __CHAR_BIT__ - 1
+      || __builtin_clzg (2UL, -1) != __SIZEOF_LONG__ * __CHAR_BIT__ - 2
+      || __builtin_clzg (5ULL) != __SIZEOF_LONG_LONG__ * __CHAR_BIT__ - 3
+#ifdef __SIZEOF_INT128__
+      || __builtin_clzg ((unsigned __int128) 9) != __SIZEOF_INT128__ * __CHAR_BIT__ - 4
+#endif
+      || __builtin_clzg (~0U, -5) != 0
+      || __builtin_clzg (~0ULL >> 2) != 2
+      || __builtin_ctzg ((unsigned char) 1) != 0
+      || __builtin_ctzg ((unsigned short) 28) != 2
+      || __builtin_ctzg (0U, 32) != 32
+      || __builtin_ctzg (0U, -42) != -42
+      || __builtin_ctzg (1U) != 0
+      || __builtin_ctzg (16UL, -1) != 4
+      || __builtin_ctzg (5ULL << 52, 0) != 52
+#ifdef __SIZEOF_INT128__
+      || __builtin_ctzg (((unsigned __int128) 9) << 72) != 72
+#endif
+      || __builtin_clrsbg ((signed char) 0) != __CHAR_BIT__ - 1
+      || __builtin_clrsbg ((signed short) -1) != __SIZEOF_SHORT__ * __CHAR_BIT__ - 1
+      || __builtin_clrsbg (0) != __SIZEOF_INT__ * __CHAR_BIT__ - 1
+      || __builtin_clrsbg (-1L) != __SIZEOF_LONG__ * __CHAR_BIT__ - 1
+      || __builtin_clrsbg (0LL) != __SIZEOF_LONG_LONG__ * __CHAR_BIT__ - 1
+#ifdef __SIZEOF_INT128__
+      || __builtin_clrsbg ((__int128) -1) != __SIZEOF_INT128__ * __CHAR_BIT__ - 1
+#endif
+      || __builtin_clrsbg (0x1afb) != __SIZEOF_INT__ * __CHAR_BIT__ - 14
+      || __builtin_clrsbg (-2) != __SIZEOF_INT__ * __CHAR_BIT__ - 2
+      || __builtin_clrsbg (1L) != __SIZEOF_LONG__ * __CHAR_BIT__ - 2
+      || __builtin_clrsbg (-4LL) != __SIZEOF_LONG_LONG__ * __CHAR_BIT__ - 3
+      || __builtin_ffsg ((signed char) 0) != 0
+      || __builtin_ffsg ((signed short) 0) != 0
+      || __builtin_ffsg (0) != 0
+      || __builtin_ffsg (0L) != 0
+      || __builtin_ffsg (0LL) != 0
+#ifdef __SIZEOF_INT128__
+      || __builtin_ffsg ((__int128) 0) != 0
+#endif
+      || __builtin_ffsg ((signed char) 4) != 3
+      || __builtin_ffsg ((signed short) 8) != 4
+      || __builtin_ffsg (1) != 1
+      || __builtin_ffsg (2L) != 2
+      || __builtin_ffsg (28LL) != 3
+      || __builtin_parityg ((unsigned char) 1) != 1
+      || __builtin_parityg ((unsigned short) 2) != 1
+      || __builtin_parityg (0U) != 0
+      || __builtin_parityg (3U) != 0
+      || __builtin_parityg (0UL) != 0
+      || __builtin_parityg (7UL) != 1
+      || __builtin_parityg (0ULL) != 0
+#ifdef __SIZEOF_INT128__
+      || __builtin_parityg ((unsigned __int128) 0) != 0
+#endif
+      || __builtin_parityg ((unsigned char) ~0U) != 0
+      || __builtin_parityg ((unsigned short) ~0U) != 0
+      || __builtin_parityg (~0U) != 0
+      || __builtin_parityg (~0UL) != 0
+      || __builtin_parityg (~0ULL) != 0
+#ifdef __SIZEOF_INT128__
+      || __builtin_parityg (~(unsigned __int128) 0) != 0
+#endif
+      || __builtin_popcountg (0U) != 0
+      || __builtin_popcountg (0UL) != 0
+      || __builtin_popcountg (0ULL) != 0
+#ifdef __SIZEOF_INT128__
+      || __builtin_popcountg ((unsigned __int128) 0) != 0
+#endif
+      || __builtin_popcountg ((unsigned char) ~0U) != __CHAR_BIT__
+      || __builtin_popcountg ((unsigned short) ~0U) != __SIZEOF_SHORT__ * __CHAR_BIT__
+      || __builtin_popcountg (~0U) != __SIZEOF_INT__ * __CHAR_BIT__
+      || __builtin_popcountg (~0UL) != __SIZEOF_LONG__ * __CHAR_BIT__
+      || __builtin_popcountg (~0ULL) != __SIZEOF_LONG_LONG__ * __CHAR_BIT__
+#ifdef __SIZEOF_INT128__
+      || __builtin_popcountg (~(unsigned __int128) 0) != __SIZEOF_INT128__ * __CHAR_BIT__
+#endif
+      || 0)
+  __builtin_abort ();
+  if (clzc (1) != __CHAR_BIT__ - 1
+      || clzs2 (2) != __SIZEOF_SHORT__ * __CHAR_BIT__ - 2
+      || clzi2 (0U, 42) != 42
+      || clzi2 (0U, -1) != -1
+      || clzi (1U) != __SIZEOF_INT__ * __CHAR_BIT__ - 1
+      || clzl2 (2UL) != __SIZEOF_LONG__ * __CHAR_BIT__ - 2
+      || clzL (5ULL) != __SIZEOF_LONG_LONG__ * __CHAR_BIT__ - 3
+#ifdef __SIZEOF_INT128__
+      || clzI ((unsigned __int128) 9) != __SIZEOF_INT128__ * __CHAR_BIT__ - 4
+#endif
+      || clzi2 (~0U, -5) != 0
+      || clzL (~0ULL >> 2) != 2
+      || ctzc (1) != 0
+      || ctzs (28) != 2
+      || ctzi2 (0U, 32) != 32
+      || ctzi2 (0U, -42) != -42
+      || ctzi (1U) != 0
+      || ctzl2 (16UL, -1) != 4
+      || ctzL2 (5ULL << 52, 0) != 52
+#ifdef __SIZEOF_INT128__
+      || ctzI (((unsigned __int128) 9) << 72) != 72
+#endif
+      || clrsbc (0) != __CHAR_BIT__ - 1
+      || clrsbs (-1) != __SIZEOF_SHORT__ * __CHAR_BIT__ - 1
+      || clrsbi (0) != __SIZEOF_INT__ * __CHAR_BIT__ - 1
+      || clrsbl (-1L) != __SIZEOF_LONG__ * __CHAR_BIT__ - 1
+      || clrsbL (0LL) != __SIZEOF_LONG_LONG__ * __CHAR_BIT__ - 1
+#ifdef __SIZEOF_INT128__
+      || clrsbI (-1) != __SIZEOF_INT128__ * __CHAR_BIT__ - 1
+#endif
+      || clrsbi (0x1afb) != __SIZEOF_INT__ * __CHAR_BIT__ - 14
+      || clrsbi (-2) != __SIZEOF_INT__ * __CHAR_BIT__ - 2
+      || clrsbl (1L) != __SIZEOF_LONG__ * __CHAR_BIT__ - 2
+      || clrsbL (-4LL) != __SIZEOF_LONG_LONG__ * __CHAR_BIT__ - 3
+      || ffsc (0) != 0
+      || ffss (0) != 0
+      || ffsi (0) != 0
+      || ffsl (0L) != 0
+      || ffsL (0LL) != 0
+#ifdef __SIZEOF_INT128__
+      || ffsI (0) != 0
+#endif
+      || ffsc (4) != 3
+      || ffss (8) != 4
+      || ffsi (1) != 1
+      || ffsl (2L) != 2
+      || ffsL (28LL) != 3
+      || parityc (1) != 1
+      || paritys (2) != 1
+      || parityi (0U) != 0
+      || parityi (3U) != 0
+      || parityl (0UL) != 0
+      || parityl (7UL) != 1
+      || parityL (0ULL) != 0
+#ifdef __SIZEOF_INT128__
+      || parityI (0) != 0
+#endif
+      || parityc ((unsigned char) ~0U) != 0
+      || paritys ((unsigned short) ~0U) != 0
+      || parityi (~0U) != 0
+      || parityl (~0UL) != 0
+      || parityL (~0ULL) != 0
+#ifdef __SIZEOF_INT128__
+      || parityI (~(unsigned __int128) 0) != 0
+#endif
+      || popcounti (0U) != 0
+      || popcountl (0UL) != 0
+      || popcountL (0ULL) != 0
+#ifdef __SIZEOF_INT128__
+      || popcountI (0) != 0
+#endif
+      || popcountc ((unsigned char) ~0U) != __CHAR_BIT__
+      || popcounts ((unsigned short) ~0U) != __SIZEOF_SHORT__ * __CHAR_BIT__
+      || popcounti (~0U) != __SIZEOF_INT__ * __CHAR_BIT__
+      || popcountl (~0UL) != __SIZEOF_LONG__ * __CHAR_BIT__
+      || popcountL (~0ULL) != __SIZEOF_LONG_LONG__ * __CHAR_BIT__
+#ifdef __SIZEOF_INT128__
+      || popcountI (~(unsigned __int128) 0) != __SIZEOF_INT128__ * __CHAR_BIT__
+#endif
+      || 0)
+  __builtin_abort ();
+}
diff --git a/gcc/testsuite/c-c++-common/pr111309-2.c b/gcc/testsuite/c-c++-common/pr111309-2.c
new file mode 100644
index 0000000..535208b
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/pr111309-2.c
@@ -0,0 +1,85 @@
+/* PR c/111309 */
+/* { dg-do compile } */
+/* { dg-additional-options "-std=c99" { target c } } */
+
+#ifndef __cplusplus
+#define bool _Bool
+#define true ((_Bool) 1)
+#define false ((_Bool) 0)
+#endif
+
+void
+foo (void)
+{
+  enum E { E0 = 0 };
+  struct S { int s; } s;
+  __builtin_clzg ();		/* { dg-error "too few arguments" } */
+  __builtin_clzg (0U, 1, 2);	/* { dg-error "too many arguments" } */
+  __builtin_clzg (0);		/* { dg-error "has signed type" } */
+  __builtin_clzg (0.0);		/* { dg-error "does not have integral type" } */
+  __builtin_clzg (s);		/* { dg-error "does not have integral type" } */
+  __builtin_clzg (true);	/* { dg-error "has boolean type" } */
+  __builtin_clzg (E0);		/* { dg-error "has signed type" "" { target c } } */
+				/* { dg-error "has enumerated type" "" { target c++ } .-1 } */
+  __builtin_clzg (0, 0);	/* { dg-error "has signed type" } */
+  __builtin_clzg (0.0, 0);	/* { dg-error "does not have integral type" } */
+  __builtin_clzg (s, 0);	/* { dg-error "does not have integral type" } */
+  __builtin_clzg (true, 0);	/* { dg-error "has boolean type" } */
+  __builtin_clzg (E0, 0);	/* { dg-error "has signed type" "" { target c } } */
+				/* { dg-error "has enumerated type" "" { target c++ } .-1 } */
+  __builtin_clzg (0U, 2.0);	/* { dg-error "does not have integral type" } */
+  __builtin_clzg (0U, s);	/* { dg-error "does not have integral type" } */
+  __builtin_clzg (0U, 2LL);	/* { dg-error "does not have 'int' type" } */
+  __builtin_clzg (0U, 2U);	/* { dg-error "does not have 'int' type" } */
+  __builtin_clzg (0U, true);
+  __builtin_clzg (0U, E0);	/* { dg-error "does not have 'int' type" "" { target c++ } } */
+  __builtin_ctzg ();		/* { dg-error "too few arguments" } */
+  __builtin_ctzg (0U, 1, 2);	/* { dg-error "too many arguments" } */
+  __builtin_ctzg (0);		/* { dg-error "has signed type" } */
+  __builtin_ctzg (0.0);		/* { dg-error "does not have integral type" } */
+  __builtin_ctzg (s);		/* { dg-error "does not have integral type" } */
+  __builtin_ctzg (true);	/* { dg-error "has boolean type" } */
+  __builtin_ctzg (E0);		/* { dg-error "has signed type" "" { target c } } */
+				/* { dg-error "has enumerated type" "" { target c++ } .-1 } */
+  __builtin_ctzg (0, 0);	/* { dg-error "has signed type" } */
+  __builtin_ctzg (0.0, 0);	/* { dg-error "does not have integral type" } */
+  __builtin_ctzg (s, 0);	/* { dg-error "does not have integral type" } */
+  __builtin_ctzg (true, 0);	/* { dg-error "has boolean type" } */
+  __builtin_ctzg (E0, 0);	/* { dg-error "has signed type" "" { target c } } */
+				/* { dg-error "has enumerated type" "" { target c++ } .-1 } */
+  __builtin_ctzg (0U, 2.0);	/* { dg-error "does not have integral type" } */
+  __builtin_ctzg (0U, 2LL);	/* { dg-error "does not have 'int' type" } */
+  __builtin_ctzg (0U, 2U);	/* { dg-error "does not have 'int' type" } */
+  __builtin_ctzg (0U, true);
+  __builtin_ctzg (0U, E0);	/* { dg-error "does not have 'int' type" "" { target c++ } } */
+  __builtin_clrsbg ();		/* { dg-error "too few arguments" } */
+  __builtin_clrsbg (0, 1);	/* { dg-error "too many arguments" } */
+  __builtin_clrsbg (0U);	/* { dg-error "has unsigned type" } */
+  __builtin_clrsbg (0.0);	/* { dg-error "does not have integral type" } */
+  __builtin_clrsbg (s);		/* { dg-error "does not have integral type" } */
+  __builtin_clrsbg (true);	/* { dg-error "has boolean type" } */
+  __builtin_clrsbg (E0);	/* { dg-error "has enumerated type" "" { target c++ } } */
+  __builtin_ffsg ();		/* { dg-error "too few arguments" } */
+  __builtin_ffsg (0, 1);	/* { dg-error "too many arguments" } */
+  __builtin_ffsg (0U);		/* { dg-error "has unsigned type" } */
+  __builtin_ffsg (0.0);		/* { dg-error "does not have integral type" } */
+  __builtin_ffsg (s);		/* { dg-error "does not have integral type" } */
+  __builtin_ffsg (true);	/* { dg-error "has boolean type" } */
+  __builtin_ffsg (E0);		/* { dg-error "has enumerated type" "" { target c++ } } */
+  __builtin_parityg ();		/* { dg-error "too few arguments" } */
+  __builtin_parityg (0U, 1);	/* { dg-error "too many arguments" } */
+  __builtin_parityg (0);	/* { dg-error "has signed type" } */
+  __builtin_parityg (0.0);	/* { dg-error "does not have integral type" } */
+  __builtin_parityg (s);	/* { dg-error "does not have integral type" } */
+  __builtin_parityg (true);	/* { dg-error "has boolean type" } */
+  __builtin_parityg (E0);	/* { dg-error "has signed type" "" { target c } } */
+				/* { dg-error "has enumerated type" "" { target c++ } .-1 } */
+  __builtin_popcountg ();	/* { dg-error "too few arguments" } */
+  __builtin_popcountg (0U, 1);	/* { dg-error "too many arguments" } */
+  __builtin_popcountg (0);	/* { dg-error "has signed type" } */
+  __builtin_popcountg (0.0);	/* { dg-error "does not have integral type" } */
+  __builtin_popcountg (s);	/* { dg-error "does not have integral type" } */
+  __builtin_popcountg (true);	/* { dg-error "has boolean type" } */
+  __builtin_popcountg (E0);	/* { dg-error "has signed type" "" { target c } } */
+				/* { dg-error "has enumerated type" "" { target c++ } .-1 } */
+}
diff --git a/gcc/testsuite/g++.dg/DRs/dr2406.C b/gcc/testsuite/g++.dg/DRs/dr2406.C
new file mode 100644
index 0000000..856a1ea
--- /dev/null
+++ b/gcc/testsuite/g++.dg/DRs/dr2406.C
@@ -0,0 +1,82 @@
+// DR 2406 - [[fallthrough]] attribute and iteration statements
+// PR c++/107571
+// { dg-do compile { target c++11 } }
+// { dg-options "-pedantic-errors -Wimplicit-fallthrough" }
+
+void bar ();
+void baz ();
+void qux ();
+
+void
+foo (int n)
+{
+  switch (n)
+    {
+    case 1:
+    case 2:
+      bar ();
+      [[fallthrough]];
+    case 3:
+      do
+	{
+	  [[fallthrough]];	// { dg-error "attribute 'fallthrough' not preceding a case label or default label" }
+	}
+      while (false);
+    case 6:
+      do
+	{
+	  [[fallthrough]];	// { dg-error "attribute 'fallthrough' not preceding a case label or default label" }
+	}
+      while (n--);
+    case 7:
+      while (false)
+	{
+	  [[fallthrough]];	// { dg-error "attribute 'fallthrough' not preceding a case label or default label" }
+	}
+    case 5:
+      baz ();			// { dg-warning "this statement may fall through" }
+    case 4:			// { dg-message "here" }
+      qux ();
+      [[fallthrough]];		// { dg-error "attribute 'fallthrough' not preceding a case label or default label" }
+    }
+}
+
+void
+corge (int n)
+{
+  switch (n)
+    {
+    case 1:
+      {
+	int i = 0;
+	do
+	  {
+	    [[fallthrough]];	// { dg-error "attribute 'fallthrough' not preceding a case label or default label" }
+	  }
+	while (false);
+      }
+    case 2:
+      bar ();
+      break;
+    default:
+      break;
+    }
+}
+
+void
+fred (int n)
+{
+  switch (n)
+    {
+    case 1:
+      {
+	int i = 0;
+	[[fallthrough]];
+      }
+    case 2:
+      bar ();
+      break;
+    default:
+      break;
+    }
+}
diff --git a/gcc/testsuite/g++.dg/cpp0x/linkage2.C b/gcc/testsuite/g++.dg/cpp0x/linkage2.C
index 549bd82..34a36c4 100644
--- a/gcc/testsuite/g++.dg/cpp0x/linkage2.C
+++ b/gcc/testsuite/g++.dg/cpp0x/linkage2.C
@@ -29,5 +29,6 @@ void f() {
   ba.g(a);              // OK
   ba.h(a);              // error, B<T>::h never defined
   i(ba, a);             // OK
-  e1+e2+e3; // { dg-warning "arithmetic between different enumeration types" "" { target c++20 } }
+  e1+e2+e3; // { dg-warning "arithmetic between different enumeration types" "" { target { c++20 && c++23_down } } }
+	    // { dg-error "arithmetic between different enumeration types" "" { target c++26 } .-1 }
 }
diff --git a/gcc/testsuite/g++.dg/cpp0x/pr112365.C b/gcc/testsuite/g++.dg/cpp0x/pr112365.C
new file mode 100644
index 0000000..23409cb
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/pr112365.C
@@ -0,0 +1,8 @@
+// PR c++/112365
+// { dg-do compile { target c++11 } }
+// { dg-excess-errors "" }
+
+template <typename> struct A;
+template <typename T> A <T> foo (T;
+template <typename T> struct A { constexpr A : T {} }
+struct { bar ( { foo (this)
diff --git a/gcc/testsuite/g++.dg/cpp1z/nontype-auto22.C b/gcc/testsuite/g++.dg/cpp1z/nontype-auto22.C
new file mode 100644
index 0000000..1882d25
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1z/nontype-auto22.C
@@ -0,0 +1,17 @@
+// PR c++/104802
+// { dg-do compile { target c++17 } }
+
+template<auto const& ... Args>
+struct S {
+  template<typename=void>
+  void operator()() const {}
+};
+
+struct weird_ {
+  int operator&() const { return 123; }
+} const weird {};
+
+int main() {
+  S<weird> s {};
+  s();
+}
diff --git a/gcc/testsuite/g++.dg/cpp1z/utf8-neg.C b/gcc/testsuite/g++.dg/cpp1z/utf8-neg.C
index 7bca124..d9e982f 100644
--- a/gcc/testsuite/g++.dg/cpp1z/utf8-neg.C
+++ b/gcc/testsuite/g++.dg/cpp1z/utf8-neg.C
@@ -1,6 +1,6 @@
 /* { dg-do compile { target c++17 } } */
 
 const static char c0 = u8'';		// { dg-error "empty character" }
-const static char c1 = u8'ab';  	// { dg-error "character constant too long for its type" }
-const static char c2 = u8'\u0124';	// { dg-error "character constant too long for its type" }
-const static char c3 = u8'\U00064321';  // { dg-error "character constant too long for its type" }
+const static char c1 = u8'ab';  	// { dg-error "multi-character literal cannot have an encoding prefix" }
+const static char c2 = u8'\u0124';	// { dg-error "character not encodable in a single code unit" }
+const static char c3 = u8'\U00064321';  // { dg-error "character not encodable in a single code unit" }
diff --git a/gcc/testsuite/g++.dg/cpp23/auto-fncast13.C b/gcc/testsuite/g++.dg/cpp23/auto-fncast13.C
new file mode 100644
index 0000000..1bceffb
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/auto-fncast13.C
@@ -0,0 +1,61 @@
+// PR c++/112410
+// { dg-do compile { target c++23 } }
+
+int f1 (auto(int) -> char);
+int f2 (auto x);
+int f3 (auto);
+int f4 (auto(i));
+
+int v1 (auto(42));
+int v2 (auto{42});
+int e1 (auto{i}); // { dg-error "not declared" }
+int i;
+int v3 (auto{i});
+int v4 (auto(i + 1));
+int v5 (auto(+i));
+int v6 (auto(i = 4));
+
+int f5 (auto(i));
+int f6 (auto());
+int f7 (auto(int));
+int f8 (auto(f)(int));
+int f9 (auto(...) -> char);
+// FIXME: ICEs (PR c++/89867)
+//int f10 (auto(__attribute__((unused)) i));
+int f11 (auto((i)));
+int f12 (auto(i[]));
+int f13 (auto(*i));
+int f14 (auto(*));
+
+int e2 (auto{}); // { dg-error "invalid use of .auto." }
+int e3 (auto(i, i)); // { dg-error "invalid use of .auto." }
+
+char bar (int);
+char baz ();
+char qux (...);
+
+void
+g (int i)
+{
+  f1 (bar);
+  f2 (42);
+  f3 (42);
+  f4 (42);
+  f5 (42);
+  f6 (baz);
+  f7 (bar);
+  f8 (bar);
+  f9 (qux);
+//  f10 (42);
+  f11 (42);
+  f12 (&i);
+  f13 (&i);
+  f14 (&i);
+
+  v1 = 1;
+  v2 = 2;
+  v3 = 3;
+  v4 = 4;
+  v5 = 5;
+  v6 = 6;
+}
diff --git a/gcc/testsuite/g++.dg/cpp23/auto-fncast14.C b/gcc/testsuite/g++.dg/cpp23/auto-fncast14.C
new file mode 100644
index 0000000..9e7a06c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/auto-fncast14.C
@@ -0,0 +1,9 @@
+// PR c++/112410
+// { dg-do compile { target c++23 } }
+
+struct A {
+   A(int,int);
+};
+
+int a;
+A b1(auto(a), 42);
diff --git a/gcc/testsuite/g++.dg/cpp23/ext-floating16.C b/gcc/testsuite/g++.dg/cpp23/ext-floating16.C
new file mode 100644
index 0000000..d6a562d
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/ext-floating16.C
@@ -0,0 +1,40 @@
+// P1467R9 - Extended floating-point types and standard names.
+// { dg-do compile { target c++23 } }
+// { dg-options "-pedantic-errors -Wno-narrowing" }
+// { dg-add-options float16 }
+// { dg-add-options float32 }
+// { dg-add-options float64 }
+// { dg-add-options float128 }
+
+#include "ext-floating.h"
+
+#ifdef __STRICT_ANSI__
+#undef __SIZEOF_FLOAT128__
+#endif
+
+using namespace std;
+
+#ifdef __STDCPP_FLOAT16_T__
+#ifdef __STDCPP_FLOAT32_T__
+float16_t f16c = 1.0F32;		// { dg-bogus "converting to 'std::float16_t' \\\{aka '_Float16'\\\} from '_Float32' with greater conversion rank" "" { target { float16 && float32 } } }
+#endif
+#ifdef __STDCPP_FLOAT64_T__
+float16_t f16e = 1.0F64;		// { dg-bogus "converting to 'std::float16_t' \\\{aka '_Float16'\\\} from '_Float64' with greater conversion rank" "" { target { float16 && float64 } } }
+#endif
+#ifdef __STDCPP_FLOAT128_T__
+float16_t f16g = 1.0F128;		// { dg-bogus "converting to 'std::float16_t' \\\{aka '_Float16'\\\} from '_Float128' with greater conversion rank" "" { target { float16 && float128 } } }
+#endif
+#endif
+#ifdef __STDCPP_FLOAT32_T__
+#ifdef __STDCPP_FLOAT64_T__
+float32_t f32e = 1.0F64;		// { dg-bogus "converting to 'std::float32_t' \\\{aka '_Float32'\\\} from '_Float64' with greater conversion rank" "" { target { float32 && float64 } } }
+#endif
+#ifdef __STDCPP_FLOAT128_T__
+float32_t f32g = 1.0F128;		// { dg-bogus "converting to 'std::float32_t' \\\{aka '_Float32'\\\} from '_Float128' with greater conversion rank" "" { target { float32 && float128 } } }
+#endif
+#endif
+#ifdef __STDCPP_FLOAT64_T__
+#ifdef __STDCPP_FLOAT128_T__
+float64_t f64g = 1.0F128;		// { dg-bogus "converting to 'std::float64_t' \\\{aka '_Float64'\\\} from '_Float128' with greater conversion rank" "" { target { float64 && float128 } } }
+#endif
+#endif
diff --git a/gcc/testsuite/g++.dg/cpp23/ext-floating17.C b/gcc/testsuite/g++.dg/cpp23/ext-floating17.C
new file mode 100644
index 0000000..796e045
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/ext-floating17.C
@@ -0,0 +1,42 @@
+// P1467R9 - Extended floating-point types and standard names.
+// { dg-do compile { target c++23 } }
+// { dg-options "-Werror=narrowing" }
+// { dg-add-options float16 }
+// { dg-add-options float32 }
+// { dg-add-options float64 }
+// { dg-add-options float128 }
+// { dg-prune-output "some warnings being treated as errors" }
+
+#include "ext-floating.h"
+
+#ifdef __STRICT_ANSI__
+#undef __SIZEOF_FLOAT128__
+#endif
+
+using namespace std;
+
+#ifdef __STDCPP_FLOAT16_T__
+#ifdef __STDCPP_FLOAT32_T__
+float16_t f16c = 1.0F32;		// { dg-error "converting to 'std::float16_t' \\\{aka '_Float16'\\\} from '_Float32' with greater conversion rank" "" { target { float16 && float32 } } }
+#endif
+#ifdef __STDCPP_FLOAT64_T__
+float16_t f16e = 1.0F64;		// { dg-error "converting to 'std::float16_t' \\\{aka '_Float16'\\\} from '_Float64' with greater conversion rank" "" { target { float16 && float64 } } }
+#endif
+#ifdef __STDCPP_FLOAT128_T__
+float16_t f16g = 1.0F128;		// { dg-error "converting to 'std::float16_t' \\\{aka '_Float16'\\\} from '_Float128' with greater conversion rank" "" { target { float16 && float128 } } }
+#endif
+#endif
+#ifdef __STDCPP_FLOAT32_T__
+#ifdef __STDCPP_FLOAT64_T__
+float32_t f32e = 1.0F64;		// { dg-error "converting to 'std::float32_t' \\\{aka '_Float32'\\\} from '_Float64' with greater conversion rank" "" { target { float32 && float64 } } }
+#endif
+#ifdef __STDCPP_FLOAT128_T__
+float32_t f32g = 1.0F128;		// { dg-error "converting to 'std::float32_t' \\\{aka '_Float32'\\\} from '_Float128' with greater conversion rank" "" { target { float32 && float128 } } }
+#endif
+#endif
+#ifdef __STDCPP_FLOAT64_T__
+#ifdef __STDCPP_FLOAT128_T__
+float64_t f64g = 1.0F128;		// { dg-error "converting to 'std::float64_t' \\\{aka '_Float64'\\\} from '_Float128' with greater conversion rank" "" { target { float64 && float128 } } }
+#endif
+#endif
+
diff --git a/gcc/testsuite/g++.dg/cpp23/wchar-multi1.C b/gcc/testsuite/g++.dg/cpp23/wchar-multi1.C
index 77fa3a6..d86dfc9 100644
--- a/gcc/testsuite/g++.dg/cpp23/wchar-multi1.C
+++ b/gcc/testsuite/g++.dg/cpp23/wchar-multi1.C
@@ -4,18 +4,19 @@
 
 char a = 'a';
 int b = 'ab';			// { dg-warning "multi-character character constant" }
-int c = '\u05D9';		// { dg-warning "multi-character character constant" }
+int c = '\u05D9';		// { dg-error "character not encodable in a single execution character code unit" }
 #if __SIZEOF_INT__ > 2
-int d = '\U0001F525';		// { dg-warning "multi-character character constant" "" { target int32 } }
+int d = '\U0001F525';		// { dg-error "character not encodable in a single execution character code unit" "" { target int32 } }
 #endif
-int e = 'abcd';			// { dg-warning "multi-character character constant" }
+int e = 'abcd';			// { dg-warning "multi-character character constant" "" { target int32plus } }
+				// { dg-warning "multi-character literal with \[0-9]+ characters exceeds 'int' size of \[0-9]+ bytes" "" { target { ! int32plus } } .-1 }
 wchar_t f = L'f';
-wchar_t g = L'gh';		// { dg-error "character constant too long for its type" "" { target c++23 } }
-				// { dg-warning "character constant too long for its type" "" { target c++20_down } .-1 }
-wchar_t h = L'ijkl';		// { dg-error "character constant too long for its type" "" { target c++23 } }
-				// { dg-warning "character constant too long for its type" "" { target c++20_down } .-1 }
-wchar_t i = L'\U0001F525';	// { dg-error "character constant too long for its type" "" { target { c++23 && { ! 4byte_wchar_t } } } }
-				// { dg-warning "character constant too long for its type" "" { target { c++20_down && { ! 4byte_wchar_t } } } .-1 }
+wchar_t g = L'gh';		// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++23 } }
+				// { dg-warning "multi-character literal cannot have an encoding prefix" "" { target c++20_down } .-1 }
+wchar_t h = L'ijkl';		// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++23 } }
+				// { dg-warning "multi-character literal cannot have an encoding prefix" "" { target c++20_down } .-1 }
+wchar_t i = L'\U0001F525';	// { dg-error "multi-character literal cannot have an encoding prefix" "" { target { c++23 && { ! 4byte_wchar_t } } } }
+				// { dg-warning "multi-character literal cannot have an encoding prefix" "" { target { c++20_down && { ! 4byte_wchar_t } } } .-1 }
 #ifdef __cpp_char8_t
 typedef char8_t u8;
 #else
@@ -23,20 +24,20 @@ typedef char u8;
 #endif
 #if __cpp_unicode_characters >= 201411 
 u8 j = u8'j';
-u8 k = u8'kl';			// { dg-error "character constant too long for its type" "" { target c++17 } }
-u8 l = u8'\U0001F525';		// { dg-error "character constant too long for its type" "" { target c++17 }  }
+u8 k = u8'kl';			// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++17 } }
+u8 l = u8'\U0001F525';		// { dg-error "character not encodable in a single code unit" "" { target c++17 }  }
 #endif
 #if __cpp_unicode_characters >= 200704
 char16_t m = u'm';
-char16_t n = u'no';		// { dg-error "character constant too long for its type" "" { target c++11 } }
+char16_t n = u'no';		// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++11 } }
 char16_t o = u'\u05D9';
-char16_t p = u'\U0001F525';	// { dg-error "character constant too long for its type" "" { target c++11 } }
+char16_t p = u'\U0001F525';	// { dg-error "character not encodable in a single code unit" "" { target c++11 } }
 char32_t q = U'm';
-char32_t r = U'no';		// { dg-error "character constant too long for its type" "" { target c++11 } }
+char32_t r = U'no';		// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++11 } }
 char32_t s = U'\u05D9';
 char32_t t = U'\U0001F525';
 #endif
-wchar_t u = L'\u0065\u0301';		// { dg-error "character constant too long for its type" "" { target c++23 } }
-				// { dg-warning "character constant too long for its type" "" { target c++20_down } .-1 }
-wchar_t v = L'é';		// { dg-error "character constant too long for its type" "" { target c++23 } }
-				// { dg-warning "character constant too long for its type" "" { target c++20_down } .-1 }
+wchar_t u = L'\u0065\u0301';		// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++23 } }
+				// { dg-warning "multi-character literal cannot have an encoding prefix" "" { target c++20_down } .-1 }
+wchar_t v = L'é';		// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++23 } }
+				// { dg-warning "multi-character literal cannot have an encoding prefix" "" { target c++20_down } .-1 }
diff --git a/gcc/testsuite/g++.dg/cpp23/wchar-multi2.C b/gcc/testsuite/g++.dg/cpp23/wchar-multi2.C
index a63e0ff..270de65 100644
--- a/gcc/testsuite/g++.dg/cpp23/wchar-multi2.C
+++ b/gcc/testsuite/g++.dg/cpp23/wchar-multi2.C
@@ -11,12 +11,12 @@ int d = '\U0001F525';		// { dg-warning "multi-character character constant" "" {
 #endif
 int e = 'abcd';			// { dg-warning "multi-character character constant" }
 wchar_t f = L'f';
-wchar_t g = L'gh';		// { dg-error "character constant too long for its type" "" { target c++23 } }
-				// { dg-warning "character constant too long for its type" "" { target c++20_down } .-1 }
-wchar_t h = L'ijkl';		// { dg-error "character constant too long for its type" "" { target c++23 } }
-				// { dg-warning "character constant too long for its type" "" { target c++20_down } .-1 }
-wchar_t i = L'\U0001F525';	// { dg-error "character constant too long for its type" "" { target { c++23 } } }
-				// { dg-warning "character constant too long for its type" "" { target { c++20_down } } .-1 }
+wchar_t g = L'gh';		// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++23 } }
+				// { dg-warning "multi-character literal cannot have an encoding prefix" "" { target c++20_down } .-1 }
+wchar_t h = L'ijkl';		// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++23 } }
+				// { dg-warning "multi-character literal cannot have an encoding prefix" "" { target c++20_down } .-1 }
+wchar_t i = L'\U0001F525';	// { dg-error "character not encodable in a single code unit" "" { target { c++23 } } }
+				// { dg-warning "character not encodable in a single code unit" "" { target { c++20_down } } .-1 }
 #ifdef __cpp_char8_t
 typedef char8_t u8;
 #else
@@ -24,20 +24,20 @@ typedef char u8;
 #endif
 #if __cpp_unicode_characters >= 201411 
 u8 j = u8'j';
-u8 k = u8'kl';			// { dg-error "character constant too long for its type" "" { target c++17 } }
-u8 l = u8'\U0001F525';		// { dg-error "character constant too long for its type" "" { target c++17 }  }
+u8 k = u8'kl';			// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++17 } }
+u8 l = u8'\U0001F525';		// { dg-error "character not encodable in a single code unit" "" { target c++17 }  }
 #endif
 #if __cpp_unicode_characters >= 200704
 char16_t m = u'm';
-char16_t n = u'no';		// { dg-error "character constant too long for its type" "" { target c++11 } }
+char16_t n = u'no';		// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++11 } }
 char16_t o = u'\u05D9';
-char16_t p = u'\U0001F525';	// { dg-error "character constant too long for its type" "" { target c++11 } }
+char16_t p = u'\U0001F525';	// { dg-error "character not encodable in a single code unit" "" { target c++11 } }
 char32_t q = U'm';
-char32_t r = U'no';		// { dg-error "character constant too long for its type" "" { target c++11 } }
+char32_t r = U'no';		// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++11 } }
 char32_t s = U'\u05D9';
 char32_t t = U'\U0001F525';
 #endif
-wchar_t u = L'\u0065\u0301';		// { dg-error "character constant too long for its type" "" { target c++23 } }
-				// { dg-warning "character constant too long for its type" "" { target c++20_down } .-1 }
-wchar_t v = L'é';		// { dg-error "character constant too long for its type" "" { target c++23 } }
-				// { dg-warning "character constant too long for its type" "" { target c++20_down } .-1 }
+wchar_t u = L'\u0065\u0301';		// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++23 } }
+				// { dg-warning "multi-character literal cannot have an encoding prefix" "" { target c++20_down } .-1 }
+wchar_t v = L'é';		// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++23 } }
+				// { dg-warning "multi-character literal cannot have an encoding prefix" "" { target c++20_down } .-1 }
diff --git a/gcc/testsuite/g++.dg/cpp26/enum-conv1.C b/gcc/testsuite/g++.dg/cpp26/enum-conv1.C
new file mode 100644
index 0000000..5771435
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp26/enum-conv1.C
@@ -0,0 +1,39 @@
+// P2864R2 - Remove Deprecated Arithmetic Conversion on Enumerations From C++26
+// { dg-do compile { target c++20 } }
+
+enum A { a };
+enum B { b };
+
+template <auto X, auto Y> decltype (true ? X : Y) f1 () { throw 1; }
+// { dg-error "enumerated mismatch in conditional expression: 'A' vs 'B'" "" { target c++26 } .-1 }
+// { dg-error "conditional expression between enumeration type 'A' and floating-point type 'double'" "" { target c++26 } .-2 }
+// { dg-error "conditional expression between floating-point type 'double' and enumeration type 'A'" "" { target c++26 } .-3 }
+template <auto X, auto Y> decltype (X + Y) f2 () { throw 1; }
+// { dg-error "arithmetic between different enumeration types 'A' and 'B'" "" { target c++26 } .-1 }
+// { dg-error "arithmetic between enumeration type 'A' and floating-point type 'double'" "" { target c++26 } .-2 }
+// { dg-error "arithmetic between floating-point type 'double' and enumeration type 'A'" "" { target c++26 } .-3 }
+template <auto X, auto Y> decltype (X | Y) f3 () { throw 1; }
+// { dg-error "bitwise operation between different enumeration types 'A' and 'B'" "" { target c++26 } .-1 }
+template <auto X, auto Y> decltype (X < Y) f4 () { throw 1; }
+// { dg-error "comparison between 'enum A' and 'enum B'" "" { target c++26 } .-1 }
+// { dg-error "comparison of enumeration type 'A' with floating-point type 'double'" "" { target c++26 } .-2 }
+// { dg-error "comparison of floating-point type 'double' with enumeration type 'A'" "" { target c++26 } .-3 }
+
+int
+main ()
+{
+  f1<a, a> ();
+  f2<a, a> ();
+  f3<b, b> ();
+  f4<b, b> ();
+  f1<a, b> ();		// { dg-error "no matching function for call to" "" { target c++26 } }
+  f2<a, b> ();		// { dg-error "no matching function for call to" "" { target c++26 } }
+  f3<a, b> ();		// { dg-error "no matching function for call to" "" { target c++26 } }
+  f4<a, b> ();		// { dg-error "no matching function for call to" "" { target c++26 } }
+  f1<a, 0.0> ();	// { dg-error "no matching function for call to" "" { target c++26 } }
+  f2<a, 0.0> ();	// { dg-error "no matching function for call to" "" { target c++26 } }
+  f4<a, 0.0> ();	// { dg-error "no matching function for call to" "" { target c++26 } }
+  f1<0.0, a> ();	// { dg-error "no matching function for call to" "" { target c++26 } }
+  f2<0.0, a> ();	// { dg-error "no matching function for call to" "" { target c++26 } }
+  f4<0.0, a> ();	// { dg-error "no matching function for call to" "" { target c++26 } }
+}
diff --git a/gcc/testsuite/g++.dg/cpp26/literals1.C b/gcc/testsuite/g++.dg/cpp26/literals1.C
new file mode 100644
index 0000000..d51f2f8
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp26/literals1.C
@@ -0,0 +1,66 @@
+// C++26 P1854R4 - Making non-encodable string literals ill-formed
+// { dg-do compile { target c++11 } }
+// { dg-require-effective-target int32 }
+// { dg-options "-pedantic-errors -finput-charset=UTF-8 -fexec-charset=UTF-8" }
+
+int a = 'abcd';						// { dg-warning "multi-character character constant" }
+int b = '\x61\x62\x63\x64';				// { dg-warning "multi-character character constant" }
+int c = 'á';						// { dg-error "character not encodable in a single execution character code unit" }
+int d = '😁';						// { dg-error "character not encodable in a single execution character code unit" }
+int e = '\N{FACE WITH TEARS OF JOY}';			// { dg-error "character not encodable in a single execution character code unit" }
+							// { dg-error "named universal character escapes are only valid in" "" { target c++20_down } .-1 }
+int f = '\U0001F602';					// { dg-error "character not encodable in a single execution character code unit" }
+wchar_t g = L'abcd';					// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++23 } }
+							// { dg-warning "multi-character literal cannot have an encoding prefix" "" { target c++20_down } .-1 }
+wchar_t h = L'\x61\x62\x63\x64';			// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++23 } }
+							// { dg-warning "multi-character literal cannot have an encoding prefix" "" { target c++20_down } .-1 }
+wchar_t i = L'á';
+char16_t j = u'abcd';					// { dg-error "multi-character literal cannot have an encoding prefix" }
+char16_t k = u'\x61\x62\x63\x64';			// { dg-error "multi-character literal cannot have an encoding prefix" }
+char16_t l = u'á';
+char16_t m = u'😁';					// { dg-error "character not encodable in a single code unit" }
+char16_t n = u'\N{FACE WITH TEARS OF JOY}';		// { dg-error "character not encodable in a single code unit" { target c++23 } }
+							// { dg-error "named universal character escapes are only valid in" "" { target c++20_down } .-1 }
+char16_t o = u'\U0001F602';				// { dg-error "character not encodable in a single code unit" }
+char32_t p = U'abcd';					// { dg-error "multi-character literal cannot have an encoding prefix" }
+char32_t q = U'\x61\x62\x63\x64';			// { dg-error "multi-character literal cannot have an encoding prefix" }
+char32_t r = U'á';
+char32_t s = U'😁';
+char32_t t = U'\N{FACE WITH TEARS OF JOY}';		// { dg-error "named universal character escapes are only valid in" "" { target c++20_down } }
+char32_t u = U'\U0001F602';
+#if __cpp_unicode_characters >= 201411L
+auto v = u8'abcd';					// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++17 } }
+auto w = u8'\x61\x62\x63\x64';				// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++17 } }
+auto x = u8'á';						// { dg-error "character not encodable in a single code unit" "" { target c++17 } }
+auto y = u8'😁';					// { dg-error "character not encodable in a single code unit" "" { target c++17 } }
+auto z = u8'\N{FACE WITH TEARS OF JOY}';		// { dg-error "character not encodable in a single code unit" "" { target c++17 } }
+							// { dg-error "named universal character escapes are only valid in" "" { target { c++17 && c++20_down } } .-1 }
+auto aa = u8'\U0001F602';				// { dg-error "character not encodable in a single code unit" "" { target c++17 } }
+#endif
+const char *ab = "😁";
+const char *ac = "\N{FACE WITH TEARS OF JOY}";		// { dg-error "named universal character escapes are only valid in" "" { target c++20_down } }
+const char *ad = "\U0001F602";
+const char16_t *ae = u"😁";
+const char16_t *af = u"\N{FACE WITH TEARS OF JOY}";	// { dg-error "named universal character escapes are only valid in" "" { target c++20_down } }
+const char16_t *ag = u"\U0001F602";
+const char32_t *ah = U"😁";
+const char32_t *ai = U"\N{FACE WITH TEARS OF JOY}";	// { dg-error "named universal character escapes are only valid in" "" { target c++20_down } }
+const char32_t *aj = U"\U0001F602";
+auto ak = u8"😁";
+auto al = u8"\N{FACE WITH TEARS OF JOY}";		// { dg-error "named universal character escapes are only valid in" "" { target c++20_down } }
+auto am = u8"\U0001F602";
+int an = '\x123456789';					// { dg-error "hex escape sequence out of range" }
+wchar_t ao = L'\x123456789abcdef0';			// { dg-error "hex escape sequence out of range" }
+char16_t ap = u'\x12345678';				// { dg-error "hex escape sequence out of range" }
+char32_t aq = U'\x123456789abcdef0';			// { dg-error "hex escape sequence out of range" }
+#if __cpp_unicode_characters >= 201411L
+auto ar = u8'\x123456789abcdef0';			// { dg-error "hex escape sequence out of range" "" { target c++17 } }
+#endif
+char as = '\xff';
+#if __SIZEOF_WCHAR_T__ * __CHAR_BIT__ == 32
+wchar_t at = L'\xffffffff';
+#elif __SIZEOF_WCHAR_T__ * __CHAR_BIT__ == 16
+wchar_t at = L'\xffff';
+#endif
+int au = '\x1234';					// { dg-error "hex escape sequence out of range" }
+int av = 'abcdefghijklmnop';				// { dg-warning "multi-character literal with \[0-9]+ characters exceeds 'int' size of \[0-9]+ bytes" }
diff --git a/gcc/testsuite/g++.dg/cpp26/literals2.C b/gcc/testsuite/g++.dg/cpp26/literals2.C
new file mode 100644
index 0000000..11e4406
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp26/literals2.C
@@ -0,0 +1,68 @@
+// C++26 P1854R4 - Making non-encodable string literals ill-formed
+// { dg-do compile { target c++11 } }
+// { dg-require-effective-target int32 }
+// { dg-options "-pedantic-errors -finput-charset=UTF-8 -fexec-charset=ISO-8859-1" }
+/* { dg-require-iconv "ISO-8859-1" } */
+
+int a = 'abcd';						// { dg-warning "multi-character character constant" }
+int b = '\x61\x62\x63\x64';				// { dg-warning "multi-character character constant" }
+int c = 'á';
+int d = '😁';						// { dg-error "converting to execution character set" }
+int e = '\N{FACE WITH TEARS OF JOY}';			// { dg-error "converting UCN to execution character set" }
+							// { dg-error "named universal character escapes are only valid in" "" { target c++20_down } .-1 }
+int f = '\U0001F602';					// { dg-error "converting UCN to execution character set" }
+wchar_t g = L'abcd';					// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++23 } }
+							// { dg-warning "multi-character literal cannot have an encoding prefix" "" { target c++20_down } .-1 }
+wchar_t h = L'\x61\x62\x63\x64';			// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++23 } }
+							// { dg-warning "multi-character literal cannot have an encoding prefix" "" { target c++20_down } .-1 }
+wchar_t i = L'á';
+char16_t j = u'abcd';					// { dg-error "multi-character literal cannot have an encoding prefix" }
+char16_t k = u'\x61\x62\x63\x64';			// { dg-error "multi-character literal cannot have an encoding prefix" }
+char16_t l = u'á';
+char16_t m = u'😁';					// { dg-error "character not encodable in a single code unit" }
+char16_t n = u'\N{FACE WITH TEARS OF JOY}';		// { dg-error "character not encodable in a single code unit" { target c++23 } }
+							// { dg-error "named universal character escapes are only valid in" "" { target c++20_down } .-1 }
+char16_t o = u'\U0001F602';				// { dg-error "character not encodable in a single code unit" }
+char32_t p = U'abcd';					// { dg-error "multi-character literal cannot have an encoding prefix" }
+char32_t q = U'\x61\x62\x63\x64';			// { dg-error "multi-character literal cannot have an encoding prefix" }
+char32_t r = U'á';
+char32_t s = U'😁';
+char32_t t = U'\N{FACE WITH TEARS OF JOY}';		// { dg-error "named universal character escapes are only valid in" "" { target c++20_down } }
+char32_t u = U'\U0001F602';
+#if __cpp_unicode_characters >= 201411L
+auto v = u8'abcd';					// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++17 } }
+auto w = u8'\x61\x62\x63\x64';				// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++17 } }
+auto x = u8'á';						// { dg-error "character not encodable in a single code unit" "" { target c++17 } }
+auto y = u8'😁';					// { dg-error "character not encodable in a single code unit" "" { target c++17 } }
+auto z = u8'\N{FACE WITH TEARS OF JOY}';		// { dg-error "character not encodable in a single code unit" "" { target c++17 } }
+							// { dg-error "named universal character escapes are only valid in" "" { target { c++17 && c++20_down } } .-1 }
+auto aa = u8'\U0001F602';				// { dg-error "character not encodable in a single code unit" "" { target c++17 } }
+#endif
+const char *ab = "😁";					// { dg-error "converting to execution character set" }
+const char *ac = "\N{FACE WITH TEARS OF JOY}";		// { dg-error "converting UCN to execution character set" }
+							// { dg-error "named universal character escapes are only valid in" "" { target c++20_down } .-1 }
+const char *ad = "\U0001F602";				// { dg-error "converting UCN to execution character set" }
+const char16_t *ae = u"😁";
+const char16_t *af = u"\N{FACE WITH TEARS OF JOY}";	// { dg-error "named universal character escapes are only valid in" "" { target c++20_down } }
+const char16_t *ag = u"\U0001F602";
+const char32_t *ah = U"😁";
+const char32_t *ai = U"\N{FACE WITH TEARS OF JOY}";	// { dg-error "named universal character escapes are only valid in" "" { target c++20_down } }
+const char32_t *aj = U"\U0001F602";
+auto ak = u8"😁";
+auto al = u8"\N{FACE WITH TEARS OF JOY}";		// { dg-error "named universal character escapes are only valid in" "" { target c++20_down } }
+auto am = u8"\U0001F602";
+int an = '\x123456789';					// { dg-error "hex escape sequence out of range" }
+wchar_t ao = L'\x123456789abcdef0';			// { dg-error "hex escape sequence out of range" }
+char16_t ap = u'\x12345678';				// { dg-error "hex escape sequence out of range" }
+char32_t aq = U'\x123456789abcdef0';			// { dg-error "hex escape sequence out of range" }
+#if __cpp_unicode_characters >= 201411L
+auto ar = u8'\x123456789abcdef0';			// { dg-error "hex escape sequence out of range" "" { target c++17 } }
+#endif
+char as = '\xff';
+#if __SIZEOF_WCHAR_T__ * __CHAR_BIT__ == 32
+wchar_t at = L'\xffffffff';
+#elif __SIZEOF_WCHAR_T__ * __CHAR_BIT__ == 16
+wchar_t at = L'\xffff';
+#endif
+int au = '\x1234';					// { dg-error "hex escape sequence out of range" }
+int av = 'abcdefghijklmnop';				// { dg-warning "multi-character literal with \[0-9]+ characters exceeds 'int' size of \[0-9]+ bytes" }
diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-fn8.C b/gcc/testsuite/g++.dg/cpp2a/concepts-fn8.C
new file mode 100644
index 0000000..c63d26c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp2a/concepts-fn8.C
@@ -0,0 +1,26 @@
+// PR c++/111703
+// { dg-do compile { target c++20 } }
+
+template<class T>
+constexpr bool always_true() { return true; }
+
+struct P {
+  P() = default;
+
+  template<class T>
+    requires (always_true<T>()) // { dg-bogus "used before its definition" }
+  constexpr P(const T&) { }
+
+  int n, m;
+};
+
+void (*f)(P);
+P (*h)(P);
+
+template<class T>
+constexpr bool g() {
+  P x;
+  f(x); // { dg-bogus "from here" }
+  f(h(x)); // { dg-bogus "from here" }
+  return true;
+}
diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-partial-spec14.C b/gcc/testsuite/g++.dg/cpp2a/concepts-partial-spec14.C
new file mode 100644
index 0000000..c94b401
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp2a/concepts-partial-spec14.C
@@ -0,0 +1,10 @@
+// PR c++/98614
+// { dg-do compile { target c++20 } }
+
+template<class T>
+struct A;
+
+template<class T> requires true
+struct A<T> {
+  A(A<T> const&) = default;
+};
diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-requires37.C b/gcc/testsuite/g++.dg/cpp2a/concepts-requires37.C
new file mode 100644
index 0000000..fa4095e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp2a/concepts-requires37.C
@@ -0,0 +1,11 @@
+// PR c++/101043
+// { dg-do compile { target c++20 } }
+
+template<class T>
+void f(T t) {
+  [&](auto) noexcept(requires { t.g(); }) { }(0);
+}
+
+int main() {
+  f(0);
+}
diff --git a/gcc/testsuite/g++.dg/cpp2a/enum-conv1.C b/gcc/testsuite/g++.dg/cpp2a/enum-conv1.C
index 4571b5e..b59794d 100644
--- a/gcc/testsuite/g++.dg/cpp2a/enum-conv1.C
+++ b/gcc/testsuite/g++.dg/cpp2a/enum-conv1.C
@@ -14,11 +14,16 @@ void
 conv ()
 {
   bool b1 = e == e1;
-  bool b2 = e == f; // { dg-warning "comparison between .enum E1. and .enum E2." }
-  bool b3 = e == 0.0; // { dg-warning "comparison of enumeration type .E1. with floating-point type .double." "" { target c++20 } }
-  bool b4 = 0.0 == f; // { dg-warning "comparison of floating-point type .double. with enumeration type .E2." "" { target c++20 } }
-  int n1 = true ? e : f; // { dg-warning "enumerated mismatch" }
-  int n2 = true ? e : 0.0; // { dg-warning "conditional expression between" "" { target c++20 } }
+  bool b2 = e == f; // { dg-warning "comparison between .enum E1. and .enum E2." "" { target c++23_down } }
+		    // { dg-error "comparison between .enum E1. and .enum E2." "" { target c++26 } .-1 }
+  bool b3 = e == 0.0; // { dg-warning "comparison of enumeration type .E1. with floating-point type .double." "" { target { c++20 && c++23_down } } }
+		      // { dg-error "comparison of enumeration type .E1. with floating-point type .double." "" { target c++26 } .-1 }
+  bool b4 = 0.0 == f; // { dg-warning "comparison of floating-point type .double. with enumeration type .E2." "" { target { c++20 && c++23_down } } }
+		      // { dg-error "comparison of floating-point type .double. with enumeration type .E2." "" { target c++26 } .-1 }
+  int n1 = true ? e : f; // { dg-warning "enumerated mismatch" "" { target c++23_down } }
+			 // { dg-error "enumerated mismatch" "" { target c++26 } .-1 }
+  int n2 = true ? e : 0.0; // { dg-warning "conditional expression between" "" { target { c++20 && c++23_down } } }
+			   // { dg-error "conditional expression between" "" { target c++26 } .-1 }
 }
 
 int
@@ -29,42 +34,60 @@ enum_enum (bool b)
 
   r += e - e;
   r += e - e1;
-  r += e - f; // { dg-warning "arithmetic between different enumeration types .E1. and .E2." "" { target c++20 } }
-  r += f - e; // { dg-warning "arithmetic between different enumeration types .E2. and .E1." "" { target c++20 } }
-
+  r += e - f; // { dg-warning "arithmetic between different enumeration types .E1. and .E2." "" { target { c++20 && c++23_down } } }
+	      // { dg-error "arithmetic between different enumeration types .E1. and .E2." "" { target c++26 } .-1 }
+  r += f - e; // { dg-warning "arithmetic between different enumeration types .E2. and .E1." "" { target { c++20 && c++23_down } } }
+	      // { dg-error "arithmetic between different enumeration types .E2. and .E1." "" { target c++26 } .-1 }
   r += f + f;
-  r += f + e; // { dg-warning "arithmetic between different enumeration types .E2. and .E1." "" { target c++20 } }
-  r += e + f; // { dg-warning "arithmetic between different enumeration types .E1. and .E2." "" { target c++20 } }
+  r += f + e; // { dg-warning "arithmetic between different enumeration types .E2. and .E1." "" { target { c++20 && c++23_down } } }
+	      // { dg-error "arithmetic between different enumeration types .E2. and .E1." "" { target c++26 } .-1 }
+  r += e + f; // { dg-warning "arithmetic between different enumeration types .E1. and .E2." "" { target { c++20 && c++23_down } } }
+	      // { dg-error "arithmetic between different enumeration types .E1. and .E2." "" { target c++26 } .-1 }
 
-  r += e1 - e2; // { dg-warning "arithmetic between different enumeration types .E1. and .E2." "" { target c++20 } }
+  r += e1 - e2; // { dg-warning "arithmetic between different enumeration types .E1. and .E2." "" { target { c++20 && c++23_down } } }
+	      // { dg-error "arithmetic between different enumeration types .E1. and .E2." "" { target c++26 } .-1 }
   r += e1 - e1c;
   r += e1c - e1;
 
-  r += e * f; // { dg-warning "arithmetic between different enumeration types .E1. and .E2." "" { target c++20 } }
-  r += f * e; // { dg-warning "arithmetic between different enumeration types .E2. and .E1." "" { target c++20 } }
+  r += e * f; // { dg-warning "arithmetic between different enumeration types .E1. and .E2." "" { target { c++20 && c++23_down } } }
+	      // { dg-error "arithmetic between different enumeration types .E1. and .E2." "" { target c++26 } .-1 }
+  r += f * e; // { dg-warning "arithmetic between different enumeration types .E2. and .E1." "" { target { c++20 && c++23_down } } }
+	      // { dg-error "arithmetic between different enumeration types .E2. and .E1." "" { target c++26 } .-1 }
   r += e * e;
 
   r += e1 < e1c;
   r += e < e1;
-  r += e1 < e2; // { dg-warning "comparison between .enum E1. and .enum E2." }
-  r += e < f; // { dg-warning "comparison between .enum E1. and .enum E2." }
-  r += f < e; // { dg-warning "comparison between .enum E2. and .enum E1." }
+  r += e1 < e2; // { dg-warning "comparison between .enum E1. and .enum E2." "" { target c++23_down } }
+		// { dg-error "comparison between .enum E1. and .enum E2." "" { target c++26 } .-1 }
+  r += e < f; // { dg-warning "comparison between .enum E1. and .enum E2." "" { target c++23_down } }
+	      // { dg-error "comparison between .enum E1. and .enum E2." "" { target c++26 } .-1 }
+  r += f < e; // { dg-warning "comparison between .enum E2. and .enum E1." "" { target c++23_down } }
+	      // { dg-error "comparison between .enum E2. and .enum E1." "" { target c++26 } .-1 }
 
   r += e1 == e1c;
   r += e == e1;
-  r += e == f; // { dg-warning "comparison between .enum E1. and .enum E2." }
-  r += f == e; // { dg-warning "comparison between .enum E2. and .enum E1." }
-  r += e1 == e2; // { dg-warning "comparison between .enum E1. and .enum E2." }
-  r += e2 == e1; // { dg-warning "comparison between .enum E2. and .enum E1." }
+  r += e == f; // { dg-warning "comparison between .enum E1. and .enum E2." "" { target c++23_down } }
+	       // { dg-error "comparison between .enum E1. and .enum E2." "" { target c++26 } .-1 }
+  r += f == e; // { dg-warning "comparison between .enum E2. and .enum E1." "" { target c++23_down } }
+	       // { dg-error "comparison between .enum E2. and .enum E1." "" { target c++26 } .-1 }
+  r += e1 == e2; // { dg-warning "comparison between .enum E1. and .enum E2." "" { target c++23_down } }
+		 // { dg-error "comparison between .enum E1. and .enum E2." "" { target c++26 } .-1 }
+  r += e2 == e1; // { dg-warning "comparison between .enum E2. and .enum E1." "" { target c++23_down } }
+		 // { dg-error "comparison between .enum E2. and .enum E1." "" { target c++26 } .-1 }
 
   r += b ? e1 : e1c;
   r += b ? e1 : e;
-  r += b ? f : e; // { dg-warning "enumerated mismatch in conditional expression: .E2. vs .E1." }
-  r += b ? e1 : e2; // { dg-warning "enumerated mismatch in conditional expression: .E1. vs .E2." }
-
-  r += e | f; // { dg-warning "bitwise operation between different enumeration types .E1. and .E2." "" { target c++20 } }
-  r += e ^ f; // { dg-warning "bitwise operation between different enumeration types .E1. and .E2." "" { target c++20 } }
-  r += e & f; // { dg-warning "bitwise operation between different enumeration types .E1. and .E2." "" { target c++20 } }
+  r += b ? f : e; // { dg-warning "enumerated mismatch in conditional expression: .E2. vs .E1." "" { target c++23_down } }
+		  // { dg-error "enumerated mismatch in conditional expression: .E2. vs .E1." "" { target c++26 } .-1 }
+  r += b ? e1 : e2; // { dg-warning "enumerated mismatch in conditional expression: .E1. vs .E2." "" { target c++23_down } }
+		    // { dg-error "enumerated mismatch in conditional expression: .E1. vs .E2." "" { target c++26 } .-1 }
+
+  r += e | f; // { dg-warning "bitwise operation between different enumeration types .E1. and .E2." "" { target { c++20 && c++23_down } } }
+	      // { dg-error "bitwise operation between different enumeration types .E1. and .E2." "" { target c++26 } .-1 }
+  r += e ^ f; // { dg-warning "bitwise operation between different enumeration types .E1. and .E2." "" { target { c++20 && c++23_down } } }
+	      // { dg-error "bitwise operation between different enumeration types .E1. and .E2." "" { target c++26 } .-1 }
+  r += e & f; // { dg-warning "bitwise operation between different enumeration types .E1. and .E2." "" { target { c++20 && c++23_down } } }
+	      // { dg-error "bitwise operation between different enumeration types .E1. and .E2." "" { target c++26 } .-1 }
   r += !e;
   r += e1 | e;
 
@@ -76,10 +99,14 @@ enum_enum (bool b)
 
   // Anonymous enum.
   r += u1 - u1;
-  r += u1 + u2; // { dg-warning "arithmetic between different enumeration types" "" { target c++20 } }
-  r += u1 * u2; // { dg-warning "arithmetic between different enumeration types" "" { target c++20 } }
-  r += u1 == u2; // { dg-warning "comparison between" }
-  r += u1 & u2; // { dg-warning "bitwise operation between different enumeration types" "" { target c++20 } }
+  r += u1 + u2; // { dg-warning "arithmetic between different enumeration types" "" { target { c++20 && c++23_down } } }
+		// { dg-error "arithmetic between different enumeration types" "" { target c++26 } .-1 }
+  r += u1 * u2; // { dg-warning "arithmetic between different enumeration types" "" { target { c++20 && c++23_down } } }
+		// { dg-error "arithmetic between different enumeration types" "" { target c++26 } .-1 }
+  r += u1 == u2; // { dg-warning "comparison between" "" { target c++23_down } }
+		 // { dg-error "comparison between" "" { target c++26 } .-1 }
+  r += u1 & u2; // { dg-warning "bitwise operation between different enumeration types" "" { target { c++20 && c++23_down } } }
+		// { dg-error "bitwise operation between different enumeration types" "" { target c++26 } .-1 }
 
   return r;
 }
@@ -89,28 +116,47 @@ enum_float (bool b)
 {
   double r = 0.0;
 
-  r += e1 - d; // { dg-warning "arithmetic between enumeration type .E1. and floating-point type .double." "" { target c++20 } }
-  r += d - e1; // { dg-warning "arithmetic between floating-point type .double. and enumeration type .E1." "" { target c++20 } }
-  r += e1 + d; // { dg-warning "arithmetic between enumeration type .E1. and floating-point type .double." "" { target c++20 } }
-  r += d + e1; // { dg-warning "arithmetic between floating-point type .double. and enumeration type .E1." "" { target c++20 } }
-  r += e1 * d; // { dg-warning "arithmetic between enumeration type .E1. and floating-point type .double." "" { target c++20 } }
-  r += d * e1; // { dg-warning "arithmetic between floating-point type .double. and enumeration type .E1." "" { target c++20 } }
-  r += u1 * d; // { dg-warning "arithmetic between enumeration type" "" { target c++20 } }
-  r += d * u1; // { dg-warning "arithmetic between floating-point type" "" { target c++20 } }
-
-  r += e1 < d;  // { dg-warning "comparison of enumeration type .E1. with floating-point type .double." "" { target c++20 } }
-  r += d < e1;  // { dg-warning "comparison of floating-point type .double. with enumeration type .E1." "" { target c++20 } }
-  r += d == e1; // { dg-warning "comparison of floating-point type .double. with enumeration type .E1." "" { target c++20 } }
-  r += e1 == d; // { dg-warning "comparison of enumeration type .E1. with floating-point type .double." "" { target c++20 } }
-  r += u1 == d; // { dg-warning "comparison of enumeration type" "" { target c++20 } }
-  r += d == u1; // { dg-warning "comparison of floating-point type" "" { target c++20 } }
-
-  r += b ? e1 : d; // { dg-warning "conditional expression between enumeration type .E1. and floating-point type .double." "" { target c++20 } }
-  r += b ? d : e1; // { dg-warning "conditional expression between floating-point type .double. and enumeration type .E1." "" { target c++20 } }
-  r += b ? d : u1; // { dg-warning "conditional expression between" "" { target c++20 } }
-  r += b ? u1 : d; // { dg-warning "conditional expression between" "" { target c++20 } }
-
-  d += e1; // { dg-warning "arithmetic between floating-point type .double. and enumeration type .E1." "" { target c++20 } }
+  r += e1 - d; // { dg-warning "arithmetic between enumeration type .E1. and floating-point type .double." "" { target { c++20 && c++23_down } } }
+	       // { dg-error "arithmetic between enumeration type .E1. and floating-point type .double." "" { target c++26 } .-1 }
+  r += d - e1; // { dg-warning "arithmetic between floating-point type .double. and enumeration type .E1." "" { target { c++20 && c++23_down } } }
+	       // { dg-error "arithmetic between floating-point type .double. and enumeration type .E1." "" { target c++26 } .-1 }
+  r += e1 + d; // { dg-warning "arithmetic between enumeration type .E1. and floating-point type .double." "" { target { c++20 && c++23_down } } }
+	       // { dg-error "arithmetic between enumeration type .E1. and floating-point type .double." "" { target c++26 } .-1 }
+  r += d + e1; // { dg-warning "arithmetic between floating-point type .double. and enumeration type .E1." "" { target { c++20 && c++23_down } } }
+	       // { dg-error "arithmetic between floating-point type .double. and enumeration type .E1." "" { target c++26 } .-1 }
+  r += e1 * d; // { dg-warning "arithmetic between enumeration type .E1. and floating-point type .double." "" { target { c++20 && c++23_down } } }
+	       // { dg-error "arithmetic between enumeration type .E1. and floating-point type .double." "" { target c++26 } .-1 }
+  r += d * e1; // { dg-warning "arithmetic between floating-point type .double. and enumeration type .E1." "" { target { c++20 && c++23_down } } }
+	       // { dg-error "arithmetic between floating-point type .double. and enumeration type .E1." "" { target c++26 } .-1 }
+  r += u1 * d; // { dg-warning "arithmetic between enumeration type" "" { target { c++20 && c++23_down } } }
+	       // { dg-error "arithmetic between enumeration type" "" { target c++26 } .-1 }
+  r += d * u1; // { dg-warning "arithmetic between floating-point type" "" { target { c++20 && c++23_down } } }
+	       // { dg-error "arithmetic between floating-point type" "" { target c++26 } .-1 }
+
+  r += e1 < d;  // { dg-warning "comparison of enumeration type .E1. with floating-point type .double." "" { target { c++20 && c++23_down } } }
+		// { dg-error "comparison of enumeration type .E1. with floating-point type .double." "" { target c++26 } .-1 }
+  r += d < e1;  // { dg-warning "comparison of floating-point type .double. with enumeration type .E1." "" { target { c++20 && c++23_down } } }
+		// { dg-error "comparison of floating-point type .double. with enumeration type .E1." "" { target c++26 } .-1 }
+  r += d == e1; // { dg-warning "comparison of floating-point type .double. with enumeration type .E1." "" { target { c++20 && c++23_down } } }
+		// { dg-error "comparison of floating-point type .double. with enumeration type .E1." "" { target c++26 } .-1 }
+  r += e1 == d; // { dg-warning "comparison of enumeration type .E1. with floating-point type .double." "" { target { c++20 && c++23_down } } }
+		// { dg-error "comparison of enumeration type .E1. with floating-point type .double." "" { target c++26 } .-1 }
+  r += u1 == d; // { dg-warning "comparison of enumeration type" "" { target { c++20 && c++23_down } } }
+		// { dg-error "comparison of enumeration type" "" { target c++26 } .-1 }
+  r += d == u1; // { dg-warning "comparison of floating-point type" "" { target { c++20 && c++23_down } } }
+		// { dg-error "comparison of floating-point type" "" { target c++26 } .-1 }
+
+  r += b ? e1 : d; // { dg-warning "conditional expression between enumeration type .E1. and floating-point type .double." "" { target { c++20 && c++23_down } } }
+		   // { dg-error "conditional expression between enumeration type .E1. and floating-point type .double." "" { target c++26 } .-1 }
+  r += b ? d : e1; // { dg-warning "conditional expression between floating-point type .double. and enumeration type .E1." "" { target { c++20 && c++23_down } } }
+		   // { dg-error "conditional expression between floating-point type .double. and enumeration type .E1." "" { target c++26 } .-1 }
+  r += b ? d : u1; // { dg-warning "conditional expression between" "" { target { c++20 && c++23_down } } }
+		   // { dg-error "conditional expression between" "" { target c++26 } .-1 }
+  r += b ? u1 : d; // { dg-warning "conditional expression between" "" { target { c++20 && c++23_down } } }
+		   // { dg-error "conditional expression between" "" { target c++26 } .-1 }
+
+  d += e1; // { dg-warning "arithmetic between floating-point type .double. and enumeration type .E1." "" { target { c++20 && c++23_down } } }
+	   // { dg-error "arithmetic between floating-point type .double. and enumeration type .E1." "" { target c++26 } .-1 }
   d = e1;
 
   return r;
diff --git a/gcc/testsuite/g++.dg/cpp2a/ucn2.C b/gcc/testsuite/g++.dg/cpp2a/ucn2.C
index ee7011b..53ee06e 100644
--- a/gcc/testsuite/g++.dg/cpp2a/ucn2.C
+++ b/gcc/testsuite/g++.dg/cpp2a/ucn2.C
@@ -12,18 +12,18 @@ const char32_t *f = U"\uD802";		// { dg-error "is not a valid universal characte
 const char32_t *g = U"\U0000DFF0";	// { dg-error "is not a valid universal character" }
 const char32_t *h = U"\U00110001";	// { dg-error "is outside the UCS codespace" "" { target c++20 } }
 #if __cpp_unicode_characters >= 201411
-const char8_t i = u8'\u00C0';		// { dg-error "character constant too long for its type" "" { target c++17 } }
+const char8_t i = u8'\u00C0';		// { dg-error "character not encodable in a single code unit" "" { target c++17 } }
 #endif
-const char16_t j = u'\U0001F914';	// { dg-error "character constant too long for its type" }
+const char16_t j = u'\U0001F914';	// { dg-error "character not encodable in a single code unit" }
 const char32_t k = U'\U0001F914';
 #if __cpp_unicode_characters >= 201411
-const char8_t l = u8'ab';		// { dg-error "character constant too long for its type" "" { target c++17 } }
+const char8_t l = u8'ab';		// { dg-error "multi-character literal cannot have an encoding prefix" "" { target c++17 } }
 #endif
-const char16_t m = u'ab';		// { dg-error "character constant too long for its type" }
-const char32_t n = U'ab';		// { dg-error "character constant too long for its type" }
+const char16_t m = u'ab';		// { dg-error "multi-character literal cannot have an encoding prefix" }
+const char32_t n = U'ab';		// { dg-error "multi-character literal cannot have an encoding prefix" }
 #if __cpp_unicode_characters >= 201411
 const char8_t o = u8'\U00110002';	// { dg-error "is outside the UCS codespace" "" { target c++20 } }
-					// { dg-error "character constant too long for its type" "" { target c++17 } .-1 }
+					// { dg-error "character not encodable in a single code unit" "" { target c++17 } .-1 }
 #endif
 const char16_t p = u'\U00110003';	// { dg-error "is outside the UCS codespace" "" { target c++20 } }
 					// { dg-error "converting UCN to execution character set" "" { target *-*-* } .-1 }
diff --git a/gcc/testsuite/g++.dg/diagnostic/constexpr4.C b/gcc/testsuite/g++.dg/diagnostic/constexpr4.C
new file mode 100644
index 0000000..f37c01c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/diagnostic/constexpr4.C
@@ -0,0 +1,9 @@
+// Verify we diagnose a call to a non-constant function pointer ahead of time.
+// { dg-do compile { target c++11 } }
+
+bool (*f)(int);
+
+template<int N>
+void g() {
+  static_assert(f(N), ""); // { dg-error "non-constant|'f' is not usable" }
+}
diff --git a/gcc/testsuite/g++.dg/diagnostic/enum3.C b/gcc/testsuite/g++.dg/diagnostic/enum3.C
index d51aa8a..acddb53 100644
--- a/gcc/testsuite/g++.dg/diagnostic/enum3.C
+++ b/gcc/testsuite/g++.dg/diagnostic/enum3.C
@@ -5,5 +5,6 @@ enum e1 { e1val };
 enum e2 { e3val };
 
 int main( int, char * [] ) {
-   if ( e1val == e3val ) return 1; // { dg-warning -Wenum-compare }
+   if ( e1val == e3val ) return 1; // { dg-warning "comparison between 'enum e1' and 'enum e2'" "" { target c++23_down } }
+				   // { dg-error "comparison between 'enum e1' and 'enum e2'" "" { target c++26 } .-1 }
 }
diff --git a/gcc/testsuite/g++.dg/ext/utf16-4.C b/gcc/testsuite/g++.dg/ext/utf16-4.C
index 030e085..feb8166 100644
--- a/gcc/testsuite/g++.dg/ext/utf16-4.C
+++ b/gcc/testsuite/g++.dg/ext/utf16-4.C
@@ -4,8 +4,8 @@
 
 
 const static char16_t	c0 = u'';		/* { dg-error "empty character" } */
-const static char16_t	c1 = u'ab';		/* { dg-error "constant too long" } */
-const static char16_t	c2 = u'\U00064321';	/* { dg-error "constant too long" } */
+const static char16_t	c1 = u'ab';		/* { dg-error "multi-character literal cannot have an encoding prefix" } */
+const static char16_t	c2 = u'\U00064321';	/* { dg-error "character not encodable in a single code unit" } */
 
 const static char16_t	c3 = 'a';
 const static char16_t	c4 = U'a';
@@ -14,5 +14,6 @@ const static char16_t	c6 = U'\U00064321';	/* { dg-warning "conversion from .char
 const static char16_t	c7 = L'a';
 const static char16_t	c8 = L'\u2029';
 const static char16_t	c9 = L'\U00064321';	/* { dg-warning "conversion from .wchar_t. to .char16_t. changes value from .410401. to .17185." "" { target { 4byte_wchar_t } } } */
-						/* { dg-warning "constant too long" "" { target { ! 4byte_wchar_t } } .-1 } */
+						/* { dg-warning "character not encodable in a single code unit" "" { target { { ! 4byte_wchar_t } && c++20_down } } .-1 } */
+						/* { dg-error "character not encodable in a single code unit" "" { target { { ! 4byte_wchar_t } && c++23 } } .-2 } */
 int main () {}
diff --git a/gcc/testsuite/g++.dg/ext/utf32-4.C b/gcc/testsuite/g++.dg/ext/utf32-4.C
index 96bf0bb..8310bf4 100644
--- a/gcc/testsuite/g++.dg/ext/utf32-4.C
+++ b/gcc/testsuite/g++.dg/ext/utf32-4.C
@@ -3,15 +3,16 @@
 /* { dg-do compile { target c++11 } } */
 
 const static char32_t	c0 = U'';		/* { dg-error "empty character" } */
-const static char32_t	c1 = U'ab';		/* { dg-error "constant too long" } */
+const static char32_t	c1 = U'ab';		/* { dg-error "multi-character literal cannot have an encoding prefix" } */
 const static char32_t	c2 = U'\U00064321';
 
 const static char32_t	c3 = 'a';
 const static char32_t	c4 = u'a';
 const static char32_t	c5 = u'\u2029';
-const static char32_t	c6 = u'\U00064321';	/* { dg-error "constant too long" } */
+const static char32_t	c6 = u'\U00064321';	/* { dg-error "character not encodable in a single code unit" } */
 const static char32_t	c7 = L'a';
 const static char32_t	c8 = L'\u2029';
-const static char32_t	c9 = L'\U00064321';     /* { dg-warning "constant too long" "" { target { ! 4byte_wchar_t } } } */  
+const static char32_t	c9 = L'\U00064321';     /* { dg-warning "character not encodable in a single code unit" "" { target { { ! 4byte_wchar_t } && c++20_down } } } */
+						/* { dg-error "character not encodable in a single code unit" "" { target { { ! 4byte_wchar_t } && c++23 } } .-1 } */
 
 int main () {}
diff --git a/gcc/testsuite/g++.dg/modules/pr103499_a.C b/gcc/testsuite/g++.dg/modules/pr103499_a.C
new file mode 100644
index 0000000..0497c2c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/modules/pr103499_a.C
@@ -0,0 +1,12 @@
+// PR c++/103499
+// { dg-module-do compile }
+// { dg-additional-options "-fmodules-ts" }
+// { dg-module-cmi pr103499 }
+
+export module pr103499;
+
+export struct base {
+  virtual ~base() = default;
+};
+
+export struct derived : base {};
diff --git a/gcc/testsuite/g++.dg/modules/pr103499_b.C b/gcc/testsuite/g++.dg/modules/pr103499_b.C
new file mode 100644
index 0000000..b746856
--- /dev/null
+++ b/gcc/testsuite/g++.dg/modules/pr103499_b.C
@@ -0,0 +1,8 @@
+// PR c++/103499
+// { dg-additional-options "-fmodules-ts" }
+
+import pr103499;
+
+void test(derived* p) {
+  delete p;
+}
diff --git a/gcc/testsuite/g++.dg/modules/using-9.C b/gcc/testsuite/g++.dg/modules/using-9.C
new file mode 100644
index 0000000..4290280
--- /dev/null
+++ b/gcc/testsuite/g++.dg/modules/using-9.C
@@ -0,0 +1,13 @@
+// PR c++/106849
+// { dg-additional-options "-fmodules-ts" }
+// { dg-module-cmi !lib }
+
+export module lib;
+
+namespace outer {
+  template<typename T> void any_of(T) { }  // { dg-note "declared here" }
+}
+
+export using outer::any_of;  // { dg-error "does not have external linkage" }
+
+// { dg-prune-output "not writing module" }
diff --git a/gcc/testsuite/g++.dg/opt/pr112374.C b/gcc/testsuite/g++.dg/opt/pr112374.C
new file mode 100644
index 0000000..15d8a06
--- /dev/null
+++ b/gcc/testsuite/g++.dg/opt/pr112374.C
@@ -0,0 +1,24 @@
+// PR tree-optimization/112374
+// { dg-do compile { target c++11 } }
+// { dg-options "-fcompare-debug -gno-statement-frontiers -O2" }
+// { dg-additional-options "-march=skylake-avx512" { target i?86-*-* x86_64-*-* } }
+// { dg-additional-options "-march=armv9-a" { target aarch64*-*-* } }
+
+struct t
+{
+  long coef[1];
+  t(const unsigned long &a) : coef{(long)a} {};
+  t(const t &a);
+};
+extern void gen_int_mode(t, int);
+struct expand_vec_perm_d {
+  unsigned char perm[64];
+  int vmode;
+  unsigned char nelt;
+};
+void expand_vec_perm_blend(struct expand_vec_perm_d *d) {
+  unsigned long mask = 0;
+  for (unsigned i = 0; i < 4; ++i)
+    mask |= (d->perm[i] >= 4 ? 3 : 0) << (i * 2);
+  gen_int_mode(mask, 0);
+}
diff --git a/gcc/testsuite/g++.dg/parse/attr3.C b/gcc/testsuite/g++.dg/parse/attr3.C
index de09598..7362905 100644
--- a/gcc/testsuite/g++.dg/parse/attr3.C
+++ b/gcc/testsuite/g++.dg/parse/attr3.C
@@ -10,5 +10,6 @@ int main () {
     S::F y;	// { dg-warning "'F' is deprecated" }
     y = S::f;
 
-    return x + y; // { dg-warning "arithmetic between different enumeration types" "" { target c++20 } }
+    return x + y; // { dg-warning "arithmetic between different enumeration types" "" { target { c++20 && c++23_down } } }
+		  // { dg-error "arithmetic between different enumeration types" "" { target c++26 } .-1 }
 }
diff --git a/gcc/testsuite/g++.dg/pch/main-file-warnings.C b/gcc/testsuite/g++.dg/pch/main-file-warnings.C
new file mode 100644
index 0000000..a9e8b0b
--- /dev/null
+++ b/gcc/testsuite/g++.dg/pch/main-file-warnings.C
@@ -0,0 +1,7 @@
+/* PR pch/9471 */
+/* PR pch/47857 */
+/* Test will fail if any warnings get issued while compiling the header into a PCH.  */
+#include "main-file-warnings.H"
+#pragma once /* { dg-warning "in main file" } */
+#pragma GCC system_header /* { dg-warning "outside include file" } */
+#include_next <stdint.h> /* { dg-warning "in primary source file" } */
diff --git a/gcc/testsuite/g++.dg/pch/main-file-warnings.Hs b/gcc/testsuite/g++.dg/pch/main-file-warnings.Hs
new file mode 100644
index 0000000..d1582bb
--- /dev/null
+++ b/gcc/testsuite/g++.dg/pch/main-file-warnings.Hs
@@ -0,0 +1,3 @@
+#pragma once /* { dg-bogus "in main file" } */
+#pragma GCC system_header /* { dg-bogus "outside include file" } */
+#include_next <stdint.h> /* { dg-bogus "in primary source file" } */
diff --git a/gcc/testsuite/g++.dg/template/non-dependent29.C b/gcc/testsuite/g++.dg/template/non-dependent29.C
new file mode 100644
index 0000000..41bd11a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/non-dependent29.C
@@ -0,0 +1,13 @@
+// PR c++/112427
+
+struct A { int m; void f(); };
+struct B { A a; };
+
+template<class T>
+void f(B b) {
+  int A::*pd = &A::m;
+  b.a.*pd;
+
+  void (A::*pf)() = &A::f;
+  (b.a.*pf)();
+}
diff --git a/gcc/testsuite/g++.dg/template/non-dependent30.C b/gcc/testsuite/g++.dg/template/non-dependent30.C
new file mode 100644
index 0000000..32d48e4
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/non-dependent30.C
@@ -0,0 +1,9 @@
+// PR c++/112515
+// { dg-do compile { target c++11 } }
+
+enum E : int { };
+
+template<class T>
+E f(T t) {
+  return E{t.e};
+}
diff --git a/gcc/testsuite/g++.dg/tsan/pthread_cond_clockwait.C b/gcc/testsuite/g++.dg/tsan/pthread_cond_clockwait.C
index 82d6a5c..b43f3eb 100644
--- a/gcc/testsuite/g++.dg/tsan/pthread_cond_clockwait.C
+++ b/gcc/testsuite/g++.dg/tsan/pthread_cond_clockwait.C
@@ -4,6 +4,19 @@
 
 #include <pthread.h>
 
+// This overloaded version should only be selected on targets that
+// don't have a pthread_cond_clockwait in pthread.h, and it will wait
+// indefinitely for the cond_signal that, in this testcase, ought to
+// be delivered.
+static inline int
+pthread_cond_clockwait (pthread_cond_t *cv,
+			pthread_mutex_t *mtx,
+			__clockid_t,
+			void const /* struct timespec */ *)
+{
+  return pthread_cond_wait (cv, mtx);
+}		   
+
 pthread_cond_t cv;
 pthread_mutex_t mtx;
 
diff --git a/gcc/testsuite/g++.target/loongarch/vect-copysign-negconst-run.C b/gcc/testsuite/g++.target/loongarch/vect-copysign-negconst-run.C
new file mode 100644
index 0000000..d2d5d15
--- /dev/null
+++ b/gcc/testsuite/g++.target/loongarch/vect-copysign-negconst-run.C
@@ -0,0 +1,47 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -march=loongarch64 -mlasx -mno-strict-align" } */
+/* { dg-require-effective-target loongarch_asx_hw } */
+
+#include "vect-copysign-negconst.C"
+
+double d[] = {1.2, -3.4, -5.6, 7.8};
+float f[] = {1.2, -3.4, -5.6, 7.8, -9.0, -11.4, 51.4, 1919.810};
+
+double _abs(double x) { return __builtin_fabs (x); }
+float _abs(float x) { return __builtin_fabsf (x); }
+
+template <class T>
+void
+check (T *arr, T *orig, int len)
+{
+  for (int i = 0; i < len; i++)
+    {
+      if (arr[i] > 0)
+	__builtin_trap ();
+      if (_abs (arr[i]) != _abs (orig[i]))
+	__builtin_trap ();
+    }
+}
+
+int
+main()
+{
+  double test_d[4];
+  float test_f[8];
+
+  __builtin_memcpy (test_d, d, sizeof (test_d));
+  force_negative<2> (test_d);
+  check (test_d, d, 2);
+
+  __builtin_memcpy (test_d, d, sizeof (test_d));
+  force_negative<4> (test_d);
+  check (test_d, d, 4);
+
+  __builtin_memcpy (test_f, f, sizeof (test_f));
+  force_negative<4> (test_f);
+  check (test_f, f, 4);
+
+  __builtin_memcpy (test_f, f, sizeof (test_f));
+  force_negative<8> (test_f);
+  check (test_f, f, 8);
+}
diff --git a/gcc/testsuite/g++.target/loongarch/vect-copysign-negconst.C b/gcc/testsuite/g++.target/loongarch/vect-copysign-negconst.C
new file mode 100644
index 0000000..5e8820d
--- /dev/null
+++ b/gcc/testsuite/g++.target/loongarch/vect-copysign-negconst.C
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -march=loongarch64 -mlasx -mno-strict-align" } */
+/* { dg-final { scan-assembler "\txvbitseti.*63" } } */
+/* { dg-final { scan-assembler "\txvbitseti.*31" } } */
+/* { dg-final { scan-assembler "\tvbitseti.*63" } } */
+/* { dg-final { scan-assembler "\tvbitseti.*31" } } */
+
+template <int N>
+__attribute__ ((noipa)) void
+force_negative (float *arr)
+{
+  for (int i = 0; i < N; i++)
+    arr[i] = __builtin_copysignf (arr[i], -2);
+}
+
+template <int N>
+__attribute__ ((noipa)) void
+force_negative (double *arr)
+{
+  for (int i = 0; i < N; i++)
+    arr[i] = __builtin_copysign (arr[i], -3);
+}
+
+template void force_negative<4>(float *);
+template void force_negative<8>(float *);
+template void force_negative<2>(double *);
+template void force_negative<4>(double *);
diff --git a/gcc/testsuite/g++.target/s390/zvec-templ-1.C b/gcc/testsuite/g++.target/s390/zvec-templ-1.C
new file mode 100644
index 0000000..07bb65f
--- /dev/null
+++ b/gcc/testsuite/g++.target/s390/zvec-templ-1.C
@@ -0,0 +1,24 @@
+// { dg-do compile }
+// { dg-options "-O0 -mzvector -march=arch14 -mzarch" }
+// { dg-bogus "internal compiler error" "ICE" { target s390*-*-* } 23 }
+// { dg-excess-errors "" }
+
+/* This used to ICE with checking enabled because
+   s390_resolve_overloaded_builtin gets called on NON_DEPENDENT_EXPR
+   arguments. We then try to determine the type of it, get an error
+   node and ICEd consequently when using this.
+
+   This particular instance of the problem disappeared when
+   NON_DEPENDENT_EXPRs got removed with:
+
+   commit dad311874ac3b3cf4eca1c04f67cae80c953f7b8
+   Author: Patrick Palka <ppalka@redhat.com>
+   Date:   Fri Oct 20 10:45:00 2023 -0400
+
+    c++: remove NON_DEPENDENT_EXPR, part 1
+
+   Nevertheless we should check for error mark nodes in that code.  */
+
+template <typename> void foo() {
+  __builtin_s390_vec_perm( , , );
+}
diff --git a/gcc/testsuite/gcc.c-torture/execute/931004-13.c b/gcc/testsuite/gcc.c-torture/execute/931004-13.c
index 8b79679..e8c0c81 100644
--- a/gcc/testsuite/gcc.c-torture/execute/931004-13.c
+++ b/gcc/testsuite/gcc.c-torture/execute/931004-13.c
@@ -43,8 +43,8 @@ f (int n, struct tiny x, struct tiny y, struct tiny z, long l)
     abort ();
 }
 
-void
-main (int)
+int
+main (void)
 {
   struct tiny x[3];
   x[0].c = 10;
diff --git a/gcc/testsuite/gcc.dg/20020206-1.c b/gcc/testsuite/gcc.dg/20020206-1.c
index c8d8b61..a5a9cb0 100644
--- a/gcc/testsuite/gcc.dg/20020206-1.c
+++ b/gcc/testsuite/gcc.dg/20020206-1.c
@@ -5,6 +5,7 @@
 /* { dg-do run } */
 /* { dg-options "-O2 -fprefetch-loop-arrays" } */
 /* { dg-options "-O2 -fprefetch-loop-arrays -mtune=pentium3" { target { { i?86-*-* x86_64-*-* } && ia32 } } } */
+/* { dg-prune-output  ".-fprefetch-loop-arrays. not supported for this target" } */
 
 
 struct reload
diff --git a/gcc/testsuite/gcc.dg/analyzer/boxed-malloc-1.c b/gcc/testsuite/gcc.dg/analyzer/boxed-malloc-1.c
index 435fb4f..6b6bba3 100644
--- a/gcc/testsuite/gcc.dg/analyzer/boxed-malloc-1.c
+++ b/gcc/testsuite/gcc.dg/analyzer/boxed-malloc-1.c
@@ -141,7 +141,7 @@ void test_12 (void)
 
   while (1)
     {
-      free (ptr.value);
+      free (ptr.value); /* { dg-warning "infinite loop" } */
       free (ptr.value); /* { dg-warning "double-'free' of 'ptr.value'" } */
     }
 }
diff --git a/gcc/testsuite/gcc.dg/analyzer/data-model-20.c b/gcc/testsuite/gcc.dg/analyzer/data-model-20.c
index ff65883..59f6285 100644
--- a/gcc/testsuite/gcc.dg/analyzer/data-model-20.c
+++ b/gcc/testsuite/gcc.dg/analyzer/data-model-20.c
@@ -14,7 +14,11 @@ test (int n) {
 
   for (i = 0; i < n; i++) {
     if ((arr[i] = (struct foo *)malloc(sizeof(struct foo))) == NULL) {
-      for (; i >= 0; i++) {
+      for (; i >= 0; i++) { /* { dg-warning "infinite loop" } */
+	/* This loop is in the wrong direction, so not technically an
+	   infinite loop ("i" will eventually wrap around), but the
+	   analyzer's condition handling treats the overflow as such.
+	   In any case, the code is suspect and warrants a warning.  */
 	free(arr[i]); /* { dg-bogus "double-'free'" } */
       }
       free(arr); /* { dg-warning "leak" } */
diff --git a/gcc/testsuite/gcc.dg/analyzer/data-model-20a.c b/gcc/testsuite/gcc.dg/analyzer/data-model-20a.c
new file mode 100644
index 0000000..767b991
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/analyzer/data-model-20a.c
@@ -0,0 +1,25 @@
+/* { dg-additional-options "-Wno-analyzer-too-complex" } */
+
+#include <stdlib.h>
+
+struct foo { int dummy; };
+
+struct foo **
+test (int n) {
+  struct foo **arr;
+  int i;
+
+  if ((arr = (struct foo **)malloc(n * sizeof(struct foo *))) == NULL)
+    return NULL;
+
+  for (i = 0; i < n; i++) {
+    if ((arr[i] = (struct foo *)malloc(sizeof(struct foo))) == NULL) {
+      for (; i >= 0; i--) {
+	free(arr[i]); /* { dg-bogus "double-'free'" } */
+      }
+      free(arr); /* { dg-bogus "leak" "" { xfail *-*-* } } */
+      return NULL;
+    }
+  }
+  return arr;
+}
diff --git a/gcc/testsuite/gcc.dg/analyzer/edges-1.c b/gcc/testsuite/gcc.dg/analyzer/edges-1.c
index f08a614..644a2df 100644
--- a/gcc/testsuite/gcc.dg/analyzer/edges-1.c
+++ b/gcc/testsuite/gcc.dg/analyzer/edges-1.c
@@ -15,6 +15,8 @@ void test_1 (const char *path, int flag)
   if (!fp) /* { dg-message "when 'fp' is non-NULL" } */
     return;
 
+  bar ();
+
   /* We shouldn't report this control flow.  */
   while (foo ()) /* { dg-bogus "" } */
     bar ();
diff --git a/gcc/testsuite/gcc.dg/analyzer/explode-2a.c b/gcc/testsuite/gcc.dg/analyzer/explode-2a.c
index 32c71ca..d07ce5b 100644
--- a/gcc/testsuite/gcc.dg/analyzer/explode-2a.c
+++ b/gcc/testsuite/gcc.dg/analyzer/explode-2a.c
@@ -14,7 +14,7 @@ void test (void)
      explode-2.c as this code.  */
   int a = get ();
   int b = get ();
-  while (a)
+  while (a) /* { dg-warning "infinite loop" } */
     {
       switch (b)
 	{
diff --git a/gcc/testsuite/gcc.dg/analyzer/infinite-loop-1.c b/gcc/testsuite/gcc.dg/analyzer/infinite-loop-1.c
new file mode 100644
index 0000000..c3515bb
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/analyzer/infinite-loop-1.c
@@ -0,0 +1,235 @@
+/* { dg-additional-options "-O0" } */
+
+extern int maybe_useful_work ();
+
+int global_var;
+volatile int volatile_global_var;
+
+struct st
+{
+  int x;
+  int y;
+};
+
+static void __attribute__((noinline))
+do_nothing (void)
+{
+}
+
+void test_empty_while_true ()
+{
+  while (1) {} /* { dg-warning "infinite loop" } */
+  /* { dg-message "looping back\.\.\." "" { target *-*-* } .-1 } */
+  /* { dg-message "\.\.\.to here" "" { target *-*-* } .-2 } */
+}
+
+void test_empty_do_while ()
+{
+  do {} while (1);  /* { dg-warning "infinite loop" } */
+  /* { dg-message "looping back\.\.\." "" { target *-*-* } .-1 } */
+  /* { dg-message "\.\.\.to here" "" { target *-*-* } .-2 } */
+}
+
+void test_empty_for ()
+{
+  for (;;) {} /* { dg-warning "infinite loop" } */
+  /* { dg-message "looping back\.\.\." "" { target *-*-* } .-1 } */
+  /* { dg-message "\.\.\.to here" "" { target *-*-* } .-2 } */
+}
+
+void test_while_true_maybe_useful_work ()
+{
+  while (1)
+    maybe_useful_work ();
+}
+
+void test_while_true_interproc_empty ()
+{
+  /* Depending on optimization level, location is sometimes
+     on "while", sometimes on "do_nothing", and sometimes the
+     unknown location.  */
+  while (1)
+    do_nothing ();  /* { dg-warning "infinite loop" } */
+}
+
+void test_while_true_increment_local ()
+{
+  int i = 0;
+  while (1)
+    i++;  /* { dg-warning "infinite loop" } */
+}
+
+void test_while_true_increment_global ()
+{
+  while (1)
+    global_var++;
+}
+
+void test_guarded_while_true_increment_local (int flag)
+{
+  if (flag)
+    {
+      int i = 0;
+      while (1)
+	i++;  /* { dg-warning "infinite loop" } */
+    }
+}
+
+void test_while_local_flag_increment_local (int flag)
+{
+  int i = 0;
+  while (flag) /* { dg-warning "infinite loop" } */
+    i++;
+}
+
+extern int check_flag (void);
+
+void test_while_calling_fn (void)
+{
+  while (check_flag ())
+    do_nothing ();
+}
+
+void test_missing_parens_on_call (void)
+{
+  while (check_flag)
+    do_nothing ();  /* { dg-warning "infinite loop" } */
+}
+
+void test_iteration_copy_and_paste_error (int m, int n)
+{
+  /* Wrong variable is incremented in inner "for" loop, thus
+     effectively an infinite loop.  */
+  float arr[m][n];
+  for (int i = 0; i < m; i++)
+    for (int j = 0; j < n; i++) /* { dg-warning "infinite loop" } */
+      arr[i][j] = 0.f;
+}
+
+void test_missing_comparison_in_for_condition_1 (int n)
+{
+  /* Should have been "i < n", rather than just "n".  */
+  for (int i = 0; n; i++) /* { dg-warning "infinite loop" } */
+    {
+    }
+}
+
+int test_missing_comparison_in_for_condition_2 (int val, int *arr, int n)
+{
+  /* Should have been "i < n", rather than just "n".  */
+  int acc = 0;
+  for (int i = 0; n; i++) /* { dg-warning "infinite loop" } */
+    acc += arr[i];
+  return acc;
+}
+
+void test_non_volatile_local_1 (void)
+{
+  int flag = 0;
+  while (!flag) /* { dg-warning "infinite loop" } */
+    {
+    }
+}
+
+void test_non_volatile_local_2a (void)
+{
+  int flag = 0;
+
+  /* Perhaps should complain about this.
+     Although the infinite loop might be doing useful work,
+     "while (!flag)" is a misleading way to spell "infinite loop".  */
+  while (!flag)
+    maybe_useful_work ();
+}
+
+void test_non_volatile_local_2b (void)
+{
+  int flag = 0;
+
+  while (!flag)
+    flag = maybe_useful_work ();
+}
+
+void test_non_volatile_local_3a (int n)
+{
+  int i = 0;
+
+  /* Perhaps should complain about this.
+     Although the infinite loop might be doing useful work,
+     "while (i < n)" is a misleading way to spell "infinite loop".  */
+  while (i < n)
+    maybe_useful_work ();
+}
+
+void test_non_volatile_local_3b (int n)
+{
+  int i = 0;
+
+  while (i < n)
+    {
+      maybe_useful_work ();
+      i++;
+    }
+}
+
+void test_volatile_local (void)
+{
+  volatile int flag = 0;
+  while (!flag) /* { dg-bogus "infinite loop" } */
+    {
+    }
+}
+
+void test_non_volatile_global (void)
+{
+  /* Not sure if we should warn here.  */
+  while (!global_var) /* { dg-warning "infinite loop" } */
+    {
+    }
+}
+
+void test_volatile_global (void)
+{
+  while (!volatile_global_var) /* { dg-bogus "infinite loop" } */
+    {
+    }
+}
+
+void test_field_1 (struct st *p)
+{
+  /* Not sure if we should warn here.  */
+  while (!p->x) /* { dg-warning "infinite loop" } */
+    {
+    }
+}
+
+void test_field_2 (struct st *p)
+{
+  while (!p->x) /* { dg-bogus "infinite loop" } */
+    maybe_useful_work ();
+}
+
+
+int missing_init_of_i (int *arr, unsigned n)
+{
+  int sum = 0;
+  for (int i; i < n; i--) /* { dg-warning "use of uninitialized value 'i'" } */
+    sum += arr[i];
+  return sum;
+}
+
+void test_switch (char *pc)
+{
+  while (1)
+    {
+      char opcode = *pc; /* { dg-warning "infinite loop" } */
+      switch (opcode) /* { dg-message "if it ever follows 'default:' branch, it will always do so\.\.\." } */
+	{
+	case 'A':
+	  pc++;
+	  break;
+	case 'B':
+	  return;
+	}
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/analyzer/malloc-1.c b/gcc/testsuite/gcc.dg/analyzer/malloc-1.c
index 6b5590a..2a42a05 100644
--- a/gcc/testsuite/gcc.dg/analyzer/malloc-1.c
+++ b/gcc/testsuite/gcc.dg/analyzer/malloc-1.c
@@ -124,7 +124,7 @@ void test_12 (void)
 
   while (1)
     {
-      free (ptr);
+      free (ptr); /* { dg-warning "infinite loop" } */
       free (ptr); /* { dg-warning "double-'free' of 'ptr'" } */
     }
 }
diff --git a/gcc/testsuite/gcc.dg/analyzer/out-of-bounds-coreutils.c b/gcc/testsuite/gcc.dg/analyzer/out-of-bounds-coreutils.c
index cd0f4b7..7af4c37 100644
--- a/gcc/testsuite/gcc.dg/analyzer/out-of-bounds-coreutils.c
+++ b/gcc/testsuite/gcc.dg/analyzer/out-of-bounds-coreutils.c
@@ -3,7 +3,7 @@
 void add_zero_terminator (char *buf)
 {
   char *end = buf;
-  while (end++);
+  while (end++); /* TODO: arguably we should report this.  */
   if (buf < end)
     end[-1] = '\0';
 }
diff --git a/gcc/testsuite/gcc.dg/analyzer/paths-4.c b/gcc/testsuite/gcc.dg/analyzer/paths-4.c
index b72e658..60b3a0c 100644
--- a/gcc/testsuite/gcc.dg/analyzer/paths-4.c
+++ b/gcc/testsuite/gcc.dg/analyzer/paths-4.c
@@ -26,9 +26,10 @@ int test_2 (struct state *s)
   while (1)
     {
       __analyzer_dump_exploded_nodes (0); /* { dg-warning "2 processed enode" } */
+      /* { dg-warning "infinite loop" "" { target *-*-* } .-1 } */
       __analyzer_dump_exploded_nodes (0); /* { dg-warning "2 processed enode" } */
       /* TODO: why does the above need an extra stmt to merge state?  */
-      switch (s->mode)
+      switch (s->mode) /* { dg-message "if it ever follows 'default:' branch, it will always do so\.\.\." } */
 	{
 	case 0:
 	  __analyzer_dump_exploded_nodes (0); /* { dg-warning "2 processed enode" } */
diff --git a/gcc/testsuite/gcc.dg/analyzer/pr103892.c b/gcc/testsuite/gcc.dg/analyzer/pr103892.c
index 95d4b17..d16cd83 100644
--- a/gcc/testsuite/gcc.dg/analyzer/pr103892.c
+++ b/gcc/testsuite/gcc.dg/analyzer/pr103892.c
@@ -38,7 +38,7 @@ typedef struct pipecmd_sequence pipecmd_sequence_t;
 
 static char *argstr_get_word (const char **argstr)
 {
- while (**argstr) {
+ while (**argstr) { /* { dg-warning "infinite loop" } */
   switch (**argstr) {
    case ' ':
    case '\t':
diff --git a/gcc/testsuite/gcc.dg/analyzer/pr93032-mztools-signed-char.c b/gcc/testsuite/gcc.dg/analyzer/pr93032-mztools-signed-char.c
index 1f3df7c..45599e2 100644
--- a/gcc/testsuite/gcc.dg/analyzer/pr93032-mztools-signed-char.c
+++ b/gcc/testsuite/gcc.dg/analyzer/pr93032-mztools-signed-char.c
@@ -6,6 +6,9 @@
 /* { dg-do "compile" } */
 /* { dg-additional-options "-fsigned-char" } */
 
+/* TODO (PR analyzer/112528): remove need for this.  */
+/* { dg-additional-options "--param analyzer-max-enodes-per-program-point=40 --param analyzer-bb-explosion-factor=10" } */
+
 /* Minimal replacement of system headers.  */
 
 typedef __SIZE_TYPE__ size_t;
diff --git a/gcc/testsuite/gcc.dg/analyzer/pr93032-mztools-unsigned-char.c b/gcc/testsuite/gcc.dg/analyzer/pr93032-mztools-unsigned-char.c
index db9678d..a59fc49 100644
--- a/gcc/testsuite/gcc.dg/analyzer/pr93032-mztools-unsigned-char.c
+++ b/gcc/testsuite/gcc.dg/analyzer/pr93032-mztools-unsigned-char.c
@@ -6,6 +6,9 @@
 /* { dg-do "compile" } */
 /* { dg-additional-options "-funsigned-char" } */
 
+/* TODO (PR analyzer/112528): remove need for this.  */
+/* { dg-additional-options "--param analyzer-max-enodes-per-program-point=40 --param analyzer-bb-explosion-factor=10" } */
+
 /* Minimal replacement of system headers.  */
 
 typedef __SIZE_TYPE__ size_t;
diff --git a/gcc/testsuite/gcc.dg/analyzer/pr93382.c b/gcc/testsuite/gcc.dg/analyzer/pr93382.c
index 1e6612d..91eab21 100644
--- a/gcc/testsuite/gcc.dg/analyzer/pr93382.c
+++ b/gcc/testsuite/gcc.dg/analyzer/pr93382.c
@@ -1,5 +1,3 @@
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 typedef __SIZE_TYPE__ size_t;
 
 int idx;
diff --git a/gcc/testsuite/gcc.dg/analyzer/pr93546.c b/gcc/testsuite/gcc.dg/analyzer/pr93546.c
index 66f6805..07898e9 100644
--- a/gcc/testsuite/gcc.dg/analyzer/pr93546.c
+++ b/gcc/testsuite/gcc.dg/analyzer/pr93546.c
@@ -5,7 +5,7 @@ void
 ch (int x1)
 {
   ({ bx: &&bx; });
-  while (x1 == 0)
+  while (x1 == 0) /* { dg-warning "infinite loop" } */
     {
     }
 }
diff --git a/gcc/testsuite/gcc.dg/analyzer/switch-enum-taint-1.c b/gcc/testsuite/gcc.dg/analyzer/switch-enum-taint-1.c
index db3bb5b..d20b33e 100644
--- a/gcc/testsuite/gcc.dg/analyzer/switch-enum-taint-1.c
+++ b/gcc/testsuite/gcc.dg/analyzer/switch-enum-taint-1.c
@@ -1,6 +1,3 @@
-// TODO: remove need for this option
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 #include "analyzer-decls.h"
 
 /* Verify the handling of "switch (enum_value)".  */
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-CVE-2011-2210-1.c b/gcc/testsuite/gcc.dg/analyzer/taint-CVE-2011-2210-1.c
index b44be99..fa89bda 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-CVE-2011-2210-1.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-CVE-2011-2210-1.c
@@ -7,9 +7,6 @@
    Fixed in 3d0475119d8722798db5e88f26493f6547a4bb5b on linux-2.6.39.y
    in linux-stable.  */
 
-// TODO: remove need for this option:
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 #include "analyzer-decls.h"
 #include "test-uaccess.h"
 
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-CVE-2020-13143-1.c b/gcc/testsuite/gcc.dg/analyzer/taint-CVE-2020-13143-1.c
index 328c579..1b81c1b 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-CVE-2020-13143-1.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-CVE-2020-13143-1.c
@@ -1,9 +1,6 @@
 /* See notes in this header.  */
 #include "taint-CVE-2020-13143.h"
 
-// TODO: remove need for this option
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 struct configfs_attribute {
 	/* [...snip...] */
 	ssize_t (*store)(struct config_item *, const char *, size_t) /* { dg-message "\\(1\\) field 'store' of 'struct configfs_attribute' is marked with '__attribute__\\(\\(tainted_args\\)\\)'" } */
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-CVE-2020-13143-2.c b/gcc/testsuite/gcc.dg/analyzer/taint-CVE-2020-13143-2.c
index c74a460..f53e42b 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-CVE-2020-13143-2.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-CVE-2020-13143-2.c
@@ -1,9 +1,6 @@
 /* See notes in this header.  */
 #include "taint-CVE-2020-13143.h"
 
-// TODO: remove need for this option
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 struct configfs_attribute {
 	/* [...snip...] */
 	ssize_t (*store)(struct config_item *, const char *, size_t) /* { dg-message "\\(1\\) field 'store' of 'struct configfs_attribute' is marked with '__attribute__\\(\\(tainted_args\\)\\)'" } */
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-CVE-2020-13143.h b/gcc/testsuite/gcc.dg/analyzer/taint-CVE-2020-13143.h
index 0ba0235..93f90d4 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-CVE-2020-13143.h
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-CVE-2020-13143.h
@@ -8,9 +8,6 @@
    Fixed by 15753588bcd4bbffae1cca33c8ced5722477fe1f on linux-5.7.y
    in linux-stable.  */
 
-// TODO: remove need for this option
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 #include <stddef.h>
 
 /* Adapted from include/uapi/asm-generic/posix_types.h  */
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-alloc-1.c b/gcc/testsuite/gcc.dg/analyzer/taint-alloc-1.c
index cb2db6c..dfb585b 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-alloc-1.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-alloc-1.c
@@ -1,5 +1,3 @@
-// TODO: remove need for this option
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
 /* { dg-require-effective-target alloca } */
 
 #include "analyzer-decls.h"
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-alloc-2.c b/gcc/testsuite/gcc.dg/analyzer/taint-alloc-2.c
index 72dbca5..68fbce9 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-alloc-2.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-alloc-2.c
@@ -1,6 +1,3 @@
-// TODO: remove need for this option:
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 #include "analyzer-decls.h"
 #include <stdio.h>
 #include <stdlib.h>
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-alloc-3.c b/gcc/testsuite/gcc.dg/analyzer/taint-alloc-3.c
index 80d8f0b..ce6a327 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-alloc-3.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-alloc-3.c
@@ -1,6 +1,3 @@
-// TODO: remove need for this option:
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 #include "analyzer-decls.h"
 #include <stdio.h>
 #include <stdlib.h>
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-alloc-4.c b/gcc/testsuite/gcc.dg/analyzer/taint-alloc-4.c
index bd47097..9df9422 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-alloc-4.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-alloc-4.c
@@ -1,6 +1,3 @@
-// TODO: remove need for this option:
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 #include "analyzer-decls.h"
 #include <stdio.h>
 #include <stdlib.h>
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-alloc-5.c b/gcc/testsuite/gcc.dg/analyzer/taint-alloc-5.c
index 9a15980..18dbff0 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-alloc-5.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-alloc-5.c
@@ -1,6 +1,3 @@
-// TODO: remove need for this option
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 #include "analyzer-decls.h"
 
 struct foo
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-assert-BUG_ON.c b/gcc/testsuite/gcc.dg/analyzer/taint-assert-BUG_ON.c
index 8aef0a4..328940d 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-assert-BUG_ON.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-assert-BUG_ON.c
@@ -1,6 +1,3 @@
-// TODO: remove need for this option
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 /* We need this, otherwise the warnings are emitted inside the macros, which
    makes it hard to write the DejaGnu directives.  */
 /* { dg-additional-options " -ftrack-macro-expansion=0" } */
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-assert-macro-expansion.c b/gcc/testsuite/gcc.dg/analyzer/taint-assert-macro-expansion.c
index 24b175a..78357ae 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-assert-macro-expansion.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-assert-macro-expansion.c
@@ -2,9 +2,6 @@
    -Wanalyzer-tainted-assertion with macro-tracking enabled
    (the default).  */
 
-// TODO: remove need for this option
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 /* { dg-additional-options "-fdiagnostics-show-path-depths" } */
 /* { dg-additional-options "-fdiagnostics-path-format=inline-events -fdiagnostics-show-caret" } */
 
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-assert-system-header.c b/gcc/testsuite/gcc.dg/analyzer/taint-assert-system-header.c
index a65853c..bd47ab7 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-assert-system-header.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-assert-system-header.c
@@ -3,9 +3,6 @@
    (the default), where the assertion macro is defined in
    a system header.  */
 
-// TODO: remove need for this option
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 /* { dg-additional-options "-fdiagnostics-show-path-depths" } */
 /* { dg-additional-options "-fdiagnostics-path-format=inline-events -fdiagnostics-show-caret" } */
 
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-assert.c b/gcc/testsuite/gcc.dg/analyzer/taint-assert.c
index b09f8c5..855ed5f 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-assert.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-assert.c
@@ -1,6 +1,3 @@
-// TODO: remove need for this option
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 /* We need this, otherwise the warnings are emitted inside the macros, which
    makes it hard to write the DejaGnu directives.  */
 /* { dg-additional-options " -ftrack-macro-expansion=0" } */
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-divisor-1.c b/gcc/testsuite/gcc.dg/analyzer/taint-divisor-1.c
index b7c1fae..438a209 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-divisor-1.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-divisor-1.c
@@ -1,6 +1,3 @@
-// TODO: remove need for this option:
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 #include "analyzer-decls.h"
 #include <stdio.h>
 
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-divisor-2.c b/gcc/testsuite/gcc.dg/analyzer/taint-divisor-2.c
index de9a1cb..7702584 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-divisor-2.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-divisor-2.c
@@ -1,6 +1,3 @@
-// TODO: remove need for this option:
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 #include "analyzer-decls.h"
 
 __attribute__ ((tainted_args))
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-merger.c b/gcc/testsuite/gcc.dg/analyzer/taint-merger.c
index e4e48f3..b7d562b 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-merger.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-merger.c
@@ -1,6 +1,3 @@
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-// TODO: remove need for this option
-
 #include "analyzer-decls.h"
 
 int v_start;
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-ops.c b/gcc/testsuite/gcc.dg/analyzer/taint-ops.c
deleted file mode 100644
index 729dbe5..0000000
--- a/gcc/testsuite/gcc.dg/analyzer/taint-ops.c
+++ /dev/null
@@ -1,106 +0,0 @@
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-// TODO: remove need for this option
-/* This test can probably be removed when -fanalyzer enables
-   the taint checker by default.  */
-
-#include "analyzer-decls.h"
-
-void
-test_1 (char a)
-{
-  char b = -a;
-}
-
-/* Copies of code from data-model-1.c.  */
-
-void test_20 (int i, int j)
-{
-  __analyzer_eval (i + 1); /* { dg-warning "UNKNOWN" } */
-  __analyzer_eval (i + j); /* { dg-warning "UNKNOWN" } */
-
-  __analyzer_eval (i - 1); /* { dg-warning "UNKNOWN" } */
-  __analyzer_eval (i - j); /* { dg-warning "UNKNOWN" } */
-
-  __analyzer_eval (i * 2); /* { dg-warning "UNKNOWN" } */
-  __analyzer_eval (i * j); /* { dg-warning "UNKNOWN" } */
-
-  __analyzer_eval (i / 2); /* { dg-warning "UNKNOWN" } */
-  __analyzer_eval (i / j); /* { dg-warning "UNKNOWN" } */
-
-  __analyzer_eval (i % 2); /* { dg-warning "UNKNOWN" } */
-  __analyzer_eval (i % j); /* { dg-warning "UNKNOWN" } */
-
-  __analyzer_eval (i & 1); /* { dg-warning "UNKNOWN" } */
-  __analyzer_eval (i & j); /* { dg-warning "UNKNOWN" } */
-
-  __analyzer_eval (i | 1); /* { dg-warning "UNKNOWN" } */
-  __analyzer_eval (i | j); /* { dg-warning "UNKNOWN" } */
-
-  __analyzer_eval (i ^ 1); /* { dg-warning "UNKNOWN" } */
-  __analyzer_eval (i ^ j); /* { dg-warning "UNKNOWN" } */
-
-  __analyzer_eval (i >> 1); /* { dg-warning "UNKNOWN" } */
-  __analyzer_eval (i >> j); /* { dg-warning "UNKNOWN" } */
-
-  __analyzer_eval (i << 1); /* { dg-warning "UNKNOWN" } */
-  __analyzer_eval (i << j); /* { dg-warning "UNKNOWN" } */
-
-  __analyzer_eval (i && 0); /* { dg-warning "FALSE" } */
-  __analyzer_eval (i && 1); /* { dg-warning "UNKNOWN" } */
-  __analyzer_eval (i && j); /* { dg-warning "UNKNOWN" } */
-
-  __analyzer_eval (i || 0); /* { dg-warning "UNKNOWN" } */
-
-  __analyzer_eval (i || 1); /* { dg-warning "TRUE" } */
-  __analyzer_eval (i || j); /* { dg-warning "UNKNOWN" } */
-
-  __analyzer_eval (~i); /* { dg-warning "UNKNOWN" } */
-  __analyzer_eval (-i); /* { dg-warning "UNKNOWN" } */
-  __analyzer_eval (+i); /* { dg-warning "UNKNOWN" } */
-
-  /* Anything added above should be added to the next function also.  */
-}
-
-void test_21 (void)
-{
-  int i, j, zero;
-  int *pi = &i;
-  int *pj = &j;
-  int *pzero = &zero;
-  *pi = 5;
-  *pj = 3;
-  *pzero = 0;
-
-  __analyzer_eval (i + j == 8); /* { dg-warning "TRUE" } */
-  __analyzer_eval (i - j == 2); /* { dg-warning "TRUE" } */
-  __analyzer_eval (i * j == 15); /* { dg-warning "TRUE" } */
-  __analyzer_eval (i / j == 1); /* { dg-warning "TRUE" } */
-  __analyzer_eval (i % j == 2); /* { dg-warning "TRUE" } */
-
-  /* Division by zero.  */
-  // TODO: should we warn for this?
-  __analyzer_eval (i / zero); /* { dg-warning "UNKNOWN" } */
-  __analyzer_eval (i % zero); /* { dg-warning "UNKNOWN" } */
-
-  __analyzer_eval ((i & 1) == (5 & 1)); /* { dg-warning "TRUE" } */
-  __analyzer_eval ((i & j) == (5 & 3)); /* { dg-warning "TRUE" } */
-  __analyzer_eval ((i | 1) == (5 | 1)); /* { dg-warning "TRUE" } */
-  __analyzer_eval ((i | j) == (5 | 3)); /* { dg-warning "TRUE" } */
-  __analyzer_eval ((i ^ 1) == (5 ^ 1)); /* { dg-warning "TRUE" } */
-  __analyzer_eval ((i ^ j) == (5 ^ 3)); /* { dg-warning "TRUE" } */
-  __analyzer_eval ((i >> 1) == (5 >> 1)); /* { dg-warning "TRUE" } */
-  __analyzer_eval ((i >> j) == (5 >> 3)); /* { dg-warning "TRUE" } */
-  __analyzer_eval ((i << 1) == (5 << 1)); /* { dg-warning "TRUE" } */
-  __analyzer_eval ((i << j) == (5 << 3)); /* { dg-warning "TRUE" } */
-  __analyzer_eval (i && 0); /* { dg-warning "FALSE" } */
-  __analyzer_eval (i && 1); /* { dg-warning "TRUE" } */
-  __analyzer_eval (i && j); /* { dg-warning "TRUE" } */
-
-  __analyzer_eval (i || 0); /* { dg-warning "TRUE" } */
-  __analyzer_eval (i || 1); /* { dg-warning "TRUE" } */
-  __analyzer_eval (i || j); /* { dg-warning "TRUE" } */
-
-  __analyzer_eval (~i == ~5); /* { dg-warning "TRUE" } */
-  __analyzer_eval (-i == -5); /* { dg-warning "TRUE" } */
-  __analyzer_eval (+i == +5); /* { dg-warning "TRUE" } */
-}
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-read-index-1.c b/gcc/testsuite/gcc.dg/analyzer/taint-read-index-1.c
index 71c0816..1ec78b5 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-read-index-1.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-read-index-1.c
@@ -1,6 +1,3 @@
-// TODO: remove need for this option:
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-read-offset-1.c b/gcc/testsuite/gcc.dg/analyzer/taint-read-offset-1.c
index 6db59bc..bb5d093 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-read-offset-1.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-read-offset-1.c
@@ -1,6 +1,3 @@
-// TODO: remove need for this option:
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-realloc.c b/gcc/testsuite/gcc.dg/analyzer/taint-realloc.c
index bd0ed00..aeefb7d 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-realloc.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-realloc.c
@@ -1,6 +1,3 @@
-// TODO: remove need for this option:
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 #include "analyzer-decls.h"
 #include <stdio.h>
 #include <stdlib.h>
@@ -18,4 +15,4 @@ test_1 (size_t sz) /* { dg-message "\\(1\\) function 'test_1' marked with '__att
   __analyzer_dump_state ("taint", sz); /* { dg-warning "state: 'tainted'" } */
 
   q = realloc (p, sz);  /* { dg-warning "use of attacker-controlled value 'sz' as allocation size without upper-bounds checking" } */
-}
+} /* { dg-warning "leak of 'q'" } */
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-size-1.c b/gcc/testsuite/gcc.dg/analyzer/taint-size-1.c
index 1fd5fd4..36083ac 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-size-1.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-size-1.c
@@ -1,6 +1,3 @@
-// TODO: remove need for this option:
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 #include "analyzer-decls.h"
 #include <stdio.h>
 #include <stdlib.h>
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-size-access-attr-1.c b/gcc/testsuite/gcc.dg/analyzer/taint-size-access-attr-1.c
index 7d243a9..d4da3d7 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-size-access-attr-1.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-size-access-attr-1.c
@@ -1,8 +1,7 @@
 /* Passing tainted sizes to external functions with attribute ((access)) with
    a size-index.  */
 
-// TODO: remove need for the explicit taint option:
-/* { dg-additional-options "-fanalyzer-checker=taint -fanalyzer-show-duplicate-count" } */
+/* { dg-additional-options "-fanalyzer-show-duplicate-count" } */
 
 #include "analyzer-decls.h"
 #include <stdio.h>
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-write-index-1.c b/gcc/testsuite/gcc.dg/analyzer/taint-write-index-1.c
index cc7ab1c..6222206 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-write-index-1.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-write-index-1.c
@@ -1,6 +1,3 @@
-// TODO: remove need for this option:
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
diff --git a/gcc/testsuite/gcc.dg/analyzer/taint-write-offset-1.c b/gcc/testsuite/gcc.dg/analyzer/taint-write-offset-1.c
index d0df622..21794ce 100644
--- a/gcc/testsuite/gcc.dg/analyzer/taint-write-offset-1.c
+++ b/gcc/testsuite/gcc.dg/analyzer/taint-write-offset-1.c
@@ -1,6 +1,3 @@
-// TODO: remove need for this option:
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
diff --git a/gcc/testsuite/gcc.dg/analyzer/torture/taint-read-index-2.c b/gcc/testsuite/gcc.dg/analyzer/torture/taint-read-index-2.c
index b3dc177..8142133 100644
--- a/gcc/testsuite/gcc.dg/analyzer/torture/taint-read-index-2.c
+++ b/gcc/testsuite/gcc.dg/analyzer/torture/taint-read-index-2.c
@@ -1,5 +1,3 @@
-// TODO: remove need for the taint option:
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
 /* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } { "" } } */
 
 #define LOWER_LIMIT 5
diff --git a/gcc/testsuite/gcc.dg/analyzer/torture/taint-read-index-3.c b/gcc/testsuite/gcc.dg/analyzer/torture/taint-read-index-3.c
index 8eb6061..86bdede 100644
--- a/gcc/testsuite/gcc.dg/analyzer/torture/taint-read-index-3.c
+++ b/gcc/testsuite/gcc.dg/analyzer/torture/taint-read-index-3.c
@@ -1,5 +1,3 @@
-// TODO: remove need for the taint option:
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
 /* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } { "" } } */
 
 struct raw_ep {
diff --git a/gcc/testsuite/gcc.dg/c23-utf8char-3.c b/gcc/testsuite/gcc.dg/c23-utf8char-3.c
index e152edb..0d82af5 100644
--- a/gcc/testsuite/gcc.dg/c23-utf8char-3.c
+++ b/gcc/testsuite/gcc.dg/c23-utf8char-3.c
@@ -3,6 +3,6 @@
 /* { dg-options "-std=c23 -pedantic-errors" } */
 
 unsigned char a = u8''; /* { dg-error "empty character constant" } */
-unsigned char b = u8'ab'; /* { dg-error "character constant too long for its type" } */
-unsigned char c = u8'\u00ff'; /* { dg-error "character constant too long for its type" } */
+unsigned char b = u8'ab'; /* { dg-error "multi-character literal cannot have an encoding prefix" } */
+unsigned char c = u8'\u00ff'; /* { dg-error "character not encodable in a single code unit" } */
 unsigned char d = u8'\x100'; /* { dg-error "hex escape sequence out of range" } */
diff --git a/gcc/testsuite/gcc.dg/cpp/charconst-4.c b/gcc/testsuite/gcc.dg/cpp/charconst-4.c
index 9ea5e8a..03706c5 100644
--- a/gcc/testsuite/gcc.dg/cpp/charconst-4.c
+++ b/gcc/testsuite/gcc.dg/cpp/charconst-4.c
@@ -38,7 +38,7 @@ extern void abort (void);
 # error Charconst incorrectly sign-extended
 #endif
 
-#if LONG_CHARCONST != SHORT_CHARCONST /* { dg-warning "too long" } */
+#if LONG_CHARCONST != SHORT_CHARCONST /* { dg-warning "multi-character literal with \[0-9]+ characters exceeds 'int' size of \[0-9]+ bytes" } */
 # error Overly long charconst truncates wrongly for preprocessor
 #endif
 
@@ -46,7 +46,7 @@ int main ()
 {
   if (POS_CHARCONST < 0)
     abort ();
-  if (LONG_CHARCONST != SHORT_CHARCONST)  /* { dg-warning "too long" } */
+  if (LONG_CHARCONST != SHORT_CHARCONST)  /* { dg-warning "multi-character literal with \[0-9]+ characters exceeds 'int' size of \[0-9]+ bytes" } */
     abort ();
   return 0;
 }
diff --git a/gcc/testsuite/gcc.dg/cpp/charconst.c b/gcc/testsuite/gcc.dg/cpp/charconst.c
index 8934d6a..a2a5717 100644
--- a/gcc/testsuite/gcc.dg/cpp/charconst.c
+++ b/gcc/testsuite/gcc.dg/cpp/charconst.c
@@ -11,9 +11,9 @@
 #endif
 #if L''			/* { dg-error "empty" "empty wide charconst" } */
 #endif
-#if 'very long'		/* { dg-warning "too long" "long charconst" } */
+#if 'very long'		/* { dg-warning "multi-character literal with \[0-9]+ characters exceeds 'int' size of \[0-9]+ bytes" "long charconst" } */
 #endif
-#if L'very long'	/* { dg-warning "too long" "long wide charconst" } */
+#if L'very long'	/* { dg-warning "multi-character literal cannot have an encoding prefix" "long wide charconst" } */
 #endif
 /* Don't do this test for L'ab'; it depends upon sizeof (wchar_t).  */
 #if 'ab'		/* { dg-warning "multi-char" "multi-character" } */
@@ -27,10 +27,10 @@ void foo ()
   c = '';		/* { dg-error "empty" "empty charconst" } */
   w = L'';		/* { dg-error "empty" "empty wide charconst" } */
 
-  c = 'very long';	/* { dg-warning "too long" "long charconst" } */
-  w = L'very long';	/* { dg-warning "too long" "long wide charconst" } */
+  c = 'very long';	/* { dg-warning "multi-character literal with \[0-9]+ characters exceeds 'int' size of \[0-9]+ bytes" "long charconst" } */
+  w = L'very long';	/* { dg-warning "multi-character literal cannot have an encoding prefix" "long wide charconst" } */
 
   c = 'ab';		/* { dg-warning "multi-char" "multi-char" } */
   /* Wide charconsts cannot contain more than one wide character.  */
-  w = L'ab';		/* { dg-warning "too long" "multi-char wide" } */
+  w = L'ab';		/* { dg-warning "multi-character literal cannot have an encoding prefix" "multi-char wide" } */
 }
diff --git a/gcc/testsuite/gcc.dg/cpp/if-2.c b/gcc/testsuite/gcc.dg/cpp/if-2.c
index dc136b4..2a3272d 100644
--- a/gcc/testsuite/gcc.dg/cpp/if-2.c
+++ b/gcc/testsuite/gcc.dg/cpp/if-2.c
@@ -17,11 +17,11 @@
 #error 0x1234	/* { dg-bogus "error" "wide charconst recognition 3" } */
 #endif
 
-/* The 'character constant (is )?too long' message is produced by 16-bit targets.  */
-#if 'abcd' /* { dg-warning "(multi-character character constant)|(character constant (is )?too long)" "multi-character charconst" } */
+/* The 'multi-character literal with 4 characters exceeds 'int' size of \[0-9]+ bytes' message is produced by 16-bit targets.  */
+#if 'abcd' /* { dg-warning "(multi-character character constant)|(multi-character literal with 4 characters exceeds 'int' size of \[0-9]+ bytes)" "multi-character charconst" } */
 #endif
 
-#if 'abcdefghi' /* { dg-warning "character constant (is )?too long" "charconst too long" } */
+#if 'abcdefghi' /* { dg-warning "multi-character literal with \[0-9]+ characters exceeds 'int' size of \[0-9]+ bytes" } */
 #endif
 
 #if '' /* { dg-error "empty character constant" "empty charconst" } */
diff --git a/gcc/testsuite/gcc.dg/graphite/pr111878.c b/gcc/testsuite/gcc.dg/graphite/pr111878.c
new file mode 100644
index 0000000..6722910
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr111878.c
@@ -0,0 +1,19 @@
+/* { dg-options "-O3 -fgraphite-identity -fsave-optimization-record" } */
+
+int long_c2i_ltmp;
+int *long_c2i_cont;
+
+void
+long_c2i (long utmp, int i)
+{
+  int neg = 1;
+  switch (long_c2i_cont[0])
+    case 0:
+    neg = 0;
+  for (; i; i++)
+    if (neg)
+      utmp |= long_c2i_cont[i] ^ 5;
+    else
+      utmp |= long_c2i_cont[i];
+  long_c2i_ltmp = utmp;
+}
diff --git a/gcc/testsuite/gcc.dg/pch/main-file-warnings.c b/gcc/testsuite/gcc.dg/pch/main-file-warnings.c
new file mode 100644
index 0000000..aedbc15
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pch/main-file-warnings.c
@@ -0,0 +1,7 @@
+/* PR pch/9471 */
+/* PR pch/47857 */
+/* Test will fail if any warnings get issued while compiling the header into a PCH.  */
+#include "main-file-warnings.h"
+#pragma once /* { dg-warning "in main file" } */
+#pragma GCC system_header /* { dg-warning "outside include file" } */
+#include_next <stdint.h> /* { dg-warning "in primary source file" } */
diff --git a/gcc/testsuite/gcc.dg/pch/main-file-warnings.hs b/gcc/testsuite/gcc.dg/pch/main-file-warnings.hs
new file mode 100644
index 0000000..d1582bb
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pch/main-file-warnings.hs
@@ -0,0 +1,3 @@
+#pragma once /* { dg-bogus "in main file" } */
+#pragma GCC system_header /* { dg-bogus "outside include file" } */
+#include_next <stdint.h> /* { dg-bogus "in primary source file" } */
diff --git a/gcc/testsuite/gcc.dg/plugin/diagnostic_group_plugin.c b/gcc/testsuite/gcc.dg/plugin/diagnostic_group_plugin.c
index e8903ba..ce0b322 100644
--- a/gcc/testsuite/gcc.dg/plugin/diagnostic_group_plugin.c
+++ b/gcc/testsuite/gcc.dg/plugin/diagnostic_group_plugin.c
@@ -224,7 +224,7 @@ plugin_init (struct plugin_name_args *plugin_info,
     return 1;
 
   diagnostic_starter (global_dc) = test_diagnostic_starter;
-  global_dc->m_text_callbacks.start_span = test_diagnostic_start_span_fn;
+  diagnostic_start_span (global_dc) = test_diagnostic_start_span_fn;
   global_dc->set_output_format (new test_output_format (*global_dc));
 
   pass_info.pass = new pass_test_groups (g);
diff --git a/gcc/testsuite/gcc.dg/plugin/diagnostic_plugin_test_show_locus.c b/gcc/testsuite/gcc.dg/plugin/diagnostic_plugin_test_show_locus.c
index 2b8cbc9..6cc661b 100644
--- a/gcc/testsuite/gcc.dg/plugin/diagnostic_plugin_test_show_locus.c
+++ b/gcc/testsuite/gcc.dg/plugin/diagnostic_plugin_test_show_locus.c
@@ -438,7 +438,8 @@ test_show_locus (function *fun)
       rich_location richloc (line_table, loc);
       for (int line = start_line; line <= finish_line; line++)
 	{
-	  char_span content = location_get_source_line (file, line);
+	  file_cache &fc = global_dc->get_file_cache ();
+	  char_span content = fc.get_source_line (file, line);
 	  gcc_assert (content);
 	  /* Split line up into words.  */
 	  for (int idx = 0; idx < content.length (); idx++)
diff --git a/gcc/testsuite/gcc.dg/plugin/expensive_selftests_plugin.c b/gcc/testsuite/gcc.dg/plugin/expensive_selftests_plugin.c
index a7c6728..3c53400 100644
--- a/gcc/testsuite/gcc.dg/plugin/expensive_selftests_plugin.c
+++ b/gcc/testsuite/gcc.dg/plugin/expensive_selftests_plugin.c
@@ -51,7 +51,7 @@ test_richloc (rich_location *richloc)
   diagnostic_show_locus (&dc, richloc, DK_ERROR);
 
   /* Generate a diff.  */
-  edit_context ec;
+  edit_context ec (global_dc->get_file_cache ());
   ec.add_fixits (richloc);
   char *diff = ec.generate_diff (true);
   free (diff);
diff --git a/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-1-fixed.c b/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-1-fixed.c
index 0ca8137..51526b8 100644
--- a/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-1-fixed.c
+++ b/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-1-fixed.c
@@ -1,7 +1,6 @@
 /* { dg-do compile } */
-// TODO: remove need for -fanalyzer-checker=taint here:
-/* { dg-options "-fanalyzer -fanalyzer-checker=taint" } */
 /* { dg-require-effective-target analyzer } */
+/* { dg-additional-options "-Wno-pedantic" } */
 
 /* See notes in this header.  */
 #include "taint-CVE-2011-0521.h"
diff --git a/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-1.c b/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-1.c
index cde12b3..3d11a75 100644
--- a/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-1.c
+++ b/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-1.c
@@ -1,6 +1,5 @@
 /* { dg-do compile } */
-// TODO: remove need for -fanalyzer-checker=taint here:
-/* { dg-options "-fanalyzer -fanalyzer-checker=taint" } */
+/* { dg-additional-options "-Wno-pedantic" } */
 /* { dg-require-effective-target analyzer } */
 
 /* See notes in this header.  */
diff --git a/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-2-fixed.c b/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-2-fixed.c
index 8a211ce..d035266 100644
--- a/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-2-fixed.c
+++ b/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-2-fixed.c
@@ -1,14 +1,10 @@
 /* { dg-do compile } */
-// TODO: remove need for -fanalyzer-checker=taint here:
-/* { dg-options "-fanalyzer -fanalyzer-checker=taint" } */
+/* { dg-additional-options "-Wno-pedantic" } */
 /* { dg-require-effective-target analyzer } */
 
 /* See notes in this header.  */
 #include "taint-CVE-2011-0521.h"
 
-// TODO: remove need for this option
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 /* Adapted from drivers/media/dvb/ttpci/av7110_ca.c  */
 
 int dvb_ca_ioctl(struct file *file, unsigned int cmd, void *parg)
diff --git a/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-2.c b/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-2.c
index 30cab38..5270e22 100644
--- a/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-2.c
+++ b/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-2.c
@@ -1,7 +1,6 @@
 /* { dg-do compile } */
-// TODO: remove need for -fanalyzer-checker=taint here:
-/* { dg-options "-fanalyzer -fanalyzer-checker=taint" } */
 /* { dg-require-effective-target analyzer } */
+/* { dg-additional-options "-Wno-pedantic" } */
 
 /* See notes in this header.  */
 #include "taint-CVE-2011-0521.h"
diff --git a/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-3-fixed.c b/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-3-fixed.c
index b7852b4..b8268fa 100644
--- a/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-3-fixed.c
+++ b/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-3-fixed.c
@@ -1,14 +1,10 @@
 /* { dg-do compile } */
-// TODO: remove need for -fanalyzer-checker=taint here:
-/* { dg-options "-fanalyzer -fanalyzer-checker=taint" } */
 /* { dg-require-effective-target analyzer } */
+/* { dg-additional-options "-Wno-pedantic" } */
 
 /* See notes in this header.  */
 #include "taint-CVE-2011-0521.h"
 
-// TODO: remove need for this option
-/* { dg-additional-options "-fanalyzer-checker=taint" } */
-
 /* Adapted from drivers/media/dvb/ttpci/av7110_ca.c  */
 
 int dvb_ca_ioctl(struct file *file, unsigned int cmd, void *parg)
diff --git a/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-3.c b/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-3.c
index 6b9e034..86868a0 100644
--- a/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-3.c
+++ b/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-3.c
@@ -1,7 +1,6 @@
 /* { dg-do compile } */
-// TODO: remove need for -fanalyzer-checker=taint here:
-/* { dg-options "-fanalyzer -fanalyzer-checker=taint" } */
 /* { dg-require-effective-target analyzer } */
+/* { dg-additional-options "-Wno-pedantic" } */
 
 /* See notes in this header.  */
 #include "taint-CVE-2011-0521.h"
@@ -21,7 +20,7 @@ int dvb_ca_ioctl(struct file *file, unsigned int cmd, void *parg)
 		if (info->num > 1)
 			return -EINVAL;
 		av7110->ci_slot[info->num].num = info->num; /* { dg-warning "attacker-controlled value" "" { xfail *-*-* } } */
-		// TODO(xfail)
+		/* TODO(xfail).  */
 		av7110->ci_slot[info->num].type = FW_CI_LL_SUPPORT(av7110->arm_app) ?
 							CA_CI_LINK : CA_CI;
 		memcpy(info, &av7110->ci_slot[info->num], sizeof(ca_slot_info_t));
diff --git a/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-4.c b/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-4.c
index f314c64..06b3468 100644
--- a/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-4.c
+++ b/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-4.c
@@ -1,8 +1,7 @@
 /* { dg-do compile } */
-// TODO: remove need for -fanalyzer-checker=taint here:
 // TODO: remove need for --param=analyzer-max-svalue-depth=25 here:
-/* { dg-options "-fanalyzer -fanalyzer-checker=taint --param=analyzer-max-svalue-depth=25" } */
-/* { dg-options "-fanalyzer -fanalyzer-checker=taint" } */
+/* { dg-options "-fanalyzer --param=analyzer-max-svalue-depth=25" } */
+/* { dg-additional-options "-Wno-pedantic" } */
 /* { dg-require-effective-target analyzer } */
 
 /* See notes in this header.  */
@@ -32,11 +31,10 @@ int test_1(struct file *file, unsigned int cmd, unsigned long arg)
 
 		if (info->num > 1)
 			return -EINVAL;
-		av7110->ci_slot[info->num].num = info->num; /* { dg-warning "attacker-controlled value" "" { xfail *-*-* } } */
-		// TODO(xfail)
-		av7110->ci_slot[info->num].type = FW_CI_LL_SUPPORT(av7110->arm_app) ?
+		av7110->ci_slot[info->num].num = info->num; /* { dg-warning "attacker-controlled value" } */
+		av7110->ci_slot[info->num].type = FW_CI_LL_SUPPORT(av7110->arm_app) ? /* { dg-warning "attacker-controlled value" } */
 							CA_CI_LINK : CA_CI;
-		memcpy(info, &av7110->ci_slot[info->num], sizeof(ca_slot_info_t));
+		memcpy(info, &av7110->ci_slot[info->num], sizeof(ca_slot_info_t));  /* { dg-warning "attacker-controlled value" } */
 	}
 
 	copy_to_user((void __user *)arg, parg, sizeof(sbuf));
diff --git a/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-5-fixed.c b/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-5-fixed.c
index 2e74770..076ada3 100644
--- a/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-5-fixed.c
+++ b/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-5-fixed.c
@@ -1,7 +1,7 @@
 /* { dg-do compile } */
-// TODO: remove need for -fanalyzer-checker=taint here:
 // TODO: remove need for --param=analyzer-max-svalue-depth=25 here:
-/* { dg-options "-fanalyzer -fanalyzer-checker=taint --param=analyzer-max-svalue-depth=25" } */
+/* { dg-options "-fanalyzer --param=analyzer-max-svalue-depth=25" } */
+/* { dg-additional-options "-Wno-pedantic" } */
 /* { dg-require-effective-target analyzer } */
 
 /* On darwin, system headers are fortified, which defeats the analysis.  Turn it off.  */
diff --git a/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-5.c b/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-5.c
index 021d458..e27ee46 100644
--- a/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-5.c
+++ b/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-5.c
@@ -1,7 +1,7 @@
 /* { dg-do compile } */
-// TODO: remove need for -fanalyzer-checker=taint here:
 // TODO: remove need for --param=analyzer-max-svalue-depth=25 here:
-/* { dg-options "-fanalyzer -fanalyzer-checker=taint --param=analyzer-max-svalue-depth=25" } */
+/* { dg-options "-fanalyzer --param=analyzer-max-svalue-depth=25" } */
+/* { dg-additional-options "-Wno-pedantic" } */
 /* { dg-require-effective-target analyzer } */
 
 /* On darwin, system headers are fortified, which defeats the analysis.  Turn it off.  */
diff --git a/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-6.c b/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-6.c
index f27e9eb..fea70ee 100644
--- a/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-6.c
+++ b/gcc/testsuite/gcc.dg/plugin/taint-CVE-2011-0521-6.c
@@ -1,7 +1,7 @@
 /* { dg-do compile } */
-// TODO: remove need for -fanalyzer-checker=taint here:
 // TODO: remove need for --param=analyzer-max-svalue-depth=25 here:
-/* { dg-options "-fanalyzer -fanalyzer-checker=taint --param=analyzer-max-svalue-depth=25" } */
+/* { dg-options "-fanalyzer --param=analyzer-max-svalue-depth=25" } */
+/* { dg-additional-options "-Wno-pedantic" } */
 /* { dg-require-effective-target analyzer } */
 
 /* On darwin, system headers are fortified, which defeats the analysis.  Turn it off.  */
diff --git a/gcc/testsuite/gcc.dg/plugin/taint-antipatterns-1.c b/gcc/testsuite/gcc.dg/plugin/taint-antipatterns-1.c
index 6bb6f1b..cdd9a4f 100644
--- a/gcc/testsuite/gcc.dg/plugin/taint-antipatterns-1.c
+++ b/gcc/testsuite/gcc.dg/plugin/taint-antipatterns-1.c
@@ -1,6 +1,5 @@
 /* { dg-do compile } */
-// TODO: remove need for -fanalyzer-checker=taint here:
-/* { dg-options "-fanalyzer -fanalyzer-checker=taint" } */
+/* { dg-options "-fanalyzer" } */
 /* { dg-require-effective-target analyzer } */
 
 #include "test-uaccess.h"
diff --git a/gcc/testsuite/gcc.dg/pr112374-1.c b/gcc/testsuite/gcc.dg/pr112374-1.c
new file mode 100644
index 0000000..7fbd67a
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr112374-1.c
@@ -0,0 +1,20 @@
+/* PR tree-optimization/112374 */
+/* { dg-do compile } */
+/* { dg-options "-fcompare-debug -gno-statement-frontiers -O2 -w" } */
+/* { dg-additional-options "-march=skylake-avx512" { target i?86-*-* x86_64-*-* } } */
+/* { dg-additional-options "-march=armv9-a" { target aarch64*-*-* } } */
+
+void foo (int, int);
+struct S { char s[4]; };
+int a, b, c;
+
+void
+bar ()
+{
+  struct S d;
+  long e = 0;
+  for (c = 0; c < 4; ++c)
+    e |= (d.s[c] ? 3 : 0) << c;
+  if (e)
+    foo (a, b);
+}
diff --git a/gcc/testsuite/gcc.dg/pr112374-2.c b/gcc/testsuite/gcc.dg/pr112374-2.c
new file mode 100644
index 0000000..1598c49
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr112374-2.c
@@ -0,0 +1,33 @@
+/* PR tree-optimization/112374 */
+/* { dg-do compile } */
+/* { dg-options "-fcompare-debug -gno-statement-frontiers -O2" } */
+/* { dg-additional-options "-march=skylake-avx512" { target i?86-*-* x86_64-*-* } } */
+/* { dg-additional-options "-march=armv9-a" { target aarch64*-*-* } } */
+
+void foo (int, int);
+struct S { char s[64]; } *p;
+char a, b;
+unsigned char c;
+int d, e;
+
+void
+bar (void)
+{
+  unsigned i;
+  long j = 0;
+  for (i = 0; i < b; ++i)
+    j |= (p->s[i] ? 3 : 0) << i;
+  if (p->s[i + 1])
+  lab:
+    for (;;)
+      ;
+  for (i = 0; i < 4; ++i)
+    j |= p->s[i] << i;
+  for (; i; i += 2)
+    if (c + 1 != a)
+      goto lab;
+  for (; i < 8; ++i)
+    j |= p->s[i] >= 6;
+  if (j)
+    foo (d, e);
+}
diff --git a/gcc/testsuite/gcc.dg/pr112509.c b/gcc/testsuite/gcc.dg/pr112509.c
new file mode 100644
index 0000000..b733780
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr112509.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-tree-vrp -fno-tree-fre -fno-tree-forwprop" } */
+
+struct S {
+  unsigned j : 3;
+};
+int k, l, m_1 = {0};
+void f(int l, struct S x) {
+  unsigned int k_1;
+  while (m_1 % 8) switch (x.j) {
+    case 1:
+    case 3:
+    case 4:
+    case 6:
+    case 2:
+    case 5: l = m_1;
+    case 7:
+    case 0: k_1 = 0;
+    default: break;
+    }
+}
+void foo(struct S x) { f(l, x); }
diff --git a/gcc/testsuite/gcc.dg/pr112511.c b/gcc/testsuite/gcc.dg/pr112511.c
new file mode 100644
index 0000000..7d0b73f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr112511.c
@@ -0,0 +1,17 @@
+/* PR middle-end/112511 */
+/* { dg-do compile { target bitint } } */
+/* { dg-options "-O2" } */
+
+struct T { _BitInt(22) a; };
+
+void
+bar (struct T t)
+{
+}
+
+void
+foo (void)
+{
+  struct T t;
+  bar (t);
+}
diff --git a/gcc/testsuite/gcc.dg/pr112536.c b/gcc/testsuite/gcc.dg/pr112536.c
new file mode 100644
index 0000000..633e131
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr112536.c
@@ -0,0 +1,58 @@
+/* PR tree-optimization/112536 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fno-ipa-icf" } */
+/* { dg-additional-options "-mlzcnt -mavx512cd -mavx512vl" { target { i?86-*-* x86_64-*-* } } } */
+/* { dg-final { scan-assembler-times "\tvplzcntd\t" 3 { target { i?86-*-* x86_64-*-* } } } } */
+
+unsigned a[12];
+
+void
+foo (void)
+{
+  int i = a[0];
+  int j = a[1];
+  int k = a[2];
+  int l = a[3];
+  int e = i ? __builtin_clz (i) : __SIZEOF_INT__ * __CHAR_BIT__;
+  int f = j ? __builtin_clz (j) : __SIZEOF_INT__ * __CHAR_BIT__;
+  int g = k ? __builtin_clz (k) : __SIZEOF_INT__ * __CHAR_BIT__;
+  int h = l ? __builtin_clz (l) : __SIZEOF_INT__ * __CHAR_BIT__;
+  a[0] = e;
+  a[1] = f;
+  a[2] = g;
+  a[3] = h;
+}
+
+void
+bar (void)
+{
+  int i = a[4];
+  int j = a[5];
+  int k = a[6];
+  int l = a[7];
+  int e = i ? __builtin_clz (i) : __SIZEOF_INT__ * __CHAR_BIT__;
+  int f = __builtin_clz (j);
+  int g = __builtin_clz (k);
+  int h = l ? __builtin_clz (l) : __SIZEOF_INT__ * __CHAR_BIT__;
+  a[4] = e;
+  a[5] = f;
+  a[6] = g;
+  a[7] = h;
+}
+
+void
+baz (void)
+{
+  int i = a[8];
+  int j = a[9];
+  int k = a[10];
+  int l = a[11];
+  int e = __builtin_clz (i);
+  int f = j ? __builtin_clz (j) : __SIZEOF_INT__ * __CHAR_BIT__;
+  int g = __builtin_clz (k);
+  int h = l ? __builtin_clz (l) : __SIZEOF_INT__ * __CHAR_BIT__;
+  a[8] = e;
+  a[9] = f;
+  a[10] = g;
+  a[11] = h;
+}
diff --git a/gcc/testsuite/gcc.dg/pr112566-1.c b/gcc/testsuite/gcc.dg/pr112566-1.c
new file mode 100644
index 0000000..e7672ab
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr112566-1.c
@@ -0,0 +1,14 @@
+/* PR tree-optimization/112566 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+/* { dg-additional-options "-mbmi2 -mlzcnt -mpopcnt" { target i?86-*-* x86_64-*-* } } */
+/* { dg-final { scan-tree-dump-not "ll \\\(" "optimized" { target ia32 } } } */
+/* { dg-final { scan-tree-dump-not "\\\(long long (unsigned )?int\\\)" "optimized" { target ia32 } } } */
+
+int foo (unsigned int x) { return __builtin_ctzll (x); }
+int bar (unsigned int x) { return __builtin_popcountll (x); }
+int baz (unsigned int x) { return __builtin_parityll (x); }
+int qux (int x) { return __builtin_ffsll (x); }
+int corge (int x) { return __builtin_ctzll (x); }
+int garply (int x) { return __builtin_parityll (x); }
+int fred (unsigned int x) { return __builtin_ffsll (x); }
diff --git a/gcc/testsuite/gcc.dg/pr112566-2.c b/gcc/testsuite/gcc.dg/pr112566-2.c
new file mode 100644
index 0000000..acf9ab6
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr112566-2.c
@@ -0,0 +1,12 @@
+/* PR tree-optimization/112566 */
+/* { dg-do compile { target bitint575 } } */
+/* { dg-options "-O2 -fdump-tree-ccp2" } */
+/* { dg-final { scan-tree-dump-not "\\\((unsigned )?_BitInt\\\(512\\\)\\\)" "ccp2" } } */
+
+int foo (unsigned _BitInt(256) x) { return __builtin_ctzg ((unsigned _BitInt(512)) x); }
+int bar (unsigned _BitInt(256) x) { return __builtin_popcountg ((unsigned _BitInt(512)) x); }
+int baz (unsigned _BitInt(256) x) { return __builtin_parityg ((unsigned _BitInt(512)) x); }
+int qux (_BitInt(256) x) { return __builtin_ffsg ((_BitInt(512)) x); }
+int corge (_BitInt(256) x) { return __builtin_ctzg ((unsigned _BitInt(512)) x); }
+int garply (_BitInt(256) x) { return __builtin_parityg ((unsigned _BitInt(512)) x); }
+int fred (unsigned _BitInt(256) x) { return __builtin_ffsg ((_BitInt(512)) x); }
diff --git a/gcc/testsuite/gcc.dg/pr90838.c b/gcc/testsuite/gcc.dg/pr90838.c
index 7590596..40aad70 100644
--- a/gcc/testsuite/gcc.dg/pr90838.c
+++ b/gcc/testsuite/gcc.dg/pr90838.c
@@ -83,3 +83,8 @@ int ctz4 (unsigned long x)
 /* { dg-final { scan-assembler-times "ctz\t" 3 { target { rv32 } } } } */
 /* { dg-final { scan-assembler-times "andi\t" 1 { target { rv32 } } } } */
 /* { dg-final { scan-assembler-times "mul\t" 1 { target { rv32 } } } } */
+
+/* { dg-final { scan-tree-dump-times {= \.CTZ} 4 "forwprop2" { target { loongarch64*-*-* } } } } */
+/* { dg-final { scan-assembler-times "ctz.d\t" 1 { target { loongarch64*-*-* } } } } */
+/* { dg-final { scan-assembler-times "ctz.w\t" 3 { target { loongarch64*-*-* } } } } */
+/* { dg-final { scan-assembler-times "andi\t" 4 { target { loongarch64*-*-* } } } } */
diff --git a/gcc/testsuite/gcc.dg/torture/bitint-43.c b/gcc/testsuite/gcc.dg/torture/bitint-43.c
new file mode 100644
index 0000000..4265bff
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/bitint-43.c
@@ -0,0 +1,306 @@
+/* PR c/111309 */
+/* { dg-do run { target bitint } } */
+/* { dg-options "-std=c2x -pedantic-errors" } */
+/* { dg-skip-if "" { ! run_expensive_tests }  { "*" } { "-O0" "-O2" } } */
+/* { dg-skip-if "" { ! run_expensive_tests } { "-flto" } { "" } } */
+
+#if __BITINT_MAXWIDTH__ >= 156
+__attribute__((noipa)) int
+clz156 (unsigned _BitInt(156) x)
+{
+  return __builtin_clzg (x);
+}
+
+__attribute__((noipa)) int
+clzd156 (unsigned _BitInt(156) x)
+{
+  return __builtin_clzg (x, __builtin_popcountg ((typeof (x)) ~(typeof (x)) 0));
+}
+
+__attribute__((noipa)) int
+clzD156 (unsigned _BitInt(156) x, int y)
+{
+  return __builtin_clzg (x, y);
+}
+
+__attribute__((noipa)) int
+ctz156 (unsigned _BitInt(156) x)
+{
+  return __builtin_ctzg (x);
+}
+
+__attribute__((noipa)) int
+ctzd156 (unsigned _BitInt(156) x)
+{
+  return __builtin_ctzg (x, __builtin_popcountg ((typeof (x)) ~(typeof (x)) 0));
+}
+
+__attribute__((noipa)) int
+ctzD156 (unsigned _BitInt(156) x, int y)
+{
+  return __builtin_ctzg (x, y);
+}
+
+__attribute__((noipa)) int
+clrsb156 (_BitInt(156) x)
+{
+  return __builtin_clrsbg (x);
+}
+
+__attribute__((noipa)) int
+ffs156 (_BitInt(156) x)
+{
+  return __builtin_ffsg (x);
+}
+
+__attribute__((noipa)) int
+parity156 (unsigned _BitInt(156) x)
+{
+  return __builtin_parityg (x);
+}
+
+__attribute__((noipa)) int
+popcount156 (unsigned _BitInt(156) x)
+{
+  return __builtin_popcountg (x);
+}
+#endif
+
+#if __BITINT_MAXWIDTH__ >= 192
+__attribute__((noipa)) int
+clz192 (unsigned _BitInt(192) x)
+{
+  return __builtin_clzg (x);
+}
+
+__attribute__((noipa)) int
+clzd192 (unsigned _BitInt(192) x)
+{
+  return __builtin_clzg (x, __builtin_popcountg ((typeof (x)) ~(typeof (x)) 0));
+}
+
+__attribute__((noipa)) int
+clzD192 (unsigned _BitInt(192) x, int y)
+{
+  return __builtin_clzg (x, y);
+}
+
+__attribute__((noipa)) int
+ctz192 (unsigned _BitInt(192) x)
+{
+  return __builtin_ctzg (x);
+}
+
+__attribute__((noipa)) int
+ctzd192 (unsigned _BitInt(192) x)
+{
+  return __builtin_ctzg (x, __builtin_popcountg ((typeof (x)) ~(typeof (x)) 0));
+}
+
+__attribute__((noipa)) int
+ctzD192 (unsigned _BitInt(192) x, int y)
+{
+  return __builtin_ctzg (x, y);
+}
+
+__attribute__((noipa)) int
+clrsb192 (_BitInt(192) x)
+{
+  return __builtin_clrsbg (x);
+}
+
+__attribute__((noipa)) int
+ffs192 (_BitInt(192) x)
+{
+  return __builtin_ffsg (x);
+}
+
+__attribute__((noipa)) int
+parity192 (unsigned _BitInt(192) x)
+{
+  return __builtin_parityg (x);
+}
+
+__attribute__((noipa)) int
+popcount192 (unsigned _BitInt(192) x)
+{
+  return __builtin_popcountg (x);
+}
+#endif
+
+int
+main ()
+{
+#if __BITINT_MAXWIDTH__ >= 156
+  if (clzd156 (0) != 156
+      || clzD156 (0, -1) != -1
+      || ctzd156 (0) != 156
+      || ctzD156 (0, 42) != 42
+      || clrsb156 (0) != 156 - 1
+      || ffs156 (0) != 0
+      || parity156 (0) != 0
+      || popcount156 (0) != 0
+      || __builtin_clzg ((unsigned _BitInt(156)) 0, 156 + 32) != 156 + 32
+      || __builtin_ctzg ((unsigned _BitInt(156)) 0, 156) != 156
+      || __builtin_clrsbg ((_BitInt(156)) 0) != 156 - 1
+      || __builtin_ffsg ((_BitInt(156)) 0) != 0
+      || __builtin_parityg ((unsigned _BitInt(156)) 0) != 0
+      || __builtin_popcountg ((unsigned _BitInt(156)) 0) != 0)
+    __builtin_abort ();
+  if (clz156 (-1) != 0
+      || clzd156 (-1) != 0
+      || clzD156 (-1, 0) != 0
+      || ctz156 (-1) != 0
+      || ctzd156 (-1) != 0
+      || ctzD156 (-1, 17) != 0
+      || clrsb156 (-1) != 156 - 1
+      || ffs156 (-1) != 1
+      || parity156 (-1) != 0
+      || popcount156 (-1) != 156
+      || __builtin_clzg ((unsigned _BitInt(156)) -1) != 0
+      || __builtin_clzg ((unsigned _BitInt(156)) -1, 156 + 32) != 0
+      || __builtin_ctzg ((unsigned _BitInt(156)) -1) != 0
+      || __builtin_ctzg ((unsigned _BitInt(156)) -1, 156) != 0
+      || __builtin_clrsbg ((_BitInt(156)) -1) != 156 - 1
+      || __builtin_ffsg ((_BitInt(156)) -1) != 1
+      || __builtin_parityg ((unsigned _BitInt(156)) -1) != 0
+      || __builtin_popcountg ((unsigned _BitInt(156)) -1) != 156)
+    __builtin_abort ();
+  if (clz156 (((unsigned _BitInt(156)) -1) >> 24) != 24
+      || clz156 (((unsigned _BitInt(156)) -1) >> 79) != 79
+      || clz156 (1) != 156 - 1
+      || clzd156 (((unsigned _BitInt(156)) -1) >> 139) != 139
+      || clzd156 (2) != 156 - 2
+      || ctz156 (((unsigned _BitInt(156)) -1) << 42) != 42
+      || ctz156 (((unsigned _BitInt(156)) -1) << 57) != 57
+      || ctz156 (0x4000000000000000000000uwb) != 86
+      || ctzd156 (((unsigned _BitInt(156)) -1) << 149) != 149
+      || ctzd156 (2) != 1
+      || clrsb156 ((unsigned _BitInt(156 - 4)) -1) != 3
+      || clrsb156 ((unsigned _BitInt(156 - 28)) -1) != 27
+      || clrsb156 ((unsigned _BitInt(156 - 29)) -1) != 28
+      || clrsb156 (~(unsigned _BitInt(156)) (unsigned _BitInt(156 - 68)) -1) != 67
+      || clrsb156 (~(unsigned _BitInt(156)) (unsigned _BitInt(156 - 92)) -1) != 91
+      || clrsb156 (~(unsigned _BitInt(156)) (unsigned _BitInt(156 - 93)) -1) != 92
+      || ffs156 (((unsigned _BitInt(156)) -1) << 42) != 43
+      || ffs156 (((unsigned _BitInt(156)) -1) << 57) != 58
+      || ffs156 (0x4000000000000000000000uwb) != 87
+      || ffs156 (((unsigned _BitInt(156)) -1) << 149) != 150
+      || ffs156 (2) != 2
+      || __builtin_clzg (((unsigned _BitInt(156)) -1) >> 24) != 24
+      || __builtin_clzg (((unsigned _BitInt(156)) -1) >> 79) != 79
+      || __builtin_clzg ((unsigned _BitInt(156)) 1) != 156 - 1
+      || __builtin_clzg (((unsigned _BitInt(156)) -1) >> 139, 156) != 139
+      || __builtin_clzg ((unsigned _BitInt(156)) 2, 156) != 156 - 2
+      || __builtin_ctzg (((unsigned _BitInt(156)) -1) << 42) != 42
+      || __builtin_ctzg (((unsigned _BitInt(156)) -1) << 57) != 57
+      || __builtin_ctzg ((unsigned _BitInt(156)) 0x4000000000000000000000uwb) != 86
+      || __builtin_ctzg (((unsigned _BitInt(156)) -1) << 149, 156) != 149
+      || __builtin_ctzg ((unsigned _BitInt(156)) 2, 156) != 1
+      || __builtin_clrsbg ((_BitInt(156)) (unsigned _BitInt(156 - 4)) -1) != 3
+      || __builtin_clrsbg ((_BitInt(156)) (unsigned _BitInt(156 - 28)) -1) != 27
+      || __builtin_clrsbg ((_BitInt(156)) (unsigned _BitInt(156 - 29)) -1) != 28
+      || __builtin_clrsbg ((_BitInt(156)) ~(unsigned _BitInt(156)) (unsigned _BitInt(156 - 68)) -1) != 67
+      || __builtin_clrsbg ((_BitInt(156)) ~(unsigned _BitInt(156)) (unsigned _BitInt(156 - 92)) -1) != 91
+      || __builtin_clrsbg ((_BitInt(156)) ~(unsigned _BitInt(156)) (unsigned _BitInt(156 - 93)) -1) != 92
+      || __builtin_ffsg ((_BitInt(156)) (((unsigned _BitInt(156)) -1) << 42)) != 43
+      || __builtin_ffsg ((_BitInt(156)) (((unsigned _BitInt(156)) -1) << 57)) != 58
+      || __builtin_ffsg ((_BitInt(156)) 0x4000000000000000000000uwb) != 87
+      || __builtin_ffsg ((_BitInt(156)) (((unsigned _BitInt(156)) -1) << 149)) != 150
+      || __builtin_ffsg ((_BitInt(156)) 2) != 2)
+    __builtin_abort ();
+  if (parity156 (23008250258685373142923325827291949461178444434uwb) != __builtin_parityg (23008250258685373142923325827291949461178444434uwb)
+      || parity156 (41771568792516301628132437740665810252917251244uwb) != __builtin_parityg (41771568792516301628132437740665810252917251244uwb)
+      || parity156 (5107402473866766219120283991834936835726115452uwb) != __builtin_parityg (5107402473866766219120283991834936835726115452uwb)
+      || popcount156 (50353291748276374580944955711958129678996395562uwb) != __builtin_popcountg (50353291748276374580944955711958129678996395562uwb)
+      || popcount156 (29091263616891212550063067166307725491211684496uwb) != __builtin_popcountg (29091263616891212550063067166307725491211684496uwb)
+      || popcount156 (64973284306583205619384799873110935608793072026uwb) != __builtin_popcountg (64973284306583205619384799873110935608793072026uwb))
+    __builtin_abort ();
+#endif
+#if __BITINT_MAXWIDTH__ >= 192
+  if (clzd192 (0) != 192
+      || clzD192 (0, 42) != 42
+      || ctzd192 (0) != 192
+      || ctzD192 (0, -1) != -1
+      || clrsb192 (0) != 192 - 1
+      || ffs192 (0) != 0
+      || parity192 (0) != 0
+      || popcount192 (0) != 0
+      || __builtin_clzg ((unsigned _BitInt(192)) 0, 192 + 32) != 192 + 32
+      || __builtin_ctzg ((unsigned _BitInt(192)) 0, 192) != 192
+      || __builtin_clrsbg ((_BitInt(192)) 0) != 192 - 1
+      || __builtin_ffsg ((_BitInt(192)) 0) != 0
+      || __builtin_parityg ((unsigned _BitInt(192)) 0) != 0
+      || __builtin_popcountg ((unsigned _BitInt(192)) 0) != 0)
+    __builtin_abort ();
+  if (clz192 (-1) != 0
+      || clzd192 (-1) != 0
+      || clzD192 (-1, 15) != 0
+      || ctz192 (-1) != 0
+      || ctzd192 (-1) != 0
+      || ctzD192 (-1, -57) != 0
+      || clrsb192 (-1) != 192 - 1
+      || ffs192 (-1) != 1
+      || parity192 (-1) != 0
+      || popcount192 (-1) != 192
+      || __builtin_clzg ((unsigned _BitInt(192)) -1) != 0
+      || __builtin_clzg ((unsigned _BitInt(192)) -1, 192 + 32) != 0
+      || __builtin_ctzg ((unsigned _BitInt(192)) -1) != 0
+      || __builtin_ctzg ((unsigned _BitInt(192)) -1, 192) != 0
+      || __builtin_clrsbg ((_BitInt(192)) -1) != 192 - 1
+      || __builtin_ffsg ((_BitInt(192)) -1) != 1
+      || __builtin_parityg ((unsigned _BitInt(192)) -1) != 0
+      || __builtin_popcountg ((unsigned _BitInt(192)) -1) != 192)
+    __builtin_abort ();
+  if (clz192 (((unsigned _BitInt(192)) -1) >> 24) != 24
+      || clz192 (((unsigned _BitInt(192)) -1) >> 79) != 79
+      || clz192 (1) != 192 - 1
+      || clzd192 (((unsigned _BitInt(192)) -1) >> 139) != 139
+      || clzd192 (2) != 192 - 2
+      || ctz192 (((unsigned _BitInt(192)) -1) << 42) != 42
+      || ctz192 (((unsigned _BitInt(192)) -1) << 57) != 57
+      || ctz192 (0x4000000000000000000000uwb) != 86
+      || ctzd192 (((unsigned _BitInt(192)) -1) << 149) != 149
+      || ctzd192 (2) != 1
+      || clrsb192 ((unsigned _BitInt(192 - 4)) -1) != 3
+      || clrsb192 ((unsigned _BitInt(192 - 28)) -1) != 27
+      || clrsb192 ((unsigned _BitInt(192 - 29)) -1) != 28
+      || clrsb192 (~(unsigned _BitInt(192)) (unsigned _BitInt(192 - 68)) -1) != 67
+      || clrsb192 (~(unsigned _BitInt(192)) (unsigned _BitInt(192 - 92)) -1) != 91
+      || clrsb192 (~(unsigned _BitInt(192)) (unsigned _BitInt(192 - 93)) -1) != 92
+      || ffs192 (((unsigned _BitInt(192)) -1) << 42) != 43
+      || ffs192 (((unsigned _BitInt(192)) -1) << 57) != 58
+      || ffs192 (0x4000000000000000000000uwb) != 87
+      || ffs192 (((unsigned _BitInt(192)) -1) << 149) != 150
+      || ffs192 (2) != 2
+      || __builtin_clzg (((unsigned _BitInt(192)) -1) >> 24) != 24
+      || __builtin_clzg (((unsigned _BitInt(192)) -1) >> 79) != 79
+      || __builtin_clzg ((unsigned _BitInt(192)) 1) != 192 - 1
+      || __builtin_clzg (((unsigned _BitInt(192)) -1) >> 139, 192) != 139
+      || __builtin_clzg ((unsigned _BitInt(192)) 2, 192) != 192 - 2
+      || __builtin_ctzg (((unsigned _BitInt(192)) -1) << 42) != 42
+      || __builtin_ctzg (((unsigned _BitInt(192)) -1) << 57) != 57
+      || __builtin_ctzg ((unsigned _BitInt(192)) 0x4000000000000000000000uwb) != 86
+      || __builtin_ctzg (((unsigned _BitInt(192)) -1) << 149, 192) != 149
+      || __builtin_ctzg ((unsigned _BitInt(192)) 2, 192) != 1
+      || __builtin_clrsbg ((_BitInt(192)) (unsigned _BitInt(192 - 4)) -1) != 3
+      || __builtin_clrsbg ((_BitInt(192)) (unsigned _BitInt(192 - 28)) -1) != 27
+      || __builtin_clrsbg ((_BitInt(192)) (unsigned _BitInt(192 - 29)) -1) != 28
+      || __builtin_clrsbg ((_BitInt(192)) ~(unsigned _BitInt(192)) (unsigned _BitInt(192 - 68)) -1) != 67
+      || __builtin_clrsbg ((_BitInt(192)) ~(unsigned _BitInt(192)) (unsigned _BitInt(192 - 92)) -1) != 91
+      || __builtin_clrsbg ((_BitInt(192)) ~(unsigned _BitInt(192)) (unsigned _BitInt(192 - 93)) -1) != 92
+      || __builtin_ffsg ((_BitInt(192)) (((unsigned _BitInt(192)) -1) << 42)) != 43
+      || __builtin_ffsg ((_BitInt(192)) (((unsigned _BitInt(192)) -1) << 57)) != 58
+      || __builtin_ffsg ((_BitInt(192)) 0x4000000000000000000000uwb) != 87
+      || __builtin_ffsg ((_BitInt(192)) (((unsigned _BitInt(192)) -1) << 149)) != 150
+      || __builtin_ffsg ((_BitInt(192)) 2) != 2)
+    __builtin_abort ();
+  if (parity192 (4692147078159863499615754634965484598760535154638668598762uwb) != __builtin_parityg (4692147078159863499615754634965484598760535154638668598762uwb)
+      || parity192 (1669461228546917627909935444501097256112222796898845183538uwb) != __builtin_parityg (1669461228546917627909935444501097256112222796898845183538uwb)
+      || parity192 (5107402473866766219120283991834936835726115452uwb) != __builtin_parityg (5107402473866766219120283991834936835726115452uwb)
+      || popcount192 (4033871057575185619108386380181511734118888391160164588976uwb) != __builtin_popcountg (4033871057575185619108386380181511734118888391160164588976uwb)
+      || popcount192 (58124766715713711628758119849579188845074973856704521119uwb) != __builtin_popcountg (58124766715713711628758119849579188845074973856704521119uwb)
+      || popcount192 (289948065236269174335700831610076764076947650072787325852uwb) != __builtin_popcountg (289948065236269174335700831610076764076947650072787325852uwb))
+    __builtin_abort ();
+#endif
+}
diff --git a/gcc/testsuite/gcc.dg/torture/bitint-44.c b/gcc/testsuite/gcc.dg/torture/bitint-44.c
new file mode 100644
index 0000000..938c0e9
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/bitint-44.c
@@ -0,0 +1,306 @@
+/* PR c/111309 */
+/* { dg-do run { target bitint } } */
+/* { dg-options "-std=c2x -pedantic-errors" } */
+/* { dg-skip-if "" { ! run_expensive_tests }  { "*" } { "-O0" "-O2" } } */
+/* { dg-skip-if "" { ! run_expensive_tests } { "-flto" } { "" } } */
+
+#if __BITINT_MAXWIDTH__ >= 512
+__attribute__((noipa)) int
+clz512 (unsigned _BitInt(512) x)
+{
+  return __builtin_clzg (x);
+}
+
+__attribute__((noipa)) int
+clzd512 (unsigned _BitInt(512) x)
+{
+  return __builtin_clzg (x, __builtin_popcountg ((typeof (x)) ~(typeof (x)) 0));
+}
+
+__attribute__((noipa)) int
+clzD512 (unsigned _BitInt(512) x, int y)
+{
+  return __builtin_clzg (x, y);
+}
+
+__attribute__((noipa)) int
+ctz512 (unsigned _BitInt(512) x)
+{
+  return __builtin_ctzg (x);
+}
+
+__attribute__((noipa)) int
+ctzd512 (unsigned _BitInt(512) x)
+{
+  return __builtin_ctzg (x, __builtin_popcountg ((typeof (x)) ~(typeof (x)) 0));
+}
+
+__attribute__((noipa)) int
+ctzD512 (unsigned _BitInt(512) x, int y)
+{
+  return __builtin_ctzg (x, y);
+}
+
+__attribute__((noipa)) int
+clrsb512 (_BitInt(512) x)
+{
+  return __builtin_clrsbg (x);
+}
+
+__attribute__((noipa)) int
+ffs512 (_BitInt(512) x)
+{
+  return __builtin_ffsg (x);
+}
+
+__attribute__((noipa)) int
+parity512 (unsigned _BitInt(512) x)
+{
+  return __builtin_parityg (x);
+}
+
+__attribute__((noipa)) int
+popcount512 (unsigned _BitInt(512) x)
+{
+  return __builtin_popcountg (x);
+}
+#endif
+
+#if __BITINT_MAXWIDTH__ >= 523
+__attribute__((noipa)) int
+clz523 (unsigned _BitInt(523) x)
+{
+  return __builtin_clzg (x);
+}
+
+__attribute__((noipa)) int
+clzd523 (unsigned _BitInt(523) x)
+{
+  return __builtin_clzg (x, __builtin_popcountg ((typeof (x)) ~(typeof (x)) 0));
+}
+
+__attribute__((noipa)) int
+clzD523 (unsigned _BitInt(523) x, int y)
+{
+  return __builtin_clzg (x, y);
+}
+
+__attribute__((noipa)) int
+ctz523 (unsigned _BitInt(523) x)
+{
+  return __builtin_ctzg (x);
+}
+
+__attribute__((noipa)) int
+ctzd523 (unsigned _BitInt(523) x)
+{
+  return __builtin_ctzg (x, __builtin_popcountg ((typeof (x)) ~(typeof (x)) 0));
+}
+
+__attribute__((noipa)) int
+ctzD523 (unsigned _BitInt(523) x, int y)
+{
+  return __builtin_ctzg (x, y);
+}
+
+__attribute__((noipa)) int
+clrsb523 (_BitInt(523) x)
+{
+  return __builtin_clrsbg (x);
+}
+
+__attribute__((noipa)) int
+ffs523 (_BitInt(523) x)
+{
+  return __builtin_ffsg (x);
+}
+
+__attribute__((noipa)) int
+parity523 (unsigned _BitInt(523) x)
+{
+  return __builtin_parityg (x);
+}
+
+__attribute__((noipa)) int
+popcount523 (unsigned _BitInt(523) x)
+{
+  return __builtin_popcountg (x);
+}
+#endif
+
+int
+main ()
+{
+#if __BITINT_MAXWIDTH__ >= 512
+  if (clzd512 (0) != 512
+      || clzD512 (0, -1) != -1
+      || ctzd512 (0) != 512
+      || ctzD512 (0, 42) != 42
+      || clrsb512 (0) != 512 - 1
+      || ffs512 (0) != 0
+      || parity512 (0) != 0
+      || popcount512 (0) != 0
+      || __builtin_clzg ((unsigned _BitInt(512)) 0, 512 + 32) != 512 + 32
+      || __builtin_ctzg ((unsigned _BitInt(512)) 0, 512) != 512
+      || __builtin_clrsbg ((_BitInt(512)) 0) != 512 - 1
+      || __builtin_ffsg ((_BitInt(512)) 0) != 0
+      || __builtin_parityg ((unsigned _BitInt(512)) 0) != 0
+      || __builtin_popcountg ((unsigned _BitInt(512)) 0) != 0)
+    __builtin_abort ();
+  if (clz512 (-1) != 0
+      || clzd512 (-1) != 0
+      || clzD512 (-1, 0) != 0
+      || ctz512 (-1) != 0
+      || ctzd512 (-1) != 0
+      || ctzD512 (-1, 17) != 0
+      || clrsb512 (-1) != 512 - 1
+      || ffs512 (-1) != 1
+      || parity512 (-1) != 0
+      || popcount512 (-1) != 512
+      || __builtin_clzg ((unsigned _BitInt(512)) -1) != 0
+      || __builtin_clzg ((unsigned _BitInt(512)) -1, 512 + 32) != 0
+      || __builtin_ctzg ((unsigned _BitInt(512)) -1) != 0
+      || __builtin_ctzg ((unsigned _BitInt(512)) -1, 512) != 0
+      || __builtin_clrsbg ((_BitInt(512)) -1) != 512 - 1
+      || __builtin_ffsg ((_BitInt(512)) -1) != 1
+      || __builtin_parityg ((unsigned _BitInt(512)) -1) != 0
+      || __builtin_popcountg ((unsigned _BitInt(512)) -1) != 512)
+    __builtin_abort ();
+  if (clz512 (((unsigned _BitInt(512)) -1) >> 24) != 24
+      || clz512 (((unsigned _BitInt(512)) -1) >> 79) != 79
+      || clz512 (1) != 512 - 1
+      || clzd512 (((unsigned _BitInt(512)) -1) >> 139) != 139
+      || clzd512 (2) != 512 - 2
+      || ctz512 (((unsigned _BitInt(512)) -1) << 42) != 42
+      || ctz512 (((unsigned _BitInt(512)) -1) << 57) != 57
+      || ctz512 (0x4000000000000000000000uwb) != 86
+      || ctzd512 (((unsigned _BitInt(512)) -1) << 149) != 149
+      || ctzd512 (2) != 1
+      || clrsb512 ((unsigned _BitInt(512 - 4)) -1) != 3
+      || clrsb512 ((unsigned _BitInt(512 - 28)) -1) != 27
+      || clrsb512 ((unsigned _BitInt(512 - 29)) -1) != 28
+      || clrsb512 (~(unsigned _BitInt(512)) (unsigned _BitInt(512 - 68)) -1) != 67
+      || clrsb512 (~(unsigned _BitInt(512)) (unsigned _BitInt(512 - 92)) -1) != 91
+      || clrsb512 (~(unsigned _BitInt(512)) (unsigned _BitInt(512 - 93)) -1) != 92
+      || ffs512 (((unsigned _BitInt(512)) -1) << 42) != 43
+      || ffs512 (((unsigned _BitInt(512)) -1) << 57) != 58
+      || ffs512 (0x4000000000000000000000uwb) != 87
+      || ffs512 (((unsigned _BitInt(512)) -1) << 149) != 150
+      || ffs512 (2) != 2
+      || __builtin_clzg (((unsigned _BitInt(512)) -1) >> 24) != 24
+      || __builtin_clzg (((unsigned _BitInt(512)) -1) >> 79) != 79
+      || __builtin_clzg ((unsigned _BitInt(512)) 1) != 512 - 1
+      || __builtin_clzg (((unsigned _BitInt(512)) -1) >> 139, 512) != 139
+      || __builtin_clzg ((unsigned _BitInt(512)) 2, 512) != 512 - 2
+      || __builtin_ctzg (((unsigned _BitInt(512)) -1) << 42) != 42
+      || __builtin_ctzg (((unsigned _BitInt(512)) -1) << 57) != 57
+      || __builtin_ctzg ((unsigned _BitInt(512)) 0x4000000000000000000000uwb) != 86
+      || __builtin_ctzg (((unsigned _BitInt(512)) -1) << 149, 512) != 149
+      || __builtin_ctzg ((unsigned _BitInt(512)) 2, 512) != 1
+      || __builtin_clrsbg ((_BitInt(512)) (unsigned _BitInt(512 - 4)) -1) != 3
+      || __builtin_clrsbg ((_BitInt(512)) (unsigned _BitInt(512 - 28)) -1) != 27
+      || __builtin_clrsbg ((_BitInt(512)) (unsigned _BitInt(512 - 29)) -1) != 28
+      || __builtin_clrsbg ((_BitInt(512)) ~(unsigned _BitInt(512)) (unsigned _BitInt(512 - 68)) -1) != 67
+      || __builtin_clrsbg ((_BitInt(512)) ~(unsigned _BitInt(512)) (unsigned _BitInt(512 - 92)) -1) != 91
+      || __builtin_clrsbg ((_BitInt(512)) ~(unsigned _BitInt(512)) (unsigned _BitInt(512 - 93)) -1) != 92
+      || __builtin_ffsg ((_BitInt(512)) (((unsigned _BitInt(512)) -1) << 42)) != 43
+      || __builtin_ffsg ((_BitInt(512)) (((unsigned _BitInt(512)) -1) << 57)) != 58
+      || __builtin_ffsg ((_BitInt(512)) 0x4000000000000000000000uwb) != 87
+      || __builtin_ffsg ((_BitInt(512)) (((unsigned _BitInt(512)) -1) << 149)) != 150
+      || __builtin_ffsg ((_BitInt(512)) 2) != 2)
+    __builtin_abort ();
+  if (parity512 (8278593062772967967574644592392030907507244457324713380127157444008480135136016412791369421272159911061801023217823646324038055629840240503699995274750141uwb) != __builtin_parityg (8278593062772967967574644592392030907507244457324713380127157444008480135136016412791369421272159911061801023217823646324038055629840240503699995274750141uwb)
+      || parity512 (663951521760319802637316646127146913163123967584512032007606686578544864655291546789196279408181546344880831465704154822174055168766759305688225967189384uwb) != __builtin_parityg (663951521760319802637316646127146913163123967584512032007606686578544864655291546789196279408181546344880831465704154822174055168766759305688225967189384uwb)
+      || parity512 (8114152627481936575035564712656624361256533214211179387274127464949371919139038942819974113641465089580051998523156404968195970853124179018281296621919217uwb) != __builtin_parityg (8114152627481936575035564712656624361256533214211179387274127464949371919139038942819974113641465089580051998523156404968195970853124179018281296621919217uwb)
+      || popcount512 (697171368046392901434470580443928282938585745214587494987284546386421344865289735592202298494880955572094546861862007016154025065165834164941207378563932uwb) != __builtin_popcountg (697171368046392901434470580443928282938585745214587494987284546386421344865289735592202298494880955572094546861862007016154025065165834164941207378563932uwb)
+      || popcount512 (12625357869391866487124235043239209385173615631331705015179232007319637649427586947822360147798041278948617160703315666047585702906648747835331939389354450uwb) != __builtin_popcountg (12625357869391866487124235043239209385173615631331705015179232007319637649427586947822360147798041278948617160703315666047585702906648747835331939389354450uwb)
+      || popcount512 (12989863959706456104163426941303698078341934896544520782734564901708926112239778316241786242633862403309192697330635825122310265805838908726925342761646021uwb) != __builtin_popcountg (12989863959706456104163426941303698078341934896544520782734564901708926112239778316241786242633862403309192697330635825122310265805838908726925342761646021uwb))
+    __builtin_abort ();
+#endif
+#if __BITINT_MAXWIDTH__ >= 523
+  if (clzd523 (0) != 523
+      || clzD523 (0, 42) != 42
+      || ctzd523 (0) != 523
+      || ctzD523 (0, -1) != -1
+      || clrsb523 (0) != 523 - 1
+      || ffs523 (0) != 0
+      || parity523 (0) != 0
+      || popcount523 (0) != 0
+      || __builtin_clzg ((unsigned _BitInt(523)) 0, 523 + 32) != 523 + 32
+      || __builtin_ctzg ((unsigned _BitInt(523)) 0, 523) != 523
+      || __builtin_clrsbg ((_BitInt(523)) 0) != 523 - 1
+      || __builtin_ffsg ((_BitInt(523)) 0) != 0
+      || __builtin_parityg ((unsigned _BitInt(523)) 0) != 0
+      || __builtin_popcountg ((unsigned _BitInt(523)) 0) != 0)
+    __builtin_abort ();
+  if (clz523 (-1) != 0
+      || clzd523 (-1) != 0
+      || clzD523 (-1, 15) != 0
+      || ctz523 (-1) != 0
+      || ctzd523 (-1) != 0
+      || ctzD523 (-1, -57) != 0
+      || clrsb523 (-1) != 523 - 1
+      || ffs523 (-1) != 1
+      || parity523 (-1) != 1
+      || popcount523 (-1) != 523
+      || __builtin_clzg ((unsigned _BitInt(523)) -1) != 0
+      || __builtin_clzg ((unsigned _BitInt(523)) -1, 523 + 32) != 0
+      || __builtin_ctzg ((unsigned _BitInt(523)) -1) != 0
+      || __builtin_ctzg ((unsigned _BitInt(523)) -1, 523) != 0
+      || __builtin_clrsbg ((_BitInt(523)) -1) != 523 - 1
+      || __builtin_ffsg ((_BitInt(523)) -1) != 1
+      || __builtin_parityg ((unsigned _BitInt(523)) -1) != 1
+      || __builtin_popcountg ((unsigned _BitInt(523)) -1) != 523)
+    __builtin_abort ();
+  if (clz523 (((unsigned _BitInt(523)) -1) >> 24) != 24
+      || clz523 (((unsigned _BitInt(523)) -1) >> 79) != 79
+      || clz523 (1) != 523 - 1
+      || clzd523 (((unsigned _BitInt(523)) -1) >> 139) != 139
+      || clzd523 (2) != 523 - 2
+      || ctz523 (((unsigned _BitInt(523)) -1) << 42) != 42
+      || ctz523 (((unsigned _BitInt(523)) -1) << 57) != 57
+      || ctz523 (0x4000000000000000000000uwb) != 86
+      || ctzd523 (((unsigned _BitInt(523)) -1) << 149) != 149
+      || ctzd523 (2) != 1
+      || clrsb523 ((unsigned _BitInt(523 - 4)) -1) != 3
+      || clrsb523 ((unsigned _BitInt(523 - 28)) -1) != 27
+      || clrsb523 ((unsigned _BitInt(523 - 29)) -1) != 28
+      || clrsb523 (~(unsigned _BitInt(523)) (unsigned _BitInt(523 - 68)) -1) != 67
+      || clrsb523 (~(unsigned _BitInt(523)) (unsigned _BitInt(523 - 92)) -1) != 91
+      || clrsb523 (~(unsigned _BitInt(523)) (unsigned _BitInt(523 - 93)) -1) != 92
+      || ffs523 (((unsigned _BitInt(523)) -1) << 42) != 43
+      || ffs523 (((unsigned _BitInt(523)) -1) << 57) != 58
+      || ffs523 (0x4000000000000000000000uwb) != 87
+      || ffs523 (((unsigned _BitInt(523)) -1) << 149) != 150
+      || ffs523 (2) != 2
+      || __builtin_clzg (((unsigned _BitInt(523)) -1) >> 24) != 24
+      || __builtin_clzg (((unsigned _BitInt(523)) -1) >> 79) != 79
+      || __builtin_clzg ((unsigned _BitInt(523)) 1) != 523 - 1
+      || __builtin_clzg (((unsigned _BitInt(523)) -1) >> 139, 523) != 139
+      || __builtin_clzg ((unsigned _BitInt(523)) 2, 523) != 523 - 2
+      || __builtin_ctzg (((unsigned _BitInt(523)) -1) << 42) != 42
+      || __builtin_ctzg (((unsigned _BitInt(523)) -1) << 57) != 57
+      || __builtin_ctzg ((unsigned _BitInt(523)) 0x4000000000000000000000uwb) != 86
+      || __builtin_ctzg (((unsigned _BitInt(523)) -1) << 149, 523) != 149
+      || __builtin_ctzg ((unsigned _BitInt(523)) 2, 523) != 1
+      || __builtin_clrsbg ((_BitInt(523)) (unsigned _BitInt(523 - 4)) -1) != 3
+      || __builtin_clrsbg ((_BitInt(523)) (unsigned _BitInt(523 - 28)) -1) != 27
+      || __builtin_clrsbg ((_BitInt(523)) (unsigned _BitInt(523 - 29)) -1) != 28
+      || __builtin_clrsbg ((_BitInt(523)) ~(unsigned _BitInt(523)) (unsigned _BitInt(523 - 68)) -1) != 67
+      || __builtin_clrsbg ((_BitInt(523)) ~(unsigned _BitInt(523)) (unsigned _BitInt(523 - 92)) -1) != 91
+      || __builtin_clrsbg ((_BitInt(523)) ~(unsigned _BitInt(523)) (unsigned _BitInt(523 - 93)) -1) != 92
+      || __builtin_ffsg ((_BitInt(523)) (((unsigned _BitInt(523)) -1) << 42)) != 43
+      || __builtin_ffsg ((_BitInt(523)) (((unsigned _BitInt(523)) -1) << 57)) != 58
+      || __builtin_ffsg ((_BitInt(523)) 0x4000000000000000000000uwb) != 87
+      || __builtin_ffsg ((_BitInt(523)) (((unsigned _BitInt(523)) -1) << 149)) != 150
+      || __builtin_ffsg ((_BitInt(523)) 2) != 2)
+    __builtin_abort ();
+  if (parity523 (14226628251091586975416900831427560438504550751597528218770815297642064445318137709184907300499591292677456563377096100346699421879373024906380724757049700104uwb) != __builtin_parityg (14226628251091586975416900831427560438504550751597528218770815297642064445318137709184907300499591292677456563377096100346699421879373024906380724757049700104uwb)
+      || parity523 (20688958227123188226117538663818621034852702121556301239818743230005799574164516085541310491875153692467123662601853835357822935286851364843928714141587045255uwb) != __builtin_parityg (20688958227123188226117538663818621034852702121556301239818743230005799574164516085541310491875153692467123662601853835357822935286851364843928714141587045255uwb)
+      || parity523 (8927708174664018648856542263215989788443763271738485875573765922613438023117960552135374015673598803453205044464280019640319125968982118836809392169156450404uwb) != __builtin_parityg (8927708174664018648856542263215989788443763271738485875573765922613438023117960552135374015673598803453205044464280019640319125968982118836809392169156450404uwb)
+      || popcount523 (27178327344587654457581274852432957423537947348354896748701960885269035920194935311522194372418922852798513401240689173265979378157685169921449935364246334672uwb) != __builtin_popcountg (27178327344587654457581274852432957423537947348354896748701960885269035920194935311522194372418922852798513401240689173265979378157685169921449935364246334672uwb)
+      || popcount523 (5307736750284212829931201546806718535860789684371772688568780952567669490917265125893664418036905110148872995350655890585853451175740907670080602411287166989uwb) != __builtin_popcountg (5307736750284212829931201546806718535860789684371772688568780952567669490917265125893664418036905110148872995350655890585853451175740907670080602411287166989uwb)
+      || popcount523 (21261096432069432668470452941790780841888331284195411465624030283325239673941548816191698556934198698768393659379577567450765073013688585051560340496749593370uwb) != __builtin_popcountg (21261096432069432668470452941790780841888331284195411465624030283325239673941548816191698556934198698768393659379577567450765073013688585051560340496749593370uwb))
+    __builtin_abort ();
+#endif
+}
diff --git a/gcc/testsuite/gcc.dg/torture/pr111233.c b/gcc/testsuite/gcc.dg/torture/pr111233.c
new file mode 100644
index 0000000..3093403
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr111233.c
@@ -0,0 +1,19 @@
+/* { dg-do run } */
+/* { dg-additional-options "-fsplit-loops" } */
+
+int a, c, f;
+char b, g;
+int *d = &c;
+long e;
+int main()
+{
+  for (; e != 25; e++) {
+    f = -17;
+    for (; f <= 0; f = f + 7) {
+      g = f ? 0 : b;
+      a = *d;
+    }
+  }
+  if (a != 0)
+    __builtin_abort ();
+}
diff --git a/gcc/testsuite/gcc.dg/torture/pr111652.c b/gcc/testsuite/gcc.dg/torture/pr111652.c
new file mode 100644
index 0000000..ebca9c7
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr111652.c
@@ -0,0 +1,15 @@
+/* { dg-do run } */
+/* { dg-additional-options "-fsplit-loops" } */
+
+volatile int a;
+int b;
+int main() {
+  for (; b < 5; b += 3) {
+    b && a;
+    if (b < 4)
+      a--;
+  }
+  if (b != 6)
+    __builtin_abort();
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/torture/pr111727.c b/gcc/testsuite/gcc.dg/torture/pr111727.c
new file mode 100644
index 0000000..fb68e19
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr111727.c
@@ -0,0 +1,14 @@
+/* { dg-do run } */
+/* { dg-additional-options "-fsplit-loops" } */
+
+int a, b;
+int main()
+{
+  for (; a < 4; a += 2)
+    if (a > 2)
+      while (b++);
+  ;
+  if (a != 4)
+    __builtin_abort();
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/torture/pr111838.c b/gcc/testsuite/gcc.dg/torture/pr111838.c
new file mode 100644
index 0000000..67007d9
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr111838.c
@@ -0,0 +1,17 @@
+/* { dg-do run } */
+/* { dg-additional-options "-fsplit-loops" } */
+
+int a, b, c;
+volatile char d;
+int main()
+{
+  for (; b < 1; b++)
+    for (char e = -17; e < 1; e += 5)
+      {
+	if (e ? a % e : 0)
+	  d;
+	for (c = 0; c < 1; c++)
+	  ;
+      }
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/torture/pr112113.c b/gcc/testsuite/gcc.dg/torture/pr112113.c
new file mode 100644
index 0000000..96cd75f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr112113.c
@@ -0,0 +1,16 @@
+/* { dg-do run } */
+/* The -Waggressive-loop-optimizations diagnostic is spurious, missed
+   constant propagation after final value replacement.  */
+/* { dg-additional-options "-Wno-aggressive-loop-optimizations -fsplit-loops" } */
+
+volatile int a;
+int main()
+{
+  for (int b = 0; b < 33; b += 3) {
+    if (b > 31)
+      a++;
+  }
+  if (a != 0)
+    __builtin_abort();
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/torture/pr112282.c b/gcc/testsuite/gcc.dg/torture/pr112282.c
new file mode 100644
index 0000000..6190b90
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr112282.c
@@ -0,0 +1,137 @@
+/* { dg-do run } */
+
+int printf(const char *, ...);
+void abort ();
+/* We need an abort that isn't noreturn.  */
+void __attribute__((noipa)) my_abort ()
+{
+  abort ();
+}
+int a, g, h, i, v, w = 2, x, y, ab, ac, ad, ae, af, ag;
+static int f, j, m, n, p, r, u, aa;
+struct b {
+  int c : 20;
+  int d : 20;
+  int e : 10;
+};
+static struct b l, o, q = {3, 3, 5};
+int s(int z) {
+  struct b ah;
+  int ai = 1, aj[7] = {1, 1, 1, 1, 1, 1, 1};
+ak:
+  for (u = -22; u < 2; ++u) {
+    struct b al[8] = {{2, 7, 9}, {8, 7, 1}, {2, 7, 9}, {8, 7, 1}, {2, 7, 9}, {8, 7, 1}, {2, 7, 9}};
+    y = z = 0;
+    for (; z < 2; z++) {
+      int am[18], k;
+      ab = ac = 0;
+      for (; ac < 1; ac++)
+        for (k = 0; k < 9; k++)
+          am[k] = 0;
+      n = 0;
+      while (1) {
+        v = u < 0 || a;
+        h = z < ~u && 4 & q.c;
+        if ((aa <= l.c) > q.d && p)
+          return o.c;
+        if (w)
+          break;
+        return q.e;
+      }
+      a = j;
+    }
+  }
+  for (x = 0; x < 2; x++) {
+    struct b an = {1, 8, 4};
+    int ao[28] = {5, 0, 0, 9, 0, 3, 0, 5, 0, 0, 9, 0, 3, 0, 5, 0, 0, 9, 0, 3, 0, 5, 0, 0, 9, 0, 3, 0};
+    if (q.e) {
+      int ap = ai || l.c + q.c, aq = q.d, ar = p & f;
+      q.d = q.d || ar || ap;
+      p = 0;
+      if (!j && ai)
+        goto as;
+      if (q.d) {
+        printf("", l);
+        q.d = f >> j;
+      }
+      p = l.c = aq;
+      an = q;
+    } else {
+      int at[12][1] = {{9}, {9}, {5}, {9}, {9}, {5}, {9}, {9}, {5}, {9}, {9}, {5}};
+      struct b au;
+      if (o.c)
+        aa = ah.e;
+      if (an.d)
+        ah.e = (j & (aa * m)) ^ au.d;
+      o.c = m + aa;
+      int av = o.c || 0, aw = ai || q.c & l.c, ax = n;
+      if (q.e < ai)
+        q = an;
+      if (r)
+        break;
+      ai = aw - av;
+      an.e = 0;
+      if (ai) {
+        an.e = l.c || 0;
+        f = q.c;
+        ah.e = l.c % q.d;
+        q.c = au.e;
+        if ((q.d && q.c) || ah.e)
+          my_abort ();
+        q.c = 0;
+        if (au.d > m || ah.e)
+          w = au.c | (n & ah.c);
+      as:
+        ae = af = ah.c;
+        int ay = au.d & q.e & au.c || o.c, az = 0 || o.c, ba = m & ah.d;
+        if (n)
+          au.c = au.e = (q.e || ah.d) ^ (o.c + (az / au.e));
+        n = au.c || au.e;
+        if (ba) {
+          printf("", ax);
+          x = q.e | m;
+          continue;
+        }
+        m = ay;
+        n = printf("", au);
+      }
+      if (ah.d)
+        o.c = l.c & o.c & q.c;
+      if (q.d)
+        my_abort ();
+      printf("", an);
+      printf("", q);
+      printf("", au);
+      if (ah.e)
+        while (u++) {
+          struct b al[7] = {{7, 9, 8}, {7, 1, 2}, {7, 9, 8}, {7, 1, 2}, {7, 9, 8}, {7, 1, 2}, {7, 9, 0}};
+          if (an.d) {
+            int d[8] = {0, 1, 0, 1, 0, 1, 0, 1};
+            if (ad)
+              goto ak;
+            while (ag)
+              g = an.d = i = m;
+            f = j;
+          }
+          n++;
+        }
+      f = q.d;
+    }
+    if (l.c && m) {
+      int d[7] = {1, 0, 1, 0, 1, 0, 1};
+      if (x)
+        h = an.d;
+      else
+        g = 0;
+    }
+  }
+  int bb = (q.d ^ ah.c) | aa | (q.e & q.c) | (f & ah.d);
+  if (bb)
+    return x;
+  return 0;
+}
+int main() {
+  j = 1;
+  s(0);
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/torture/pr112585.c b/gcc/testsuite/gcc.dg/torture/pr112585.c
new file mode 100644
index 0000000..6c8cbeb
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr112585.c
@@ -0,0 +1,18 @@
+/* { dg-do run } */
+/* { dg-additional-options "-ftree-loop-distribution" } */
+
+static int a[10], b;
+char c, *d = &c, e;
+int main()
+{
+  int f = 0;
+  for (; f < 9; f++) {
+    a[f] = 1;
+    a[f + 1] = e;
+    for (b = 0; b < 8; b++)
+      *d = 0;
+  }
+  if (a[2] != 1)
+    __builtin_abort();
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/sra-17.c b/gcc/testsuite/gcc.dg/tree-ssa/sra-17.c
index 221d96b..b0d4811 100644
--- a/gcc/testsuite/gcc.dg/tree-ssa/sra-17.c
+++ b/gcc/testsuite/gcc.dg/tree-ssa/sra-17.c
@@ -1,6 +1,7 @@
 /* { dg-do run { target { aarch64*-*-* alpha*-*-* arm*-*-* hppa*-*-* powerpc*-*-* s390*-*-* } } } */
 /* { dg-options "-O2 -fdump-tree-esra --param sra-max-scalarization-size-Ospeed=32" } */
 /* { dg-additional-options "-mcpu=ev4" { target alpha*-*-* } } */
+/* { dg-additional-options "-mno-vsx" { target { powerpc*-*-* && ilp32 } } } */
 
 extern void abort (void);
 
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/sra-18.c b/gcc/testsuite/gcc.dg/tree-ssa/sra-18.c
index f5e6a21..2cdeae6 100644
--- a/gcc/testsuite/gcc.dg/tree-ssa/sra-18.c
+++ b/gcc/testsuite/gcc.dg/tree-ssa/sra-18.c
@@ -1,6 +1,7 @@
 /* { dg-do run { target { aarch64*-*-* alpha*-*-* arm*-*-* hppa*-*-* powerpc*-*-* s390*-*-* } } } */
 /* { dg-options "-O2 -fdump-tree-esra --param sra-max-scalarization-size-Ospeed=32" } */
 /* { dg-additional-options "-mcpu=ev4" { target alpha*-*-* } } */
+/* { dg-additional-options "-mno-vsx" { target { powerpc*-*-* && ilp32 } } } */
 
 extern void abort (void);
 struct foo { long x; };
diff --git a/gcc/testsuite/gcc.dg/utf16-4.c b/gcc/testsuite/gcc.dg/utf16-4.c
index 60e00f6..e108d00 100644
--- a/gcc/testsuite/gcc.dg/utf16-4.c
+++ b/gcc/testsuite/gcc.dg/utf16-4.c
@@ -6,8 +6,8 @@
 typedef __CHAR16_TYPE__ char16_t;
 
 char16_t	c0 = u'';		/* { dg-error "empty character" } */
-char16_t	c1 = u'ab';		/* { dg-warning "constant too long" } */
-char16_t	c2 = u'\U00064321';	/* { dg-warning "constant too long" } */
+char16_t	c1 = u'ab';		/* { dg-warning "multi-character literal cannot have an encoding prefix" } */
+char16_t	c2 = u'\U00064321';	/* { dg-warning "character not encodable in a single code unit" } */
 
 char16_t	c3 = 'a';
 char16_t	c4 = U'a';
@@ -16,6 +16,6 @@ char16_t	c6 = U'\U00064321';	/* { dg-warning "conversion from .(long )?unsigned
 char16_t	c7 = L'a';
 char16_t	c8 = L'\u2029';
 char16_t 	c9 = L'\U00064321';	/* { dg-warning "conversion" "" { target { 4byte_wchar_t } } } */
-					/* { dg-warning "constant too long" "" { target { ! 4byte_wchar_t } } .-1 } */
+					/* { dg-warning "character not encodable in a single code unit" "" { target { ! 4byte_wchar_t } } .-1 } */
 
 int main () {}
diff --git a/gcc/testsuite/gcc.dg/utf32-4.c b/gcc/testsuite/gcc.dg/utf32-4.c
index aa7f66a..72086bc 100644
--- a/gcc/testsuite/gcc.dg/utf32-4.c
+++ b/gcc/testsuite/gcc.dg/utf32-4.c
@@ -6,15 +6,15 @@
 typedef __CHAR32_TYPE__ char32_t;
 
 char32_t	c0 = U'';		/* { dg-error "empty character" } */
-char32_t	c1 = U'ab';		/* { dg-warning "constant too long" } */
+char32_t	c1 = U'ab';		/* { dg-warning "multi-character literal cannot have an encoding prefix" } */
 char32_t	c2 = U'\U00064321';
 
 char32_t	c3 = 'a';
 char32_t	c4 = u'a';
 char32_t	c5 = u'\u2029';
-char32_t	c6 = u'\U00064321';	/* { dg-warning "constant too long" } */
+char32_t	c6 = u'\U00064321';	/* { dg-warning "character not encodable in a single code unit" } */
 char32_t	c7 = L'a';
 char32_t	c8 = L'\u2029';
-char32_t	c9 = L'\U00064321';     /* { dg-warning "constant too long" "" { target { ! 4byte_wchar_t } } } */
+char32_t	c9 = L'\U00064321';     /* { dg-warning "character not encodable in a single code unit" "" { target { ! 4byte_wchar_t } } } */
 
 int main () {}
diff --git a/gcc/testsuite/gcc.target/aarch64/pr112406.c b/gcc/testsuite/gcc.target/aarch64/pr112406.c
new file mode 100644
index 0000000..46459c6
--- /dev/null
+++ b/gcc/testsuite/gcc.target/aarch64/pr112406.c
@@ -0,0 +1,37 @@
+/* { dg-do compile { target { aarch64*-*-* } } } */
+/* { dg-options "-march=armv8-a+sve -w -Ofast" } */
+
+typedef struct {
+  int red
+} MagickPixelPacket;
+
+GetImageChannelMoments_image, GetImageChannelMoments_image_0,
+    GetImageChannelMoments___trans_tmp_1, GetImageChannelMoments_M11_0,
+    GetImageChannelMoments_pixel_3, GetImageChannelMoments_y,
+    GetImageChannelMoments_p;
+
+double GetImageChannelMoments_M00_0, GetImageChannelMoments_M00_1,
+    GetImageChannelMoments_M01_1;
+
+MagickPixelPacket GetImageChannelMoments_pixel;
+
+SetMagickPixelPacket(int color, MagickPixelPacket *pixel) {
+  pixel->red = color;
+}
+
+GetImageChannelMoments() {
+  for (; GetImageChannelMoments_y; GetImageChannelMoments_y++) {
+    SetMagickPixelPacket(GetImageChannelMoments_p,
+                         &GetImageChannelMoments_pixel);
+    GetImageChannelMoments_M00_1 += GetImageChannelMoments_pixel.red;
+    if (GetImageChannelMoments_image)
+      GetImageChannelMoments_M00_1++;
+    GetImageChannelMoments_M01_1 +=
+        GetImageChannelMoments_y * GetImageChannelMoments_pixel_3;
+    if (GetImageChannelMoments_image_0)
+      GetImageChannelMoments_M00_0++;
+    GetImageChannelMoments_M01_1 +=
+        GetImageChannelMoments_y * GetImageChannelMoments_p++;
+  }
+  GetImageChannelMoments___trans_tmp_1 = atan(GetImageChannelMoments_M11_0);
+}
diff --git a/gcc/testsuite/gcc.target/arm/acle/data-intrinsics-armv6.c b/gcc/testsuite/gcc.target/arm/acle/data-intrinsics-armv6.c
index 6dc8c55..c231fa4 100644
--- a/gcc/testsuite/gcc.target/arm/acle/data-intrinsics-armv6.c
+++ b/gcc/testsuite/gcc.target/arm/acle/data-intrinsics-armv6.c
@@ -1,5 +1,5 @@
 /* { dg-do run } */
-/* { dg-require-effective-target arm_arch_v6t2_hw_ok } */
+/* { dg-require-effective-target arm_arch_v6t2_hw } */
 /* { dg-add-options arm_arch_v6t2 } */
 
 #include "arm_acle.h"
diff --git a/gcc/testsuite/gcc.target/arm/acle/data-intrinsics-rbit.c b/gcc/testsuite/gcc.target/arm/acle/data-intrinsics-rbit.c
index b01c421..ac358bc 100644
--- a/gcc/testsuite/gcc.target/arm/acle/data-intrinsics-rbit.c
+++ b/gcc/testsuite/gcc.target/arm/acle/data-intrinsics-rbit.c
@@ -1,6 +1,6 @@
 /* Test the ACLE data intrinsics existence for specific instruction.  */
 /* { dg-do run } */
-/* { dg-require-effective-target arm_arch_v6t2_hw_ok } */
+/* { dg-require-effective-target arm_arch_v6t2_hw } */
 /* { dg-additional-options "--save-temps -O1" } */
 /* { dg-add-options arm_arch_v6t2 } */
 /* { dg-final { check-function-bodies "**" "" "" } } */
diff --git a/gcc/testsuite/gcc.target/arm/mve/pr112337.c b/gcc/testsuite/gcc.target/arm/mve/pr112337.c
new file mode 100644
index 0000000..8f49199
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/mve/pr112337.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+/* { dg-require-effective-target arm_v8_1m_mve_ok } */
+/* { dg-add-options arm_v8_1m_mve } */
+#include <arm_mve.h>
+
+void g(int32x4_t);
+void f(int, int, int, short, int *p) {
+  int *bias = p;
+  for (;;) {
+    int32x4_t d = vldrwq_s32 (p);
+    bias += 4;
+    g(d);
+  }
+}
diff --git a/gcc/testsuite/gcc.target/avr/pr53372-1.c b/gcc/testsuite/gcc.target/avr/pr53372-1.c
new file mode 100644
index 0000000..7d3f193
--- /dev/null
+++ b/gcc/testsuite/gcc.target/avr/pr53372-1.c
@@ -0,0 +1,10 @@
+/* { dg-do compile { target { ! avr_tiny } } } */
+/* { dg-options "-std=gnu99" } */
+
+__attribute__((__section__("fffsection")))
+const __flash char fff = 123;
+
+const __flash char ppp = 124;
+
+/* { dg-final { scan-assembler ".section	fffsection,\"a\",@progbits" } } */
+/* { dg-final { scan-assembler ".section	.progmem.data,\"a\",@progbits" } } */
diff --git a/gcc/testsuite/gcc.target/avr/pr53372-2.c b/gcc/testsuite/gcc.target/avr/pr53372-2.c
new file mode 100644
index 0000000..79ef2b7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/avr/pr53372-2.c
@@ -0,0 +1,10 @@
+/* { dg-do compile { target { ! avr_tiny } } } */
+/* { dg-options "-std=gnu99 -fdata-sections" } */
+
+__attribute__((__section__("fffsection")))
+const __flash char fff = 123;
+
+const __flash char ppp = 124;
+
+/* { dg-final { scan-assembler ".section	fffsection,\"a\",@progbits" } } */
+/* { dg-final { scan-assembler ".section	.progmem.data.ppp,\"a\",@progbits" } } */
diff --git a/gcc/testsuite/gcc.target/gcn/avgpr-mem-double.c b/gcc/testsuite/gcc.target/gcn/avgpr-mem-double.c
new file mode 100644
index 0000000..ce089fb
--- /dev/null
+++ b/gcc/testsuite/gcc.target/gcn/avgpr-mem-double.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=gfx90a -O1" } */
+/* { dg-skip-if "incompatible ISA" { *-*-* } { "-march=gfx90[068]" } } */
+/* { dg-final { scan-assembler {load[^\n]*a[0-9[]} } } */
+/* { dg-final { scan-assembler {store[^\n]*a[0-9[]} } } */
+
+#define TYPE double
+
+#include "avgpr-mem-int.c"
diff --git a/gcc/testsuite/gcc.target/gcn/avgpr-mem-int.c b/gcc/testsuite/gcc.target/gcn/avgpr-mem-int.c
new file mode 100644
index 0000000..03d8148
--- /dev/null
+++ b/gcc/testsuite/gcc.target/gcn/avgpr-mem-int.c
@@ -0,0 +1,116 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=gfx90a -O1" } */
+/* { dg-skip-if "incompatible ISA" { *-*-* } { "-march=gfx90[068]" } } */
+/* { dg-final { scan-assembler {load[^\n]*a[0-9[]} } } */
+/* { dg-final { scan-assembler {store[^\n]*a[0-9[]} } } */
+
+#ifndef TYPE
+#define TYPE int
+#endif
+
+TYPE a[50];
+
+int f()
+{
+  __asm__ volatile ("; fake -> %0" :: "va"(a[0]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[1]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[2]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[3]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[4]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[5]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[6]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[7]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[8]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[9]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[10]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[11]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[12]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[13]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[14]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[15]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[16]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[17]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[18]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[19]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[20]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[21]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[22]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[23]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[24]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[25]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[26]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[27]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[28]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[29]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[30]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[31]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[32]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[33]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[34]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[35]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[36]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[37]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[38]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[39]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[40]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[41]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[42]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[43]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[44]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[45]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[46]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[47]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[48]));
+  __asm__ volatile ("; fake -> %0" :: "va"(a[49]));
+
+  __asm__ volatile ("; fake <- %0" : "+va"(a[0]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[1]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[2]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[3]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[4]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[5]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[6]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[7]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[8]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[9]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[10]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[11]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[12]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[13]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[14]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[15]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[16]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[17]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[18]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[19]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[20]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[21]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[22]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[23]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[24]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[25]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[26]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[27]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[28]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[29]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[30]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[31]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[32]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[33]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[34]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[35]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[36]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[37]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[38]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[39]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[40]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[41]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[42]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[43]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[44]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[45]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[46]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[47]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[48]));
+  __asm__ volatile ("; fake <- %0" : "+va"(a[49]));
+}
diff --git a/gcc/testsuite/gcc.target/gcn/avgpr-mem-long.c b/gcc/testsuite/gcc.target/gcn/avgpr-mem-long.c
new file mode 100644
index 0000000..dcfb483
--- /dev/null
+++ b/gcc/testsuite/gcc.target/gcn/avgpr-mem-long.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=gfx90a -O1" } */
+/* { dg-skip-if "incompatible ISA" { *-*-* } { "-march=gfx90[068]" } } */
+/* { dg-final { scan-assembler {load[^\n]*a[0-9[]} } } */
+/* { dg-final { scan-assembler {store[^\n]*a[0-9[]} } } */
+
+#define TYPE long
+
+#include "avgpr-mem-int.c"
diff --git a/gcc/testsuite/gcc.target/gcn/avgpr-mem-short.c b/gcc/testsuite/gcc.target/gcn/avgpr-mem-short.c
new file mode 100644
index 0000000..91cc14e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/gcn/avgpr-mem-short.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=gfx90a -O1" } */
+/* { dg-skip-if "incompatible ISA" { *-*-* } { "-march=gfx90[068]" } } */
+/* { dg-final { scan-assembler {load[^\n]*a[0-9[]} } } */
+/* { dg-final { scan-assembler {store[^\n]*a[0-9[]} } } */
+
+#define TYPE short
+
+#include "avgpr-mem-int.c"
diff --git a/gcc/testsuite/gcc.target/gcn/avgpr-spill-double.c b/gcc/testsuite/gcc.target/gcn/avgpr-spill-double.c
new file mode 100644
index 0000000..3e9996d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/gcn/avgpr-spill-double.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=gfx908 -O1" } */
+/* { dg-skip-if "incompatible ISA" { *-*-* } { "-march=gfx90[06]" } } */
+/* { dg-final { scan-assembler "accvgpr" } } */
+
+#define TYPE double
+
+#include "avgpr-spill-int.c"
diff --git a/gcc/testsuite/gcc.target/gcn/avgpr-spill-int.c b/gcc/testsuite/gcc.target/gcn/avgpr-spill-int.c
new file mode 100644
index 0000000..0b64c8e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/gcn/avgpr-spill-int.c
@@ -0,0 +1,115 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=gfx908 -O1" } */
+/* { dg-skip-if "incompatible ISA" { *-*-* } { "-march=gfx90[06]" } } */
+/* { dg-final { scan-assembler "accvgpr" } } */
+
+#ifndef TYPE
+#define TYPE int
+#endif
+
+TYPE a[50];
+
+int f()
+{
+  __asm__ volatile ("; fake <- %0" : "=v"(a[0]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[1]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[2]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[3]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[4]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[5]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[6]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[7]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[8]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[9]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[10]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[11]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[12]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[13]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[14]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[15]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[16]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[17]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[18]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[19]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[20]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[21]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[22]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[23]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[24]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[25]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[26]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[27]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[28]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[29]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[30]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[31]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[32]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[33]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[34]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[35]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[36]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[37]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[38]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[39]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[40]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[41]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[42]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[43]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[44]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[45]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[46]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[47]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[48]));
+  __asm__ volatile ("; fake <- %0" : "=v"(a[49]));
+
+  __asm__ volatile ("; fake -> %0" :: "v"(a[0]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[1]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[2]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[3]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[4]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[5]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[6]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[7]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[8]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[9]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[10]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[11]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[12]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[13]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[14]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[15]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[16]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[17]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[18]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[19]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[20]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[21]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[22]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[23]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[24]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[25]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[26]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[27]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[28]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[29]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[30]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[31]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[32]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[33]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[34]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[35]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[36]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[37]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[38]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[39]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[40]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[41]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[42]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[43]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[44]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[45]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[46]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[47]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[48]));
+  __asm__ volatile ("; fake -> %0" :: "v"(a[49]));
+}
diff --git a/gcc/testsuite/gcc.target/gcn/avgpr-spill-long.c b/gcc/testsuite/gcc.target/gcn/avgpr-spill-long.c
new file mode 100644
index 0000000..516890d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/gcn/avgpr-spill-long.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=gfx908 -O1" } */
+/* { dg-skip-if "incompatible ISA" { *-*-* } { "-march=gfx90[06]" } } */
+/* { dg-final { scan-assembler "accvgpr" } } */
+
+#define TYPE long
+
+#include "avgpr-spill-int.c"
diff --git a/gcc/testsuite/gcc.target/gcn/avgpr-spill-short.c b/gcc/testsuite/gcc.target/gcn/avgpr-spill-short.c
new file mode 100644
index 0000000..1e55684
--- /dev/null
+++ b/gcc/testsuite/gcc.target/gcn/avgpr-spill-short.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=gfx908 -O1" } */
+/* { dg-skip-if "incompatible ISA" { *-*-* } { "-march=gfx90[06]" } } */
+/* { dg-final { scan-assembler "accvgpr" } } */
+
+#define TYPE short
+
+#include "avgpr-spill-int.c"
diff --git a/gcc/testsuite/gcc.target/i386/apx-spill_to_egprs-1.c b/gcc/testsuite/gcc.target/i386/apx-spill_to_egprs-1.c
index 290863d..d7952b4 100644
--- a/gcc/testsuite/gcc.target/i386/apx-spill_to_egprs-1.c
+++ b/gcc/testsuite/gcc.target/i386/apx-spill_to_egprs-1.c
@@ -3,22 +3,9 @@
 
 #include "spill_to_mask-1.c"
 
-/* { dg-final { scan-assembler "movl\[ \t]+\[^\\n\\r\]*, %r16d" } } */
-/* { dg-final { scan-assembler "movl\[ \t]+\[^\\n\\r\]*, %r17d" } } */
-/* { dg-final { scan-assembler "movl\[ \t]+\[^\\n\\r\]*, %r18d" } } */
-/* { dg-final { scan-assembler "movq\[ \t]+\[^\\n\\r\]*, %r19" } } */
-/* { dg-final { scan-assembler "movl\[ \t]+\[^\\n\\r\]*, %r20d" } } */
-/* { dg-final { scan-assembler "movl\[ \t]+\[^\\n\\r\]*, %r21d" } } */
-/* { dg-final { scan-assembler "movl\[ \t]+\[^\\n\\r\]*, %r22d" } } */
-/* { dg-final { scan-assembler "movl\[ \t]+\[^\\n\\r\]*, %r23d" } } */
-/* { dg-final { scan-assembler "movl\[ \t]+\[^\\n\\r\]*, %r24d" } } */
-/* { dg-final { scan-assembler "addl\[ \t]+\[^\\n\\r\]*, %r25d" } } */
-/* { dg-final { scan-assembler "movl\[ \t]+\[^\\n\\r\]*, %r26d" } } */
-/* { dg-final { scan-assembler "movl\[ \t]+\[^\\n\\r\]*, %r27d" } } */
-/* { dg-final { scan-assembler "movbel\[ \t]+\[^\\n\\r\]*, %r28d" } } */
-/* { dg-final { scan-assembler "movbel\[ \t]+\[^\\n\\r\]*, %r29d" } } */
-/* { dg-final { scan-assembler "movbel\[ \t]+\[^\\n\\r\]*, %r30d" } } */
-/* { dg-final { scan-assembler "movbel\[ \t]+\[^\\n\\r\]*, %r31d" } } */
+/* Make sure that no local variables are stored on the stack. */
+/* { dg-final { scan-assembler-not "\\(%rsp\\)" } } */
+
 /* { dg-final { scan-assembler-not "knot" } } */
 /* { dg-final { scan-assembler-not "kxor" } } */
 /* { dg-final { scan-assembler-not "kor" } } */
diff --git a/gcc/testsuite/gcc.target/i386/avx512vl-pr112435-1.c b/gcc/testsuite/gcc.target/i386/avx512vl-pr112435-1.c
new file mode 100644
index 0000000..46aae28
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512vl-pr112435-1.c
@@ -0,0 +1,13 @@
+/* PR target/112435 */
+/* { dg-do assemble { target { avx512vl && { ! ia32 } } } } */
+/* { dg-options "-mavx512vl -O2" } */
+
+#include <x86intrin.h>
+
+__m256i
+foo (__m256i a, __m256i b)
+{
+  register __m256i c __asm__("ymm16") = a;
+  asm ("" : "+v" (c));
+  return _mm256_shuffle_i32x4 (c, b, 2);
+}
diff --git a/gcc/testsuite/gcc.target/i386/avx512vl-pr112435-2.c b/gcc/testsuite/gcc.target/i386/avx512vl-pr112435-2.c
new file mode 100644
index 0000000..a856fb5
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512vl-pr112435-2.c
@@ -0,0 +1,63 @@
+/* PR target/112435 */
+/* { dg-do assemble { target { avx512vl && { ! ia32 } } } } */
+/* { dg-options "-mavx512vl -O2" } */
+
+#include <x86intrin.h>
+
+/* vpermi128/vpermf128 */
+__m256i
+perm0 (__m256i a, __m256i b)
+{
+  register __m256i c __asm__("ymm17") = a;
+  asm ("":"+v" (c));
+  return _mm256_permute2x128_si256 (c, b, 50);
+}
+
+__m256i
+perm1 (__m256i a, __m256i b)
+{
+  register __m256i c __asm__("ymm17") = a;
+  asm ("":"+v" (c));
+  return _mm256_permute2x128_si256 (c, b, 18);
+}
+
+__m256i
+perm2 (__m256i a, __m256i b)
+{
+  register __m256i c __asm__("ymm17") = a;
+  asm ("":"+v" (c));
+  return _mm256_permute2x128_si256 (c, b, 48);
+}
+
+/* vshuf{i,f}{32x4,64x2} ymm .*/
+__m256i
+shuff0 (__m256i a, __m256i b)
+{
+  register __m256i c __asm__("ymm17") = a;
+  asm ("":"+v" (c));
+  return _mm256_shuffle_i32x4 (c, b, 2);
+}
+
+__m256
+shuff1 (__m256 a, __m256 b)
+{
+  register __m256 c __asm__("ymm17") = a;
+  asm ("":"+v" (c));
+  return _mm256_shuffle_f32x4 (c, b, 2);
+}
+
+__m256i
+shuff2 (__m256i a, __m256i b)
+{
+  register __m256i c __asm__("ymm17") = a;
+  asm ("":"+v" (c));
+  return _mm256_shuffle_i64x2 (c, b, 2);
+}
+
+__m256d
+shuff3 (__m256d a, __m256d b)
+{
+  register __m256d c __asm__("ymm17") = a;
+  asm ("":"+v" (c));
+  return _mm256_shuffle_f64x2 (c, b, 2);
+}
diff --git a/gcc/testsuite/gcc.target/i386/avx512vl-pr112435-3.c b/gcc/testsuite/gcc.target/i386/avx512vl-pr112435-3.c
new file mode 100644
index 0000000..f7538ff
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512vl-pr112435-3.c
@@ -0,0 +1,78 @@
+/* PR target/112435 */
+/* { dg-do assemble { target { avx512vl && { ! ia32 } } } } */
+/* { dg-options "-mavx512vl -O2" } */
+
+#include <x86intrin.h>
+
+/* vpermf128 */
+__m256
+perm0 (__m256 a, __m256 b)
+{
+  register __m256 c __asm__("ymm17") =a;
+  asm ("":"+v" (c));
+  return _mm256_permute2f128_ps (c, b, 50);
+}
+
+__m256
+perm1 (__m256 a, __m256 b)
+{
+  register __m256 c __asm__("ymm17") =a;
+  asm ("":"+v" (c));
+  return _mm256_permute2f128_ps (c, b, 18);
+}
+
+__m256
+perm2 (__m256 a, __m256 b)
+{
+  register __m256 c __asm__("ymm17") =a;
+  asm ("":"+v" (c));
+  return _mm256_permute2f128_ps (c, b, 48);
+}
+
+__m256i
+perm3 (__m256i a, __m256i b)
+{
+  register __m256i c __asm__("ymm17") =a;
+  asm ("":"+v" (c));
+  return _mm256_permute2f128_si256 (c, b, 50);
+}
+
+__m256i
+perm4 (__m256i a, __m256i b)
+{
+  register __m256i c __asm__("ymm17") =a;
+  asm ("":"+v" (c));
+  return _mm256_permute2f128_si256 (c, b, 18);
+}
+
+__m256i
+perm5 (__m256i a, __m256i b)
+{
+  register __m256i c __asm__("ymm17") =a;
+  asm ("":"+v" (c));
+  return _mm256_permute2f128_si256 (c, b, 48);
+}
+
+__m256d
+perm6 (__m256d a, __m256d b)
+{
+  register __m256d c __asm__("ymm17") =a;
+  asm ("":"+v" (c));
+  return _mm256_permute2f128_pd (c, b, 50);
+}
+
+__m256d
+perm7 (__m256d a, __m256d b)
+{
+  register __m256d c __asm__("ymm17") =a;
+  asm ("":"+v" (c));
+  return _mm256_permute2f128_pd (c, b, 18);
+}
+
+__m256d
+perm8 (__m256d a, __m256d b)
+{
+  register __m256d c __asm__("ymm17") =a;
+  asm ("":"+v" (c));
+  return _mm256_permute2f128_pd (c, b, 48);
+}
diff --git a/gcc/testsuite/gcc.target/i386/bmi2-pr112526.c b/gcc/testsuite/gcc.target/i386/bmi2-pr112526.c
new file mode 100644
index 0000000..7a3c6f1
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/bmi2-pr112526.c
@@ -0,0 +1,27 @@
+/* PR target/112526 */
+/* { dg-do run { target { bmi2 && int128 } } } */
+/* { dg-options "-O2 -mbmi2" } */
+
+#include "bmi2-check.h"
+
+__attribute__((noipa)) void
+foo (unsigned long x, unsigned __int128 *y, unsigned long z, unsigned long *w)
+{
+  register unsigned long a __asm ("%r10") = x + z;
+  register unsigned __int128 b __asm ("%r8") = ((unsigned __int128) a) * 257342423UL;
+  asm volatile ("" : "+r" (b));
+  asm volatile ("" : "+d" (a));
+  *y = b;
+  *w = a;
+}
+
+static void
+bmi2_test ()
+{
+  unsigned __int128 y;
+  unsigned long w;
+  foo (10268318293806702989UL, &y, 4702524958196331333UL, &w);
+  if (y != ((((unsigned __int128) 0xc72d2c9UL) << 64) | 0x9586adfdc95b225eUL)
+      || w != 14970843252003034322UL)
+    abort ();
+}
diff --git a/gcc/testsuite/gcc.target/i386/pr105735-3.c b/gcc/testsuite/gcc.target/i386/pr105735-3.c
new file mode 100644
index 0000000..9e268a1
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr105735-3.c
@@ -0,0 +1,87 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-sccp-details" } */
+/* { dg-final { scan-tree-dump-times {final value replacement} 8 "sccp" } } */
+
+unsigned int
+__attribute__((noipa))
+foo (unsigned int tmp)
+{
+  for (int bit = 0; bit < 64; bit++)
+    tmp &= 11304;
+  return tmp;
+}
+
+unsigned int
+__attribute__((noipa))
+foo1 (unsigned int tmp)
+{
+  for (int bit = 63; bit >= 0; bit -=3)
+    tmp &= 11304;
+  return tmp;
+}
+
+unsigned int
+__attribute__((noipa))
+foo2 (unsigned int tmp)
+{
+  for (int bit = 0; bit < 64; bit++)
+    tmp |= 11304;
+  return tmp;
+}
+
+unsigned int
+__attribute__((noipa))
+foo3 (unsigned int tmp)
+{
+  for (int bit = 63; bit >= 0; bit -=3)
+    tmp |= 11304;
+  return tmp;
+}
+
+unsigned int
+__attribute__((noipa))
+foo4 (unsigned int tmp)
+{
+  for (int bit = 0; bit < 64; bit++)
+    tmp ^= 11304;
+  return tmp;
+}
+
+unsigned int
+__attribute__((noipa))
+foo5 (unsigned int tmp)
+{
+  for (int bit = 0; bit < 63; bit++)
+    tmp ^= 11304;
+  return tmp;
+}
+
+unsigned int
+__attribute__((noipa))
+f (unsigned int tmp, int bit)
+{
+  unsigned int res = tmp;
+  for (int i = 0; i < bit; i++)
+    res &= 11304;
+  return res;
+}
+
+unsigned int
+__attribute__((noipa))
+f1 (unsigned int tmp, int bit)
+{
+  unsigned int res = tmp;
+  for (int i = 0; i < bit; i++)
+    res |= 11304;
+  return res;
+}
+
+unsigned int
+__attribute__((noipa))
+f2 (unsigned int tmp, int bit)
+{
+  unsigned int res = tmp;
+  for (int i = 0; i < bit; i++)
+    res ^= 11304;
+  return res;
+}
diff --git a/gcc/testsuite/gcc.target/i386/pr112496.c b/gcc/testsuite/gcc.target/i386/pr112496.c
new file mode 100644
index 0000000..c478fda
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr112496.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+struct T { int x : 24; } v;
+void f1(int x) {
+  while (v.x - ((v.x <<= 1) - v.x)) ;
+}
diff --git a/gcc/testsuite/gcc.target/i386/pr112532.c b/gcc/testsuite/gcc.target/i386/pr112532.c
new file mode 100644
index 0000000..690f1d9
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr112532.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-msse4 -O2" } */
+
+typedef char __attribute__((__vector_size__(2))) v16u8;
+typedef int __attribute__((__vector_size__(8))) v64u8;
+typedef unsigned short __attribute__((__vector_size__(2))) v16u16;
+typedef unsigned short __attribute__((__vector_size__(8))) v64u16;
+v64u16 foo0_v64u16_0;
+int __attribute__((__vector_size__(4 * sizeof(int)))) foo0_v128u32_0;
+__attribute__((__vector_size__(8 * sizeof(short)))) unsigned short foo0_v128u16_0;
+v16u16 foo0_v16u16_0;
+v16u8 foo0() {
+  v16u16 v16u16_1 = __builtin_shufflevector(__builtin_shufflevector(__builtin_convertvector(foo0_v128u32_0, v64u16),foo0_v16u16_0, 1, 4, 2, 0, 0, 2, 2, 2),foo0_v16u16_0, 7);
+  foo0_v64u16_0 -= (short)v16u16_1;
+  v64u16 v64u16_3 = __builtin_shufflevector(v16u16_1, __builtin_shufflevector((v16u16){}, foo0_v128u16_0, 7, 0), 0, 1, 2, 2);
+  return (union {v16u8 b;})
+    {((union {
+      v64u8 a;
+      int b;
+    })(v64u8)v64u16_3).b}.b + (v16u8)v16u16_1;
+}
diff --git a/gcc/testsuite/gcc.target/i386/pr78057.c b/gcc/testsuite/gcc.target/i386/pr78057.c
index 493a533..b1f7a24 100644
--- a/gcc/testsuite/gcc.target/i386/pr78057.c
+++ b/gcc/testsuite/gcc.target/i386/pr78057.c
@@ -5,7 +5,7 @@
 extern void link_error (void);
 
 int
-foo (int x)
+foo (int x, long long y)
 {
   if (__builtin_ia32_tzcnt_u16 (16) != 4
       || __builtin_ia32_tzcnt_u16 (0) != 16
@@ -24,13 +24,14 @@ foo (int x)
      )
     link_error ();
   x += 2;
-  if (x == 0)
+  y += 2;
+  if (x == 0 || y == 0)
     return 5;
   return __builtin_ia32_tzcnt_u32 (x)
          + __builtin_ia32_lzcnt_u32 (x)
 #ifdef __x86_64__
-	 + __builtin_ia32_tzcnt_u64 (x)
-	 + __builtin_ia32_lzcnt_u64 (x)
+	 + __builtin_ia32_tzcnt_u64 (y)
+	 + __builtin_ia32_lzcnt_u64 (y)
 #endif
 	 ;
 }
diff --git a/gcc/testsuite/gcc.target/i386/pr78904-10.c b/gcc/testsuite/gcc.target/i386/pr78904-10.c
new file mode 100644
index 0000000..0796291
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr78904-10.c
@@ -0,0 +1,47 @@
+/* PR target/78904 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -masm=att" } */
+/* { dg-additional-options "-mregparm=3" { target ia32 } } */
+/* { dg-final { scan-assembler-not "shr" } } */
+
+struct S1
+{
+  unsigned char pad1;
+  unsigned char val;
+  unsigned short pad2;
+};
+
+char test_and (struct S1 a, struct S1 b)
+{
+  return a.val & b.val;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]andb" } } */
+
+char test_or (struct S1 a, struct S1 b)
+{
+  return a.val | b.val;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]orb" } } */
+
+char test_xor (struct S1 a, struct S1 b)
+{
+  return a.val ^ b.val;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]xorb" } } */
+
+char test_add (struct S1 a, struct S1 b)
+{
+  return a.val + b.val;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]addb" } } */
+
+char test_sub (struct S1 a, struct S1 b)
+{
+  return a.val - b.val;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]subb" } } */
diff --git a/gcc/testsuite/gcc.target/i386/pr78904-10a.c b/gcc/testsuite/gcc.target/i386/pr78904-10a.c
new file mode 100644
index 0000000..1014028
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr78904-10a.c
@@ -0,0 +1,46 @@
+/* PR target/78904 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -masm=att" } */
+/* { dg-additional-options "-mregparm=3" { target ia32 } } */
+/* { dg-final { scan-assembler-not "shr" } } */
+
+struct S1
+{
+  unsigned char pad1;
+  unsigned char val;
+};
+
+char test_and (struct S1 a, struct S1 b)
+{
+  return a.val & b.val;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]andb" } } */
+
+char test_or (struct S1 a, struct S1 b)
+{
+  return a.val | b.val;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]orb" } } */
+
+char test_xor (struct S1 a, struct S1 b)
+{
+  return a.val ^ b.val;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]xorb" } } */
+
+char test_add (struct S1 a, struct S1 b)
+{
+  return a.val + b.val;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]addb" } } */
+
+char test_sub (struct S1 a, struct S1 b)
+{
+  return a.val - b.val;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]subb" } } */
diff --git a/gcc/testsuite/gcc.target/i386/pr78904-10b.c b/gcc/testsuite/gcc.target/i386/pr78904-10b.c
new file mode 100644
index 0000000..376acf8
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr78904-10b.c
@@ -0,0 +1,47 @@
+/* PR target/78904 */
+/* { dg-do compile { target { ! ia32 } } } */
+/* { dg-options "-O2 -masm=att" } */
+/* { dg-final { scan-assembler-not "shr" } } */
+
+struct S1
+{
+  unsigned char pad1;
+  unsigned char val;
+  unsigned short pad2;
+  unsigned int pad3;
+};
+
+char test_and (struct S1 a, struct S1 b)
+{
+  return a.val & b.val;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]andb" } } */
+
+char test_or (struct S1 a, struct S1 b)
+{
+  return a.val | b.val;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]orb" } } */
+
+char test_xor (struct S1 a, struct S1 b)
+{
+  return a.val ^ b.val;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]xorb" } } */
+
+char test_add (struct S1 a, struct S1 b)
+{
+  return a.val + b.val;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]addb" } } */
+
+char test_sub (struct S1 a, struct S1 b)
+{
+  return a.val - b.val;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]subb" } } */
diff --git a/gcc/testsuite/gcc.target/i386/pr78904-7.c b/gcc/testsuite/gcc.target/i386/pr78904-7.c
new file mode 100644
index 0000000..e52a269
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr78904-7.c
@@ -0,0 +1,64 @@
+/* PR target/78904 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -masm=att" } */
+/* { dg-final { scan-assembler-not "movzbl" } } */
+/* { dg-final { scan-assembler-not "movb" } } */
+
+struct S1
+{
+  unsigned char val;
+  unsigned char pad1;
+  unsigned short pad2;
+};
+
+struct S2
+{
+  unsigned char pad1;
+  unsigned char val;
+  unsigned short pad2;
+};
+
+struct S1 test_and (struct S1 a, struct S2 b)
+{
+  a.val &= b.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]andb" } } */
+
+struct S1 test_or (struct S1 a, struct S2 b)
+{
+  a.val |= b.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]orb" } } */
+
+struct S1 test_xor (struct S1 a, struct S2 b)
+{
+  a.val ^= b.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]xorb" } } */
+
+struct S1 test_add (struct S1 a, struct S2 b)
+{
+  a.val += b.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]addb" } } */
+
+struct S1 test_sub (struct S1 a, struct S2 b)
+{
+  a.val -= b.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]subb" } } */
diff --git a/gcc/testsuite/gcc.target/i386/pr78904-7a.c b/gcc/testsuite/gcc.target/i386/pr78904-7a.c
new file mode 100644
index 0000000..c060a48
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr78904-7a.c
@@ -0,0 +1,62 @@
+/* PR target/78904 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -masm=att" } */
+/* { dg-final { scan-assembler-not "movzbl" } } */
+/* { dg-final { scan-assembler-not "movb" } } */
+
+struct S1
+{
+  unsigned char val;
+  unsigned char pad1;
+};
+
+struct S2
+{
+  unsigned char pad1;
+  unsigned char val;
+};
+
+struct S1 test_and (struct S1 a, struct S2 b)
+{
+  a.val &= b.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]andb" } } */
+
+struct S1 test_or (struct S1 a, struct S2 b)
+{
+  a.val |= b.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]orb" } } */
+
+struct S1 test_xor (struct S1 a, struct S2 b)
+{
+  a.val ^= b.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]xorb" } } */
+
+struct S1 test_add (struct S1 a, struct S2 b)
+{
+  a.val += b.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]addb" } } */
+
+struct S1 test_sub (struct S1 a, struct S2 b)
+{
+  a.val -= b.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]subb" } } */
diff --git a/gcc/testsuite/gcc.target/i386/pr78904-7b.c b/gcc/testsuite/gcc.target/i386/pr78904-7b.c
new file mode 100644
index 0000000..76dc048
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr78904-7b.c
@@ -0,0 +1,66 @@
+/* PR target/78904 */
+/* { dg-do compile { target { ! ia32 } } } */
+/* { dg-options "-O2 -masm=att" } */
+/* { dg-final { scan-assembler-not "movzbl" } } */
+/* { dg-final { scan-assembler-not "movb" } } */
+
+struct S1
+{
+  unsigned char val;
+  unsigned char pad1;
+  unsigned short pad2;
+  unsigned int pad3;
+};
+
+struct S2
+{
+  unsigned char pad1;
+  unsigned char val;
+  unsigned short pad2;
+  unsigned int pad3;
+};
+
+struct S1 test_and (struct S1 a, struct S2 b)
+{
+  a.val &= b.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]andb" } } */
+
+struct S1 test_or (struct S1 a, struct S2 b)
+{
+  a.val |= b.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]orb" } } */
+
+struct S1 test_xor (struct S1 a, struct S2 b)
+{
+  a.val ^= b.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]xorb" } } */
+
+struct S1 test_add (struct S1 a, struct S2 b)
+{
+  a.val += b.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]addb" } } */
+
+struct S1 test_sub (struct S1 a, struct S2 b)
+{
+  a.val -= b.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]subb" } } */
diff --git a/gcc/testsuite/gcc.target/i386/pr78904-8.c b/gcc/testsuite/gcc.target/i386/pr78904-8.c
new file mode 100644
index 0000000..3ca1d42
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr78904-8.c
@@ -0,0 +1,25 @@
+/* PR target/78904 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -masm=att" } */
+/* { dg-final { scan-assembler-not "movzbl" } } */
+
+struct S1
+{
+  unsigned char val;
+  unsigned char pad1;
+  unsigned short pad2;
+};
+
+struct S2
+{
+  unsigned char pad1;
+  unsigned char val;
+  unsigned short pad2;
+};
+
+struct S1 test (struct S1 a, struct S2 b)
+{
+  a.val = b.val;
+
+  return a;
+}
diff --git a/gcc/testsuite/gcc.target/i386/pr78904-8a.c b/gcc/testsuite/gcc.target/i386/pr78904-8a.c
new file mode 100644
index 0000000..fe484a7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr78904-8a.c
@@ -0,0 +1,23 @@
+/* PR target/78904 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -masm=att" } */
+/* { dg-final { scan-assembler-not "movzbl" } } */
+
+struct S1
+{
+  unsigned char val;
+  unsigned char pad1;
+};
+
+struct S2
+{
+  unsigned char pad1;
+  unsigned char val;
+};
+
+struct S1 test (struct S1 a, struct S2 b)
+{
+  a.val = b.val;
+
+  return a;
+}
diff --git a/gcc/testsuite/gcc.target/i386/pr78904-8b.c b/gcc/testsuite/gcc.target/i386/pr78904-8b.c
new file mode 100644
index 0000000..cfed7c1
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr78904-8b.c
@@ -0,0 +1,27 @@
+/* PR target/78904 */
+/* { dg-do compile { target { ! ia32 } } } */
+/* { dg-options "-O2 -masm=att" } */
+/* { dg-final { scan-assembler-not "movzbl" } } */
+
+struct S1
+{
+  unsigned char val;
+  unsigned char pad1;
+  unsigned short pad2;
+  unsigned int pad3;
+};
+
+struct S2
+{
+  unsigned char pad1;
+  unsigned char val;
+  unsigned short pad2;
+  unsigned int pad3;
+};
+
+struct S1 test (struct S1 a, struct S2 b)
+{
+  a.val = b.val;
+
+  return a;
+}
diff --git a/gcc/testsuite/gcc.target/i386/pr78904-9.c b/gcc/testsuite/gcc.target/i386/pr78904-9.c
new file mode 100644
index 0000000..aa80be4
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr78904-9.c
@@ -0,0 +1,63 @@
+/* PR target/78904 */
+/* { dg-do compile { target { ! ia32 } } } */
+/* { dg-options "-O2 -masm=att" } */
+/* { dg-final { scan-assembler-not "movzbl" } } */
+
+struct S1
+{
+  unsigned char val;
+  unsigned char pad1;
+  unsigned short pad2;
+};
+
+struct S2
+{
+  unsigned char pad1;
+  unsigned char val;
+  unsigned short pad2;
+};
+
+struct S1 test_and (struct S1 a, struct S2 b, struct S2 c)
+{
+  a.val = b.val & c.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]andb" } } */
+
+struct S1 test_or (struct S1 a, struct S2 b, struct S2 c)
+{
+  a.val = b.val | c.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]orb" } } */
+
+struct S1 test_xor (struct S1 a, struct S2 b, struct S2 c)
+{
+  a.val = b.val ^ c.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]xorb" } } */
+
+struct S1 test_add (struct S1 a, struct S2 b, struct S2 c)
+{
+  a.val = b.val + c.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]addb" } } */
+
+struct S1 test_sub (struct S1 a, struct S2 b, struct S2 c)
+{
+  a.val = b.val - c.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]subb" } } */
diff --git a/gcc/testsuite/gcc.target/i386/pr78904-9a.c b/gcc/testsuite/gcc.target/i386/pr78904-9a.c
new file mode 100644
index 0000000..009ae24
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr78904-9a.c
@@ -0,0 +1,61 @@
+/* PR target/78904 */
+/* { dg-do compile { target { ! ia32 } } } */
+/* { dg-options "-O2 -masm=att" } */
+/* { dg-final { scan-assembler-not "movzbl" } } */
+
+struct S1
+{
+  unsigned char val;
+  unsigned char pad1;
+};
+
+struct S2
+{
+  unsigned char pad1;
+  unsigned char val;
+};
+
+struct S1 test_and (struct S1 a, struct S2 b, struct S2 c)
+{
+  a.val = b.val & c.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]andb" } } */
+
+struct S1 test_or (struct S1 a, struct S2 b, struct S2 c)
+{
+  a.val = b.val | c.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]orb" } } */
+
+struct S1 test_xor (struct S1 a, struct S2 b, struct S2 c)
+{
+  a.val = b.val ^ c.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]xorb" } } */
+
+struct S1 test_add (struct S1 a, struct S2 b, struct S2 c)
+{
+  a.val = b.val + c.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]addb" } } */
+
+struct S1 test_sub (struct S1 a, struct S2 b, struct S2 c)
+{
+  a.val = b.val - c.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]subb" } } */
diff --git a/gcc/testsuite/gcc.target/i386/pr78904-9b.c b/gcc/testsuite/gcc.target/i386/pr78904-9b.c
new file mode 100644
index 0000000..bf68f8b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr78904-9b.c
@@ -0,0 +1,65 @@
+/* PR target/78904 */
+/* { dg-do compile { target { ! ia32 } } } */
+/* { dg-options "-O2 -masm=att" } */
+/* { dg-final { scan-assembler-not "movzbl" } } */
+
+struct S1
+{
+  unsigned char val;
+  unsigned char pad1;
+  unsigned short pad2;
+  unsigned int pad3;
+};
+
+struct S2
+{
+  unsigned char pad1;
+  unsigned char val;
+  unsigned short pad2;
+  unsigned int pad3;
+};
+
+struct S1 test_and (struct S1 a, struct S2 b, struct S2 c)
+{
+  a.val = b.val & c.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]andb" } } */
+
+struct S1 test_or (struct S1 a, struct S2 b, struct S2 c)
+{
+  a.val = b.val | c.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]orb" } } */
+
+struct S1 test_xor (struct S1 a, struct S2 b, struct S2 c)
+{
+  a.val = b.val ^ c.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]xorb" } } */
+
+struct S1 test_add (struct S1 a, struct S2 b, struct S2 c)
+{
+  a.val = b.val + c.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]addb" } } */
+
+struct S1 test_sub (struct S1 a, struct S2 b, struct S2 c)
+{
+  a.val = b.val - c.val;
+
+  return a;
+}
+
+/* { dg-final { scan-assembler "\[ \t\]subb" } } */
diff --git a/gcc/testsuite/gcc.target/i386/pr95126-m32-3.c b/gcc/testsuite/gcc.target/i386/pr95126-m32-3.c
index cc2fe94..91608f8 100644
--- a/gcc/testsuite/gcc.target/i386/pr95126-m32-3.c
+++ b/gcc/testsuite/gcc.target/i386/pr95126-m32-3.c
@@ -1,5 +1,5 @@
 /* { dg-do compile { target { ia32 } } } */
-/* { dg-options "-O2" } */
+/* { dg-options "-O2 -mno-accumulate-outgoing-args" } */
 
 struct small{ short a; };
 
diff --git a/gcc/testsuite/gcc.target/i386/pr95126-m32-4.c b/gcc/testsuite/gcc.target/i386/pr95126-m32-4.c
index e829335..85b30f6 100644
--- a/gcc/testsuite/gcc.target/i386/pr95126-m32-4.c
+++ b/gcc/testsuite/gcc.target/i386/pr95126-m32-4.c
@@ -1,5 +1,5 @@
 /* { dg-do compile { target { ia32 } } } */
-/* { dg-options "-O2" } */
+/* { dg-options "-O2 -mno-accumulate-outgoing-args" } */
 
 struct small{ short a,b; };
 
diff --git a/gcc/testsuite/gcc.target/loongarch/cas-acquire.c b/gcc/testsuite/gcc.target/loongarch/cas-acquire.c
new file mode 100644
index 0000000..ff7ba86
--- /dev/null
+++ b/gcc/testsuite/gcc.target/loongarch/cas-acquire.c
@@ -0,0 +1,82 @@
+/* { dg-do run } */
+/* { dg-require-effective-target c99_runtime } */
+/* { dg-require-effective-target pthread } */
+/* { dg-options "-std=c99 -pthread" } */
+
+/* https://github.com/llvm/llvm-project/pull/67391#issuecomment-1752403934
+   reported that this had failed with GCC and 3A6000.  */
+
+#include <pthread.h>
+#include <stdatomic.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+static unsigned int tags[32];
+static unsigned int vals[32];
+
+static void *
+writer_entry (void *data)
+{
+  atomic_uint *pt = (atomic_uint *)tags;
+  atomic_uint *pv = (atomic_uint *)vals;
+
+  for (unsigned int n = 1; n < 10000; n++)
+    {
+      atomic_store_explicit (&pv[n & 31], n, memory_order_release);
+      atomic_store_explicit (&pt[n & 31], n, memory_order_release);
+    }
+
+  return NULL;
+}
+
+static void *
+reader_entry (void *data)
+{
+  atomic_uint *pt = (atomic_uint *)tags;
+  atomic_uint *pv = (atomic_uint *)vals;
+  int i;
+
+  for (;;)
+    {
+      for (i = 0; i < 32; i++)
+        {
+          unsigned int tag = 0;
+          bool res;
+
+          res = atomic_compare_exchange_weak_explicit (
+              &pt[i], &tag, 0, memory_order_acquire, memory_order_acquire);
+          if (!res)
+            {
+              unsigned int val;
+
+              val = atomic_load_explicit (&pv[i], memory_order_relaxed);
+              if (val < tag)
+                __builtin_trap ();
+            }
+        }
+    }
+
+  return NULL;
+}
+
+int
+main (int argc, char *argv[])
+{
+  pthread_t writer;
+  pthread_t reader;
+  int res;
+
+  res = pthread_create (&writer, NULL, writer_entry, NULL);
+  if (res < 0)
+    __builtin_trap ();
+
+  res = pthread_create (&reader, NULL, reader_entry, NULL);
+  if (res < 0)
+    __builtin_trap ();
+
+  res = pthread_join (writer, NULL);
+  if (res < 0)
+    __builtin_trap ();
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.target/loongarch/div-div32.c b/gcc/testsuite/gcc.target/loongarch/div-div32.c
new file mode 100644
index 0000000..8b1f686
--- /dev/null
+++ b/gcc/testsuite/gcc.target/loongarch/div-div32.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -march=loongarch64 -mabi=lp64d -mdiv32" } */
+/* { dg-final { scan-assembler "div\.w" } } */
+/* { dg-final { scan-assembler "div\.wu" } } */
+/* { dg-final { scan-assembler "mod\.w" } } */
+/* { dg-final { scan-assembler "mod\.wu" } } */
+/* { dg-final { scan-assembler-not "slli\.w.*,0" } } */
+
+int
+divw (long a, long b)
+{
+  return (int)a / (int)b;
+}
+
+unsigned int
+divwu (long a, long b)
+{
+  return (unsigned int)a / (unsigned int)b;
+}
+
+int
+modw (long a, long b)
+{
+  return (int)a % (int)b;
+}
+
+unsigned int
+modwu (long a, long b)
+{
+  return (unsigned int)a % (unsigned int)b;
+}
diff --git a/gcc/testsuite/gcc.target/loongarch/div-no-div32.c b/gcc/testsuite/gcc.target/loongarch/div-no-div32.c
new file mode 100644
index 0000000..f0f697b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/loongarch/div-no-div32.c
@@ -0,0 +1,11 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -march=loongarch64 -mabi=lp64d" } */
+/* { dg-final { scan-assembler "div\.w" } } */
+/* { dg-final { scan-assembler "div\.wu" } } */
+/* { dg-final { scan-assembler "mod\.w" } } */
+/* { dg-final { scan-assembler "mod\.wu" } } */
+
+/* -mno-div32 should be implied by -march=loongarch64.  */
+/* { dg-final { scan-assembler-times "slli\.w\[^\n\]*0" 8 } } */
+
+#include "div-div32.c"
diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-5.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-5.c
index 8a47b5a..cae880b 100644
--- a/gcc/testsuite/gcc.target/loongarch/func-call-medium-5.c
+++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-5.c
@@ -1,4 +1,5 @@
 /* { dg-do compile } */
+/* { dg-skip-if "dg-require-effective-target loongarch_call36_support" { *-*-* } } */
 /* { dg-options "-mabi=lp64d -O0 -fpic -fplt -mexplicit-relocs -mcmodel=medium" } */
 /* { dg-final { scan-assembler "test:.*pcalau12i.*%pc_hi20\\(g\\)\n\tjirl.*pc_lo12\\(g\\)" } } */
 /* { dg-final { scan-assembler "test1:.*pcalau12i.*%pc_hi20\\(f\\)\n\tjirl.*%pc_lo12\\(f\\)" } } */
diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-6.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-6.c
index 1e75e60..3381954 100644
--- a/gcc/testsuite/gcc.target/loongarch/func-call-medium-6.c
+++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-6.c
@@ -1,4 +1,5 @@
 /* { dg-do compile } */
+/* { dg-skip-if "dg-require-effective-target loongarch_call36_support" { *-*-* } } */
 /* { dg-options "-mabi=lp64d -O0 -fno-pic -fplt -mexplicit-relocs -mcmodel=medium" } */
 /* { dg-final { scan-assembler "test:.*pcalau12i.*%pc_hi20\\(g\\)\n\tjirl.*pc_lo12\\(g\\)" } } */
 /* { dg-final { scan-assembler "test1:.*pcalau12i.*%pc_hi20\\(f\\)\n\tjirl.*%pc_lo12\\(f\\)" } } */
diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-7.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-7.c
index 9e89085..969b59d 100644
--- a/gcc/testsuite/gcc.target/loongarch/func-call-medium-7.c
+++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-7.c
@@ -1,4 +1,5 @@
 /* { dg-do compile } */
+/* { dg-skip-if "dg-require-effective-target loongarch_call36_support" { *-*-* } } */
 /* { dg-options "-mabi=lp64d -O0 -fpic -fno-plt -mexplicit-relocs -mcmodel=medium" } */
 /* { dg-final { scan-assembler "test:.*pcalau12i\t.*%got_pc_hi20\\(g\\)\n\tld\.d\t.*%got_pc_lo12\\(g\\)\n\tjirl" } } */
 /* { dg-final { scan-assembler "test1:.*pcalau12i\t.*%got_pc_hi20\\(f\\)\n\tld\.d\t.*%got_pc_lo12\\(f\\)\n\tjirl" } } */
diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-8.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-8.c
index fde9c6e..786ff39 100644
--- a/gcc/testsuite/gcc.target/loongarch/func-call-medium-8.c
+++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-8.c
@@ -1,4 +1,5 @@
 /* { dg-do compile } */
+/* { dg-skip-if "dg-require-effective-target loongarch_call36_support" { *-*-* } } */
 /* { dg-options "-mabi=lp64d -O0 -fno-pic -fno-plt -mexplicit-relocs -mcmodel=medium" } */
 /* { dg-final { scan-assembler "test:.*pcalau12i\t.*%got_pc_hi20\\(g\\)\n\tld\.d\t.*%got_pc_lo12\\(g\\)\n\tjirl" } } */
 /* { dg-final { scan-assembler "test1:.*pcalau12i\t.*%pc_hi20\\(f\\)\n\tjirl.*%pc_lo12\\(f\\)" } } */
diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-call36-1.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-call36-1.c
new file mode 100644
index 0000000..872ff32
--- /dev/null
+++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-call36-1.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target loongarch_call36_support } */
+/* { dg-options "-mcmodel=medium -mexplicit-relocs -fdump-rtl-final -O2" } */
+/* { dg-final { scan-assembler "test:.*pcaddu18i\t\\\$r1,%call36\\(func\\)" } } */
+/* { dg-final { scan-assembler "test_value:.*pcaddu18i\t\\\$r1,%call36\\(func_value\\)" } } */
+
+extern void func (void);
+int
+test (void)
+{
+  func ();
+}
+
+
+extern int func_value (void);
+float
+test_value (void)
+{
+  func_value ();
+}
+
diff --git a/gcc/testsuite/gcc.target/loongarch/func-call-medium-call36.c b/gcc/testsuite/gcc.target/loongarch/func-call-medium-call36.c
new file mode 100644
index 0000000..98ccd26
--- /dev/null
+++ b/gcc/testsuite/gcc.target/loongarch/func-call-medium-call36.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target loongarch_call36_support } */
+/* { dg-options "-mcmodel=medium -mexplicit-relocs -fdump-rtl-final -O2" } */
+/* { dg-final { scan-rtl-dump-times "\\(clobber \\(reg:DI 12 \\\$r12\\)\\)" 3 "final" } } */
+/* { dg-final { scan-assembler "test:.*pcaddu18i\t\\\$r12,%call36\\(func\\)" } } */
+/* { dg-final { scan-assembler "test_value:.*pcaddu18i\t\\\$r12,%call36\\(func_value\\)" } } */
+/* { dg-final { scan-assembler "test_multi:.*pcaddu18i\t\\\$r12,%call36\\(func_multi\\)" } } */
+
+extern void func (void);
+void
+test (void)
+{
+  func();
+}
+
+
+extern int func_value (void);
+int
+test_value (void)
+{
+  func_value ();
+}
+
+struct t {float a; float b;};
+
+extern struct t func_multi (void);
+struct t
+test_multi (void)
+{
+  func_multi ();
+}
+
diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-vcond-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-vcond-1.c
index ee9cb1a..57064ea 100644
--- a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-vcond-1.c
+++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-vcond-1.c
@@ -52,13 +52,13 @@ TEST_VAR_ALL (DEF_VCOND_VAR)
 
 /* { dg-final { scan-assembler-times {\txvslt\.b} 4 } } */
 /* { dg-final { scan-assembler-times {\txvslt\.h} 4 } } */
-/* { dg-final { scan-assembler-times {\txvslt\.w} 4 } } */
-/* { dg-final { scan-assembler-times {\txvslt\.d} 4 } } */
+/* { dg-final { scan-assembler-times {\txvslt\.w} 8 } } */
+/* { dg-final { scan-assembler-times {\txvslt\.d} 8 } } */
 /* { dg-final { scan-assembler-times {\txvsle\.b} 4 } } */
 /* { dg-final { scan-assembler-times {\txvsle\.h} 4 } } */
-/* { dg-final { scan-assembler-times {\txvsle\.w} 4 } } */
-/* { dg-final { scan-assembler-times {\txvsle\.d} 4 } } */
+/* { dg-final { scan-assembler-times {\txvsle\.w} 8 } } */
+/* { dg-final { scan-assembler-times {\txvsle\.d} 8 } } */
 /* { dg-final { scan-assembler-times {\txvseq\.b} 4 } } */
 /* { dg-final { scan-assembler-times {\txvseq\.h} 4 } } */
-/* { dg-final { scan-assembler-times {\txvseq\.w} 4 } } */
-/* { dg-final { scan-assembler-times {\txvseq\.d} 4 } } */
+/* { dg-final { scan-assembler-times {\txvseq\.w} 8 } } */
+/* { dg-final { scan-assembler-times {\txvseq\.d} 8 } } */
diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-vcond-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-vcond-2.c
index 5f40ed4..55d5a08 100644
--- a/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-vcond-2.c
+++ b/gcc/testsuite/gcc.target/loongarch/vector/lasx/lasx-vcond-2.c
@@ -67,21 +67,21 @@ TEST_CMP (nule)
 TEST_CMP (nuge)
 TEST_CMP (nugt)
 
-/* { dg-final { scan-assembler-times {\txvfcmp\.ceq\.s} 2 } } */
-/* { dg-final { scan-assembler-times {\txvfcmp\.ceq\.d} 2 } } */
-/* { dg-final { scan-assembler-times {\txvfcmp\.cne\.s} 2 } } */
-/* { dg-final { scan-assembler-times {\txvfcmp\.cne\.d} 2 } } */
-/* { dg-final { scan-assembler-times {\txvfcmp\.slt\.s} 4 } } */
-/* { dg-final { scan-assembler-times {\txvfcmp\.slt\.d} 4 } } */
-/* { dg-final { scan-assembler-times {\txvfcmp\.sle\.s} 4 } } */
-/* { dg-final { scan-assembler-times {\txvfcmp\.sle\.d} 4 } } */
-/* { dg-final { scan-assembler-times {\txvfcmp\.cor\.s} 2 } } */
-/* { dg-final { scan-assembler-times {\txvfcmp\.cor\.d} 2 } } */
-/* { dg-final { scan-assembler-times {\txvfcmp\.cun\.s} 2 } } */
-/* { dg-final { scan-assembler-times {\txvfcmp\.cun\.d} 2 } } */
-/* { dg-final { scan-assembler-times {\txvfcmp\.cueq\.s} 4 } } */
-/* { dg-final { scan-assembler-times {\txvfcmp\.cueq\.d} 4 } } */
-/* { dg-final { scan-assembler-times {\txvfcmp\.cule\.s} 8 } } */
-/* { dg-final { scan-assembler-times {\txvfcmp\.cule\.d} 8 } } */
-/* { dg-final { scan-assembler-times {\txvfcmp\.cult\.s} 8 } } */
-/* { dg-final { scan-assembler-times {\txvfcmp\.cult\.d} 8 } } */
+/* { dg-final { scan-assembler-times {\txvfcmp\.ceq\.s} 3 } } */
+/* { dg-final { scan-assembler-times {\txvfcmp\.ceq\.d} 3 } } */
+/* { dg-final { scan-assembler-times {\txvfcmp\.cne\.s} 3 } } */
+/* { dg-final { scan-assembler-times {\txvfcmp\.cne\.d} 3 } } */
+/* { dg-final { scan-assembler-times {\txvfcmp\.slt\.s} 6 } } */
+/* { dg-final { scan-assembler-times {\txvfcmp\.slt\.d} 6 } } */
+/* { dg-final { scan-assembler-times {\txvfcmp\.sle\.s} 6 } } */
+/* { dg-final { scan-assembler-times {\txvfcmp\.sle\.d} 6 } } */
+/* { dg-final { scan-assembler-times {\txvfcmp\.cor\.s} 3 } } */
+/* { dg-final { scan-assembler-times {\txvfcmp\.cor\.d} 3 } } */
+/* { dg-final { scan-assembler-times {\txvfcmp\.cun\.s} 3 } } */
+/* { dg-final { scan-assembler-times {\txvfcmp\.cun\.d} 3 } } */
+/* { dg-final { scan-assembler-times {\txvfcmp\.cueq\.s} 6 } } */
+/* { dg-final { scan-assembler-times {\txvfcmp\.cueq\.d} 6 } } */
+/* { dg-final { scan-assembler-times {\txvfcmp\.cule\.s} 12 } } */
+/* { dg-final { scan-assembler-times {\txvfcmp\.cule\.d} 12 } } */
+/* { dg-final { scan-assembler-times {\txvfcmp\.cult\.s} 12 } } */
+/* { dg-final { scan-assembler-times {\txvfcmp\.cult\.d} 12 } } */
diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vcond-1.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vcond-1.c
index 138adcc..8c69f0d 100644
--- a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vcond-1.c
+++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vcond-1.c
@@ -52,13 +52,13 @@ TEST_VAR_ALL (DEF_VCOND_VAR)
 
 /* { dg-final { scan-assembler-times {\tvslt\.b} 4 } } */
 /* { dg-final { scan-assembler-times {\tvslt\.h} 4 } } */
-/* { dg-final { scan-assembler-times {\tvslt\.w} 4 } } */
-/* { dg-final { scan-assembler-times {\tvslt\.d} 4 } } */
+/* { dg-final { scan-assembler-times {\tvslt\.w} 8 } } */
+/* { dg-final { scan-assembler-times {\tvslt\.d} 8 } } */
 /* { dg-final { scan-assembler-times {\tvsle\.b} 4 } } */
 /* { dg-final { scan-assembler-times {\tvsle\.h} 4 } } */
-/* { dg-final { scan-assembler-times {\tvsle\.w} 4 } } */
-/* { dg-final { scan-assembler-times {\tvsle\.d} 4 } } */
+/* { dg-final { scan-assembler-times {\tvsle\.w} 8 } } */
+/* { dg-final { scan-assembler-times {\tvsle\.d} 8 } } */
 /* { dg-final { scan-assembler-times {\tvseq\.b} 4 } } */
 /* { dg-final { scan-assembler-times {\tvseq\.h} 4 } } */
-/* { dg-final { scan-assembler-times {\tvseq\.w} 4 } } */
-/* { dg-final { scan-assembler-times {\tvseq\.d} 4 } } */
+/* { dg-final { scan-assembler-times {\tvseq\.w} 8 } } */
+/* { dg-final { scan-assembler-times {\tvseq\.d} 8 } } */
diff --git a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vcond-2.c b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vcond-2.c
index e8fe31f..2214afd 100644
--- a/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vcond-2.c
+++ b/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-vcond-2.c
@@ -67,21 +67,21 @@ TEST_CMP (nule)
 TEST_CMP (nuge)
 TEST_CMP (nugt)
 
-/* { dg-final { scan-assembler-times {\tvfcmp\.ceq\.s} 2 } } */
-/* { dg-final { scan-assembler-times {\tvfcmp\.ceq\.d} 2 } } */
-/* { dg-final { scan-assembler-times {\tvfcmp\.cne\.s} 2 } } */
-/* { dg-final { scan-assembler-times {\tvfcmp\.cne\.d} 2 } } */
-/* { dg-final { scan-assembler-times {\tvfcmp\.slt\.s} 4 } } */
-/* { dg-final { scan-assembler-times {\tvfcmp\.slt\.d} 4 } } */
-/* { dg-final { scan-assembler-times {\tvfcmp\.sle\.s} 4 } } */
-/* { dg-final { scan-assembler-times {\tvfcmp\.sle\.d} 4 } } */
-/* { dg-final { scan-assembler-times {\tvfcmp\.cor\.s} 2 } } */
-/* { dg-final { scan-assembler-times {\tvfcmp\.cor\.d} 2 } } */
-/* { dg-final { scan-assembler-times {\tvfcmp\.cun\.s} 2 } } */
-/* { dg-final { scan-assembler-times {\tvfcmp\.cun\.d} 2 } } */
-/* { dg-final { scan-assembler-times {\tvfcmp\.cueq\.s} 4 } } */
-/* { dg-final { scan-assembler-times {\tvfcmp\.cueq\.d} 4 } } */
-/* { dg-final { scan-assembler-times {\tvfcmp\.cule\.s} 8 } } */
-/* { dg-final { scan-assembler-times {\tvfcmp\.cule\.d} 8 } } */
-/* { dg-final { scan-assembler-times {\tvfcmp\.cult\.s} 8 } } */
-/* { dg-final { scan-assembler-times {\tvfcmp\.cult\.d} 8 } } */
+/* { dg-final { scan-assembler-times {\tvfcmp\.ceq\.s} 3 } } */
+/* { dg-final { scan-assembler-times {\tvfcmp\.ceq\.d} 3 } } */
+/* { dg-final { scan-assembler-times {\tvfcmp\.cne\.s} 3 } } */
+/* { dg-final { scan-assembler-times {\tvfcmp\.cne\.d} 3 } } */
+/* { dg-final { scan-assembler-times {\tvfcmp\.slt\.s} 6 } } */
+/* { dg-final { scan-assembler-times {\tvfcmp\.slt\.d} 6 } } */
+/* { dg-final { scan-assembler-times {\tvfcmp\.sle\.s} 6 } } */
+/* { dg-final { scan-assembler-times {\tvfcmp\.sle\.d} 6 } } */
+/* { dg-final { scan-assembler-times {\tvfcmp\.cor\.s} 3 } } */
+/* { dg-final { scan-assembler-times {\tvfcmp\.cor\.d} 3 } } */
+/* { dg-final { scan-assembler-times {\tvfcmp\.cun\.s} 3 } } */
+/* { dg-final { scan-assembler-times {\tvfcmp\.cun\.d} 3 } } */
+/* { dg-final { scan-assembler-times {\tvfcmp\.cueq\.s} 6 } } */
+/* { dg-final { scan-assembler-times {\tvfcmp\.cueq\.d} 6 } } */
+/* { dg-final { scan-assembler-times {\tvfcmp\.cule\.s} 12 } } */
+/* { dg-final { scan-assembler-times {\tvfcmp\.cule\.d} 12 } } */
+/* { dg-final { scan-assembler-times {\tvfcmp\.cult\.s} 12 } } */
+/* { dg-final { scan-assembler-times {\tvfcmp\.cult\.d} 12 } } */
diff --git a/gcc/testsuite/gcc.target/nvptx/brev-1.c b/gcc/testsuite/gcc.target/nvptx/brev-1.c
index fbb4fff..af875dd 100644
--- a/gcc/testsuite/gcc.target/nvptx/brev-1.c
+++ b/gcc/testsuite/gcc.target/nvptx/brev-1.c
@@ -1,8 +1,16 @@
 /* { dg-do compile } */
 /* { dg-options "-O2" } */
+/* { dg-final { check-function-bodies {**} {} } } */
+
 unsigned int foo(unsigned int x)
 {
   return __builtin_nvptx_brev(x);
 }
-
-/* { dg-final { scan-assembler "brev.b32" } } */
+/*
+** foo:
+**	...
+**	mov\.u32	(%r[0-9]+), %ar0;
+**	brev\.b32	%value, \1;
+**	st\.param\.u32	\[%value_out\], %value;
+**	ret;
+*/
diff --git a/gcc/testsuite/gcc.target/nvptx/brev-2-O0.c b/gcc/testsuite/gcc.target/nvptx/brev-2-O0.c
new file mode 100644
index 0000000..ca011eb
--- /dev/null
+++ b/gcc/testsuite/gcc.target/nvptx/brev-2-O0.c
@@ -0,0 +1,129 @@
+/* { dg-do run } */
+/* { dg-options "-O0" } */
+/* { dg-additional-options -save-temps } */
+/* { dg-final { check-function-bodies {**} {} } } */
+
+inline __attribute__((always_inline))
+unsigned int bitreverse32(unsigned int x)
+{
+  return __builtin_nvptx_brev(x);
+}
+
+int main(void)
+{
+  if (bitreverse32(0x00000000) != 0x00000000)
+    __builtin_abort();
+  if (bitreverse32(0xffffffff) != 0xffffffff)
+    __builtin_abort();
+
+  if (bitreverse32(0x00000001) != 0x80000000)
+    __builtin_abort();
+  if (bitreverse32(0x00000002) != 0x40000000)
+    __builtin_abort();
+  if (bitreverse32(0x00000004) != 0x20000000)
+    __builtin_abort();
+  if (bitreverse32(0x00000008) != 0x10000000)
+    __builtin_abort();
+  if (bitreverse32(0x00000010) != 0x08000000)
+    __builtin_abort();
+  if (bitreverse32(0x00000020) != 0x04000000)
+    __builtin_abort();
+  if (bitreverse32(0x00000040) != 0x02000000)
+    __builtin_abort();
+  if (bitreverse32(0x00000080) != 0x01000000)
+    __builtin_abort();
+  if (bitreverse32(0x00000100) != 0x00800000)
+    __builtin_abort();
+  if (bitreverse32(0x00000200) != 0x00400000)
+    __builtin_abort();
+  if (bitreverse32(0x00000400) != 0x00200000)
+    __builtin_abort();
+  if (bitreverse32(0x00000800) != 0x00100000)
+    __builtin_abort();
+  if (bitreverse32(0x00001000) != 0x00080000)
+    __builtin_abort();
+  if (bitreverse32(0x00002000) != 0x00040000)
+    __builtin_abort();
+  if (bitreverse32(0x00004000) != 0x00020000)
+    __builtin_abort();
+  if (bitreverse32(0x00008000) != 0x00010000)
+    __builtin_abort();
+  if (bitreverse32(0x00010000) != 0x00008000)
+    __builtin_abort();
+  if (bitreverse32(0x00020000) != 0x00004000)
+    __builtin_abort();
+  if (bitreverse32(0x00040000) != 0x00002000)
+    __builtin_abort();
+  if (bitreverse32(0x00080000) != 0x00001000)
+    __builtin_abort();
+  if (bitreverse32(0x00100000) != 0x00000800)
+    __builtin_abort();
+  if (bitreverse32(0x00200000) != 0x00000400)
+    __builtin_abort();
+  if (bitreverse32(0x00400000) != 0x00000200)
+    __builtin_abort();
+  if (bitreverse32(0x00800000) != 0x00000100)
+    __builtin_abort();
+  if (bitreverse32(0x01000000) != 0x00000080)
+    __builtin_abort();
+  if (bitreverse32(0x02000000) != 0x00000040)
+    __builtin_abort();
+  if (bitreverse32(0x04000000) != 0x00000020)
+    __builtin_abort();
+  if (bitreverse32(0x08000000) != 0x00000010)
+    __builtin_abort();
+  if (bitreverse32(0x10000000) != 0x00000008)
+    __builtin_abort();
+  if (bitreverse32(0x20000000) != 0x00000004)
+    __builtin_abort();
+  if (bitreverse32(0x40000000) != 0x00000002)
+    __builtin_abort();
+  if (bitreverse32(0x80000000) != 0x00000001)
+    __builtin_abort();
+
+  if (bitreverse32(0x01234567) != 0xe6a2c480)
+    __builtin_abort();
+  if (bitreverse32(0xe6a2c480) != 0x01234567)
+    __builtin_abort();
+  if (bitreverse32(0xdeadbeef) != 0xf77db57b)
+    __builtin_abort();
+  if (bitreverse32(0xf77db57b) != 0xdeadbeef)
+    __builtin_abort();
+  if (bitreverse32(0xcafebabe) != 0x7d5d7f53)
+    __builtin_abort();
+  if (bitreverse32(0x7d5d7f53) != 0xcafebabe)
+    __builtin_abort();
+
+  return 0;
+}
+/*
+** main:
+**	...
+**	mov\.u32	(%r[0-9]+), 0;
+**	st\.u32	(\[%frame[+0-9]*\]), \1;
+**	ld\.u32	(%r[0-9]+), \2;
+**	brev\.b32	(%r[0-9]+), \3;
+**	setp\.[^.]+\.u32	%r[0-9]+, \4, 0;
+**	...
+**	mov\.u32	(%r[0-9]+), -1;
+**	st\.u32	(\[%frame[+0-9]*\]), \5;
+**	ld\.u32	(%r[0-9]+), \6;
+**	brev\.b32	(%r[0-9]+), \7;
+**	setp\.[^.]+\.u32	%r[0-9]+, \8, -1;
+**	...
+**	mov\.u32	(%r[0-9]+), 1;
+**	st\.u32	(\[%frame[+0-9]*\]), \9;
+**	ld\.u32	(%r[0-9]+), \10;
+**	brev\.b32	(%r[0-9]+), \11;
+**	setp\.[^.]+\.u32	%r[0-9]+, \12, -2147483648;
+**	...
+**	mov\.u32	(%r[0-9]+), 2;
+**	st\.u32	(\[%frame[+0-9]*\]), \13;
+**	ld\.u32	(%r[0-9]+), \14;
+**	brev\.b32	(%r[0-9]+), \15;
+**	setp\.[^.]+\.u32	%r[0-9]+, \16, 1073741824;
+**	...
+*/
+
+/* { dg-final { scan-assembler-times {\tbrev\.b32\t} 40 } } */
+/* { dg-final { scan-assembler {\mabort\M} } } */
diff --git a/gcc/testsuite/gcc.target/nvptx/brev-2.c b/gcc/testsuite/gcc.target/nvptx/brev-2-O2.c
index 9d0defe..c707a87 100644
--- a/gcc/testsuite/gcc.target/nvptx/brev-2.c
+++ b/gcc/testsuite/gcc.target/nvptx/brev-2-O2.c
@@ -1,5 +1,8 @@
 /* { dg-do run } */
 /* { dg-options "-O2" } */
+/* { dg-additional-options -save-temps } */
+
+inline __attribute__((always_inline))
 unsigned int bitreverse32(unsigned int x)
 {
   return __builtin_nvptx_brev(x);
@@ -89,6 +92,9 @@ int main(void)
     __builtin_abort();
   if (bitreverse32(0x7d5d7f53) != 0xcafebabe)
     __builtin_abort();
+
   return 0;
 }
 
+/* { dg-final { scan-assembler-not {\tbrev\.b32\t} } } */
+/* { dg-final { scan-assembler-not {\mabort\M} } } */
diff --git a/gcc/testsuite/gcc.target/nvptx/brevll-1.c b/gcc/testsuite/gcc.target/nvptx/brevll-1.c
index 7009d5f..0b03fee 100644
--- a/gcc/testsuite/gcc.target/nvptx/brevll-1.c
+++ b/gcc/testsuite/gcc.target/nvptx/brevll-1.c
@@ -1,8 +1,16 @@
 /* { dg-do compile } */
 /* { dg-options "-O2" } */
+/* { dg-final { check-function-bodies {**} {} } } */
+
 unsigned long foo(unsigned long x)
 {
   return __builtin_nvptx_brevll(x);
 }
-
-/* { dg-final { scan-assembler "brev.b64" } } */
+/*
+** foo:
+**	...
+**	mov\.u64	(%r[0-9]+), %ar0;
+**	brev\.b64	%value, \1;
+**	st\.param\.u64	\[%value_out\], %value;
+**	ret;
+*/
diff --git a/gcc/testsuite/gcc.target/nvptx/brevll-2-O0.c b/gcc/testsuite/gcc.target/nvptx/brevll-2-O0.c
new file mode 100644
index 0000000..32bbfbf
--- /dev/null
+++ b/gcc/testsuite/gcc.target/nvptx/brevll-2-O0.c
@@ -0,0 +1,189 @@
+/* { dg-do run } */
+/* { dg-options "-O0" } */
+/* { dg-additional-options -save-temps } */
+/* { dg-final { check-function-bodies {**} {} } } */
+
+inline __attribute__((always_inline))
+unsigned long long bitreverse64(unsigned long long x)
+{
+  return __builtin_nvptx_brevll(x);
+}
+
+int main(void)
+{
+  if (bitreverse64(0x0000000000000000ll) != 0x0000000000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0xffffffffffffffffll) != 0xffffffffffffffffll)
+    __builtin_abort();
+
+  if (bitreverse64(0x0000000000000001ll) != 0x8000000000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000000002ll) != 0x4000000000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000000004ll) != 0x2000000000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000000008ll) != 0x1000000000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000000010ll) != 0x0800000000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000000020ll) != 0x0400000000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000000040ll) != 0x0200000000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000000080ll) != 0x0100000000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000000100ll) != 0x0080000000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000000200ll) != 0x0040000000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000000400ll) != 0x0020000000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000000800ll) != 0x0010000000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000001000ll) != 0x0008000000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000002000ll) != 0x0004000000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000004000ll) != 0x0002000000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000008000ll) != 0x0001000000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000010000ll) != 0x0000800000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000020000ll) != 0x0000400000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000040000ll) != 0x0000200000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000080000ll) != 0x0000100000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000100000ll) != 0x0000080000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000200000ll) != 0x0000040000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000400000ll) != 0x0000020000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000000800000ll) != 0x0000010000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000001000000ll) != 0x0000008000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000002000000ll) != 0x0000004000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000004000000ll) != 0x0000002000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000008000000ll) != 0x0000001000000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000010000000ll) != 0x0000000800000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000020000000ll) != 0x0000000400000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000040000000ll) != 0x0000000200000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000080000000ll) != 0x0000000100000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000100000000ll) != 0x0000000080000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000200000000ll) != 0x0000000040000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000400000000ll) != 0x0000000020000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000000800000000ll) != 0x0000000010000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000001000000000ll) != 0x0000000008000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000002000000000ll) != 0x0000000004000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000004000000000ll) != 0x0000000002000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000008000000000ll) != 0x0000000001000000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000010000000000ll) != 0x0000000000800000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000020000000000ll) != 0x0000000000400000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000040000000000ll) != 0x0000000000200000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000080000000000ll) != 0x0000000000100000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000100000000000ll) != 0x0000000000080000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000200000000000ll) != 0x0000000000040000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000400000000000ll) != 0x0000000000020000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0000800000000000ll) != 0x0000000000010000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0001000000000000ll) != 0x0000000000008000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0002000000000000ll) != 0x0000000000004000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0004000000000000ll) != 0x0000000000002000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0008000000000000ll) != 0x0000000000001000ll)
+    __builtin_abort();
+  if (bitreverse64(0x0010000000000000ll) != 0x0000000000000800ll)
+    __builtin_abort();
+  if (bitreverse64(0x0020000000000000ll) != 0x0000000000000400ll)
+    __builtin_abort();
+  if (bitreverse64(0x0040000000000000ll) != 0x0000000000000200ll)
+    __builtin_abort();
+  if (bitreverse64(0x0080000000000000ll) != 0x0000000000000100ll)
+    __builtin_abort();
+  if (bitreverse64(0x0100000000000000ll) != 0x0000000000000080ll)
+    __builtin_abort();
+  if (bitreverse64(0x0200000000000000ll) != 0x0000000000000040ll)
+    __builtin_abort();
+  if (bitreverse64(0x0400000000000000ll) != 0x0000000000000020ll)
+    __builtin_abort();
+  if (bitreverse64(0x0800000000000000ll) != 0x0000000000000010ll)
+    __builtin_abort();
+  if (bitreverse64(0x1000000000000000ll) != 0x0000000000000008ll)
+    __builtin_abort();
+  if (bitreverse64(0x2000000000000000ll) != 0x0000000000000004ll)
+    __builtin_abort();
+  if (bitreverse64(0x4000000000000000ll) != 0x0000000000000002ll)
+    __builtin_abort();
+  if (bitreverse64(0x8000000000000000ll) != 0x0000000000000001ll)
+    __builtin_abort();
+
+  if (bitreverse64(0x0123456789abcdefll) != 0xf7b3d591e6a2c480ll)
+    __builtin_abort();
+  if (bitreverse64(0xf7b3d591e6a2c480ll) != 0x0123456789abcdefll)
+    __builtin_abort();
+  if (bitreverse64(0xdeadbeefcafebabell) != 0x7d5d7f53f77db57bll)
+    __builtin_abort();
+  if (bitreverse64(0x7d5d7f53f77db57bll) != 0xdeadbeefcafebabell)
+    __builtin_abort();
+
+  return 0;
+}
+/*
+** main:
+**	...
+**	mov\.u64	(%r[0-9]+), 0;
+**	st\.u64	(\[%frame[+0-9]*\]), \1;
+**	ld\.u64	(%r[0-9]+), \2;
+**	brev\.b64	(%r[0-9]+), \3;
+**	setp\.[^.]+\.u64	%r[0-9]+, \4, 0;
+**	...
+**	mov\.u64	(%r[0-9]+), -1;
+**	st\.u64	(\[%frame[+0-9]*\]), \5;
+**	ld\.u64	(%r[0-9]+), \6;
+**	brev\.b64	(%r[0-9]+), \7;
+**	setp\.[^.]+\.u64	%r[0-9]+, \8, -1;
+**	...
+**	mov\.u64	(%r[0-9]+), 1;
+**	st\.u64	(\[%frame[+0-9]*\]), \9;
+**	ld\.u64	(%r[0-9]+), \10;
+**	brev\.b64	(%r[0-9]+), \11;
+**	setp\.[^.]+\.u64	%r[0-9]+, \12, -9223372036854775808;
+**	...
+**	mov\.u64	(%r[0-9]+), 2;
+**	st\.u64	(\[%frame[+0-9]*\]), \13;
+**	ld\.u64	(%r[0-9]+), \14;
+**	brev\.b64	(%r[0-9]+), \15;
+**	setp\.[^.]+\.u64	%r[0-9]+, \16, 4611686018427387904;
+**	...
+*/
+
+/* { dg-final { scan-assembler-times {\tbrev\.b64\t} 70 } } */
+/* { dg-final { scan-assembler {\mabort\M} } } */
diff --git a/gcc/testsuite/gcc.target/nvptx/brevll-2.c b/gcc/testsuite/gcc.target/nvptx/brevll-2-O2.c
index 56054b1..c89be96 100644
--- a/gcc/testsuite/gcc.target/nvptx/brevll-2.c
+++ b/gcc/testsuite/gcc.target/nvptx/brevll-2-O2.c
@@ -1,5 +1,8 @@
 /* { dg-do run } */
 /* { dg-options "-O2" } */
+/* { dg-additional-options -save-temps } */
+
+inline __attribute__((always_inline))
 unsigned long long bitreverse64(unsigned long long x)
 {
   return __builtin_nvptx_brevll(x);
@@ -149,6 +152,9 @@ int main(void)
     __builtin_abort();
   if (bitreverse64(0x7d5d7f53f77db57bll) != 0xdeadbeefcafebabell)
     __builtin_abort();
+
   return 0;
 }
 
+/* { dg-final { scan-assembler-not {\tbrev\.b64\t} } } */
+/* { dg-final { scan-assembler-not {\mabort\M} } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/pr111449-1.c b/gcc/testsuite/gcc.target/powerpc/pr111449-1.c
new file mode 100644
index 0000000..0c9e176
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/pr111449-1.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target powerpc_p8vector_ok } */
+/* { dg-options "-mdejagnu-cpu=power8 -mvsx -O2" } */
+
+/* Ensure vector mode is used for 16-byte by pieces equality compare.  */
+
+int compare1 (const char* s1, const char* s2)
+{
+  return __builtin_memcmp (s1, s2, 16) == 0;
+}
+
+int compare2 (const char* s1)
+{
+  return __builtin_memcmp (s1, "0123456789012345", 16) == 0;
+}
+
+/* { dg-final { scan-assembler-times {\mvcmpequb\.} 2 } } */
+/* { dg-final { scan-assembler-not {\mcmpd\M} } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/pr111449-2.c b/gcc/testsuite/gcc.target/powerpc/pr111449-2.c
new file mode 100644
index 0000000..7003bdc
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/pr111449-2.c
@@ -0,0 +1,18 @@
+/* { dg-do compile { target { has_arch_pwr8 } } } */
+/* { dg-require-effective-target powerpc_p8vector_ok } */
+/* { dg-options "-mvsx -O2" } */
+
+/* Ensure 16-byte by pieces move is enabled.  */
+
+void move1 (void *s1, void *s2)
+{
+  __builtin_memcpy (s1, s2, 16);
+}
+
+void move2 (void *s1)
+{
+  __builtin_memcpy (s1, "0123456789012345", 16);
+}
+
+/* { dg-final { scan-assembler-times {\mlxvd2x\M|\mp?lxv\M} 2 } } */
+/* { dg-final { scan-assembler-times {\mstxvd2x\M|\mstxv\M} 2 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/arch-27.c b/gcc/testsuite/gcc.target/riscv/arch-27.c
new file mode 100644
index 0000000..70143b2
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/arch-27.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64ge -mabi=lp64d" } */
+int foo()
+{
+}
+
+/* { dg-error "ISA string is not in canonical order. 'e'" "" { target *-*-* } 0 } */
diff --git a/gcc/testsuite/gcc.target/riscv/arch-28.c b/gcc/testsuite/gcc.target/riscv/arch-28.c
new file mode 100644
index 0000000..934399a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/arch-28.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64imaefcv -mabi=lp64d" } */
+int foo()
+{
+}
+
+/* { dg-error "ISA string is not in canonical order. 'e'" "" { target *-*-* } 0 } */
diff --git a/gcc/testsuite/gcc.target/riscv/attribute-1.c b/gcc/testsuite/gcc.target/riscv/attribute-1.c
index abfb0b4..a39efb3 100644
--- a/gcc/testsuite/gcc.target/riscv/attribute-1.c
+++ b/gcc/testsuite/gcc.target/riscv/attribute-1.c
@@ -4,13 +4,13 @@ int foo()
 {
 
 /* In absence of -m[no-]strict-align, default mcpu is currently 
-   set to rocket.  rocket has slow_unaligned_access=true.  */
-#if !defined(__riscv_unaligned_slow)
-#error "__riscv_unaligned_slow is not set"
+   set to rocket.  rocket has slow_misaligned_access=true.  */
+#if !defined(__riscv_misaligned_slow)
+#error "__riscv_misaligned_slow is not set"
 #endif
 
-#if defined(__riscv_unaligned_avoid) || defined(__riscv_unaligned_fast)
-#error "__riscv_unaligned_avoid or __riscv_unaligned_fast is unexpectedly set"
+#if defined(__riscv_misaligned_avoid) || defined(__riscv_misaligned_fast)
+#error "__riscv_misaligned_avoid or __riscv_misaligned_fast is unexpectedly set"
 #endif
 
 return 0;
diff --git a/gcc/testsuite/gcc.target/riscv/attribute-4.c b/gcc/testsuite/gcc.target/riscv/attribute-4.c
index 545f87c..a5a9504 100644
--- a/gcc/testsuite/gcc.target/riscv/attribute-4.c
+++ b/gcc/testsuite/gcc.target/riscv/attribute-4.c
@@ -3,12 +3,12 @@
 int foo()
 {
 
-#if !defined(__riscv_unaligned_avoid)
-#error "__riscv_unaligned_avoid is not set"
+#if !defined(__riscv_misaligned_avoid)
+#error "__riscv_misaligned_avoid is not set"
 #endif
 
-#if defined(__riscv_unaligned_fast) || defined(__riscv_unaligned_slow)
-#error "__riscv_unaligned_fast or __riscv_unaligned_slow is unexpectedly set"
+#if defined(__riscv_misaligned_fast) || defined(__riscv_misaligned_slow)
+#error "__riscv_misaligned_fast or __riscv_misaligned_slow is unexpectedly set"
 #endif
 
   return 0;
diff --git a/gcc/testsuite/gcc.target/riscv/attribute-5.c b/gcc/testsuite/gcc.target/riscv/attribute-5.c
index 753043c..ad1a181 100644
--- a/gcc/testsuite/gcc.target/riscv/attribute-5.c
+++ b/gcc/testsuite/gcc.target/riscv/attribute-5.c
@@ -3,13 +3,13 @@
 int foo()
 {
 
-/* Default mcpu is rocket which has slow_unaligned_access=true.  */
-#if !defined(__riscv_unaligned_slow)
-#error "__riscv_unaligned_slow is not set"
+/* Default mcpu is rocket which has slow_misaligned_access=true.  */
+#if !defined(__riscv_misaligned_slow)
+#error "__riscv_misaligned_slow is not set"
 #endif
 
-#if defined(__riscv_unaligned_avoid) || defined(__riscv_unaligned_fast)
-#error "__riscv_unaligned_avoid or __riscv_unaligned_fast is unexpectedly set"
+#if defined(__riscv_misaligned_avoid) || defined(__riscv_misaligned_fast)
+#error "__riscv_misaligned_avoid or __riscv_misaligned_fast is unexpectedly set"
 #endif
 
 return 0;
diff --git a/gcc/testsuite/gcc.target/riscv/pr112478.c b/gcc/testsuite/gcc.target/riscv/pr112478.c
new file mode 100644
index 0000000..0bbde20
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/pr112478.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-ffat-lto-objects" } */
+
+void foo() {
+    asm volatile("# " : ::"ra");
+}
+
+/* { dg-final { scan-assembler "s(w|d)\[ \t\]*ra" } } */
diff --git a/gcc/testsuite/gcc.target/riscv/predef-align-1.c b/gcc/testsuite/gcc.target/riscv/predef-align-1.c
index 9dde37a..fb8c5f7 100644
--- a/gcc/testsuite/gcc.target/riscv/predef-align-1.c
+++ b/gcc/testsuite/gcc.target/riscv/predef-align-1.c
@@ -3,13 +3,13 @@
 
 int main() {
 
-/* thead-c906 default is cpu tune param unaligned access fast */
-#if !defined(__riscv_unaligned_fast)
-#error "__riscv_unaligned_fast is not set"
+/* thead-c906 default is cpu tune param misaligned access fast */
+#if !defined(__riscv_misaligned_fast)
+#error "__riscv_misaligned_fast is not set"
 #endif
 
-#if defined(__riscv_unaligned_avoid) || defined(__riscv_unaligned_slow)
-#error "__riscv_unaligned_avoid or __riscv_unaligned_slow is unexpectedly set"
+#if defined(__riscv_misaligned_avoid) || defined(__riscv_misaligned_slow)
+#error "__riscv_misaligned_avoid or __riscv_misaligned_slow is unexpectedly set"
 #endif
 
   return 0;
diff --git a/gcc/testsuite/gcc.target/riscv/predef-align-2.c b/gcc/testsuite/gcc.target/riscv/predef-align-2.c
index 33d604f..50ab67e 100644
--- a/gcc/testsuite/gcc.target/riscv/predef-align-2.c
+++ b/gcc/testsuite/gcc.target/riscv/predef-align-2.c
@@ -3,12 +3,12 @@
 
 int main() {
 
-#if !defined(__riscv_unaligned_avoid)
-#error "__riscv_unaligned_avoid is not set"
+#if !defined(__riscv_misaligned_avoid)
+#error "__riscv_misaligned_avoid is not set"
 #endif
 
-#if defined(__riscv_unaligned_fast) || defined(__riscv_unaligned_slow)
-#error "__riscv_unaligned_fast or __riscv_unaligned_slow is unexpectedly set"
+#if defined(__riscv_misaligned_fast) || defined(__riscv_misaligned_slow)
+#error "__riscv_misaligned_fast or __riscv_misaligned_slow is unexpectedly set"
 #endif
 
   return 0;
diff --git a/gcc/testsuite/gcc.target/riscv/predef-align-3.c b/gcc/testsuite/gcc.target/riscv/predef-align-3.c
index daf5718..5c58690 100644
--- a/gcc/testsuite/gcc.target/riscv/predef-align-3.c
+++ b/gcc/testsuite/gcc.target/riscv/predef-align-3.c
@@ -3,13 +3,13 @@
 
 int main() {
 
-/* thead-c906 default is cpu tune param unaligned access fast */
-#if !defined(__riscv_unaligned_fast)
-#error "__riscv_unaligned_fast is not set"
+/* thead-c906 default is cpu tune param misaligned access fast */
+#if !defined(__riscv_misaligned_fast)
+#error "__riscv_misaligned_fast is not set"
 #endif
 
-#if defined(__riscv_unaligned_avoid) || defined(__riscv_unaligned_slow)
-#error "__riscv_unaligned_avoid or __riscv_unaligned_slow is unexpectedly set"
+#if defined(__riscv_misaligned_avoid) || defined(__riscv_misaligned_slow)
+#error "__riscv_misaligned_avoid or __riscv_misaligned_slow is unexpectedly set"
 #endif
 
   return 0;
diff --git a/gcc/testsuite/gcc.target/riscv/predef-align-4.c b/gcc/testsuite/gcc.target/riscv/predef-align-4.c
index d46a46f..6fbdc7f 100644
--- a/gcc/testsuite/gcc.target/riscv/predef-align-4.c
+++ b/gcc/testsuite/gcc.target/riscv/predef-align-4.c
@@ -3,13 +3,13 @@
 
 int main() {
 
-/* rocket default is cpu tune param unaligned access slow */
-#if !defined(__riscv_unaligned_slow)
-#error "__riscv_unaligned_slow is not set"
+/* rocket default is cpu tune param misaligned access slow */
+#if !defined(__riscv_misaligned_slow)
+#error "__riscv_misaligned_slow is not set"
 #endif
 
-#if defined(__riscv_unaligned_avoid) || defined(__riscv_unaligned_fast)
-#error "__riscv_unaligned_avoid or __riscv_unaligned_fast is unexpectedly set"
+#if defined(__riscv_misaligned_avoid) || defined(__riscv_misaligned_fast)
+#error "__riscv_misaligned_avoid or __riscv_misaligned_fast is unexpectedly set"
 #endif
 
   return 0;
diff --git a/gcc/testsuite/gcc.target/riscv/predef-align-5.c b/gcc/testsuite/gcc.target/riscv/predef-align-5.c
index 3aa25f8..4a40081 100644
--- a/gcc/testsuite/gcc.target/riscv/predef-align-5.c
+++ b/gcc/testsuite/gcc.target/riscv/predef-align-5.c
@@ -3,12 +3,12 @@
 
 int main() {
 
-#if !defined(__riscv_unaligned_avoid)
-#error "__riscv_unaligned_avoid is not set"
+#if !defined(__riscv_misaligned_avoid)
+#error "__riscv_misaligned_avoid is not set"
 #endif
 
-#if defined(__riscv_unaligned_fast) || defined(__riscv_unaligned_slow)
-#error "__riscv_unaligned_fast or __riscv_unaligned_slow is unexpectedly set"
+#if defined(__riscv_misaligned_fast) || defined(__riscv_misaligned_slow)
+#error "__riscv_misaligned_fast or __riscv_misaligned_slow is unexpectedly set"
 #endif
 
   return 0;
diff --git a/gcc/testsuite/gcc.target/riscv/predef-align-6.c b/gcc/testsuite/gcc.target/riscv/predef-align-6.c
index cb64d7e..18eb72c 100644
--- a/gcc/testsuite/gcc.target/riscv/predef-align-6.c
+++ b/gcc/testsuite/gcc.target/riscv/predef-align-6.c
@@ -3,13 +3,13 @@
 
 int main() {
 
-/* rocket default is cpu tune param unaligned access slow */
-#if !defined(__riscv_unaligned_slow)
-#error "__riscv_unaligned_slow is not set"
+/* rocket default is cpu tune param misaligned access slow */
+#if !defined(__riscv_misaligned_slow)
+#error "__riscv_misaligned_slow is not set"
 #endif
 
-#if defined(__riscv_unaligned_avoid) || defined(__riscv_unaligned_fast)
-#error "__riscv_unaligned_avoid or __riscv_unaligned_fast is unexpectedly set"
+#if defined(__riscv_misaligned_avoid) || defined(__riscv_misaligned_fast)
+#error "__riscv_misaligned_avoid or __riscv_misaligned_fast is unexpectedly set"
 #endif
 
   return 0;
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr112535.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr112535.c
new file mode 100644
index 0000000..95799aa
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr112535.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3" } */
+
+int *a, *f;
+char b, c;
+int ***d;
+static int ****e = &d;
+void g() {
+  c = 3;
+  for (; c; c--)
+    if (c < 8) {
+      f = 0;
+      ***e = a;
+    }
+  if (b)
+    ***d = 0;
+}
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr112552.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr112552.c
new file mode 100644
index 0000000..32d221c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr112552.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -march=rv64gcv -mabi=lp64d --param=riscv-autovec-preference=fixed-vlmax -w" } */
+
+int a, c, d;
+void (*b)();
+void (*e)();
+void g();
+
+void h() {
+  for (; a; --a) {
+    char *f = h;
+    e = b || g > 1 ? g : b;
+    d |= !e;
+    *f ^= c;
+  }
+}
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr112554.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr112554.c
new file mode 100644
index 0000000..4afa7c2
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr112554.c
@@ -0,0 +1,12 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 --param=riscv-autovec-preference=fixed-vlmax" } */
+
+int a;
+void b() {
+  unsigned long c = 18446744073709551612UL;
+d:
+  --c;
+  a ^= c;
+  if (c)
+    goto d;
+}
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr112561.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr112561.c
new file mode 100644
index 0000000..25e61fa
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr112561.c
@@ -0,0 +1,16 @@
+/* { dg-do run { target { riscv_v } } } */
+/* { dg-options "-O3 -ftree-vectorize --param=riscv-autovec-preference=fixed-vlmax -mcmodel=medlow" } */
+
+int printf(char *, ...);
+int a, b, c, e;
+short d[7][7] = {};
+int main() {
+  short f;
+  c = 0;
+  for (; c <= 6; c++) {
+    e |= d[c][c] & 1;
+    b &= f & 3;
+  }
+  printf("%d\n", a);
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-10.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-10.c
new file mode 100644
index 0000000..ccce505
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-10.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=rv64gcv_zvl1024b -mabi=lp64d -fno-schedule-insns -fno-schedule-insns2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+#include <stdint-gcc.h>
+
+typedef int64_t vnx32di __attribute__ ((vector_size (32 * 8)));
+
+/*
+** f_vnx32di:
+**   vsetvli\s+[axt][0-9]+,\s*zero,\s*e64,\s*m2,\s*ta,\s*ma
+**   ...
+**   vmv\.v\.x\s+v[0-9]+,\s*[axt][0-9]+
+**   ...
+**   vmv\.s\.x\s+v0,\s*[axt][0-9]+
+**   vmerge\.vxm\s+v[0-9]+,\s*v[0-9]+,\s*[axt][0-9]+,\s*v0
+**   vs2r\.v\s+v[0-9]+,\s*0\([axt][0-9]+\)
+**   ret
+*/
+__attribute__ ((noipa)) void
+f_vnx32di (int64_t a, int64_t b, int64_t *out)
+{
+  vnx32di v = {
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+  };
+  *(vnx32di *) out = v;
+}
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-11.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-11.c
new file mode 100644
index 0000000..a62eee8
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-11.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=rv64gcv_zvl1024b -mabi=lp64d -fno-schedule-insns -fno-schedule-insns2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+typedef double vnx32df __attribute__ ((vector_size (32 * 8)));
+
+/*
+** f_vnx32df:
+**   vsetvli\s+[axt][0-9]+\s*,zero,\s*e64,\s*m2,\s*ta,\s*ma
+**   ...
+**   vfmv\.v\.f\s+v[0-9]+,\s*[af]+[0-9]+
+**   ...
+**   vmv\.s\.x\s+v0,\s*[axt][0-9]+
+**   vfmerge\.vfm\s+v[0-9]+,\s*v[0-9]+,\s*[af]+[0-9]+,\s*v0
+**   vs2r\.v\s+v[0-9]+,\s*0\([axt][0-9]+\)
+**   ret
+*/
+__attribute__ ((noipa)) void
+f_vnx32df (double a, double b, double *out)
+{
+  vnx32df v = {
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+  };
+  *(vnx32df *) out = v;
+}
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-12.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-12.c
new file mode 100644
index 0000000..92cf299
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-12.c
@@ -0,0 +1,279 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=rv64gcv_zvl4096b -mabi=lp64d -fno-schedule-insns -fno-schedule-insns2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+#include <stdint-gcc.h>
+
+typedef int8_t vnx4096qi __attribute__ ((vector_size (4096)));
+
+/*
+** f_vnx4096qi:
+**   ...
+**   vsetvli\s+[axt][0-9]+,\s*zero,\s*e16,\s*m8,\s*ta,\s*ma
+**   vmv\.v\.x\s+v[0-9]+,\s*[axt][0-9]+
+**   vs8r\.v\s+v[0-9]+,\s*0\([axt][0-9]+\)
+**   ret
+*/
+__attribute__ ((noipa)) void
+f_vnx4096qi (int8_t a, int8_t b, int8_t *out)
+{
+  vnx4096qi v = {
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+  };
+  *(vnx4096qi *) out = v;
+}
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-13.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-13.c
new file mode 100644
index 0000000..e3ec3a1
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-13.c
@@ -0,0 +1,57 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=rv64gcv_zvl4096b -mabi=lp64d -fno-schedule-insns -fno-schedule-insns2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+#include <stdint-gcc.h>
+
+typedef int64_t vnx512di __attribute__ ((vector_size (512 * 8)));
+
+/*
+** f_vnx512di:
+**   ...
+**   vsetivli\s+zero,\s*8,\s*e64,\s*m1,\s*ta,\s*ma
+**   vmv\.v\.x\s+v0,[atx][0-9]+
+**   vsetvli\s+[atx][0-9]+,\s*zero,\s*e64,\s*m8,\s*ta,\s*ma
+**   vmerge\.vxm\s+v[0-9]+,\s*v[0-9]+,\s*[axt][0-9]+,\s*v0
+**   vs8r\.v\s+v[0-9]+,\s*0\([axt][0-9]+\)
+**   ret
+*/
+__attribute__ ((noipa)) void
+f_vnx512di (int64_t a, int64_t b, int64_t *out)
+{
+  vnx512di v = {
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+  };
+  *(vnx512di *) out = v;
+}
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-14.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-14.c
new file mode 100644
index 0000000..23a4ea6
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-14.c
@@ -0,0 +1,87 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=rv64gcv_zvl4096b -mabi=lp64d -fno-schedule-insns -fno-schedule-insns2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+#include <stdint-gcc.h>
+
+typedef int32_t vnx1024si __attribute__ ((vector_size (1024 * 4)));
+
+/*
+** f_vnx1024si:
+**   ...
+**   vsetvli\s+[atx][0-9]+,\s*zero,\s*e64,\s*m8,\s*ta,\s*ma
+**   vmv\.v\.x\s+v[0-9]+,\s*[axt][0-9]+
+**   vs8r\.v\s+v[0-9]+,\s*0\([axt][0-9]+\)
+**   ret
+*/
+__attribute__ ((noipa)) void
+f_vnx1024si (int32_t a, int32_t b, int32_t *out)
+{
+  vnx1024si v = {
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+  };
+  *(vnx1024si *) out = v;
+}
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-15.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-15.c
new file mode 100644
index 0000000..37c08a1
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-15.c
@@ -0,0 +1,151 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=rv64gcv_zvl4096b -mabi=lp64d -fno-schedule-insns -fno-schedule-insns2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+#include <stdint-gcc.h>
+
+typedef int16_t vnx2048hi __attribute__ ((vector_size (2048 * 2)));
+
+/*
+** f_vnx2048hi:
+**   ...
+**   vsetvli\s+[atx][0-9]+,\s*zero,\s*e32,\s*m8,\s*ta,\s*ma
+**   vmv\.v\.x\s+v[0-9]+,\s*[axt][0-9]+
+**   vs8r\.v\s+v[0-9]+,\s*0\([axt][0-9]+\)
+**   ret
+*/
+__attribute__ ((noipa)) void
+f_vnx2048hi (int16_t a, int16_t b, int16_t *out)
+{
+  vnx2048hi v = {
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+  };
+  *(vnx2048hi *) out = v;
+}
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-6.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-6.c
new file mode 100644
index 0000000..4f8a78b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-6.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=rv64gcv -mabi=lp64d -fno-schedule-insns -fno-schedule-insns2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+#include <stdint-gcc.h>
+
+typedef int64_t vnx16di __attribute__ ((vector_size (16 * 8)));
+
+/*
+** f_vnx16di:
+**   vsetivli\s+zero,\s*16,\s*e64,\s*m8,\s*ta,\s*ma
+**   ...
+**   vmv\.v\.x\s+v[0-9]+,\s*[axt][0-9]+
+**   ...
+**   vmv\.s\.x\s+v0,\s*[axt][0-9]+
+**   vmerge\.vxm\s+v[0-9]+,\s*v[0-9]+,\s*[axt][0-9]+,\s*v0
+**   vs8r\.v\s+v[0-9]+,\s*0\([axt][0-9]+\)
+**   ret
+*/
+__attribute__ ((noipa)) void
+f_vnx16di (int64_t a, int64_t b, int64_t *out)
+{
+  vnx16di v = {
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+  };
+  *(vnx16di *) out = v;
+}
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-7.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-7.c
new file mode 100644
index 0000000..f0d14db
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-7.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=rv64gcv -mabi=lp64d -fno-schedule-insns -fno-schedule-insns2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+typedef double vnx16df __attribute__ ((vector_size (16 * 8)));
+
+/*
+** f_vnx16df:
+**   vsetivli\s+zero,\s*16,\s*e64,\s*m8,\s*ta,\s*ma
+**   ...
+**   vfmv\.v\.f\s+v[0-9]+,\s*[af]+[0-9]+
+**   ...
+**   vmv\.s\.x\s+v0,\s*[axt][0-9]+
+**   vfmerge\.vfm\s+v[0-9]+,\s*v[0-9]+,\s*[af]+[0-9]+,\s*v0
+**   vs8r\.v\s+v[0-9]+,\s*0\([axt][0-9]+\)
+**   ret
+*/
+__attribute__ ((noipa)) void
+f_vnx16df (double a, double b, double *out)
+{
+  vnx16df v = {
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+  };
+  *(vnx16df *) out = v;
+}
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-8.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-8.c
new file mode 100644
index 0000000..fd986e6
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-8.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=rv64gcv_zvl1024b -mabi=lp64d -fno-schedule-insns -fno-schedule-insns2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+#include <stdint-gcc.h>
+
+typedef int64_t vnx16di __attribute__ ((vector_size (16 * 8)));
+
+/*
+** f_vnx16di:
+**   vsetivli\s+zero,\s*16,\s*e64,\s*m1,\s*ta,\s*ma
+**   ...
+**   vmv\.v\.x\s+v[0-9]+,\s*[axt][0-9]+
+**   ...
+**   vmv\.s\.x\s+v0,\s*[axt][0-9]+
+**   vmerge\.vxm\s+v[0-9]+,\s*v[0-9]+,\s*[axt][0-9]+,\s*v0
+**   vs1r\.v\s+v[0-9]+,\s*0\([axt][0-9]+\)
+**   ret
+*/
+__attribute__ ((noipa)) void
+f_vnx16di (int64_t a, int64_t b, int64_t *out)
+{
+  vnx16di v = {
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+  };
+  *(vnx16di *) out = v;
+}
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-9.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-9.c
new file mode 100644
index 0000000..753221f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/init-repeat-sequence-9.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=rv64gcv_zvl1024b -mabi=lp64d -fno-schedule-insns -fno-schedule-insns2" } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+typedef double vnx16df __attribute__ ((vector_size (16 * 8)));
+
+/*
+** f_vnx16df:
+**   vsetivli\s+zero,\s*16,\s*e64,\s*m1,\s*ta,\s*ma
+**   ...
+**   vfmv\.v\.f\s+v[0-9]+,\s*[af]+[0-9]+
+**   ...
+**   vmv\.s\.x\s+v0,\s*[axt][0-9]+
+**   vfmerge\.vfm\s+v[0-9]+,\s*v[0-9]+,\s*[af]+[0-9]+,\s*v0
+**   vs1r\.v\s+v[0-9]+,\s*0\([axt][0-9]+\)
+**   ret
+*/
+__attribute__ ((noipa)) void
+f_vnx16df (double a, double b, double *out)
+{
+  vnx16df v = {
+    a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b,
+  };
+  *(vnx16df *) out = v;
+}
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/trailing-1.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/trailing-1.c
new file mode 100644
index 0000000..b48252a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/trailing-1.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=rv64gcv -mabi=lp64d --param=riscv-autovec-lmul=m8 --param=riscv-autovec-preference=fixed-vlmax" } */
+
+#include <stdint-gcc.h>
+
+typedef int64_t v16di __attribute__ ((vector_size (128)));
+
+__attribute__ ((noipa)) void
+f_v16di (int64_t a, int64_t b, int64_t c, int64_t d, int64_t *out)
+{
+  v16di v = {a, b, c, d, d, d, d, d, d, d, d, d, d, d, d, d};
+  *(v16di *) out = v;
+}
+
+/* { dg-final { scan-assembler-times {vslide1up\.vx\tv[0-9]+,\s*v[0-9]+,\s*[a-x0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/trailing-2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/trailing-2.c
new file mode 100644
index 0000000..46d2777
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/trailing-2.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-march=rv64gcv -mabi=lp64d --param=riscv-autovec-lmul=m8 --param=riscv-autovec-preference=fixed-vlmax" } */
+
+#include <stdint-gcc.h>
+
+typedef double v16df __attribute__ ((vector_size (128)));
+
+__attribute__ ((noipa)) void
+f_v16df (double a, double b, double c, double d, double *out)
+{
+  v16df v = {a, b, c, d, d, d, d, d, d, d, d, d, d, d, d, d};
+  *(v16df *) out = v;
+}
+
+/* { dg-final { scan-assembler-times {vfslide1up\.vf\tv[0-9]+,\s*v[0-9]+,\s*[a-x0-9]+} 3 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/trailing_run-1.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/trailing_run-1.c
new file mode 100644
index 0000000..469c30d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/trailing_run-1.c
@@ -0,0 +1,42 @@
+/* { dg-do run { target { riscv_v } } } */
+/* { dg-options "--param riscv-autovec-preference=fixed-vlmax -O3 --param=riscv-autovec-lmul=m8" } */
+
+#include "trailing-1.c"
+
+int
+main ()
+{
+  int64_t a = -1789089;
+  int64_t b = 8916156;
+  int64_t c = -7789;
+  int64_t d = 9156;
+
+  int64_t v_v16di[sizeof (v16di) / sizeof (int64_t)];
+  f_v16di (a, b, c, d, v_v16di);
+
+  for (int i = 0; i < sizeof (v16di) / sizeof (int64_t); i++)
+    {
+      if (i == 0)
+	{
+	  if (v_v16di[i] != a)
+	    __builtin_abort ();
+	}
+      else if (i == 1)
+	{
+	  if (v_v16di[i] != b)
+	    __builtin_abort ();
+	}
+      else if (i == 2)
+	{
+	  if (v_v16di[i] != c)
+	    __builtin_abort ();
+	}
+      else
+	{
+	  if (v_v16di[i] != d)
+	    __builtin_abort ();
+	}
+    }
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/trailing_run-2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/trailing_run-2.c
new file mode 100644
index 0000000..cbb0b15
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls-vlmax/trailing_run-2.c
@@ -0,0 +1,42 @@
+/* { dg-do run { target { riscv_v } } } */
+/* { dg-options "--param riscv-autovec-preference=fixed-vlmax -O3 --param=riscv-autovec-lmul=m8" } */
+
+#include "trailing-2.c"
+
+int
+main ()
+{
+  double a = -1789089.4324;
+  double b = 8916156.82343;
+  double c = -7789.3423;
+  double d = 9156.955;
+
+  double v_v16df[sizeof (v16df) / sizeof (double)];
+  f_v16df (a, b, c, d, v_v16df);
+
+  for (int i = 0; i < sizeof (v16df) / sizeof (double); i++)
+    {
+      if (i == 0)
+	{
+	  if (v_v16df[i] != a)
+	    __builtin_abort ();
+	}
+      else if (i == 1)
+	{
+	  if (v_v16df[i] != b)
+	    __builtin_abort ();
+	}
+      else if (i == 2)
+	{
+	  if (v_v16df[i] != c)
+	    __builtin_abort ();
+	}
+      else
+	{
+	  if (v_v16df[i] != d)
+	    __builtin_abort ();
+	}
+    }
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/def.h b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/def.h
index 9cc3656..cb7a1c9 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/def.h
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/def.h
@@ -852,3 +852,11 @@ typedef double v512df __attribute__ ((vector_size (4096)));
     v##NUM##TYPE1 v = {__VA_ARGS__};                                           \
     *(v##NUM##TYPE1 *) out = v;                                                \
   }
+
+#define DEF_TRAILING(TYPE1, TYPE2, NUM, ...)                                   \
+  void init_##TYPE1##_##TYPE2##_##NUM (TYPE2 var0, TYPE2 var1, TYPE2 var2,     \
+				       TYPE2 var3, TYPE2 *__restrict out)      \
+  {                                                                            \
+    TYPE1 v = {__VA_ARGS__};                                                   \
+    *(TYPE1 *) out = v;                                                        \
+  }
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-2.c
index f27c395..ae31e22 100644
--- a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-2.c
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-2.c
@@ -45,4 +45,4 @@ DEF_INIT (v128uhi, uint16_t, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
 	  113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126,
 	  127)
 
-/* { dg-final { scan-assembler-times {vid\.vx} 494 } } */
+/* { dg-final { scan-assembler-times {vid\.v} 14 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-0.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-0.c
new file mode 100644
index 0000000..9bb21d7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-0.c
@@ -0,0 +1,654 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv_zvfh_zvl4096b -mabi=lp64d -O3 --param=riscv-autovec-lmul=m8" } */
+
+#include "def.h"
+
+DEF_REPEAT (v4qi, int8_t, 4, var0, var1, var0, var1)
+DEF_REPEAT (v8qi, int8_t, 8, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (v16qi, int8_t, 16, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (v32qi, int8_t, 32, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1)
+DEF_REPEAT (v64qi, int8_t, 64, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1)
+DEF_REPEAT (v128qi, int8_t, 128, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v256qi, int8_t, 256, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v512qi, int8_t, 512, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v1024qi, int8_t, 1024, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1)
+DEF_REPEAT (
+  v2048qi, int8_t, 2048, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v4096qi, int8_t, 4096, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1)
+
+/* { dg-final { scan-assembler-times {vmv\.v\.x} 11 } } */
+/* { dg-final { scan-assembler-not {vmv1r\.v\s+v0,\s*v[0-9]+} } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-1.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-1.c
new file mode 100644
index 0000000..e5934ac
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-1.c
@@ -0,0 +1,654 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv_zvfh_zvl4096b -mabi=lp64d -O3 --param=riscv-autovec-lmul=m8" } */
+
+#include "def.h"
+
+DEF_REPEAT (v4uqi, uint8_t, 4, var0, var1, var0, var1)
+DEF_REPEAT (v8uqi, uint8_t, 8, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (v16uqi, uint8_t, 16, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (v32uqi, uint8_t, 32, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1)
+DEF_REPEAT (v64uqi, uint8_t, 64, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1)
+DEF_REPEAT (v128uqi, uint8_t, 128, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v256uqi, uint8_t, 256, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v512uqi, uint8_t, 512, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v1024uqi, uint8_t, 1024, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1)
+DEF_REPEAT (
+  v2048uqi, uint8_t, 2048, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v4096uqi, uint8_t, 4096, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1)
+
+/* { dg-final { scan-assembler-times {vmv\.v\.x} 11 } } */
+/* { dg-final { scan-assembler-not {vmv1r\.v\s+v0,\s*v[0-9]+} } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-2.c
new file mode 100644
index 0000000..7b30e2b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-2.c
@@ -0,0 +1,337 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv_zvfh_zvl4096b -mabi=lp64d -O3 --param=riscv-autovec-lmul=m8" } */
+
+#include "def.h"
+
+DEF_REPEAT (v4hi, int16_t, 4, var0, var1, var0, var1)
+DEF_REPEAT (v8hi, int16_t, 8, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (v16hi, int16_t, 16, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (v32hi, int16_t, 32, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1)
+DEF_REPEAT (v64hi, int16_t, 64, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1)
+DEF_REPEAT (v128hi, int16_t, 128, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v256hi, int16_t, 256, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v512hi, int16_t, 512, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v1024hi, int16_t, 1024, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1)
+DEF_REPEAT (
+  v2048hi, int16_t, 2048, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+
+/* { dg-final { scan-assembler-times {vmv\.v\.x} 10 } } */
+/* { dg-final { scan-assembler-not {vmv1r\.v\s+v0,\s*v[0-9]+} } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-3.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-3.c
new file mode 100644
index 0000000..d3efc9a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-3.c
@@ -0,0 +1,337 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv_zvfh_zvl4096b -mabi=lp64d -O3 --param=riscv-autovec-lmul=m8" } */
+
+#include "def.h"
+
+DEF_REPEAT (v4uhi, uint16_t, 4, var0, var1, var0, var1)
+DEF_REPEAT (v8uhi, uint16_t, 8, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (v16uhi, uint16_t, 16, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (v32uhi, uint16_t, 32, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1)
+DEF_REPEAT (v64uhi, uint16_t, 64, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1)
+DEF_REPEAT (v128uhi, uint16_t, 128, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v256uhi, uint16_t, 256, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v512uhi, uint16_t, 512, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v1024uhi, uint16_t, 1024, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1)
+DEF_REPEAT (
+  v2048uhi, uint16_t, 2048, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+
+/* { dg-final { scan-assembler-times {vmv\.v\.x} 10 } } */
+/* { dg-final { scan-assembler-not {vmv1r\.v\s+v0,\s*v[0-9]+} } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-4.c
new file mode 100644
index 0000000..a9d1e87
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-4.c
@@ -0,0 +1,178 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv_zvfh_zvl4096b -mabi=lp64d -O3 --param=riscv-autovec-lmul=m8" } */
+
+#include "def.h"
+
+DEF_REPEAT (v4si, int32_t, 4, var0, var1, var0, var1)
+DEF_REPEAT (v8si, int32_t, 8, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (v16si, int32_t, 16, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (v32si, int32_t, 32, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1)
+DEF_REPEAT (v64si, int32_t, 64, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1)
+DEF_REPEAT (v128si, int32_t, 128, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v256si, int32_t, 256, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v512si, int32_t, 512, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v1024si, int32_t, 1024, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1)
+
+/* { dg-final { scan-assembler-times {vmv\.v\.x} 9 } } */
+/* { dg-final { scan-assembler-not {vmv1r\.v\s+v0,\s*v[0-9]+} } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-5.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-5.c
new file mode 100644
index 0000000..b528c80
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-5.c
@@ -0,0 +1,178 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv_zvfh_zvl4096b -mabi=lp64d -O3 --param=riscv-autovec-lmul=m8" } */
+
+#include "def.h"
+
+DEF_REPEAT (v4usi, uint32_t, 4, var0, var1, var0, var1)
+DEF_REPEAT (v8usi, uint32_t, 8, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (v16usi, uint32_t, 16, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (v32usi, uint32_t, 32, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1)
+DEF_REPEAT (v64usi, uint32_t, 64, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1)
+DEF_REPEAT (v128usi, uint32_t, 128, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v256usi, uint32_t, 256, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v512usi, uint32_t, 512, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v1024usi, uint32_t, 1024, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1)
+
+/* { dg-final { scan-assembler-times {vmv\.v\.x} 9 } } */
+/* { dg-final { scan-assembler-not {vmv1r\.v\s+v0,\s*v[0-9]+} } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-6.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-6.c
new file mode 100644
index 0000000..5c36d86
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-6.c
@@ -0,0 +1,55 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv_zvfh_zvl4096b -mabi=lp64d -O3 --param=riscv-autovec-lmul=m8" } */
+
+#include "def.h"
+
+DEF_REPEAT (v16di, int64_t, 16, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (v32di, int64_t, 32, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1)
+DEF_REPEAT (v64di, int64_t, 64, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1)
+DEF_REPEAT (v128di, int64_t, 128, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v256di, int64_t, 256, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+
+/* { dg-final { scan-assembler-times {vmv\.v\.x\s+v0,\s*[atx][0-9]+} 2 } } */
+/* { dg-final { scan-assembler-times {vmv\.s\.x\s+v0,\s*[atx][0-9]+} 3 } } */
+/* { dg-final { scan-assembler-not {vmv1r\.v\s+v0,\s*v[0-9]+} } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-7.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-7.c
new file mode 100644
index 0000000..1087b60
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-7.c
@@ -0,0 +1,337 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv_zvfh_zvl4096b -mabi=lp64d -O3 --param=riscv-autovec-lmul=m8" } */
+
+#include "def.h"
+
+DEF_REPEAT (v4hf, _Float16, 4, var0, var1, var0, var1)
+DEF_REPEAT (v8hf, _Float16, 8, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (v16hf, _Float16, 16, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (v32hf, _Float16, 32, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1)
+DEF_REPEAT (v64hf, _Float16, 64, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1)
+DEF_REPEAT (v128hf, _Float16, 128, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v256hf, _Float16, 256, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v512hf, _Float16, 512, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v1024hf, _Float16, 1024, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1)
+DEF_REPEAT (
+  v2048hf, _Float16, 2048, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+
+/* { dg-final { scan-assembler-times {vmv\.v\.x} 10 } } */
+/* { dg-final { scan-assembler-not {vmv1r\.v\s+v0,\s*v[0-9]+} } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-8.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-8.c
new file mode 100644
index 0000000..f0d40df
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/init-repeat-sequence-8.c
@@ -0,0 +1,178 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv_zvfh_zvl4096b -mabi=lp64d -O3 --param=riscv-autovec-lmul=m8" } */
+
+#include "def.h"
+
+DEF_REPEAT (v4sf, float, 4, var0, var1, var0, var1)
+DEF_REPEAT (v8sf, float, 8, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (v16sf, float, 16, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (v32sf, float, 32, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1)
+DEF_REPEAT (v64sf, float, 64, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1)
+DEF_REPEAT (v128sf, float, 128, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+	    var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+	    var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v256sf, float, 256, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v512sf, float, 512, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1)
+DEF_REPEAT (
+  v1024sf, float, 1024, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1,
+  var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0, var1, var0,
+  var1)
+
+/* { dg-final { scan-assembler-times {vmv\.v\.x} 9 } } */
+/* { dg-final { scan-assembler-not {vmv1r\.v\s+v0,\s*v[0-9]+} } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-1.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-1.c
new file mode 100644
index 0000000..ed15a12
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-1.c
@@ -0,0 +1,652 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv_zvfh_zvl4096b -mabi=lp64d -O3 --param=riscv-autovec-lmul=m8" } */
+
+#include "def.h"
+
+DEF_TRAILING (v8qi, int8_t, 8, var0, var1, var2, var3, var3, var3, var3, var3)
+DEF_TRAILING (v16qi, int8_t, 16, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (v32qi, int8_t, 32, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3)
+DEF_TRAILING (v64qi, int8_t, 64, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3)
+DEF_TRAILING (v128qi, int8_t, 128, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (
+  v256qi, int8_t, 256, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (
+  v512qi, int8_t, 512, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (
+  v1024qi, int8_t, 1024, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3)
+DEF_TRAILING (
+  v2048qi, int8_t, 2048, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (
+  v4096qi, int8_t, 4096, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3)
+
+/* { dg-final { scan-assembler-times {vslide1up\.vx} 30 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-2.c
new file mode 100644
index 0000000..5deb097
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-2.c
@@ -0,0 +1,335 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv_zvfh_zvl4096b -mabi=lp64d -O3 --param=riscv-autovec-lmul=m8" } */
+
+#include "def.h"
+
+DEF_TRAILING (v8hi, int16_t, 8, var0, var1, var2, var3, var3, var3, var3, var3)
+DEF_TRAILING (v16hi, int16_t, 16, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (v32hi, int16_t, 32, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3)
+DEF_TRAILING (v64hi, int16_t, 64, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3)
+DEF_TRAILING (v128hi, int16_t, 128, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (
+  v256hi, int16_t, 256, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (
+  v512hi, int16_t, 512, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (
+  v1024hi, int16_t, 1024, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3)
+DEF_TRAILING (
+  v2048hi, int16_t, 2048, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3)
+
+/* { dg-final { scan-assembler-times {vslide1up\.vx} 27 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-3.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-3.c
new file mode 100644
index 0000000..e503d6c
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-3.c
@@ -0,0 +1,176 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv_zvfh_zvl4096b -mabi=lp64d -O3 --param=riscv-autovec-lmul=m8" } */
+
+#include "def.h"
+
+DEF_TRAILING (v8si, int32_t, 8, var0, var1, var2, var3, var3, var3, var3, var3)
+DEF_TRAILING (v16si, int32_t, 16, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (v32si, int32_t, 32, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3)
+DEF_TRAILING (v64si, int32_t, 64, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3)
+DEF_TRAILING (v128si, int32_t, 128, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (
+  v256si, int32_t, 256, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (
+  v512si, int32_t, 512, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (
+  v1024si, int32_t, 1024, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3)
+
+/* { dg-final { scan-assembler-times {vslide1up\.vx} 24 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-4.c
new file mode 100644
index 0000000..c794564
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-4.c
@@ -0,0 +1,96 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv_zvfh_zvl4096b -mabi=lp64d -O3 --param=riscv-autovec-lmul=m8" } */
+
+#include "def.h"
+
+DEF_TRAILING (v8di, int64_t, 8, var0, var1, var2, var3, var3, var3, var3, var3)
+DEF_TRAILING (v16di, int64_t, 16, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (v32di, int64_t, 32, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3)
+DEF_TRAILING (v64di, int64_t, 64, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3)
+DEF_TRAILING (v128di, int64_t, 128, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (
+  v256di, int64_t, 256, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (
+  v512di, int64_t, 512, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3)
+
+
+/* { dg-final { scan-assembler-times {vslide1up\.vx} 21 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-5.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-5.c
new file mode 100644
index 0000000..43e1792
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-5.c
@@ -0,0 +1,335 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv_zvfh_zvl4096b -mabi=lp64d -O3 --param=riscv-autovec-lmul=m8" } */
+
+#include "def.h"
+
+DEF_TRAILING (v8hf, _Float16, 8, var0, var1, var2, var3, var3, var3, var3, var3)
+DEF_TRAILING (v16hf, _Float16, 16, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (v32hf, _Float16, 32, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3)
+DEF_TRAILING (v64hf, _Float16, 64, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3)
+DEF_TRAILING (v128hf, _Float16, 128, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (
+  v256hf, _Float16, 256, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (
+  v512hf, _Float16, 512, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (
+  v1024hf, _Float16, 1024, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3)
+DEF_TRAILING (
+  v2048hf, _Float16, 2048, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3)
+
+/* { dg-final { scan-assembler-times {vfslide1up\.vf} 27 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-6.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-6.c
new file mode 100644
index 0000000..bb91c6a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-6.c
@@ -0,0 +1,176 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv_zvfh_zvl4096b -mabi=lp64d -O3 --param=riscv-autovec-lmul=m8" } */
+
+#include "def.h"
+
+DEF_TRAILING (v8sf, float, 8, var0, var1, var2, var3, var3, var3, var3, var3)
+DEF_TRAILING (v16sf, float, 16, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (v32sf, float, 32, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3)
+DEF_TRAILING (v64sf, float, 64, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3)
+DEF_TRAILING (v128sf, float, 128, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (
+  v256sf, float, 256, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (
+  v512sf, float, 512, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (
+  v1024sf, float, 1024, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3)
+
+/* { dg-final { scan-assembler-times {vfslide1up\.vf} 24 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-7.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-7.c
new file mode 100644
index 0000000..b12f08d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/vls/trailing-7.c
@@ -0,0 +1,96 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gcv_zvfh_zvl4096b -mabi=lp64d -O3 --param=riscv-autovec-lmul=m8" } */
+
+#include "def.h"
+
+DEF_TRAILING (v8df, double, 8, var0, var1, var2, var3, var3, var3, var3, var3)
+DEF_TRAILING (v16df, double, 16, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (v32df, double, 32, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3)
+DEF_TRAILING (v64df, double, 64, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3)
+DEF_TRAILING (v128df, double, 128, var0, var1, var2, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+	    var3, var3, var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (
+  v256df, double, 256, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3)
+DEF_TRAILING (
+  v512df, double, 512, var0, var1, var2, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3, var3,
+  var3, var3, var3, var3, var3, var3, var3, var3, var3)
+
+
+/* { dg-final { scan-assembler-times {vfslide1up\.vf} 21 } } */
diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-01.c b/gcc/testsuite/gcc.target/riscv/target-attr-01.c
new file mode 100644
index 0000000..b3f3d65
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/target-attr-01.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
+/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+
+/*
+** foo:
+**   ...
+**   sh1add\s*a0,a1,a0
+**   ...
+*/
+
+
+long foo() __attribute__((target("arch=rv64gc_zba")));
+long foo(long a, long b){
+  return a + (b * 2);
+}
+
+/*
+** bar:
+**   ...
+**   slli\s*a1,a1,1
+**   add\s*a0,a1,a0
+**   ...
+*/
+
+
+long bar(long a, long b){
+  return a + (b * 2);
+}
diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-02.c b/gcc/testsuite/gcc.target/riscv/target-attr-02.c
new file mode 100644
index 0000000..c010089
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/target-attr-02.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
+/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+
+/*
+** foo:
+**   ...
+**   sh1add\s*a0,a1,a0
+**   ...
+*/
+
+
+long foo() __attribute__((target("arch=+zba")));
+long foo(long a, long b){
+  return a + (b * 2);
+}
+
+/*
+** bar:
+**   ...
+**   slli\s*a1,a1,1
+**   add\s*a0,a1,a0
+**   ...
+*/
+
+
+long bar(long a, long b){
+  return a + (b * 2);
+}
diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-03.c b/gcc/testsuite/gcc.target/riscv/target-attr-03.c
new file mode 100644
index 0000000..b4896cb
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/target-attr-03.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
+/* { dg-options "-march=rv64gc_zba -O2 -mabi=lp64" } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+/*
+** foo:
+**   ...
+**   slli\s*a1,a1,1
+**   add\s*a0,a1,a0
+**   ...
+*/
+long foo() __attribute__((target("arch=rv64gc")));
+long foo(long a, long b){
+  return a + (b * 2);
+}
+
+/*
+** bar:
+**   ...
+**   sh1add\s*a0,a1,a0
+**   ...
+*/
+long bar(long a, long b){
+  return a + (b * 2);
+}
diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-04.c b/gcc/testsuite/gcc.target/riscv/target-attr-04.c
new file mode 100644
index 0000000..369d651
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/target-attr-04.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
+/* { dg-options "-march=rv64gc_zba -O2 -mabi=lp64 -mtune=rocket" } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+/*
+** foo:
+**   ...
+**   # tune = sifive-7-series
+**   ...
+**   slli\s*a1,a1,1
+**   add\s*a0,a1,a0
+**   ...
+*/
+long foo() __attribute__((target("cpu=sifive-u74")));
+long foo(long a, long b){
+  return a + (b * 2);
+}
+
+/*
+** bar:
+**   ...
+**   sh1add\s*a0,a1,a0
+**   ...
+*/
+long bar(long a, long b){
+  return a + (b * 2);
+}
diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-05.c b/gcc/testsuite/gcc.target/riscv/target-attr-05.c
new file mode 100644
index 0000000..c75368d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/target-attr-05.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
+/* { dg-options "-march=rv64gc_zba -O2 -mabi=lp64 -mtune=rocket" } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+/*
+** foo:
+**   ...
+**   # tune = sifive-7-series
+**   ...
+**   sh1add\s*a0,a1,a0
+**   ...
+*/
+long foo() __attribute__((target("cpu=sifive-u74;arch=rv64gc_zba")));
+long foo(long a, long b){
+  return a + (b * 2);
+}
+
+/*
+** bar:
+**   ...
+**   sh1add\s*a0,a1,a0
+**   ...
+*/
+long bar(long a, long b){
+  return a + (b * 2);
+}
diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-06.c b/gcc/testsuite/gcc.target/riscv/target-attr-06.c
new file mode 100644
index 0000000..369c95e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/target-attr-06.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
+/* { dg-options "-march=rv64gc_zba -O2 -mabi=lp64 -mtune=rocket" } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+/*
+** foo:
+**   ...
+**   # tune = sifive-5-series
+**   ...
+**   sh1add\s*a0,a1,a0
+**   ...
+*/
+long foo() __attribute__((target("cpu=sifive-u74;tune=sifive-5-series;arch=rv64gc_zba")));
+long foo(long a, long b){
+  return a + (b * 2);
+}
+
+/*
+** bar:
+**   ...
+**   sh1add\s*a0,a1,a0
+**   ...
+*/
+long bar(long a, long b){
+  return a + (b * 2);
+}
diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-07.c b/gcc/testsuite/gcc.target/riscv/target-attr-07.c
new file mode 100644
index 0000000..4ff8116
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/target-attr-07.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
+/* { dg-options "-march=rv64gc_zba -O2 -mabi=lp64 -mtune=rocket" } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+/*
+** foo:
+**   ...
+**   # tune = sifive-5-series
+**   ...
+*/
+long foo() __attribute__((target("tune=sifive-5-series")));
+long foo(long a, long b){
+  return a + (b * 2);
+}
+
+/*
+** bar:
+**   ...
+**   sh1add\s*a0,a1,a0
+**   ...
+*/
+long bar(long a, long b){
+  return a + (b * 2);
+}
diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-bad-01.c b/gcc/testsuite/gcc.target/riscv/target-attr-bad-01.c
new file mode 100644
index 0000000..91cbcaa
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/target-attr-bad-01.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
+/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */
+
+
+long foo() __attribute__((target("arch=rv64gc_zba;;"))); /* { dg-error "malformed" } */
+long foo(long a, long b){
+  return a + (b * 2);
+}
+
+long bar(long a, long b){
+  return a + (b * 2);
+}
diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-bad-02.c b/gcc/testsuite/gcc.target/riscv/target-attr-bad-02.c
new file mode 100644
index 0000000..0c838bb3
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/target-attr-bad-02.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
+/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */
+
+
+long foo() __attribute__((target("cpu=xyz-cpu"))); /* { dg-error "unknown CPU" } */
+long foo(long a, long b){
+  return a + (b * 2);
+}
+
+long bar(long a, long b){
+  return a + (b * 2);
+}
diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-bad-03.c b/gcc/testsuite/gcc.target/riscv/target-attr-bad-03.c
new file mode 100644
index 0000000..09702d1
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/target-attr-bad-03.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
+/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */
+
+
+long foo() __attribute__((target("tune=xyz-cpu"))); /* { dg-error "unknown TUNE" } */
+long foo(long a, long b){
+  return a + (b * 2);
+}
+
+long bar(long a, long b){
+  return a + (b * 2);
+}
diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-bad-04.c b/gcc/testsuite/gcc.target/riscv/target-attr-bad-04.c
new file mode 100644
index 0000000..1d9a0ff
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/target-attr-bad-04.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
+/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */
+
+
+long foo() __attribute__((target(123))); /* { dg-error "argument not a string" } */
+long foo(long a, long b){
+  return a + (b * 2);
+}
+
+long bar(long a, long b){
+  return a + (b * 2);
+}
diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-bad-05.c b/gcc/testsuite/gcc.target/riscv/target-attr-bad-05.c
new file mode 100644
index 0000000..24a81c5
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/target-attr-bad-05.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
+/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */
+
+
+long foo() __attribute__((target(""))); /* { dg-warning "empty string in attribute .target." } */
+long foo(long a, long b){
+  return a + (b * 2);
+}
+
+long bar(long a, long b){
+  return a + (b * 2);
+}
diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-bad-06.c b/gcc/testsuite/gcc.target/riscv/target-attr-bad-06.c
new file mode 100644
index 0000000..a0d6585
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/target-attr-bad-06.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
+/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */
+
+
+long foo() __attribute__((target("arch=*x"))); /* { dg-error "must start with \\+ or rv" } */
+long foo(long a, long b){
+  return a + (b * 2);
+}
+
+long bar(long a, long b){
+  return a + (b * 2);
+}
diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-bad-07.c b/gcc/testsuite/gcc.target/riscv/target-attr-bad-07.c
new file mode 100644
index 0000000..8aa8250
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/target-attr-bad-07.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
+/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */
+
+
+long foo() __attribute__((target("arch=+zbb_zba"))); /* { dg-error "extension 'zbb_zba' starts with 'z' but is unsupported standard extension" } */
+long foo(long a, long b){
+  return a + (b * 2);
+}
+
+long bar(long a, long b){
+  return a + (b * 2);
+}
diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-bad-08.c b/gcc/testsuite/gcc.target/riscv/target-attr-bad-08.c
new file mode 100644
index 0000000..68d211d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/target-attr-bad-08.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
+/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */
+
+long foo() __attribute__((target("arch=rv64gc_zba;arch=rv64gc_zba"))); /* { dg-error "arch appears more than once" } */
+long foo(long a, long b){
+  return a + (b * 2);
+}
diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-bad-09.c b/gcc/testsuite/gcc.target/riscv/target-attr-bad-09.c
new file mode 100644
index 0000000..2b6e498
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/target-attr-bad-09.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
+/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */
+
+long foo() __attribute__((target("cpu=sifive-u74;cpu=sifive-u74"))); /* { dg-error "cpu appears more than once" } */
+long foo(long a, long b){
+  return a + (b * 2);
+}
diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-bad-10.c b/gcc/testsuite/gcc.target/riscv/target-attr-bad-10.c
new file mode 100644
index 0000000..00cefa0
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/target-attr-bad-10.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
+/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */
+
+long foo() __attribute__((target("tune=sifive-u74;tune=sifive-u74"))); /* { dg-error "tune appears more than once" } */
+long foo(long a, long b){
+  return a + (b * 2);
+}
diff --git a/gcc/testsuite/gfortran.dg/coarray/caf.exp b/gcc/testsuite/gfortran.dg/coarray/caf.exp
index a10b17a..c626265 100644
--- a/gcc/testsuite/gfortran.dg/coarray/caf.exp
+++ b/gcc/testsuite/gfortran.dg/coarray/caf.exp
@@ -80,8 +80,6 @@ if [check_effective_target_libatomic_available] {
 	    set maybe_atomic_lib "[atomic_link_flags [get_multilibs]]"
 	}
     }
-    set t [get_multilibs]
-    puts "maybe al $maybe_atomic_lib ml $t"
 }
 
 # Main loop.
diff --git a/gcc/testsuite/gfortran.dg/continuation_17.f90 b/gcc/testsuite/gfortran.dg/continuation_17.f90
new file mode 100644
index 0000000..6f2b11d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/continuation_17.f90
@@ -0,0 +1,267 @@
+! { dg-do compile }
+! { dg-options -std=f2018 }
+!
+! copied from continuation_4.f90 - but use -std=f2018
+! Fortran 2018: Continuation-line limit is 255  <<< TESTED
+! Fortran 2023: Maximally 1,000,000 characters per statement (implied but no explicit continuation-line line limit)
+!
+! PR 19262  Test limit on line continuations. Test case derived form case in PR
+! by Steve Kargl.  Submitted by Jerry DeLisle  <jvdelisle@gcc.gnu.org>
+print *, &
+       "1" // & !  1  Counting in groups of 40.
+       "2" // & !  2
+       "3" // & !  3
+       "4" // & !  4
+       "5" // & !  5
+       "6" // & !  6
+       "7" // & !  7
+       "8" // & !  8
+       "9" // & !  9
+       "0" // & ! 10
+       "1" // & ! 11
+       "2" // & ! 12
+       "3" // & ! 13
+       "4" // & ! 14
+       "5" // & ! 15
+       "6" // & ! 16
+       "7" // & ! 17
+       "8" // & ! 18
+       "9" // & ! 19
+       "0" // & ! 20
+       "1" // & ! 21
+       "2" // & ! 22
+       "3" // & ! 23
+       "4" // & ! 24
+       "5" // & ! 25
+       "6" // & ! 26
+       "7" // & ! 27
+       "8" // & ! 28
+       "9" // & ! 29
+       "0" // & ! 30
+       "1" // & ! 31
+       "2" // & ! 32
+       "3" // & ! 33
+       "4" // & ! 34
+       "5" // & ! 35
+       "6" // & ! 36
+       "7" // & ! 37
+       "8" // & ! 38
+       "9" // & ! 39
+       "0" // & ! 40
+       "1" // & !  1
+       "2" // & !  2
+       "3" // & !  3
+       "4" // & !  4
+       "5" // & !  5
+       "6" // & !  6
+       "7" // & !  7
+       "8" // & !  8
+       "9" // & !  9
+       "0" // & ! 10
+       "1" // & ! 11
+       "2" // & ! 12
+       "3" // & ! 13
+       "4" // & ! 14
+       "5" // & ! 15
+       "6" // & ! 16
+       "7" // & ! 17
+       "8" // & ! 18
+       "9" // & ! 19
+       "0" // & ! 20
+       "1" // & ! 21
+       "2" // & ! 22
+       "3" // & ! 23
+       "4" // & ! 24
+       "5" // & ! 25
+       "6" // & ! 26
+       "7" // & ! 27
+       "8" // & ! 28
+       "9" // & ! 29
+       "0" // & ! 30
+       "1" // & ! 31
+       "2" // & ! 32
+       "3" // & ! 33
+       "4" // & ! 34
+       "5" // & ! 35
+       "6" // & ! 36
+       "7" // & ! 37
+       "8" // & ! 38
+       "9" // & ! 39
+       "0" // & ! 80
+       "1" // & !  1
+       "2" // & !  2
+       "3" // & !  3
+       "4" // & !  4
+       "5" // & !  5
+       "6" // & !  6
+       "7" // & !  7
+       "8" // & !  8
+       "9" // & !  9
+       "0" // & ! 10
+       "1" // & ! 11
+       "2" // & ! 12
+       "3" // & ! 13
+       "4" // & ! 14
+       "5" // & ! 15
+       "6" // & ! 16
+       "7" // & ! 17
+       "8" // & ! 18
+       "9" // & ! 19
+       "0" // & ! 20
+       "1" // & ! 21
+       "2" // & ! 22
+       "3" // & ! 23
+       "4" // & ! 24
+       "5" // & ! 25
+       "6" // & ! 26
+       "7" // & ! 27
+       "8" // & ! 28
+       "9" // & ! 29
+       "0" // & ! 30
+       "1" // & ! 31
+       "2" // & ! 32
+       "3" // & ! 33
+       "4" // & ! 34
+       "5" // & ! 35
+       "6" // & ! 36
+       "7" // & ! 37
+       "8" // & ! 38
+       "9" // & ! 39
+       "0" // & ! 120
+       "1" // & !  1
+       "2" // & !  2
+       "3" // & !  3
+       "4" // & !  4
+       "5" // & !  5
+       "6" // & !  6
+       "7" // & !  7
+       "8" // & !  8
+       "9" // & !  9
+       "0" // & ! 10
+       "1" // & ! 11
+       "2" // & ! 12
+       "3" // & ! 13
+       "4" // & ! 14
+       "5" // & ! 15
+       "6" // & ! 16
+       "7" // & ! 17
+       "8" // & ! 18
+       "9" // & ! 19
+       "0" // & ! 20
+       "1" // & ! 21
+       "2" // & ! 22
+       "3" // & ! 23
+       "4" // & ! 24
+       "5" // & ! 25
+       "6" // & ! 26
+       "7" // & ! 27
+       "8" // & ! 28
+       "9" // & ! 29
+       "0" // & ! 30
+       "1" // & ! 31
+       "2" // & ! 32
+       "3" // & ! 33
+       "4" // & ! 34
+       "5" // & ! 35
+       "6" // & ! 36
+       "7" // & ! 37
+       "8" // & ! 38
+       "9" // & ! 39
+       "0" // & ! 160
+       "1" // & !  1
+       "2" // & !  2
+       "3" // & !  3
+       "4" // & !  4
+       "5" // & !  5
+       "6" // & !  6
+       "7" // & !  7
+       "8" // & !  8
+       "9" // & !  9
+       "0" // & ! 10
+       "1" // & ! 11
+       "2" // & ! 12
+       "3" // & ! 13
+       "4" // & ! 14
+       "5" // & ! 15
+       "6" // & ! 16
+       "7" // & ! 17
+       "8" // & ! 18
+       "9" // & ! 19
+       "0" // & ! 20
+       "1" // & ! 21
+       "2" // & ! 22
+       "3" // & ! 23
+       "4" // & ! 24
+       "5" // & ! 25
+       "6" // & ! 26
+       "7" // & ! 27
+       "8" // & ! 28
+       "9" // & ! 29
+       "0" // & ! 30
+       "1" // & ! 31
+       "2" // & ! 32
+       "3" // & ! 33
+       "4" // & ! 34
+       "5" // & ! 35
+       "6" // & ! 36
+       "7" // & ! 37
+       "8" // & ! 38
+       "9" // & ! 39
+       "0" // & ! 200
+       "1" // & !  1
+       "2" // & !  2
+       "3" // & !  3
+       "4" // & !  4
+       "5" // & !  5
+       "6" // & !  6
+       "7" // & !  7
+       "8" // & !  8
+       "9" // & !  9
+       "0" // & ! 10
+       "1" // & ! 11
+       "2" // & ! 12
+       "3" // & ! 13
+       "4" // & ! 14
+       "5" // & ! 15
+       "6" // & ! 16
+       "7" // & ! 17
+       "8" // & ! 18
+       "9" // & ! 19
+       "0" // & ! 20
+       "1" // & ! 21
+       "2" // & ! 22
+       "3" // & ! 23
+       "4" // & ! 24
+       "5" // & ! 25
+       "6" // & ! 26
+       "7" // & ! 27
+       "8" // & ! 28
+       "9" // & ! 29
+       "0" // & ! 30
+       "1" // & ! 31
+       "2" // & ! 32
+       "3" // & ! 33
+       "4" // & ! 34
+       "5" // & ! 35
+       "6" // & ! 36
+       "7" // & ! 37
+       "8" // & ! 38
+       "9" // & ! 39
+       "0" // & ! 240
+       "1" // & !  1
+       "2" // & !  2
+       "3" // & !  3
+       "4" // & !  4
+       "5" // & !  5
+       "6" // & !  6
+       "7" // & !  7
+       "8" // & !  8
+       "9" // & !  9
+       "0" // & ! 10
+       "1" // & ! 11
+       "2" // & ! 12
+       "3" // & ! 13
+       "4" // & ! 14
+       "5" // & ! 255
+       "0"      ! { dg-warning "Limit of 255 continuations exceeded" }
+end
diff --git a/gcc/testsuite/gfortran.dg/continuation_18.f90 b/gcc/testsuite/gfortran.dg/continuation_18.f90
new file mode 100644
index 0000000..7ad887d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/continuation_18.f90
@@ -0,0 +1,267 @@
+! { dg-do compile }
+! { dg-options -std=f2023 }
+!
+! copied from continuation_4.f90 - but use -std=f2023
+! Fortran 2018: Continuation-line limit is 255
+! Fortran 2023: Maximally 1,000,000 characters per statement (implied but no explicit continuation-line line limit)  <<< TESTED
+!
+! PR 19262  Test limit on line continuations. Test case derived form case in PR
+! by Steve Kargl.  Submitted by Jerry DeLisle  <jvdelisle@gcc.gnu.org>
+print *, &
+       "1" // & !  1  Counting in groups of 40.
+       "2" // & !  2
+       "3" // & !  3
+       "4" // & !  4
+       "5" // & !  5
+       "6" // & !  6
+       "7" // & !  7
+       "8" // & !  8
+       "9" // & !  9
+       "0" // & ! 10
+       "1" // & ! 11
+       "2" // & ! 12
+       "3" // & ! 13
+       "4" // & ! 14
+       "5" // & ! 15
+       "6" // & ! 16
+       "7" // & ! 17
+       "8" // & ! 18
+       "9" // & ! 19
+       "0" // & ! 20
+       "1" // & ! 21
+       "2" // & ! 22
+       "3" // & ! 23
+       "4" // & ! 24
+       "5" // & ! 25
+       "6" // & ! 26
+       "7" // & ! 27
+       "8" // & ! 28
+       "9" // & ! 29
+       "0" // & ! 30
+       "1" // & ! 31
+       "2" // & ! 32
+       "3" // & ! 33
+       "4" // & ! 34
+       "5" // & ! 35
+       "6" // & ! 36
+       "7" // & ! 37
+       "8" // & ! 38
+       "9" // & ! 39
+       "0" // & ! 40
+       "1" // & !  1
+       "2" // & !  2
+       "3" // & !  3
+       "4" // & !  4
+       "5" // & !  5
+       "6" // & !  6
+       "7" // & !  7
+       "8" // & !  8
+       "9" // & !  9
+       "0" // & ! 10
+       "1" // & ! 11
+       "2" // & ! 12
+       "3" // & ! 13
+       "4" // & ! 14
+       "5" // & ! 15
+       "6" // & ! 16
+       "7" // & ! 17
+       "8" // & ! 18
+       "9" // & ! 19
+       "0" // & ! 20
+       "1" // & ! 21
+       "2" // & ! 22
+       "3" // & ! 23
+       "4" // & ! 24
+       "5" // & ! 25
+       "6" // & ! 26
+       "7" // & ! 27
+       "8" // & ! 28
+       "9" // & ! 29
+       "0" // & ! 30
+       "1" // & ! 31
+       "2" // & ! 32
+       "3" // & ! 33
+       "4" // & ! 34
+       "5" // & ! 35
+       "6" // & ! 36
+       "7" // & ! 37
+       "8" // & ! 38
+       "9" // & ! 39
+       "0" // & ! 80
+       "1" // & !  1
+       "2" // & !  2
+       "3" // & !  3
+       "4" // & !  4
+       "5" // & !  5
+       "6" // & !  6
+       "7" // & !  7
+       "8" // & !  8
+       "9" // & !  9
+       "0" // & ! 10
+       "1" // & ! 11
+       "2" // & ! 12
+       "3" // & ! 13
+       "4" // & ! 14
+       "5" // & ! 15
+       "6" // & ! 16
+       "7" // & ! 17
+       "8" // & ! 18
+       "9" // & ! 19
+       "0" // & ! 20
+       "1" // & ! 21
+       "2" // & ! 22
+       "3" // & ! 23
+       "4" // & ! 24
+       "5" // & ! 25
+       "6" // & ! 26
+       "7" // & ! 27
+       "8" // & ! 28
+       "9" // & ! 29
+       "0" // & ! 30
+       "1" // & ! 31
+       "2" // & ! 32
+       "3" // & ! 33
+       "4" // & ! 34
+       "5" // & ! 35
+       "6" // & ! 36
+       "7" // & ! 37
+       "8" // & ! 38
+       "9" // & ! 39
+       "0" // & ! 120
+       "1" // & !  1
+       "2" // & !  2
+       "3" // & !  3
+       "4" // & !  4
+       "5" // & !  5
+       "6" // & !  6
+       "7" // & !  7
+       "8" // & !  8
+       "9" // & !  9
+       "0" // & ! 10
+       "1" // & ! 11
+       "2" // & ! 12
+       "3" // & ! 13
+       "4" // & ! 14
+       "5" // & ! 15
+       "6" // & ! 16
+       "7" // & ! 17
+       "8" // & ! 18
+       "9" // & ! 19
+       "0" // & ! 20
+       "1" // & ! 21
+       "2" // & ! 22
+       "3" // & ! 23
+       "4" // & ! 24
+       "5" // & ! 25
+       "6" // & ! 26
+       "7" // & ! 27
+       "8" // & ! 28
+       "9" // & ! 29
+       "0" // & ! 30
+       "1" // & ! 31
+       "2" // & ! 32
+       "3" // & ! 33
+       "4" // & ! 34
+       "5" // & ! 35
+       "6" // & ! 36
+       "7" // & ! 37
+       "8" // & ! 38
+       "9" // & ! 39
+       "0" // & ! 160
+       "1" // & !  1
+       "2" // & !  2
+       "3" // & !  3
+       "4" // & !  4
+       "5" // & !  5
+       "6" // & !  6
+       "7" // & !  7
+       "8" // & !  8
+       "9" // & !  9
+       "0" // & ! 10
+       "1" // & ! 11
+       "2" // & ! 12
+       "3" // & ! 13
+       "4" // & ! 14
+       "5" // & ! 15
+       "6" // & ! 16
+       "7" // & ! 17
+       "8" // & ! 18
+       "9" // & ! 19
+       "0" // & ! 20
+       "1" // & ! 21
+       "2" // & ! 22
+       "3" // & ! 23
+       "4" // & ! 24
+       "5" // & ! 25
+       "6" // & ! 26
+       "7" // & ! 27
+       "8" // & ! 28
+       "9" // & ! 29
+       "0" // & ! 30
+       "1" // & ! 31
+       "2" // & ! 32
+       "3" // & ! 33
+       "4" // & ! 34
+       "5" // & ! 35
+       "6" // & ! 36
+       "7" // & ! 37
+       "8" // & ! 38
+       "9" // & ! 39
+       "0" // & ! 200
+       "1" // & !  1
+       "2" // & !  2
+       "3" // & !  3
+       "4" // & !  4
+       "5" // & !  5
+       "6" // & !  6
+       "7" // & !  7
+       "8" // & !  8
+       "9" // & !  9
+       "0" // & ! 10
+       "1" // & ! 11
+       "2" // & ! 12
+       "3" // & ! 13
+       "4" // & ! 14
+       "5" // & ! 15
+       "6" // & ! 16
+       "7" // & ! 17
+       "8" // & ! 18
+       "9" // & ! 19
+       "0" // & ! 20
+       "1" // & ! 21
+       "2" // & ! 22
+       "3" // & ! 23
+       "4" // & ! 24
+       "5" // & ! 25
+       "6" // & ! 26
+       "7" // & ! 27
+       "8" // & ! 28
+       "9" // & ! 29
+       "0" // & ! 30
+       "1" // & ! 31
+       "2" // & ! 32
+       "3" // & ! 33
+       "4" // & ! 34
+       "5" // & ! 35
+       "6" // & ! 36
+       "7" // & ! 37
+       "8" // & ! 38
+       "9" // & ! 39
+       "0" // & ! 240
+       "1" // & !  1
+       "2" // & !  2
+       "3" // & !  3
+       "4" // & !  4
+       "5" // & !  5
+       "6" // & !  6
+       "7" // & !  7
+       "8" // & !  8
+       "9" // & !  9
+       "0" // & ! 10
+       "1" // & ! 11
+       "2" // & ! 12
+       "3" // & ! 13
+       "4" // & ! 14
+       "5" // & ! 255
+       "0" ! No warning with -std=f2023
+end
diff --git a/gcc/testsuite/gfortran.dg/continuation_19.f b/gcc/testsuite/gfortran.dg/continuation_19.f
new file mode 100644
index 0000000..2b32a33
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/continuation_19.f
@@ -0,0 +1,267 @@
+! { dg-do run }
+! { dg-options "-std=f2023" }
+
+      implicit none
+      integer :: x
+
+      ! 256 continuation lines - but less than 1,000,000 character
+      ! => Valid since Fortran 2023
+      x =
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+     & + 2
+
+      end
diff --git a/gcc/testsuite/gfortran.dg/dg.exp b/gcc/testsuite/gfortran.dg/dg.exp
index 73541ea..253c0f5 100644
--- a/gcc/testsuite/gfortran.dg/dg.exp
+++ b/gcc/testsuite/gfortran.dg/dg.exp
@@ -67,8 +67,6 @@ if [check_effective_target_libatomic_available] {
     } else {
         set maybe_atomic_lib ""
     }
-  set t [get_multilibs]
-  puts "dg set al $maybe_atomic_lib ml $t"
 }
 
 set all_flags $DEFAULT_FFLAGS
@@ -78,8 +76,6 @@ if { $maybe_atomic_lib != "" } {
    }
 }
 
-puts "revised FFLAGS $all_flags"
-
 # Main loop.
 gfortran-dg-runtest [lsort \
        [glob -nocomplain $srcdir/$subdir/*.\[fF\]{,90,95,03,08} ] ] "" $all_flags
diff --git a/gcc/testsuite/gfortran.dg/goacc/warn_truncated.f90 b/gcc/testsuite/gfortran.dg/goacc/warn_truncated.f90
index 15ef3f5..101e026 100644
--- a/gcc/testsuite/gfortran.dg/goacc/warn_truncated.f90
+++ b/gcc/testsuite/gfortran.dg/goacc/warn_truncated.f90
@@ -1,4 +1,5 @@
 ! { dg-do compile }
+! { dg-additional-options "-std=f2018" }
 ! PR fortran/97390
 !
 integer :: tempRbuffer, array, compactHaloInfo, dimsizes, nHaloLayers, gpu_nList_send, gpu_idx_send, gpu_bufferOffset_send, counter
diff --git a/gcc/testsuite/gfortran.dg/gomp/warn_truncated.f90 b/gcc/testsuite/gfortran.dg/gomp/warn_truncated.f90
index 86d7eb2..20cd044 100644
--- a/gcc/testsuite/gfortran.dg/gomp/warn_truncated.f90
+++ b/gcc/testsuite/gfortran.dg/gomp/warn_truncated.f90
@@ -1,4 +1,5 @@
 ! { dg-do compile }
+! { dg-additional-options "-std=f2018" }
 !
 ! PR fortran/94709
 !
diff --git a/gcc/testsuite/gfortran.dg/line_length_10.f90 b/gcc/testsuite/gfortran.dg/line_length_10.f90
index 390e9a1..c244172 100644
--- a/gcc/testsuite/gfortran.dg/line_length_10.f90
+++ b/gcc/testsuite/gfortran.dg/line_length_10.f90
@@ -1,5 +1,5 @@
 ! { dg-do compile }
-! { dg-options "-Wno-line-truncation" }
+! { dg-options "-std=f2018 -Wno-line-truncation" }
 !
 ! By default, for free-form source code: Error out
 ! But due to the explicit -Wno-line-truncation, compile w/o warning
diff --git a/gcc/testsuite/gfortran.dg/line_length_11.f90 b/gcc/testsuite/gfortran.dg/line_length_11.f90
index 67f1e29..2125f54 100644
--- a/gcc/testsuite/gfortran.dg/line_length_11.f90
+++ b/gcc/testsuite/gfortran.dg/line_length_11.f90
@@ -1,5 +1,5 @@
 ! { dg-do compile }
-! { dg-options "-Wno-all" }
+! { dg-options "-Wno-all -std=f2018" }
 !
 ! By default, for free-form source code: Error out
 ! But due to the explicit -Wno-all, compile w/o warning
diff --git a/gcc/testsuite/gfortran.dg/line_length_12.f90 b/gcc/testsuite/gfortran.dg/line_length_12.f90
new file mode 100644
index 0000000..c8a935a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/line_length_12.f90
@@ -0,0 +1,31 @@
+! { dg-do compile }
+! { dg-additional-options "-std=f2018" }
+! { dg-prune-output "some warnings being treated as errors" }
+!
+! In Fortran 2018, the linelength is    132 characters.   <<<  Test this.
+! In Fortran 2023, the linelength is 10,000 characters.
+
+implicit none
+integer :: a, b, c, d
+
+a =  & ! The next line has 9,999 characters -> OK
+   1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3        +4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 + 42
+
+! { dg-error "Line truncated at .1. \\\[-Werror=line-truncation\\\]" "" { target *-*-* } .-2 }
+
+b =  & ! The next line has 10,000 characters -> OK
+   1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3        +4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +  42
+
+! { dg-error "Line truncated at .1. \\\[-Werror=line-truncation\\\]" "" { target *-*-* } .-2 }
+
+c =  & ! The next line has 10,001 characters -> TOO LONG
+   1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3        +4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 + 4242
+
+! { dg-error "Line truncated at .1. \\\[-Werror=line-truncation\\\]" "" { target *-*-* } .-2 }
+
+d =  & ! The next line has 10,002 characters -> TOO LONG
+   1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3        +4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 + 42424
+
+! { dg-error "Line truncated at .1. \\\[-Werror=line-truncation\\\]" "" { target *-*-* } .-2 }
+
+end 
diff --git a/gcc/testsuite/gfortran.dg/line_length_13.f90 b/gcc/testsuite/gfortran.dg/line_length_13.f90
new file mode 100644
index 0000000..861eeb9
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/line_length_13.f90
@@ -0,0 +1,27 @@
+! { dg-do compile }
+! { dg-additional-options "-std=f2023" }
+! { dg-prune-output "some warnings being treated as errors" }
+!
+! In Fortran 2018, the linelength is    132 characters.
+! In Fortran 2023, the linelength is 10,000 characters.   <<<  Test this.
+
+implicit none
+integer :: a, b, c, d
+
+a =  & ! The next line has 9,999 characters -> OK
+   1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3        +4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 + 42
+
+b =  & ! The next line has 10,000 characters -> OK
+   1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3        +4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +  42
+
+c =  & ! The next line has 10,001 characters -> TOO LONG
+   1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3        +4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 + 4242
+
+! { dg-error "Line truncated at .1. \\\[-Werror=line-truncation\\\]" "" { target *-*-* } .-2 }
+
+d =  & ! The next line has 10,002 characters -> TOO LONG
+   1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3        +4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 +       1 +       2 +       3 +       4 +       5 +       6 +       7 +       8 +       9 +      10 + 42424
+
+! { dg-error "Line truncated at .1. \\\[-Werror=line-truncation\\\]" "" { target *-*-* } .-2 }
+
+end 
diff --git a/gcc/testsuite/gfortran.dg/line_length_2.f90 b/gcc/testsuite/gfortran.dg/line_length_2.f90
index e1ab722..ff44d88 100644
--- a/gcc/testsuite/gfortran.dg/line_length_2.f90
+++ b/gcc/testsuite/gfortran.dg/line_length_2.f90
@@ -1,7 +1,7 @@
 ! Testcase for -ffree-line-length-none
 ! See PR fortran/21302
 ! { dg-do compile }
-! { dg-options "-ffree-line-length-none" }
+! { dg-options "-ffree-line-length-none -std=f2018" }
 program two
  if (abs(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa).gt.999.d0.or.abs(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb).gt.999.d0.or.abs(cccccccccccccccccccc).gt.999.d0) THEN
  endif
diff --git a/gcc/testsuite/gfortran.dg/line_length_5.f90 b/gcc/testsuite/gfortran.dg/line_length_5.f90
index 8183245..ba9f285 100644
--- a/gcc/testsuite/gfortran.dg/line_length_5.f90
+++ b/gcc/testsuite/gfortran.dg/line_length_5.f90
@@ -1,5 +1,5 @@
 ! { dg-do compile }
-! { dg-options "-Wline-truncation" }
+! { dg-options "-std=f2018 -Wline-truncation" }
 print *, 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
 end 
 ! { dg-error "Line truncated" " " { target *-*-* } 3 }
diff --git a/gcc/testsuite/gfortran.dg/line_length_6.f90 b/gcc/testsuite/gfortran.dg/line_length_6.f90
index 8cdb0209..a88e2d2 100644
--- a/gcc/testsuite/gfortran.dg/line_length_6.f90
+++ b/gcc/testsuite/gfortran.dg/line_length_6.f90
@@ -1,5 +1,5 @@
 ! { dg-do compile }
-! { dg-options "" }
+! { dg-options "-std=f2018" }
 !
 ! By default, for free-form source code: Error out
 !
diff --git a/gcc/testsuite/gfortran.dg/line_length_7.f90 b/gcc/testsuite/gfortran.dg/line_length_7.f90
index b4ebf49..6c6d73b 100644
--- a/gcc/testsuite/gfortran.dg/line_length_7.f90
+++ b/gcc/testsuite/gfortran.dg/line_length_7.f90
@@ -1,5 +1,5 @@
 ! { dg-do compile }
-! { dg-options "-Wno-error" }
+! { dg-options "-std=f2018 -Wno-error" }
 !
 ! By default, for free-form source code: Error out
 ! But due to -Wno-error, we only expect a warning
diff --git a/gcc/testsuite/gfortran.dg/line_length_8.f90 b/gcc/testsuite/gfortran.dg/line_length_8.f90
index afd6cc2..822b09e 100644
--- a/gcc/testsuite/gfortran.dg/line_length_8.f90
+++ b/gcc/testsuite/gfortran.dg/line_length_8.f90
@@ -1,5 +1,5 @@
 ! { dg-do compile }
-! { dg-options "-Wline-truncation" }
+! { dg-options "-std=f2018 -Wline-truncation" }
 !
 ! By default, for free-form source code: Error out
 ! Even with -Wline-truncation, we still get an error
diff --git a/gcc/testsuite/gfortran.dg/line_length_9.f90 b/gcc/testsuite/gfortran.dg/line_length_9.f90
index 6c156af..9f07d9a 100644
--- a/gcc/testsuite/gfortran.dg/line_length_9.f90
+++ b/gcc/testsuite/gfortran.dg/line_length_9.f90
@@ -1,5 +1,5 @@
 ! { dg-do compile }
-! { dg-options "-Wall" }
+! { dg-options "-std=f2018 -Wall" }
 !
 ! By default, for free-form source code: Error out
 ! Even with -Wall, we still get an error
diff --git a/gcc/testsuite/gnat.dg/varsize4.adb b/gcc/testsuite/gnat.dg/varsize4.adb
new file mode 100644
index 0000000..0ea5135
--- /dev/null
+++ b/gcc/testsuite/gnat.dg/varsize4.adb
@@ -0,0 +1,20 @@
+-- { dg-do compile }
+
+package body Varsize4 is
+
+   function Func (Bytes_Read : out Natural) return Arr is
+      Ret : Arr := (others => False);
+   begin
+      Bytes_Read := 0;
+      return Ret;
+   end;
+
+   function Get return Natural is
+      Data  : Arr;
+      Bytes : Natural;
+   begin
+      Data := Func (Bytes);
+      return Bytes;
+   end;
+
+end Varsize4;
diff --git a/gcc/testsuite/gnat.dg/varsize4.ads b/gcc/testsuite/gnat.dg/varsize4.ads
new file mode 100644
index 0000000..62b673f
--- /dev/null
+++ b/gcc/testsuite/gnat.dg/varsize4.ads
@@ -0,0 +1,9 @@
+with Varsize4_Pkg;
+
+package Varsize4 is
+
+   type Arr is array (1 .. Varsize4_Pkg.F) of Boolean;
+
+   function Get return Natural;
+
+end Varsize4;
diff --git a/gcc/testsuite/gnat.dg/varsize4_pkg.ads b/gcc/testsuite/gnat.dg/varsize4_pkg.ads
new file mode 100644
index 0000000..e07a6b0
--- /dev/null
+++ b/gcc/testsuite/gnat.dg/varsize4_pkg.ads
@@ -0,0 +1,5 @@
+package Varsize4_Pkg is
+
+   function F return Natural;
+
+end Varsize4_Pkg;
diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp
index 43a040e..8777e3b 100644
--- a/gcc/testsuite/lib/target-supports.exp
+++ b/gcc/testsuite/lib/target-supports.exp
@@ -5607,9 +5607,9 @@ proc check_effective_target_arm_thumb1_cbz_ok {} {
 # Return 1 if this is an Arm target which supports the Armv6t2 extensions.
 # This can be either in Arm state or in Thumb state.
 
-proc check_effective_target_arm_arch_v6t2_hw_ok {} {
-    if [check_effective_target_arm_thumb1_ok] {
-	return [check_no_compiler_messages arm_movt object {
+proc check_effective_target_arm_arch_v6t2_hw {} {
+    if [check_effective_target_arm_arch_v6t2_ok] {
+	return [check_runtime arm_arch_v6t2 {
 	    int
 	    main (void)
 	    {
@@ -13176,6 +13176,15 @@ proc check_effective_target_loongarch_asx_hw { } {
     } "-mlasx"]
 }
 
+# Check whether LoongArch binutils supports call36 relocation.
+proc check_effective_target_loongarch_call36_support { } {
+  return [check_no_compiler_messages loongarch_call36_support object {
+/* Assembly code */
+	pcaddu18i $r1,%call36(a)
+	jirl $r1,$r1,0
+  } ""]
+}
+
 # Appends necessary Python flags to extra-tool-flags if Python.h is supported.
 # Otherwise, modifies dg-do-what.
 proc dg-require-python-h { args } {
diff --git a/gcc/timevar.cc b/gcc/timevar.cc
index a63e5c6..f89e610 100644
--- a/gcc/timevar.cc
+++ b/gcc/timevar.cc
@@ -841,12 +841,10 @@ json::object *
 make_json_for_timevar_time_def (const timevar_time_def &ttd)
 {
   json::object *obj = new json::object ();
-  obj->set ("user",
-	    new json::float_number (nanosec_to_floating_sec (ttd.user)));
-  obj->set ("sys", new json::float_number (nanosec_to_floating_sec (ttd.sys)));
-  obj->set ("wall",
-	    new json::float_number (nanosec_to_floating_sec (ttd.wall)));
-  obj->set ("ggc_mem", new json::integer_number (ttd.ggc_mem));
+  obj->set_float ("user", nanosec_to_floating_sec (ttd.user));
+  obj->set_float ("sys", nanosec_to_floating_sec (ttd.sys));
+  obj->set_float ("wall", nanosec_to_floating_sec (ttd.wall));
+  obj->set_integer ("ggc_mem", ttd.ggc_mem);
   return obj;
 }
 #undef nanosec_to_floating_sec
@@ -859,7 +857,7 @@ json::value *
 timer::timevar_def::make_json () const
 {
   json::object *timevar_obj = new json::object ();
-  timevar_obj->set ("name", new json::string (name));
+  timevar_obj->set_string ("name", name);
   timevar_obj->set ("elapsed", make_json_for_timevar_time_def (elapsed));
 
   if (children)
@@ -883,7 +881,7 @@ timer::timevar_def::make_json () const
 		continue;
 	      json::object *child_obj = new json::object;
 	      children_arr->append (child_obj);
-	      child_obj->set ("name", new json::string (i.first->name));
+	      child_obj->set_string ("name", i.first->name);
 	      child_obj->set ("elapsed",
 			      make_json_for_timevar_time_def (i.second));
 	    }
@@ -947,15 +945,15 @@ timer::make_json () const
 
     json::object *total_obj = new json::object();
     json_arr->append (total_obj);
-    total_obj->set ("name", new json::string ("TOTAL"));
+    total_obj->set_string ("name", "TOTAL");
     total_obj->set ("elapsed", make_json_for_timevar_time_def (total_elapsed));
   }
 
   if (m_jit_client_items)
     report_obj->set ("client_items", m_jit_client_items->make_json ());
 
-  report_obj->set ("CHECKING_P", new json::literal ((bool)CHECKING_P));
-  report_obj->set ("flag_checking", new json::literal ((bool)flag_checking));
+  report_obj->set_bool ("CHECKING_P", CHECKING_P);
+  report_obj->set_bool ("flag_checking", flag_checking);
 
   return report_obj;
 
diff --git a/gcc/timevar.def b/gcc/timevar.def
index d21b08c..9628223 100644
--- a/gcc/timevar.def
+++ b/gcc/timevar.def
@@ -342,6 +342,7 @@ DEFTIMEVAR (TV_ANALYZER_STATE_PURGE  , "analyzer: state purge")
 DEFTIMEVAR (TV_ANALYZER_PLAN         , "analyzer: planning")
 DEFTIMEVAR (TV_ANALYZER_SCC          , "analyzer: scc")
 DEFTIMEVAR (TV_ANALYZER_WORKLIST     , "analyzer: processing worklist")
+DEFTIMEVAR (TV_ANALYZER_INFINITE_LOOPS, "analyzer: finding infinite loops")
 DEFTIMEVAR (TV_ANALYZER_DUMP         , "analyzer: dump")
 DEFTIMEVAR (TV_ANALYZER_DIAGNOSTICS  , "analyzer: emitting diagnostics")
 DEFTIMEVAR (TV_ANALYZER_SHORTEST_PATHS, "analyzer: shortest paths")
diff --git a/gcc/toplev.cc b/gcc/toplev.cc
index d8e8978..8c3fcd3 100644
--- a/gcc/toplev.cc
+++ b/gcc/toplev.cc
@@ -715,7 +715,7 @@ init_asm_output (const char *name)
 		     "cannot open %qs for writing: %m", asm_file_name);
     }
 
-  if (!flag_syntax_only && !(global_dc->m_lang_mask & CL_LTODump))
+  if (!flag_syntax_only && !(global_dc->get_lang_mask () & CL_LTODump))
     {
       targetm.asm_out.file_start ();
 
@@ -1020,7 +1020,6 @@ general_init (const char *argv0, bool init_signals)
   /* Initialize the diagnostics reporting machinery, so option parsing
      can give warnings and errors.  */
   diagnostic_initialize (global_dc, N_OPTS);
-  global_dc->m_lang_mask = lang_hooks.option_lang_mask ();
   /* Set a default printer.  Language specific initializations will
      override it later.  */
   tree_diagnostics_defaults (global_dc);
@@ -1045,10 +1044,11 @@ general_init (const char *argv0, bool init_signals)
   global_dc->m_show_column
     = global_options_init.x_flag_show_column;
   global_dc->m_internal_error = internal_error_function;
-  global_dc->m_option_enabled = option_enabled;
-  global_dc->m_option_state = &global_options;
-  global_dc->m_option_name = option_name;
-  global_dc->m_get_option_url = get_option_url;
+  global_dc->set_option_hooks (option_enabled,
+			       &global_options,
+			       option_name,
+			       get_option_url,
+			       lang_hooks.option_lang_mask ());
   global_dc->set_urlifier (make_gcc_urlifier ());
 
   if (init_signals)
diff --git a/gcc/tree-diagnostic-path.cc b/gcc/tree-diagnostic-path.cc
index ee957cc..3cd9c21 100644
--- a/gcc/tree-diagnostic-path.cc
+++ b/gcc/tree-diagnostic-path.cc
@@ -206,7 +206,7 @@ struct event_range
 	  = linemap_client_expand_location_to_spelling_point
 	  (line_table, initial_loc, LOCATION_ASPECT_CARET);
 	if (exploc.file != LOCATION_FILE (dc->m_last_location))
-	  dc->m_text_callbacks.start_span (dc, exploc);
+	  diagnostic_start_span (dc) (dc, exploc);
       }
 
     /* If we have an UNKNOWN_LOCATION (or BUILTINS_LOCATION) as the
@@ -673,15 +673,14 @@ default_tree_make_json_for_path (diagnostic_context *context,
 			json_from_expanded_location (context,
 						     event.get_location ()));
       label_text event_text (event.get_desc (false));
-      event_obj->set ("description", new json::string (event_text.get ()));
+      event_obj->set_string ("description", event_text.get ());
       if (tree fndecl = event.get_fndecl ())
 	{
 	  const char *function
 	    = identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2));
-	  event_obj->set ("function", new json::string (function));
+	  event_obj->set_string ("function", function);
 	}
-      event_obj->set ("depth",
-		      new json::integer_number (event.get_stack_depth ()));
+      event_obj->set_integer ("depth", event.get_stack_depth ());
       path_array->append (event_obj);
     }
   return path_array;
diff --git a/gcc/tree-if-conv.cc b/gcc/tree-if-conv.cc
index 0190cf2..0bde281 100644
--- a/gcc/tree-if-conv.cc
+++ b/gcc/tree-if-conv.cc
@@ -3468,30 +3468,28 @@ ifcvt_can_hoist (class loop *loop, edge pe, gimple *stmt)
 static void
 ifcvt_hoist_invariants (class loop *loop, edge pe)
 {
+  /* Only hoist from the now unconditionally executed part of the loop.  */
+  basic_block bb = loop->header;
   gimple_stmt_iterator hoist_gsi = {};
-  unsigned int num_blocks = loop->num_nodes;
-  basic_block *body = get_loop_body (loop);
-  for (unsigned int i = 0; i < num_blocks; ++i)
-    for (gimple_stmt_iterator gsi = gsi_start_bb (body[i]); !gsi_end_p (gsi);)
-      {
-	gimple *stmt = gsi_stmt (gsi);
-	if (ifcvt_can_hoist (loop, pe, stmt))
-	  {
-	    /* Once we've hoisted one statement, insert other statements
-	       after it.  */
-	    gsi_remove (&gsi, false);
-	    if (hoist_gsi.ptr)
-	      gsi_insert_after (&hoist_gsi, stmt, GSI_NEW_STMT);
-	    else
-	      {
-		gsi_insert_on_edge_immediate (pe, stmt);
-		hoist_gsi = gsi_for_stmt (stmt);
-	      }
-	    continue;
-	  }
-	gsi_next (&gsi);
-      }
-  free (body);
+  for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
+    {
+      gimple *stmt = gsi_stmt (gsi);
+      if (ifcvt_can_hoist (loop, pe, stmt))
+	{
+	  /* Once we've hoisted one statement, insert other statements
+	     after it.  */
+	  gsi_remove (&gsi, false);
+	  if (hoist_gsi.ptr)
+	    gsi_insert_after (&hoist_gsi, stmt, GSI_NEW_STMT);
+	  else
+	    {
+	      gsi_insert_on_edge_immediate (pe, stmt);
+	      hoist_gsi = gsi_for_stmt (stmt);
+	    }
+	  continue;
+	}
+      gsi_next (&gsi);
+    }
 }
 
 /* Returns the DECL_FIELD_BIT_OFFSET of the bitfield accesse in stmt iff its
diff --git a/gcc/tree-loop-distribution.cc b/gcc/tree-loop-distribution.cc
index 8abfa99..ffca535 100644
--- a/gcc/tree-loop-distribution.cc
+++ b/gcc/tree-loop-distribution.cc
@@ -1440,7 +1440,7 @@ loop_distribution::data_dep_in_cycle_p (struct graph *rdg,
   else if (DDR_NUM_DIST_VECTS (ddr) > 1)
     return true;
   else if (DDR_REVERSED_P (ddr)
-	   || lambda_vector_zerop (DDR_DIST_VECT (ddr, 0), 1))
+	   || lambda_vector_zerop (DDR_DIST_VECT (ddr, 0), DDR_NB_LOOPS (ddr)))
     return false;
 
   return true;
diff --git a/gcc/tree-profile.cc b/gcc/tree-profile.cc
index da300d5..7d3cb1e 100644
--- a/gcc/tree-profile.cc
+++ b/gcc/tree-profile.cc
@@ -73,6 +73,41 @@ static GTY(()) tree ic_tuple_var;
 static GTY(()) tree ic_tuple_counters_field;
 static GTY(()) tree ic_tuple_callee_field;
 
+/* Types of counter update methods.
+
+   By default, the counter updates are done for a single threaded system
+   (COUNTER_UPDATE_SINGLE_THREAD).
+
+   If the user selected atomic profile counter updates
+   (-fprofile-update=atomic), then the counter updates will be done atomically
+   on a best-effort basis.  One of three methods to do the counter updates is
+   selected according to the target capabilities.
+
+   Ideally, the counter updates are done through atomic operations in hardware
+   (COUNTER_UPDATE_ATOMIC_BUILTIN).
+
+   If the target supports only 32-bit atomic increments and gcov_type_node is a
+   64-bit integer type, then for the profile edge counters the increment is
+   performed through two separate 32-bit atomic increments
+   (COUNTER_UPDATE_ATOMIC_SPLIT or COUNTER_UPDATE_ATOMIC_PARTIAL).  If the
+   target supports libatomic (targetm.have_libatomic), then other counter
+   updates are carried out by libatomic calls (COUNTER_UPDATE_ATOMIC_SPLIT).
+   If the target does not support libatomic, then the other counter updates are
+   not done atomically (COUNTER_UPDATE_ATOMIC_PARTIAL) and a warning is
+   issued.
+
+   If the target does not support atomic operations in hardware, however,  it
+   supports libatomic, then all updates are carried out by libatomic calls
+   (COUNTER_UPDATE_ATOMIC_BUILTIN).  */
+enum counter_update_method {
+  COUNTER_UPDATE_SINGLE_THREAD,
+  COUNTER_UPDATE_ATOMIC_BUILTIN,
+  COUNTER_UPDATE_ATOMIC_SPLIT,
+  COUNTER_UPDATE_ATOMIC_PARTIAL
+};
+
+static counter_update_method counter_update = COUNTER_UPDATE_SINGLE_THREAD;
+
 /* Do initialization work for the edge profiler.  */
 
 /* Add code:
@@ -235,47 +270,111 @@ gimple_init_gcov_profiler (void)
     }
 }
 
-/* Output instructions as GIMPLE trees to increment the edge
-   execution count, and insert them on E.  We rely on
-   gsi_insert_on_edge to preserve the order.  */
+/* If RESULT is not null, then output instructions as GIMPLE trees to assign
+   the updated counter from CALL of FUNC to RESULT.  Insert the CALL and the
+   optional assignment instructions to GSI.  Use NAME for temporary values.  */
 
-void
-gimple_gen_edge_profiler (int edgeno, edge e)
+static inline void
+gen_assign_counter_update (gimple_stmt_iterator *gsi, gcall *call, tree func,
+			   tree result, const char *name)
 {
-  tree one;
+  if (result)
+    {
+      tree result_type = TREE_TYPE (TREE_TYPE (func));
+      tree tmp = make_temp_ssa_name (result_type, NULL, name);
+      gimple_set_lhs (call, tmp);
+      gsi_insert_after (gsi, call, GSI_NEW_STMT);
+      gassign *assign = gimple_build_assign (result, tmp);
+      gsi_insert_after (gsi, assign, GSI_NEW_STMT);
+    }
+  else
+    gsi_insert_after (gsi, call, GSI_NEW_STMT);
+}
 
-  one = build_int_cst (gcov_type_node, 1);
+/* Output instructions as GIMPLE trees to increment the COUNTER.  If RESULT is
+   not null, then assign the updated counter value to RESULT.  Insert the
+   instructions to GSI.  Use NAME for temporary values.  */
 
-  if (flag_profile_update == PROFILE_UPDATE_ATOMIC)
+static inline void
+gen_counter_update (gimple_stmt_iterator *gsi, tree counter, tree result,
+		    const char *name)
+{
+  tree type = gcov_type_node;
+  tree addr = build_fold_addr_expr (counter);
+  tree one = build_int_cst (type, 1);
+  tree relaxed = build_int_cst (integer_type_node, MEMMODEL_RELAXED);
+
+  if (counter_update == COUNTER_UPDATE_ATOMIC_BUILTIN ||
+      (result && counter_update == COUNTER_UPDATE_ATOMIC_SPLIT))
     {
       /* __atomic_fetch_add (&counter, 1, MEMMODEL_RELAXED); */
-      tree addr = tree_coverage_counter_addr (GCOV_COUNTER_ARCS, edgeno);
-      tree f = builtin_decl_explicit (TYPE_PRECISION (gcov_type_node) > 32
-				      ? BUILT_IN_ATOMIC_FETCH_ADD_8:
-				      BUILT_IN_ATOMIC_FETCH_ADD_4);
-      gcall *stmt = gimple_build_call (f, 3, addr, one,
-				       build_int_cst (integer_type_node,
-						      MEMMODEL_RELAXED));
-      gsi_insert_on_edge (e, stmt);
+      tree f = builtin_decl_explicit (TYPE_PRECISION (type) > 32
+				      ? BUILT_IN_ATOMIC_ADD_FETCH_8:
+				      BUILT_IN_ATOMIC_ADD_FETCH_4);
+      gcall *call = gimple_build_call (f, 3, addr, one, relaxed);
+      gen_assign_counter_update (gsi, call, f, result, name);
+    }
+  else if (!result && (counter_update == COUNTER_UPDATE_ATOMIC_SPLIT ||
+		       counter_update == COUNTER_UPDATE_ATOMIC_PARTIAL))
+    {
+      /* low = __atomic_add_fetch_4 (addr, 1, MEMMODEL_RELAXED);
+	 high_inc = low == 0 ? 1 : 0;
+	 __atomic_add_fetch_4 (addr_high, high_inc, MEMMODEL_RELAXED); */
+      tree zero32 = build_zero_cst (uint32_type_node);
+      tree one32 = build_one_cst (uint32_type_node);
+      tree addr_high = make_temp_ssa_name (TREE_TYPE (addr), NULL, name);
+      tree four = build_int_cst (size_type_node, 4);
+      gassign *assign1 = gimple_build_assign (addr_high, POINTER_PLUS_EXPR,
+					      addr, four);
+      gsi_insert_after (gsi, assign1, GSI_NEW_STMT);
+      if (WORDS_BIG_ENDIAN)
+	std::swap (addr, addr_high);
+      tree f = builtin_decl_explicit (BUILT_IN_ATOMIC_ADD_FETCH_4);
+      gcall *call1 = gimple_build_call (f, 3, addr, one, relaxed);
+      tree low = make_temp_ssa_name (uint32_type_node, NULL, name);
+      gimple_call_set_lhs (call1, low);
+      gsi_insert_after (gsi, call1, GSI_NEW_STMT);
+      tree is_zero = make_temp_ssa_name (boolean_type_node, NULL, name);
+      gassign *assign2 = gimple_build_assign (is_zero, EQ_EXPR, low,
+					      zero32);
+      gsi_insert_after (gsi, assign2, GSI_NEW_STMT);
+      tree high_inc = make_temp_ssa_name (uint32_type_node, NULL, name);
+      gassign *assign3 = gimple_build_assign (high_inc, COND_EXPR,
+					      is_zero, one32, zero32);
+      gsi_insert_after (gsi, assign3, GSI_NEW_STMT);
+      gcall *call2 = gimple_build_call (f, 3, addr_high, high_inc,
+					relaxed);
+      gsi_insert_after (gsi, call2, GSI_NEW_STMT);
     }
   else
     {
-      tree ref = tree_coverage_counter_ref (GCOV_COUNTER_ARCS, edgeno);
-      tree gcov_type_tmp_var = make_temp_ssa_name (gcov_type_node,
-						   NULL, "PROF_edge_counter");
-      gassign *stmt1 = gimple_build_assign (gcov_type_tmp_var, ref);
-      gcov_type_tmp_var = make_temp_ssa_name (gcov_type_node,
-					      NULL, "PROF_edge_counter");
-      gassign *stmt2 = gimple_build_assign (gcov_type_tmp_var, PLUS_EXPR,
-					    gimple_assign_lhs (stmt1), one);
-      gassign *stmt3 = gimple_build_assign (unshare_expr (ref),
-					    gimple_assign_lhs (stmt2));
-      gsi_insert_on_edge (e, stmt1);
-      gsi_insert_on_edge (e, stmt2);
-      gsi_insert_on_edge (e, stmt3);
+      tree tmp1 = make_temp_ssa_name (type, NULL, name);
+      gassign *assign1 = gimple_build_assign (tmp1, counter);
+      gsi_insert_after (gsi, assign1, GSI_NEW_STMT);
+      tree tmp2 = make_temp_ssa_name (type, NULL, name);
+      gassign *assign2 = gimple_build_assign (tmp2, PLUS_EXPR, tmp1, one);
+      gsi_insert_after (gsi, assign2, GSI_NEW_STMT);
+      gassign *assign3 = gimple_build_assign (counter, tmp2);
+      gsi_insert_after (gsi, assign3, GSI_NEW_STMT);
+      if (result)
+	{
+	  gassign *assign4 = gimple_build_assign (result, tmp2);
+	  gsi_insert_after (gsi, assign4, GSI_NEW_STMT);
+	}
     }
 }
 
+/* Output instructions as GIMPLE trees to increment the edge
+   execution count, and insert them on E.  */
+
+void
+gimple_gen_edge_profiler (int edgeno, edge e)
+{
+  gimple_stmt_iterator gsi = gsi_last (PENDING_STMT (e));
+  tree counter = tree_coverage_counter_ref (GCOV_COUNTER_ARCS, edgeno);
+  gen_counter_update (&gsi, counter, NULL_TREE, "PROF_edge_counter");
+}
+
 /* Emits code to get VALUE to instrument at GSI, and returns the
    variable containing the value.  */
 
@@ -507,56 +606,16 @@ gimple_gen_time_profiler (unsigned tag)
   tree original_ref = tree_coverage_counter_ref (tag, 0);
   tree ref = force_gimple_operand_gsi (&gsi, original_ref, true, NULL_TREE,
 				       true, GSI_SAME_STMT);
-  tree one = build_int_cst (type, 1);
 
   /* Emit: if (counters[0] != 0).  */
   gcond *cond = gimple_build_cond (EQ_EXPR, ref, build_int_cst (type, 0),
 				   NULL, NULL);
   gsi_insert_before (&gsi, cond, GSI_NEW_STMT);
 
-  gsi = gsi_start_bb (update_bb);
-
   /* Emit: counters[0] = ++__gcov_time_profiler_counter.  */
-  if (flag_profile_update == PROFILE_UPDATE_ATOMIC)
-    {
-      tree ptr = make_temp_ssa_name (build_pointer_type (type), NULL,
-				     "PROF_time_profiler_counter_ptr");
-      tree addr = build1 (ADDR_EXPR, TREE_TYPE (ptr),
-			  tree_time_profiler_counter);
-      gassign *assign = gimple_build_assign (ptr, NOP_EXPR, addr);
-      gsi_insert_before (&gsi, assign, GSI_NEW_STMT);
-      tree f = builtin_decl_explicit (TYPE_PRECISION (gcov_type_node) > 32
-				      ? BUILT_IN_ATOMIC_ADD_FETCH_8:
-				      BUILT_IN_ATOMIC_ADD_FETCH_4);
-      gcall *stmt = gimple_build_call (f, 3, ptr, one,
-				       build_int_cst (integer_type_node,
-						      MEMMODEL_RELAXED));
-      tree result_type = TREE_TYPE (TREE_TYPE (f));
-      tree tmp = make_temp_ssa_name (result_type, NULL, "PROF_time_profile");
-      gimple_set_lhs (stmt, tmp);
-      gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
-      tmp = make_temp_ssa_name (type, NULL, "PROF_time_profile");
-      assign = gimple_build_assign (tmp, NOP_EXPR,
-				    gimple_call_lhs (stmt));
-      gsi_insert_after (&gsi, assign, GSI_NEW_STMT);
-      assign = gimple_build_assign (original_ref, tmp);
-      gsi_insert_after (&gsi, assign, GSI_NEW_STMT);
-    }
-  else
-    {
-      tree tmp = make_temp_ssa_name (type, NULL, "PROF_time_profile");
-      gassign *assign = gimple_build_assign (tmp, tree_time_profiler_counter);
-      gsi_insert_before (&gsi, assign, GSI_NEW_STMT);
-
-      tmp = make_temp_ssa_name (type, NULL, "PROF_time_profile");
-      assign = gimple_build_assign (tmp, PLUS_EXPR, gimple_assign_lhs (assign),
-				    one);
-      gsi_insert_after (&gsi, assign, GSI_NEW_STMT);
-      assign = gimple_build_assign (original_ref, tmp);
-      gsi_insert_after (&gsi, assign, GSI_NEW_STMT);
-      assign = gimple_build_assign (tree_time_profiler_counter, tmp);
-      gsi_insert_after (&gsi, assign, GSI_NEW_STMT);
-    }
+  gsi = gsi_start_bb (update_bb);
+  gen_counter_update (&gsi, tree_time_profiler_counter, original_ref,
+		      "PROF_time_profile");
 }
 
 /* Output instructions as GIMPLE trees to increment the average histogram
@@ -698,15 +757,20 @@ tree_profiling (void)
   struct cgraph_node *node;
 
   /* Verify whether we can utilize atomic update operations.  */
-  bool can_support_atomic = false;
+  bool can_support_atomic = targetm.have_libatomic;
   unsigned HOST_WIDE_INT gcov_type_size
     = tree_to_uhwi (TYPE_SIZE_UNIT (get_gcov_type ()));
-  if (gcov_type_size == 4)
-    can_support_atomic
-      = HAVE_sync_compare_and_swapsi || HAVE_atomic_compare_and_swapsi;
-  else if (gcov_type_size == 8)
-    can_support_atomic
-      = HAVE_sync_compare_and_swapdi || HAVE_atomic_compare_and_swapdi;
+  bool have_atomic_4
+    = HAVE_sync_compare_and_swapsi || HAVE_atomic_compare_and_swapsi;
+  bool have_atomic_8
+    = HAVE_sync_compare_and_swapdi || HAVE_atomic_compare_and_swapdi;
+  if (!can_support_atomic)
+    {
+      if (gcov_type_size == 4)
+	can_support_atomic = have_atomic_4;
+      else if (gcov_type_size == 8)
+	can_support_atomic = have_atomic_8;
+    }
 
   if (flag_profile_update == PROFILE_UPDATE_ATOMIC
       && !can_support_atomic)
@@ -719,6 +783,16 @@ tree_profiling (void)
     flag_profile_update = can_support_atomic
       ? PROFILE_UPDATE_ATOMIC : PROFILE_UPDATE_SINGLE;
 
+  if (flag_profile_update == PROFILE_UPDATE_ATOMIC)
+    {
+      if (gcov_type_size == 8 && !have_atomic_8 && have_atomic_4)
+	counter_update = COUNTER_UPDATE_ATOMIC_SPLIT;
+      else
+	counter_update = COUNTER_UPDATE_ATOMIC_BUILTIN;
+    }
+  else if (gcov_type_size == 8 && have_atomic_4)
+      counter_update = COUNTER_UPDATE_ATOMIC_PARTIAL;
+
   /* This is a small-ipa pass that gets called only once, from
      cgraphunit.cc:ipa_passes().  */
   gcc_assert (symtab->state == IPA_SSA);
diff --git a/gcc/tree-scalar-evolution.cc b/gcc/tree-scalar-evolution.cc
index 70b17c5..f61277c 100644
--- a/gcc/tree-scalar-evolution.cc
+++ b/gcc/tree-scalar-evolution.cc
@@ -3689,6 +3689,9 @@ analyze_and_compute_bitop_with_inv_effect (class loop* loop, tree phidef,
   match_op[0] = gimple_assign_rhs1 (def);
   match_op[1] = gimple_assign_rhs2 (def);
 
+  if (expr_invariant_in_loop_p (loop, match_op[1]))
+    std::swap (match_op[0], match_op[1]);
+
   if (TREE_CODE (match_op[1]) != SSA_NAME
       || !expr_invariant_in_loop_p (loop, match_op[0])
       || !(header_phi = dyn_cast <gphi *> (SSA_NAME_DEF_STMT (match_op[1])))
diff --git a/gcc/tree-ssa-forwprop.cc b/gcc/tree-ssa-forwprop.cc
index d4e9202..d39dfc1 100644
--- a/gcc/tree-ssa-forwprop.cc
+++ b/gcc/tree-ssa-forwprop.cc
@@ -2381,6 +2381,7 @@ simplify_count_trailing_zeroes (gimple_stmt_iterator *gsi)
       HOST_WIDE_INT type_size = tree_to_shwi (TYPE_SIZE (type));
       bool zero_ok
 	= CTZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (type), ctz_val) == 2;
+      int nargs = 2;
 
       /* If the input value can't be zero, don't special case ctz (0).  */
       if (tree_expr_nonzero_p (res_ops[0]))
@@ -2388,6 +2389,7 @@ simplify_count_trailing_zeroes (gimple_stmt_iterator *gsi)
 	  zero_ok = true;
 	  zero_val = 0;
 	  ctz_val = 0;
+	  nargs = 1;
 	}
 
       /* Skip if there is no value defined at zero, or if we can't easily
@@ -2399,7 +2401,11 @@ simplify_count_trailing_zeroes (gimple_stmt_iterator *gsi)
 
       gimple_seq seq = NULL;
       gimple *g;
-      gcall *call = gimple_build_call_internal (IFN_CTZ, 1, res_ops[0]);
+      gcall *call
+	= gimple_build_call_internal (IFN_CTZ, nargs, res_ops[0],
+				      nargs == 1 ? NULL_TREE
+				      : build_int_cst (integer_type_node,
+						       ctz_val));
       gimple_set_location (call, gimple_location (stmt));
       gimple_set_lhs (call, make_ssa_name (integer_type_node));
       gimple_seq_add_stmt (&seq, call);
diff --git a/gcc/tree-ssa-loop-niter.cc b/gcc/tree-ssa-loop-niter.cc
index 718582a..2098bef 100644
--- a/gcc/tree-ssa-loop-niter.cc
+++ b/gcc/tree-ssa-loop-niter.cc
@@ -2235,14 +2235,18 @@ build_cltz_expr (tree src, bool leading, bool define_at_zero)
   tree call;
   if (use_ifn)
     {
-      call = build_call_expr_internal_loc (UNKNOWN_LOCATION, ifn,
-					   integer_type_node, 1, src);
       int val;
       int optab_defined_at_zero
 	= (leading
 	   ? CLZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (utype), val)
 	   : CTZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (utype), val));
-      if (define_at_zero && !(optab_defined_at_zero == 2 && val == prec))
+      tree arg2 = NULL_TREE;
+      if (define_at_zero && optab_defined_at_zero == 2 && val == prec)
+	arg2 = build_int_cst (integer_type_node, val);
+      call = build_call_expr_internal_loc (UNKNOWN_LOCATION, ifn,
+					   integer_type_node, arg2 ? 2 : 1,
+					   src, arg2);
+      if (define_at_zero && arg2 == NULL_TREE)
 	{
 	  tree is_zero = fold_build2 (NE_EXPR, boolean_type_node, src,
 				      build_zero_cst (TREE_TYPE (src)));
diff --git a/gcc/tree-ssa-loop-split.cc b/gcc/tree-ssa-loop-split.cc
index 6446480..2e2adb6 100644
--- a/gcc/tree-ssa-loop-split.cc
+++ b/gcc/tree-ssa-loop-split.cc
@@ -194,13 +194,12 @@ split_at_bb_p (class loop *loop, basic_block bb, tree *border, affine_iv *iv,
    also be true/false in the next iteration.  */
 
 static void
-patch_loop_exit (class loop *loop, gcond *guard, tree nextval, tree newbound,
-		 bool initial_true)
+patch_loop_exit (class loop *loop, tree_code guard_code, tree nextval,
+		 tree newbound, bool initial_true)
 {
   edge exit = single_exit (loop);
   gcond *stmt = as_a <gcond *> (*gsi_last_bb (exit->src));
-  gimple_cond_set_condition (stmt, gimple_cond_code (guard),
-			     nextval, newbound);
+  gimple_cond_set_condition (stmt, guard_code, nextval, newbound);
   update_stmt (stmt);
 
   edge stay = EDGE_SUCC (exit->src, EDGE_SUCC (exit->src, 0) == exit);
@@ -745,7 +744,7 @@ split_loop (class loop *loop1)
 	  gsi_insert_seq_on_edge_immediate (loop_preheader_edge (loop1),
 					    stmts);
 	tree guard_next = PHI_ARG_DEF_FROM_EDGE (phi, loop_latch_edge (loop1));
-	patch_loop_exit (loop1, guard_stmt, guard_next, newend, initial_true);
+	patch_loop_exit (loop1, guard_code, guard_next, newend, initial_true);
 
 	/* Finally patch out the two copies of the condition to be always
 	   true/false (or opposite).  */
diff --git a/gcc/tree-ssa-phiopt.cc b/gcc/tree-ssa-phiopt.cc
index bb55a4f..ac80517 100644
--- a/gcc/tree-ssa-phiopt.cc
+++ b/gcc/tree-ssa-phiopt.cc
@@ -2863,18 +2863,26 @@ cond_removal_in_builtin_zero_pattern (basic_block cond_bb,
     }
 
   /* Check that we have a popcount/clz/ctz builtin.  */
-  if (!is_gimple_call (call) || gimple_call_num_args (call) != 1)
+  if (!is_gimple_call (call))
     return false;
 
-  arg = gimple_call_arg (call, 0);
   lhs = gimple_get_lhs (call);
 
   if (lhs == NULL_TREE)
     return false;
 
   combined_fn cfn = gimple_call_combined_fn (call);
+  if (gimple_call_num_args (call) != 1
+      && (gimple_call_num_args (call) != 2
+	  || cfn == CFN_CLZ
+	  || cfn == CFN_CTZ))
+    return false;
+
+  arg = gimple_call_arg (call, 0);
+
   internal_fn ifn = IFN_LAST;
   int val = 0;
+  bool any_val = false;
   switch (cfn)
     {
     case CFN_BUILT_IN_BSWAP16:
@@ -2889,6 +2897,23 @@ cond_removal_in_builtin_zero_pattern (basic_block cond_bb,
       if (INTEGRAL_TYPE_P (TREE_TYPE (arg)))
 	{
 	  tree type = TREE_TYPE (arg);
+	  if (TREE_CODE (type) == BITINT_TYPE)
+	    {
+	      if (gimple_call_num_args (call) == 1)
+		{
+		  any_val = true;
+		  ifn = IFN_CLZ;
+		  break;
+		}
+	      if (!tree_fits_shwi_p (gimple_call_arg (call, 1)))
+		return false;
+	      HOST_WIDE_INT at_zero = tree_to_shwi (gimple_call_arg (call, 1));
+	      if ((int) at_zero != at_zero)
+		return false;
+	      ifn = IFN_CLZ;
+	      val = at_zero;
+	      break;
+	    }
 	  if (direct_internal_fn_supported_p (IFN_CLZ, type, OPTIMIZE_FOR_BOTH)
 	      && CLZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (type),
 					    val) == 2)
@@ -2902,6 +2927,23 @@ cond_removal_in_builtin_zero_pattern (basic_block cond_bb,
       if (INTEGRAL_TYPE_P (TREE_TYPE (arg)))
 	{
 	  tree type = TREE_TYPE (arg);
+	  if (TREE_CODE (type) == BITINT_TYPE)
+	    {
+	      if (gimple_call_num_args (call) == 1)
+		{
+		  any_val = true;
+		  ifn = IFN_CTZ;
+		  break;
+		}
+	      if (!tree_fits_shwi_p (gimple_call_arg (call, 1)))
+		return false;
+	      HOST_WIDE_INT at_zero = tree_to_shwi (gimple_call_arg (call, 1));
+	      if ((int) at_zero != at_zero)
+		return false;
+	      ifn = IFN_CTZ;
+	      val = at_zero;
+	      break;
+	    }
 	  if (direct_internal_fn_supported_p (IFN_CTZ, type, OPTIMIZE_FOR_BOTH)
 	      && CTZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (type),
 					    val) == 2)
@@ -2960,8 +3002,18 @@ cond_removal_in_builtin_zero_pattern (basic_block cond_bb,
 
   /* Check PHI arguments.  */
   if (lhs != arg0
-      || TREE_CODE (arg1) != INTEGER_CST
-      || wi::to_wide (arg1) != val)
+      || TREE_CODE (arg1) != INTEGER_CST)
+    return false;
+  if (any_val)
+    {
+      if (!tree_fits_shwi_p (arg1))
+	return false;
+      HOST_WIDE_INT at_zero = tree_to_shwi (arg1);
+      if ((int) at_zero != at_zero)
+	return false;
+      val = at_zero;
+    }
+  else if (wi::to_wide (arg1) != val)
     return false;
 
   /* And insert the popcount/clz/ctz builtin and cast stmt before the
@@ -2974,13 +3026,15 @@ cond_removal_in_builtin_zero_pattern (basic_block cond_bb,
       reset_flow_sensitive_info (gimple_get_lhs (cast));
     }
   gsi_from = gsi_for_stmt (call);
-  if (ifn == IFN_LAST || gimple_call_internal_p (call))
+  if (ifn == IFN_LAST
+      || (gimple_call_internal_p (call) && gimple_call_num_args (call) == 2))
     gsi_move_before (&gsi_from, &gsi);
   else
     {
       /* For __builtin_c[lt]z* force .C[LT]Z ifn, because only
 	 the latter is well defined at zero.  */
-      call = gimple_build_call_internal (ifn, 1, gimple_call_arg (call, 0));
+      call = gimple_build_call_internal (ifn, 2, gimple_call_arg (call, 0),
+					 build_int_cst (integer_type_node, val));
       gimple_call_set_lhs (call, lhs);
       gsi_insert_before (&gsi, call, GSI_SAME_STMT);
       gsi_remove (&gsi_from, true);
diff --git a/gcc/tree-vect-loop-manip.cc b/gcc/tree-vect-loop-manip.cc
index b916127..bcd90a3 100644
--- a/gcc/tree-vect-loop-manip.cc
+++ b/gcc/tree-vect-loop-manip.cc
@@ -1792,6 +1792,10 @@ find_loop_location (class loop *loop)
   if (!loop)
     return dump_user_location_t ();
 
+  /* For the root of the loop tree return the function location.  */
+  if (!loop_outer (loop))
+    return dump_user_location_t::from_function_decl (cfun->decl);
+
   if (loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
     {
       /* We only care about the loop location, so use any exit with location
diff --git a/gcc/tree-vect-loop.cc b/gcc/tree-vect-loop.cc
index 7d00cc9..b7675d8 100644
--- a/gcc/tree-vect-loop.cc
+++ b/gcc/tree-vect-loop.cc
@@ -2657,6 +2657,19 @@ vect_determine_partial_vectors_and_peeling (loop_vec_info loop_vinfo)
     = (!LOOP_VINFO_USING_PARTIAL_VECTORS_P (loop_vinfo)
        && need_peeling_or_partial_vectors_p);
 
+  /* We set LOOP_VINFO_USING_SELECT_VL_P as true before loop vectorization
+     analysis that we don't know whether the loop is vectorized by partial
+     vectors (More details see tree-vect-loop-manip.cc).
+
+     However, SELECT_VL vectorizaton style should only applied on partial
+     vectorization since SELECT_VL is the GIMPLE IR that calculates the
+     number of elements to be process for each iteration.
+
+     After loop vectorization analysis, Clear LOOP_VINFO_USING_SELECT_VL_P
+     if it is not partial vectorized loop.  */
+  if (!LOOP_VINFO_USING_PARTIAL_VECTORS_P (loop_vinfo))
+    LOOP_VINFO_USING_SELECT_VL_P (loop_vinfo) = false;
+
   return opt_result::success ();
 }
 
@@ -4105,9 +4118,9 @@ pop:
 	/* In case of a COND_OP (mask, op1, op2, op1) reduction we might have
 	   op1 twice (once as definition, once as else) in the same operation.
 	   Allow this.  */
-	  if (cond_fn_p)
+	  if (cond_fn_p && op_use_stmt == use_stmt)
 	    {
-	      gcall *call = dyn_cast<gcall *> (use_stmt);
+	      gcall *call = as_a<gcall *> (use_stmt);
 	      unsigned else_pos
 		= internal_fn_else_index (internal_fn (op.code));
 
@@ -8470,15 +8483,28 @@ vect_transform_reduction (loop_vec_info loop_vinfo,
 
   /* Get NCOPIES vector definitions for all operands except the reduction
      definition.  */
-  vect_get_vec_defs (loop_vinfo, stmt_info, slp_node, ncopies,
-		     single_defuse_cycle && reduc_index == 0
-		     ? NULL_TREE : op.ops[0], &vec_oprnds0,
-		     single_defuse_cycle && reduc_index == 1
-		     ? NULL_TREE : op.ops[1], &vec_oprnds1,
-		     op.num_ops == 4
-		     || (op.num_ops == 3
-			 && !(single_defuse_cycle && reduc_index == 2))
-		     ? op.ops[2] : NULL_TREE, &vec_oprnds2);
+  if (!cond_fn_p)
+    {
+      vect_get_vec_defs (loop_vinfo, stmt_info, slp_node, ncopies,
+			 single_defuse_cycle && reduc_index == 0
+			 ? NULL_TREE : op.ops[0], &vec_oprnds0,
+			 single_defuse_cycle && reduc_index == 1
+			 ? NULL_TREE : op.ops[1], &vec_oprnds1,
+			 op.num_ops == 3
+			 && !(single_defuse_cycle && reduc_index == 2)
+			 ? op.ops[2] : NULL_TREE, &vec_oprnds2);
+    }
+  else
+    {
+      /* For a conditional operation pass the truth type as mask
+	 vectype.  */
+      gcc_assert (single_defuse_cycle && reduc_index == 1);
+      vect_get_vec_defs (loop_vinfo, stmt_info, slp_node, ncopies,
+			 op.ops[0], &vec_oprnds0,
+			 truth_type_for (vectype_in),
+			 NULL_TREE, &vec_oprnds1, NULL_TREE,
+			 op.ops[2], &vec_oprnds2, NULL_TREE);
+    }
 
   /* For single def-use cycles get one copy of the vectorized reduction
      definition.  */
@@ -9569,9 +9595,16 @@ vectorizable_nonlinear_induction (loop_vec_info loop_vinfo,
 
   if (TREE_CODE (init_expr) == INTEGER_CST)
     init_expr = fold_convert (TREE_TYPE (vectype), init_expr);
-  else
-    gcc_assert (tree_nop_conversion_p (TREE_TYPE (vectype),
-				       TREE_TYPE (init_expr)));
+  else if (!tree_nop_conversion_p (TREE_TYPE (vectype), TREE_TYPE (init_expr)))
+    {
+      /* INIT_EXPR could be a bit_field, bail out for such case.  */
+      if (dump_enabled_p ())
+	dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+			 "nonlinear induction vectorization failed:"
+			 " component type of vectype is not a nop conversion"
+			 " from type of init_expr.\n");
+      return false;
+    }
 
   switch (induction_type)
     {
diff --git a/gcc/tree-vect-patterns.cc b/gcc/tree-vect-patterns.cc
index 6b6b412..7debe7f 100644
--- a/gcc/tree-vect-patterns.cc
+++ b/gcc/tree-vect-patterns.cc
@@ -1818,7 +1818,7 @@ vect_recog_ctz_ffs_pattern (vec_info *vinfo, stmt_vec_info stmt_vinfo,
   tree new_var;
   internal_fn ifn = IFN_LAST, ifnnew = IFN_LAST;
   bool defined_at_zero = true, defined_at_zero_new = false;
-  int val = 0, val_new = 0;
+  int val = 0, val_new = 0, val_cmp = 0;
   int prec;
   int sub = 0, add = 0;
   location_t loc;
@@ -1826,7 +1826,8 @@ vect_recog_ctz_ffs_pattern (vec_info *vinfo, stmt_vec_info stmt_vinfo,
   if (!is_gimple_call (call_stmt))
     return NULL;
 
-  if (gimple_call_num_args (call_stmt) != 1)
+  if (gimple_call_num_args (call_stmt) != 1
+      && gimple_call_num_args (call_stmt) != 2)
     return NULL;
 
   rhs_oprnd = gimple_call_arg (call_stmt, 0);
@@ -1846,9 +1847,10 @@ vect_recog_ctz_ffs_pattern (vec_info *vinfo, stmt_vec_info stmt_vinfo,
     CASE_CFN_CTZ:
       ifn = IFN_CTZ;
       if (!gimple_call_internal_p (call_stmt)
-	  || CTZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (rhs_type),
-					val) != 2)
+	  || gimple_call_num_args (call_stmt) != 2)
 	defined_at_zero = false;
+      else
+	val = tree_to_shwi (gimple_call_arg (call_stmt, 1));
       break;
     CASE_CFN_FFS:
       ifn = IFN_FFS;
@@ -1907,6 +1909,7 @@ vect_recog_ctz_ffs_pattern (vec_info *vinfo, stmt_vec_info stmt_vinfo,
 
   vect_pattern_detected ("vec_recog_ctz_ffs_pattern", call_stmt);
 
+  val_cmp = val_new;
   if ((ifnnew == IFN_CLZ
        && defined_at_zero
        && defined_at_zero_new
@@ -1918,7 +1921,7 @@ vect_recog_ctz_ffs_pattern (vec_info *vinfo, stmt_vec_info stmt_vinfo,
 	 .CTZ (X) = .POPCOUNT ((X - 1) & ~X).  */
       if (ifnnew == IFN_CLZ)
 	sub = prec;
-      val_new = prec;
+      val_cmp = prec;
 
       if (!TYPE_UNSIGNED (rhs_type))
 	{
@@ -1955,7 +1958,7 @@ vect_recog_ctz_ffs_pattern (vec_info *vinfo, stmt_vec_info stmt_vinfo,
       /* .CTZ (X) = (PREC - 1) - .CLZ (X & -X)
 	 .FFS (X) = PREC - .CLZ (X & -X).  */
       sub = prec - (ifn == IFN_CTZ);
-      val_new = sub - val_new;
+      val_cmp = sub - val_new;
 
       tree neg = vect_recog_temp_ssa_var (rhs_type, NULL);
       pattern_stmt = gimple_build_assign (neg, NEGATE_EXPR, rhs_oprnd);
@@ -1974,7 +1977,7 @@ vect_recog_ctz_ffs_pattern (vec_info *vinfo, stmt_vec_info stmt_vinfo,
       /* .CTZ (X) = PREC - .POPCOUNT (X | -X)
 	 .FFS (X) = (PREC + 1) - .POPCOUNT (X | -X).  */
       sub = prec + (ifn == IFN_FFS);
-      val_new = sub;
+      val_cmp = sub;
 
       tree neg = vect_recog_temp_ssa_var (rhs_type, NULL);
       pattern_stmt = gimple_build_assign (neg, NEGATE_EXPR, rhs_oprnd);
@@ -1992,12 +1995,18 @@ vect_recog_ctz_ffs_pattern (vec_info *vinfo, stmt_vec_info stmt_vinfo,
     {
       /* .FFS (X) = .CTZ (X) + 1.  */
       add = 1;
-      val_new++;
+      val_cmp++;
     }
 
   /* Create B = .IFNNEW (A).  */
   new_var = vect_recog_temp_ssa_var (lhs_type, NULL);
-  pattern_stmt = gimple_build_call_internal (ifnnew, 1, rhs_oprnd);
+  if ((ifnnew == IFN_CLZ || ifnnew == IFN_CTZ) && defined_at_zero_new)
+    pattern_stmt
+      = gimple_build_call_internal (ifnnew, 2, rhs_oprnd,
+				    build_int_cst (integer_type_node,
+						   val_new));
+  else
+    pattern_stmt = gimple_build_call_internal (ifnnew, 1, rhs_oprnd);
   gimple_call_set_lhs (pattern_stmt, new_var);
   gimple_set_location (pattern_stmt, loc);
   *type_out = vec_type;
@@ -2023,7 +2032,7 @@ vect_recog_ctz_ffs_pattern (vec_info *vinfo, stmt_vec_info stmt_vinfo,
     }
 
   if (defined_at_zero
-      && (!defined_at_zero_new || val != val_new))
+      && (!defined_at_zero_new || val != val_cmp))
     {
       append_pattern_def_seq (vinfo, stmt_vinfo, pattern_stmt, vec_type);
       tree ret_var = vect_recog_temp_ssa_var (lhs_type, NULL);
@@ -2143,7 +2152,8 @@ vect_recog_popcount_clz_ctz_ffs_pattern (vec_info *vinfo,
       return NULL;
     }
 
-  if (gimple_call_num_args (call_stmt) != 1)
+  if (gimple_call_num_args (call_stmt) != 1
+      && gimple_call_num_args (call_stmt) != 2)
     return NULL;
 
   rhs_oprnd = gimple_call_arg (call_stmt, 0);
@@ -2181,17 +2191,14 @@ vect_recog_popcount_clz_ctz_ffs_pattern (vec_info *vinfo,
 	  return NULL;
 	addend = (TYPE_PRECISION (TREE_TYPE (rhs_oprnd))
 		  - TYPE_PRECISION (lhs_type));
-	if (gimple_call_internal_p (call_stmt))
+	if (gimple_call_internal_p (call_stmt)
+	    && gimple_call_num_args (call_stmt) == 2)
 	  {
 	    int val1, val2;
-	    int d1
-	      = CLZ_DEFINED_VALUE_AT_ZERO
-		  (SCALAR_INT_TYPE_MODE (TREE_TYPE (rhs_oprnd)), val1);
+	    val1 = tree_to_shwi (gimple_call_arg (call_stmt, 1));
 	    int d2
 	      = CLZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (lhs_type),
 					   val2);
-	    if (d1 != 2)
-	      break;
 	    if (d2 != 2 || val1 != val2 + addend)
 	      return NULL;
 	  }
@@ -2200,17 +2207,14 @@ vect_recog_popcount_clz_ctz_ffs_pattern (vec_info *vinfo,
 	/* ctzll (x) == ctz (x) for unsigned or signed x != 0, so ok
 	   if it is undefined at zero or if it matches also for the
 	   defined value there.  */
-	if (gimple_call_internal_p (call_stmt))
+	if (gimple_call_internal_p (call_stmt)
+	    && gimple_call_num_args (call_stmt) == 2)
 	  {
 	    int val1, val2;
-	    int d1
-	      = CTZ_DEFINED_VALUE_AT_ZERO
-		  (SCALAR_INT_TYPE_MODE (TREE_TYPE (rhs_oprnd)), val1);
+	    val1 = tree_to_shwi (gimple_call_arg (call_stmt, 1));
 	    int d2
 	      = CTZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (lhs_type),
 					   val2);
-	    if (d1 != 2)
-	      break;
 	    if (d2 != 2 || val1 != val2)
 	      return NULL;
 	  }
@@ -2260,7 +2264,20 @@ vect_recog_popcount_clz_ctz_ffs_pattern (vec_info *vinfo,
 
   /* Create B = .POPCOUNT (A).  */
   new_var = vect_recog_temp_ssa_var (lhs_type, NULL);
-  pattern_stmt = gimple_build_call_internal (ifn, 1, unprom_diff.op);
+  tree arg2 = NULL_TREE;
+  int val;
+  if (ifn == IFN_CLZ
+      && CLZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (lhs_type),
+				    val) == 2)
+    arg2 = build_int_cst (integer_type_node, val);
+  else if (ifn == IFN_CTZ
+	   && CTZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (lhs_type),
+					 val) == 2)
+    arg2 = build_int_cst (integer_type_node, val);
+  if (arg2)
+    pattern_stmt = gimple_build_call_internal (ifn, 2, unprom_diff.op, arg2);
+  else
+    pattern_stmt = gimple_build_call_internal (ifn, 1, unprom_diff.op);
   gimple_call_set_lhs (pattern_stmt, new_var);
   gimple_set_location (pattern_stmt, gimple_location (last_stmt));
   *type_out = vec_type;
diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc
index 80e279d..4a09b3c 100644
--- a/gcc/tree-vect-slp.cc
+++ b/gcc/tree-vect-slp.cc
@@ -505,6 +505,7 @@ static const int cond_expr_maps[3][5] = {
   { 4, -2, -1, 1, 2 },
   { 4, -1, -2, 2, 1 }
 };
+static const int arg0_map[] = { 1, 0 };
 static const int arg1_map[] = { 1, 1 };
 static const int arg2_map[] = { 1, 2 };
 static const int arg1_arg4_map[] = { 2, 1, 4 };
@@ -580,6 +581,10 @@ vect_get_operand_map (const gimple *stmt, bool gather_scatter_p = false,
 		return nullptr;
 	    }
 
+	  case IFN_CLZ:
+	  case IFN_CTZ:
+	    return arg0_map;
+
 	  default:
 	    break;
 	  }
@@ -7652,6 +7657,7 @@ vect_slp_region (vec<basic_block> bbs, vec<data_reference_p> datarefs,
 
 	  bb_vinfo->shared->check_datarefs ();
 
+	  bool force_clear = false;
 	  auto_vec<slp_instance> profitable_subgraphs;
 	  for (slp_instance instance : BB_VINFO_SLP_INSTANCES (bb_vinfo))
 	    {
@@ -7674,15 +7680,17 @@ vect_slp_region (vec<basic_block> bbs, vec<data_reference_p> datarefs,
 
 	      vect_location = saved_vect_location;
 	      if (!dbg_cnt (vect_slp))
-		continue;
+		{
+		  force_clear = true;
+		  continue;
+		}
 
 	      profitable_subgraphs.safe_push (instance);
 	    }
 
 	  /* When we're vectorizing an if-converted loop body make sure
 	     we vectorized all if-converted code.  */
-	  if (!profitable_subgraphs.is_empty ()
-	      && orig_loop)
+	  if ((!profitable_subgraphs.is_empty () || force_clear) && orig_loop)
 	    {
 	      gcc_assert (bb_vinfo->bbs.length () == 1);
 	      for (gimple_stmt_iterator gsi = gsi_start_bb (bb_vinfo->bbs[0]);
diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc
index ee89f47..96e4a6cf 100644
--- a/gcc/tree-vect-stmts.cc
+++ b/gcc/tree-vect-stmts.cc
@@ -3115,6 +3115,7 @@ vectorizable_call (vec_info *vinfo,
   enum { NARROW, NONE, WIDEN } modifier;
   size_t i, nargs;
   tree lhs;
+  tree clz_ctz_arg1 = NULL_TREE;
 
   if (!STMT_VINFO_RELEVANT_P (stmt_info) && !bb_vinfo)
     return false;
@@ -3160,6 +3161,14 @@ vectorizable_call (vec_info *vinfo,
       nargs = 0;
       rhs_type = unsigned_type_node;
     }
+  /* Similarly pretend IFN_CLZ and IFN_CTZ only has one argument, the second
+     argument just says whether it is well-defined at zero or not and what
+     value should be returned for it.  */
+  if ((cfn == CFN_CLZ || cfn == CFN_CTZ) && nargs == 2)
+    {
+      nargs = 1;
+      clz_ctz_arg1 = gimple_call_arg (stmt, 1);
+    }
 
   int mask_opno = -1;
   if (internal_fn_p (cfn))
@@ -3425,6 +3434,8 @@ vectorizable_call (vec_info *vinfo,
       ifn = cond_fn;
       vect_nargs += 2;
     }
+  if (clz_ctz_arg1)
+    ++vect_nargs;
 
   if (modifier == NONE || ifn != IFN_LAST)
     {
@@ -3462,6 +3473,9 @@ vectorizable_call (vec_info *vinfo,
 		    }
 		  if (masked_loop_p && reduc_idx >= 0)
 		    vargs[varg++] = vargs[reduc_idx + 1];
+		  if (clz_ctz_arg1)
+		    vargs[varg++] = clz_ctz_arg1;
+
 		  gimple *new_stmt;
 		  if (modifier == NARROW)
 		    {
@@ -3548,6 +3562,8 @@ vectorizable_call (vec_info *vinfo,
 	    }
 	  if (masked_loop_p && reduc_idx >= 0)
 	    vargs[varg++] = vargs[reduc_idx + 1];
+	  if (clz_ctz_arg1)
+	    vargs[varg++] = clz_ctz_arg1;
 
 	  if (len_opno >= 0 && len_loop_p)
 	    {
diff --git a/gcc/tree-vrp.cc b/gcc/tree-vrp.cc
index 19d8f99..917fa87 100644
--- a/gcc/tree-vrp.cc
+++ b/gcc/tree-vrp.cc
@@ -886,8 +886,6 @@ find_case_label_range (gswitch *switch_stmt, const irange *range_of_op)
   size_t i, j;
   tree op = gimple_switch_index (switch_stmt);
   tree type = TREE_TYPE (op);
-  unsigned prec = TYPE_PRECISION (type);
-  signop sign = TYPE_SIGN (type);
   tree tmin = wide_int_to_tree (type, range_of_op->lower_bound ());
   tree tmax = wide_int_to_tree (type, range_of_op->upper_bound ());
   find_case_label_range (switch_stmt, tmin, tmax, &i, &j);
@@ -900,9 +898,7 @@ find_case_label_range (gswitch *switch_stmt, const irange *range_of_op)
 	= CASE_HIGH (label) ? CASE_HIGH (label) : CASE_LOW (label);
       wide_int wlow = wi::to_wide (CASE_LOW (label));
       wide_int whigh = wi::to_wide (case_high);
-      int_range_max label_range (type,
-				 wide_int::from (wlow, prec, sign),
-				 wide_int::from (whigh, prec, sign));
+      int_range_max label_range (TREE_TYPE (case_high), wlow, whigh);
       if (!types_compatible_p (label_range.type (), range_of_op->type ()))
 	range_cast (label_range, range_of_op->type ());
       label_range.intersect (*range_of_op);
diff --git a/gcc/tree.cc b/gcc/tree.cc
index 33ea1d2..a3d907a 100644
--- a/gcc/tree.cc
+++ b/gcc/tree.cc
@@ -4210,6 +4210,7 @@ type_contains_placeholder_1 (const_tree type)
       return false;
 
     case INTEGER_TYPE:
+    case BITINT_TYPE:
     case REAL_TYPE:
     case FIXED_POINT_TYPE:
       /* Here we just check the bounds.  */