aboutsummaryrefslogtreecommitdiff
AgeCommit message (Collapse)AuthorFilesLines
2023-09-05c++: [[no_unique_address]] and cv-qualified typeJason Merrill4-2/+88
We were checking for overlap using same_type_p and therefore allocating two Empty subobjects at the same offset because one was cv-qualified. This gives the warning at the location of the class name rather than the member declaration, but this should be a rare enough issue that it doesn't seem worth trying to be more precise. gcc/ChangeLog: * common.opt: Update -fabi-version=19. gcc/cp/ChangeLog: * class.cc (check_subobject_offset): Check same_type_ignoring_top_level_qualifiers_p. gcc/testsuite/ChangeLog: * g++.dg/abi/no_unique_address8.C: New test. * g++.dg/abi/no_unique_address8a.C: New test.
2023-09-06RISC-V: typo: add closing paren to a commentTsukasa OI1-1/+1
gcc/ChangeLog: * config/riscv/zicond.md: Add closing parent to a comment.
2023-09-06RISC-V: Fix Zicond ICE on large constantsTsukasa OI2-6/+26
Large constant cons and/or alt will trigger ICEs building GCC target libraries (libgomp and libatomic) when the 'Zicond' extension is enabled. For instance, zicond-ice-2.c (new test case in this commit) will cause an ICE when SOME_NUMBER is 0x1000 or larger. While opposite numbers corresponding cons/alt (two temp2 variables) are checked, cons/alt themselves are not checked and causing 2 ICEs building GCC target libraries as of this writing: 1. gcc/libatomic/config/posix/lock.c 2. gcc/libgomp/fortran.c Coercing a large value into a register will fix the issue. It also coerce a large cons into a register on "imm, imm" case (the author could not reproduce but possible to cause an ICE). gcc/ChangeLog: * config/riscv/riscv.cc (riscv_expand_conditional_move): Force large constant cons/alt into a register. gcc/testsuite/ChangeLog: * gcc.target/riscv/zicond-ice-2.c: New test. This is based on an ICE at libat_lock_n func on gcc/libatomic/config/posix/lock.c but heavily minimized.
2023-09-06Daily bump.GCC Administrator5-1/+187
2023-09-05riscv: Synthesize all 11-bit-rotate constants with roriChristoph Müllner3-12/+118
Some constants can be built up using LI+RORI instructions. The current implementation requires one of the upper 32-bits to be a zero bit, which is not neccesary. Let's drop this requirement in order to be able to synthesize a constant like 0xffffffff00ffffffL. The tests for LI+RORI are made more strict to detect regression in the calculation of the LI constant and the rotation amount. Signed-off-by: Christoph Müllner <christoph.muellner@vrull.eu> gcc/ChangeLog: * config/riscv/riscv.cc (riscv_build_integer_1): Don't require one zero bit in the upper 32 bits for LI+RORI synthesis. gcc/testsuite/ChangeLog: * gcc.target/riscv/xtheadbb-li-rotr.c: New tests. * gcc.target/riscv/zbb-li-rotr.c: Likewise.
2023-09-05RISC-V: Expose bswapsi for TARGET_64BITJeff Law1-1/+10
Various bswapsi tests are failing for rv64. More importantly, we're generating crappy code. Let's take the first test from bswapsi-1.c as an example. > typedef unsigned int uint32_t; > > #define __const_swab32(x) ((uint32_t)( \ > (((uint32_t)(x) & (uint32_t)0x000000ffUL) << 24) | \ > (((uint32_t)(x) & (uint32_t)0x0000ff00UL) << 8) | \ > (((uint32_t)(x) & (uint32_t)0x00ff0000UL) >> 8) | \ > (((uint32_t)(x) & (uint32_t)0xff000000UL) >> 24))) > > /* This byte swap implementation is used by the Linux kernel and the > GNU C library. */ > > uint32_t > swap32_a (uint32_t in) > { > return __const_swab32 (in); > } > > > We generate this for rv64gc_zba_zbb_zbs: > srliw a1,a0,24 > slliw a5,a0,24 > slliw a3,a0,8 > li a2,16711680 > li a4,65536 > or a5,a5,a1 > and a3,a3,a2 > addi a4,a4,-256 > srliw a0,a0,8 > or a5,a5,a3 > and a0,a0,a4 > or a0,a5,a0 > retUrgh! After this patch we generate: > rev8 a0,a0 > srai a0,a0,32 > ret Clearly better. The stated rationale behind not exposing bswapsi2 for TARGET_64BIT is that the RTL expanders already know how to widen a bswap, which is definitely true. But it's the case that failure to expose a bswapsi will cause the 32bit bswap optimizations in gimple store merging to not trigger. Thus we get crappy code. To fix this we expose bswapsi on TARGET_64BIT. gimple-store-merging then detects the 32bit bswap idioms and generates suitable __builtin calls. The expander will "FAIL" expansion for TARGET_64BIT which forces the generic expander code to synthesize the operation (we could synthesize in here, but that'd result in duplicate code). Tested on rv64gc_zba_zbb_zbs, fixes all the bswapsi failures in the testsuite without any regressions. gcc/ * config/riscv/bitmanip.md (bswapsi2): Expose for TARGET_64BIT.
2023-09-05MATCH: Add `(x | c) & ~(y | c)` and `x & ~(y | x)` patterns [PR98710]Andrew Pinski3-1/+48
Adding some more simple bit_and/bit_ior patterns. How often these show up, I have no idea. OK? Bootstrapped and tested on x86_64-linux-gnu with no regressions. gcc/ChangeLog: PR tree-optimization/98710 * match.pd (`(x | c) & ~(y | c)`, `(x & c) | ~(y & c)`): New pattern. (`x & ~(y | x)`, `x | ~(y & x)`): New patterns. gcc/testsuite/ChangeLog: PR tree-optimization/98710 * gcc.dg/tree-ssa/andor-7.c: New test. * gcc.dg/tree-ssa/andor-8.c: New test.
2023-09-05MATCH: Add pattern for `(x | y) & (x & z)`Andrew Pinski3-1/+38
Like the pattern already there for `(x | y) & x`, this adds a simple pattern to optimize `(x | y) & (x & z)` to just `x & z`. OK? Bootstrapped and tested on x86-64-linux-gnu with no regressions. gcc/ChangeLog: PR tree-optimization/103536 * match.pd (`(x | y) & (x & z)`, `(x & y) | (x | z)`): New patterns. gcc/testsuite/ChangeLog: PR tree-optimization/103536 * gcc.dg/tree-ssa/andor-6.c: New test. * gcc.dg/tree-ssa/andor-bool-1.c: New test.
2023-09-05MATCH: `(nop_convert)-(convert)a` into -(convert)a if we are converting from ↵Andrew Pinski3-0/+46
something smaller This allows removal of one conversion and in the case of booleans, might be able to remove the negate and the other conversion later on. OK? Bootstrapped and tested on x86_64-linux-gnu with no regressions. PR tree-optimization/107137 gcc/ChangeLog: * match.pd (`(nop_convert)-(convert)a`): New pattern. gcc/testsuite/ChangeLog: * gcc.dg/tree-ssa/neg-cast-2.c: New test. * gcc.dg/tree-ssa/neg-cast-3.c: New test.
2023-09-05MATCH: Add `~MAX(~X, Y)` pattern: [PR96694]Andrew Pinski2-1/+37
This adds `~MAX(~X, Y)` and `~MIN(~X, Y)` patterns that are like the `~(~a & b)` and `~(~a | b)` patterns and allows to reduce the number of ~ by 1. OK? Bootstrapped and tested on x86_64-linux-gnu with no regressions. PR tree-optimization/96694 gcc/ChangeLog: * match.pd (`~MAX(~X, Y)`, `~MIN(~X, Y)`): New patterns. gcc/testsuite/ChangeLog: * gcc.dg/tree-ssa/minmax-24.c: New test.
2023-09-05MATCH: Transform `(1 >> X) !=/== 0` into `X ==/!= 0`Andrew Pinski4-2/+109
We currently have a pattern for handling `(C >> X) & D == 0` but if C is 1 and D is 1, the `& 1` might have been removed. gcc/ChangeLog: PR tree-optimization/105832 * match.pd (`(1 >> X) != 0`): New pattern gcc/testsuite/ChangeLog: PR tree-optimization/105832 * gcc.dg/tree-ssa/pr105832-1.c: New test. * gcc.dg/tree-ssa/pr105832-2.c: New test. * gcc.dg/tree-ssa/pr105832-3.c: New test.
2023-09-05c++: improve verify_constant diagnostic [PR91483]Marek Polacek2-1/+95
When verify_constant complains, it's pretty terse. Consider void test () { constexpr int i = 42; constexpr const int *p = &i; } where it says "'& i' is not a constant expression". OK, but why? With this patch, we say: b.C:5:28: error: '& i' is not a constant expression 5 | constexpr const int *p = &i; | ^~ b.C:5:28: note: pointer to 'i' is not a constant expression b.C:4:17: note: address of non-static constexpr variable 'i' may differ on each invocation of the enclosing function; add 'static' to give it a constant address 4 | constexpr int i = 42; | ^ | static which brings g++ on par with clang++. PR c++/91483 gcc/cp/ChangeLog: * constexpr.cc (verify_constant_explain_r): New. (verify_constant): Call it. gcc/testsuite/ChangeLog: * g++.dg/diagnostic/constexpr3.C: New test.
2023-09-05RISC-V: Add Types to Un-Typed Risc-v InstructionsEdwin Lu1-30/+82
Updates risc-v instructions to ensure that no instruction is left without a type attribute. Added new types "trap" and "cbo" (for cache related instructions) Tested for regressions using rv32/64 multilib with newlib/linux and rv32/64 gcv for linux. gcc/Changelog: * config/riscv/riscv.md: Update/Add types Reviewed-by: Jeff Law <jlaw@ventanamicro.com> Signed-off-by: Edwin Lu <ewlu@rivosinc.com>
2023-09-05RISC-V: Add Types to Un-Typed Pic InstructionsEdwin Lu1-10/+20
Updates pic instructions to ensure that no instruction is left without a type attribute. Tested for regressions using rv32/64 multilib with newlib/linux. gcc/Changelog: * config/riscv/pic.md: Update types Reviewed-by: Jeff Law <jlaw@ventanamicro.com> Signed-off-by: Edwin Lu <ewlu@rivosinc.com>
2023-09-05riscv: xtheadbb: Enable constant synthesis with th.srriChristoph Müllner2-1/+35
Some constants can be built up using rotate-right instructions. The code that enables this can be found in riscv_build_integer_1(). However, this functionality is only available for Zbb, which includes the rori instruction. This patch enables this also for XTheadBb, which includes the th.srri instruction. Signed-off-by: Christoph Müllner <christoph.muellner@vrull.eu> gcc/ChangeLog: * config/riscv/riscv.cc (riscv_build_integer_1): Enable constant synthesis with rotate-right for XTheadBb. gcc/testsuite/ChangeLog: * gcc.target/riscv/xtheadbb-li-rotr.c: New test.
2023-09-05c++: Diagnose [basic.scope.block]/2 violations even for block externs [PR52953]Jakub Jelinek4-19/+394
C++17 had in [basic.block.scope]/2 "A parameter name shall not be redeclared in the outermost block of the function definition nor in the outermost block of any handler associated with a function-try-block." and in [basic.block.scope]/4 similar rule for selection/iteration statements. My reading of that is that it applied even for block local externs in all those spots, while they declare something at namespace scope, the redeclaration happens in that outermost block etc. and introduces names into that. Those wordings seemed to have been moved somewhere else in C++20, but what's worse, they were moved back and completely rewritten in P1787R6: Declarations and where to find them which has been applied as a DR (but admittedly, we don't claim yet to implement that). The current wording at https://eel.is/c++draft/basic.scope#block-2 and https://eel.is/c++draft/basic.scope#scope-2.10 seem to imply at least to me that it doesn't apply to extern block local decls because their target scope is the namespace scope and [basic.scope.block]/2 says "and whose target scope is the block scope"... Now, it is unclear if that is actually the intent or not. There seems to be quite large implementation divergence on this as well. Unpatched g++ e.g. on the redeclaration-5.C testcase diagnoses just lines 55,58,67,70 (i.e. where the previous declaration is in for's condition). clang++ trunk diagnoses just lines 8 and 27, i.e. redeclaration in the function body vs. parameter both in normal fn and lambda (but not e.g. function-try-block and others, including ctors, but it diagnoses those for non-extern decls). ICC 19 diagnoses lines 8,32,38,41,45,52,55,58,61,64,67,70,76. And MSCV trunk diagnoses 8,27,32,38,41,45,48,52,55,58,67,70,76,87,100,137 although the last 4 are just warnings. g++ with the patch diagnoses 8,15,27,32,38,41,45,48,52,55,58,61,64,67,70,76,87,100,121,137 as the dg-error directives test. Jason said: > Yes, I suspect that should be > > If a declaration that is not a name-independent declaration and <del>whose > target scope is</del><ins>that binds a name in</ins> the block scope S of a > > which seems to also be needed to prohibit the already-diagnosed > > void f(int i) { union { int i; }; } > void g(int i) { enum { i }; } The following patch diagnoses DECL_EXTERNAL in check_local_shadow like !DECL_EXTERNAL, except that 1) it uses pedwarn instead of errors for those cases 2) it doesn't diagnose shadowing of namespace scope identifiers by block local externs, as they could be not actually shadowing but just redeclaring the same objects 2023-09-05 Jakub Jelinek <jakub@redhat.com> PR c++/52953 * name-lookup.cc (check_local_shadow): Don't punt early for DECL_EXTERNAL decls, instead just disable the shadowing of namespace decls check for those and emit a pedwarn rather than error_at or permerror for those. Formatting fix. * g++.dg/diagnostic/redeclaration-4.C: New test. * g++.dg/diagnostic/redeclaration-5.C: New test. * g++.dg/warn/Wshadow-19.C: New test.
2023-09-05c++: Diagnose [basic.scope.block]/2 violations even in compound-stmt of ↵Jakub Jelinek8-20/+250
function-try-block [PR52953] As the following testcase shows, while check_local_shadow diagnoses most of the [basic.scope.block]/2 violations, it doesn't diagnose when parameter's name is redeclared inside of the compound-stmt of a function-try-block. There is in that case an extra scope (sk_try with parent artificial sk_block with for FUNCTION_NEEDS_BODY_BLOCK another sk_block and only then sk_function_param). The in_function_try_handler case doesn't work correctly void foo (int x) try { } catch (int) { try { } catch (int x) { } try { } catch (int) { int x; } } (which is valid) is rejected, because || (TREE_CODE (old) == PARM_DECL && (current_binding_level->kind == sk_catch || current_binding_level->level_chain->kind == sk_catch) && in_function_try_handler)) is true but nothing verified that for the first case current_binding_level->level_chain->kind == sk_function_params (with perhaps artificial scopes in between and in the latter case with one extra level in between). The patch also changes behavior where for catch handlers of function-try-block the diagnostics will have the shadows function parameter wording as pedwarn rather than the old redeclaration permerror. 2023-09-05 Jakub Jelinek <jakub@redhat.com> PR c++/52953 * name-lookup.h (struct cp_binding_level): Add artificial bit-field. Formatting fixes. * name-lookup.cc (check_local_shadow): Skip artificial bindings when checking if parameter scope is parent scope. Don't special case FUNCTION_NEEDS_BODY_BLOCK. Diagnose the in_function_try_handler cases in the b->kind == sk_function_parms test and verify no non-artificial intervening scopes. Add missing auto_diagnostic_group. * decl.cc (begin_function_body): Set current_binding_level->artificial. * semantics.cc (begin_function_try_block): Likewise. * g++.dg/diagnostic/redeclaration-1.C: Expect different diagnostic wording. * g++.dg/diagnostic/redeclaration-3.C: New test. * g++.dg/parse/pr31952-1.C: Expect different diagnostic wording. * g++.dg/parse/pr31952-3.C: Likewise.
2023-09-05RISC-V: zicond: Fix opt2 patternVineet Gupta1-1/+1
Fixes: 1d5bc3285e8a ("[committed][RISC-V] Fix 20010221-1.c with zicond") This was tripping up gcc.c-torture/execute/pr60003.c at -O1 since in failing case, pattern semantics were not matching with asm czero.nez We start with the following src code snippet: if (a == 0) return 0; else return x; } which is equivalent to: "x = (a != 0) ? x : a" where x is NOT 0. ^^^^^^^^^^^^^^^^ and matches define_insn "*czero.nez.<GPR:mode><X:mode>.opt2" | (insn 41 20 38 3 (set (reg/v:DI 136 [ x ]) | (if_then_else:DI (ne (reg/v:DI 134 [ a ]) | (const_int 0 [0])) | (reg/v:DI 136 [ x ]) | (reg/v:DI 134 [ a ]))) {*czero.nez.didi.opt2} The corresponding asm pattern generates czero.nez x, x, a ; %0, %2, %1 which implies "x = (a != 0) ? 0 : a" clearly not what the pattern wants to do. Essentially "(a != 0) ? x : a" cannot be expressed with CZERO.nez if X is not guaranteed to be 0. However this can be fixed with a small tweak "x = (a != 0) ? x : a" is same as "x = (a == 0) ? a : x" and since middle operand is 0 when a == 0, it is equivalent to "x = (a == 0) ? 0 : x" which can be expressed with CZERO.eqz before fix after fix ----------------- ----------------- li a5,1 li a5,1 ld a4,8(sp) ld a4,8(sp) czero.nez a0,a4,a5 czero.eqz a0,a4,a5 The issue only happens at -O1 as at higher optimization levels, the whole conditional move gets optimized away. This fixes 4 testsuite failues in a zicond build: FAIL: gcc.c-torture/execute/pr60003.c -O1 execution test FAIL: gcc.dg/setjmp-3.c execution test FAIL: gcc.dg/torture/stackalign/setjmp-3.c -O1 execution test FAIL: gcc.dg/torture/stackalign/setjmp-3.c -O1 -fpic execution test gcc/ChangeLog: * config/riscv/zicond.md: Fix op2 pattern. Signed-off-by: Vineet Gupta <vineetg@rivosinc.com>
2023-09-05OpenMP: Avoid ICE in c_parser_omp_clause_allocate with invalid exprTobias Burnus2-1/+31
gcc/c/ChangeLog: * c-parser.cc (c_parser_omp_clause_allocate): Handle error_mark_node. gcc/testsuite/ChangeLog: * c-c++-common/gomp/allocate-13.c: New test.
2023-09-05aarch64: AARCH64_ISA_RCPC was defined twiceSzabolcs Nagy1-1/+0
gcc/ChangeLog: * config/aarch64/aarch64.h (AARCH64_ISA_RCPC): Remove dup.
2023-09-05c++: more dummy non_constant_p arg avoidancePatrick Palka1-3/+8
As a follow-up to Marek's r14-3088-ga263152643bbec, this patch makes us avoid passing an effectively dummy non_constant_p argument in two more spots in the parser so that we further avoid unnecessary constantness checks from cp_parser_constant_expression. gcc/cp/ChangeLog: * parser.cc (cp_parser_parenthesized_expression_list_elt): Pass nullptr as non_constant_p to cp_parser_braced_list if our non_constant_p is null. (cp_parser_initializer_list): Likewise to cp_parser_initializer_clause. Avoid inspecting clause_non_constant_p if it's uninitialized.
2023-09-05c++: use conversion_obstack_sentinel throughoutPatrick Palka1-85/+22
This replaces direct calls to conversion_obstack_alloc(0) and obstack_free with the recently added conversion_obstack_sentinel. In passing, I noticed build_user_type_conversion and build_operator_new_call don't free their conversion_obstack allocations, so this patch also uses this SFINAE helper in those two entry points. gcc/cp/ChangeLog: * call.cc (build_user_type_conversion): Free allocated conversions. (build_converted_constant_expr_internal): Use conversion_obstack_sentinel instead. (perform_dguide_overload_resolution): Likewise. (build_new_function_call): Likewise. (build_operator_new_call): Free allocated conversions. (build_op_call): Use conversion_obstack_sentinel instead. (build_conditional_expr): Use conversion_obstack_sentinel instead, and hoist it out to the outermost scope. (build_new_op): Use conversion_obstack_sentinel instead and set it up before the first goto. Remove second unneeded goto. (build_op_subscript): Use conversion_obstack_sentinel instead. (ref_conv_binds_to_temporary): Likewise. (build_new_method_call): Likewise. (can_convert_arg): Likewise. (can_convert_arg_bad): Likewise. (perform_implicit_conversion_flags): Likewise. (perform_direct_initialization_if_possible): Likewise. (initialize_reference): Likewise.
2023-09-05Daily bump.GCC Administrator9-1/+1520
2023-09-05LoongArch: Fix unintentionally breakage in r14-3665Xi Ruoyao1-0/+4
Fix a build failure with no system assembler or system old assembler. gcc/ChangeLog: * config/loongarch/loongarch-opts.h (HAVE_AS_EXPLICIT_RELOCS): Define to 0 if not defined yet.
2023-09-05RISC-V: Emit .note.GNU-stack for non-linux target as wellKito Cheng2-2/+2
We only emit that on linux target before, that not problem before, however Qemu has fix a bug to make qemu user mode honor PT_GNU_STACK[1], that will cause problem when we test baremetal with qemu. So the straightforward is enable that as well for non-linux toolchian, the price is that will increase few bytes for each binary. [1] https://github.com/qemu/qemu/commit/872f3d046f2381e3f416519e82df96bd60818311 gcc/ChangeLog: * config/riscv/linux.h (TARGET_ASM_FILE_END): Move ... * config/riscv/riscv.cc (TARGET_ASM_FILE_END): to here.
2023-09-05RISC-V: Support FP SGNJ autovec for VLS modePan Li5-12/+128
This patch would like to allow the VLS mode autovec for the floating-point binary operation MAX/MIN. Given below code example: void test(float * restrict out, float * restrict in1, float * restrict in2) { for (int i = 0; i < 128; i++) out[i] = __builtin_copysignf (in1[i], in2[i]); } Before this patch: test: csrr a4,vlenb slli a4,a4,1 li a5,128 bleu a5,a4,.L2 mv a5,a4 .L2: vsetvli zero,a5,e32,m8,ta,ma vle32.v v8,0(a1) vle32.v v16,0(a2) vsetvli a4,zero,e32,m8,ta,ma vfsgnj.vv v8,v8,v16 vsetvli zero,a5,e32,m8,ta,ma vse32.v v8,0(a0) ret After this patch: test: li a5,128 vsetvli zero,a5,e32,m1,ta,ma vle32.v v1,0(a1) vle32.v v2,0(a2) vfsgnj.vv v1,v1,v2 vse32.v v1,0(a0) ret Signed-off-by: Pan Li <pan2.li@intel.com> gcc/ChangeLog: * config/riscv/autovec-vls.md (copysign<mode>3): New pattern. * config/riscv/vector.md: Extend iterator for VLS. gcc/testsuite/ChangeLog: * gcc.target/riscv/rvv/autovec/vls/def.h: New macro. * gcc.target/riscv/rvv/autovec/vls/floating-point-sgnj-1.c: New test. * gcc.target/riscv/rvv/autovec/vls/floating-point-sgnj-2.c: New test.
2023-09-05LoongArch: Add Loongson ASX directive builtin function support.Lulu Cheng4-3/+6788
gcc/ChangeLog: * config.gcc: Export the header file lasxintrin.h. * config/loongarch/loongarch-builtins.cc (enum loongarch_builtin_type): Add Loongson ASX builtin functions support. (AVAIL_ALL): Ditto. (LASX_BUILTIN): Ditto. (LASX_NO_TARGET_BUILTIN): Ditto. (LASX_BUILTIN_TEST_BRANCH): Ditto. (CODE_FOR_lasx_xvsadd_b): Ditto. (CODE_FOR_lasx_xvsadd_h): Ditto. (CODE_FOR_lasx_xvsadd_w): Ditto. (CODE_FOR_lasx_xvsadd_d): Ditto. (CODE_FOR_lasx_xvsadd_bu): Ditto. (CODE_FOR_lasx_xvsadd_hu): Ditto. (CODE_FOR_lasx_xvsadd_wu): Ditto. (CODE_FOR_lasx_xvsadd_du): Ditto. (CODE_FOR_lasx_xvadd_b): Ditto. (CODE_FOR_lasx_xvadd_h): Ditto. (CODE_FOR_lasx_xvadd_w): Ditto. (CODE_FOR_lasx_xvadd_d): Ditto. (CODE_FOR_lasx_xvaddi_bu): Ditto. (CODE_FOR_lasx_xvaddi_hu): Ditto. (CODE_FOR_lasx_xvaddi_wu): Ditto. (CODE_FOR_lasx_xvaddi_du): Ditto. (CODE_FOR_lasx_xvand_v): Ditto. (CODE_FOR_lasx_xvandi_b): Ditto. (CODE_FOR_lasx_xvbitsel_v): Ditto. (CODE_FOR_lasx_xvseqi_b): Ditto. (CODE_FOR_lasx_xvseqi_h): Ditto. (CODE_FOR_lasx_xvseqi_w): Ditto. (CODE_FOR_lasx_xvseqi_d): Ditto. (CODE_FOR_lasx_xvslti_b): Ditto. (CODE_FOR_lasx_xvslti_h): Ditto. (CODE_FOR_lasx_xvslti_w): Ditto. (CODE_FOR_lasx_xvslti_d): Ditto. (CODE_FOR_lasx_xvslti_bu): Ditto. (CODE_FOR_lasx_xvslti_hu): Ditto. (CODE_FOR_lasx_xvslti_wu): Ditto. (CODE_FOR_lasx_xvslti_du): Ditto. (CODE_FOR_lasx_xvslei_b): Ditto. (CODE_FOR_lasx_xvslei_h): Ditto. (CODE_FOR_lasx_xvslei_w): Ditto. (CODE_FOR_lasx_xvslei_d): Ditto. (CODE_FOR_lasx_xvslei_bu): Ditto. (CODE_FOR_lasx_xvslei_hu): Ditto. (CODE_FOR_lasx_xvslei_wu): Ditto. (CODE_FOR_lasx_xvslei_du): Ditto. (CODE_FOR_lasx_xvdiv_b): Ditto. (CODE_FOR_lasx_xvdiv_h): Ditto. (CODE_FOR_lasx_xvdiv_w): Ditto. (CODE_FOR_lasx_xvdiv_d): Ditto. (CODE_FOR_lasx_xvdiv_bu): Ditto. (CODE_FOR_lasx_xvdiv_hu): Ditto. (CODE_FOR_lasx_xvdiv_wu): Ditto. (CODE_FOR_lasx_xvdiv_du): Ditto. (CODE_FOR_lasx_xvfadd_s): Ditto. (CODE_FOR_lasx_xvfadd_d): Ditto. (CODE_FOR_lasx_xvftintrz_w_s): Ditto. (CODE_FOR_lasx_xvftintrz_l_d): Ditto. (CODE_FOR_lasx_xvftintrz_wu_s): Ditto. (CODE_FOR_lasx_xvftintrz_lu_d): Ditto. (CODE_FOR_lasx_xvffint_s_w): Ditto. (CODE_FOR_lasx_xvffint_d_l): Ditto. (CODE_FOR_lasx_xvffint_s_wu): Ditto. (CODE_FOR_lasx_xvffint_d_lu): Ditto. (CODE_FOR_lasx_xvfsub_s): Ditto. (CODE_FOR_lasx_xvfsub_d): Ditto. (CODE_FOR_lasx_xvfmul_s): Ditto. (CODE_FOR_lasx_xvfmul_d): Ditto. (CODE_FOR_lasx_xvfdiv_s): Ditto. (CODE_FOR_lasx_xvfdiv_d): Ditto. (CODE_FOR_lasx_xvfmax_s): Ditto. (CODE_FOR_lasx_xvfmax_d): Ditto. (CODE_FOR_lasx_xvfmin_s): Ditto. (CODE_FOR_lasx_xvfmin_d): Ditto. (CODE_FOR_lasx_xvfsqrt_s): Ditto. (CODE_FOR_lasx_xvfsqrt_d): Ditto. (CODE_FOR_lasx_xvflogb_s): Ditto. (CODE_FOR_lasx_xvflogb_d): Ditto. (CODE_FOR_lasx_xvmax_b): Ditto. (CODE_FOR_lasx_xvmax_h): Ditto. (CODE_FOR_lasx_xvmax_w): Ditto. (CODE_FOR_lasx_xvmax_d): Ditto. (CODE_FOR_lasx_xvmaxi_b): Ditto. (CODE_FOR_lasx_xvmaxi_h): Ditto. (CODE_FOR_lasx_xvmaxi_w): Ditto. (CODE_FOR_lasx_xvmaxi_d): Ditto. (CODE_FOR_lasx_xvmax_bu): Ditto. (CODE_FOR_lasx_xvmax_hu): Ditto. (CODE_FOR_lasx_xvmax_wu): Ditto. (CODE_FOR_lasx_xvmax_du): Ditto. (CODE_FOR_lasx_xvmaxi_bu): Ditto. (CODE_FOR_lasx_xvmaxi_hu): Ditto. (CODE_FOR_lasx_xvmaxi_wu): Ditto. (CODE_FOR_lasx_xvmaxi_du): Ditto. (CODE_FOR_lasx_xvmin_b): Ditto. (CODE_FOR_lasx_xvmin_h): Ditto. (CODE_FOR_lasx_xvmin_w): Ditto. (CODE_FOR_lasx_xvmin_d): Ditto. (CODE_FOR_lasx_xvmini_b): Ditto. (CODE_FOR_lasx_xvmini_h): Ditto. (CODE_FOR_lasx_xvmini_w): Ditto. (CODE_FOR_lasx_xvmini_d): Ditto. (CODE_FOR_lasx_xvmin_bu): Ditto. (CODE_FOR_lasx_xvmin_hu): Ditto. (CODE_FOR_lasx_xvmin_wu): Ditto. (CODE_FOR_lasx_xvmin_du): Ditto. (CODE_FOR_lasx_xvmini_bu): Ditto. (CODE_FOR_lasx_xvmini_hu): Ditto. (CODE_FOR_lasx_xvmini_wu): Ditto. (CODE_FOR_lasx_xvmini_du): Ditto. (CODE_FOR_lasx_xvmod_b): Ditto. (CODE_FOR_lasx_xvmod_h): Ditto. (CODE_FOR_lasx_xvmod_w): Ditto. (CODE_FOR_lasx_xvmod_d): Ditto. (CODE_FOR_lasx_xvmod_bu): Ditto. (CODE_FOR_lasx_xvmod_hu): Ditto. (CODE_FOR_lasx_xvmod_wu): Ditto. (CODE_FOR_lasx_xvmod_du): Ditto. (CODE_FOR_lasx_xvmul_b): Ditto. (CODE_FOR_lasx_xvmul_h): Ditto. (CODE_FOR_lasx_xvmul_w): Ditto. (CODE_FOR_lasx_xvmul_d): Ditto. (CODE_FOR_lasx_xvclz_b): Ditto. (CODE_FOR_lasx_xvclz_h): Ditto. (CODE_FOR_lasx_xvclz_w): Ditto. (CODE_FOR_lasx_xvclz_d): Ditto. (CODE_FOR_lasx_xvnor_v): Ditto. (CODE_FOR_lasx_xvor_v): Ditto. (CODE_FOR_lasx_xvori_b): Ditto. (CODE_FOR_lasx_xvnori_b): Ditto. (CODE_FOR_lasx_xvpcnt_b): Ditto. (CODE_FOR_lasx_xvpcnt_h): Ditto. (CODE_FOR_lasx_xvpcnt_w): Ditto. (CODE_FOR_lasx_xvpcnt_d): Ditto. (CODE_FOR_lasx_xvxor_v): Ditto. (CODE_FOR_lasx_xvxori_b): Ditto. (CODE_FOR_lasx_xvsll_b): Ditto. (CODE_FOR_lasx_xvsll_h): Ditto. (CODE_FOR_lasx_xvsll_w): Ditto. (CODE_FOR_lasx_xvsll_d): Ditto. (CODE_FOR_lasx_xvslli_b): Ditto. (CODE_FOR_lasx_xvslli_h): Ditto. (CODE_FOR_lasx_xvslli_w): Ditto. (CODE_FOR_lasx_xvslli_d): Ditto. (CODE_FOR_lasx_xvsra_b): Ditto. (CODE_FOR_lasx_xvsra_h): Ditto. (CODE_FOR_lasx_xvsra_w): Ditto. (CODE_FOR_lasx_xvsra_d): Ditto. (CODE_FOR_lasx_xvsrai_b): Ditto. (CODE_FOR_lasx_xvsrai_h): Ditto. (CODE_FOR_lasx_xvsrai_w): Ditto. (CODE_FOR_lasx_xvsrai_d): Ditto. (CODE_FOR_lasx_xvsrl_b): Ditto. (CODE_FOR_lasx_xvsrl_h): Ditto. (CODE_FOR_lasx_xvsrl_w): Ditto. (CODE_FOR_lasx_xvsrl_d): Ditto. (CODE_FOR_lasx_xvsrli_b): Ditto. (CODE_FOR_lasx_xvsrli_h): Ditto. (CODE_FOR_lasx_xvsrli_w): Ditto. (CODE_FOR_lasx_xvsrli_d): Ditto. (CODE_FOR_lasx_xvsub_b): Ditto. (CODE_FOR_lasx_xvsub_h): Ditto. (CODE_FOR_lasx_xvsub_w): Ditto. (CODE_FOR_lasx_xvsub_d): Ditto. (CODE_FOR_lasx_xvsubi_bu): Ditto. (CODE_FOR_lasx_xvsubi_hu): Ditto. (CODE_FOR_lasx_xvsubi_wu): Ditto. (CODE_FOR_lasx_xvsubi_du): Ditto. (CODE_FOR_lasx_xvpackod_d): Ditto. (CODE_FOR_lasx_xvpackev_d): Ditto. (CODE_FOR_lasx_xvpickod_d): Ditto. (CODE_FOR_lasx_xvpickev_d): Ditto. (CODE_FOR_lasx_xvrepli_b): Ditto. (CODE_FOR_lasx_xvrepli_h): Ditto. (CODE_FOR_lasx_xvrepli_w): Ditto. (CODE_FOR_lasx_xvrepli_d): Ditto. (CODE_FOR_lasx_xvandn_v): Ditto. (CODE_FOR_lasx_xvorn_v): Ditto. (CODE_FOR_lasx_xvneg_b): Ditto. (CODE_FOR_lasx_xvneg_h): Ditto. (CODE_FOR_lasx_xvneg_w): Ditto. (CODE_FOR_lasx_xvneg_d): Ditto. (CODE_FOR_lasx_xvbsrl_v): Ditto. (CODE_FOR_lasx_xvbsll_v): Ditto. (CODE_FOR_lasx_xvfmadd_s): Ditto. (CODE_FOR_lasx_xvfmadd_d): Ditto. (CODE_FOR_lasx_xvfmsub_s): Ditto. (CODE_FOR_lasx_xvfmsub_d): Ditto. (CODE_FOR_lasx_xvfnmadd_s): Ditto. (CODE_FOR_lasx_xvfnmadd_d): Ditto. (CODE_FOR_lasx_xvfnmsub_s): Ditto. (CODE_FOR_lasx_xvfnmsub_d): Ditto. (CODE_FOR_lasx_xvpermi_q): Ditto. (CODE_FOR_lasx_xvpermi_d): Ditto. (CODE_FOR_lasx_xbnz_v): Ditto. (CODE_FOR_lasx_xbz_v): Ditto. (CODE_FOR_lasx_xvssub_b): Ditto. (CODE_FOR_lasx_xvssub_h): Ditto. (CODE_FOR_lasx_xvssub_w): Ditto. (CODE_FOR_lasx_xvssub_d): Ditto. (CODE_FOR_lasx_xvssub_bu): Ditto. (CODE_FOR_lasx_xvssub_hu): Ditto. (CODE_FOR_lasx_xvssub_wu): Ditto. (CODE_FOR_lasx_xvssub_du): Ditto. (CODE_FOR_lasx_xvabsd_b): Ditto. (CODE_FOR_lasx_xvabsd_h): Ditto. (CODE_FOR_lasx_xvabsd_w): Ditto. (CODE_FOR_lasx_xvabsd_d): Ditto. (CODE_FOR_lasx_xvabsd_bu): Ditto. (CODE_FOR_lasx_xvabsd_hu): Ditto. (CODE_FOR_lasx_xvabsd_wu): Ditto. (CODE_FOR_lasx_xvabsd_du): Ditto. (CODE_FOR_lasx_xvavg_b): Ditto. (CODE_FOR_lasx_xvavg_h): Ditto. (CODE_FOR_lasx_xvavg_w): Ditto. (CODE_FOR_lasx_xvavg_d): Ditto. (CODE_FOR_lasx_xvavg_bu): Ditto. (CODE_FOR_lasx_xvavg_hu): Ditto. (CODE_FOR_lasx_xvavg_wu): Ditto. (CODE_FOR_lasx_xvavg_du): Ditto. (CODE_FOR_lasx_xvavgr_b): Ditto. (CODE_FOR_lasx_xvavgr_h): Ditto. (CODE_FOR_lasx_xvavgr_w): Ditto. (CODE_FOR_lasx_xvavgr_d): Ditto. (CODE_FOR_lasx_xvavgr_bu): Ditto. (CODE_FOR_lasx_xvavgr_hu): Ditto. (CODE_FOR_lasx_xvavgr_wu): Ditto. (CODE_FOR_lasx_xvavgr_du): Ditto. (CODE_FOR_lasx_xvmuh_b): Ditto. (CODE_FOR_lasx_xvmuh_h): Ditto. (CODE_FOR_lasx_xvmuh_w): Ditto. (CODE_FOR_lasx_xvmuh_d): Ditto. (CODE_FOR_lasx_xvmuh_bu): Ditto. (CODE_FOR_lasx_xvmuh_hu): Ditto. (CODE_FOR_lasx_xvmuh_wu): Ditto. (CODE_FOR_lasx_xvmuh_du): Ditto. (CODE_FOR_lasx_xvssran_b_h): Ditto. (CODE_FOR_lasx_xvssran_h_w): Ditto. (CODE_FOR_lasx_xvssran_w_d): Ditto. (CODE_FOR_lasx_xvssran_bu_h): Ditto. (CODE_FOR_lasx_xvssran_hu_w): Ditto. (CODE_FOR_lasx_xvssran_wu_d): Ditto. (CODE_FOR_lasx_xvssrarn_b_h): Ditto. (CODE_FOR_lasx_xvssrarn_h_w): Ditto. (CODE_FOR_lasx_xvssrarn_w_d): Ditto. (CODE_FOR_lasx_xvssrarn_bu_h): Ditto. (CODE_FOR_lasx_xvssrarn_hu_w): Ditto. (CODE_FOR_lasx_xvssrarn_wu_d): Ditto. (CODE_FOR_lasx_xvssrln_bu_h): Ditto. (CODE_FOR_lasx_xvssrln_hu_w): Ditto. (CODE_FOR_lasx_xvssrln_wu_d): Ditto. (CODE_FOR_lasx_xvssrlrn_bu_h): Ditto. (CODE_FOR_lasx_xvssrlrn_hu_w): Ditto. (CODE_FOR_lasx_xvssrlrn_wu_d): Ditto. (CODE_FOR_lasx_xvftint_w_s): Ditto. (CODE_FOR_lasx_xvftint_l_d): Ditto. (CODE_FOR_lasx_xvftint_wu_s): Ditto. (CODE_FOR_lasx_xvftint_lu_d): Ditto. (CODE_FOR_lasx_xvsllwil_h_b): Ditto. (CODE_FOR_lasx_xvsllwil_w_h): Ditto. (CODE_FOR_lasx_xvsllwil_d_w): Ditto. (CODE_FOR_lasx_xvsllwil_hu_bu): Ditto. (CODE_FOR_lasx_xvsllwil_wu_hu): Ditto. (CODE_FOR_lasx_xvsllwil_du_wu): Ditto. (CODE_FOR_lasx_xvsat_b): Ditto. (CODE_FOR_lasx_xvsat_h): Ditto. (CODE_FOR_lasx_xvsat_w): Ditto. (CODE_FOR_lasx_xvsat_d): Ditto. (CODE_FOR_lasx_xvsat_bu): Ditto. (CODE_FOR_lasx_xvsat_hu): Ditto. (CODE_FOR_lasx_xvsat_wu): Ditto. (CODE_FOR_lasx_xvsat_du): Ditto. (loongarch_builtin_vectorized_function): Ditto. (loongarch_expand_builtin_insn): Ditto. (loongarch_expand_builtin): Ditto. * config/loongarch/loongarch-ftypes.def (1): Ditto. (2): Ditto. (3): Ditto. (4): Ditto. * config/loongarch/lasxintrin.h: New file.
2023-09-05LoongArch: Add Loongson ASX base instruction support.Lulu Cheng6-82/+7600
gcc/ChangeLog: * config/loongarch/loongarch-modes.def (VECTOR_MODES): Add Loongson ASX instruction support. * config/loongarch/loongarch-protos.h (loongarch_split_256bit_move): Ditto. (loongarch_split_256bit_move_p): Ditto. (loongarch_expand_vector_group_init): Ditto. (loongarch_expand_vec_perm_1): Ditto. * config/loongarch/loongarch.cc (loongarch_symbol_insns): Ditto. (loongarch_valid_offset_p): Ditto. (loongarch_address_insns): Ditto. (loongarch_const_insns): Ditto. (loongarch_legitimize_move): Ditto. (loongarch_builtin_vectorization_cost): Ditto. (loongarch_split_move_p): Ditto. (loongarch_split_move): Ditto. (loongarch_output_move_index_float): Ditto. (loongarch_split_256bit_move_p): Ditto. (loongarch_split_256bit_move): Ditto. (loongarch_output_move): Ditto. (loongarch_print_operand_reloc): Ditto. (loongarch_print_operand): Ditto. (loongarch_hard_regno_mode_ok_uncached): Ditto. (loongarch_hard_regno_nregs): Ditto. (loongarch_class_max_nregs): Ditto. (loongarch_can_change_mode_class): Ditto. (loongarch_mode_ok_for_mov_fmt_p): Ditto. (loongarch_vector_mode_supported_p): Ditto. (loongarch_preferred_simd_mode): Ditto. (loongarch_autovectorize_vector_modes): Ditto. (loongarch_lsx_output_division): Ditto. (loongarch_expand_lsx_shuffle): Ditto. (loongarch_expand_vec_perm): Ditto. (loongarch_expand_vec_perm_interleave): Ditto. (loongarch_try_expand_lsx_vshuf_const): Ditto. (loongarch_expand_vec_perm_even_odd_1): Ditto. (loongarch_expand_vec_perm_even_odd): Ditto. (loongarch_expand_vec_perm_1): Ditto. (loongarch_expand_vec_perm_const_2): Ditto. (loongarch_is_quad_duplicate): Ditto. (loongarch_is_double_duplicate): Ditto. (loongarch_is_odd_extraction): Ditto. (loongarch_is_even_extraction): Ditto. (loongarch_is_extraction_permutation): Ditto. (loongarch_is_center_extraction): Ditto. (loongarch_is_reversing_permutation): Ditto. (loongarch_is_di_misalign_extract): Ditto. (loongarch_is_si_misalign_extract): Ditto. (loongarch_is_lasx_lowpart_interleave): Ditto. (loongarch_is_lasx_lowpart_interleave_2): Ditto. (COMPARE_SELECTOR): Ditto. (loongarch_is_lasx_lowpart_extract): Ditto. (loongarch_is_lasx_highpart_interleave): Ditto. (loongarch_is_lasx_highpart_interleave_2): Ditto. (loongarch_is_elem_duplicate): Ditto. (loongarch_is_op_reverse_perm): Ditto. (loongarch_is_single_op_perm): Ditto. (loongarch_is_divisible_perm): Ditto. (loongarch_is_triple_stride_extract): Ditto. (loongarch_vectorize_vec_perm_const): Ditto. (loongarch_cpu_sched_reassociation_width): Ditto. (loongarch_expand_vector_extract): Ditto. (emit_reduc_half): Ditto. (loongarch_expand_vec_unpack): Ditto. (loongarch_expand_vector_group_init): Ditto. (loongarch_expand_vector_init): Ditto. (loongarch_expand_lsx_cmp): Ditto. (loongarch_builtin_support_vector_misalignment): Ditto. * config/loongarch/loongarch.h (UNITS_PER_LASX_REG): Ditto. (BITS_PER_LASX_REG): Ditto. (STRUCTURE_SIZE_BOUNDARY): Ditto. (LASX_REG_FIRST): Ditto. (LASX_REG_LAST): Ditto. (LASX_REG_NUM): Ditto. (LASX_REG_P): Ditto. (LASX_REG_RTX_P): Ditto. (LASX_SUPPORTED_MODE_P): Ditto. * config/loongarch/loongarch.md: Ditto. * config/loongarch/lasx.md: New file.
2023-09-05LoongArch: Add Loongson SX directive builtin function support.Lulu Cheng4-7/+7071
gcc/ChangeLog: * config.gcc: Export the header file lsxintrin.h. * config/loongarch/loongarch-builtins.cc (LARCH_FTYPE_NAME4): Add builtin function support. (enum loongarch_builtin_type): Ditto. (AVAIL_ALL): Ditto. (LARCH_BUILTIN): Ditto. (LSX_BUILTIN): Ditto. (LSX_BUILTIN_TEST_BRANCH): Ditto. (LSX_NO_TARGET_BUILTIN): Ditto. (CODE_FOR_lsx_vsadd_b): Ditto. (CODE_FOR_lsx_vsadd_h): Ditto. (CODE_FOR_lsx_vsadd_w): Ditto. (CODE_FOR_lsx_vsadd_d): Ditto. (CODE_FOR_lsx_vsadd_bu): Ditto. (CODE_FOR_lsx_vsadd_hu): Ditto. (CODE_FOR_lsx_vsadd_wu): Ditto. (CODE_FOR_lsx_vsadd_du): Ditto. (CODE_FOR_lsx_vadd_b): Ditto. (CODE_FOR_lsx_vadd_h): Ditto. (CODE_FOR_lsx_vadd_w): Ditto. (CODE_FOR_lsx_vadd_d): Ditto. (CODE_FOR_lsx_vaddi_bu): Ditto. (CODE_FOR_lsx_vaddi_hu): Ditto. (CODE_FOR_lsx_vaddi_wu): Ditto. (CODE_FOR_lsx_vaddi_du): Ditto. (CODE_FOR_lsx_vand_v): Ditto. (CODE_FOR_lsx_vandi_b): Ditto. (CODE_FOR_lsx_bnz_v): Ditto. (CODE_FOR_lsx_bz_v): Ditto. (CODE_FOR_lsx_vbitsel_v): Ditto. (CODE_FOR_lsx_vseqi_b): Ditto. (CODE_FOR_lsx_vseqi_h): Ditto. (CODE_FOR_lsx_vseqi_w): Ditto. (CODE_FOR_lsx_vseqi_d): Ditto. (CODE_FOR_lsx_vslti_b): Ditto. (CODE_FOR_lsx_vslti_h): Ditto. (CODE_FOR_lsx_vslti_w): Ditto. (CODE_FOR_lsx_vslti_d): Ditto. (CODE_FOR_lsx_vslti_bu): Ditto. (CODE_FOR_lsx_vslti_hu): Ditto. (CODE_FOR_lsx_vslti_wu): Ditto. (CODE_FOR_lsx_vslti_du): Ditto. (CODE_FOR_lsx_vslei_b): Ditto. (CODE_FOR_lsx_vslei_h): Ditto. (CODE_FOR_lsx_vslei_w): Ditto. (CODE_FOR_lsx_vslei_d): Ditto. (CODE_FOR_lsx_vslei_bu): Ditto. (CODE_FOR_lsx_vslei_hu): Ditto. (CODE_FOR_lsx_vslei_wu): Ditto. (CODE_FOR_lsx_vslei_du): Ditto. (CODE_FOR_lsx_vdiv_b): Ditto. (CODE_FOR_lsx_vdiv_h): Ditto. (CODE_FOR_lsx_vdiv_w): Ditto. (CODE_FOR_lsx_vdiv_d): Ditto. (CODE_FOR_lsx_vdiv_bu): Ditto. (CODE_FOR_lsx_vdiv_hu): Ditto. (CODE_FOR_lsx_vdiv_wu): Ditto. (CODE_FOR_lsx_vdiv_du): Ditto. (CODE_FOR_lsx_vfadd_s): Ditto. (CODE_FOR_lsx_vfadd_d): Ditto. (CODE_FOR_lsx_vftintrz_w_s): Ditto. (CODE_FOR_lsx_vftintrz_l_d): Ditto. (CODE_FOR_lsx_vftintrz_wu_s): Ditto. (CODE_FOR_lsx_vftintrz_lu_d): Ditto. (CODE_FOR_lsx_vffint_s_w): Ditto. (CODE_FOR_lsx_vffint_d_l): Ditto. (CODE_FOR_lsx_vffint_s_wu): Ditto. (CODE_FOR_lsx_vffint_d_lu): Ditto. (CODE_FOR_lsx_vfsub_s): Ditto. (CODE_FOR_lsx_vfsub_d): Ditto. (CODE_FOR_lsx_vfmul_s): Ditto. (CODE_FOR_lsx_vfmul_d): Ditto. (CODE_FOR_lsx_vfdiv_s): Ditto. (CODE_FOR_lsx_vfdiv_d): Ditto. (CODE_FOR_lsx_vfmax_s): Ditto. (CODE_FOR_lsx_vfmax_d): Ditto. (CODE_FOR_lsx_vfmin_s): Ditto. (CODE_FOR_lsx_vfmin_d): Ditto. (CODE_FOR_lsx_vfsqrt_s): Ditto. (CODE_FOR_lsx_vfsqrt_d): Ditto. (CODE_FOR_lsx_vflogb_s): Ditto. (CODE_FOR_lsx_vflogb_d): Ditto. (CODE_FOR_lsx_vmax_b): Ditto. (CODE_FOR_lsx_vmax_h): Ditto. (CODE_FOR_lsx_vmax_w): Ditto. (CODE_FOR_lsx_vmax_d): Ditto. (CODE_FOR_lsx_vmaxi_b): Ditto. (CODE_FOR_lsx_vmaxi_h): Ditto. (CODE_FOR_lsx_vmaxi_w): Ditto. (CODE_FOR_lsx_vmaxi_d): Ditto. (CODE_FOR_lsx_vmax_bu): Ditto. (CODE_FOR_lsx_vmax_hu): Ditto. (CODE_FOR_lsx_vmax_wu): Ditto. (CODE_FOR_lsx_vmax_du): Ditto. (CODE_FOR_lsx_vmaxi_bu): Ditto. (CODE_FOR_lsx_vmaxi_hu): Ditto. (CODE_FOR_lsx_vmaxi_wu): Ditto. (CODE_FOR_lsx_vmaxi_du): Ditto. (CODE_FOR_lsx_vmin_b): Ditto. (CODE_FOR_lsx_vmin_h): Ditto. (CODE_FOR_lsx_vmin_w): Ditto. (CODE_FOR_lsx_vmin_d): Ditto. (CODE_FOR_lsx_vmini_b): Ditto. (CODE_FOR_lsx_vmini_h): Ditto. (CODE_FOR_lsx_vmini_w): Ditto. (CODE_FOR_lsx_vmini_d): Ditto. (CODE_FOR_lsx_vmin_bu): Ditto. (CODE_FOR_lsx_vmin_hu): Ditto. (CODE_FOR_lsx_vmin_wu): Ditto. (CODE_FOR_lsx_vmin_du): Ditto. (CODE_FOR_lsx_vmini_bu): Ditto. (CODE_FOR_lsx_vmini_hu): Ditto. (CODE_FOR_lsx_vmini_wu): Ditto. (CODE_FOR_lsx_vmini_du): Ditto. (CODE_FOR_lsx_vmod_b): Ditto. (CODE_FOR_lsx_vmod_h): Ditto. (CODE_FOR_lsx_vmod_w): Ditto. (CODE_FOR_lsx_vmod_d): Ditto. (CODE_FOR_lsx_vmod_bu): Ditto. (CODE_FOR_lsx_vmod_hu): Ditto. (CODE_FOR_lsx_vmod_wu): Ditto. (CODE_FOR_lsx_vmod_du): Ditto. (CODE_FOR_lsx_vmul_b): Ditto. (CODE_FOR_lsx_vmul_h): Ditto. (CODE_FOR_lsx_vmul_w): Ditto. (CODE_FOR_lsx_vmul_d): Ditto. (CODE_FOR_lsx_vclz_b): Ditto. (CODE_FOR_lsx_vclz_h): Ditto. (CODE_FOR_lsx_vclz_w): Ditto. (CODE_FOR_lsx_vclz_d): Ditto. (CODE_FOR_lsx_vnor_v): Ditto. (CODE_FOR_lsx_vor_v): Ditto. (CODE_FOR_lsx_vori_b): Ditto. (CODE_FOR_lsx_vnori_b): Ditto. (CODE_FOR_lsx_vpcnt_b): Ditto. (CODE_FOR_lsx_vpcnt_h): Ditto. (CODE_FOR_lsx_vpcnt_w): Ditto. (CODE_FOR_lsx_vpcnt_d): Ditto. (CODE_FOR_lsx_vxor_v): Ditto. (CODE_FOR_lsx_vxori_b): Ditto. (CODE_FOR_lsx_vsll_b): Ditto. (CODE_FOR_lsx_vsll_h): Ditto. (CODE_FOR_lsx_vsll_w): Ditto. (CODE_FOR_lsx_vsll_d): Ditto. (CODE_FOR_lsx_vslli_b): Ditto. (CODE_FOR_lsx_vslli_h): Ditto. (CODE_FOR_lsx_vslli_w): Ditto. (CODE_FOR_lsx_vslli_d): Ditto. (CODE_FOR_lsx_vsra_b): Ditto. (CODE_FOR_lsx_vsra_h): Ditto. (CODE_FOR_lsx_vsra_w): Ditto. (CODE_FOR_lsx_vsra_d): Ditto. (CODE_FOR_lsx_vsrai_b): Ditto. (CODE_FOR_lsx_vsrai_h): Ditto. (CODE_FOR_lsx_vsrai_w): Ditto. (CODE_FOR_lsx_vsrai_d): Ditto. (CODE_FOR_lsx_vsrl_b): Ditto. (CODE_FOR_lsx_vsrl_h): Ditto. (CODE_FOR_lsx_vsrl_w): Ditto. (CODE_FOR_lsx_vsrl_d): Ditto. (CODE_FOR_lsx_vsrli_b): Ditto. (CODE_FOR_lsx_vsrli_h): Ditto. (CODE_FOR_lsx_vsrli_w): Ditto. (CODE_FOR_lsx_vsrli_d): Ditto. (CODE_FOR_lsx_vsub_b): Ditto. (CODE_FOR_lsx_vsub_h): Ditto. (CODE_FOR_lsx_vsub_w): Ditto. (CODE_FOR_lsx_vsub_d): Ditto. (CODE_FOR_lsx_vsubi_bu): Ditto. (CODE_FOR_lsx_vsubi_hu): Ditto. (CODE_FOR_lsx_vsubi_wu): Ditto. (CODE_FOR_lsx_vsubi_du): Ditto. (CODE_FOR_lsx_vpackod_d): Ditto. (CODE_FOR_lsx_vpackev_d): Ditto. (CODE_FOR_lsx_vpickod_d): Ditto. (CODE_FOR_lsx_vpickev_d): Ditto. (CODE_FOR_lsx_vrepli_b): Ditto. (CODE_FOR_lsx_vrepli_h): Ditto. (CODE_FOR_lsx_vrepli_w): Ditto. (CODE_FOR_lsx_vrepli_d): Ditto. (CODE_FOR_lsx_vsat_b): Ditto. (CODE_FOR_lsx_vsat_h): Ditto. (CODE_FOR_lsx_vsat_w): Ditto. (CODE_FOR_lsx_vsat_d): Ditto. (CODE_FOR_lsx_vsat_bu): Ditto. (CODE_FOR_lsx_vsat_hu): Ditto. (CODE_FOR_lsx_vsat_wu): Ditto. (CODE_FOR_lsx_vsat_du): Ditto. (CODE_FOR_lsx_vavg_b): Ditto. (CODE_FOR_lsx_vavg_h): Ditto. (CODE_FOR_lsx_vavg_w): Ditto. (CODE_FOR_lsx_vavg_d): Ditto. (CODE_FOR_lsx_vavg_bu): Ditto. (CODE_FOR_lsx_vavg_hu): Ditto. (CODE_FOR_lsx_vavg_wu): Ditto. (CODE_FOR_lsx_vavg_du): Ditto. (CODE_FOR_lsx_vavgr_b): Ditto. (CODE_FOR_lsx_vavgr_h): Ditto. (CODE_FOR_lsx_vavgr_w): Ditto. (CODE_FOR_lsx_vavgr_d): Ditto. (CODE_FOR_lsx_vavgr_bu): Ditto. (CODE_FOR_lsx_vavgr_hu): Ditto. (CODE_FOR_lsx_vavgr_wu): Ditto. (CODE_FOR_lsx_vavgr_du): Ditto. (CODE_FOR_lsx_vssub_b): Ditto. (CODE_FOR_lsx_vssub_h): Ditto. (CODE_FOR_lsx_vssub_w): Ditto. (CODE_FOR_lsx_vssub_d): Ditto. (CODE_FOR_lsx_vssub_bu): Ditto. (CODE_FOR_lsx_vssub_hu): Ditto. (CODE_FOR_lsx_vssub_wu): Ditto. (CODE_FOR_lsx_vssub_du): Ditto. (CODE_FOR_lsx_vabsd_b): Ditto. (CODE_FOR_lsx_vabsd_h): Ditto. (CODE_FOR_lsx_vabsd_w): Ditto. (CODE_FOR_lsx_vabsd_d): Ditto. (CODE_FOR_lsx_vabsd_bu): Ditto. (CODE_FOR_lsx_vabsd_hu): Ditto. (CODE_FOR_lsx_vabsd_wu): Ditto. (CODE_FOR_lsx_vabsd_du): Ditto. (CODE_FOR_lsx_vftint_w_s): Ditto. (CODE_FOR_lsx_vftint_l_d): Ditto. (CODE_FOR_lsx_vftint_wu_s): Ditto. (CODE_FOR_lsx_vftint_lu_d): Ditto. (CODE_FOR_lsx_vandn_v): Ditto. (CODE_FOR_lsx_vorn_v): Ditto. (CODE_FOR_lsx_vneg_b): Ditto. (CODE_FOR_lsx_vneg_h): Ditto. (CODE_FOR_lsx_vneg_w): Ditto. (CODE_FOR_lsx_vneg_d): Ditto. (CODE_FOR_lsx_vshuf4i_d): Ditto. (CODE_FOR_lsx_vbsrl_v): Ditto. (CODE_FOR_lsx_vbsll_v): Ditto. (CODE_FOR_lsx_vfmadd_s): Ditto. (CODE_FOR_lsx_vfmadd_d): Ditto. (CODE_FOR_lsx_vfmsub_s): Ditto. (CODE_FOR_lsx_vfmsub_d): Ditto. (CODE_FOR_lsx_vfnmadd_s): Ditto. (CODE_FOR_lsx_vfnmadd_d): Ditto. (CODE_FOR_lsx_vfnmsub_s): Ditto. (CODE_FOR_lsx_vfnmsub_d): Ditto. (CODE_FOR_lsx_vmuh_b): Ditto. (CODE_FOR_lsx_vmuh_h): Ditto. (CODE_FOR_lsx_vmuh_w): Ditto. (CODE_FOR_lsx_vmuh_d): Ditto. (CODE_FOR_lsx_vmuh_bu): Ditto. (CODE_FOR_lsx_vmuh_hu): Ditto. (CODE_FOR_lsx_vmuh_wu): Ditto. (CODE_FOR_lsx_vmuh_du): Ditto. (CODE_FOR_lsx_vsllwil_h_b): Ditto. (CODE_FOR_lsx_vsllwil_w_h): Ditto. (CODE_FOR_lsx_vsllwil_d_w): Ditto. (CODE_FOR_lsx_vsllwil_hu_bu): Ditto. (CODE_FOR_lsx_vsllwil_wu_hu): Ditto. (CODE_FOR_lsx_vsllwil_du_wu): Ditto. (CODE_FOR_lsx_vssran_b_h): Ditto. (CODE_FOR_lsx_vssran_h_w): Ditto. (CODE_FOR_lsx_vssran_w_d): Ditto. (CODE_FOR_lsx_vssran_bu_h): Ditto. (CODE_FOR_lsx_vssran_hu_w): Ditto. (CODE_FOR_lsx_vssran_wu_d): Ditto. (CODE_FOR_lsx_vssrarn_b_h): Ditto. (CODE_FOR_lsx_vssrarn_h_w): Ditto. (CODE_FOR_lsx_vssrarn_w_d): Ditto. (CODE_FOR_lsx_vssrarn_bu_h): Ditto. (CODE_FOR_lsx_vssrarn_hu_w): Ditto. (CODE_FOR_lsx_vssrarn_wu_d): Ditto. (CODE_FOR_lsx_vssrln_bu_h): Ditto. (CODE_FOR_lsx_vssrln_hu_w): Ditto. (CODE_FOR_lsx_vssrln_wu_d): Ditto. (CODE_FOR_lsx_vssrlrn_bu_h): Ditto. (CODE_FOR_lsx_vssrlrn_hu_w): Ditto. (CODE_FOR_lsx_vssrlrn_wu_d): Ditto. (loongarch_builtin_vector_type): Ditto. (loongarch_build_cvpointer_type): Ditto. (LARCH_ATYPE_CVPOINTER): Ditto. (LARCH_ATYPE_BOOLEAN): Ditto. (LARCH_ATYPE_V2SF): Ditto. (LARCH_ATYPE_V2HI): Ditto. (LARCH_ATYPE_V2SI): Ditto. (LARCH_ATYPE_V4QI): Ditto. (LARCH_ATYPE_V4HI): Ditto. (LARCH_ATYPE_V8QI): Ditto. (LARCH_ATYPE_V2DI): Ditto. (LARCH_ATYPE_V4SI): Ditto. (LARCH_ATYPE_V8HI): Ditto. (LARCH_ATYPE_V16QI): Ditto. (LARCH_ATYPE_V2DF): Ditto. (LARCH_ATYPE_V4SF): Ditto. (LARCH_ATYPE_V4DI): Ditto. (LARCH_ATYPE_V8SI): Ditto. (LARCH_ATYPE_V16HI): Ditto. (LARCH_ATYPE_V32QI): Ditto. (LARCH_ATYPE_V4DF): Ditto. (LARCH_ATYPE_V8SF): Ditto. (LARCH_ATYPE_UV2DI): Ditto. (LARCH_ATYPE_UV4SI): Ditto. (LARCH_ATYPE_UV8HI): Ditto. (LARCH_ATYPE_UV16QI): Ditto. (LARCH_ATYPE_UV4DI): Ditto. (LARCH_ATYPE_UV8SI): Ditto. (LARCH_ATYPE_UV16HI): Ditto. (LARCH_ATYPE_UV32QI): Ditto. (LARCH_ATYPE_UV2SI): Ditto. (LARCH_ATYPE_UV4HI): Ditto. (LARCH_ATYPE_UV8QI): Ditto. (loongarch_builtin_vectorized_function): Ditto. (LARCH_GET_BUILTIN): Ditto. (loongarch_expand_builtin_insn): Ditto. (loongarch_expand_builtin_lsx_test_branch): Ditto. (loongarch_expand_builtin): Ditto. * config/loongarch/loongarch-ftypes.def (1): Ditto. (2): Ditto. (3): Ditto. (4): Ditto. * config/loongarch/lsxintrin.h: New file.
2023-09-05LoongArch: Add Loongson SX base instruction support.Lulu Cheng12-95/+7093
gcc/ChangeLog: * config/loongarch/constraints.md (M): Add Loongson LSX base instruction support. (N): Ditto. (O): Ditto. (P): Ditto. (R): Ditto. (S): Ditto. (YG): Ditto. (YA): Ditto. (YB): Ditto. (Yb): Ditto. (Yh): Ditto. (Yw): Ditto. (YI): Ditto. (YC): Ditto. (YZ): Ditto. (Unv5): Ditto. (Uuv5): Ditto. (Usv5): Ditto. (Uuv6): Ditto. (Urv8): Ditto. * config/loongarch/genopts/loongarch.opt.in: Ditto. * config/loongarch/loongarch-builtins.cc (loongarch_gen_const_int_vector): Ditto. * config/loongarch/loongarch-modes.def (VECTOR_MODES): Ditto. (VECTOR_MODE): Ditto. (INT_MODE): Ditto. * config/loongarch/loongarch-protos.h (loongarch_split_move_insn_p): Ditto. (loongarch_split_move_insn): Ditto. (loongarch_split_128bit_move): Ditto. (loongarch_split_128bit_move_p): Ditto. (loongarch_split_lsx_copy_d): Ditto. (loongarch_split_lsx_insert_d): Ditto. (loongarch_split_lsx_fill_d): Ditto. (loongarch_expand_vec_cmp): Ditto. (loongarch_const_vector_same_val_p): Ditto. (loongarch_const_vector_same_bytes_p): Ditto. (loongarch_const_vector_same_int_p): Ditto. (loongarch_const_vector_shuffle_set_p): Ditto. (loongarch_const_vector_bitimm_set_p): Ditto. (loongarch_const_vector_bitimm_clr_p): Ditto. (loongarch_lsx_vec_parallel_const_half): Ditto. (loongarch_gen_const_int_vector): Ditto. (loongarch_lsx_output_division): Ditto. (loongarch_expand_vector_init): Ditto. (loongarch_expand_vec_unpack): Ditto. (loongarch_expand_vec_perm): Ditto. (loongarch_expand_vector_extract): Ditto. (loongarch_expand_vector_reduc): Ditto. (loongarch_ldst_scaled_shift): Ditto. (loongarch_expand_vec_cond_expr): Ditto. (loongarch_expand_vec_cond_mask_expr): Ditto. (loongarch_builtin_vectorized_function): Ditto. (loongarch_gen_const_int_vector_shuffle): Ditto. (loongarch_build_signbit_mask): Ditto. * config/loongarch/loongarch.cc (loongarch_pass_aggregate_num_fpr): Ditto. (loongarch_setup_incoming_varargs): Ditto. (loongarch_emit_move): Ditto. (loongarch_const_vector_bitimm_set_p): Ditto. (loongarch_const_vector_bitimm_clr_p): Ditto. (loongarch_const_vector_same_val_p): Ditto. (loongarch_const_vector_same_bytes_p): Ditto. (loongarch_const_vector_same_int_p): Ditto. (loongarch_const_vector_shuffle_set_p): Ditto. (loongarch_symbol_insns): Ditto. (loongarch_cannot_force_const_mem): Ditto. (loongarch_valid_offset_p): Ditto. (loongarch_valid_index_p): Ditto. (loongarch_classify_address): Ditto. (loongarch_address_insns): Ditto. (loongarch_ldst_scaled_shift): Ditto. (loongarch_const_insns): Ditto. (loongarch_split_move_insn_p): Ditto. (loongarch_subword_at_byte): Ditto. (loongarch_legitimize_move): Ditto. (loongarch_builtin_vectorization_cost): Ditto. (loongarch_split_move_p): Ditto. (loongarch_split_move): Ditto. (loongarch_split_move_insn): Ditto. (loongarch_output_move_index_float): Ditto. (loongarch_split_128bit_move_p): Ditto. (loongarch_split_128bit_move): Ditto. (loongarch_split_lsx_copy_d): Ditto. (loongarch_split_lsx_insert_d): Ditto. (loongarch_split_lsx_fill_d): Ditto. (loongarch_output_move): Ditto. (loongarch_extend_comparands): Ditto. (loongarch_print_operand_reloc): Ditto. (loongarch_print_operand): Ditto. (loongarch_hard_regno_mode_ok_uncached): Ditto. (loongarch_hard_regno_call_part_clobbered): Ditto. (loongarch_hard_regno_nregs): Ditto. (loongarch_class_max_nregs): Ditto. (loongarch_can_change_mode_class): Ditto. (loongarch_mode_ok_for_mov_fmt_p): Ditto. (loongarch_secondary_reload): Ditto. (loongarch_vector_mode_supported_p): Ditto. (loongarch_preferred_simd_mode): Ditto. (loongarch_autovectorize_vector_modes): Ditto. (loongarch_lsx_output_division): Ditto. (loongarch_option_override_internal): Ditto. (loongarch_hard_regno_caller_save_mode): Ditto. (MAX_VECT_LEN): Ditto. (loongarch_spill_class): Ditto. (struct expand_vec_perm_d): Ditto. (loongarch_promote_function_mode): Ditto. (loongarch_expand_vselect): Ditto. (loongarch_starting_frame_offset): Ditto. (loongarch_expand_vselect_vconcat): Ditto. (TARGET_ASM_ALIGNED_DI_OP): Ditto. (TARGET_OPTION_OVERRIDE): Ditto. (TARGET_LEGITIMIZE_ADDRESS): Ditto. (TARGET_ASM_SELECT_RTX_SECTION): Ditto. (TARGET_ASM_FUNCTION_RODATA_SECTION): Ditto. (loongarch_expand_lsx_shuffle): Ditto. (TARGET_SCHED_INIT): Ditto. (TARGET_SCHED_REORDER): Ditto. (TARGET_SCHED_REORDER2): Ditto. (TARGET_SCHED_VARIABLE_ISSUE): Ditto. (TARGET_SCHED_ADJUST_COST): Ditto. (TARGET_SCHED_ISSUE_RATE): Ditto. (TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD): Ditto. (TARGET_FUNCTION_OK_FOR_SIBCALL): Ditto. (TARGET_VALID_POINTER_MODE): Ditto. (TARGET_REGISTER_MOVE_COST): Ditto. (TARGET_MEMORY_MOVE_COST): Ditto. (TARGET_RTX_COSTS): Ditto. (TARGET_ADDRESS_COST): Ditto. (TARGET_IN_SMALL_DATA_P): Ditto. (TARGET_PREFERRED_RELOAD_CLASS): Ditto. (TARGET_ASM_FILE_START_FILE_DIRECTIVE): Ditto. (TARGET_EXPAND_BUILTIN_VA_START): Ditto. (loongarch_expand_vec_perm): Ditto. (TARGET_PROMOTE_FUNCTION_MODE): Ditto. (TARGET_RETURN_IN_MEMORY): Ditto. (TARGET_FUNCTION_VALUE): Ditto. (TARGET_LIBCALL_VALUE): Ditto. (loongarch_try_expand_lsx_vshuf_const): Ditto. (TARGET_ASM_OUTPUT_MI_THUNK): Ditto. (TARGET_ASM_CAN_OUTPUT_MI_THUNK): Ditto. (TARGET_PRINT_OPERAND): Ditto. (TARGET_PRINT_OPERAND_ADDRESS): Ditto. (TARGET_PRINT_OPERAND_PUNCT_VALID_P): Ditto. (TARGET_SETUP_INCOMING_VARARGS): Ditto. (TARGET_STRICT_ARGUMENT_NAMING): Ditto. (TARGET_MUST_PASS_IN_STACK): Ditto. (TARGET_PASS_BY_REFERENCE): Ditto. (TARGET_ARG_PARTIAL_BYTES): Ditto. (TARGET_FUNCTION_ARG): Ditto. (TARGET_FUNCTION_ARG_ADVANCE): Ditto. (TARGET_FUNCTION_ARG_BOUNDARY): Ditto. (TARGET_SCALAR_MODE_SUPPORTED_P): Ditto. (TARGET_INIT_BUILTINS): Ditto. (loongarch_expand_vec_perm_const_1): Ditto. (loongarch_expand_vec_perm_const_2): Ditto. (loongarch_vectorize_vec_perm_const): Ditto. (loongarch_cpu_sched_reassociation_width): Ditto. (loongarch_sched_reassociation_width): Ditto. (loongarch_expand_vector_extract): Ditto. (emit_reduc_half): Ditto. (loongarch_expand_vector_reduc): Ditto. (loongarch_expand_vec_unpack): Ditto. (loongarch_lsx_vec_parallel_const_half): Ditto. (loongarch_constant_elt_p): Ditto. (loongarch_gen_const_int_vector_shuffle): Ditto. (loongarch_expand_vector_init): Ditto. (loongarch_expand_lsx_cmp): Ditto. (loongarch_expand_vec_cond_expr): Ditto. (loongarch_expand_vec_cond_mask_expr): Ditto. (loongarch_expand_vec_cmp): Ditto. (loongarch_case_values_threshold): Ditto. (loongarch_build_const_vector): Ditto. (loongarch_build_signbit_mask): Ditto. (loongarch_builtin_support_vector_misalignment): Ditto. (TARGET_ASM_ALIGNED_HI_OP): Ditto. (TARGET_ASM_ALIGNED_SI_OP): Ditto. (TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST): Ditto. (TARGET_VECTOR_MODE_SUPPORTED_P): Ditto. (TARGET_VECTORIZE_PREFERRED_SIMD_MODE): Ditto. (TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES): Ditto. (TARGET_VECTORIZE_VEC_PERM_CONST): Ditto. (TARGET_SCHED_REASSOCIATION_WIDTH): Ditto. (TARGET_CASE_VALUES_THRESHOLD): Ditto. (TARGET_HARD_REGNO_CALL_PART_CLOBBERED): Ditto. (TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT): Ditto. * config/loongarch/loongarch.h (TARGET_SUPPORTS_WIDE_INT): Ditto. (UNITS_PER_LSX_REG): Ditto. (BITS_PER_LSX_REG): Ditto. (BIGGEST_ALIGNMENT): Ditto. (LSX_REG_FIRST): Ditto. (LSX_REG_LAST): Ditto. (LSX_REG_NUM): Ditto. (LSX_REG_P): Ditto. (LSX_REG_RTX_P): Ditto. (IMM13_OPERAND): Ditto. (LSX_SUPPORTED_MODE_P): Ditto. * config/loongarch/loongarch.md (unknown,add,sub,not,nor,and,or,xor): Ditto. (unknown,add,sub,not,nor,and,or,xor,simd_add): Ditto. (unknown,none,QI,HI,SI,DI,TI,SF,DF,TF,FCC): Ditto. (mode" ): Ditto. (DF): Ditto. (SF): Ditto. (sf): Ditto. (DI): Ditto. (SI): Ditto. * config/loongarch/loongarch.opt: Ditto. * config/loongarch/predicates.md (const_lsx_branch_operand): Ditto. (const_uimm3_operand): Ditto. (const_8_to_11_operand): Ditto. (const_12_to_15_operand): Ditto. (const_uimm4_operand): Ditto. (const_uimm6_operand): Ditto. (const_uimm7_operand): Ditto. (const_uimm8_operand): Ditto. (const_imm5_operand): Ditto. (const_imm10_operand): Ditto. (const_imm13_operand): Ditto. (reg_imm10_operand): Ditto. (aq8b_operand): Ditto. (aq8h_operand): Ditto. (aq8w_operand): Ditto. (aq8d_operand): Ditto. (aq10b_operand): Ditto. (aq10h_operand): Ditto. (aq10w_operand): Ditto. (aq10d_operand): Ditto. (aq12b_operand): Ditto. (aq12h_operand): Ditto. (aq12w_operand): Ditto. (aq12d_operand): Ditto. (const_m1_operand): Ditto. (reg_or_m1_operand): Ditto. (const_exp_2_operand): Ditto. (const_exp_4_operand): Ditto. (const_exp_8_operand): Ditto. (const_exp_16_operand): Ditto. (const_exp_32_operand): Ditto. (const_0_or_1_operand): Ditto. (const_0_to_3_operand): Ditto. (const_0_to_7_operand): Ditto. (const_2_or_3_operand): Ditto. (const_4_to_7_operand): Ditto. (const_8_to_15_operand): Ditto. (const_16_to_31_operand): Ditto. (qi_mask_operand): Ditto. (hi_mask_operand): Ditto. (si_mask_operand): Ditto. (d_operand): Ditto. (db4_operand): Ditto. (db7_operand): Ditto. (db8_operand): Ditto. (ib3_operand): Ditto. (sb4_operand): Ditto. (sb5_operand): Ditto. (sb8_operand): Ditto. (sd8_operand): Ditto. (ub4_operand): Ditto. (ub8_operand): Ditto. (uh4_operand): Ditto. (uw4_operand): Ditto. (uw5_operand): Ditto. (uw6_operand): Ditto. (uw8_operand): Ditto. (addiur2_operand): Ditto. (addiusp_operand): Ditto. (andi16_operand): Ditto. (movep_src_register): Ditto. (movep_src_operand): Ditto. (fcc_reload_operand): Ditto. (muldiv_target_operand): Ditto. (const_vector_same_val_operand): Ditto. (const_vector_same_simm5_operand): Ditto. (const_vector_same_uimm5_operand): Ditto. (const_vector_same_ximm5_operand): Ditto. (const_vector_same_uimm6_operand): Ditto. (par_const_vector_shf_set_operand): Ditto. (reg_or_vector_same_val_operand): Ditto. (reg_or_vector_same_simm5_operand): Ditto. (reg_or_vector_same_uimm5_operand): Ditto. (reg_or_vector_same_ximm5_operand): Ditto. (reg_or_vector_same_uimm6_operand): Ditto. * doc/md.texi: Ditto. * config/loongarch/lsx.md: New file.
2023-09-05ada: Elide the copy in extended returns for nonlimited by-reference typesEric Botcazou1-1/+1
gcc/ada/ * gcc-interface/trans.cc (gnat_to_gnu): Really test Storage_Pool on the simple return statement.
2023-09-05ada: Fix DWARF for certain arraysTom Tromey2-8/+14
An array whose index type is a nonstandard enum will be marked as "packed", but should not emit DW_AT_bit_stride unless it is also bit-packed. gcc/ada/ * gcc-interface/decl.cc (gnat_to_gnu_entity): Set bit-packed for constrained and unconstrained array types. * gcc-interface/misc.cc (gnat_get_array_descr_info): Examine BIT_PACKED_ARRAY_TYPE_P.
2023-09-05ada: Remove redundant protection against empty listPiotr Trojanek1-21/+19
Calls to First on No_List intentionally return Empty, so explicit guards against No_List are unnecessary. Code cleanup; semantics is unaffected. gcc/ada/ * sem_type.adb (Interface_Present_In_Ancestor): Remove guard against no list of interfaces; fix style in comments (trailing dots).
2023-09-05ada: Add guard before querying the type for its interfacesPiotr Trojanek1-1/+3
Fix crash on illegal code, when routine Iface_Present_In_Ancestor is called on the predefined String type and attempts to examine the list of interfaces. gcc/ada/ * sem_type.adb (Iface_Present_In_Ancestor): Only look at the list of interfaces for types that allow it. The guard is a high-level equivalent of the entity kinds listed in the preconditon of the Interfaces query.
2023-09-05ada: Remove redundant guard against an empty list of interfacesPiotr Trojanek1-3/+1
Code cleanup; semantics is unaffected. gcc/ada/ * sem_type.adb (Iface_Present_In_Ancestor): Remove guard for empty list of interfaces; the following loop will work just fine without it.
2023-09-05ada: Fix problematic secondary stack management in protected entryEric Botcazou1-1/+1
The secondary stack mark goes formally out of scope before the finalizer reads it to reclaim the storage. gcc/ada/ * exp_ch9.adb (Build_Protected_Entry): Move the At_End procedure from the entry body to the inner block statement.
2023-09-05ada: Fix crash on selected component lookup in generic instanceBob Duff1-3/+7
This patch fixes a compiler crash on selected component lookup in an instance of a generic unit when the relevant type is an itype. gcc/ada/ * sem_ch4.adb (Find_Component_In_Instance): Check that Declaration_Node (Par) is not Empty, as it is for itypes.
2023-09-05ada: Fix spurious warning emissionsRonan Desplanques1-6/+11
Before this patch, warnings handled by `Sem_Warn.Check_References` were erroneously emitted in some cases. Here is an example of a program that, when compiled with the `-gnatwu` switch, triggered the bug: procedure Main is package T is A : Integer; end T; begin T.A := 7; end Main; The following message was emitted: main.adb:3:07: warning: variable "A" is never read and never assigned [-gnatwu] This patch mitigates the issue by restricting the cases in which `Sem_Warn.Check_References` is called for package specifications. Note that the recursive calls in `Sem_Warn.Check_References` can be used to convince oneself that this patch does not remove legitimate warnings for non-library-level package specifications. gcc/ada/ * sem_ch7.adb (Analyze_Package_Declaration): Restrict calls to `Sem_Warn.Check_References` and adjust comment accordingly.
2023-09-05ada: Fix assertion failure on very peculiar enumeration typeEric Botcazou1-0/+14
The compiler currently does not support the combination of a representation clause on an enumeration type with a size clause whose value is greater than the size of the largest machine scalar supported by the target. Given that such a type would have little practical value, this change causes the compiler to give a proper error message instead of aborting. gcc/ada/ * freeze.adb (Freeze_Enumeration_Type): Give an error on a type with both representation clause and too large size.
2023-09-05ada: Remove TBC comment, no more neededLiaiss Merzougue1-1/+0
gcc/ada/ * libgnat/s-imguti.adb: Remove comment.
2023-09-05ada: Crash on creation of extra formals on type extensionJavier Miranda3-7/+67
The compiler blows up processing an overriding dispatching function of a derived tagged type that returns a private tagged type that has an access type discriminant. gcc/ada/ * accessibility.ads (Needs_Result_Accessibility_Extra_Formal): New subprogram. * accessibility.adb (Needs_Result_Accessibility_Level_Param): New subprogram. (Needs_Result_Accessibility_Extra_Formal): New subprogram, temporarily keep the previous behavior of the frontend. * sem_ch6.adb (Create_Extra_Formals): Replace occurrences of function Needs_Result_Accessibility_Level_Param by calls to function Needs_Result_Accessibility_Extra_Formal. (Extra_Formals_OK): Ditto.
2023-09-05ada: Pass -msmp when linking for ppc-vx6 --RTS=rtp-smpAlexandre Oliva1-0/+1
gprbuild and gnatmake won't pass --RTS=rtp-smp to the compiler driver for linking. The flag was not used during linking: the .spec files named as linker options were all we passed for the linker to get the -L flags for lib_smp and lib. There was a problem, though: although /lib_smp/ and /lib/ were to be searched in this order, and the specs files did that correctly, the compiler would search /lib/ first regardless, because STARTFILE_PREFIX_SPEC said so, and specs files cannot override that. With this patch, we make sure the rtp-smp runtime causes -msmp to be added to the command line passed to the compiler driver for linking, and a corresponding patch for the ppc-vxworks configuration makes the GCC compiler driver use this flag to select /lib_smp/ rather than /lib/. gcc/ada/ * libgnat/system-vxworks-ppc-rtp-smp.ads: Add -msmp to Linker_Options pragma.
2023-09-05ada: Crash on function returning empty Ada 2022 aggregateJavier Miranda3-2/+37
The compiler crashes processing a function that returns an empty aggregate when its returned type is a record type which defined its container aggregate aspects. gcc/ada/ * exp_aggr.adb (Expand_Container_Aggregate): Report warning on infinite recursion if an empty container aggregate appears in the return statement of its Empty function. Fix typo in comment. * sem_aggr.adb (Resolve_Aggregate): Resolve Ada 2022 empty aggregate that initializes a record type that has defined its container aggregate aspects. (Resolve_Iterated_Association): Protect access to attribute Etype. * sem_ch13.adb (Resolve_Aspect_Aggregate): Fix typo in comment.
2023-09-05ada: Compiler hangs on invalid postconditionSteve Baird1-1/+3
In some cases involving an illegal reference to F'Result in the postcondition for a function not named F, the compiler would hang instead of correctly diagnosing the error. gcc/ada/ * sem_attr.adb (Denote_Same_Function): Handle the case where Has_Homonym (Pref_Id) returns True but Homonym (Pref_Id) returns an empty result.
2023-09-05ada: Spurious warning about negative modular literalSteve Baird1-0/+1
If -gnatw.m is enabled, the compiler generates a warning if a unary minus operator of a modular type is applied to an integer literal. This warning was being incorrectly generated in some cases where no integer literal is present in the source code. gcc/ada/ * sem_res.adb (Resolve_Unary_Op): In deciding whether to emit a warning about a modular type's unary minus operator being applied to an integer literal, ignore integer literals for which Comes_From_Source is False.
2023-09-05ada: Support setting task affinity on QNXJohannes Kliemann1-5/+40
QNX does not support setting the thread affinity via a POSIX API. This implementation uses QNX's native Thread_Ctl API to set the thread affinity for Ada tasks. gcc/ada/ * libgnarl/s-taprop__qnx.adb: Implement Set_Task_Affinity.
2023-09-05ada: building_executable_programs_with_gnat.rst: fix -gnatw.x indexGhjuvan Lacambre2-3/+3
The index for this paragraph was wrong. gcc/ada/ * doc/gnat_ugn/building_executable_programs_with_gnat.rst: Fix index. * gnat_ugn.texi: Regenerate.
2023-09-05ada: Preserve capability validity in address arithmeticDaniel King11-65/+76
On CHERI targets where System.Address is a capability, arithmetic on addresses should avoid converting to integers and instead use the operations defined in System.Storage_Elements to perform the arithmetic directly on the System.Address object. This preserves the capability's validity throughout the calculation, ensuring that the resulting capability can be dereferenced. gcc/ada/ * libgnat/s-carsi8.adb: Use operations from System.Storage_Elements for address arithmetic. * libgnat/s-carun8.adb: Likewise * libgnat/s-casi128.adb: Likewise * libgnat/s-casi16.adb: Likewise * libgnat/s-casi32.adb: Likewise * libgnat/s-casi64.adb: Likewise * libgnat/s-caun128.adb: Likewise * libgnat/s-caun16.adb: Likewise * libgnat/s-caun32.adb: Likewise * libgnat/s-caun64.adb: Likewise * libgnat/s-geveop.adb: Likewise
2023-09-05ada: Fix internal error on instantiation with private component typeEric Botcazou1-6/+48
First, this fixes an internal error on the instantiation of a nested generic package taking an array type whose component type is a private type declared in the parent package as formal type parameter. In the body of the instance, the full view of the private type is visible and must be restored by means of the Check_Generic_Actuals mechanism. Second, this fixes the same internal error in the case where the component type itself is an array type whose component type is a private type declared in the parent package, i.e. when the formal type parameter is an array of array type, by naturally extending the Has_Secondary_Private_View mechanism to the array of array case. gcc/ada/ * sem_ch12.adb (Component_Type_For_Private_View): New function. (Check_Generic_Actuals): For an actual type parameter, also check its component type if it is an array type. (Check_Private_View): Use Component_Type_For_Private_View in the case of an array type. (Instantiate_Type): Likewise. (Save_Global_References.Set_Global_Type): Likewise.
2023-09-05ada: Remove GNATcheck violationsSheri Bernstein2-0/+14
Use pragma Annotate to exempt GNATcheck violations that are related to proof code. Specifically, exempt rules "Metrics_LSLOC" and "Metrics_Cyclomatic_Complexity" whose limits are exceeded due to proof code, and exempt rule "Discriminated_Records" for a variant record that is only used in proof code. gcc/ada/ * libgnat/s-aridou.adb: Add pragma to exempt Metrics_LSLOC. (Double_Divide): Add pragma to exempt Metrics_Cyclomatic_Complexity. (Scaled_Divide): Likewise. * libgnat/s-vauspe.ads (Uns_Option): Add pragma to exempt Discriminated_Records.
generated by cgit v1.1 at 2025-09-27 02:04:23 +0000