diff --git a/ChangeLog b/ChangeLog index 3485d88c8185..b5903d424af0 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,16 @@ +2016-03-17 Cary Coutant + + Sync with binutils-gdb: + + 2016-03-17 Cary Coutant + + * configure.ac: Add mips and s390 to the gold target check. + * configure: Regenerate. + +2016-03-01 DJ Delorie + + * MAINTAINERS (mep): Remove myself as MeP maintainer. + 2016-02-22 David Malcolm * MAINTAINERS (libcpp): Add myself. diff --git a/MAINTAINERS b/MAINTAINERS index 70e9d4a9adef..7265f4f9df11 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -75,7 +75,6 @@ m68k port (?) Jeff Law m68k port Andreas Schwab m68k-motorola-sysv port Philippe De Muyter mcore port Nick Clifton -mep port DJ Delorie microblaze Michael Eager mips port Catherine Moore mips port Eric Christopher diff --git a/boehm-gc/ChangeLog b/boehm-gc/ChangeLog index 365038e4bfe2..c41734a3cc52 100644 --- a/boehm-gc/ChangeLog +++ b/boehm-gc/ChangeLog @@ -1,3 +1,8 @@ +2016-03-16 Andreas Schwab + + * include/private/gcconfig.h [AARCH64] (ALIGNMENT, CPP_WORDSZ): + Define for __ILP32__. + 2015-10-09 David Malcolm * testsuite/lib/boehm-gc.exp: Load multiline.exp before diff --git a/boehm-gc/include/private/gcconfig.h b/boehm-gc/include/private/gcconfig.h index 7e081d993bb0..aa81f15b06cd 100644 --- a/boehm-gc/include/private/gcconfig.h +++ b/boehm-gc/include/private/gcconfig.h @@ -1854,9 +1854,14 @@ # endif # ifdef AARCH64 -# define CPP_WORDSZ 64 +# ifdef __ILP32__ +# define ALIGNMENT 4 +# define CPP_WORDSZ 32 +# else +# define ALIGNMENT 8 +# define CPP_WORDSZ 64 +# endif # define MACH_TYPE "AARCH64" -# define ALIGNMENT 8 # ifndef HBLKSIZE # define HBLKSIZE 4096 # endif diff --git a/configure b/configure index 89c863ca97cc..35f231ea92bd 100755 --- a/configure +++ b/configure @@ -2973,7 +2973,7 @@ case "${ENABLE_GOLD}" in # Check for target supported by gold. case "${target}" in i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-* | arm*-*-* \ - | aarch64*-*-* | tilegx*-*-*) + | aarch64*-*-* | tilegx*-*-* | mips*-*-* | s390*-*-*) configdirs="$configdirs gold" if test x${ENABLE_GOLD} = xdefault; then default_ld=gold diff --git a/configure.ac b/configure.ac index 321b90896f08..74bf58aad93b 100644 --- a/configure.ac +++ b/configure.ac @@ -351,7 +351,7 @@ case "${ENABLE_GOLD}" in # Check for target supported by gold. case "${target}" in i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-* | arm*-*-* \ - | aarch64*-*-* | tilegx*-*-*) + | aarch64*-*-* | tilegx*-*-* | mips*-*-* | s390*-*-*) configdirs="$configdirs gold" if test x${ENABLE_GOLD} = xdefault; then default_ld=gold diff --git a/contrib/ChangeLog b/contrib/ChangeLog index d789cd8cf7b7..54f9d5e72b22 100644 --- a/contrib/ChangeLog +++ b/contrib/ChangeLog @@ -1,3 +1,16 @@ +2016-03-07 Martin Sebor + + * check_GNU_style.sh (color): New global variable. + Add checks for trailing operators and spaces before left brackets. + Tightened up a check for a trailing left curly brace. + (g, ag, vg): Use color. + (col): Don't complain about excessively long lines with DejaGnu + directives. + +2016-03-06 Trevor Saunders + + * mklog: Look for the ChangeLog file in $cwd. + 2016-02-26 Joel Sherrill * config-list.mk: Add aarch64-rtems and x86_64-rtems diff --git a/contrib/check_GNU_style.sh b/contrib/check_GNU_style.sh index ac54ed070e73..fbf6cb2465d2 100755 --- a/contrib/check_GNU_style.sh +++ b/contrib/check_GNU_style.sh @@ -1,7 +1,7 @@ #!/bin/sh # Checks some of the GNU style formatting rules in a set of patches. -# Copyright (C) 2010, 2012 Free Software Foundation, Inc. +# Copyright (C) 2010, 2012, 2016 Free Software Foundation, Inc. # Contributed by Sebastian Pop # This program is free software; you can redistribute it and/or modify @@ -15,8 +15,11 @@ # GNU General Public License for more details. # You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +# along with this program; if not, see the file COPYING3. If not, +# see . + +# Set to empty in the environment to override. +: ${color:---color=always} usage() { cat < "$tmp" && found=true if $found; then @@ -117,8 +120,8 @@ ag (){ local found=false cat $inp \ - | egrep --color=always -- "$arg1" \ - | egrep --color=always -- "$arg2" \ + | egrep $color -- "$arg1" \ + | egrep $color -- "$arg2" \ > "$tmp" && found=true if $found; then @@ -136,7 +139,7 @@ vg (){ local found=false cat $inp \ | egrep -v -- "$varg" \ - | egrep --color=always -- "$arg" \ + | egrep $color -- "$arg" \ > "$tmp" && found=true if $found; then @@ -171,10 +174,11 @@ col (){ # Expand tabs to spaces according to tab positions. # Keep long lines, make short lines empty. Print the part past 80 chars # in red. + # Don't complain about dg-xxx directives in tests. cat "$tmp" \ | sed 's/^[0-9]*:+//' \ | expand \ - | awk '{ \ + | awk '$0 !~ /{[[:space:]]*dg-(error|warning|message)[[:space:]]/ { \ if (length($0) > 80) \ printf "%s\033[1;31m%s\033[0m\n", \ substr($0,1,80), \ @@ -201,6 +205,7 @@ col (){ done } + col 'Lines should not exceed 80 characters.' g 'Blocks of 8 spaces should be replaced with tabs.' \ @@ -221,13 +226,20 @@ g 'Dot, space, space, end of comment.' \ g 'Sentences should end with a dot. Dot, space, space, end of the comment.' \ '[[:alnum:]][[:blank:]]*\*/' -vg 'There should be exactly one space between function name and parentheses.' \ +vg 'There should be exactly one space between function name and parenthesis.' \ '\#define' \ '[[:alnum:]]([[:blank:]]{2,})?\(' -g 'There should be no space before closing parentheses.' \ +g 'There should be no space before a left square bracket.' \ + '[[:alnum:]][[:blank:]]+\[' + +g 'There should be no space before closing parenthesis.' \ '[[:graph:]][[:blank:]]+\)' -ag 'Braces should be on a separate line.' \ - '\{' \ - 'if[[:blank:]]\(|while[[:blank:]]\(|switch[[:blank:]]\(' +# This will give false positives for C99 compound literals. +g 'Braces should be on a separate line.' \ + '(\)|else)[[:blank:]]*{' + +# Does this apply to definition of aggregate objects? +g 'Trailing operator.' \ + '(([^a-zA-Z_]\*)|([-%<=&|^?])|([^*]/)|([^:][+]))$' diff --git a/contrib/mklog b/contrib/mklog index 455614bfb422..61126280f1fe 100755 --- a/contrib/mklog +++ b/contrib/mklog @@ -104,7 +104,7 @@ sub get_clname ($) { my $dirname = $_[0]; while ($dirname) { my $clname = "$dirname/ChangeLog"; - if (-f "$gcc_root/$clname") { + if (-f "$gcc_root/$clname" || -f "$clname") { my $relname = substr ($_[0], length ($dirname) + 1); return ($clname, $relname); } else { diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 4db03b62e834..f02e3d87c150 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,1560 @@ +2016-03-26 Richard Biener + Prathamesh Kulkarni + + PR ipa/70366 + * ipa-inline-transform.c (inline_call): Pass opts_for_fn (to->decl) + instead of + TREE_OPTIMIZATION (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (to->decl)) + as 2nd argument to cl_optimization_restore(). + +2016-03-25 Richard Henderson + + PR target/70120 + * config/aarch64/aarch64.c (aarch64_asm_output_pool_epilogue): New. + * config/aarch64/aarch64-protos.h: Declare it. + * config/aarch64/aarch64.h (ASM_OUTPUT_POOL_EPILOGUE): New. + +2016-03-25 Alan Modra + + PR target/70052 + * config/rs6000/constraints.md (j): Simplify. + * config/rs6000/predicates.md (easy_fp_constant): Exclude + decimal float 0.D. + * config/rs6000/rs6000.md (zero_fp): New mode_attr. + (mov_hardfloat, mov_hardfloat32, mov_hardfloat64, + mov_64bit_dm, mov_32bit): Use zero_fp in place of j + in all constraint alternatives. + (movtd_64bit_nodm): Delete "j" constraint alternative. + +2016-03-24 Aldy Hernandez + + * tree-ssa-propagate.c: Enhance docs for + SSA_PROP_NOT_INTERESTING. + +2016-03-24 Aldy Hernandez + + * doc/extend.texi: Fix typo in documentation to pure attribute. + +2016-03-24 John David Anglin + + PR target/70319 + * config/pa/pa.md (bswapdi2): Use a scratch register. + +2016-03-24 Richard Henderson + + PR middle-end/69845 + * fold-const.c (extract_muldiv_1): Correct test for multiplication + overflow. + +2016-03-24 Uros Bizjak + + * config/i386/i386.md (*anddi3_doubleword): Generate AND insn + using ix86_expand_binary_operator instead of gen_andsi3. + +2016-03-24 Richard Biener + + PR tree-optimization/70396 + * tree-vect-stmts.c (vectorizable_comparison): Use + get_vectype_for_scalar_type. + +2016-03-24 Richard Biener + + PR middle-end/70370 + * gimplify.c (gimplify_asm_expr): Handle !allows_mem outputs + with register bases. + +2016-03-24 Richard Biener + + PR tree-optimization/70372 + * tree-ssa-reassoc.c (eliminate_plus_minus_pair): Use + build_all_ones_cst to also handle vector types correctly. + +2016-03-23 Michael Meissner + + PR target/70381 + * config/rs6000/rs6000-cpus.def (ISA_2_6_MASKS_SERVER): Do not set + -mfloat128 here. + +2016-03-23 Marek Polacek + + PR c++/69884 + * doc/invoke.texi: Document -Wignored-attributes. + +2016-03-23 Bin Cheng + + PR tree-optimization/69042 + * params.def (PARAM_IV_CONSIDER_ALL_CANDIDATES_BOUND): Increase the + parameter from 30 to 40. + +2016-03-23 Bin Cheng + + PR tree-optimization/69042 + * tree-ssa-loop-ivopts.c (add_iv_candidate_for_use): Add IV cand + for use with constant offset stripped in base. + +2016-03-23 Richard Biener + + PR middle-end/70251 + * match.pd (A + (B vcmp C ? 1 : 0) -> A - (B vcmp C)): Adjust + mode compatibility check. + (A - (B vcmp C ? 1 : 0) -> A + (B vcmp C)): Likewise. + +2016-03-23 Jeff Law + + PR tree-optimization/64058 + * tree-ssa-coalesce.c (struct coalesce_pair): Add new field + CONFLICT_COUNT. + (struct ssa_conflicts): Move up earlier in the file. + (conflicts_, var_map_): New static variables. + (initialize_conflict_count): New function to initialize the + CONFLICT_COUNT field for each conflict pair. + (compare_pairs): Lazily initialize the conflict count and use it + as the first tie-breaker. + (sort_coalesce_list): Add new arguments conflicts, map. Initialize + and wipe conflicts_ and map_ around the call to qsort. Remove + special case for 2 coalesce pairs. + * bitmap.c (bitmap_count_unique_bits): New function. + (bitmap_count_bits_in_word): New function, extracted from + bitmap_count_bits. + (bitmap_count_bits): Use bitmap_count_bits_in_word. + * bitmap.h (bitmap_count_unique_bits): Declare it. + +2016-03-23 Ilya Enkovich + + PR target/69917 + * config/i386/sol2.h (ASM_OUTPUT_DEF_FROM_DECLS): Follow + transparent alias chain for decl assembler name. + * config/sol2.c (solaris_assemble_visibility): Likewise. + +2016-03-23 Kyrylo Tkachov + + * config/arm/arm1020e.md (1020call_op): Reduce reservation + duration. + (v10_fdivs): Likewise. + (v10_fdivd): Likewise. + +2016-03-23 Kyrylo Tkachov + + PR driver/70132 + * config/arm/driver-arm.c (host_detect_local_cpu): Reorder exit logic + to not call fclose twice on file. + +2016-03-23 Jakub Jelinek + + PR tree-optimization/70354 + * tree-vect-patterns.c (vect_recog_vector_vector_shift_pattern): If + oprnd0 is wider than oprnd1 and there is a cast from the wider + type to oprnd1, mask it with the mask of the narrower type. + + PR target/70321 + * config/i386/i386.md (*anddi3_doubleword, *di3_doubleword): + Optimize TARGET_STV splitters, if high or low word of last argument + is 0 or -1. + +2016-03-22 Jeff Law + + PR target/70232 + tree-ssa-threadbackward.c + (fsm_find_control_statement_thread_paths): Correctly distinguish + between old style jump threads vs FSM jump threads. + +2016-03-22 Ilya Enkovich + + PR target/70302 + * config/i386/i386.c (scalar_chain::convert_op): Support + uninitialized register usage case. + +2016-03-22 Richard Biener + + PR middle-end/70251 + * genmatch.c (gen_transform): Adjust last parameter to a three-state + int... + (capture::gen_transform): ... to change behavior when substituting + a condition into cond or not-cond expr context. + (dt_simplify::gen_1): Adjust. + * gimple-match-head.c: Include gimplify.h for unshare_expr. + * match.pd (A + (B vcmp C ? 1 : 0) -> A - (B vcmp C)): Revert + last change and instead change to + A + (B vcmp C ? 1 : 0) -> A - (B vcmp C ? -1 : 0). + (A - (B vcmp C ? 1 : 0) -> A + (B vcmp C)): Likewise. + +2016-03-22 Anthony Green + + * config/moxie/moxiebox.h (CC1_SPEC): Define. Fix endianness + issue for moxiebox targets. + (CC1PLUS_SPEC): Ditto. + +2016-03-22 Richard Biener + + PR middle-end/70333 + * fold-const.c (extract_muldiv_1): Properly perform multiplication + in the wide type. + +2016-03-22 Kirill Yukhin + + * config/i386/i386.c (def_builtin): Remove duplicated functionality. + +2016-03-22 Kirill Yukhin + + PR target/70325 + * config/i386/i386.c (def_builtin): Handle + OPTION_MASK_ISA_AVX512VL to be and-ed with other + bits. + (const struct builtin_description bdesc_special_args[]): + Remove duplicate ISA bits. + +2016-03-22 Jakub Jelinek + + PR target/70329 + * config/i386/i386.c (ix86_expand_vecop_qihi): Don't bother computing + d.perm[i] for i >= d.nelt. If not full_interleave, compute d.perm[i] + in a way that works also for AVX512BW. + + PR target/70300 + * config/i386/i386.md (cvtsd2ss splitter): Unpack in destination + instead of source if operands[1] is xmm16 and above and + !TARGET_AVX512VL. Use avx512f_vec_dupv16sf_1 instead of + vec_interleave_lowv4sf if we need to unpack xmm16 and above. + + PR c++/70295 + * gimplify.c (gimplify_modify_expr): Call gimple_set_no_warning + on assign if (*from_p) is a comparison, set it to + TREE_NO_WARNING (*from_p). + +2016-03-21 Jakub Jelinek + + PR middle-end/70326 + * lra.c (restore_scratches): Ignore deleted insns. + +2016-03-21 Marc Glisse + Jakub Jelinek + + PR tree-optimization/70317 + * match.pd (cmp @0 @0): Pass @0 instead of TYPE_MODE (TREE_TYPE (@0)) + to HONOR_NANS. + +2016-03-21 Uros Bizjak + + PR target/70327 + * config/i386/i386.md (movxi): Use ix86_expand_vector_move instead + of ix86_expand_move. + (movoi): Ditto. + (movti): Use general_operand for operand 1 predicate. + +2016-03-21 Martin Liska + + * hsa-dump.c (dump_hsa_insn_1): dump default branch of SBR + insns. + (dump_hsa_symbol): Dump BRIG offset of hsa_symbols. + +2016-03-21 Martin Liska + + PR ipa/70306 + * ipa-icf.c (sem_function::parse): Skip static + constructors and destructors. + +2016-03-21 Jakub Jelinek + + PR target/70296 + * config/rs6000/rs6000-c.c (rs6000_macro_to_expand): If IDENT is + function-like macro, peek following token(s) if it is followed + by CPP_OPEN_PAREN token with optional padding in between, and + if not, don't treat it like a macro. + +2016-03-21 Thomas Schwinge + Alexander Monakov + + * config/nvptx/nvptx.c (nvptx_option_override): Don't emit sorry + for the stabs debug format. + +2016-03-21 Richard Biener + + PR tree-optimization/70310 + * tree-vect-generic.c (expand_vector_condition): Fold the built + condition. + +2016-03-21 Kirill Yukhin + + PR target/70293 + * config/i386/sse.md: (define_insn "*vec_dup"/AVX2): + Block third alternative for AVX-512VL target, + +2016-03-21 Martin Liska + + PR hsa/70234 + * hsa-brig.c (emit_function_directives): Mark unemitted + global variables for emission. + * hsa-gen.c (hsa_symbol::hsa_symbol): Initialize a new flag. + (get_symbol_for_decl): Likewise. + * hsa.h (struct hsa_symbol): New flag. + +2016-03-21 Richard Biener + + PR tree-optimization/70288 + * tree-ssa-loop-ivcanon.c (tree_estimate_loop_size): Make sure + we do not estimate unsimplified all-constant conditionals or + switches as optimized away. + +2016-03-21 Andrey Belevantsev + + PR rtl-optimization/69102 + * sched-deps.c (sched_analyze_insn): Do not set last_args_size field + when we have a readonly dependency context. + +2016-03-18 Jeff Law + + PR rtl-optimization/70263 + * ira.c (memref_used_between_p): Assert we found END in the insn chain. + (update_equiv_regs): When trying to move a store to after the insn + that sets the source of the store, make sure the store occurs after + the insn that sets the source of the store. When successful note + the REG_EQUIV note created in the dump file. + +2016-03-16 David Wohlferd + Bernd Schmidt + + * doc/extend.texi: Document more potential problems with basic asms. + +2016-03-18 Bernd Schmidt + + PR rtl-optimization/70278 + * lra-constraints.c (split_reg): Handle the case where biggest_mode is + VOIDmode. + +2016-03-18 Jason Merrill + + * calls.c (load_register_parameters): Fix zero size sibcall logic. + +2016-03-18 Kirill Yukhin + + * config/i386/sse.md: Use vpbroadcastq for broadcasting DF + values to 128b regs. + +2016-03-18 Ilya Enkovich + + PR tree-optimization/70252 + * tree-vect-stmts.c (supportable_widening_operation): Check resulting + boolean vector has a proper number of elements. + (supportable_narrowing_operation): Likewise. + +2016-03-18 Tom de Vries + + PR ipa/70269 + * cgraph.c (cgraph_node::get_body): Set dump_file to NULL after save. + +2016-03-18 Jakub Jelinek + + * reload1.c (emit_input_reload_insns): Use simplify_replace_rtx + instead of replace_rtx for DEBUG_INSNs. + +2016-03-18 Venkataramanan Kumar + + * config/i386/znver1.md : Fix latencies of FP/SSE/AVX + load type reservations. + +2016-03-17 John David Anglin + + PR target/70188 + * config/pa/constraints.md: Revert 2015-02-13 change. Use + define_constraint for "Q" and "T" constraints. + +2016-03-17 Evandro Menezes + + Tweak the pipeline model for Exynos M1 + + * config/aarch64/aarch64.c (exynosm1_tunings): Enable weak prefetching + model. + +2016-03-17 David Malcolm + + PR c/70264 + * diagnostic-show-locus.c (compatible_locations_p): Handle the case + where one or both locations aren't within a line_map. + +2016-03-17 H.J. Lu + + PR driver/70192 + * opts.c (finish_options): Don't set flag_pie to the default if + -fpic, -fPIC, -fno-pic or -fno-PIC is used. Set flag_pic to 0 + if it is -1. + +2016-03-17 Joern Rennecke + + * config/i386/i386.md (*movv4qicc_insn+1..36): Pass + true as ALL_REGS argument to replace_rtx. + +2016-03-17 Richard Biener + + PR debug/70271 + * dwarf2out.c (dwarf2out_early_finish): Process deferred_asm_name + last. + +2016-03-17 Jakub Jelinek + + PR target/70245 + * rtl.h (replace_rtx): Add ALL_REGS argument. + * rtlanal.c (replace_rtx): Likewise. If true, use REGNO + equality and assert mode is the same, instead of just rtx pointer + equality. + * config/i386/i386.md (mov + arithmetics with load peephole): Pass + true as ALL_REGS argument to replace_rtx. + +2016-03-17 Ilya Enkovich + + * match.pd (A + (B vcmp C ? 1 : 0) -> A - (B vcmp C)): Apply + for boolean vector with vector mode only. + (A - (B vcmp C ? 1 : 0) -> A + (B vcmp C)): Likewise. + +2016-03-17 Nick Clifton + + PR target/70162 + * config/rx/rx.c (rx_print_integer): Print negative constants in + decimal. + +2016-03-17 Jakub Jelinek + + PR target/70261 + * rtlanal.c (replace_rtx): Revert 2016-03-16 change. + +2016-03-16 Richard Henderson + Richard Biener + + PR middle-end/70240 + PR middle-end/68215 + PR tree-opt/68714 + * gimplify.c (gimplify_expr) [VEC_COND_EXPR]: Gimplify the + first operand as is_gimple_condexpr. + + PR middle-end/70240 + PR middle-end/68215 + Revert r231575 + 2015-12-11 Eric Botcazou + * tree-vect-generic.c (tree_vec_extract): Remove GSI parameter. + Do not gimplify the result. + (do_unop): Adjust call to tree_vec_extract. + (do_binop): Likewise. + (do_compare): Likewise. + (do_plus_minus): Likewise. + (do_negate): Likewise. + (expand_vector_condition): Likewise. + (do_cond): Likewise. + +2016-03-16 Richard Henderson + + PR target/70048 + * config/aarch64/aarch64.c (virt_or_elim_regno_p): New. + (aarch64_classify_address): Use it. + (aarch64_legitimize_address): Force all subexpressions of PLUS + into registers. Simplify as (sfp+const)+reg or (reg+reg)+const. + +2016-03-16 Jakub Jelinek + Richard Biener + + PR target/70245 + * rtlanal.c (replace_rtx): For REG, if from is a REG, + return to even if only REGNO is equal, and assert + mode is the same. + +2016-03-11 Jeff Law + + PR rtl-optimization/70224 + * reorg.c (relax_delay_slots): Pass right argument to CROSSING_JUMP_P. + +2016-03-16 Richard Henderson + + PR middle-end/70199 + * function.h (struct function): Add has_forced_label_in_static. + * gimplify.c (force_labels_r): Set it. + * lto-streamer-in.c (input_struct_function_base): Read it. + * lto-streamer-out.c (output_struct_function_base): Write it. + * tree-inline.c (has_label_address_in_static_1): Remove. + (copy_forbidden): Remove fndecl parameter; test + has_forced_label_in_static. + (inline_forbidden_p): Update call to copy_forbidden. + (tree_versionable_function_p): Likewise. + * ipa-chkp.c (chkp_instrumentable_p): Likewise. + (chkp_versioning): Likewise. + * tree-inline.h (copy_forbidden): Update decl. + +2016-03-16 Marek Polacek + + PR c/70093 + * cgraphunit.c (cgraph_node::expand_thunk): Also build call to the + function being thunked if the result type doesn't have fixed size. + * gimplify.c (gimplify_modify_expr): Also set LHS if the result type + doesn't have fixed size. + +2016-03-16 Bin Cheng + + * tree-vect-loop.c (vect_analyze_loop_2): Fix wrong dump info by + reporting malformed loop nest. + +2016-03-16 Tom de Vries + + PR lto/70187 + * ipa-devirt.c (possible_polymorphic_call_targets): Move + nodes.length () == 1 test to before first nodes[0] access. + +2016-03-16 Tom de Vries + + PR tree-optimization/68715 + * graphite-scop-detection.c (scop_detection::merge_sese): Add missing + single_pred_p test. + +2016-03-16 Tom de Vries + + PR tree-optimization/68809 + * graphite-scop-detection.c (same_close_phi_node): Test if result types + are the same. + +2016-03-16 Carlos O'Donell + Sandra Loosemore + + * doc/extend.texi (Common Function Attributes): Describe ifunc impact + on leaf attribute. Mention ELF interposition problems. + +2016-03-16 Alan Modra + + PR rtl-optimization/69195 + PR rtl-optimization/47992 + * ira.c (indirect_jump_optimize): Ignore artificial defs. + Add comments. + +2016-03-15 Eric Botcazou + + PR bootstrap/69513 + * dwarf2out.c (flush_limbo_die_list): Really flush the limbo list. + +2016-03-15 Senthil Kumar Selvaraj + + * config/avr/avr.md (rotl3): Set mode for operand 2. + +2016-03-15 Jakub Jelinek + + PR rtl-optimization/70222 + * combine.c (simplify_shift_const_1): For A >> B >> C LSHIFTRT + optimization if mode is different from result_mode, queue up masking + of the result in outer_op. Formatting fix. + + PR middle-end/70239 + * tree-ssa-sccvn.c (VN_INFO_GET): Use safe_grow_cleared instead + of safe_grow. + +2016-03-15 Andrey Belevantsev + + PR rtl-optimization/69032 + * sel-sched-ir.c (get_seqno_by_preds): Include both insn and head when + looping backwards over basic block insns. + +2016-03-15 Andrey Belevantsev + + PR target/66660 + * sel-sched-ir.c (merge_expr): Avoid changing the speculative pattern + to non-speculative when propagating trap bits. + +2016-03-15 Andrey Belevantsev + + PR rtl-optimization/63384 + * sel-sched.c (invoke_aftermath_hooks): Do not decrease issue_more on + DEBUG_INSN_P insns. + +2016-03-15 Andrey Belevantsev + + PR target/64411 + * sched-deps.c (get_implicit_reg_pending_clobbers): New function, + factored out from ... + (sched_analyze_insn): ... here. + * sched-int.h (get_implicit_reg_pending_clobbers): Declare it. + * sel-sched-ir.c (setup_id_implicit_regs): New function, use + get_implicit_reg_pending_clobbers in it. + (setup_id_reg_sets): Use setup_id_implicit_regs. + (deps_init_id): Ditto. + +2016-03-15 Tom de Vries + + PR ipa/70161 + * cgraph.c (cgraph_node::get_body): Save, reset and restore + dump_file_name. + * passes.c (execute_one_ipa_transform_pass): Add missing argument to + execute_function_dump. + (execute_one_pass): Don't dump function if it will be dumped after ipa + transform. + +2016-03-15 Segher Boessenkool + + * genrecog.c (match_pattern_2): If pred is NULL don't call + safe_predicate_mode on it. + +2016-03-14 Jakub Jelinek + + PR middle-end/70219 + * lra-constraints.c (delete_move_and_clobber): Change assertion + to also allow dregno == 0. + +2016-03-14 Richard Henderson + + PR tree-opt/68714 + * tree-ssa-reassoc.c (ovce_extract_ops, optimize_vec_cond_expr): New. + (can_reassociate_p): Allow ANY_INTEGRAL_TYPE_P. + (reassociate_bb): Use optimize_vec_cond_expr; avoid + optimize_range_tests, attempt_builtin_copysign and attempt_builtin_powi + on vectors. + +2016-03-14 Bernd Schmidt + + PR target/70083 + * lra-lives.c (process_bb_lives): Also update biggest mode for hard + regs. + (lra_create_live_ranges_1): initialize hard register biggest_mode to + VOIDmode. + * lra-constraints.c (split_reg): For hard regs, try to find the + biggest single-register mode used in the function. + +2016-03-14 Richard Biener + + PR tree-optimization/56365 + * tree-ssa-phiopt.c (minmax_replacement): Handle alternate + constants to compare against. + +2016-03-14 Segher Boessenkool + + PR target/70098 + * config/rs6000/rs6000.md (*ctr_internal1, *ctr_internal2, + *ctr_internal5, *ctr_internal6): Also allow "d" as output. + (define_split for the GPR case): Use int_reg_operand instead of + gpc_reg_operand for the output. + +2016-03-14 Tom de Vries + + PR tree-optimization/70045 + * graphite-isl-ast-to-gimple.c (graphite_create_new_loop_guard): Unshare + create_empty_if_region_on_edge argument. + +2016-03-13 Eric Botcazou + + * config/arm/vxworks.h (STACK_CHECK_STATIC_BUILTIN): Define. + (STACK_CHECK_PROTECT): Likewise. + * config/i386/vxworks.h (STACK_CHECK_STATIC_BUILTIN): Likewise + (STACK_CHECK_PROTECT): Likewise. + * config/rs6000/vxworks.h (STACK_CHECK_STATIC_BUILTIN): Likewise + (STACK_CHECK_PROTECT): Likewise. + * config/rs6000/vxworksae.h (STACK_CHECK_PROTECT): Likewise. + * config/sparc/vxworks.h (STACK_CHECK_STATIC_BUILTIN): Likewise. + (STACK_CHECK_PROTECT): Likewise. + +2016-03-12 Andrey Belevantsev + + PR rtl-optimization/69307 + * sel-sched.c (choose_best_pseudo_reg): Properly check for hard + registers in modes that span more than one register. + +2016-03-12 Vladimir Makarov + + PR target/69614 + * lra-constraints.c (delete_move_and_clobber): New. + (remove_inheritance_pseudos): Use it. + +2016-03-12 Eric Botcazou + + PR ada/70017 + * calls.c (emit_library_call_value_1): Clear the ECF_NOTHROW flag if + the libcall is LCT_THROW. + * explow.c (probe_stack_range): Pass LCT_THROW to emit_library_call + for the checking routine. + +2016-03-11 Michael Meissner + + PR target/70131 + * config/rs6000/rs6000.md (round322_fprs): Do not do the + optimization if we have direct move. + (roundu322_fprs): Likewise. + +2016-03-11 Bernd Schmidt + + PR target/70123 + * lra-remat.c (operand_to_remat): Disallow hard regs in the value t + be rematerialized. + (reg_overlap_for_remat_p): Renamed from input_regno_present_p. + Arguments swapped. All callers changed. Take reg_renumber into + account, and Calculate and compare register ranges for hard regs. + +2016-03-11 Jeff Law + + PR tree-optimization/70190 + * tree-ssa-threadbackward.c (fsm_find_control_statement_thread_paths): + Handle cases where we can not extract the taken edge, even though we + found a constant value. + + PR tree-optimization/64058 + * tree-ssa-coalesce.c (struct coalesce_pair): Add new field INDEX. + (num_coalesce_pairs): Move up earlier in file. + (find_coalesce_pair): Initialize the INDEX field for each pair + discovered. + (compare_pairs): No longer sort on the elements in each pair. + Instead break ties with the index of the coalesce pair. + +2016-03-11 Kyrylo Tkachov + + PR target/70002 + * config/aarch64/aarch64-protos.h + (aarch64_save_restore_target_globals): New prototype. + * config/aarch64/aarch64-c.c (aarch64_pragma_target_parse): + Call the above when popping pragma. + * config/aarch64/aarch64.c (aarch64_save_restore_target_globals): + New function. + (aarch64_set_current_function): Rewrite using the above. + +2016-03-11 Jakub Jelinek + + PR tree-optimization/70177 + * gimple-expr.h (extract_ops_from_tree_1): Renamed to ... + (extract_ops_from_tree): ... this. In the 2 argument + overload remove _1 suffix. + * gimple-expr.c (extract_ops_from_tree_1): Renamed to ... + (extract_ops_from_tree): ... this. + * gimple.c (gimple_build_assign, gimple_assign_set_rhs_from_tree): + Adjust callers. + * tree-ssa-loop-niter.c (derive_constant_upper_bound): Likewise. + * tree-ssa-forwprop.c (defcodefor_name): Call 3 operand + extract_ops_from_tree instead of 2 operand one. + +2016-03-11 Alan Lawrence + + PR tree-optimization/70013 + * tree-sra.c (analyze_access_subtree): Also set grp_unscalarized_data + for constant-pool entries. + +2016-03-11 Jakub Jelinek + + PR rtl-optimization/70174 + * expmed.c (store_bit_field_using_insv): Use gen_lowpart_if_possible + followed by gen_lowpart on force_reg instead of just gen_lowpart. + + PR tree-optimization/70169 + * tree-ssa-loop.c (gen_lsm_tmp_name): Handle FUNCTION_DECL and + LABEL_DECL like VAR_DECL. Emit nothing instead of gcc_unreachable + for unknown codes. + +2016-03-11 Ilya Enkovich + Jakub Jelinek + + PR target/70160 + * config/i386/i386.c (scalar_chain::convert_reg): Skip uses + of uninitialized values. + +2016-03-11 Andreas Krebbel + + * config/s390/s390.md ("trunctddd2"): Turn former define_insn into + define_expand. + ("*trunctddd2"): New pattern definition. + ("trunctdsd2"): Set prep_for_short_prec rounding mode for the + TD->DD truncation. + +2016-03-11 Andreas Krebbel + + * config/s390/s390.md (BFP_RND_*, DFP_RND_*): Add new constant + definitions for BFP and DFP rounding modes. + ("fixuns_truncdddi2", "fixuns_trunctddi2") + ("fixuns_trunc2", "fixuns_truncsi2") + ("fix_trunc2", "fix_truncdi2") + ("fix_trunctf2"): Use the new constants instead of magic + numbers. + +2016-03-11 Andreas Krebbel + + * config/s390/constraints.md: Adjust comment. + ("Y"): Adjust comment. Rename s390_decompose_shift_count to + s390_decompose_addrstyle_without_index. + * config/s390/predicates.md (shift_count_or_setmem_operand): + Rename to setmem_operand. + * config/s390/s390-protos.h + (s390_decompose_shift_count): Rename to + s390_decompose_addrstyle_without_index. + * config/s390/s390.c (s390_decompose_shift_count) + (s390_mem_constraint, print_shift_count_operand) + (print_operand_address, print_operand): Rename + s390_decompose_shift_count to + s390_decompose_addrstyle_without_index and rename + print_shift_count_operand to print_addrstyle_operand troughout the + file. + * config/s390/s390.md ("setmem_long_", "*setmem_long") + ("*setmem_long_and", "*setmem_long_31z", "*setmem_long_and_31z"): + Rename shift_count_or_setmem_operand to setmem_operand. + * config/s390/vx-builtins.md ("vec_insert") + ("vec_promote"): Replace shift_count_or_setmem_operand with + nonmemory_operand. + +2016-03-10 Ulrich Weigand + + PR target/70168 + * config/rs6000/rs6000.c (rs6000_expand_atomic_compare_and_swap): + Handle overlapping retval and newval. + +2016-03-10 Nick Clifton + + PR target/7044 + * config/aarch64/aarch64.c + (aarch64_override_options_after_change_1): When forcing + flag_omit_frame_pointer to be true, use a special value that can + be detected if this function is called again, thus preventing + flag_omit_leaf_frame_pointer from being forced to be false. + +2016-03-10 Kyrylo Tkachov + + * common/config/aarch64/aarch64-common.c (aarch64_handle_option): + Set x_flag_omit_leaf_frame_pointer when handling + -momit-leaf-frame-pointer. + +2016-03-10 Jan Hubicka + + PR lto/69589 + * cgraph.c (cgraph_node::dump): Dump split_part and + indirect_call_target. + * cgraph.h (cgraph_node): Add indirect_call_target flag. + * ipa.c (has_addr_references_p): Cleanup. + (is_indirect_call_target_p): New. + (walk_polymorphic_call_targets): Do not mark virtuals that may be + called indirectly as local. + (symbol_table::remove_unreachable_nodes): Compute indirect_call_target. + +2016-03-10 Jan Hubicka + + PR ipa/69630 + * ipa-devirt.c (possible_polymorphic_call_targets): Do not ICE + on cxa_pure_virtual. + +2016-03-10 Jan Hubicka + + PR lto/69589 + * tree.c (free_lang_data_in_decl): Clear visibility of TYPE_DECL. + +2016-03-10 Jan Hubicka + + PR lto/69589 + * tree.c (need_assembler_name_p): Only record main variant type names. + +2016-03-10 Christophe Lyon + + PR target/70113. + * config/aarch64/aarch64.h (TARGET_FIX_ERR_A53_843419_DEFAULT): + Always define to 0 or 1. + (TARGET_FIX_ERR_A53_843419): New macro. + * config/aarch64/aarch64-elf-raw.h + (TARGET_FIX_ERR_A53_843419_DEFAULT): Update for above changes. + * config/aarch64/aarch64-linux.h: Likewise. + * config/aarch64/aarch64.c + (aarch64_override_options_after_change_1): Do not default + aarch64_nopcrelative_literal_loads to true if Cortex-A53 erratum + 843419 is on. + (aarch64_attributes): Handle fix-cortex-a53-843419. + (aarch64_can_inline_p): Likewise. + * config/aarch64/aarch64.opt (aarch64_fix_a53_err843419): Save. + +2016-03-10 Alan Lawrence + Jakub Jelinek + + * common.opt (funconstrained-commons, flag_unconstrained_commons): New. + * tree.c (array_at_struct_end_p): Do not limit to size of decl for + DECL_COMMONS if flag_unconstrained_commons is set. + * tree-dfa.c (get_ref_base_and_extent): Likewise. + * doc/invoke.texi (Optimize Options): Add -funconstrained-commons. + (funconstrained-commons): Document. + +2016-03-10 Christophe Lyon + + * config/aarch64/t-aarch64 (OPTIONS_H_EXTRA): Add + aarch64-fusion-pairs.def and aarch64-tuning-flags.def + +2016-03-10 Ilya Enkovich + + * tree-vect-stmts.c (vectorizable_mask_load_store): Check mask + has a proper number of elements. + +2016-03-10 Alan Modra + + PR rtl-optimization/69195 + PR rtl-optimization/47992 + * ira.c (recorded_label_ref): Delete. + (update_equiv_regs): Return void. + (indirect_jump_optimize): New function. + (ira): Call indirect_jump_optimize and delete_trivially_dead_insns + before regstat_compute_ri. Don't rebuild_jump_labels here. + Delete update_regstat. + +2016-03-10 Richard Biener + + PR tree-optimization/70128 + * tree-ssa-structalias.c (set_uids_in_ptset): Set + vars_contains_nonlocal for any FUNCTION_DECL or LABEL_DECL. + +2016-03-09 Jakub Jelinek + + PR tree-optimization/70152 + * tree-sra.c (replace_removed_params_ssa_names): Copy over + SSA_NAME_OCCURS_IN_ABNORMAL_PHI from old_name to new_name. + + PR target/70086 + * config/i386/i386.md (truncdfsf2 splitter): Use gen_vec_concatv2df + instead of gen_sse2_loadlpd. + * config/i386/sse.md (*vec_concatv2df): Rename to... + (vec_concatv2df): ... this. + + PR tree-optimization/70127 + * fold-const.c (operand_equal_p): Revert the 2015-10-28 change. + +2016-03-09 David Malcolm + + PR c/68473 + PR c++/70105 + * diagnostic-show-locus.c (compatible_locations_p): New function. + (layout::layout): Sanitize ranges using compatible_locations_p. + +2016-03-09 David Malcolm + + PR c/68473 + PR c++/70105 + * diagnostic-show-locus.c (layout_range::layout_range): Replace + location_range param with three const expanded_locations * and a + bool. + (layout::layout): Replace call to + rich_location::lazily_expand_location with get_expanded_location. + Extract the range and perform location expansion here, passing + the results to the layout_range ctor. + * diagnostic.c (source_range::debug): Delete. + * diagnostic.h (diagnostic_expand_location): Reimplement in terms + of rich_location::get_expanded_location. + * gcc-rich-location.c (get_range_for_expr): Delete. + (gcc_rich_location::add_expr): Reimplement to avoid the + rich_location::add_range overload that took a location_range, + passing a location_t instead. + +2016-03-09 Richard Biener + Jakub Jelinek + + PR tree-optimization/70138 + * tree-vect-loop-manip.c (vect_update_ivs_after_vectorizer): + Also skip vect_double_reduction_def. + +2016-03-09 Jakub Jelinek + + PR target/70049 + * config/i386/sse.md (*vec_extract): Use %0 instead of %k0 + if the operand is "m". + +2016-03-09 Nathan Sidwell + + * config/nvptx/nvptx.c (nvptx_option_override): Don't kill debug level. + +2016-03-09 Venkataramanan Kumar + + * config/i386/i386.c (processor_target_table): Fix cost table + intialization order for znver1. + +2016-03-08 Jakub Jelinek + + * ipa-polymorphic-call.c (walk_ssa_copies): Fix spelling + - becuase -> because. + * ipa-reference.c (ignore_module_statics): Likewise. + * cgraph.c (cgraph_node::get_body): Likewise. + * ipa-inline.c (early_inliner): Likewise. + * ipa-devirt.c (types_same_for_odr): Likewise. + * tree-streamer-out.c (pack_ts_type_common_value_fields): Likewise. + * config/i386/i386.h (ACCUMULATE_OUTGOING_ARGS): Likewise. + +2016-03-08 Kyrylo Tkachov + + * tree-ssa-math-opts.c: Fix typo in comment. + +2016-03-08 Jakub Jelinek + + PR target/70110 + * config/i386/i386.c (scalar_chain::make_vector_copies, + scalar_chain::convert_reg): Call end_sequence in between + get_insns and emit_conversion_insns rather than after both + calls. + +2016-03-07 Uros Bizjak + + PR target/70064 + * config/i386/i386.h (machine_function): Add + pc_thunk_call_expanded flag. + (ix86_pc_thunk_call_expanded): New define. + * config/i386/i386.md (set_got, set_got_labelled): New expanders. + (*set_got): Rename insn pattern from set_got. + (*set_got_labelled): Rename inst pattern from set_got_labelled. + * config/i386/i386.c (ix86_compute_frame_layout): Use + ix86_pc_thunk_call_expanded to prevent red-zone. + +2016-03-07 Martin Jambor + + * hsa.h (hsa_get_ctor_statements): Declare. + (hsa_get_dtor_statements): Likewise. + (hsa_get_kernel_dispatch_type): Likewise. + * hsa.c (hsa_get_ctor_statements): New function. + (hsa_get_dtor_statements): Likewise. + (hsa_get_kernel_dispatch_type): Likewise. + * hsa-brig.c (hsa_cdtor_statements): Removed. + (hsa_output_libgomp_mapping): Use hsa_get_ctor_statements and + hsa_get_dtor_statements. + * hsa-gen.c (hsa_kernel_dispatch_type): Removed. + (get_hsa_kernel_dispatch_offset): Use hsa_get_kernel_dispatch_type. + +2016-03-07 Andre Vieira + + * config/arm/arm-cores.def (cortex-r8): New. + * config/arm/arm-tables.opt (cortex-r8): Regenerate. + * config/arm/arm-tune.md: Likewise. + * gcc/doc/invoke.texi: Add cortex-r8 to list of cpu values. + +2016-03-07 Martin Sebor + + PR rtl-optimization/19705 + * doc/invoke.texi (Options That Control Optimization): Clarify + -fno-branch-count-reg. + +2016-02-26 Richard Biener + Jeff Law + + PR tree-optimization/69740 + * cfghooks.c (remove_edge): Request loop fixups if we delete + an edge that might turn an irreducible loop into a natural + loop. + * cfgloop.h (check_verify_loop_structure): Clear LOOPS_NEED_FIXUP. + Move after definition of loops_state_clear. + +2016-03-07 Bin Cheng + + PR rtl-optimization/69052 + * rtlanal.c (commutative_operand_precedence): Set higher precedence + to CONST_WIDE_INT. + +2016-03-07 Tom de Vries + + PR tree-optimization/70116 + * tree-ssa-tail-merge.c (merge_stmts_p): New function, handling + is_tm_ending stmts and ubsan/asan internal functions. + (find_duplicate): Use it. Don't test is_tm_ending here. + +2016-03-07 Richard Biener + + PR tree-optimization/70115 + * tree-ssa-loop-ivcanon.c (propagate_into_all_uses): Remove. + (propagate_constants_for_unrolling): Use replace_uses_by. + +2016-03-07 Nathan Sidwell + + PR middle-end/69916 + * omp-low.c (struct oacc_loop): Add ifns. + (new_oacc_loop_raw): Initialize it. + (finish_oacc_loop): Clear mask & flags if no ifns. + (oacc_loop_discover_walk): Count IFN_GOACC_LOOP calls. + (oacc_loop_xform_loop): Add ifns arg & adjust. + (oacc_loop_process): Adjust oacc_loop_xform_loop call. + +2016-03-07 Richard Henderson + + PR rtl-opt/70061 + * tree-outofssa.c (emit_partition_copy): Flush pending stack adjust. + (insert_value_copy_on_edge): Likewise. + +2016-03-07 Kyrylo Tkachov + + * config/arm/arm_neon.h: Show error if using with soft-float ABI. + +2016-03-07 Rainer Orth + + PR target/62281 + * config/i386/sol2.h (STACK_REALIGN_DEFAULT): Define. + +2016-03-05 Venkataramanan Kumar + + * config/i386/i386.c (znver1_cost): Fix Multiply cost. + +2016-03-05 Venkataramanan Kumar + + Fix sseimul type attribute. + * config/i386/znver1.md + (znver1_sseimul, znver1_sseimul_avx256, znver1_sseimul_load, + znver1_sseimul_avx256_load) : Fix the type attribute. + (znver1_sseimul_di, znver1_sseimul_load_di): Fix type attribute, + pipe usage and latency. + +2016-03-05 Jakub Jelinek + + PR c++/70084 + * tree-inline.c (copy_tree_body_r): When cancelling ADDR_EXPR + of INDIRECT_REF and ADDR_EXPR changed type, fold_convert it + to the right type. + +2016-03-04 Bernd Schmidt + + PR c/69973 + * targhooks.c (default_vector_alignment): Limit to MAX_OFILE_ALIGNMENT. + + PR rtl-optimization/69941 + * postreload.c (reload_combine_recognize_pattern): Ensure all uses of + the reg share its mode. + +2016-03-04 Jeff Law + + PR tree-optimization/69196 + * tree-ssa-threadbackward.c (fsm_find_control_statement_thread_paths): + If the both SSA_NAMEs are anonymous, then consider them unassociated + and include the PHI in the statement count. + +2016-03-05 Tom de Vries + + * omp-low.c (check_omp_nesting_restrictions): Check for non-oacc + construct in oacc routine. Check for oacc region in oacc routine. + +2016-03-04 Jakub Jelinek + + PR target/70062 + * config/i386/i386.c (decide_alg): Add RECUR argument. Revert + 2016-02-22 changes, instead don't recurse if RECUR is already true. + Don't change *dynamic_check if RECUR. Adjust recursive caller + to pass true to the new argument. + (ix86_expand_set_or_movmem): Adjust decide_alg caller. + + PR target/70059 + * config/i386/sse.md (vec_set_lo_, + _vinsert_mask): Formatting + fixes. + (vec_set_hi_): Likewise. Swap VEC_CONCAT operands. + +2016-03-04 Bernd Schmidt + + PR rtl-optimization/57676 + * lra-assigns.c (lra_assign): Guard test for maximum iterations + with flag_checking. + +2016-03-04 Ilya Enkovich + + * tree-vect-patterns.c (search_type_for_mask): Handle + comparison of booleans. + +2016-03-04 Jakub Jelinek + + * doc/extend.texi (__builtin_alloca, __builtin_alloca_with_align): + Fix @xref usage. + + PR debug/69947 + * dwarf2out.c (prune_unused_types_walk_loc_descr): Handle + all other ops that have dw_val_class_die_ref operands, + and DW_OP_GNU_entry_value. + +2016-03-03 Kyrylo Tkachov + + PR rtl-optimization/69904 + * config/arm/arm.c (arm_cannot_copy_insn_p): + Return true for load-exclusive instructions. + +2016-03-03 Jakub Jelinek + + PR target/70021 + * tree-vect-stmts.c (vect_mark_relevant): Remove USED_IN_PATTERN + argument, if STMT_VINFO_IN_PATTERN_P (stmt_info), always mark + the pattern no matter if it is used just by non-pattern, pattern + or mix thereof. + (process_use, vect_mark_stmts_to_be_vectorized): Adjust callers. + * tree-vect-patterns.c (vect_recog_vector_vector_shift_pattern): If + oprnd1 def_stmt is in pattern, don't look through it. + +2016-03-03 Marek Polacek + + PR middle-end/70050 + * match.pd (X % -Y): Add INTEGRAL_TYPE_P check. + +2016-03-03 Martin Liska + + PR tree-optimization/70043 + * tree-vect-loop.c (optimize_mask_stores): Move iterator to + previous statement if we see a debug statement. + +2016-03-03 Richard Biener + + PR tree-optimization/55936 + * tree-vrp.c (compare_name_with_value): Add use_equiv_p + parameter and guard unsafe equivalence use. + (vrp_evaluate_conditional_warnv_with_ops): Always use + safe equivalences but not via the quadratic compare_names + helper. + +2016-03-03 Michael Collison + + PR target/70014 + * config/arm/arm.md (*subsi3_carryin_const): Change predicate + for operand 1 to s_register_operand. Change predicate for operand + 2 to arm_not_immediate_operand. + +2016-03-02 H.J. Lu + + * doc/tm.texi: Regenerated. + +2016-03-02 Richard Henderson + + PR rtl-opt/67145 + * simplify-rtx.c (simplify_plus_minus): Allow reassoc without + simplification when all args are positive non-fixed registers. + +2016-03-02 Manuel Lopez-Ibanez + + * target.def (lra_p): Specify that new ports should use LRA. + +2016-03-02 Jakub Jelinek + + PR libgomp/69555 + * gimplify.c (gimplify_decl_expr): For decls with REFERENCE_TYPE, also + gimplify_type_sizes the type they refer to. + (omp_notice_variable): Handle reference vars to VLAs. + * omp-low.c (lower_omp_target): Emit setup of OMP_CLAUSE_PRIVATE + reference to VLA decls in the second pass instead of first pass. + +2016-03-02 Tom de Vries + + PR tree-optimization/68659 + * graphite-isl-ast-to-gimple.c (collect_all_ssa_names): Handle + new_expr == NULL_TREE. + (get_new_name): Handle ADDR_EXPR. + +2016-03-02 Bin Cheng + + PR rtl-optimization/69052 + * loop-invariant.c (canonicalize_address): New function. + (inv_can_prop_to_addr_use): Check validity of address expression + which is canonicalized by above function. + +2016-03-02 Alan Modra + + PR ipa/69990 + * ipa-icf.c (sem_variable::merge): Do not merge an alias with + larger alignment. + +2016-03-02 Jakub Jelinek + + PR target/70028 + * config/i386/i386.md (kmovw): Move m constraint to 2nd alternative. + (*movhi_internal): Put mask moves from and to memory separately + from moves from/to GPRs. + +2016-03-02 Richard Biener + + * genmatch.c (dt_node::gen_kids): Fix match code-gen for embedded + GENERIC expressions in GIMPLE. + +2016-03-02 Richard Biener + + * config/i386/i386.c (type_natural_mode): Fix typo. + +2016-03-02 Nick Clifton + + * config.gcc (mep-*-elf): Add newlib-stdint.h to tm_file. + +2016-03-02 Richard Biener + Uros Bizjak + + PR target/67278 + * config/i386/i386.c (type_natural_mode): Handle XFmode vectors. + +2016-03-02 Richard Biener + + PR middle-end/67278 + * tree-cfg.c (verify_expr): Adjust BIT_FIELD_REF case. + +2016-03-02 Marek Polacek + + PR c/67854 + * gimplify.c (gimplify_va_arg_expr): Use expanded location for the + "is promoted to" warning. + +2016-03-01 DJ Delorie + + * config.gcc: Deprecate mep-*. + +2016-03-01 Vladimir Makarov + + PR middle-end/70025 + * lra-constraints.c (regno_val_use_in): New. + (match_reload): Use it instead of regno_use_in. + +2016-03-01 Eric Botcazou + + PR rtl-optimization/70007 + * gcse.c (compute_ld_motion_mems): Tidy up and also invalidate memory + references present in REG_EQUAL notes attached to non-SET patterns. + +2016-03-01 Jeff Law + + PR tree-optimization/69196 + * tree-ssa-threadbackward.c (fsm_find_control_statement_thread_paths): + Appropriately clamp the number of statements to copy when the + thread path does not traverse a loop backedge. + + PR tree-optimization/69196 + * tree-ssa-threadbackward.c (fsm_find_control_statement_thread_paths): + Do count some PHIs in the thread path against the insn count. Decrease + final statement count by one as the control statement in the last + block will get removed. Remove special cased code for handling PHIs + in the last block. + +2016-03-01 Uros Bizjak + + PR target/70027 + * config/i386/i386.c (ix86_output_call_insn): Add -masm=intel + asm dialect alternatives to explicit GOTPCREL calls. + +2016-03-01 Eric Botcazou + + PR ada/70017 + * ira.c (do_reload): Issue warning for generic stack checking here... + * reload1.c (reload): ...instead of here and streamline it. + +2016-03-01 Nick Clifton + + * config.gcc (cr16-*-elf): Add newlib-stdint.h to tm_file. + +2016-03-01 Richard Biener + + PR tree-optimization/69983 + * tree-chrec.c (eq_evolutions_p): Handle conversions, compare + types and fall back to operand_equal_p. + +2016-03-01 Andreas Krebbel + + Revert + 2016-03-01 Andreas Krebbel + + * config/s390/constraints.md ("jm8"): New constraint. + * config/s390/predicates.md ("const_int_8bitset_operand"): New + predicate. + * config/s390/s390.md ("*setmem_long", "*setmem_long_and"): Merge + into ... + ("*setmem_long"): New pattern. + ("*setmem_long_31z", "*setmem_long_and_31z"): Merge + into ... + ("*setmem_long_31z"): New pattern. + * config/s390/subst.md ("setmem_31z_subst", "setmem_and_subst"): + New substitution rules with the required attributes. + + +2016-03-01 Andreas Krebbel + + Revert + 2016-03-01 Andreas Krebbel + + * gensupport.c (process_substs_on_one_elem): Split loop to + complete mark_operands_used_in_match_dup on all expressions in the + vector first. + (adjust_operands_numbers): Inline into process_substs_on_one_elem + and remove function. + +2016-03-01 Richard Biener + + PR middle-end/70022 + * fold-const.c (fold_indirect_ref_1): Fix range checking for + vector BIT_FIELD_REF extract. + +2016-03-01 Richard Biener + + PR tree-optimization/69994 + * tree-ssa-reassoc.c (ops_equal_values_p): Handle missing case. + +2016-03-01 Ilya Enkovich + + PR tree-optimization/69956 + * tree-vect-stmts.c (supportable_widening_operation): Support + multi-step conversion of boolean vectors. + (supportable_narrowing_operation): Likewise. + +2016-03-01 Andreas Krebbel + + * config/s390/s390.c (s390_decompose_address): Don't accept SImode + anymore. + +2016-03-01 Andreas Krebbel + + * config/s390/subst.md (DSI_VI): New mode iterator. + ("addr_style_op_subst"): Use DSI_VI instead of DSI. + * config/s390/vector.md ("vec_set"): Move expander before + the insn definition. + ("*vec_set"): Change predicate and add alternative to + support only either register or const_int operands as element + selector. + ("*vec_set_plus"): New pattern to support reg + const_int + operands. + ("vec_extract"): New expander. + ("*vec_extract"): New insn definition supporting reg and + const_int element selectors. + ("*vec_extract_plus"): New insn definition supporting + reg+const_int element selectors. + ("rotl3", "ashl3", "ashr3"): Merge into the + following expander+insn definition. + ("3"): New expander. + ("*3"): New insn definition. + +2016-03-01 Andreas Krebbel + + * config/s390/s390.md ("*tabort_1"): Change predicate to + nonmemory_operand. Add a second alternative to cover + register as well as const int operands. + ("*tabort_1_plus"): New pattern definition. + +2016-03-01 Andreas Krebbel + + * config/s390/s390.md ("*ashrdi3_cc_31") + ("*ashrdi3_cconly_31""*ashrdi3_cc_31_and") + ("*ashrdi3_cconly_31_and", "*ashrdi3_31_and", "*ashrdi3_31"): + Merge insn definitions into ... + ("*ashrdi3_31"): + New pattern definition. + ("*ashr3_cc", "*ashr3_cconly", "ashr3", ) + ("*ashr3_cc_and", "*ashr3_cconly_and") + ("*ashr3_and"): Merge insn definitions into ... + ("*ashr3"): + New pattern definition. + * config/s390/subst.md ("addr_style_op_cc_subst") + ("masked_op_cc_subst", "setcc_subst", "cconly_subst"): New + substitutions patterns plus attributes. + Add ashiftrt to SUBST iterator. + +2016-03-01 Andreas Krebbel + + * config/s390/s390.md ("3"): Change predicate of + op2 to nonmemory_operand. + ("*di3_31", "*di3_31_and"): + Merge into single pattern definition ... + ("*di3_31"): New pattern. + ("*3", "*3_and"): Merge into single + pattern definition ... + ("*3"): New pattern. + * config/s390/subst.md: Add ashift and lshiftrt to SUBST + iterator. + +2016-03-01 Andreas Krebbel + + * config/s390/predicates.md (const_int_6bitset_operand): New + predicate. + * config/s390/s390.md: Include subst.md. + ("rotl3"): New expander. + ("rotl3", "*rotl3_and"): Merge insn definitions into + ... + ("*rotl3"): New insn definition. + * config/s390/subst.md: New file. + +2016-03-01 Andreas Krebbel + + * config/s390/s390.md ("op_type", "atype", "length" attributes): + Remove RRR type. It doesn't really exist. + ("RRer", "f0", "v0", "vf", "vd", "op1", "Rf"): Remove mode + attributes. + ("BFP", "DFP", "nDSF", "nDFDI"): Add mode attributes. + ("*cmp_ccs", "floatdi2", "add3") + ("*add3_cc", "*add3_cconly", "sub3") + ("*sub3_cc", "*sub3_cconly", "mul3") + ("fma4", "fms4", "div3", "*neg2") + ("*abs2", "*negabs2", "sqrt2"): Override + `enabled' attribute. + +2016-03-01 Andreas Krebbel + + * gensupport.c (process_substs_on_one_elem): Split loop to + complete mark_operands_used_in_match_dup on all expressions in the + vector first. + (adjust_operands_numbers): Inline into process_substs_on_one_elem + and remove function. + +2016-02-29 Eric Botcazou + + PR target/69706 + * config/sparc/sparc.c (NWORDS_UP): Rename to... + (CEIL_NWORDS): ...this. Use CEIL macro. + (compute_fp_layout): Adjust to above renaming. + (function_arg_union_value): Likewise. + (sparc_arg_partial_bytes): Likewise. + (sparc_function_arg_advance): Likewise. + +2016-02-29 Jeff Law + + PR tree-optimization/70005 + * tree-ssa-uncprop.c (associate_equivalences_with_edges): Handle case + where an object with a boolean range is compared against a value + outside [0..1]. + + PR tree-optimization/69999 + * gimple-ssa-split-paths.c (split_paths): When duplicating a block + with an outgoing edge marked with EDGE_IRREDUCIBLE_LOOP, schedule + loop cleanups. + +2016-02-29 Richard Biener + + PR tree-optimization/69994 + * tree-ssa-reassoc.c (gimple_nop_conversion_p): New function. + (get_unary_op): Look through nop conversions. + (ops_equal_values_p): New function, look for equality diregarding + nop conversions. + (eliminate_plus_minus_pair): Use ops_equal_values_p + (repropagate_negates): Do not use get_unary_op here. + +2016-02-29 Martin Liska + + * system.h: Poison ENABLE_CHECKING macro. + +2016-02-29 Martin Liska + + * hsa-gen.c (gen_body_from_gimple): Dump only if TDF_DETAILS + is presented in dump flags. + * hsa-regalloc.c (linear_scan_regalloc): Likewise. + (hsa_regalloc): Likewise. + +2016-02-19 Richard Biener + + PR tree-optimization/69980 + * tree-vect-slp.c (vect_attempt_slp_rearrange_stmts): Update + permutation of those we need to keep. + +2016-02-29 Eric Botcazou + + PR target/69706 + * config/sparc/sparc.c (ROUND_ADVANCE): Rename to... + (NWORDS_UP): ...this + (init_cumulative_args): Minor tweaks. + (sparc_promote_function_mode): Likewise. + (scan_record_type): Delete. + (traverse_record_type): New function template. + (classify_data_t): New structure type. + (classify_registers): New inline function. + (function_arg_slotno): In 64-bit mode, bail out early if FP slots are + exhausted. Instantiate traverse_record_type on classify_registers and + deal with the case of a structure passed in slot #15 with no FP field + in the first word. + (assign_data_t): New structure type. + (compute_int_layout): New static function. + (compute_fp_layout): Likewise. + (count_registers): New inline function. + (assign_int_registers): New static function. + (assign_fp_registers): Likewise. + (assign_registers): New inline function. + (function_arg_record_value_1): Delete. + (function_arg_record_value_2): Likewise. + (function_arg_record_value_3): Likewise. + (function_arg_record_value): Adjust to above changes. Instantiate + traverse_record_type on count_registers to first count the number of + registers to be used and then on assign_registers to assign them. + (function_arg_union_value): Adjust to above renaming. + (sparc_function_arg_1); Minor tweaks. Remove commented out code. + (sparc_arg_partial_bytes): Adjust to above renaming. Deal with the + case of a structure passed in slot #15 + (sparc_function_arg_advance): Likewise. + (function_arg_padding): Minor tweak. + +2016-02-29 Richard Biener + + PR tree-optimization/69720 + * tree-vect-loop.c (get_initial_def_for_reduction): Avoid + the adjustment_def path for possibly vectorized defs. + (vect_create_epilog_for_reduction): Handle vectorized initial + defs properly. + 2016-02-28 Eric Botcazou * config/i386/cygming.h (STACK_REALIGN_DEFAULT): Define. @@ -45,12 +1602,12 @@ complain about -mallow-movmisalign without -mvsx if TARGET_ALLOW_MOVMISALIGN was not set explicitly. -2016-02-26 Joel Sherrill +2016-02-26 Joel Sherrill * config.gcc: Add x86_64-*-rtems*. * gcc/config/i386/rtems-64.h: New file. -2016-02-26 Joel Sherrill +2016-02-26 Joel Sherrill * config.gcc: Add aarch64-*-rtems*. * gcc/config/aarch64/rtems.h: New file. @@ -327,8 +1884,8 @@ 2016-02-23 Evandro Menezes - * config/aarch64/aarch64.c (exynosm1_tunings): Enable the Newton - series for reciprocal square root in Exynos M1. + * config/aarch64/aarch64.c (exynosm1_tunings): Enable the Newton + series for reciprocal square root in Exynos M1. 2016-02-23 Martin Sebor @@ -1386,7 +2943,7 @@ * lto-wrapper.c (append_diag_options): New function. (compile_offload_image): Call append_diag_options. -2016-02-08 Sandra Loosemore +2016-02-08 Sandra Loosemore PR other/69722 * doc/extend.texi (Flag Output Operands): Correct sectioning. @@ -3172,12 +4729,12 @@ (pdr_add_memory_accesses): Same. (pdr_add_data_dimensions): Same. -2016-01-20 Sandra Loosemore +2016-01-20 Sandra Loosemore * doc/invoke.texi (Instrumentation Options): Clarify -mmpx linking requirements. -2016-01-20 Sandra Loosemore +2016-01-20 Sandra Loosemore * common.opt (feliminate-dwarf2-dups): Replace references to "DWARF 2" with just "DWARF". @@ -3322,7 +4879,7 @@ (gen_typedef_die): Likewise. (force_type_die): Adjust call to modified_type_die. -2016-01-19 Sandra Loosemore +2016-01-19 Sandra Loosemore * doc/standards.texi: Copy-editing for grammar, markup, and sentence flow throughout the file. Fix broken link to Objective-C 2.0 @@ -3486,7 +5043,7 @@ 2016-01-19 Martin Jambor Martin Liska - Michael Matz + Michael Matz * Makefile.in (OBJS): Add new source files. (GTFILES): Add hsa.c. @@ -3627,7 +5184,7 @@ * tree-ssanames.c (ssa_name_has_boolean_range): Remove unnecessary test. -2016-01-18 Sandra Loosemore +2016-01-18 Sandra Loosemore * doc/invoke.texi (Invoking GCC): Add new section to menu. (Option Summary): Update to reflect new section and moved options. @@ -4163,14 +5720,14 @@ use block_ultimate_origin (noncall-stmt_may_be_vtbl_ptr_store): Likewise. -2016-01-13 Sandra Loosemore +2016-01-13 Sandra Loosemore * doc/invoke.texi (Submodel Options): Rename section to "Machine-Dependent Options" to better reflect its content. Rewrite introductory text to remove archaic CPU names. Update references. -2016-01-13 Sandra Loosemore +2016-01-13 Sandra Loosemore * doc/invoke.texi (Code Gen Options): Move section up in file, before target-specific options. Update menu and option summary diff --git a/gcc/ChangeLog-2015 b/gcc/ChangeLog-2015 index 7c3131cd4d9a..32f3efc988bf 100644 --- a/gcc/ChangeLog-2015 +++ b/gcc/ChangeLog-2015 @@ -324,7 +324,7 @@ * tree-ssa-dom.c: Include dbgcnt.h (dom_opt_dom_walker::before_dom_children): Handle the new counter. -2015-12-21 Andrew Pinski +2015-12-21 Andrew Pinski * config/aarch64/aarch64-option-extensions.def (LSE): Change FEAT_STRING to "atomics". @@ -574,7 +574,7 @@ * config/aarch64/aarch64-protos.h (aarch64_mask_from_zextract_ops): New prototype. -2015-12-18 Robin Dapp +2015-12-18 Robin Dapp * config/s390/predicates.md: Change and rename constm1_operand to all_ones_operand @@ -601,7 +601,7 @@ * config/s390/s390.h: Default to z900 in the driver. * doc/invoke.texi: Document the deprecation of g5 and g6. -2015-12-18 Andris Pavenis +2015-12-18 Andris Pavenis * config/i386/djgpp-stdint.h: update typedefs for integer types @@ -1414,7 +1414,7 @@ PR rtl-optimization/68730 * cfgrtl.c (cfg_layout_finalize): Free dominators. -2015-12-13 Alexandre Oliva +2015-12-13 Alexandre Oliva PR debug/67355 * var-tracking.c (reverse_op): Don't add dummy zero to reverse @@ -3754,7 +3754,7 @@ * tree-vect-slp.c (vect_get_mask_element): Remove. (vect_transform_slp_perm_load): Implement in a simpler way. -2015-11-26 Alexandre Oliva +2015-11-26 Alexandre Oliva PR rtl-optimization/67753 PR rtl-optimization/64164 @@ -3919,7 +3919,7 @@ TREE_READONLY, don't call use_pointer_for_field with non-NULL second argument until we are sure we are keeping OMP_CLAUSE_SHARED. -2015-11-26 Paolo Bonzini +2015-11-26 Paolo Bonzini * doc/implement-c.texi (Integers Implementation): Make GCC's promises about signed left shift stronger and clarify the cases when they're @@ -4373,7 +4373,7 @@ (gimple_fold_builtin_memory_op): Don't fold call if we are going to instrument it and it may copy pointers. -2015-11-24 Bernd Schmidt +2015-11-24 Bernd Schmidt Kyrylo Tkachov PR rtl-optimization/68194 @@ -4697,7 +4697,7 @@ * config/nvptx/nvptx.c (nvptx_use_anchors_for_symbol_p): New. (TARGET_USE_ANCHORS_FOR_SYMBOL_P): Override. -2015-11-20 Alan Hayward +2015-11-20 Alan Hayward PR tree-optimization/68413 * tree-vect-loop.c (vect_analyze_scalar_cycles_1): Cache @@ -5575,7 +5575,7 @@ (if_convertible_loop_p_1): Initialize hash maps and predicates before hashing data references and delete hashmaps at the end. -2015-11-16 Thomas Preud'homme +2015-11-16 Thomas Preud'homme PR 56036 * doc/invoke.texi (Optimize Options): Move @end table to the right @@ -5599,7 +5599,7 @@ in the user documentation. (define_peephole2, define_split): Similarly. -2015-11-16 Andris Pavenis +2015-11-16 Andris Pavenis * lto-streamer-out.c (write_global_references): Adjust integer type. (lto_output_decl_state_refs): Likewise. @@ -5881,7 +5881,7 @@ argument is 1, replace it with GOMP_ordered_* call instead of removing it. -2015-11-13 Rich Felker +2015-11-13 Rich Felker * config/sh/sh.md (symGOT_load): Suppress __stack_chk_guard address loading hack for FDPIC targets. @@ -6183,7 +6183,7 @@ * tree-vect-stmts.c (vectorizable_comparison): Provide vectype for loop invariants. -2015-11-13 Alan Hayward +2015-11-13 Alan Hayward PR tree-optimization/66558 * tree-vect-loop.c (is_integer_induction):Add. @@ -8067,7 +8067,7 @@ the dominance info; free it if we can't. (pass_call_cdce::execute): Don't free the dominance info here. -2015-11-06 Jeff Law +2015-11-06 Jeff Law * tree-ssa-threadedge.c (dummy_simplify): Remove. (thread_around_empty_blocks): Remove backedge_seen_p argument. @@ -8100,7 +8100,7 @@ (build_scop_scattering): Call build_pbb_minimal_scattering_polyhedrons. (build_poly_scop): Call build_scop_minimal_scattering. -2015-11-06 Jeff Law +2015-11-06 Jeff Law * cfg-flags.def (IGNORE): New edge flag. * tree-vrp.c (identify_jump_threads): Mark and clear edges @@ -8426,7 +8426,7 @@ * config/i386/i386.c: Include gimple-iterator.h. * config/aarch64/aarch64.c: Likewise. -2015-11-06 Alexandre Oliva +2015-11-06 Alexandre Oliva PR rtl-optimization/67753 PR rtl-optimization/64164 @@ -8840,7 +8840,7 @@ * config/aarch64/aarch64.md (*movhf_aarch64): Use aarch64_reg_or_fp_zero for second operand. -2015-11-03 Alexandre Oliva +2015-11-03 Alexandre Oliva * gimple-expr.c: Include hash-set.h and rtl.h. (mark_addressable_queue): New var. @@ -8852,7 +8852,7 @@ * cfgexpand.c: Include gimple-expr.h. (pass_expand::execute): Flush mark_addressable queue. -2015-11-02 Alexandre Oliva +2015-11-02 Alexandre Oliva * tree-ssa-ifcombine.c (tree_ssa_ifcombine_bb_1): Factor out bb_no_side_effects_p tests... @@ -8864,7 +8864,7 @@ * tree-ssa.c (gimple_uses_undefined_value_p): New. * tree-ssa.h (gimple_uses_undefined_value_p): Declare. -2015-11-02 Jeff Law +2015-11-02 Jeff Law * tree-ssa-threadupdate.c (valid_jump_thread_path): Also detect cases where the loop latch edge is in the middle of an FSM path. @@ -8928,7 +8928,7 @@ PR middle-end/68166 * fold-const.c: Include "md5.h". -2015-11-01 Jeff Law +2015-11-01 Jeff Law * vmsdbgout.c: Revert unused header file reduction patch. @@ -8977,7 +8977,7 @@ * tree-ssa-structalias.c (ipa_pta_execute): Use make_copy_constraint. -2015-10-30 Jeff Law +2015-10-30 Jeff Law Nathan Sidwell * config/nvptx/nvptx.h (HARD_REGNO_NREGS): Avoid warning on unused @@ -10523,7 +10523,7 @@ Joseph Myers Mark Shinwell Andrew Stubbs - Rich Felker + Rich Felker * config.gcc: Handle --enable-fdpic. * config/sh/constraints.md (Ccl): New constraint. @@ -10848,7 +10848,7 @@ * match.pd ((A & ~B) - (A & B) -> (A ^ B) - B): Add missing :c. ( (X & ~Y) | (~X & Y) -> X ^ Y): Remove redundant :c. -2015-10-26 Alan Hayward +2015-10-26 Alan Hayward * tree-vect-loop.c (vect_create_epilog_for_reduction): Fix VEC_COND_EXPR types. @@ -11043,7 +11043,7 @@ * tree.c (build_truth_vector_type): Support BLK mode returned for boolean vector. -2015-10-23 Alan Hayward +2015-10-23 Alan Hayward PR tree-optimization/65947 * tree-vect-loop.c @@ -12082,7 +12082,7 @@ empty constructors. 2015-10-16 Michael Collison - Andrew Pinski + Andrew Pinski * match.pd ((x < y) && (x < z) -> x < min (y,z), (x > y) and (x > z) -> x > max (y,z)) @@ -12641,7 +12641,7 @@ (ix86_set_reg_reg_cost): Ditto. * config/i386/i386.h (HARD_REGNO_NREGS): Ditto. -2015-10-13 Alexandre Oliva +2015-10-13 Alexandre Oliva PR middle-end/67912 * expmed.c (store_bit_field_1): Adjust mode of BLKmode inputs. @@ -13037,7 +13037,7 @@ * config/rs6000/rs6000.c (rs6000_offload_options): New. (TARGET_OFFLOAD_OPTIONS): New. -2015-10-09 Alexandre Oliva +2015-10-09 Alexandre Oliva PR middle-end/67891 * cfgexpand.c (set_parm_rtl): Drop is_gimple_reg test. @@ -13927,8 +13927,8 @@ (fold_builtin_hypot, fold_builtin_pow): Likewise. * match.pd: Likewise. -2015-10-05 James Greenhalgh - Jiong Wang +2015-10-05 James Greenhalgh + Jiong Wang * config/aarch64/aarch64.md (tlsie_tiny_sidi): Replace "" with "w". @@ -15087,7 +15087,7 @@ arith_reg_operand for operands[1]. Allow it only when LRA is enabled. (addsi3_scr, *addsi3): New insn_and_split patterns. -2015-09-27 Alexandre Oliva +2015-09-27 Alexandre Oliva PR rtl-optimization/64164 PR tree-optimization/67312 @@ -15563,7 +15563,7 @@ 'reg + reloc' cases, allow first operand to be non-REG, and use force_reg() to enforce address pattern. -2015-09-22 Alexander Fomin +2015-09-22 Alexander Fomin PR target/67480 * config/i386/sse.md (define_mode_iterator VI48_AVX_AVX512F): New. @@ -17063,7 +17063,7 @@ * config/arc/arc.opt, config/arc/constraints.md: Likewise. * config/arc/t-arc-newlib: Likewise. -2015-09-10 Claudiu Zissulescu +2015-09-10 Claudiu Zissulescu * config/arc/arc.md (length): Fix attribute length for conditional executed instructions with long immediate. @@ -17750,7 +17750,7 @@ * genmodes.c: Add CONST_MODE_UNIT_SIZE modifier. -2015-09-01 Kyrylo Tkachov +2015-09-01 Kyrylo Tkachov * ifcvt.c (struct noce_if_info): Add then_simple, else_simple, then_cost, else_cost fields. Change branch_cost field to unsigned int. @@ -17886,7 +17886,7 @@ adjust_concat. (dump_swap_insn_table): Handle SH_XXPERMDI and SH_CONCAT. -2015-08-30 Rich Felker +2015-08-30 Rich Felker * config.gcc (supported_defaults): Handle sh[123456ble]*-*-* case instead of sh[123456ble]-*-*. @@ -18736,7 +18736,7 @@ * config/aarch64/aarch64.c: Remove the last argument to AARCH64_FUSION_PAIR. -2015-08-22 Mikhail Maltsev +2015-08-22 Mikhail Maltsev * dominance.c (new_zero_array): Define. (dom_info): Redefine as class with proper encapsulation. @@ -20353,7 +20353,7 @@ * toplev.h (toplev::toplev): Replace "use_TV_TOTAL" bool param with "external_timer" timer *. -2015-08-03 Alexander Basov +2015-08-03 Alexander Basov PR middle-end/64744 PR middle-end/48470 @@ -23087,19 +23087,19 @@ iterator to use_stmt. 2015-07-15 Aditya Kumar - Sebastian Pop + Sebastian Pop * graphite-scop-detection.c (build_scops_1): Discard scops for which entry==exit. 2015-07-15 Aditya Kumar - Sebastian Pop + Sebastian Pop * graphite-scop-detection.c (stmt_simple_for_scop_p): Bail out in case of a return statement in scop. 2015-07-15 Aditya Kumar - Sebastian Pop + Sebastian Pop * graphite-sese-to-poly.c (parameter_index_in_region): Only handle INTEGER_TYPE parameters. @@ -25255,7 +25255,7 @@ * match.pd: Add missing condition to ~X ^ C -> X ^ ~C. 2015-07-05 Chung-Lin Tang - Sandra Loosemore + Sandra Loosemore * config/nios2/nios2-protos.h (nios2_symbol_ref_in_small_data_p): Delete extern declaration. @@ -25633,13 +25633,13 @@ (X & Y) ^ Y -> ~X & Y transforms to ... * match.pd: ... here. -2015-07-01 Richard Biener +2015-07-01 Richard Biener * genmatch.c (expr::gen_transform): Shortcut re-simplifying of converts to avoid uninteresting noise from the conversion simplifying patterns. -2015-06-30 Sandra Loosemore +2015-06-30 Sandra Loosemore * config/c6x/c6x.c (try_rename_operands): Do not depend on gcc_assert evaluating its argument for side-effect. @@ -25982,8 +25982,8 @@ division, compute max and min when value ranges for dividend and divisor are available. -2015-06-28 Chung-Lin Tang - Sandra Loosemore +2015-06-28 Chung-Lin Tang + Sandra Loosemore * regrename.h (regrename_do_replace): Change to return bool. * regrename.c (rename_chains): Check return value of @@ -26937,7 +26937,7 @@ * tree-vect-slp.c (vect_build_slp_tree_1): Init vectype. -2015-06-24 Renlin Li +2015-06-24 Renlin Li * config/aarch64/aarch64.h(TARGET_CPU_CPP_BUILTINS): Add __ARM_ALIGN_MAX_PWR, __ARM_ALIGN_MAX_STACK_PWR. @@ -33263,7 +33263,7 @@ "break". 2015-05-12 Chung-Lin Tang - Sandra Loosemore + Sandra Loosemore * config/nios2/nios2.h (enum reg_class): Add IJMP_REGS enum value. @@ -34934,7 +34934,7 @@ * configure: Regenerate. * config.in: Regenerate. -2015-04-27 Yoshinori Sato +2015-04-27 Yoshinori Sato * config.gcc: Add h8300-*-linux. * config/h8300/linux.h: New. @@ -35223,7 +35223,7 @@ (avx512f_unpckhpd512): Ditto. 2015-04-24 Thomas Preud'homme - Steven Bosscher + Steven Bosscher PR rtl-optimization/34503 * cprop.c (cprop_reg_p): New. @@ -36073,7 +36073,7 @@ Release symbol_compare_collection. * ipa-reference.c: Add TODO that a vector should be released. -2015-04-17 Sivanupandi Pitchumani +2015-04-17 Sivanupandi Pitchumani PR target/65296 * config/avr/gen-avr-mmcu-specs.c (*avrlibc_startfile): Adjust @@ -39425,7 +39425,7 @@ * omp-low.c (create_omp_child_function): Tag entrypoint functions with a special attribute. -2015-02-24 Michael Haubenwallner +2015-02-24 Michael Haubenwallner PR target/65058 * config/rs6000/xcoff.h (ASM_OUTPUT_EXTERNAL): Drop unused variable. @@ -40614,7 +40614,7 @@ * config/rs6000/rs6000.c (chain_already_loaded): New function. (rs6000_call_aix): Use it. -2015-02-05 Jan Hubicka +2015-02-05 Jan Hubicka * ipa-cp.c (ipa_value_from_jfunc, ipa_context_from_jfunc): Add bounds check. @@ -40763,7 +40763,7 @@ of manual swapping implementation. (aarch64_expand_vec_perm_const_1): Likewise. -2015-02-04 James Greenhalgh +2015-02-04 James Greenhalgh * config/aarch64/aarch64.c (NAMED_PARAM): Delete it. (generic_addrcost_table): Remove NAMED_PARAM. @@ -41933,7 +41933,7 @@ decl attribute. 2015-01-21 David Sherwood - Tejas Belagod + Tejas Belagod * config/aarch64/aarch64.h (CANNOT_CHANGE_MODE_CLASS): Removed. * config/aarch64/aarch64.c (aarch64_cannot_change_mode_class): Removed. @@ -41941,7 +41941,7 @@ Removed. 2015-01-21 David Sherwood - Tejas Belagod + Tejas Belagod * config/aarch64/aarch64-protos.h (aarch64_simd_attr_length_rglist) (aarch64_reverse_mask): New decls. @@ -42592,7 +42592,7 @@ introduced in revision 219724. 2015-01-16 Kyrylo Tkachov - Ramana Radhakrishnan + Ramana Radhakrishnan PR target/64263 * config/aarch64/aarch64.md (*movsi_aarch64): Don't split if the @@ -43555,7 +43555,7 @@ for MEM_REF access functions with the same base can never partially overlap. -2015-01-14 Marcos Diaz +2015-01-14 Marcos Diaz * common.opt: New option -fstack-protector-explicit. * cfgexpand.c (SPCT_FLAG_EXPLICIT): New enum. @@ -43741,7 +43741,7 @@ Do not save lr in case of tail call. * config/arm/thumb2.md (*thumb2_pop_single): New pattern. -2015-01-14 Martin Uecker +2015-01-14 Martin Uecker * tree-vrp.c (check_array_ref): Emit more warnings for warn_array_bounds >= 2. diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index c79ed1de35e1..7f2dc5199476 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20160228 +20160327 diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index 4868cae34a2f..0c9b179792d3 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,6 +1,93 @@ +2016-03-27 Eric Botcazou + + * gcc-interface/decl.c (components_to_record): Add special case for + single field with representation clause at offset 0. + +2016-03-16 Svante Signell + + * gcc-interface/Makefile.in: Add support for x86 GNU/Hurd. + * s-osinte-gnu.ads: New file. + +2016-03-13 Eric Botcazou + + * system-vxworks-m68k.ads (Stack_Check_Probes): Set to True. + (Stack_Check_Limits): Set to False. + * system-vxworks-mips.ads (Stack_Check_Probes): Set to True. + (Stack_Check_Limits): Set to False. + * system-vxworks-ppc.ads (Stack_Check_Probes): Set to True. + (Stack_Check_Limits): Set to False. + * system-vxworks-sparcv9.ads (Stack_Check_Probes): Set to True. + (Stack_Check_Limits): Set to False. + * system-vxworks-x86.ads (Stack_Check_Probes): Set to True. + (Stack_Check_Limits): Set to False. + +2016-03-07 Eric Botcazou + + * gcc-interface/trans.c (statement_node_p): New predicate. + (gnat_to_gnu): Invoke it to detect statement nodes. In ASIS mode, do + not return dummy results for expressions attached to packed array + implementation types. + +2016-03-07 Eric Botcazou + + * gcc-interface/decl.c (gnat_to_gnu_entity) : Always mark + the expression of a renaming manually in case #3. + +2016-03-02 Dominik Vogt + + * system-linux-s390.ads: Enable Stack_Check_Probes. + * system-linux-s390.ads: Likewise. + +2016-02-29 Martin Liska + + * gcc-interface/utils.c (set_reverse_storage_order_on_pad_type): + Replace ENABLE_CHECKING macro with flag_checking. + +2016-02-29 Eric Botcazou + + * gcc-interface/decl.c (gnat_to_gnu_entity) : Retrofit + handling of unconstrained array types as designated types into common + processing. Also handle array types as incomplete designated types. + +2016-02-29 Eric Botcazou + + * gcc-interface/decl.c (gnat_to_gnu_entity) : In + ASIS mode, fully lay out the minimal record type. + +2016-02-29 Eric Botcazou + + * gcc-interface/trans.c (finalize_nrv_r): Remove obsolete code. + (build_return_expr): Likewise. + (Call_to_gnu): If this is a function call and there is no target, + create a temporary for the return value for all aggregate types, + but never create it for a return statement. Push a binding level + around the call in more cases. Remove obsolete code. + +2016-02-29 Eric Botcazou + + * gcc-interface/ada-tree.h (DECL_RETURN_VALUE_P): New macro. + * gcc-interface/gigi.h (gigi): Remove useless attribute. + (gnat_gimplify_expr): Likewise. + (gnat_to_gnu_external): Declare. + * gcc-interface/decl.c (gnat_to_gnu_entity) : Factor out + code dealing with the expression of external constants into... + Invoke gnat_to_gnu_external instead. + : Invoke gnat_to_gnu_external to translate renamed objects + when not for a definition. Deal with COMPOUND_EXPR and variables with + DECL_RETURN_VALUE_P set for renamings and with the case of a dangling + 'reference to a function call in a renaming. Remove obsolete test and + adjust associated comment. + * gcc-interface/trans.c (Call_to_gnu): Set DECL_RETURN_VALUE_P on the + temporaries created to hold the return value, if any. + (gnat_to_gnu_external): ...this. New function. + * gcc-interface/utils.c (create_var_decl): Detect a constant created + to hold 'reference to function call. + * gcc-interface/utils2.c (build_unary_op) : Add folding + for COMPOUND_EXPR in the DECL_RETURN_VALUE_P case. + 2016-02-17 Eric Botcazou - * exp_ch4.adb (Expand_N_Indexed_Component): Active synchronization if + * exp_ch4.adb (Expand_N_Indexed_Component): Activate synchronization if the prefix denotes an entity which Has_Atomic_Components. * gcc-interface/trans.c (node_is_atomic): Return true if the prefix denotes an entity which Has_Atomic_Components. diff --git a/gcc/ada/gcc-interface/Makefile.in b/gcc/ada/gcc-interface/Makefile.in index 8d91b667087c..bfc718b38bba 100644 --- a/gcc/ada/gcc-interface/Makefile.in +++ b/gcc/ada/gcc-interface/Makefile.in @@ -1,5 +1,5 @@ # Makefile for GNU Ada Compiler (GNAT). -# Copyright (C) 1994-2015 Free Software Foundation, Inc. +# Copyright (C) 1994-2016 Free Software Foundation, Inc. #This file is part of GCC. @@ -1420,6 +1420,35 @@ ifeq ($(strip $(filter-out %86 kfreebsd%,$(target_cpu) $(target_os))),) MISCLIB = -lutil endif +# i[3456]86-pc-gnu i.e. GNU Hurd +ifeq ($(strip $(filter-out %86 pc gnu,$(target_cpu) $(target_vendor) $(target_os))),) + LIBGNAT_TARGET_PAIRS = \ + a-intnam.adsnrv, ret_val)) - { - if (init_expr) - TREE_OPERAND (TREE_OPERAND (t, 0), 1) = init_expr; - else - TREE_OPERAND (t, 0) = dp->result; - } + TREE_OPERAND (t, 0) = dp->result; } /* Replace the DECL_EXPR of NRVs with an initialization of the RESULT_DECL, @@ -3659,14 +3641,6 @@ build_return_expr (tree ret_obj, tree ret_val) && TYPE_MODE (operation_type) == BLKmode && aggregate_value_p (operation_type, current_function_decl)) { - /* Recognize the temporary created for a return value with variable - size in Call_to_gnu. We want to eliminate it if possible. */ - if (TREE_CODE (ret_val) == COMPOUND_EXPR - && TREE_CODE (TREE_OPERAND (ret_val, 0)) == INIT_EXPR - && TREE_OPERAND (TREE_OPERAND (ret_val, 0), 0) - == TREE_OPERAND (ret_val, 1)) - ret_val = TREE_OPERAND (ret_val, 1); - /* Strip useless conversions around the return value. */ if (gnat_useless_type_conversion (ret_val)) ret_val = TREE_OPERAND (ret_val, 0); @@ -4314,14 +4288,22 @@ Call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target, because we need to preserve the return value before copying back the parameters. - 2. There is no target and this is neither an object nor a renaming - declaration, and the return type has variable size, because in - these cases the gimplifier cannot create the temporary. + 2. There is no target and the call is made for neither an object nor a + renaming declaration, nor a return statement, and the return type has + variable size, because in this case the gimplifier cannot create the + temporary, or more generally is simply an aggregate type, because the + gimplifier would create the temporary in the outermost scope instead + of locally. 3. There is a target and it is a slice or an array with fixed size, and the return type has variable size, because the gimplifier doesn't handle these cases. + 4. There is no target and we have misaligned In Out or Out parameters + passed by reference, because we need to preserve the return value + before copying back the parameters. However, in this case, we'll + defer creating the temporary, see below. + This must be done before we push a binding level around the call, since we will pop it before copying the return value. */ if (function_call @@ -4329,14 +4311,29 @@ Call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target, || (!gnu_target && Nkind (Parent (gnat_node)) != N_Object_Declaration && Nkind (Parent (gnat_node)) != N_Object_Renaming_Declaration - && TREE_CODE (TYPE_SIZE (gnu_result_type)) != INTEGER_CST) + && Nkind (Parent (gnat_node)) != N_Simple_Return_Statement + && AGGREGATE_TYPE_P (gnu_result_type) + && !TYPE_IS_FAT_POINTER_P (gnu_result_type)) || (gnu_target && (TREE_CODE (gnu_target) == ARRAY_RANGE_REF || (TREE_CODE (TREE_TYPE (gnu_target)) == ARRAY_TYPE && TREE_CODE (TYPE_SIZE (TREE_TYPE (gnu_target))) == INTEGER_CST)) && TREE_CODE (TYPE_SIZE (gnu_result_type)) != INTEGER_CST))) - gnu_retval = create_temporary ("R", gnu_result_type); + { + gnu_retval = create_temporary ("R", gnu_result_type); + DECL_RETURN_VALUE_P (gnu_retval) = 1; + } + + /* If we don't need a value or have already created it, push a binding level + around the call. This will narrow the lifetime of the temporaries we may + need to make when translating the parameters as much as possible. */ + if (!returning_value || gnu_retval) + { + start_stmt_group (); + gnat_pushlevel (); + pushed_binding_level = true; + } /* Create the list of the actual parameters as GCC expects it, namely a chain of TREE_LIST nodes in which the TREE_VALUE field of each node @@ -4461,14 +4458,15 @@ Call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target, we need to create a temporary for the return value because we must preserve it before copying back at the very end. */ if (!in_param && returning_value && !gnu_retval) - gnu_retval = create_temporary ("R", gnu_result_type); - - /* If we haven't pushed a binding level, push a new one. This will - narrow the lifetime of the temporary we are about to make as much - as possible. The drawback is that we'd need to create a temporary - for the return value, if any (see comment before the loop). So do - it only when this temporary was already created just above. */ - if (!pushed_binding_level && !(in_param && returning_value)) + { + gnu_retval = create_temporary ("R", gnu_result_type); + DECL_RETURN_VALUE_P (gnu_retval) = 1; + } + + /* If we haven't pushed a binding level, push it now. This will + narrow the lifetime of the temporary we are about to make as + much as possible. */ + if (!pushed_binding_level && (!returning_value || gnu_retval)) { start_stmt_group (); gnat_pushlevel (); @@ -4699,15 +4697,6 @@ Call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target, if (!gnu_retval) { tree gnu_stmt; - /* If we haven't pushed a binding level, push a new one. This - will narrow the lifetime of the temporary we are about to - make as much as possible. */ - if (!pushed_binding_level) - { - start_stmt_group (); - gnat_pushlevel (); - pushed_binding_level = true; - } gnu_call = create_init_temporary ("P", gnu_call, &gnu_stmt, gnat_node); append_to_statement_list (gnu_stmt, &gnu_stmt_list); @@ -5726,6 +5715,28 @@ unchecked_conversion_nop (Node_Id gnat_node) return false; } +/* Return true if GNAT_NODE represents a statement. */ + +static bool +statement_node_p (Node_Id gnat_node) +{ + const Node_Kind kind = Nkind (gnat_node); + + if (kind == N_Label) + return true; + + if (IN (kind, N_Statement_Other_Than_Procedure_Call)) + return true; + + if (kind == N_Procedure_Call_Statement) + return true; + + if (IN (kind, N_Raise_xxx_Error) && Ekind (Etype (gnat_node)) == E_Void) + return true; + + return false; +} + /* This function is the driver of the GNAT to GCC tree transformation process. It is the entry point of the tree transformer. GNAT_NODE is the root of some GNAT tree. Return the root of the corresponding GCC tree. If this @@ -5749,15 +5760,23 @@ gnat_to_gnu (Node_Id gnat_node) error_gnat_node = gnat_node; Sloc_to_locus (Sloc (gnat_node), &input_location); - /* If this node is a statement and we are only annotating types, return an - empty statement list. */ - if (type_annotate_only && IN (kind, N_Statement_Other_Than_Procedure_Call)) + /* If we are only annotating types and this node is a statement, return + an empty statement list. */ + if (type_annotate_only && statement_node_p (gnat_node)) return alloc_stmt_list (); - /* If this node is a non-static subexpression and we are only annotating - types, make this into a NULL_EXPR. */ + /* If we are only annotating types and this node is a subexpression, return + a NULL_EXPR, but filter out nodes appearing in the expressions attached + to packed array implementation types. */ if (type_annotate_only && IN (kind, N_Subexpr) + && !(((IN (kind, N_Op) && kind != N_Op_Expon) + || kind == N_Type_Conversion) + && Is_Integer_Type (Etype (gnat_node))) + && !(kind == N_Attribute_Reference + && Get_Attribute_Id (Attribute_Name (gnat_node)) == Attr_Length + && Ekind (Etype (Prefix (gnat_node))) == E_Array_Subtype + && !Is_Constr_Subt_For_U_Nominal (Etype (Prefix (gnat_node)))) && kind != N_Expanded_Name && kind != N_Identifier && !Compile_Time_Known_Value (gnat_node)) @@ -5765,13 +5784,9 @@ gnat_to_gnu (Node_Id gnat_node) build_call_raise (CE_Range_Check_Failed, gnat_node, N_Raise_Constraint_Error)); - if ((IN (kind, N_Statement_Other_Than_Procedure_Call) - && kind != N_Null_Statement) - || kind == N_Procedure_Call_Statement - || kind == N_Label - || kind == N_Implicit_Label_Declaration + if ((statement_node_p (gnat_node) && kind != N_Null_Statement) || kind == N_Handled_Sequence_Of_Statements - || (IN (kind, N_Raise_xxx_Error) && Ekind (Etype (gnat_node)) == E_Void)) + || kind == N_Implicit_Label_Declaration) { tree current_elab_proc = get_elaboration_procedure (); @@ -5791,7 +5806,8 @@ gnat_to_gnu (Node_Id gnat_node) spurious errors on dummy (empty) sequences created by the front-end for package bodies in some cases. */ if (current_function_decl == current_elab_proc - && kind != N_Handled_Sequence_Of_Statements) + && kind != N_Handled_Sequence_Of_Statements + && kind != N_Implicit_Label_Declaration) Check_Elaboration_Code_Allowed (gnat_node); } @@ -7808,6 +7824,37 @@ gnat_to_gnu (Node_Id gnat_node) return gnu_result; } + +/* Similar to gnat_to_gnu, but discard any object that might be created in + the course of the translation of GNAT_NODE, which must be an "external" + expression in the sense that it will be elaborated elsewhere. */ + +tree +gnat_to_gnu_external (Node_Id gnat_node) +{ + const int save_force_global = force_global; + bool went_into_elab_proc = false; + + /* Force the local context and create a fake scope that we zap + at the end so declarations will not be stuck either in the + global varpool or in the current scope. */ + if (!current_function_decl) + { + current_function_decl = get_elaboration_procedure (); + went_into_elab_proc = true; + } + force_global = 0; + gnat_pushlevel (); + + tree gnu_result = gnat_to_gnu (gnat_node); + + gnat_zaplevel (); + force_global = save_force_global; + if (went_into_elab_proc) + current_function_decl = NULL_TREE; + + return gnu_result; +} /* Subroutine of above to push the exception label stack. GNU_STACK is a pointer to the stack to update and GNAT_LABEL, if present, is the diff --git a/gcc/ada/gcc-interface/utils.c b/gcc/ada/gcc-interface/utils.c index ff21e7b5ff05..9bd2773ba9e8 100644 --- a/gcc/ada/gcc-interface/utils.c +++ b/gcc/ada/gcc-interface/utils.c @@ -1486,11 +1486,13 @@ set_reverse_storage_order_on_pad_type (tree type) { tree field, canonical_pad_type; -#ifdef ENABLE_CHECKING - /* If the inner type is not scalar then the function does nothing. */ - tree inner_type = TREE_TYPE (TYPE_FIELDS (type)); - gcc_assert (!AGGREGATE_TYPE_P (inner_type) && !VECTOR_TYPE_P (inner_type)); -#endif + if (flag_checking) + { + /* If the inner type is not scalar then the function does nothing. */ + tree inner_type = TREE_TYPE (TYPE_FIELDS (type)); + gcc_assert (!AGGREGATE_TYPE_P (inner_type) + && !VECTOR_TYPE_P (inner_type)); + } /* This is required for the canonicalization. */ gcc_assert (TREE_CONSTANT (TYPE_SIZE (type))); @@ -2464,6 +2466,22 @@ create_var_decl (tree name, tree asm_name, tree type, tree init, && !AGGREGATE_TYPE_P (type)) ? CONST_DECL : VAR_DECL, name, type); + /* Detect constants created by the front-end to hold 'reference to function + calls for stabilization purposes. This is needed for renaming. */ + if (const_flag && init && POINTER_TYPE_P (type)) + { + tree inner = init; + if (TREE_CODE (inner) == COMPOUND_EXPR) + inner = TREE_OPERAND (inner, 1); + inner = remove_conversions (inner, true); + if (TREE_CODE (inner) == ADDR_EXPR + && ((TREE_CODE (TREE_OPERAND (inner, 0)) == CALL_EXPR + && !call_is_atomic_load (TREE_OPERAND (inner, 0))) + || (TREE_CODE (TREE_OPERAND (inner, 0)) == VAR_DECL + && DECL_RETURN_VALUE_P (TREE_OPERAND (inner, 0))))) + DECL_RETURN_VALUE_P (var_decl) = 1; + } + /* If this is external, throw away any initializations (they will be done elsewhere) unless this is a constant for which we would like to remain able to get the initializer. If we are defining a global here, leave a diff --git a/gcc/ada/gcc-interface/utils2.c b/gcc/ada/gcc-interface/utils2.c index 44a05fb012d4..c1bb74da2874 100644 --- a/gcc/ada/gcc-interface/utils2.c +++ b/gcc/ada/gcc-interface/utils2.c @@ -1383,8 +1383,11 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand) since the middle-end cannot handle it. But we don't it in the general case because it may introduce aliasing issues if the first operand is an indirect assignment and the second operand - the corresponding address, e.g. for an allocator. */ - if (TREE_CODE (type) == UNCONSTRAINED_ARRAY_TYPE) + the corresponding address, e.g. for an allocator. However do + it for a return value to expose it for later recognition. */ + if (TREE_CODE (type) == UNCONSTRAINED_ARRAY_TYPE + || (TREE_CODE (TREE_OPERAND (operand, 1)) == VAR_DECL + && DECL_RETURN_VALUE_P (TREE_OPERAND (operand, 1)))) { result = build_unary_op (ADDR_EXPR, result_type, TREE_OPERAND (operand, 1)); diff --git a/gcc/ada/s-osinte-gnu.ads b/gcc/ada/s-osinte-gnu.ads new file mode 100644 index 000000000000..b3397c1ea8e4 --- /dev/null +++ b/gcc/ada/s-osinte-gnu.ads @@ -0,0 +1,801 @@ +------------------------------------------------------------------------------ +-- -- +-- GNU ADA RUN-TIME LIBRARY (GNARL) COMPONENTS -- +-- -- +-- S Y S T E M . O S _ I N T E R F A C E -- +-- -- +-- S p e c -- +-- -- +-- Copyright (C) 1991-1994, Florida State University -- +-- Copyright (C) 1995-2016, Free Software Foundation, Inc. -- +-- -- +-- GNAT is free software; you can redistribute it and/or modify it under -- +-- terms of the GNU General Public License as published by the Free Soft- -- +-- ware Foundation; either version 3, or (at your option) any later ver- -- +-- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- +-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- +-- or FITNESS FOR A PARTICULAR PURPOSE. -- +-- -- +-- As a special exception under Section 7 of GPL version 3, you are granted -- +-- additional permissions described in the GCC Runtime Library Exception, -- +-- version 3.1, as published by the Free Software Foundation. -- +-- -- +-- You should have received a copy of the GNU General Public License and -- +-- a copy of the GCC Runtime Library Exception along with this program; -- +-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- +-- . -- +-- -- +-- GNARL was developed by the GNARL team at Florida State University. -- +-- Extensive contributions were provided by Ada Core Technologies, Inc. -- +-- -- +------------------------------------------------------------------------------ + +-- This is the GNU/Hurd (POSIX Threads) version of this package + +-- This package encapsulates all direct interfaces to OS services +-- that are needed by children of System. + +-- PLEASE DO NOT add any with-clauses to this package or remove the pragma +-- Preelaborate. This package is designed to be a bottom-level (leaf) package + +with Interfaces.C; +with Unchecked_Conversion; + +package System.OS_Interface is + pragma Preelaborate; + + pragma Linker_Options ("-lpthread"); + pragma Linker_Options ("-lrt"); + + subtype int is Interfaces.C.int; + subtype char is Interfaces.C.char; + subtype short is Interfaces.C.short; + subtype long is Interfaces.C.long; + subtype unsigned is Interfaces.C.unsigned; + subtype unsigned_short is Interfaces.C.unsigned_short; + subtype unsigned_long is Interfaces.C.unsigned_long; + subtype unsigned_char is Interfaces.C.unsigned_char; + subtype plain_char is Interfaces.C.plain_char; + subtype size_t is Interfaces.C.size_t; + + ----------- + -- Errno -- + ----------- + -- From /usr/include/i386-gnu/bits/errno.h + + function errno return int; + pragma Import (C, errno, "__get_errno"); + + EAGAIN : constant := 1073741859; + EINTR : constant := 1073741828; + EINVAL : constant := 1073741846; + ENOMEM : constant := 1073741836; + EPERM : constant := 1073741825; + ETIMEDOUT : constant := 1073741884; + + ------------- + -- Signals -- + ------------- + -- From /usr/include/i386-gnu/bits/signum.h + + Max_Interrupt : constant := 32; + type Signal is new int range 0 .. Max_Interrupt; + for Signal'Size use int'Size; + + SIGHUP : constant := 1; -- hangup + SIGINT : constant := 2; -- interrupt (rubout) + SIGQUIT : constant := 3; -- quit (ASCD FS) + SIGILL : constant := 4; -- illegal instruction (not reset) + SIGTRAP : constant := 5; -- trace trap (not reset) + SIGIOT : constant := 6; -- IOT instruction + SIGABRT : constant := 6; -- used by abort, replace SIGIOT in the future + SIGEMT : constant := 7; -- EMT instruction + SIGFPE : constant := 8; -- floating point exception + SIGKILL : constant := 9; -- kill (cannot be caught or ignored) + SIGBUS : constant := 10; -- bus error + SIGSEGV : constant := 11; -- segmentation violation + SIGSYS : constant := 12; -- bad argument to system call + SIGPIPE : constant := 13; -- write on a pipe with no one to read it + SIGALRM : constant := 14; -- alarm clock + SIGTERM : constant := 15; -- software termination signal from kill + SIGURG : constant := 16; -- urgent condition on IO channel + SIGSTOP : constant := 17; -- stop (cannot be caught or ignored) + SIGTSTP : constant := 18; -- user stop requested from tty + SIGCONT : constant := 19; -- stopped process has been continued + SIGCLD : constant := 20; -- alias for SIGCHLD + SIGCHLD : constant := 20; -- child status change + SIGTTIN : constant := 21; -- background tty read attempted + SIGTTOU : constant := 22; -- background tty write attempted + SIGIO : constant := 23; -- I/O possible (Solaris SIGPOLL alias) + SIGPOLL : constant := 23; -- I/O possible (same as SIGIO?) + SIGXCPU : constant := 24; -- CPU time limit exceeded + SIGXFSZ : constant := 25; -- filesize limit exceeded + SIGVTALRM : constant := 26; -- virtual timer expired + SIGPROF : constant := 27; -- profiling timer expired + SIGWINCH : constant := 28; -- window size change + SIGINFO : constant := 29; -- information request (NetBSD/FreeBSD) + SIGUSR1 : constant := 30; -- user defined signal 1 + SIGUSR2 : constant := 31; -- user defined signal 2 + SIGLOST : constant := 32; -- Resource lost (Sun); server died (GNU) + + SIGADAABORT : constant := SIGABRT; + -- Change this if you want to use another signal for task abort. + -- SIGTERM might be a good one. + + type Signal_Set is array (Natural range <>) of Signal; + + Unmasked : constant Signal_Set := ( + SIGTRAP, + -- To enable debugging on multithreaded applications, mark SIGTRAP to + -- be kept unmasked. + + SIGBUS, + + SIGTTIN, SIGTTOU, SIGTSTP, + -- Keep these three signals unmasked so that background processes + -- and IO behaves as normal "C" applications + + SIGPROF, + -- To avoid confusing the profiler + + SIGKILL, SIGSTOP); + -- These two signals actually cannot be masked; + -- POSIX simply won't allow it. + + Reserved : constant Signal_Set := + -- I am not sure why the following signal is reserved. + -- I guess they are not supported by this version of GNU/Hurd. + (0 .. 0 => SIGVTALRM); + + type sigset_t is private; + + -- From /usr/include/signal.h /usr/include/i386-gnu/bits/sigset.h + function sigaddset (set : access sigset_t; sig : Signal) return int; + pragma Import (C, sigaddset, "sigaddset"); + + function sigdelset (set : access sigset_t; sig : Signal) return int; + pragma Import (C, sigdelset, "sigdelset"); + + function sigfillset (set : access sigset_t) return int; + pragma Import (C, sigfillset, "sigfillset"); + + function sigismember (set : access sigset_t; sig : Signal) return int; + pragma Import (C, sigismember, "sigismember"); + + function sigemptyset (set : access sigset_t) return int; + pragma Import (C, sigemptyset, "sigemptyset"); + + -- sigcontext is architecture dependent, so define it private + type struct_sigcontext is private; + + -- From /usr/include/i386-gnu/bits/sigaction.h: Note: arg. order differs + type struct_sigaction is record + sa_handler : System.Address; + sa_mask : sigset_t; + sa_flags : int; + end record; + pragma Convention (C, struct_sigaction); + + type struct_sigaction_ptr is access all struct_sigaction; + + -- From /usr/include/i386-gnu/bits/sigaction.h + SIG_BLOCK : constant := 1; + SIG_UNBLOCK : constant := 2; + SIG_SETMASK : constant := 3; + + -- From /usr/include/i386-gnu/bits/signum.h + SIG_ERR : constant := 1; + SIG_DFL : constant := 0; + SIG_IGN : constant := 1; + SIG_HOLD : constant := 2; + + -- From /usr/include/i386-gnu/bits/sigaction.h + SA_SIGINFO : constant := 16#0040#; + SA_ONSTACK : constant := 16#0001#; + + function sigaction + (sig : Signal; + act : struct_sigaction_ptr; + oact : struct_sigaction_ptr) return int; + pragma Import (C, sigaction, "sigaction"); + + ---------- + -- Time -- + ---------- + + Time_Slice_Supported : constant Boolean := True; + -- Indicates whether time slicing is supported (i.e SCHED_RR is supported) + + type timespec is private; + + function nanosleep (rqtp, rmtp : access timespec) return int; + pragma Import (C, nanosleep, "nanosleep"); + + type clockid_t is new int; + CLOCK_REALTIME : constant clockid_t := 0; + + -- From: /usr/include/time.h + function clock_gettime + (clock_id : clockid_t; + tp : access timespec) + return int; + pragma Import (C, clock_gettime, "clock_gettime"); + + function clock_getres + (clock_id : clockid_t; + res : access timespec) return int; + pragma Import (C, clock_getres, "clock_getres"); + + function To_Duration (TS : timespec) return Duration; + pragma Inline (To_Duration); + + function To_Timespec (D : Duration) return timespec; + pragma Inline (To_Timespec); + + -- From: /usr/include/unistd.h + function sysconf (name : int) return long; + pragma Import (C, sysconf); + + -- From /usr/include/i386-gnu/bits/confname.h + SC_CLK_TCK : constant := 2; + SC_NPROCESSORS_ONLN : constant := 84; + + ------------------------- + -- Priority Scheduling -- + ------------------------- + -- From /usr/include/i386-gnu/bits/sched.h + + SCHED_OTHER : constant := 0; + SCHED_FIFO : constant := 1; + SCHED_RR : constant := 2; + + function To_Target_Priority + (Prio : System.Any_Priority) return Interfaces.C.int; + -- Maps System.Any_Priority to a POSIX priority. + + ------------- + -- Process -- + ------------- + + type pid_t is private; + + -- From: /usr/include/signal.h + function kill (pid : pid_t; sig : Signal) return int; + pragma Import (C, kill, "kill"); + + -- From: /usr/include/unistd.h + function getpid return pid_t; + pragma Import (C, getpid, "getpid"); + + --------- + -- LWP -- + --------- + + -- From: /usr/include/pthread/pthread.h + function lwp_self return System.Address; + -- lwp_self does not exist on this thread library, revert to pthread_self + -- which is the closest approximation (with getpid). This function is + -- needed to share 7staprop.adb across POSIX-like targets. + pragma Import (C, lwp_self, "pthread_self"); + + ------------- + -- Threads -- + ------------- + + type Thread_Body is access + function (arg : System.Address) return System.Address; + pragma Convention (C, Thread_Body); + + function Thread_Body_Access is new + Unchecked_Conversion (System.Address, Thread_Body); + + -- From: /usr/include/bits/pthread.h:typedef int __pthread_t; + -- /usr/include/pthread/pthreadtypes.h:typedef __pthread_t pthread_t; + type pthread_t is new unsigned_long; + subtype Thread_Id is pthread_t; + + function To_pthread_t is new Unchecked_Conversion + (unsigned_long, pthread_t); + + type pthread_mutex_t is limited private; + type pthread_rwlock_t is limited private; + type pthread_cond_t is limited private; + type pthread_attr_t is limited private; + type pthread_mutexattr_t is limited private; + type pthread_rwlockattr_t is limited private; + type pthread_condattr_t is limited private; + type pthread_key_t is private; + + -- From /usr/include/pthread/pthreadtypes.h + PTHREAD_CREATE_DETACHED : constant := 1; + PTHREAD_CREATE_JOINABLE : constant := 0; + + PTHREAD_SCOPE_PROCESS : constant := 1; + PTHREAD_SCOPE_SYSTEM : constant := 0; + + ----------- + -- Stack -- + ----------- + + -- From: /usr/include/i386-gnu/bits/sigstack.h + type stack_t is record + ss_sp : System.Address; + ss_size : size_t; + ss_flags : int; + end record; + pragma Convention (C, stack_t); + + function sigaltstack + (ss : not null access stack_t; + oss : access stack_t) return int; + pragma Import (C, sigaltstack, "sigaltstack"); + + Alternate_Stack : aliased System.Address; + -- This is a dummy definition, never used (Alternate_Stack_Size is null) + + Alternate_Stack_Size : constant := 0; + -- No alternate signal stack is used on this platform + + Stack_Base_Available : constant Boolean := False; + -- Indicates whether the stack base is available on this target + + function Get_Stack_Base (thread : pthread_t) return Address; + pragma Inline (Get_Stack_Base); + -- returns the stack base of the specified thread. Only call this function + -- when Stack_Base_Available is True. + + -- From: /usr/include/unistd.h __getpagesize or getpagesize?? + function Get_Page_Size return int; + pragma Import (C, Get_Page_Size, "__getpagesize"); + -- Returns the size of a page + + -- From /usr/include/i386-gnu/bits/mman.h + PROT_NONE : constant := 0; + PROT_READ : constant := 4; + PROT_WRITE : constant := 2; + PROT_EXEC : constant := 1; + PROT_ALL : constant := PROT_READ + PROT_WRITE + PROT_EXEC; + PROT_ON : constant := PROT_NONE; + PROT_OFF : constant := PROT_ALL; + + -- From /usr/include/i386-gnu/bits/mman.h + function mprotect (addr : Address; len : size_t; prot : int) return int; + pragma Import (C, mprotect); + + --------------------------------------- + -- Nonstandard Thread Initialization -- + --------------------------------------- + + procedure pthread_init; + pragma Inline (pthread_init); + -- This is a dummy procedure to share some GNULLI files + + ------------------------- + -- POSIX.1c Section 3 -- + ------------------------- + + -- From: /usr/include/signal.h: + -- sigwait (__const sigset_t *__restrict __set, int *__restrict __sig) + function sigwait (set : access sigset_t; sig : access Signal) return int; + pragma Import (C, sigwait, "sigwait"); + + -- From: /usr/include/pthread/pthread.h: + -- extern int pthread_kill (pthread_t thread, int signo); + function pthread_kill (thread : pthread_t; sig : Signal) return int; + pragma Import (C, pthread_kill, "pthread_kill"); + + -- From: /usr/include/i386-gnu/bits/sigthread.h + -- extern int pthread_sigmask (int __how, __const __sigset_t *__newmask, + -- __sigset_t *__oldmask) __THROW; + function pthread_sigmask + (how : int; + set : access sigset_t; + oset : access sigset_t) return int; + pragma Import (C, pthread_sigmask, "pthread_sigmask"); + + -------------------------- + -- POSIX.1c Section 11 -- + -------------------------- + + -- From: /usr/include/pthread/pthread.h and + -- /usr/include/pthread/pthreadtypes.h + function pthread_mutexattr_init + (attr : access pthread_mutexattr_t) return int; + pragma Import (C, pthread_mutexattr_init, "pthread_mutexattr_init"); + + function pthread_mutexattr_destroy + (attr : access pthread_mutexattr_t) return int; + pragma Import (C, pthread_mutexattr_destroy, "pthread_mutexattr_destroy"); + + function pthread_mutex_init + (mutex : access pthread_mutex_t; + attr : access pthread_mutexattr_t) return int; + pragma Import (C, pthread_mutex_init, "pthread_mutex_init"); + + function pthread_mutex_destroy (mutex : access pthread_mutex_t) return int; + pragma Import (C, pthread_mutex_destroy, "pthread_mutex_destroy"); + + function pthread_mutex_lock (mutex : access pthread_mutex_t) return int; + pragma Import (C, pthread_mutex_lock, "pthread_mutex_lock"); + + function pthread_mutex_unlock (mutex : access pthread_mutex_t) return int; + pragma Import (C, pthread_mutex_unlock, "pthread_mutex_unlock"); + + function pthread_rwlockattr_init + (attr : access pthread_rwlockattr_t) return int; + pragma Import (C, pthread_rwlockattr_init, "pthread_rwlockattr_init"); + + function pthread_rwlockattr_destroy + (attr : access pthread_rwlockattr_t) return int; + pragma Import (C, pthread_rwlockattr_destroy, "pthread_rwlockattr_destroy"); + PTHREAD_RWLOCK_PREFER_READER_NP : constant := 0; + PTHREAD_RWLOCK_PREFER_WRITER_NP : constant := 1; + PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP : constant := 2; + + function pthread_rwlockattr_setkind_np + (attr : access pthread_rwlockattr_t; + pref : int) return int; + pragma Import + (C, pthread_rwlockattr_setkind_np, "pthread_rwlockattr_setkind_np"); + + function pthread_rwlock_init + (mutex : access pthread_rwlock_t; + attr : access pthread_rwlockattr_t) return int; + pragma Import (C, pthread_rwlock_init, "pthread_rwlock_init"); + + function pthread_rwlock_destroy + (mutex : access pthread_rwlock_t) return int; + pragma Import (C, pthread_rwlock_destroy, "pthread_rwlock_destroy"); + + function pthread_rwlock_rdlock (mutex : access pthread_rwlock_t) return int; + pragma Import (C, pthread_rwlock_rdlock, "pthread_rwlock_rdlock"); + + function pthread_rwlock_wrlock (mutex : access pthread_rwlock_t) return int; + pragma Import (C, pthread_rwlock_wrlock, "pthread_rwlock_wrlock"); + + function pthread_rwlock_unlock (mutex : access pthread_rwlock_t) return int; + pragma Import (C, pthread_rwlock_unlock, "pthread_rwlock_unlock"); + + function pthread_condattr_init + (attr : access pthread_condattr_t) return int; + pragma Import (C, pthread_condattr_init, "pthread_condattr_init"); + + function pthread_condattr_destroy + (attr : access pthread_condattr_t) return int; + pragma Import (C, pthread_condattr_destroy, "pthread_condattr_destroy"); + + function pthread_cond_init + (cond : access pthread_cond_t; + attr : access pthread_condattr_t) return int; + pragma Import (C, pthread_cond_init, "pthread_cond_init"); + + function pthread_cond_destroy (cond : access pthread_cond_t) return int; + pragma Import (C, pthread_cond_destroy, "pthread_cond_destroy"); + + function pthread_cond_signal (cond : access pthread_cond_t) return int; + pragma Import (C, pthread_cond_signal, "pthread_cond_signal"); + + function pthread_cond_wait + (cond : access pthread_cond_t; + mutex : access pthread_mutex_t) return int; + pragma Import (C, pthread_cond_wait, "pthread_cond_wait"); + + function pthread_cond_timedwait + (cond : access pthread_cond_t; + mutex : access pthread_mutex_t; + abstime : access timespec) return int; + pragma Import (C, pthread_cond_timedwait, "pthread_cond_timedwait"); + + Relative_Timed_Wait : constant Boolean := False; + -- pthread_cond_timedwait requires an absolute delay time + + -------------------------- + -- POSIX.1c Section 13 -- + -------------------------- + -- From /usr/include/pthread/pthreadtypes.h + + PTHREAD_PRIO_NONE : constant := 0; + PTHREAD_PRIO_PROTECT : constant := 2; + PTHREAD_PRIO_INHERIT : constant := 1; + + -- From: /usr/include/pthread/pthread.h + function pthread_mutexattr_setprotocol + (attr : access pthread_mutexattr_t; + protocol : int) return int; + pragma Import (C, pthread_mutexattr_setprotocol, + "pthread_mutexattr_setprotocol"); + + function pthread_mutexattr_getprotocol + (attr : access pthread_mutexattr_t; + protocol : access int) return int; + pragma Import (C, pthread_mutexattr_getprotocol, + "pthread_mutexattr_getprotocol"); + + function pthread_mutexattr_setprioceiling + (attr : access pthread_mutexattr_t; + prioceiling : int) return int; + pragma Import (C, pthread_mutexattr_setprioceiling, + "pthread_mutexattr_setprioceiling"); + + function pthread_mutexattr_getprioceiling + (attr : access pthread_mutexattr_t; + prioceiling : access int) return int; + pragma Import (C, pthread_mutexattr_getprioceiling, + "pthread_mutexattr_getprioceiling"); + + type struct_sched_param is record + sched_priority : int; -- scheduling priority + end record; + pragma Convention (C, struct_sched_param); + + function pthread_setschedparam + (thread : pthread_t; + policy : int; + param : access struct_sched_param) return int; + pragma Import (C, pthread_setschedparam, "pthread_setschedparam"); + + function pthread_attr_setscope + (attr : access pthread_attr_t; + contentionscope : int) return int; + pragma Import (C, pthread_attr_setscope, "pthread_attr_setscope"); + + function pthread_attr_getscope + (attr : access pthread_attr_t; + contentionscope : access int) return int; + pragma Import (C, pthread_attr_getscope, "pthread_attr_getscope"); + + function pthread_attr_setinheritsched + (attr : access pthread_attr_t; + inheritsched : int) return int; + pragma Import (C, pthread_attr_setinheritsched, + "pthread_attr_setinheritsched"); + + function pthread_attr_getinheritsched + (attr : access pthread_attr_t; + inheritsched : access int) return int; + pragma Import (C, pthread_attr_getinheritsched, + "pthread_attr_getinheritsched"); + + function pthread_attr_setschedpolicy + (attr : access pthread_attr_t; + policy : int) return int; + pragma Import (C, pthread_attr_setschedpolicy, "pthread_setschedpolicy"); + + function sched_yield return int; + pragma Import (C, sched_yield, "sched_yield"); + + --------------------------- + -- P1003.1c - Section 16 -- + --------------------------- + + function pthread_attr_init + (attributes : access pthread_attr_t) return int; + pragma Import (C, pthread_attr_init, "pthread_attr_init"); + + function pthread_attr_destroy + (attributes : access pthread_attr_t) return int; + pragma Import (C, pthread_attr_destroy, "pthread_attr_destroy"); + + function pthread_attr_setdetachstate + (attr : access pthread_attr_t; + detachstate : int) return int; + pragma Import + (C, pthread_attr_setdetachstate, "pthread_attr_setdetachstate"); + + function pthread_attr_setstacksize + (attr : access pthread_attr_t; + stacksize : size_t) return int; + pragma Import (C, pthread_attr_setstacksize, "pthread_attr_setstacksize"); + + -- From: /usr/include/pthread/pthread.h + function pthread_create + (thread : access pthread_t; + attributes : access pthread_attr_t; + start_routine : Thread_Body; + arg : System.Address) return int; + pragma Import (C, pthread_create, "pthread_create"); + + procedure pthread_exit (status : System.Address); + pragma Import (C, pthread_exit, "pthread_exit"); + + function pthread_self return pthread_t; + pragma Import (C, pthread_self, "pthread_self"); + + -------------------------- + -- POSIX.1c Section 17 -- + -------------------------- + + function pthread_setspecific + (key : pthread_key_t; + value : System.Address) return int; + pragma Import (C, pthread_setspecific, "pthread_setspecific"); + + function pthread_getspecific (key : pthread_key_t) return System.Address; + pragma Import (C, pthread_getspecific, "pthread_getspecific"); + + type destructor_pointer is access procedure (arg : System.Address); + pragma Convention (C, destructor_pointer); + + function pthread_key_create + (key : access pthread_key_t; + destructor : destructor_pointer) return int; + pragma Import (C, pthread_key_create, "pthread_key_create"); + + -- From /usr/include/i386-gnu/bits/sched.h + CPU_SETSIZE : constant := 1_024; + + type bit_field is array (1 .. CPU_SETSIZE) of Boolean; + for bit_field'Size use CPU_SETSIZE; + pragma Pack (bit_field); + pragma Convention (C, bit_field); + + type cpu_set_t is record + bits : bit_field; + end record; + pragma Convention (C, cpu_set_t); + +private + + type sigset_t is array (1 .. 4) of unsigned; + + -- In GNU/Hurd the component sa_handler turns out to + -- be one a union type, and the selector is a macro: + -- #define sa_handler __sigaction_handler.sa_handler + -- #define sa_sigaction __sigaction_handler.sa_sigaction + + -- Should we add a signal_context type here ? + -- How could it be done independent of the CPU architecture ? + -- sigcontext type is opaque, so it is architecturally neutral. + -- It is always passed as an access type, so define it as an empty record + -- since the contents are not used anywhere. + type struct_sigcontext is null record; + pragma Convention (C, struct_sigcontext); + + type pid_t is new int; + + type time_t is new long; + + type timespec is record + tv_sec : time_t; + tv_nsec : long; + end record; + pragma Convention (C, timespec); + + -- From: /usr/include/pthread/pthreadtypes.h: + -- typedef struct __pthread_attr pthread_attr_t; + -- /usr/include/i386-gnu/bits/thread-attr.h: struct __pthread_attr... + -- /usr/include/pthread/pthreadtypes.h: enum __pthread_contentionscope + -- enum __pthread_detachstate detachstate; + -- enum __pthread_inheritsched inheritsched; + -- enum __pthread_contentionscope contentionscope; + -- Not used: schedpolicy : int; + type pthread_attr_t is record + schedparam : struct_sched_param; + stackaddr : System.Address; + stacksize : size_t; + guardsize : size_t; + detachstate : int; + inheritsched : int; + contentionscope : int; + schedpolicy : int; + end record; + pragma Convention (C, pthread_attr_t); + + -- From: /usr/include/pthread/pthreadtypes.h: + -- typedef struct __pthread_condattr pthread_condattr_t; + -- From: /usr/include/i386-gnu/bits/condition-attr.h: + -- struct __pthread_condattr { + -- enum __pthread_process_shared pshared; + -- __Clockid_T Clock;} + -- From: /usr/include/pthread/pthreadtypes.h: + -- enum __pthread_process_shared + type pthread_condattr_t is record + pshared : int; + clock : clockid_t; + end record; + pragma Convention (C, pthread_condattr_t); + + -- From: /usr/include/pthread/pthreadtypes.h: + -- typedef struct __pthread_mutexattr pthread_mutexattr_t; and + -- /usr/include/i386-gnu/bits/mutex-attr.h + -- struct __pthread_mutexattr { + -- int prioceiling; + -- enum __pthread_mutex_protocol protocol; + -- enum __pthread_process_shared pshared; + -- enum __pthread_mutex_type mutex_type;}; + type pthread_mutexattr_t is record + prioceiling : int; + protocol : int; + pshared : int; + mutex_type : int; + end record; + pragma Convention (C, pthread_mutexattr_t); + + -- From: /usr/include/pthread/pthreadtypes.h + -- typedef struct __pthread_mutex pthread_mutex_t; and + -- /usr/include/i386-gnu/bits/mutex.h: + -- struct __pthread_mutex { + -- __pthread_spinlock_t __held; + -- __pthread_spinlock_t __lock; + -- /* in cthreads, mutex_init does not initialized the third + -- pointer, as such, we cannot rely on its value for anything. */ + -- char *cthreadscompat1; + -- struct __pthread *__queue; + -- struct __pthread_mutexattr *attr; + -- void *data; + -- /* up to this point, we are completely compatible with cthreads + -- and what libc expects. */ + -- void *owner; + -- unsigned locks; + -- /* if null then the default attributes apply. */ + -- }; + + type pthread_mutex_t is record + held : int; + lock : int; + cthreadcompat : System.Address; + queue : System.Address; + attr : System.Address; + data : System.Address; + owner : System.Address; + locks : unsigned; + end record; + pragma Convention (C, pthread_mutex_t); + -- pointer needed? + -- type pthread_mutex_t_ptr is access pthread_mutex_t; + + -- From: /usr/include/pthread/pthreadtypes.h: + -- typedef struct __pthread_cond pthread_cond_t; + -- typedef struct __pthread_condattr pthread_condattr_t; + -- /usr/include/i386-gnu/bits/condition.h:struct __pthread_cond{} + -- pthread_condattr_t: see above! + -- /usr/include/i386-gnu/bits/condition.h: + -- struct __pthread_condimpl *__impl; + + type pthread_cond_t is record + lock : int; + queue : System.Address; + condattr : System.Address; + impl : System.Address; + data : System.Address; + end record; + pragma Convention (C, pthread_cond_t); + + -- From: /usr/include/pthread/pthreadtypes.h: + -- typedef __pthread_key pthread_key_t; and + -- /usr/include/i386-gnu/bits/thread-specific.h: + -- typedef int __pthread_key; + + type pthread_key_t is new int; + + -- From: /usr/include/i386-gnu/bits/rwlock-attr.h: + -- struct __pthread_rwlockattr { + -- enum __pthread_process_shared pshared; }; + + type pthread_rwlockattr_t is record + pshared : int; + end record; + pragma Convention (C, pthread_rwlockattr_t); + + -- From: /usr/include/i386-gnu/bits/rwlock.h: + -- struct __pthread_rwlock { + -- __pthread_spinlock_t __held; + -- __pthread_spinlock_t __lock; + -- int readers; + -- struct __pthread *readerqueue; + -- struct __pthread *writerqueue; + -- struct __pthread_rwlockattr *__attr; + -- void *__data; }; + + type pthread_rwlock_t is record + held : int; + lock : int; + readers : int; + readerqueue : System.Address; + writerqueue : System.Address; + attr : pthread_rwlockattr_t; + data : int; + end record; + pragma Convention (C, pthread_rwlock_t); + +end System.OS_Interface; diff --git a/gcc/ada/system-linux-s390.ads b/gcc/ada/system-linux-s390.ads index 6c59f6402d5a..b81b2b28dc3c 100644 --- a/gcc/ada/system-linux-s390.ads +++ b/gcc/ada/system-linux-s390.ads @@ -132,7 +132,7 @@ private Preallocated_Stacks : constant Boolean := False; Signed_Zeros : constant Boolean := True; Stack_Check_Default : constant Boolean := False; - Stack_Check_Probes : constant Boolean := False; + Stack_Check_Probes : constant Boolean := True; Stack_Check_Limits : constant Boolean := False; Support_Aggregates : constant Boolean := True; Support_Composite_Assign : constant Boolean := True; diff --git a/gcc/ada/system-linux-s390x.ads b/gcc/ada/system-linux-s390x.ads index 90e1d1cb1e56..db0e3c0f33b6 100644 --- a/gcc/ada/system-linux-s390x.ads +++ b/gcc/ada/system-linux-s390x.ads @@ -132,7 +132,7 @@ private Preallocated_Stacks : constant Boolean := False; Signed_Zeros : constant Boolean := True; Stack_Check_Default : constant Boolean := False; - Stack_Check_Probes : constant Boolean := False; + Stack_Check_Probes : constant Boolean := True; Stack_Check_Limits : constant Boolean := False; Support_Aggregates : constant Boolean := True; Support_Composite_Assign : constant Boolean := True; diff --git a/gcc/ada/system-vxworks-m68k.ads b/gcc/ada/system-vxworks-m68k.ads index d8fa9ba94f40..ca59e7a9d9ba 100644 --- a/gcc/ada/system-vxworks-m68k.ads +++ b/gcc/ada/system-vxworks-m68k.ads @@ -7,7 +7,7 @@ -- S p e c -- -- (VxWorks version M68K) -- -- -- --- Copyright (C) 1992-2015, Free Software Foundation, Inc. -- +-- Copyright (C) 1992-2016, Free Software Foundation, Inc. -- -- -- -- This specification is derived from the Ada Reference Manual for use with -- -- GNAT. The copyright notice above, and the license provisions that follow -- @@ -145,8 +145,8 @@ private Preallocated_Stacks : constant Boolean := False; Signed_Zeros : constant Boolean := False; Stack_Check_Default : constant Boolean := False; - Stack_Check_Probes : constant Boolean := False; - Stack_Check_Limits : constant Boolean := True; + Stack_Check_Probes : constant Boolean := True; + Stack_Check_Limits : constant Boolean := False; Support_Aggregates : constant Boolean := True; Support_Composite_Assign : constant Boolean := True; Support_Composite_Compare : constant Boolean := True; diff --git a/gcc/ada/system-vxworks-mips.ads b/gcc/ada/system-vxworks-mips.ads index 2284ebbd9042..d4860f42daf4 100644 --- a/gcc/ada/system-vxworks-mips.ads +++ b/gcc/ada/system-vxworks-mips.ads @@ -7,7 +7,7 @@ -- S p e c -- -- (VxWorks Version Mips) -- -- -- --- Copyright (C) 1992-2015, Free Software Foundation, Inc. -- +-- Copyright (C) 1992-2016, Free Software Foundation, Inc. -- -- -- -- This specification is derived from the Ada Reference Manual for use with -- -- GNAT. The copyright notice above, and the license provisions that follow -- @@ -145,8 +145,8 @@ private Preallocated_Stacks : constant Boolean := False; Signed_Zeros : constant Boolean := True; Stack_Check_Default : constant Boolean := False; - Stack_Check_Probes : constant Boolean := False; - Stack_Check_Limits : constant Boolean := True; + Stack_Check_Probes : constant Boolean := True; + Stack_Check_Limits : constant Boolean := False; Support_Aggregates : constant Boolean := True; Support_Composite_Assign : constant Boolean := True; Support_Composite_Compare : constant Boolean := True; diff --git a/gcc/ada/system-vxworks-ppc.ads b/gcc/ada/system-vxworks-ppc.ads index f942470f152d..bb27ee4b9933 100644 --- a/gcc/ada/system-vxworks-ppc.ads +++ b/gcc/ada/system-vxworks-ppc.ads @@ -7,7 +7,7 @@ -- S p e c -- -- (VxWorks 5 Version PPC) -- -- -- --- Copyright (C) 1992-2015, Free Software Foundation, Inc. -- +-- Copyright (C) 1992-2016, Free Software Foundation, Inc. -- -- -- -- This specification is derived from the Ada Reference Manual for use with -- -- GNAT. The copyright notice above, and the license provisions that follow -- @@ -152,8 +152,8 @@ private Preallocated_Stacks : constant Boolean := False; Signed_Zeros : constant Boolean := True; Stack_Check_Default : constant Boolean := False; - Stack_Check_Probes : constant Boolean := False; - Stack_Check_Limits : constant Boolean := True; + Stack_Check_Probes : constant Boolean := True; + Stack_Check_Limits : constant Boolean := False; Support_Aggregates : constant Boolean := True; Support_Composite_Assign : constant Boolean := True; Support_Composite_Compare : constant Boolean := True; diff --git a/gcc/ada/system-vxworks-sparcv9.ads b/gcc/ada/system-vxworks-sparcv9.ads index 5c07b05c085a..f3caca4fea93 100644 --- a/gcc/ada/system-vxworks-sparcv9.ads +++ b/gcc/ada/system-vxworks-sparcv9.ads @@ -7,7 +7,7 @@ -- S p e c -- -- (VxWorks Version Sparc/64) -- -- -- --- Copyright (C) 1992-2015, Free Software Foundation, Inc. -- +-- Copyright (C) 1992-2016, Free Software Foundation, Inc. -- -- -- -- This specification is derived from the Ada Reference Manual for use with -- -- GNAT. The copyright notice above, and the license provisions that follow -- @@ -147,8 +147,8 @@ private Preallocated_Stacks : constant Boolean := False; Signed_Zeros : constant Boolean := True; Stack_Check_Default : constant Boolean := False; - Stack_Check_Probes : constant Boolean := False; - Stack_Check_Limits : constant Boolean := True; + Stack_Check_Probes : constant Boolean := True; + Stack_Check_Limits : constant Boolean := False; Support_Aggregates : constant Boolean := True; Support_Composite_Assign : constant Boolean := True; Support_Composite_Compare : constant Boolean := True; diff --git a/gcc/ada/system-vxworks-x86.ads b/gcc/ada/system-vxworks-x86.ads index adc73a690701..a7508aadfa36 100644 --- a/gcc/ada/system-vxworks-x86.ads +++ b/gcc/ada/system-vxworks-x86.ads @@ -7,7 +7,7 @@ -- S p e c -- -- (VxWorks 5 Version x86) -- -- -- --- Copyright (C) 1992-2015, Free Software Foundation, Inc. -- +-- Copyright (C) 1992-2016, Free Software Foundation, Inc. -- -- -- -- This specification is derived from the Ada Reference Manual for use with -- -- GNAT. The copyright notice above, and the license provisions that follow -- @@ -148,8 +148,8 @@ private Preallocated_Stacks : constant Boolean := False; Signed_Zeros : constant Boolean := True; Stack_Check_Default : constant Boolean := False; - Stack_Check_Probes : constant Boolean := False; - Stack_Check_Limits : constant Boolean := True; + Stack_Check_Probes : constant Boolean := True; + Stack_Check_Limits : constant Boolean := False; Support_Aggregates : constant Boolean := True; Support_Atomic_Primitives : constant Boolean := True; Support_Composite_Assign : constant Boolean := True; diff --git a/gcc/bitmap.c b/gcc/bitmap.c index ac20ae5830f4..0c05512b6669 100644 --- a/gcc/bitmap.c +++ b/gcc/bitmap.c @@ -662,6 +662,26 @@ bitmap_popcount (BITMAP_WORD a) return ret; } #endif + +/* Count and return the number of bits set in the bitmap word BITS. */ +static unsigned long +bitmap_count_bits_in_word (const BITMAP_WORD *bits) +{ + unsigned long count = 0; + + for (unsigned ix = 0; ix != BITMAP_ELEMENT_WORDS; ix++) + { +#if GCC_VERSION >= 3400 + /* Note that popcountl matches BITMAP_WORD in type, so the actual size + of BITMAP_WORD is not material. */ + count += __builtin_popcountl (bits[ix]); +#else + count += bitmap_popcount (bits[ix]); +#endif + } + return count; +} + /* Count the number of bits set in the bitmap, and return it. */ unsigned long @@ -669,19 +689,44 @@ bitmap_count_bits (const_bitmap a) { unsigned long count = 0; const bitmap_element *elt; - unsigned ix; for (elt = a->first; elt; elt = elt->next) + count += bitmap_count_bits_in_word (elt->bits); + + return count; +} + +/* Count the number of unique bits set in A and B and return it. */ + +unsigned long +bitmap_count_unique_bits (const_bitmap a, const_bitmap b) +{ + unsigned long count = 0; + const bitmap_element *elt_a, *elt_b; + + for (elt_a = a->first, elt_b = b->first; elt_a && elt_b; ) { - for (ix = 0; ix != BITMAP_ELEMENT_WORDS; ix++) + /* If we're at different indices, then count all the bits + in the lower element. If we're at the same index, then + count the bits in the IOR of the two elements. */ + if (elt_a->indx < elt_b->indx) { -#if GCC_VERSION >= 3400 - /* Note that popcountl matches BITMAP_WORD in type, so the actual size - of BITMAP_WORD is not material. */ - count += __builtin_popcountl (elt->bits[ix]); -#else - count += bitmap_popcount (elt->bits[ix]); -#endif + count += bitmap_count_bits_in_word (elt_a->bits); + elt_a = elt_a->next; + } + else if (elt_b->indx < elt_a->indx) + { + count += bitmap_count_bits_in_word (elt_b->bits); + elt_b = elt_b->next; + } + else + { + BITMAP_WORD bits[BITMAP_ELEMENT_WORDS]; + for (unsigned ix = 0; ix != BITMAP_ELEMENT_WORDS; ix++) + bits[ix] = elt_a->bits[ix] | elt_b->bits[ix]; + count += bitmap_count_bits_in_word (bits); + elt_a = elt_a->next; + elt_b = elt_b->next; } } return count; diff --git a/gcc/bitmap.h b/gcc/bitmap.h index 805e37eb47bb..111571186b76 100644 --- a/gcc/bitmap.h +++ b/gcc/bitmap.h @@ -280,6 +280,9 @@ extern bool bitmap_single_bit_set_p (const_bitmap); /* Count the number of bits set in the bitmap. */ extern unsigned long bitmap_count_bits (const_bitmap); +/* Count the number of unique bits set across the two bitmaps. */ +extern unsigned long bitmap_count_unique_bits (const_bitmap, const_bitmap); + /* Boolean operations on bitmaps. The _into variants are two operand versions that modify the first source operand. The other variants are three operand versions that to not destroy the source bitmaps. diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog index 66d74f402abc..c1188d7e5c0c 100644 --- a/gcc/c-family/ChangeLog +++ b/gcc/c-family/ChangeLog @@ -1,3 +1,74 @@ +2016-03-23 Marek Polacek + + PR c++/69884 + * c.opt (Wignored-attributes): New option. + +2016-03-22 David Malcolm + + PR c/69993 + * c-indentation.c (warn_for_misleading_indentation): Rewrite the + diagnostic text, reversing the order of the warning and note so + that they appear in source order. + +2016-03-17 Marek Polacek + + PR c/69407 + * c-common.c (resolve_overloaded_builtin): Set TREE_USED for the fetch + operations. + +2016-03-14 Jason Merrill + + * c-cppbuiltin.c (c_cpp_builtins): Set __cpp_hex_float. + + * c-cppbuiltin.c (c_cpp_builtins): Bump __cpp_range_based_for. + +2016-03-09 Richard Biener + + PR c/70143 + * c-common.c (strict_aliasing_warning): Add back + alias_sets_conflict_p check. + +2016-03-08 Jason Merrill + + * c-opts.c (set_std_cxx1z): Don't enable concepts. + +2016-03-04 David Malcolm + + PR c/68187 + * c-indentation.c (get_visual_column): Move code to determine next + tab stop to... + (next_tab_stop): ...this new function. + (line_contains_hash_if): Delete function. + (detect_preprocessor_logic): Delete function. + (get_first_nws_vis_column): New function. + (detect_intervening_unindent): New function. + (should_warn_for_misleading_indentation): Replace call to + detect_preprocessor_logic with a call to + detect_intervening_unindent. + +2016-03-04 David Malcolm + + PR c/68187 + * c-indentation.c (should_warn_for_misleading_indentation): When + suppressing warnings about cases where the guard and body are on + the same column, only use the first non-whitespace column in place + of the guard token column when dealing with "else" clauses. + When rejecting aligned BODY and NEXT, loosen the requirement + from equality with the first non-whitespace of guard to simply + that they not be indented relative to it. + +2016-03-04 Richard Biener + + PR c++/70054 + * c-common.c (strict_aliasing_warning): Use alias_set_subset_of + instead of alias_sets_conflict_p. + +2016-03-01 Marek Polacek + + PR c++/69795 + * c-common.c (reject_gcc_builtin): Check for FUNCTION_DECL rather than + any DECL. + 2016-02-22 Martin Sebor PR middle-end/69780 diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c index 71da6e9b4724..30c815d5381c 100644 --- a/gcc/c-family/c-common.c +++ b/gcc/c-family/c-common.c @@ -1568,7 +1568,9 @@ strict_aliasing_warning (tree otype, tree type, tree expr) alias_set_type set2 = get_alias_set (TREE_TYPE (type)); if (set1 != set2 && set2 != 0 - && (set1 == 0 || !alias_sets_conflict_p (set1, set2))) + && (set1 == 0 + || (!alias_set_subset_of (set2, set1) + && !alias_sets_conflict_p (set1, set2)))) { warning (OPT_Wstrict_aliasing, "dereferencing type-punned " "pointer will break strict-aliasing rules"); @@ -11443,6 +11445,10 @@ resolve_overloaded_builtin (location_t loc, tree function, && orig_code != BUILT_IN_ATOMIC_STORE_N) result = sync_resolve_return (first_param, result, orig_format); + if (fetch_op) + /* Prevent -Wunused-value warning. */ + TREE_USED (result) = true; + /* If new_return is set, assign function to that expr and cast the result to void since the generic interface returned void. */ if (new_return) @@ -12638,7 +12644,7 @@ reject_gcc_builtin (const_tree expr, location_t loc /* = UNKNOWN_LOCATION */) if (TREE_TYPE (expr) && TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE - && DECL_P (expr) + && TREE_CODE (expr) == FUNCTION_DECL /* The intersection of DECL_BUILT_IN and DECL_IS_BUILTIN avoids false positives for user-declared built-ins such as abs or strlen, and for C++ operators new and delete. diff --git a/gcc/c-family/c-cppbuiltin.c b/gcc/c-family/c-cppbuiltin.c index 19999c7ef1d8..ee953ca44c82 100644 --- a/gcc/c-family/c-cppbuiltin.c +++ b/gcc/c-family/c-cppbuiltin.c @@ -818,6 +818,10 @@ c_cpp_builtins (cpp_reader *pfile) if (!pedantic || cxx_dialect > cxx11) cpp_define (pfile, "__cpp_binary_literals=201304"); + /* Similarly for hexadecimal floating point literals and C++17. */ + if (!pedantic || cpp_get_options (parse_in)->extended_numbers) + cpp_define (pfile, "__cpp_hex_float=201603"); + /* Arrays of runtime bound were removed from C++14, but we still support GNU VLAs. Let's define this macro to a low number (corresponding to the initial test release of GNU C++) if we won't @@ -871,7 +875,7 @@ c_cpp_builtins (cpp_reader *pfile) cpp_define (pfile, "__cpp_namespace_attributes=201411"); cpp_define (pfile, "__cpp_enumerator_attributes=201411"); cpp_define (pfile, "__cpp_nested_namespace_definitions=201411"); - cpp_define (pfile, "__cpp_fold_expressions=201411"); + cpp_define (pfile, "__cpp_fold_expressions=201603"); cpp_define (pfile, "__cpp_nontype_template_args=201411"); } if (flag_concepts) diff --git a/gcc/c-family/c-indentation.c b/gcc/c-family/c-indentation.c index 521f9924fd0b..1da3f6824c1f 100644 --- a/gcc/c-family/c-indentation.c +++ b/gcc/c-family/c-indentation.c @@ -26,6 +26,16 @@ along with GCC; see the file COPYING3. If not see extern cpp_options *cpp_opts; +/* Round up VIS_COLUMN to nearest tab stop. */ + +static unsigned int +next_tab_stop (unsigned int vis_column) +{ + const unsigned int tab_width = cpp_opts->tabstop; + vis_column = ((vis_column + tab_width) / tab_width) * tab_width; + return vis_column; +} + /* Convert libcpp's notion of a column (a 1-based char count) to the "visual column" (0-based column, respecting tabs), by reading the relevant line. @@ -77,11 +87,7 @@ get_visual_column (expanded_location exploc, location_t loc, } if (ch == '\t') - { - /* Round up to nearest tab stop. */ - const unsigned int tab_width = cpp_opts->tabstop; - vis_column = ((vis_column + tab_width) / tab_width) * tab_width; - } + vis_column = next_tab_stop (vis_column); else vis_column++; } @@ -93,54 +99,49 @@ get_visual_column (expanded_location exploc, location_t loc, return true; } -/* Does the given source line appear to contain a #if directive? - (or #ifdef/#ifndef). Ignore the possibility of it being inside a - comment, for simplicity. - Helper function for detect_preprocessor_logic. */ +/* Attempt to determine the first non-whitespace character in line LINE_NUM + of source line FILE. + + If this is possible, return true and write its "visual column" to + *FIRST_NWS. + Otherwise, return false, leaving *FIRST_NWS untouched. */ static bool -line_contains_hash_if (const char *file, int line_num) +get_first_nws_vis_column (const char *file, int line_num, + unsigned int *first_nws) { + gcc_assert (first_nws); + int line_len; const char *line = location_get_source_line (file, line_num, &line_len); if (!line) return false; + unsigned int vis_column = 0; + for (int i = 1; i < line_len; i++) + { + unsigned char ch = line[i - 1]; - int idx; - - /* Skip leading whitespace. */ - for (idx = 0; idx < line_len; idx++) - if (!ISSPACE (line[idx])) - break; - if (idx == line_len) - return false; - - /* Require a '#' character. */ - if (line[idx] != '#') - return false; - idx++; + if (!ISSPACE (ch)) + { + *first_nws = vis_column; + return true; + } - /* Skip whitespace. */ - while (idx < line_len) - { - if (!ISSPACE (line[idx])) - break; - idx++; + if (ch == '\t') + vis_column = next_tab_stop (vis_column); + else + vis_column++; } - /* Match #if/#ifdef/#ifndef. */ - if (idx + 2 <= line_len) - if (line[idx] == 'i') - if (line[idx + 1] == 'f') - return true; - + /* No non-whitespace characters found. */ return false; } - -/* Determine if there is preprocessor logic between +/* Determine if there is an unindent/outdent between BODY_EXPLOC and NEXT_STMT_EXPLOC, to ensure that we don't - issue a warning for cases like this: + issue a warning for cases like the following: + + (1) Preprocessor logic if (flagA) foo (); @@ -151,31 +152,47 @@ line_contains_hash_if (const char *file, int line_num) bar (); ^ NEXT_STMT_EXPLOC - despite "bar ();" being visually aligned below "foo ();" and - being (as far as the parser sees) the next token. + "bar ();" is visually aligned below "foo ();" and + is (as far as the parser sees) the next token, but + this isn't misleading to a human reader. - Return true if such logic is detected. */ + (2) Empty macro with bad indentation -static bool -detect_preprocessor_logic (expanded_location body_exploc, - expanded_location next_stmt_exploc) -{ - gcc_assert (next_stmt_exploc.file == body_exploc.file); - gcc_assert (next_stmt_exploc.line > body_exploc.line); + In the following, the + "if (i > 0)" + is poorly indented, and ought to be on the same column as + "engine_ref_debug(e, 0, -1)" + However, it is not misleadingly indented, due to the presence + of that macro. - if (next_stmt_exploc.line - body_exploc.line < 4) - return false; + #define engine_ref_debug(X, Y, Z) + + if (locked) + i = foo (0); + else + i = foo (1); + engine_ref_debug(e, 0, -1) + if (i > 0) + return 1; - /* Is there a #if/#ifdef/#ifndef directive somewhere in the lines - between the given locations? + Return true if such an unindent/outdent is detected. */ - This is something of a layering violation, but by necessity, - given the nature of what we're testing for. For example, - in theory we could be fooled by a #if within a comment, but - it's unlikely to matter. */ - for (int line = body_exploc.line + 1; line < next_stmt_exploc.line; line++) - if (line_contains_hash_if (body_exploc.file, line)) - return true; +static bool +detect_intervening_unindent (const char *file, + int body_line, + int next_stmt_line, + unsigned int vis_column) +{ + gcc_assert (file); + gcc_assert (next_stmt_line > body_line); + + 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)) + if (line_vis_column < vis_column) + return true; + } /* Not found. */ return false; @@ -419,7 +436,8 @@ should_warn_for_misleading_indentation (const token_indent_info &guard_tinfo, { /* Don't warn if they are aligned on the same column as the guard itself (suggesting autogenerated code that doesn't - bother indenting at all). We consider the column of the first + bother indenting at all). + For "else" clauses, we consider the column of the first non-whitespace character on the guard line instead of the column of the actual guard token itself because it is more sensible. Consider: @@ -438,14 +456,17 @@ should_warn_for_misleading_indentation (const token_indent_info &guard_tinfo, foo (2); // BODY foo (3); // NEXT - If we just used the column of the guard token, we would warn on + If we just used the column of the "else" token, we would warn on the first example and not warn on the second. But we want the exact opposite to happen: to not warn on the first example (which is probably autogenerated) and to warn on the second (whose indentation is misleading). Using the column of the first non-whitespace character on the guard line makes that happen. */ - if (guard_line_first_nws == body_vis_column) + unsigned int guard_column = (guard_tinfo.keyword == RID_ELSE + ? guard_line_first_nws + : guard_vis_column); + if (guard_column == body_vis_column) return false; /* We may have something like: @@ -458,14 +479,16 @@ should_warn_for_misleading_indentation (const token_indent_info &guard_tinfo, foo (3); // NEXT in which case the columns are not aligned but the code is not - misleadingly indented. If the column of the body is less than - that of the guard line then don't warn. */ - if (body_vis_column < guard_line_first_nws) + misleadingly indented. If the column of the body isn't indented + more than the guard line then don't warn. */ + if (body_vis_column <= guard_line_first_nws) return false; - /* Don't warn if there is multiline preprocessor logic between - the two statements. */ - if (detect_preprocessor_logic (body_exploc, next_stmt_exploc)) + /* 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, + next_stmt_exploc.line, + vis_column)) return false; /* Otherwise, they are visually aligned: issue a warning. */ @@ -579,10 +602,12 @@ warn_for_misleading_indentation (const token_indent_info &guard_tinfo, body_tinfo, next_tinfo)) { - if (warning_at (next_tinfo.location, OPT_Wmisleading_indentation, - "statement is indented as if it were guarded by...")) - inform (guard_tinfo.location, - "...this %qs clause, but it is not", + if (warning_at (guard_tinfo.location, OPT_Wmisleading_indentation, + "this %qs clause does not guard...", + guard_tinfo_to_string (guard_tinfo))) + inform (next_tinfo.location, + ("...this statement, but the latter is misleadingly indented" + " as if it is guarded by the %qs"), guard_tinfo_to_string (guard_tinfo)); } } diff --git a/gcc/c-family/c-opts.c b/gcc/c-family/c-opts.c index c2783f7e5603..fec58bcf91f4 100644 --- a/gcc/c-family/c-opts.c +++ b/gcc/c-family/c-opts.c @@ -1566,8 +1566,6 @@ set_std_cxx1z (int iso) /* C++11 includes the C99 standard library. */ flag_isoc94 = 1; flag_isoc99 = 1; - /* Enable concepts by default. */ - flag_concepts = 1; flag_isoc11 = 1; cxx_dialect = cxx1z; lang_hooks.name = "GNU C++14"; /* Pretend C++14 till standarization. */ diff --git a/gcc/c-family/c.opt b/gcc/c-family/c.opt index 7c5f6c7b5ccb..4f86876c533d 100644 --- a/gcc/c-family/c.opt +++ b/gcc/c-family/c.opt @@ -482,6 +482,10 @@ Wignored-qualifiers C C++ Var(warn_ignored_qualifiers) Warning EnabledBy(Wextra) Warn whenever type qualifiers are ignored. +Wignored-attributes +C C++ Var(warn_ignored_attributes) Init(1) Warning +Warn whenever attributes are ignored. + Wincompatible-pointer-types C ObjC Var(warn_incompatible_pointer_types) Init(1) Warning Warn when there is a conversion between pointers that have incompatible types. diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog index f814833538b7..c8cb0227e2a3 100644 --- a/gcc/c/ChangeLog +++ b/gcc/c/ChangeLog @@ -1,3 +1,47 @@ +2016-03-18 David Malcolm + + PR c/70281 + * c-parser.c (c_parser_postfix_expression): Set the source range + for uses of "__builtin_types_compatible_p". + +2016-03-17 Jakub Jelinek + + PR c/70280 + * c-typeck.c (composite_type): Don't count void_list_node + into len, if the list is terminated by void_list_node, start + with void_list_node instead of NULL for newargs. Stop + at void_list_node. + +2016-03-16 Marek Polacek + + PR c/70093 + * c-typeck.c (build_function_call_vec): Create a TARGET_EXPR for + nested functions returning VM types. + +2016-03-09 Cesar Philippidis + + * c-parser.c (c_parser_oacc_loop): Update cclauses and clauses + when calling c_finish_omp_clauses. + +2016-03-04 Bernd Schmidt + + PR c/69824 + * c-decl.c (get_parm_info): Don't queue implicit function declarations + for later. + +2016-03-04 Marek Polacek + + PR c/69798 + * c-parser.c (c_parser_postfix_expression): Call + c_parser_cast_expression rather than c_parser_postfix_expression. + +2016-03-01 Jakub Jelinek + + PR c/69796 + PR c/69974 + * c-parser.c (c_parser_translation_unit): Don't change TREE_TYPE + of incomplete decls to error_mark_node. + 2016-02-24 Marek Polacek PR c/69819 diff --git a/gcc/c/c-decl.c b/gcc/c/c-decl.c index 298036a4eec2..bab471532354 100644 --- a/gcc/c/c-decl.c +++ b/gcc/c/c-decl.c @@ -7050,25 +7050,28 @@ get_parm_info (bool ellipsis, tree expr) vec_safe_push (tags, tag); break; + case FUNCTION_DECL: + /* FUNCTION_DECLs appear when there is an implicit function + declaration in the parameter list. */ + gcc_assert (b->nested); + goto set_shadowed; + case CONST_DECL: case TYPE_DECL: - case FUNCTION_DECL: /* CONST_DECLs appear here when we have an embedded enum, and TYPE_DECLs appear here when we have an embedded struct or union. No warnings for this - we already warned about the - type itself. FUNCTION_DECLs appear when there is an implicit - function declaration in the parameter list. */ + type itself. */ /* When we reinsert this decl in the function body, we need to reconstruct whether it was marked as nested. */ - gcc_assert (TREE_CODE (decl) == FUNCTION_DECL - ? b->nested - : !b->nested); + gcc_assert (!b->nested); DECL_CHAIN (decl) = others; others = decl; /* fall through */ case ERROR_MARK: + set_shadowed: /* error_mark_node appears here when we have an undeclared variable. Just throw it away. */ if (b->id) diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c index 82c1d61b76af..646068424bd2 100644 --- a/gcc/c/c-parser.c +++ b/gcc/c/c-parser.c @@ -1436,10 +1436,7 @@ c_parser_translation_unit (c_parser *parser) tree decl; FOR_EACH_VEC_ELT (incomplete_record_decls, i, decl) if (DECL_SIZE (decl) == NULL_TREE && TREE_TYPE (decl) != error_mark_node) - { - error ("storage size of %q+D isn%'t known", decl); - TREE_TYPE (decl) = error_mark_node; - } + error ("storage size of %q+D isn%'t known", decl); } /* Parse an external declaration (C90 6.7, C99 6.9). @@ -7785,9 +7782,10 @@ c_parser_postfix_expression (c_parser *parser) expr.value = error_mark_node; break; } - c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, - "expected %<)%>"); { + location_t close_paren_loc = c_parser_peek_token (parser)->location; + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, + "expected %<)%>"); tree e1, e2; e1 = groktypename (t1, NULL, NULL); e2 = groktypename (t2, NULL, NULL); @@ -7802,6 +7800,7 @@ c_parser_postfix_expression (c_parser *parser) expr.value = comptypes (e1, e2) ? integer_one_node : integer_zero_node; + set_c_expr_source_range (&expr, loc, close_paren_loc); } break; case RID_BUILTIN_CALL_WITH_STATIC_CHAIN: @@ -8027,8 +8026,8 @@ c_parser_postfix_expression (c_parser *parser) { error_at (loc, "-fcilkplus must be enabled to use " "%<_Cilk_spawn%>"); - expr = c_parser_postfix_expression (parser); - expr.value = error_mark_node; + expr = c_parser_cast_expression (parser, NULL); + expr.value = error_mark_node; } else if (c_parser_peek_token (parser)->keyword == RID_CILK_SPAWN) { @@ -8037,14 +8036,14 @@ c_parser_postfix_expression (c_parser *parser) /* Now flush out all the _Cilk_spawns. */ while (c_parser_peek_token (parser)->keyword == RID_CILK_SPAWN) c_parser_consume_token (parser); - expr = c_parser_postfix_expression (parser); + expr = c_parser_cast_expression (parser, NULL); } else { - expr = c_parser_postfix_expression (parser); + expr = c_parser_cast_expression (parser, NULL); expr.value = build_cilk_spawn (loc, expr.value); } - break; + break; default: c_parser_error (parser, "expected expression"); expr.value = error_mark_node; @@ -10718,7 +10717,7 @@ c_parser_oacc_data_clause (c_parser *parser, pragma_omp_clause c_kind, kind = GOMP_MAP_FORCE_ALLOC; break; case PRAGMA_OACC_CLAUSE_DELETE: - kind = GOMP_MAP_FORCE_DEALLOC; + kind = GOMP_MAP_DELETE; break; case PRAGMA_OACC_CLAUSE_DEVICE: kind = GOMP_MAP_FORCE_TO; @@ -13792,9 +13791,9 @@ c_parser_oacc_loop (location_t loc, c_parser *parser, char *p_name, { clauses = c_oacc_split_loop_clauses (clauses, cclauses); if (*cclauses) - c_finish_omp_clauses (*cclauses, false); + *cclauses = c_finish_omp_clauses (*cclauses, false); if (clauses) - c_finish_omp_clauses (clauses, false); + clauses = c_finish_omp_clauses (clauses, false); } tree block = c_begin_compound_stmt (true); diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c index 6aa0f03dabe8..fb274d5f3c90 100644 --- a/gcc/c/c-typeck.c +++ b/gcc/c/c-typeck.c @@ -518,15 +518,17 @@ composite_type (tree t1, tree t2) /* If both args specify argument types, we must merge the two lists, argument by argument. */ - len = list_length (p1); - newargs = 0; + for (len = 0, newargs = p1; + newargs && newargs != void_list_node; + len++, newargs = TREE_CHAIN (newargs)) + ; for (i = 0; i < len; i++) newargs = tree_cons (NULL_TREE, NULL_TREE, newargs); n = newargs; - for (; p1; + for (; p1 && p1 != void_list_node; p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n)) { /* A null type means arg type is not specified. @@ -3068,6 +3070,16 @@ build_function_call_vec (location_t loc, vec arg_loc, result = build_call_array_loc (loc, TREE_TYPE (fntype), function, nargs, argarray); + /* In this improbable scenario, a nested function returns a VM type. + Create a TARGET_EXPR so that the call always has a LHS, much as + what the C++ FE does for functions returning non-PODs. */ + if (variably_modified_type_p (TREE_TYPE (fntype), NULL_TREE)) + { + tree tmp = create_tmp_var_raw (TREE_TYPE (fntype)); + result = build4 (TARGET_EXPR, TREE_TYPE (fntype), tmp, result, + NULL_TREE, NULL_TREE); + } + if (VOID_TYPE_P (TREE_TYPE (result))) { if (TYPE_QUALS (TREE_TYPE (result)) != TYPE_UNQUALIFIED) diff --git a/gcc/calls.c b/gcc/calls.c index 8f573b83430c..6415e08b28d4 100644 --- a/gcc/calls.c +++ b/gcc/calls.c @@ -2083,9 +2083,9 @@ load_register_parameters (struct arg_data *args, int num_actuals, /* Check for overlap with already clobbered argument area, providing that this has non-zero size. */ if (is_sibcall - && (size == 0 - || mem_overlaps_already_clobbered_arg_p - (XEXP (args[i].value, 0), size))) + && size != 0 + && (mem_overlaps_already_clobbered_arg_p + (XEXP (args[i].value, 0), size))) *sibcall_failure = 1; if (size % UNITS_PER_WORD == 0 @@ -3852,7 +3852,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value, reg_parm_stack_space = REG_PARM_STACK_SPACE ((tree) 0); #endif - /* By default, library functions can not throw. */ + /* By default, library functions cannot throw. */ flags = ECF_NOTHROW; switch (fn_type) @@ -3869,7 +3869,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value, flags |= ECF_NORETURN; break; case LCT_THROW: - flags = ECF_NORETURN; + flags &= ~ECF_NOTHROW; break; case LCT_RETURNS_TWICE: flags = ECF_RETURNS_TWICE; diff --git a/gcc/cfghooks.c b/gcc/cfghooks.c index bbb1017fd1f9..06c05d1fb39a 100644 --- a/gcc/cfghooks.c +++ b/gcc/cfghooks.c @@ -408,7 +408,20 @@ void remove_edge (edge e) { if (current_loops != NULL) - rescan_loop_exit (e, false, true); + { + rescan_loop_exit (e, false, true); + + /* Removal of an edge inside an irreducible region or which leads + to an irreducible region can turn the region into a natural loop. + In that case, ask for the loop structure fixups. + + FIXME: Note that LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS is not always + set, so always ask for fixups when removing an edge in that case. */ + if (!loops_state_satisfies_p (LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS) + || (e->flags & EDGE_IRREDUCIBLE_LOOP) + || (e->dest->flags & BB_IRREDUCIBLE_LOOP)) + loops_state_set (LOOPS_NEED_FIXUP); + } /* This is probably not needed, but it doesn't hurt. */ /* FIXME: This should be called via a remove_edge hook. */ diff --git a/gcc/cfgloop.h b/gcc/cfgloop.h index 882861c3d7ef..54e738f20f4c 100644 --- a/gcc/cfgloop.h +++ b/gcc/cfgloop.h @@ -314,16 +314,6 @@ extern void delete_loop (struct loop *); extern void verify_loop_structure (void); -/* Check loop structure invariants, if internal consistency checks are - enabled. */ - -static inline void -checking_verify_loop_structure (void) -{ - if (flag_checking) - verify_loop_structure (); -} - /* Loop analysis. */ extern bool just_once_each_iteration_p (const struct loop *, const_basic_block); gcov_type expected_loop_iterations_unbounded (const struct loop *); @@ -546,6 +536,28 @@ loops_state_clear (unsigned flags) loops_state_clear (cfun, flags); } +/* Check loop structure invariants, if internal consistency checks are + enabled. */ + +static inline void +checking_verify_loop_structure (void) +{ + /* VERIFY_LOOP_STRUCTURE essentially asserts that no loops need fixups. + + The loop optimizers should never make changes to the CFG which + require loop fixups. But the low level CFG manipulation code may + set the flag conservatively. + + Go ahead and clear the flag here. That avoids the assert inside + VERIFY_LOOP_STRUCTURE, and if there is an inconsistency in the loop + structures VERIFY_LOOP_STRUCTURE will detect it. + + This also avoid the compile time cost of excessive fixups. */ + loops_state_clear (LOOPS_NEED_FIXUP); + if (flag_checking) + verify_loop_structure (); +} + /* Loop iterators. */ /* Flags for loop iteration. */ diff --git a/gcc/cgraph.c b/gcc/cgraph.c index 77273139369d..4804081f3d94 100644 --- a/gcc/cgraph.c +++ b/gcc/cgraph.c @@ -2061,6 +2061,10 @@ cgraph_node::dump (FILE *f) fprintf (f, " icf_merged"); if (merged_comdat) fprintf (f, " merged_comdat"); + if (split_part) + fprintf (f, " split_part"); + if (indirect_call_target) + fprintf (f, " indirect_call_target"); if (nonfreeing_fn) fprintf (f, " nonfreeing_fn"); if (DECL_STATIC_CONSTRUCTOR (decl)) @@ -3356,7 +3360,7 @@ cgraph_node::get_body (void) updated = get_untransformed_body (); /* Getting transformed body makes no sense for inline clones; - we should never use this on real clones becuase they are materialized + we should never use this on real clones because they are materialized early. TODO: Materializing clones here will likely lead to smaller LTRANS footprint. */ @@ -3365,7 +3369,10 @@ cgraph_node::get_body (void) { opt_pass *saved_current_pass = current_pass; FILE *saved_dump_file = dump_file; + const char *saved_dump_file_name = dump_file_name; int saved_dump_flags = dump_flags; + dump_file_name = NULL; + dump_file = NULL; push_cfun (DECL_STRUCT_FUNCTION (decl)); execute_all_ipa_transforms (); @@ -3377,6 +3384,7 @@ cgraph_node::get_body (void) current_pass = saved_current_pass; dump_file = saved_dump_file; + dump_file_name = saved_dump_file_name; dump_flags = saved_dump_flags; } return updated; diff --git a/gcc/cgraph.h b/gcc/cgraph.h index fc7bb223484c..d0345c698c51 100644 --- a/gcc/cgraph.h +++ b/gcc/cgraph.h @@ -1366,6 +1366,8 @@ struct GTY((tag ("SYMTAB_FUNCTION"))) cgraph_node : public symtab_node { unsigned parallelized_function : 1; /* True if function is part split out by ipa-split. */ unsigned split_part : 1; + /* True if the function appears as possible target of indirect call. */ + unsigned indirect_call_target : 1; private: /* Worker for call_for_symbol_and_aliases. */ diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c index 8b3fddc435eb..4351ae499522 100644 --- a/gcc/cgraphunit.c +++ b/gcc/cgraphunit.c @@ -1708,7 +1708,9 @@ cgraph_node::expand_thunk (bool output_asm_thunks, bool force_gimple_thunk) /* Build call to the function being thunked. */ if (!VOID_TYPE_P (restype) - && (!alias_is_noreturn || TREE_ADDRESSABLE (restype))) + && (!alias_is_noreturn + || TREE_ADDRESSABLE (restype) + || TREE_CODE (TYPE_SIZE_UNIT (restype)) != INTEGER_CST)) { if (DECL_BY_REFERENCE (resdecl)) { diff --git a/gcc/combine.c b/gcc/combine.c index 24dcefa0bf62..f701f289f3fd 100644 --- a/gcc/combine.c +++ b/gcc/combine.c @@ -10524,9 +10524,19 @@ simplify_shift_const_1 (enum rtx_code code, machine_mode result_mode, && CONST_INT_P (XEXP (varop, 0)) && !CONST_INT_P (XEXP (varop, 1))) { + /* For ((unsigned) (cstULL >> count)) >> cst2 we have to make + sure the result will be masked. See PR70222. */ + if (code == LSHIFTRT + && mode != result_mode + && !merge_outer_ops (&outer_op, &outer_const, AND, + GET_MODE_MASK (result_mode) + >> orig_count, result_mode, + &complement_p)) + break; + rtx new_rtx = simplify_const_binary_operation (code, mode, - XEXP (varop, 0), - GEN_INT (count)); + XEXP (varop, 0), + GEN_INT (count)); varop = gen_rtx_fmt_ee (code, mode, new_rtx, XEXP (varop, 1)); count = 0; continue; diff --git a/gcc/common.opt b/gcc/common.opt index a176cc37b3a5..d20f8119ea83 100644 --- a/gcc/common.opt +++ b/gcc/common.opt @@ -1844,7 +1844,7 @@ Common Report Var(flag_peephole2) Optimization Enable an RTL peephole pass before sched2. fPIC -Common Report Var(flag_pic,2) Negative(fPIE) +Common Report Var(flag_pic,2) Negative(fPIE) Init(-1) Generate position-independent code if possible (large mode). fPIE @@ -1852,7 +1852,7 @@ Common Report Var(flag_pie,2) Negative(fpic) Init(-1) Generate position-independent code for executables if possible (large mode). fpic -Common Report Var(flag_pic,1) Negative(fpie) +Common Report Var(flag_pic,1) Negative(fpie) Init(-1) Generate position-independent code if possible (small mode). fpie @@ -2462,6 +2462,11 @@ fsplit-paths Common Report Var(flag_split_paths) Init(0) Optimization Split paths leading to loop backedges. +funconstrained-commons +Common Var(flag_unconstrained_commons) Optimization +Assume common declarations may be overridden with ones with a larger +trailing array. + funit-at-a-time Common Report Var(flag_unit_at_a_time) Init(1) Compile whole compilation unit at a time. diff --git a/gcc/common/config/aarch64/aarch64-common.c b/gcc/common/config/aarch64/aarch64-common.c index 69f5da70e3d7..4969f07fef4c 100644 --- a/gcc/common/config/aarch64/aarch64-common.c +++ b/gcc/common/config/aarch64/aarch64-common.c @@ -98,7 +98,7 @@ aarch64_handle_option (struct gcc_options *opts, return true; case OPT_momit_leaf_frame_pointer: - opts->x_flag_omit_frame_pointer = val; + opts->x_flag_omit_leaf_frame_pointer = val; return true; default: diff --git a/gcc/config.gcc b/gcc/config.gcc index 38b57be06b2e..dfee38186e0b 100644 --- a/gcc/config.gcc +++ b/gcc/config.gcc @@ -243,6 +243,7 @@ case ${target} in | avr-*rtems* \ | h8300-*rtems* \ | m32r-*rtems* \ + | mep-* \ ) if test "x$enable_obsolete" != xyes; then echo "*** Configuration ${target} is obsolete." >&2 @@ -1174,7 +1175,7 @@ bfin*-*) use_gcc_stdint=wrap ;; cr16-*-elf) - tm_file="elfos.h ${tm_file}" + tm_file="elfos.h ${tm_file} newlib-stdint.h" tmake_file="${tmake_file} cr16/t-cr16 " use_collect2=no ;; @@ -1979,7 +1980,7 @@ mcore-*-elf) inhibit_libc=true ;; mep-*-*) - tm_file="dbxelf.h elfos.h ${tm_file}" + tm_file="dbxelf.h elfos.h ${tm_file} newlib-stdint.h" tmake_file=mep/t-mep c_target_objs="mep-pragma.o" cxx_target_objs="mep-pragma.o" diff --git a/gcc/config/aarch64/aarch64-c.c b/gcc/config/aarch64/aarch64-c.c index 3590ae0daa5d..e64dc7676cca 100644 --- a/gcc/config/aarch64/aarch64-c.c +++ b/gcc/config/aarch64/aarch64-c.c @@ -178,6 +178,11 @@ aarch64_pragma_target_parse (tree args, tree pop_target) cpp_opts->warn_unused_macros = saved_warn_unused_macros; + /* If we're popping or reseting make sure to update the globals so that + the optab availability predicates get recomputed. */ + if (pop_target) + aarch64_save_restore_target_globals (pop_target); + /* Initialize SIMD builtins if we haven't already. Set current_target_pragma to NULL for the duration so that the builtin initialization code doesn't try to tag the functions diff --git a/gcc/config/aarch64/aarch64-elf-raw.h b/gcc/config/aarch64/aarch64-elf-raw.h index 2dcb6d400eca..909701788923 100644 --- a/gcc/config/aarch64/aarch64-elf-raw.h +++ b/gcc/config/aarch64/aarch64-elf-raw.h @@ -35,7 +35,7 @@ " %{mfix-cortex-a53-835769:--fix-cortex-a53-835769}" #endif -#ifdef TARGET_FIX_ERR_A53_843419_DEFAULT +#if TARGET_FIX_ERR_A53_843419_DEFAULT #define CA53_ERR_843419_SPEC \ " %{!mno-fix-cortex-a53-843419:--fix-cortex-a53-843419}" #else diff --git a/gcc/config/aarch64/aarch64-linux.h b/gcc/config/aarch64/aarch64-linux.h index 6064b2654cb7..5fcaa59a3aff 100644 --- a/gcc/config/aarch64/aarch64-linux.h +++ b/gcc/config/aarch64/aarch64-linux.h @@ -53,7 +53,7 @@ " %{mfix-cortex-a53-835769:--fix-cortex-a53-835769}" #endif -#ifdef TARGET_FIX_ERR_A53_843419_DEFAULT +#if TARGET_FIX_ERR_A53_843419_DEFAULT #define CA53_ERR_843419_SPEC \ " %{!mno-fix-cortex-a53-843419:--fix-cortex-a53-843419}" #else diff --git a/gcc/config/aarch64/aarch64-protos.h b/gcc/config/aarch64/aarch64-protos.h index acf2062245f1..58c9d0d01d8e 100644 --- a/gcc/config/aarch64/aarch64-protos.h +++ b/gcc/config/aarch64/aarch64-protos.h @@ -360,6 +360,7 @@ void aarch64_emit_call_insn (rtx); void aarch64_register_pragmas (void); void aarch64_relayout_simd_types (void); void aarch64_reset_previous_fndecl (void); +void aarch64_save_restore_target_globals (tree); void aarch64_emit_approx_rsqrt (rtx, rtx); /* Initialize builtins for SIMD intrinsics. */ @@ -428,4 +429,8 @@ bool extract_base_offset_in_addr (rtx mem, rtx *base, rtx *offset); bool aarch64_operands_ok_for_ldpstp (rtx *, bool, enum machine_mode); bool aarch64_operands_adjust_ok_for_ldpstp (rtx *, bool, enum machine_mode); extern bool aarch64_nopcrelative_literal_loads; + +extern void aarch64_asm_output_pool_epilogue (FILE *, const char *, + tree, HOST_WIDE_INT); + #endif /* GCC_AARCH64_PROTOS_H */ diff --git a/gcc/config/aarch64/aarch64.c b/gcc/config/aarch64/aarch64.c index 801f95ab7fd6..b7086dd46679 100644 --- a/gcc/config/aarch64/aarch64.c +++ b/gcc/config/aarch64/aarch64.c @@ -537,7 +537,7 @@ static const struct tune_params exynosm1_tunings = 2, /* min_div_recip_mul_df. */ 48, /* max_case_values. */ 64, /* cache_line_size. */ - tune_params::AUTOPREFETCHER_OFF, /* autoprefetcher_model. */ + tune_params::AUTOPREFETCHER_WEAK, /* autoprefetcher_model. */ (AARCH64_EXTRA_TUNE_APPROX_RSQRT) /* tune_flags. */ }; @@ -3847,6 +3847,18 @@ aarch64_mode_valid_for_sched_fusion_p (machine_mode mode) && GET_MODE_SIZE (mode) == 8); } +/* Return true if REGNO is a virtual pointer register, or an eliminable + "soft" frame register. Like REGNO_PTR_FRAME_P except that we don't + include stack_pointer or hard_frame_pointer. */ +static bool +virt_or_elim_regno_p (unsigned regno) +{ + return ((regno >= FIRST_VIRTUAL_REGISTER + && regno <= LAST_VIRTUAL_POINTER_REGISTER) + || regno == FRAME_POINTER_REGNUM + || regno == ARG_POINTER_REGNUM); +} + /* Return true if X is a valid address for machine mode MODE. If it is, fill in INFO appropriately. STRICT_P is true if REG_OK_STRICT is in effect. OUTER_CODE is PARALLEL for a load/store pair. */ @@ -3890,9 +3902,7 @@ aarch64_classify_address (struct aarch64_address_info *info, if (! strict_p && REG_P (op0) - && (op0 == virtual_stack_vars_rtx - || op0 == frame_pointer_rtx - || op0 == arg_pointer_rtx) + && virt_or_elim_regno_p (REGNO (op0)) && CONST_INT_P (op1)) { info->type = ADDRESS_REG_IMM; @@ -4953,74 +4963,43 @@ aarch64_legitimize_address (rtx x, rtx /* orig_x */, machine_mode mode) if (GET_CODE (x) == PLUS && CONST_INT_P (XEXP (x, 1))) { - HOST_WIDE_INT offset = INTVAL (XEXP (x, 1)); - HOST_WIDE_INT base_offset; + rtx base = XEXP (x, 0); + rtx offset_rtx XEXP (x, 1); + HOST_WIDE_INT offset = INTVAL (offset_rtx); - if (GET_CODE (XEXP (x, 0)) == PLUS) + if (GET_CODE (base) == PLUS) { - rtx op0 = XEXP (XEXP (x, 0), 0); - rtx op1 = XEXP (XEXP (x, 0), 1); + rtx op0 = XEXP (base, 0); + rtx op1 = XEXP (base, 1); - /* Address expressions of the form Ra + Rb + CONST. + /* Force any scaling into a temp for CSE. */ + op0 = force_reg (Pmode, op0); + op1 = force_reg (Pmode, op1); - If CONST is within the range supported by the addressing - mode "reg+offset", do not split CONST and use the - sequence - Rt = Ra + Rb; - addr = Rt + CONST. */ - if (REG_P (op0) && REG_P (op1)) - { - machine_mode addr_mode = GET_MODE (x); - rtx base = gen_reg_rtx (addr_mode); - rtx addr = plus_constant (addr_mode, base, offset); + /* Let the pointer register be in op0. */ + if (REG_POINTER (op1)) + std::swap (op0, op1); - if (aarch64_legitimate_address_hook_p (mode, addr, false)) - { - emit_insn (gen_adddi3 (base, op0, op1)); - return addr; - } - } - /* Address expressions of the form Ra + Rb< 16 || mode == TImode) base_offset = ((offset + 64 * GET_MODE_SIZE (mode)) @@ -5032,15 +5011,12 @@ aarch64_legitimize_address (rtx x, rtx /* orig_x */, machine_mode mode) else base_offset = offset & ~0xfff; - if (base_offset == 0) - return x; - - offset -= base_offset; - rtx base_reg = gen_reg_rtx (Pmode); - rtx val = force_operand (plus_constant (Pmode, XEXP (x, 0), base_offset), - NULL_RTX); - emit_move_insn (base_reg, val); - x = plus_constant (Pmode, base_reg, offset); + if (base_offset != 0) + { + base = plus_constant (Pmode, base, base_offset); + base = force_operand (base, NULL_RTX); + return plus_constant (Pmode, base, offset - base_offset); + } } return x; @@ -5579,6 +5555,18 @@ aarch64_select_rtx_section (machine_mode mode, return default_elf_select_rtx_section (mode, x, align); } +/* Implement ASM_OUTPUT_POOL_EPILOGUE. */ +void +aarch64_asm_output_pool_epilogue (FILE *f, const char *, tree, + HOST_WIDE_INT offset) +{ + /* When using per-function literal pools, we must ensure that any code + section is aligned to the minimal instruction length, lest we get + errors from the assembler re "unaligned instructions". */ + if ((offset & 3) && aarch64_can_use_per_function_literal_pools_p ()) + ASM_OUTPUT_ALIGN (f, 2); +} + /* Costs. */ /* Helper function for rtx cost calculation. Strip a shift expression @@ -8110,10 +8098,25 @@ aarch64_parse_override_string (const char* input_string, static void aarch64_override_options_after_change_1 (struct gcc_options *opts) { + /* The logic here is that if we are disabling all frame pointer generation + then we do not need to disable leaf frame pointer generation as a + separate operation. But if we are *only* disabling leaf frame pointer + generation then we set flag_omit_frame_pointer to true, but in + aarch64_frame_pointer_required we return false only for leaf functions. + + PR 70044: We have to be careful about being called multiple times for the + same function. Once we have decided to set flag_omit_frame_pointer just + so that we can omit leaf frame pointers, we must then not interpret a + second call as meaning that all frame pointer generation should be + omitted. We do this by setting flag_omit_frame_pointer to a special, + non-zero value. */ + if (opts->x_flag_omit_frame_pointer == 2) + opts->x_flag_omit_frame_pointer = 0; + if (opts->x_flag_omit_frame_pointer) opts->x_flag_omit_leaf_frame_pointer = false; else if (opts->x_flag_omit_leaf_frame_pointer) - opts->x_flag_omit_frame_pointer = true; + opts->x_flag_omit_frame_pointer = 2; /* If not optimizing for size, set the default alignment to what the target wants. */ @@ -8132,9 +8135,18 @@ aarch64_override_options_after_change_1 (struct gcc_options *opts) if (opts->x_nopcrelative_literal_loads == 1) aarch64_nopcrelative_literal_loads = false; - /* If it is not set on the command line, we default to no - pc relative literal loads. */ - if (opts->x_nopcrelative_literal_loads == 2) + /* If it is not set on the command line, we default to no pc + relative literal loads, unless the workaround for Cortex-A53 + erratum 843419 is in effect. */ + /* This is PR70113. When building the Linux kernel with + CONFIG_ARM64_ERRATUM_843419, support for relocations + R_AARCH64_ADR_PREL_PG_HI21 and R_AARCH64_ADR_PREL_PG_HI21_NC is + removed from the kernel to avoid loading objects with possibly + offending sequences. With nopcrelative_literal_loads, we would + generate such relocations, preventing the kernel build from + succeeding. */ + if (opts->x_nopcrelative_literal_loads == 2 + && !TARGET_FIX_ERR_A53_843419) aarch64_nopcrelative_literal_loads = true; /* In the tiny memory model it makes no sense @@ -8553,6 +8565,21 @@ aarch64_reset_previous_fndecl (void) aarch64_previous_fndecl = NULL; } +/* Restore or save the TREE_TARGET_GLOBALS from or to NEW_TREE. + Used by aarch64_set_current_function and aarch64_pragma_target_parse to + make sure optab availability predicates are recomputed when necessary. */ + +void +aarch64_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 (); +} + /* 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 @@ -8562,63 +8589,32 @@ aarch64_reset_previous_fndecl (void) static void aarch64_set_current_function (tree fndecl) { + if (!fndecl || fndecl == aarch64_previous_fndecl) + return; + tree old_tree = (aarch64_previous_fndecl ? DECL_FUNCTION_SPECIFIC_TARGET (aarch64_previous_fndecl) : NULL_TREE); - tree new_tree = (fndecl - ? DECL_FUNCTION_SPECIFIC_TARGET (fndecl) - : NULL_TREE); + tree new_tree = DECL_FUNCTION_SPECIFIC_TARGET (fndecl); + /* 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 (fndecl && fndecl != aarch64_previous_fndecl) - { - aarch64_previous_fndecl = fndecl; - if (old_tree == new_tree) - ; + /* 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; - else if (new_tree) - { - cl_target_option_restore (&global_options, - TREE_TARGET_OPTION (new_tree)); - if (TREE_TARGET_GLOBALS (new_tree)) - restore_target_globals (TREE_TARGET_GLOBALS (new_tree)); - else - TREE_TARGET_GLOBALS (new_tree) - = save_target_globals_default_opts (); - } + aarch64_previous_fndecl = fndecl; - else if (old_tree && old_tree != target_option_default_node) - { - new_tree = target_option_current_node; - cl_target_option_restore (&global_options, - TREE_TARGET_OPTION (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 (); - } - } + /* First set the target options. */ + cl_target_option_restore (&global_options, TREE_TARGET_OPTION (new_tree)); - if (!fndecl) - return; - - /* If we turned on SIMD make sure that any vector parameters are re-laid out - so that they use proper vector modes. */ - if (TARGET_SIMD) - { - tree parms = DECL_ARGUMENTS (fndecl); - for (; parms && parms != void_list_node; parms = TREE_CHAIN (parms)) - { - if (TREE_CODE (parms) == PARM_DECL - && VECTOR_TYPE_P (TREE_TYPE (parms)) - && DECL_MODE (parms) != TYPE_MODE (TREE_TYPE (parms))) - relayout_decl (parms); - } - } + aarch64_save_restore_target_globals (new_tree); } /* Enum describing the various ways we can handle attributes. @@ -8818,6 +8814,8 @@ static const struct aarch64_attribute_info aarch64_attributes[] = OPT_mgeneral_regs_only }, { "fix-cortex-a53-835769", aarch64_attr_bool, true, NULL, OPT_mfix_cortex_a53_835769 }, + { "fix-cortex-a53-843419", aarch64_attr_bool, true, NULL, + OPT_mfix_cortex_a53_843419 }, { "cmodel", aarch64_attr_enum, false, NULL, OPT_mcmodel_ }, { "strict-align", aarch64_attr_mask, false, NULL, OPT_mstrict_align }, { "omit-leaf-frame-pointer", aarch64_attr_bool, true, NULL, @@ -9232,6 +9230,12 @@ aarch64_can_inline_p (tree caller, tree callee) 2, TARGET_FIX_ERR_A53_835769_DEFAULT)) return false; + if (!aarch64_tribools_ok_for_inlining_p ( + caller_opts->x_aarch64_fix_a53_err843419, + callee_opts->x_aarch64_fix_a53_err843419, + 2, TARGET_FIX_ERR_A53_843419)) + return false; + /* If the user explicitly specified -momit-leaf-frame-pointer for the caller and calle and they don't match up, reject inlining. */ if (!aarch64_tribools_ok_for_inlining_p ( diff --git a/gcc/config/aarch64/aarch64.h b/gcc/config/aarch64/aarch64.h index 8b463c96b2df..7750d1c060d9 100644 --- a/gcc/config/aarch64/aarch64.h +++ b/gcc/config/aarch64/aarch64.h @@ -179,6 +179,20 @@ extern unsigned aarch64_architecture_version; ((aarch64_fix_a53_err835769 == 2) \ ? TARGET_FIX_ERR_A53_835769_DEFAULT : aarch64_fix_a53_err835769) +/* Make sure this is always defined so we don't have to check for ifdefs + but rather use normal ifs. */ +#ifndef TARGET_FIX_ERR_A53_843419_DEFAULT +#define TARGET_FIX_ERR_A53_843419_DEFAULT 0 +#else +#undef TARGET_FIX_ERR_A53_843419_DEFAULT +#define TARGET_FIX_ERR_A53_843419_DEFAULT 1 +#endif + +/* Apply the workaround for Cortex-A53 erratum 843419. */ +#define TARGET_FIX_ERR_A53_843419 \ + ((aarch64_fix_a53_err843419 == 2) \ + ? TARGET_FIX_ERR_A53_843419_DEFAULT : aarch64_fix_a53_err843419) + /* ARMv8.1 Adv.SIMD support. */ #define TARGET_SIMD_RDMA (TARGET_SIMD && AARCH64_ISA_RDMA) @@ -914,4 +928,6 @@ extern const char *host_detect_local_cpu (int argc, const char **argv); #define EXTRA_SPECS \ { "asm_cpu_spec", ASM_CPU_SPEC } +#define ASM_OUTPUT_POOL_EPILOGUE aarch64_asm_output_pool_epilogue + #endif /* GCC_AARCH64_H */ diff --git a/gcc/config/aarch64/aarch64.opt b/gcc/config/aarch64/aarch64.opt index 49ef0c64e2b0..c637ff43a504 100644 --- a/gcc/config/aarch64/aarch64.opt +++ b/gcc/config/aarch64/aarch64.opt @@ -73,7 +73,7 @@ Target Report Var(aarch64_fix_a53_err835769) Init(2) Save Workaround for ARM Cortex-A53 Erratum number 835769. mfix-cortex-a53-843419 -Target Report +Target Report Var(aarch64_fix_a53_err843419) Init(2) Save Workaround for ARM Cortex-A53 Erratum number 843419. mlittle-endian diff --git a/gcc/config/aarch64/t-aarch64 b/gcc/config/aarch64/t-aarch64 index e2c942b3b7f7..778e15c9652d 100644 --- a/gcc/config/aarch64/t-aarch64 +++ b/gcc/config/aarch64/t-aarch64 @@ -20,7 +20,9 @@ TM_H += $(srcdir)/config/aarch64/aarch64-cores.def OPTIONS_H_EXTRA += $(srcdir)/config/aarch64/aarch64-cores.def \ - $(srcdir)/config/aarch64/aarch64-arches.def + $(srcdir)/config/aarch64/aarch64-arches.def \ + $(srcdir)/config/aarch64/aarch64-fusion-pairs.def \ + $(srcdir)/config/aarch64/aarch64-tuning-flags.def $(srcdir)/config/aarch64/aarch64-tune.md: $(srcdir)/config/aarch64/gentune.sh \ $(srcdir)/config/aarch64/aarch64-cores.def diff --git a/gcc/config/arm/arm-cores.def b/gcc/config/arm/arm-cores.def index b61b7f82b68d..829b839c420e 100644 --- a/gcc/config/arm/arm-cores.def +++ b/gcc/config/arm/arm-cores.def @@ -155,6 +155,7 @@ ARM_CORE("cortex-r4", cortexr4, cortexr4, 7R, ARM_FSET_MAKE_CPU1 (FL_LDSCHED | ARM_CORE("cortex-r4f", cortexr4f, cortexr4f, 7R, ARM_FSET_MAKE_CPU1 (FL_LDSCHED | FL_FOR_ARCH7R), cortex) ARM_CORE("cortex-r5", cortexr5, cortexr5, 7R, ARM_FSET_MAKE_CPU1 (FL_LDSCHED | FL_ARM_DIV | FL_FOR_ARCH7R), cortex) ARM_CORE("cortex-r7", cortexr7, cortexr7, 7R, ARM_FSET_MAKE_CPU1 (FL_LDSCHED | FL_ARM_DIV | FL_FOR_ARCH7R), cortex) +ARM_CORE("cortex-r8", cortexr8, cortexr7, 7R, ARM_FSET_MAKE_CPU1 (FL_LDSCHED | FL_ARM_DIV | FL_FOR_ARCH7R), cortex) ARM_CORE("cortex-m7", cortexm7, cortexm7, 7EM, ARM_FSET_MAKE_CPU1 (FL_LDSCHED | FL_NO_VOLATILE_CE | FL_FOR_ARCH7EM), cortex_m7) ARM_CORE("cortex-m4", cortexm4, cortexm4, 7EM, ARM_FSET_MAKE_CPU1 (FL_LDSCHED | FL_FOR_ARCH7EM), v7m) ARM_CORE("cortex-m3", cortexm3, cortexm3, 7M, ARM_FSET_MAKE_CPU1 (FL_LDSCHED | FL_FOR_ARCH7M), v7m) diff --git a/gcc/config/arm/arm-tables.opt b/gcc/config/arm/arm-tables.opt index 4b7522cb7afd..adec6c95367f 100644 --- a/gcc/config/arm/arm-tables.opt +++ b/gcc/config/arm/arm-tables.opt @@ -285,6 +285,9 @@ Enum(processor_type) String(cortex-r5) Value(cortexr5) EnumValue Enum(processor_type) String(cortex-r7) Value(cortexr7) +EnumValue +Enum(processor_type) String(cortex-r8) Value(cortexr8) + EnumValue Enum(processor_type) String(cortex-m7) Value(cortexm7) diff --git a/gcc/config/arm/arm-tune.md b/gcc/config/arm/arm-tune.md index b66344a838e0..d9f02a177e36 100644 --- a/gcc/config/arm/arm-tune.md +++ b/gcc/config/arm/arm-tune.md @@ -30,10 +30,10 @@ cortexa8,cortexa9,cortexa12, cortexa15,cortexa17,cortexr4, cortexr4f,cortexr5,cortexr7, - cortexm7,cortexm4,cortexm3, - marvell_pj4,cortexa15cortexa7,cortexa17cortexa7, - cortexa32,cortexa35,cortexa53, - cortexa57,cortexa72,exynosm1, - qdf24xx,xgene1,cortexa57cortexa53, - cortexa72cortexa53" + cortexr8,cortexm7,cortexm4, + cortexm3,marvell_pj4,cortexa15cortexa7, + cortexa17cortexa7,cortexa32,cortexa35, + cortexa53,cortexa57,cortexa72, + exynosm1,qdf24xx,xgene1, + cortexa57cortexa53,cortexa72cortexa53" (const (symbol_ref "((enum attr_tune) arm_tune)"))) diff --git a/gcc/config/arm/arm.c b/gcc/config/arm/arm.c index 948934390150..c868490d768f 100644 --- a/gcc/config/arm/arm.c +++ b/gcc/config/arm/arm.c @@ -13263,7 +13263,11 @@ tls_mentioned_p (rtx x) } } -/* Must not copy any rtx that uses a pc-relative address. */ +/* Must not copy any rtx that uses a pc-relative address. + Also, disallow copying of load-exclusive instructions that + may appear after splitting of compare-and-swap-style operations + so as to prevent those loops from being transformed away from their + canonical forms (see PR 69904). */ static bool arm_cannot_copy_insn_p (rtx_insn *insn) @@ -13282,6 +13286,20 @@ arm_cannot_copy_insn_p (rtx_insn *insn) || XINT (x, 1) == UNSPEC_PIC_UNIFIED)) return true; } + + rtx set = single_set (insn); + if (set) + { + rtx src = SET_SRC (set); + if (GET_CODE (src) == ZERO_EXTEND) + src = XEXP (src, 0); + + /* Catch the load-exclusive and load-acquire operations. */ + if (GET_CODE (src) == UNSPEC_VOLATILE + && (XINT (src, 1) == VUNSPEC_LL + || XINT (src, 1) == VUNSPEC_LAX)) + return true; + } return false; } diff --git a/gcc/config/arm/arm.md b/gcc/config/arm/arm.md index e67239deb6de..47171b996822 100644 --- a/gcc/config/arm/arm.md +++ b/gcc/config/arm/arm.md @@ -883,8 +883,8 @@ (define_insn "*subsi3_carryin_const" [(set (match_operand:SI 0 "s_register_operand" "=r") - (minus:SI (plus:SI (match_operand:SI 1 "reg_or_int_operand" "r") - (match_operand:SI 2 "arm_not_operand" "K")) + (minus:SI (plus:SI (match_operand:SI 1 "s_register_operand" "r") + (match_operand:SI 2 "arm_not_immediate_operand" "K")) (ltu:SI (reg:CC_C CC_REGNUM) (const_int 0))))] "TARGET_32BIT" "sbc\\t%0, %1, #%B2" diff --git a/gcc/config/arm/arm1020e.md b/gcc/config/arm/arm1020e.md index 7cdab57ddb34..84a300d80454 100644 --- a/gcc/config/arm/arm1020e.md +++ b/gcc/config/arm/arm1020e.md @@ -246,13 +246,14 @@ (eq_attr "type" "branch")) "1020a_e") -;; The latency for a call is not predictable. Therefore, we use 32 as -;; roughly equivalent to positive infinity. +;; The latency for a call is not predictable. Therefore, we model as blocking +;; execution for a number of cycles but we can't do anything more accurate +;; than that. (define_insn_reservation "1020call_op" 32 (and (eq_attr "tune" "arm1020e,arm1022e") (eq_attr "type" "call")) - "1020a_e*32") + "1020a_e*4") ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; VFP @@ -300,12 +301,12 @@ (define_insn_reservation "v10_fdivs" 18 (and (eq_attr "vfp10" "yes") (eq_attr "type" "fdivs, fsqrts")) - "1020a_e+v10_ds*14") + "1020a_e+v10_ds*4") (define_insn_reservation "v10_fdivd" 32 (and (eq_attr "vfp10" "yes") (eq_attr "type" "fdivd, fsqrtd")) - "1020a_e+v10_fmac+v10_ds*28") + "1020a_e+v10_fmac+v10_ds*4") (define_insn_reservation "v10_floads" 4 (and (eq_attr "vfp10" "yes") diff --git a/gcc/config/arm/arm_neon.h b/gcc/config/arm/arm_neon.h index 94bbef56f752..07503d7aa353 100644 --- a/gcc/config/arm/arm_neon.h +++ b/gcc/config/arm/arm_neon.h @@ -27,6 +27,10 @@ #ifndef _GCC_ARM_NEON_H #define _GCC_ARM_NEON_H 1 +#ifndef __ARM_FP +#error "NEON intrinsics not available with the soft-float ABI. Please use -mfloat-abi=softp or -mfloat-abi=hard" +#else + #pragma GCC push_options #pragma GCC target ("fpu=neon") @@ -14833,3 +14837,4 @@ vmull_high_p64 (poly64x2_t __a, poly64x2_t __b) #pragma GCC pop_options #endif +#endif diff --git a/gcc/config/arm/driver-arm.c b/gcc/config/arm/driver-arm.c index 466743b9d47f..95dc9d53b6c1 100644 --- a/gcc/config/arm/driver-arm.c +++ b/gcc/config/arm/driver-arm.c @@ -128,12 +128,11 @@ host_detect_local_cpu (int argc, const char **argv) } } - fclose (f); - - if (val == NULL) - goto not_found; - - return concat ("-m", argv[0], "=", val, NULL); + if (val) + { + fclose (f); + return concat ("-m", argv[0], "=", val, NULL); + } not_found: { diff --git a/gcc/config/arm/vxworks.h b/gcc/config/arm/vxworks.h index 4d8463336019..5b97fe819b18 100644 --- a/gcc/config/arm/vxworks.h +++ b/gcc/config/arm/vxworks.h @@ -112,3 +112,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see #undef TARGET_DEFAULT_WORD_RELOCATIONS #define TARGET_DEFAULT_WORD_RELOCATIONS 1 + +/* Define this to be nonzero if static stack checking is supported. */ +#define STACK_CHECK_STATIC_BUILTIN 1 + +/* This platform supports the probing method of stack checking (RTP mode). + 8K is reserved in the stack to propagate exceptions in case of overflow. */ +#define STACK_CHECK_PROTECT 8192 diff --git a/gcc/config/avr/avr.md b/gcc/config/avr/avr.md index ff26f2e325b4..c98844618415 100644 --- a/gcc/config/avr/avr.md +++ b/gcc/config/avr/avr.md @@ -3351,7 +3351,7 @@ (define_expand "rotl3" [(parallel [(set (match_operand:HISI 0 "register_operand" "") (rotate:HISI (match_operand:HISI 1 "register_operand" "") - (match_operand:VOID 2 "const_int_operand" ""))) + (match_operand:HISI 2 "const_int_operand" ""))) (clobber (match_dup 3))])] "" { diff --git a/gcc/config/epiphany/epiphany.md b/gcc/config/epiphany/epiphany.md index 15a61513e975..18f96613ae6f 100644 --- a/gcc/config/epiphany/epiphany.md +++ b/gcc/config/epiphany/epiphany.md @@ -2026,8 +2026,8 @@ { operands[10] = simplify_gen_subreg (mode, operands[3], mode, 0); - replace_rtx (operands[2], operands[9], operands[3]); - replace_rtx (operands[2], operands[0], operands[10]); + replace_rtx (operands[2], operands[9], operands[3], true); + replace_rtx (operands[2], operands[0], operands[10], true); gcc_assert (!reg_overlap_mentioned_p (operands[0], operands[2])); }) diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c index d8a2909b75f1..1639704835b6 100644 --- a/gcc/config/i386/i386.c +++ b/gcc/config/i386/i386.c @@ -1350,11 +1350,11 @@ struct processor_costs znver1_cost = { COSTS_N_INSNS (1), /* cost of a lea instruction. */ COSTS_N_INSNS (1), /* variable shift costs. */ COSTS_N_INSNS (1), /* constant shift costs. */ - {COSTS_N_INSNS (4), /* cost of starting multiply for QI. */ - COSTS_N_INSNS (4), /* HI. */ - COSTS_N_INSNS (4), /* SI. */ - COSTS_N_INSNS (6), /* DI. */ - COSTS_N_INSNS (6)}, /* other. */ + {COSTS_N_INSNS (3), /* cost of starting multiply for QI. */ + COSTS_N_INSNS (3), /* HI. */ + COSTS_N_INSNS (3), /* SI. */ + COSTS_N_INSNS (4), /* DI. */ + COSTS_N_INSNS (4)}, /* other. */ 0, /* cost of multiply per each bit set. */ {COSTS_N_INSNS (19), /* cost of a divide/mod for QI. */ @@ -2662,9 +2662,9 @@ static const struct ptt processor_target_table[PROCESSOR_max] = {"bdver2", &bdver2_cost, 16, 10, 16, 7, 11}, {"bdver3", &bdver3_cost, 16, 10, 16, 7, 11}, {"bdver4", &bdver4_cost, 16, 10, 16, 7, 11}, - {"znver1", &znver1_cost, 16, 10, 16, 7, 11}, {"btver1", &btver1_cost, 16, 10, 16, 7, 11}, - {"btver2", &btver2_cost, 16, 10, 16, 7, 11} + {"btver2", &btver2_cost, 16, 10, 16, 7, 11}, + {"znver1", &znver1_cost, 16, 10, 16, 7, 11} }; static unsigned int @@ -3272,8 +3272,9 @@ scalar_chain::make_vector_copies (unsigned regno) gen_rtx_SUBREG (SImode, reg, 4)); emit_move_insn (vreg, tmp); } - emit_conversion_insns (get_insns (), insn); + rtx_insn *seq = get_insns (); end_sequence (); + emit_conversion_insns (seq, insn); if (dump_file) fprintf (dump_file, @@ -3348,8 +3349,9 @@ scalar_chain::convert_reg (unsigned regno) emit_move_insn (gen_rtx_SUBREG (SImode, scopy, 4), adjust_address (tmp, SImode, 4)); } - emit_conversion_insns (get_insns (), insn); + rtx_insn *seq = get_insns (); end_sequence (); + emit_conversion_insns (seq, insn); if (dump_file) fprintf (dump_file, @@ -3370,8 +3372,11 @@ scalar_chain::convert_reg (unsigned regno) bitmap_clear_bit (conv, DF_REF_INSN_UID (ref)); } } - else if (NONDEBUG_INSN_P (DF_REF_INSN (ref))) + /* Skip debug insns and uninitialized uses. */ + else if (DF_REF_CHAIN (ref) + && NONDEBUG_INSN_P (DF_REF_INSN (ref))) { + gcc_assert (scopy); replace_rtx (DF_REF_INSN (ref), reg, scopy); df_insn_rescan (DF_REF_INSN (ref)); } @@ -3404,6 +3409,20 @@ scalar_chain::convert_op (rtx *op, rtx_insn *insn) fprintf (dump_file, " Preloading operand for insn %d into r%d\n", INSN_UID (insn), REGNO (tmp)); } + else if (REG_P (*op)) + { + /* We may have not converted register usage in case + this register has no definition. Otherwise it + should be converted in convert_reg. */ + df_ref ref; + FOR_EACH_INSN_USE (ref, insn) + if (DF_REF_REGNO (ref) == REGNO (*op)) + { + gcc_assert (!DF_REF_CHAIN (ref)); + break; + } + *op = gen_rtx_SUBREG (V2DImode, *op, 0); + } else { gcc_assert (SUBREG_P (*op)); @@ -7794,6 +7813,10 @@ type_natural_mode (const_tree type, const CUMULATIVE_ARGS *cum, { machine_mode innermode = TYPE_MODE (TREE_TYPE (type)); + /* There are no XFmode vector modes. */ + if (innermode == XFmode) + return mode; + if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE) mode = MIN_MODE_VECTOR_FLOAT; else @@ -11099,18 +11122,7 @@ output_set_got (rtx dest, rtx label) xops[1] = gen_rtx_SYMBOL_REF (Pmode, GOT_SYMBOL_NAME); - if (!flag_pic) - { - if (TARGET_MACHO) - /* We don't need a pic base, we're not producing pic. */ - gcc_unreachable (); - - xops[2] = gen_rtx_LABEL_REF (Pmode, label ? label : gen_label_rtx ()); - output_asm_insn ("mov%z0\t{%2, %0|%0, %2}", xops); - targetm.asm_out.internal_label (asm_out_file, "L", - CODE_LABEL_NUMBER (XEXP (xops[2], 0))); - } - else + if (flag_pic) { char name[32]; get_pc_thunk_name (name, REGNO (dest)); @@ -11135,6 +11147,17 @@ output_set_got (rtx dest, rtx label) CODE_LABEL_NUMBER (label)); #endif } + else + { + if (TARGET_MACHO) + /* We don't need a pic base, we're not producing pic. */ + gcc_unreachable (); + + xops[2] = gen_rtx_LABEL_REF (Pmode, label ? label : gen_label_rtx ()); + output_asm_insn ("mov%z0\t{%2, %0|%0, %2}", xops); + targetm.asm_out.internal_label (asm_out_file, "L", + CODE_LABEL_NUMBER (XEXP (xops[2], 0))); + } if (!TARGET_MACHO) output_asm_insn ("add%z0\t{%1, %0|%0, %1}", xops); @@ -11520,6 +11543,7 @@ ix86_compute_frame_layout (struct ix86_frame *frame) if (ix86_using_red_zone () && crtl->sp_is_unchanging && crtl->is_leaf + && !ix86_pc_thunk_call_expanded && !ix86_current_function_calls_tls_descriptor) { frame->red_zone_size = to_allocate; @@ -26028,14 +26052,13 @@ static enum stringop_alg decide_alg (HOST_WIDE_INT count, HOST_WIDE_INT expected_size, unsigned HOST_WIDE_INT min_size, unsigned HOST_WIDE_INT max_size, bool memset, bool zero_memset, bool have_as, - int *dynamic_check, bool *noalign) + int *dynamic_check, bool *noalign, bool recur) { const struct stringop_algs *algs; bool optimize_for_speed; int max = 0; const struct processor_costs *cost; int i; - HOST_WIDE_INT orig_expected_size = expected_size; bool any_alg_usable_p = false; *noalign = false; @@ -26153,19 +26176,18 @@ decide_alg (HOST_WIDE_INT count, HOST_WIDE_INT expected_size, enum stringop_alg alg; HOST_WIDE_INT new_expected_size = (max > 0 ? max : 4096) / 2; - /* If there aren't any usable algorithms or if recursing with the - same arguments as before, then recursing on smaller sizes or - same size isn't going to find anything. Just return the simple - byte-at-a-time copy loop. */ - if (!any_alg_usable_p || orig_expected_size == new_expected_size) - { - /* Pick something reasonable. */ - if (TARGET_INLINE_STRINGOPS_DYNAMICALLY) - *dynamic_check = 128; - return loop_1_byte; - } + /* If there aren't any usable algorithms or if recursing already, + then recursing on smaller sizes or same size isn't going to + find anything. Just return the simple byte-at-a-time copy loop. */ + if (!any_alg_usable_p || recur) + { + /* Pick something reasonable. */ + if (TARGET_INLINE_STRINGOPS_DYNAMICALLY && !recur) + *dynamic_check = 128; + return loop_1_byte; + } alg = decide_alg (count, new_expected_size, min_size, max_size, memset, - zero_memset, have_as, dynamic_check, noalign); + zero_memset, have_as, dynamic_check, noalign, true); gcc_assert (*dynamic_check == -1); if (TARGET_INLINE_STRINGOPS_DYNAMICALLY) *dynamic_check = max; @@ -26426,7 +26448,7 @@ ix86_expand_set_or_movmem (rtx dst, rtx src, rtx count_exp, rtx val_exp, alg = decide_alg (count, expected_size, min_size, probable_max_size, issetmem, issetmem && val_exp == const0_rtx, have_as, - &dynamic_check, &noalign); + &dynamic_check, &noalign, false); if (alg == libcall) return false; gcc_assert (alg != no_stringop); @@ -27293,14 +27315,17 @@ ix86_output_call_insn (rtx_insn *insn, rtx call_op) if (SIBLING_CALL_P (insn)) { - if (direct_p && ix86_nopic_noplt_attribute_p (call_op)) - xasm = "%!jmp\t*%p0@GOTPCREL(%%rip)"; - else if (direct_p) - xasm = "%!jmp\t%P0"; + if (direct_p) + { + if (ix86_nopic_noplt_attribute_p (call_op)) + xasm = "%!jmp\t{*%p0@GOTPCREL(%%rip)|[QWORD PTR %p0@GOTPCREL[rip]]}"; + else + xasm = "%!jmp\t%P0"; + } /* SEH epilogue detection requires the indirect branch case to include REX.W. */ else if (TARGET_SEH) - xasm = "%!rex.W jmp %A0"; + xasm = "%!rex.W jmp\t%A0"; else xasm = "%!jmp\t%A0"; @@ -27338,10 +27363,13 @@ ix86_output_call_insn (rtx_insn *insn, rtx call_op) seh_nop_p = true; } - if (direct_p && ix86_nopic_noplt_attribute_p (call_op)) - xasm = "%!call\t*%p0@GOTPCREL(%%rip)"; - else if (direct_p) - xasm = "%!call\t%P0"; + if (direct_p) + { + if (ix86_nopic_noplt_attribute_p (call_op)) + xasm = "%!call\t{*%p0@GOTPCREL(%%rip)|[QWORD PTR %p0@GOTPCREL[rip]]}"; + else + xasm = "%!call\t%P0"; + } else xasm = "%!call\t%A0"; @@ -32415,6 +32443,14 @@ def_builtin (HOST_WIDE_INT mask, const char *name, { ix86_builtins_isa[(int) code].isa = mask; + /* OPTION_MASK_ISA_AVX512VL has special meaning. Despite of generic case, + where any bit set means that built-in is enable, this bit must be *and-ed* + with another one. E.g.: OPTION_MASK_ISA_AVX512DQ | OPTION_MASK_ISA_AVX512VL + means that *both* cpuid bits must be set for the built-in to be available. + Handle this here. */ + if (mask & ix86_isa_flags & OPTION_MASK_ISA_AVX512VL) + mask &= ~OPTION_MASK_ISA_AVX512VL; + mask &= ~OPTION_MASK_ISA_64BIT; if (mask == 0 || (mask & ix86_isa_flags) != 0 @@ -34080,9 +34116,9 @@ static const struct builtin_description bdesc_args[] = { OPTION_MASK_ISA_AVX512BW | OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_permvarv16hi_mask, "__builtin_ia32_permvarhi256_mask", IX86_BUILTIN_VPERMVARHI256_MASK, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI_V16HI_UHI }, { OPTION_MASK_ISA_AVX512BW | OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_permvarv8hi_mask, "__builtin_ia32_permvarhi128_mask", IX86_BUILTIN_VPERMVARHI128_MASK, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_V8HI_UQI }, { OPTION_MASK_ISA_AVX512BW | OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_vpermt2varv16hi3_mask, "__builtin_ia32_vpermt2varhi256_mask", IX86_BUILTIN_VPERMT2VARHI256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI_V16HI_UHI }, - { OPTION_MASK_ISA_AVX512BW | OPTION_MASK_ISA_AVX512BW | OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_vpermt2varv16hi3_maskz, "__builtin_ia32_vpermt2varhi256_maskz", IX86_BUILTIN_VPERMT2VARHI256_MASKZ, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI_V16HI_UHI }, + { OPTION_MASK_ISA_AVX512BW | OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_vpermt2varv16hi3_maskz, "__builtin_ia32_vpermt2varhi256_maskz", IX86_BUILTIN_VPERMT2VARHI256_MASKZ, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI_V16HI_UHI }, { OPTION_MASK_ISA_AVX512BW | OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_vpermt2varv8hi3_mask, "__builtin_ia32_vpermt2varhi128_mask", IX86_BUILTIN_VPERMT2VARHI128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_V8HI_UQI }, - { OPTION_MASK_ISA_AVX512BW | OPTION_MASK_ISA_AVX512BW | OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_vpermt2varv8hi3_maskz, "__builtin_ia32_vpermt2varhi128_maskz", IX86_BUILTIN_VPERMT2VARHI128_MASKZ, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_V8HI_UQI }, + { OPTION_MASK_ISA_AVX512BW | OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_vpermt2varv8hi3_maskz, "__builtin_ia32_vpermt2varhi128_maskz", IX86_BUILTIN_VPERMT2VARHI128_MASKZ, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_V8HI_UQI }, { OPTION_MASK_ISA_AVX512BW | OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_vpermi2varv16hi3_mask, "__builtin_ia32_vpermi2varhi256_mask", IX86_BUILTIN_VPERMI2VARHI256, UNKNOWN, (int) V16HI_FTYPE_V16HI_V16HI_V16HI_UHI }, { OPTION_MASK_ISA_AVX512BW | OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_vpermi2varv8hi3_mask, "__builtin_ia32_vpermi2varhi128_mask", IX86_BUILTIN_VPERMI2VARHI128, UNKNOWN, (int) V8HI_FTYPE_V8HI_V8HI_V8HI_UQI }, { OPTION_MASK_ISA_AVX512VL, CODE_FOR_rcp14v4df_mask, "__builtin_ia32_rcp14pd256_mask", IX86_BUILTIN_RCP14PD256, UNKNOWN, (int) V4DF_FTYPE_V4DF_V4DF_UQI }, @@ -34797,9 +34833,9 @@ static const struct builtin_description bdesc_args[] = { OPTION_MASK_ISA_AVX512VBMI | OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_permvarv32qi_mask, "__builtin_ia32_permvarqi256_mask", IX86_BUILTIN_VPERMVARQI256_MASK, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI_V32QI_USI }, { OPTION_MASK_ISA_AVX512VBMI | OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_permvarv16qi_mask, "__builtin_ia32_permvarqi128_mask", IX86_BUILTIN_VPERMVARQI128_MASK, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI_V16QI_UHI }, { OPTION_MASK_ISA_AVX512VBMI | OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_vpermt2varv32qi3_mask, "__builtin_ia32_vpermt2varqi256_mask", IX86_BUILTIN_VPERMT2VARQI256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI_V32QI_USI }, - { OPTION_MASK_ISA_AVX512VBMI | OPTION_MASK_ISA_AVX512VBMI | OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_vpermt2varv32qi3_maskz, "__builtin_ia32_vpermt2varqi256_maskz", IX86_BUILTIN_VPERMT2VARQI256_MASKZ, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI_V32QI_USI }, + { OPTION_MASK_ISA_AVX512VBMI | OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_vpermt2varv32qi3_maskz, "__builtin_ia32_vpermt2varqi256_maskz", IX86_BUILTIN_VPERMT2VARQI256_MASKZ, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI_V32QI_USI }, { OPTION_MASK_ISA_AVX512VBMI | OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_vpermt2varv16qi3_mask, "__builtin_ia32_vpermt2varqi128_mask", IX86_BUILTIN_VPERMT2VARQI128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI_V16QI_UHI }, - { OPTION_MASK_ISA_AVX512VBMI | OPTION_MASK_ISA_AVX512VBMI | OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_vpermt2varv16qi3_maskz, "__builtin_ia32_vpermt2varqi128_maskz", IX86_BUILTIN_VPERMT2VARQI128_MASKZ, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI_V16QI_UHI }, + { OPTION_MASK_ISA_AVX512VBMI | OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_vpermt2varv16qi3_maskz, "__builtin_ia32_vpermt2varqi128_maskz", IX86_BUILTIN_VPERMT2VARQI128_MASKZ, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI_V16QI_UHI }, { OPTION_MASK_ISA_AVX512VBMI | OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_vpermi2varv32qi3_mask, "__builtin_ia32_vpermi2varqi256_mask", IX86_BUILTIN_VPERMI2VARQI256, UNKNOWN, (int) V32QI_FTYPE_V32QI_V32QI_V32QI_USI }, { OPTION_MASK_ISA_AVX512VBMI | OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_vpermi2varv16qi3_mask, "__builtin_ia32_vpermi2varqi128_mask", IX86_BUILTIN_VPERMI2VARQI128, UNKNOWN, (int) V16QI_FTYPE_V16QI_V16QI_V16QI_UHI }, }; @@ -51896,16 +51932,24 @@ ix86_expand_vecop_qihi (enum rtx_code code, rtx dest, rtx op1, rtx op2) { /* For SSE2, we used an full interleave, so the desired results are in the even elements. */ - for (i = 0; i < 64; ++i) + for (i = 0; i < d.nelt; ++i) d.perm[i] = i * 2; } else { /* For AVX, the interleave used above was not cross-lane. So the extraction is evens but with the second and third quarter swapped. - Happily, that is even one insn shorter than even extraction. */ - for (i = 0; i < 64; ++i) - d.perm[i] = i * 2 + ((i & 24) == 8 ? 16 : (i & 24) == 16 ? -16 : 0); + Happily, that is even one insn shorter than even extraction. + For AVX512BW we have 4 lanes. We extract evens from within a lane, + always first from the first and then from the second source operand, + the index bits above the low 4 bits remains the same. + Thus, for d.nelt == 32 we want permutation + 0,2,4,..14, 32,34,36,..46, 16,18,20,..30, 48,50,52,..62 + and for d.nelt == 64 we want permutation + 0,2,4,..14, 64,66,68,..78, 16,18,20,..30, 80,82,84,..94, + 32,34,36,..46, 96,98,100,..110, 48,50,52,..62, 112,114,116,..126. */ + for (i = 0; i < d.nelt; ++i) + d.perm[i] = ((i * 2) & 14) + ((i & 8) ? d.nelt : 0) + (i & ~15); } ok = ix86_expand_vec_perm_const_1 (&d); diff --git a/gcc/config/i386/i386.h b/gcc/config/i386/i386.h index 9062d631165b..8d39b5de2cb9 100644 --- a/gcc/config/i386/i386.h +++ b/gcc/config/i386/i386.h @@ -1621,7 +1621,7 @@ enum reg_class function prologue should increase the stack frame size by this amount. In 32bit mode enabling argument accumulation results in about 5% code size - growth becuase move instructions are less compact than push. In 64bit + growth because move instructions are less compact than push. In 64bit mode the difference is less drastic but visible. FIXME: Unlike earlier implementations, the size of unwind info seems to @@ -2494,6 +2494,10 @@ struct GTY(()) machine_function { expander to determine the style used. */ BOOL_BITFIELD use_fast_prologue_epilogue : 1; + /* Nonzero if the current function calls pc thunk and + must not use the red zone. */ + BOOL_BITFIELD pc_thunk_call_expanded : 1; + /* If true, the current function needs the default PIC register, not an alternate register (on x86) and must not use the red zone (on x86_64), even if it's a leaf function. We don't want the @@ -2533,6 +2537,7 @@ struct GTY(()) machine_function { #define ix86_varargs_fpr_size (cfun->machine->varargs_fpr_size) #define ix86_optimize_mode_switching (cfun->machine->optimize_mode_switching) #define ix86_current_function_needs_cld (cfun->machine->needs_cld) +#define ix86_pc_thunk_call_expanded (cfun->machine->pc_thunk_call_expanded) #define ix86_tls_descriptor_calls_expanded_in_cfun \ (cfun->machine->tls_descriptor_call_expanded_p) /* Since tls_descriptor_call_expanded is not cleared, even if all TLS diff --git a/gcc/config/i386/i386.md b/gcc/config/i386/i386.md index edde41a7ac51..339a13401ddb 100644 --- a/gcc/config/i386/i386.md +++ b/gcc/config/i386/i386.md @@ -1872,14 +1872,6 @@ (set_attr "mode" "")]) -;; Move instructions. - -(define_expand "movxi" - [(set (match_operand:XI 0 "nonimmediate_operand") - (match_operand:XI 1 "general_operand"))] - "TARGET_AVX512F" - "ix86_expand_move (XImode, operands); DONE;") - ;; Reload patterns to support multi-word load/store ;; with non-offsetable address. (define_expand "reload_noff_store" @@ -1914,15 +1906,23 @@ DONE; }) +;; Move instructions. + +(define_expand "movxi" + [(set (match_operand:XI 0 "nonimmediate_operand") + (match_operand:XI 1 "general_operand"))] + "TARGET_AVX512F" + "ix86_expand_vector_move (XImode, operands); DONE;") + (define_expand "movoi" [(set (match_operand:OI 0 "nonimmediate_operand") (match_operand:OI 1 "general_operand"))] "TARGET_AVX" - "ix86_expand_move (OImode, operands); DONE;") + "ix86_expand_vector_move (OImode, operands); DONE;") (define_expand "movti" [(set (match_operand:TI 0 "nonimmediate_operand") - (match_operand:TI 1 "nonimmediate_operand"))] + (match_operand:TI 1 "general_operand"))] "TARGET_64BIT || TARGET_SSE" { if (TARGET_64BIT) @@ -2442,7 +2442,7 @@ (define_insn "kmovw" [(set (match_operand:HI 0 "nonimmediate_operand" "=k,k") (unspec:HI - [(match_operand:HI 1 "nonimmediate_operand" "rm,k")] + [(match_operand:HI 1 "nonimmediate_operand" "r,km")] UNSPEC_KMOV))] "!(MEM_P (operands[0]) && MEM_P (operands[1])) && TARGET_AVX512F" "@ @@ -2454,8 +2454,8 @@ (define_insn "*movhi_internal" - [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r ,r ,m ,k,k,rm") - (match_operand:HI 1 "general_operand" "r ,rn,rm,rn,rm,k,k"))] + [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r ,r ,m ,k,k, r,m") + (match_operand:HI 1 "general_operand" "r ,rn,rm,rn,r,km,k,k"))] "!(MEM_P (operands[0]) && MEM_P (operands[1]))" { switch (get_attr_type (insn)) @@ -2469,7 +2469,8 @@ switch (which_alternative) { case 4: return "kmovw\t{%k1, %0|%0, %k1}"; - case 5: return "kmovw\t{%1, %0|%0, %1}"; + case 5: /* FALLTHRU */ + case 7: return "kmovw\t{%1, %0|%0, %1}"; case 6: return "kmovw\t{%1, %k0|%k0, %1}"; default: gcc_unreachable (); } @@ -2482,7 +2483,7 @@ } } [(set (attr "type") - (cond [(eq_attr "alternative" "4,5,6") + (cond [(eq_attr "alternative" "4,5,6,7") (const_string "mskmov") (match_test "optimize_function_for_size_p (cfun)") (const_string "imov") @@ -2499,7 +2500,7 @@ ] (const_string "imov"))) (set (attr "prefix") - (if_then_else (eq_attr "alternative" "4,5,6") + (if_then_else (eq_attr "alternative" "4,5,6,7") (const_string "vex") (const_string "orig"))) (set (attr "mode") @@ -4228,17 +4229,28 @@ { /* If it is unsafe to overwrite upper half of source, we need to move to destination and unpack there. */ - if ((ORIGINAL_REGNO (operands[1]) < FIRST_PSEUDO_REGISTER - || PSEUDO_REGNO_BYTES (ORIGINAL_REGNO (operands[1])) > 4) - && true_regnum (operands[0]) != true_regnum (operands[1])) + if (((ORIGINAL_REGNO (operands[1]) < FIRST_PSEUDO_REGISTER + || PSEUDO_REGNO_BYTES (ORIGINAL_REGNO (operands[1])) > 4) + && true_regnum (operands[0]) != true_regnum (operands[1])) + || (EXT_REX_SSE_REG_P (operands[1]) + && !TARGET_AVX512VL)) { rtx tmp = gen_rtx_REG (SFmode, true_regnum (operands[0])); emit_move_insn (tmp, operands[1]); } else operands[3] = simplify_gen_subreg (V4SFmode, operands[1], SFmode, 0); - emit_insn (gen_vec_interleave_lowv4sf (operands[3], operands[3], - operands[3])); + /* FIXME: vec_interleave_lowv4sf for AVX512VL should allow + =v, v, then vbroadcastss will be only needed for AVX512F without + AVX512VL. */ + if (!EXT_REX_SSE_REGNO_P (true_regnum (operands[3]))) + emit_insn (gen_vec_interleave_lowv4sf (operands[3], operands[3], + operands[3])); + else + { + rtx tmp = simplify_gen_subreg (V16SFmode, operands[3], V4SFmode, 0); + emit_insn (gen_avx512f_vec_dupv16sf_1 (tmp, tmp)); + } } else emit_insn (gen_vec_setv4sf_0 (operands[3], @@ -4392,8 +4404,8 @@ emit_insn (gen_vec_dupv2df (operands[4], operands[1])); } else - emit_insn (gen_sse2_loadlpd (operands[4], - CONST0_RTX (V2DFmode), operands[1])); + emit_insn (gen_vec_concatv2df (operands[4], operands[1], + CONST0_RTX (DFmode))); }) ;; It's more profitable to split and then extend in the same register. @@ -8129,16 +8141,31 @@ (match_operand:DI 1 "nonimmediate_operand" "%0,0,0") (match_operand:DI 2 "x86_64_szext_general_operand" "Z,re,rm"))) (clobber (reg:CC FLAGS_REG))] - "!TARGET_64BIT && TARGET_STV && TARGET_SSE2 && ix86_binary_operator_ok (AND, DImode, operands)" + "!TARGET_64BIT && TARGET_STV && TARGET_SSE2 + && ix86_binary_operator_ok (AND, DImode, operands)" "#" "&& reload_completed" - [(parallel [(set (match_dup 0) - (and:SI (match_dup 1) (match_dup 2))) - (clobber (reg:CC FLAGS_REG))]) - (parallel [(set (match_dup 3) - (and:SI (match_dup 4) (match_dup 5))) - (clobber (reg:CC FLAGS_REG))])] - "split_double_mode (DImode, &operands[0], 3, &operands[0], &operands[3]);") + [(const_int 0)] +{ + split_double_mode (DImode, &operands[0], 3, &operands[0], &operands[3]); + if (operands[2] == const0_rtx) + { + operands[1] = const0_rtx; + ix86_expand_move (SImode, &operands[0]); + } + else if (operands[2] != constm1_rtx) + ix86_expand_binary_operator (AND, SImode, &operands[0]); + else if (operands[5] == constm1_rtx) + emit_note (NOTE_INSN_DELETED); + if (operands[5] == const0_rtx) + { + operands[4] = const0_rtx; + ix86_expand_move (SImode, &operands[3]); + } + else if (operands[5] != constm1_rtx) + ix86_expand_binary_operator (AND, SImode, &operands[3]); + DONE; +}) (define_insn "*andsi_1" [(set (match_operand:SI 0 "nonimmediate_operand" "=rm,r,Ya,!k") @@ -8653,16 +8680,41 @@ (match_operand:DI 1 "nonimmediate_operand" "%0,0,0") (match_operand:DI 2 "x86_64_szext_general_operand" "Z,re,rm"))) (clobber (reg:CC FLAGS_REG))] - "!TARGET_64BIT && TARGET_STV && TARGET_SSE2 && ix86_binary_operator_ok (, DImode, operands)" + "!TARGET_64BIT && TARGET_STV && TARGET_SSE2 + && ix86_binary_operator_ok (, DImode, operands)" "#" "&& reload_completed" - [(parallel [(set (match_dup 0) - (any_or:SI (match_dup 1) (match_dup 2))) - (clobber (reg:CC FLAGS_REG))]) - (parallel [(set (match_dup 3) - (any_or:SI (match_dup 4) (match_dup 5))) - (clobber (reg:CC FLAGS_REG))])] - "split_double_mode (DImode, &operands[0], 3, &operands[0], &operands[3]);") + [(const_int 0)] +{ + split_double_mode (DImode, &operands[0], 3, &operands[0], &operands[3]); + if (operands[2] == constm1_rtx) + { + if ( == IOR) + { + operands[1] = constm1_rtx; + ix86_expand_move (SImode, &operands[0]); + } + else + ix86_expand_unary_operator (NOT, SImode, &operands[0]); + } + else if (operands[2] != const0_rtx) + ix86_expand_binary_operator (, SImode, &operands[0]); + else if (operands[5] == const0_rtx) + emit_note (NOTE_INSN_DELETED); + if (operands[5] == constm1_rtx) + { + if ( == IOR) + { + operands[4] = constm1_rtx; + ix86_expand_move (SImode, &operands[3]); + } + else + ix86_expand_unary_operator (NOT, SImode, &operands[3]); + } + else if (operands[5] != const0_rtx) + ix86_expand_binary_operator (, SImode, &operands[3]); + DONE; +}) (define_insn_and_split "*andndi3_doubleword" [(set (match_operand:DI 0 "register_operand" "=r,r") @@ -12469,7 +12521,18 @@ "" "ix86_expand_prologue (); DONE;") -(define_insn "set_got" +(define_expand "set_got" + [(parallel + [(set (match_operand:SI 0 "register_operand" "=r") + (unspec:SI [(const_int 0)] UNSPEC_SET_GOT)) + (clobber (reg:CC FLAGS_REG))])] + "!TARGET_64BIT" +{ + if (flag_pic && !TARGET_VXWORKS_RTP) + ix86_pc_thunk_call_expanded = true; +}) + +(define_insn "*set_got" [(set (match_operand:SI 0 "register_operand" "=r") (unspec:SI [(const_int 0)] UNSPEC_SET_GOT)) (clobber (reg:CC FLAGS_REG))] @@ -12478,7 +12541,19 @@ [(set_attr "type" "multi") (set_attr "length" "12")]) -(define_insn "set_got_labelled" +(define_expand "set_got_labelled" + [(parallel + [(set (match_operand:SI 0 "register_operand" "=r") + (unspec:SI [(label_ref (match_operand 1))] + UNSPEC_SET_GOT)) + (clobber (reg:CC FLAGS_REG))])] + "!TARGET_64BIT" +{ + if (flag_pic && !TARGET_VXWORKS_RTP) + ix86_pc_thunk_call_expanded = true; +}) + +(define_insn "*set_got_labelled" [(set (match_operand:SI 0 "register_operand" "=r") (unspec:SI [(label_ref (match_operand 1))] UNSPEC_SET_GOT)) @@ -17861,7 +17936,7 @@ (parallel [(set (match_dup 0) (match_op_dup 3 [(match_dup 0) (match_dup 1)])) (clobber (reg:CC FLAGS_REG))])] - "operands[4] = replace_rtx (operands[2], operands[0], operands[1]);") + "operands[4] = replace_rtx (operands[2], operands[0], operands[1], true);") (define_peephole2 [(set (match_operand 0 "register_operand") diff --git a/gcc/config/i386/sol2.h b/gcc/config/i386/sol2.h index 51d1c55de0d2..368c2d2d211a 100644 --- a/gcc/config/i386/sol2.h +++ b/gcc/config/i386/sol2.h @@ -21,6 +21,11 @@ along with GCC; see the file COPYING3. If not see #define SUBTARGET_OPTIMIZATION_OPTIONS \ { OPT_LEVELS_1_PLUS, OPT_momit_leaf_frame_pointer, NULL, 1 } +/* 32-bit Solaris/x86 only guarantees 4-byte stack alignment as required by + the i386 psABI, so realign it as necessary for SSE instructions. */ +#undef STACK_REALIGN_DEFAULT +#define STACK_REALIGN_DEFAULT (TARGET_64BIT ? 0 : 1) + /* Old versions of the Solaris assembler can not handle the difference of labels in different sections, so force DW_EH_PE_datarel if so. */ #ifndef HAVE_AS_IX86_DIFF_SECT_DELTA @@ -132,8 +137,9 @@ along with GCC; see the file COPYING3. If not see /* The Solaris assembler wants a .local for non-exported aliases. */ #define ASM_OUTPUT_DEF_FROM_DECLS(FILE, DECL, TARGET) \ do { \ - const char *declname = \ - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (DECL)); \ + tree id = DECL_ASSEMBLER_NAME (DECL); \ + ultimate_transparent_alias_target (&id); \ + const char *declname = IDENTIFIER_POINTER (id); \ ASM_OUTPUT_DEF ((FILE), declname, \ IDENTIFIER_POINTER (TARGET)); \ if (! TREE_PUBLIC (DECL)) \ diff --git a/gcc/config/i386/sse.md b/gcc/config/i386/sse.md index 49b99e451bad..44141ea5d97f 100644 --- a/gcc/config/i386/sse.md +++ b/gcc/config/i386/sse.md @@ -8951,7 +8951,7 @@ (set_attr "prefix" "orig,maybe_vex,evex") (set_attr "mode" "V2DF,DF,DF")]) -(define_insn "*vec_concatv2df" +(define_insn "vec_concatv2df" [(set (match_operand:V2DF 0 "register_operand" "=x,x,v,x,v,x,x,v,x,x") (vec_concat:V2DF (match_operand:DF 1 "nonimmediate_operand" " 0,x,v,m,m,0,x,m,0,0") @@ -12426,13 +12426,13 @@ { int mask = INTVAL (operands[3]); if (mask == 0) - emit_insn (gen_vec_set_lo__mask - (operands[0], operands[1], operands[2], - operands[4], operands[5])); + emit_insn (gen_vec_set_lo__mask (operands[0], operands[1], + operands[2], operands[4], + operands[5])); else - emit_insn (gen_vec_set_hi__mask - (operands[0], operands[1], operands[2], - operands[4], operands[5])); + emit_insn (gen_vec_set_hi__mask (operands[0], operands[1], + operands[2], operands[4], + operands[5])); DONE; }) @@ -12443,9 +12443,9 @@ (vec_select: (match_operand:V16FI 1 "register_operand" "v") (parallel [(const_int 8) (const_int 9) - (const_int 10) (const_int 11) - (const_int 12) (const_int 13) - (const_int 14) (const_int 15)]))))] + (const_int 10) (const_int 11) + (const_int 12) (const_int 13) + (const_int 14) (const_int 15)]))))] "TARGET_AVX512DQ" "vinsert32x8\t{$0x0, %2, %1, %0|%0, %1, %2, $0x0}" [(set_attr "type" "sselog") @@ -12456,13 +12456,13 @@ (define_insn "vec_set_hi_" [(set (match_operand:V16FI 0 "register_operand" "=v") (vec_concat:V16FI - (match_operand: 2 "nonimmediate_operand" "vm") (vec_select: (match_operand:V16FI 1 "register_operand" "v") (parallel [(const_int 0) (const_int 1) - (const_int 2) (const_int 3) - (const_int 4) (const_int 5) - (const_int 6) (const_int 7)]))))] + (const_int 2) (const_int 3) + (const_int 4) (const_int 5) + (const_int 6) (const_int 7)])) + (match_operand: 2 "nonimmediate_operand" "vm")))] "TARGET_AVX512DQ" "vinsert32x8\t{$0x1, %2, %1, %0|%0, %1, %2, $0x1}" [(set_attr "type" "sselog") @@ -12477,7 +12477,7 @@ (vec_select: (match_operand:V8FI 1 "register_operand" "v") (parallel [(const_int 4) (const_int 5) - (const_int 6) (const_int 7)]))))] + (const_int 6) (const_int 7)]))))] "TARGET_AVX512F" "vinsert64x4\t{$0x0, %2, %1, %0|%0, %1, %2, $0x0}" [(set_attr "type" "sselog") @@ -12488,11 +12488,11 @@ (define_insn "vec_set_hi_" [(set (match_operand:V8FI 0 "register_operand" "=v") (vec_concat:V8FI - (match_operand: 2 "nonimmediate_operand" "vm") (vec_select: (match_operand:V8FI 1 "register_operand" "v") (parallel [(const_int 0) (const_int 1) - (const_int 2) (const_int 3)]))))] + (const_int 2) (const_int 3)])) + (match_operand: 2 "nonimmediate_operand" "vm")))] "TARGET_AVX512F" "vinsert64x4\t{$0x1, %2, %1, %0|%0, %1, %2, $0x1}" [(set_attr "type" "sselog") @@ -13307,7 +13307,9 @@ (parallel [(match_operand:SI 2 "const_0_to__operand")])))] "TARGET_SSE2" - "%vpextr\t{%2, %1, %k0|%k0, %1, %2}" + "@ + %vpextr\t{%2, %1, %k0|%k0, %1, %2} + %vpextr\t{%2, %1, %0|%0, %1, %2}" [(set_attr "isa" "*,sse4") (set_attr "type" "sselog1") (set_attr "prefix_data16" "1") @@ -17267,7 +17269,14 @@ (match_operand: 1 "nonimmediate_operand" "vm") (parallel [(const_int 0)]))))] "TARGET_AVX512F" - "vbroadcast\t{%1, %0|%0, %1}" +{ + /* There is no DF broadcast (in AVX-512*) to 128b register. + Mimic it with integer variant. */ + if (mode == V2DFmode) + return "vpbroadcastq\t{%1, %0|%0, %1}"; + else + return "vbroadcast\t{%1, %0|%0, %1}"; +} [(set_attr "type" "ssemov") (set_attr "prefix" "evex") (set_attr "mode" "")]) @@ -17410,7 +17419,8 @@ vbroadcast\t{%1, %0|%0, %1} vbroadcast\t{%x1, %0|%0, %x1} #" - [(set_attr "type" "ssemov") + [(set_attr "isa" "*,*,noavx512vl") + (set_attr "type" "ssemov") (set_attr "prefix_extra" "1") (set_attr "prefix" "maybe_evex") (set_attr "mode" "")]) diff --git a/gcc/config/i386/vxworks.h b/gcc/config/i386/vxworks.h index b5960b1c6586..d92510e19b58 100644 --- a/gcc/config/i386/vxworks.h +++ b/gcc/config/i386/vxworks.h @@ -88,3 +88,10 @@ along with GCC; see the file COPYING3. If not see #undef ASM_PREFERRED_EH_DATA_FORMAT #define IX86_MAYBE_NO_LIBGCC_TFMODE + +/* Define this to be nonzero if static stack checking is supported. */ +#define STACK_CHECK_STATIC_BUILTIN 1 + +/* This platform supports the probing method of stack checking (RTP mode). + 8K is reserved in the stack to propagate exceptions in case of overflow. */ +#define STACK_CHECK_PROTECT 8192 diff --git a/gcc/config/i386/znver1.md b/gcc/config/i386/znver1.md index 3db3bed5bb79..7db0562a0744 100644 --- a/gcc/config/i386/znver1.md +++ b/gcc/config/i386/znver1.md @@ -328,7 +328,7 @@ (eq_attr "type" "fcmov")) "znver1-vector,znver1-fvector") -(define_insn_reservation "znver1_fp_mov_direct_load" 5 +(define_insn_reservation "znver1_fp_mov_direct_load" 8 (and (eq_attr "cpu" "znver1") (and (eq_attr "znver1_decode" "direct") (and (eq_attr "type" "fmov") @@ -349,7 +349,7 @@ (eq_attr "memory" "none")))) "znver1-double,znver1-fp3") -(define_insn_reservation "znver1_fp_mov_double_load" 9 +(define_insn_reservation "znver1_fp_mov_double_load" 12 (and (eq_attr "cpu" "znver1") (and (eq_attr "znver1_decode" "double") (and (eq_attr "type" "fmov") @@ -386,7 +386,7 @@ (eq_attr "type" "fcmp")))) "znver1-double,znver1-fp0,znver1-fp2") -(define_insn_reservation "znver1_fp_fcmp_load" 6 +(define_insn_reservation "znver1_fp_fcmp_load" 9 (and (eq_attr "cpu" "znver1") (and (eq_attr "memory" "none") (and (eq_attr "znver1_decode" "double") @@ -400,13 +400,13 @@ (eq_attr "memory" "none"))) "znver1-direct,znver1-fp0*5") -(define_insn_reservation "znver1_fp_op_mul_load" 9 +(define_insn_reservation "znver1_fp_op_mul_load" 12 (and (eq_attr "cpu" "znver1") (and (eq_attr "type" "fop,fmul") (eq_attr "memory" "load"))) "znver1-direct,znver1-load,znver1-fp0*5") -(define_insn_reservation "znver1_fp_op_imul_load" 13 +(define_insn_reservation "znver1_fp_op_imul_load" 16 (and (eq_attr "cpu" "znver1") (and (eq_attr "type" "fop,fmul") (and (eq_attr "fp_int_src" "true") @@ -419,13 +419,13 @@ (eq_attr "memory" "none"))) "znver1-direct,znver1-fp3*15") -(define_insn_reservation "znver1_fp_op_div_load" 19 +(define_insn_reservation "znver1_fp_op_div_load" 22 (and (eq_attr "cpu" "znver1") (and (eq_attr "type" "fdiv") (eq_attr "memory" "load"))) "znver1-direct,znver1-load,znver1-fp3*15") -(define_insn_reservation "znver1_fp_op_idiv_load" 24 +(define_insn_reservation "znver1_fp_op_idiv_load" 27 (and (eq_attr "cpu" "znver1") (and (eq_attr "type" "fdiv") (and (eq_attr "fp_int_src" "true") @@ -444,7 +444,7 @@ (eq_attr "memory" "none"))) "znver1-direct,znver1-fp0|znver1-fp1|znver1-fp3") -(define_insn_reservation "znver1_mmx_add_load" 5 +(define_insn_reservation "znver1_mmx_add_load" 8 (and (eq_attr "cpu" "znver1") (and (eq_attr "type" "mmxadd") (eq_attr "memory" "load"))) @@ -456,7 +456,7 @@ (eq_attr "memory" "none"))) "znver1-direct,znver1-fp0|znver1-fp3") -(define_insn_reservation "znver1_mmx_cmp_load" 5 +(define_insn_reservation "znver1_mmx_cmp_load" 8 (and (eq_attr "cpu" "znver1") (and (eq_attr "type" "mmxcmp") (eq_attr "memory" "load"))) @@ -468,7 +468,7 @@ (eq_attr "memory" "none"))) "znver1-direct,znver1-fp1|znver1-fp2") -(define_insn_reservation "znver1_mmx_cvt_pck_shuf_load" 5 +(define_insn_reservation "znver1_mmx_cvt_pck_shuf_load" 8 (and (eq_attr "cpu" "znver1") (and (eq_attr "type" "mmxcvt,sseshuf,sseshuf1") (eq_attr "memory" "load"))) @@ -480,7 +480,7 @@ (eq_attr "memory" "none"))) "znver1-direct,znver1-fp2") -(define_insn_reservation "znver1_mmx_shift_move_load" 5 +(define_insn_reservation "znver1_mmx_shift_move_load" 8 (and (eq_attr "cpu" "znver1") (and (eq_attr "type" "mmxshft,mmxmov") (eq_attr "memory" "load"))) @@ -498,7 +498,7 @@ (eq_attr "memory" "none"))) "znver1-direct,znver1-fp0*3") -(define_insn_reservation "znver1_mmx_load" 7 +(define_insn_reservation "znver1_mmx_load" 10 (and (eq_attr "cpu" "znver1") (and (eq_attr "type" "mmxmul") (eq_attr "memory" "load"))) @@ -511,7 +511,7 @@ (eq_attr "memory" "none")))) "znver1-double,znver1-fpu") -(define_insn_reservation "znver1_avx256_log_load" 5 +(define_insn_reservation "znver1_avx256_log_load" 8 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "V8SF,V4DF,OI") (and (eq_attr "type" "sselog") @@ -524,7 +524,7 @@ (eq_attr "memory" "none"))) "znver1-direct,znver1-fpu") -(define_insn_reservation "znver1_sse_log_load" 5 +(define_insn_reservation "znver1_sse_log_load" 8 (and (eq_attr "cpu" "znver1") (and (eq_attr "type" "sselog") (eq_attr "memory" "load"))) @@ -537,7 +537,7 @@ (eq_attr "memory" "none")))) "znver1-double,znver1-fp1|znver1-fp2") -(define_insn_reservation "znver1_avx256_log1_load" 5 +(define_insn_reservation "znver1_avx256_log1_load" 8 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "V8SF,V4DF,OI") (and (eq_attr "type" "sselog1") @@ -550,7 +550,7 @@ (eq_attr "memory" "none"))) "znver1-direct,znver1-fp1|znver1-fp2") -(define_insn_reservation "znver1_sse_log1_load" 5 +(define_insn_reservation "znver1_sse_log1_load" 8 (and (eq_attr "cpu" "znver1") (and (eq_attr "type" "sselog1") (eq_attr "memory" "!none"))) @@ -565,7 +565,7 @@ (eq_attr "memory" "none")))))) "znver1-direct,znver1-fp0|znver1-fp1") -(define_insn_reservation "znver1_sse_comi_load" 5 +(define_insn_reservation "znver1_sse_comi_load" 8 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "SF,DF,V4SF,V2DF") (and (eq_attr "prefix" "!vex") @@ -583,7 +583,7 @@ (eq_attr "memory" "none")))))) "znver1-double,znver1-fp0|znver1-fp1") -(define_insn_reservation "znver1_sse_comi_double_load" 7 +(define_insn_reservation "znver1_sse_comi_double_load" 10 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "V4SF,V2DF,TI") (and (eq_attr "prefix" "vex") @@ -600,7 +600,7 @@ (eq_attr "memory" "none"))))) "znver1-direct,znver1-fp1|znver1-fp2") -(define_insn_reservation "znver1_sse_test_load" 5 +(define_insn_reservation "znver1_sse_test_load" 8 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "SF,DF,V4SF,V2DF,TI") (and (eq_attr "prefix_extra" "1") @@ -642,7 +642,7 @@ (eq_attr "memory" "store")))) "znver1-direct,znver1-fpu,znver1-store") -(define_insn_reservation "znver1_sseavx_mov_load" 5 +(define_insn_reservation "znver1_sseavx_mov_load" 8 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "SF,DF,V4SF,V2DF,TI") (and (eq_attr "type" "ssemov") @@ -663,7 +663,7 @@ (eq_attr "memory" "store")))) "znver1-double,znver1-fpu,znver1-store") -(define_insn_reservation "znver1_avx256_mov_load" 5 +(define_insn_reservation "znver1_avx256_mov_load" 8 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "V8SF,V4DF,OI") (and (eq_attr "type" "ssemov") @@ -678,7 +678,7 @@ (eq_attr "memory" "none")))) "znver1-direct,znver1-fp2|znver1-fp3") -(define_insn_reservation "znver1_sseavx_add_load" 7 +(define_insn_reservation "znver1_sseavx_add_load" 10 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "SF,DF,V4SF,V2DF,TI") (and (eq_attr "type" "sseadd") @@ -692,7 +692,7 @@ (eq_attr "memory" "none")))) "znver1-double,znver1-fp2|znver1-fp3") -(define_insn_reservation "znver1_avx256_add_load" 7 +(define_insn_reservation "znver1_avx256_add_load" 10 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "V8SF,V4DF,OI") (and (eq_attr "type" "sseadd") @@ -706,7 +706,7 @@ (eq_attr "memory" "none")))) "znver1-direct,znver1-fp0|znver1-fp1") -(define_insn_reservation "znver1_sseavx_fma_load" 9 +(define_insn_reservation "znver1_sseavx_fma_load" 12 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "SF,DF,V4SF,V2DF") (and (eq_attr "type" "ssemuladd") @@ -720,7 +720,7 @@ (eq_attr "memory" "none")))) "znver1-double,znver1-fp0|znver1-fp1") -(define_insn_reservation "znver1_avx256_fma_load" 9 +(define_insn_reservation "znver1_avx256_fma_load" 12 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "V8SF,V4DF") (and (eq_attr "type" "ssemuladd") @@ -734,7 +734,7 @@ (eq_attr "memory" "none")))) "znver1-direct,znver1-fp0|znver1-fp1|znver1-fp3") -(define_insn_reservation "znver1_sseavx_iadd_load" 5 +(define_insn_reservation "znver1_sseavx_iadd_load" 8 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "DI,TI") (and (eq_attr "type" "sseiadd") @@ -748,7 +748,7 @@ (eq_attr "memory" "none")))) "znver1-double,znver1-fp0|znver1-fp1|znver1-fp3") -(define_insn_reservation "znver1_avx256_iadd_load" 5 +(define_insn_reservation "znver1_avx256_iadd_load" 8 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "OI") (and (eq_attr "type" "sseiadd") @@ -756,7 +756,7 @@ "znver1-double,znver1-load,znver1-fp0|znver1-fp1|znver1-fp3") ;; SSE conversions. -(define_insn_reservation "znver1_ssecvtsf_si_load" 9 +(define_insn_reservation "znver1_ssecvtsf_si_load" 12 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "SI") (and (eq_attr "type" "sseicvt") @@ -772,7 +772,7 @@ (eq_attr "memory" "none"))))) "znver1-double,znver1-fp3,znver1-ieu0") -(define_insn_reservation "znver1_ssecvtdf_si_load" 9 +(define_insn_reservation "znver1_ssecvtdf_si_load" 12 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "SI") (and (eq_attr "type" "sseicvt") @@ -789,7 +789,7 @@ (eq_attr "memory" "none"))) "znver1-direct,znver1-fp3") -(define_insn_reservation "znver1_ssecvt_load" 8 +(define_insn_reservation "znver1_ssecvt_load" 11 (and (eq_attr "cpu" "znver1") (and (eq_attr "type" "ssecvt") (eq_attr "memory" "load"))) @@ -803,7 +803,7 @@ (eq_attr "memory" "none")))) "znver1-direct,znver1-fp3*10") -(define_insn_reservation "znver1_ssediv_ss_ps_load" 14 +(define_insn_reservation "znver1_ssediv_ss_ps_load" 17 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "V4SF,SF") (and (eq_attr "type" "ssediv") @@ -817,7 +817,7 @@ (eq_attr "memory" "none")))) "znver1-direct,znver1-fp3*13") -(define_insn_reservation "znver1_ssediv_sd_pd_load" 17 +(define_insn_reservation "znver1_ssediv_sd_pd_load" 20 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "V2DF,DF") (and (eq_attr "type" "ssediv") @@ -831,7 +831,7 @@ (eq_attr "type" "ssediv")))) "znver1-double,znver1-fp3*12") -(define_insn_reservation "znver1_ssediv_avx256_ps_load" 16 +(define_insn_reservation "znver1_ssediv_avx256_ps_load" 19 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "V8SF") (and (eq_attr "type" "ssediv") @@ -845,7 +845,7 @@ (eq_attr "memory" "none")))) "znver1-double,znver1-fp3*15") -(define_insn_reservation "znver1_ssediv_avx256_pd_load" 18 +(define_insn_reservation "znver1_ssediv_avx256_pd_load" 22 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "V4DF") (and (eq_attr "type" "ssediv") @@ -859,7 +859,7 @@ (eq_attr "memory" "none")))) "znver1-direct,(znver1-fp0|znver1-fp1)*3") -(define_insn_reservation "znver1_ssemul_ss_ps_load" 7 +(define_insn_reservation "znver1_ssemul_ss_ps_load" 10 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "V4SF,SF") (and (eq_attr "type" "ssemul") @@ -873,7 +873,7 @@ (eq_attr "memory" "none")))) "znver1-double,(znver1-fp0|znver1-fp1)*3") -(define_insn_reservation "znver1_ssemul_avx256_ps_load" 7 +(define_insn_reservation "znver1_ssemul_avx256_ps_load" 10 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "V8SF") (and (eq_attr "type" "ssemul") @@ -887,7 +887,7 @@ (eq_attr "memory" "none")))) "znver1-direct,(znver1-fp0|znver1-fp1)*4") -(define_insn_reservation "znver1_ssemul_sd_pd_load" 8 +(define_insn_reservation "znver1_ssemul_sd_pd_load" 11 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "V2DF,DF") (and (eq_attr "type" "ssemul") @@ -902,7 +902,7 @@ (eq_attr "memory" "none"))))) "znver1-double,(znver1-fp0|znver1-fp1)*4") -(define_insn_reservation "znver1_ssemul_avx256_pd_load" 8 +(define_insn_reservation "znver1_ssemul_avx256_pd_load" 12 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "V4DF") (and (eq_attr "type" "ssemul") @@ -913,44 +913,44 @@ (define_insn_reservation "znver1_sseimul" 3 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "TI") - (and (eq_attr "type" "ssemul") + (and (eq_attr "type" "sseimul") (eq_attr "memory" "none")))) "znver1-direct,znver1-fp0*3") (define_insn_reservation "znver1_sseimul_avx256" 4 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "OI") - (and (eq_attr "type" "ssemul") + (and (eq_attr "type" "sseimul") (eq_attr "memory" "none")))) "znver1-double,znver1-fp0*4") -(define_insn_reservation "znver1_sseimul_load" 7 +(define_insn_reservation "znver1_sseimul_load" 10 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "TI") - (and (eq_attr "type" "ssemul") + (and (eq_attr "type" "sseimul") (eq_attr "memory" "load")))) "znver1-direct,znver1-load,znver1-fp0*3") -(define_insn_reservation "znver1_sseimul_avx256_load" 8 +(define_insn_reservation "znver1_sseimul_avx256_load" 11 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "OI") - (and (eq_attr "type" "ssemul") + (and (eq_attr "type" "sseimul") (eq_attr "memory" "load")))) "znver1-double,znver1-load,znver1-fp0*4") -(define_insn_reservation "znver1_sseimul_di" 4 +(define_insn_reservation "znver1_sseimul_di" 3 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "DI") (and (eq_attr "memory" "none") - (eq_attr "type" "ssemul")))) - "znver1-direct,znver1-fp0*4") + (eq_attr "type" "sseimul")))) + "znver1-direct,znver1-fp0*3") -(define_insn_reservation "znver1_sseimul_load_di" 8 +(define_insn_reservation "znver1_sseimul_load_di" 10 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "DI") - (and (eq_attr "type" "ssemul") + (and (eq_attr "type" "sseimul") (eq_attr "memory" "load")))) - "znver1-direct,znver1-load,znver1-fp0*4") + "znver1-direct,znver1-load,znver1-fp0*3") ;; SSE compares (define_insn_reservation "znver1_sse_cmp" 1 @@ -960,7 +960,7 @@ (eq_attr "memory" "none")))) "znver1-direct,znver1-fp0|znver1-fp1") -(define_insn_reservation "znver1_sse_cmp_load" 5 +(define_insn_reservation "znver1_sse_cmp_load" 8 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "SF,DF,V4SF,V2DF") (and (eq_attr "type" "ssecmp") @@ -974,7 +974,7 @@ (eq_attr "memory" "none")))) "znver1-double,znver1-fp0|znver1-fp1") -(define_insn_reservation "znver1_sse_cmp_avx256_load" 5 +(define_insn_reservation "znver1_sse_cmp_avx256_load" 8 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "V8SF,V4DF") (and (eq_attr "type" "ssecmp") @@ -988,7 +988,7 @@ (eq_attr "memory" "none")))) "znver1-direct,znver1-fp0|znver1-fp3") -(define_insn_reservation "znver1_sse_icmp_load" 5 +(define_insn_reservation "znver1_sse_icmp_load" 8 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "QI,HI,SI,DI,TI") (and (eq_attr "type" "ssecmp") @@ -1002,7 +1002,7 @@ (eq_attr "memory" "none")))) "znver1-double,znver1-fp0|znver1-fp3") -(define_insn_reservation "znver1_sse_icmp_avx256_load" 5 +(define_insn_reservation "znver1_sse_icmp_avx256_load" 8 (and (eq_attr "cpu" "znver1") (and (eq_attr "mode" "OI") (and (eq_attr "type" "ssecmp") diff --git a/gcc/config/moxie/moxiebox.h b/gcc/config/moxie/moxiebox.h index f67bfd67d858..502ffe121e10 100644 --- a/gcc/config/moxie/moxiebox.h +++ b/gcc/config/moxie/moxiebox.h @@ -39,6 +39,12 @@ along with GCC; see the file COPYING3. If not see #undef ASM_SPEC #define ASM_SPEC "-EL" +#undef CC1_SPEC +#define CC1_SPEC "-mel %{meb:%ethis target is little-endian}" + +#undef CC1PLUS_SPEC +#define CC1PLUS_SPEC CC1_SPEC + #undef MULTILIB_DEFAULTS #undef SIZE_TYPE diff --git a/gcc/config/nvptx/nvptx.c b/gcc/config/nvptx/nvptx.c index 33b495ffcd94..b088cf89bb96 100644 --- a/gcc/config/nvptx/nvptx.c +++ b/gcc/config/nvptx/nvptx.c @@ -160,15 +160,6 @@ nvptx_option_override (void) /* Assumes that it will see only hard registers. */ flag_var_tracking = 0; - if (write_symbols == DBX_DEBUG) - /* The stabs testcases want to know stabs isn't supported. */ - sorry ("stabs debug format not supported"); - - /* Actually we don't have any debug format, but don't be - unneccesarily noisy. */ - write_symbols = NO_DEBUG; - debug_info_level = DINFO_LEVEL_NONE; - if (nvptx_optimize < 0) nvptx_optimize = optimize > 0; diff --git a/gcc/config/pa/constraints.md b/gcc/config/pa/constraints.md index b90e8f6ddd8f..cd38e4509a01 100644 --- a/gcc/config/pa/constraints.md +++ b/gcc/config/pa/constraints.md @@ -106,7 +106,7 @@ (and (match_code "mem") (match_test "IS_LO_SUM_DLT_ADDR_P (XEXP (op, 0))"))) -(define_memory_constraint "Q" +(define_constraint "Q" "A memory operand that can be used as the destination operand of an integer store, or the source operand of an integer load. That is any memory operand that isn't a symbolic, indexed or lo_sum memory @@ -122,7 +122,7 @@ (and (match_code "mem") (match_test "IS_INDEX_ADDR_P (XEXP (op, 0))"))) -(define_memory_constraint "T" +(define_constraint "T" "A memory operand for floating-point loads and stores." (match_test "floating_point_store_memory_operand (op, mode)")) diff --git a/gcc/config/pa/pa.md b/gcc/config/pa/pa.md index 2587c0546481..75100d2d69f3 100644 --- a/gcc/config/pa/pa.md +++ b/gcc/config/pa/pa.md @@ -1229,9 +1229,10 @@ (define_insn "bswapdi2" [(set (match_operand:DI 0 "register_operand" "=&r") - (bswap:DI (match_operand:DI 1 "register_operand" "+r")))] + (bswap:DI (match_operand:DI 1 "register_operand" "r"))) + (clobber (match_scratch:DI 2 "=r"))] "TARGET_64BIT" - "permh,3210 %1,%1\;hshl %1,8,%0\;hshr,u %1,8,%1\;or %0,%1,%0" + "permh,3210 %1,%2\;hshl %2,8,%0\;hshr,u %2,8,%2\;or %0,%2,%0" [(set_attr "type" "multi") (set_attr "length" "16")]) diff --git a/gcc/config/rs6000/constraints.md b/gcc/config/rs6000/constraints.md index 9eca7572c442..ea15764e513c 100644 --- a/gcc/config/rs6000/constraints.md +++ b/gcc/config/rs6000/constraints.md @@ -272,4 +272,4 @@ usually better to use @samp{m} or @samp{es} in @code{asm} statements)" (define_constraint "j" "Zero vector constant" - (match_test "op == const0_rtx || op == CONST0_RTX (GET_MODE (op))")) + (match_test "op == const0_rtx || op == CONST0_RTX (mode)")) diff --git a/gcc/config/rs6000/predicates.md b/gcc/config/rs6000/predicates.md index 072291ef7d01..71fac765e24f 100644 --- a/gcc/config/rs6000/predicates.md +++ b/gcc/config/rs6000/predicates.md @@ -527,13 +527,14 @@ && mode != DImode) return 1; + /* 0.0D is not all zero bits. */ + if (DECIMAL_FLOAT_MODE_P (mode)) + return 0; + /* The constant 0.0 is easy under VSX. */ if (TARGET_VSX && SCALAR_FLOAT_MODE_P (mode) && op == CONST0_RTX (mode)) return 1; - if (DECIMAL_FLOAT_MODE_P (mode)) - return 0; - /* If we are using V.4 style PIC, consider all constants to be hard. */ if (flag_pic && DEFAULT_ABI == ABI_V4) return 0; diff --git a/gcc/config/rs6000/rs6000-c.c b/gcc/config/rs6000/rs6000-c.c index b6e42f6ecada..ceb80b216bae 100644 --- a/gcc/config/rs6000/rs6000-c.c +++ b/gcc/config/rs6000/rs6000-c.c @@ -216,7 +216,21 @@ rs6000_macro_to_expand (cpp_reader *pfile, const cpp_token *tok) else if (ident && (ident != C_CPP_HASHNODE (__vector_keyword))) { enum rid rid_code = (enum rid)(ident->rid_code); - if (ident->type == NT_MACRO) + enum node_type itype = ident->type; + /* If there is a function-like macro, check if it is going to be + invoked with or without arguments. Without following ( treat + it like non-macro, otherwise the following cpp_get_token eats + what should be preserved. */ + if (itype == NT_MACRO && cpp_fun_like_macro_p (ident)) + { + int idx2 = idx; + do + tok = cpp_peek_token (pfile, idx2++); + while (tok->type == CPP_PADDING); + if (tok->type != CPP_OPEN_PAREN) + itype = NT_VOID; + } + if (itype == NT_MACRO) { do (void) cpp_get_token (pfile); diff --git a/gcc/config/rs6000/rs6000-cpus.def b/gcc/config/rs6000/rs6000-cpus.def index 92fb71aed21a..275404a63ac2 100644 --- a/gcc/config/rs6000/rs6000-cpus.def +++ b/gcc/config/rs6000/rs6000-cpus.def @@ -44,7 +44,6 @@ #define ISA_2_6_MASKS_SERVER (ISA_2_5_MASKS_SERVER \ | OPTION_MASK_POPCNTD \ | OPTION_MASK_ALTIVEC \ - | OPTION_MASK_FLOAT128 \ | OPTION_MASK_VSX \ | OPTION_MASK_UPPER_REGS_DF) diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c index 5b03f9e7d37f..fd4b7cc5a7ee 100644 --- a/gcc/config/rs6000/rs6000.c +++ b/gcc/config/rs6000/rs6000.c @@ -22283,6 +22283,9 @@ rs6000_expand_atomic_compare_and_swap (rtx operands[]) if (mode != TImode && !reg_or_short_operand (oldval, mode)) oldval = copy_to_mode_reg (mode, oldval); + if (reg_overlap_mentioned_p (retval, newval)) + newval = copy_to_reg (newval); + mem = rs6000_pre_atomic_barrier (mem, mod_s); label1 = NULL_RTX; diff --git a/gcc/config/rs6000/rs6000.md b/gcc/config/rs6000/rs6000.md index 0299a0002af2..ef1dea82c848 100644 --- a/gcc/config/rs6000/rs6000.md +++ b/gcc/config/rs6000/rs6000.md @@ -428,6 +428,16 @@ (SD "REAL_VALUE_TO_TARGET_DECIMAL32") (DD "REAL_VALUE_TO_TARGET_DECIMAL64")]) +; Whether 0.0 has an all-zero bit pattern +(define_mode_attr zero_fp [(SF "j") + (DF "j") + (TF "j") + (IF "j") + (KF "j") + (SD "wn") + (DD "wn") + (TD "wn")]) + ; Definitions for load to 32-bit fpr register (define_mode_attr f32_lr [(SF "f") (SD "wz")]) (define_mode_attr f32_lr2 [(SF "wb") (SD "wn")]) @@ -5387,10 +5397,12 @@ xsrdpiz %x0,%x1" [(set_attr "type" "fp")]) -;; Since FCTIWZ doesn't sign extend the upper bits, we have to do a store and a -;; load to properly sign extend the value, but at least doing a store, load -;; into a GPR to sign extend, a store from the GPR and a load back into the FPR -;; if we have 32-bit memory ops +;; Opitmize converting SF/DFmode to signed SImode and back to SF/DFmode. This +;; optimization prevents on ISA 2.06 systems and earlier having to store the +;; value from the FPR/vector unit to the stack, load the value into a GPR, sign +;; extend it, store it back on the stack from the GPR, load it back into the +;; FP/vector unit to do the rounding. If we have direct move (ISA 2.07), +;; disable using store and load to sign/zero extend the value. (define_insn_and_split "*round322_fprs" [(set (match_operand:SFDF 0 "gpc_reg_operand" "=d") (float:SFDF @@ -5399,7 +5411,7 @@ (clobber (match_scratch:DI 3 "=d"))] "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT && && TARGET_LFIWAX && TARGET_STFIWX && TARGET_FCFID - && can_create_pseudo_p ()" + && !TARGET_DIRECT_MOVE && can_create_pseudo_p ()" "#" "" [(pc)] @@ -5431,7 +5443,7 @@ (clobber (match_scratch:DI 2 "=d")) (clobber (match_scratch:DI 3 "=d"))] "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT - && TARGET_LFIWZX && TARGET_STFIWX && TARGET_FCFIDU + && TARGET_LFIWZX && TARGET_STFIWX && TARGET_FCFIDU && !TARGET_DIRECT_MOVE && can_create_pseudo_p ()" "#" "" @@ -6470,7 +6482,7 @@ (define_insn "mov_hardfloat" [(set (match_operand:FMOVE32 0 "nonimmediate_operand" "=!r,!r,m,f,,,!r,,,,,,Z,?,?r,*c*l,!r,*h") - (match_operand:FMOVE32 1 "input_operand" "r,m,r,f,,j,j,,,,,Z,,r,,r,h,0"))] + (match_operand:FMOVE32 1 "input_operand" "r,m,r,f,,,,,,,,Z,,r,,r,h,0"))] "(gpc_reg_operand (operands[0], mode) || gpc_reg_operand (operands[1], mode)) && (TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT)" @@ -6610,7 +6622,7 @@ (define_insn "*mov_hardfloat32" [(set (match_operand:FMOVE64 0 "nonimmediate_operand" "=m,d,d,,Z,,o,,,!r,Y,r,!r") - (match_operand:FMOVE64 1 "input_operand" "d,m,d,Z,,o,,,j,j,r,Y,r"))] + (match_operand:FMOVE64 1 "input_operand" "d,m,d,Z,,o,,,,,r,Y,r"))] "! TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT && (gpc_reg_operand (operands[0], mode) || gpc_reg_operand (operands[1], mode))" @@ -6648,7 +6660,7 @@ ; List Y->r and r->Y before r->r for reload. (define_insn "*mov_hardfloat64" [(set (match_operand:FMOVE64 0 "nonimmediate_operand" "=m,d,d,,o,,Z,,,!r,Y,r,!r,*c*l,!r,*h,r,wg,r,") - (match_operand:FMOVE64 1 "input_operand" "d,m,d,o,,Z,,,j,j,r,Y,r,r,h,0,wg,r,,r"))] + (match_operand:FMOVE64 1 "input_operand" "d,m,d,o,,Z,,,,,r,Y,r,r,h,0,wg,r,,r"))] "TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT && (gpc_reg_operand (operands[0], mode) || gpc_reg_operand (operands[1], mode))" @@ -6711,7 +6723,7 @@ (define_insn_and_split "*mov_64bit_dm" [(set (match_operand:FMOVE128_FPR 0 "nonimmediate_operand" "=m,d,d,d,Y,r,r,r,wh") - (match_operand:FMOVE128_FPR 1 "input_operand" "d,m,d,j,r,jY,r,wh,r"))] + (match_operand:FMOVE128_FPR 1 "input_operand" "d,m,d,,r,Y,r,wh,r"))] "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_POWERPC64 && FLOAT128_2REG_P (mode) && (mode != TDmode || WORDS_BIG_ENDIAN) @@ -6724,8 +6736,8 @@ [(set_attr "length" "8,8,8,8,12,12,8,8,8")]) (define_insn_and_split "*movtd_64bit_nodm" - [(set (match_operand:TD 0 "nonimmediate_operand" "=m,d,d,d,Y,r,r") - (match_operand:TD 1 "input_operand" "d,m,d,j,r,jY,r"))] + [(set (match_operand:TD 0 "nonimmediate_operand" "=m,d,d,Y,r,r") + (match_operand:TD 1 "input_operand" "d,m,d,r,Y,r"))] "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_POWERPC64 && !WORDS_BIG_ENDIAN && (gpc_reg_operand (operands[0], TDmode) || gpc_reg_operand (operands[1], TDmode))" @@ -6733,11 +6745,11 @@ "&& reload_completed" [(pc)] { rs6000_split_multireg_move (operands[0], operands[1]); DONE; } - [(set_attr "length" "8,8,8,8,12,12,8")]) + [(set_attr "length" "8,8,8,12,12,8")]) (define_insn_and_split "*mov_32bit" [(set (match_operand:FMOVE128_FPR 0 "nonimmediate_operand" "=m,d,d,d,Y,r,r") - (match_operand:FMOVE128_FPR 1 "input_operand" "d,m,d,j,r,jY,r"))] + (match_operand:FMOVE128_FPR 1 "input_operand" "d,m,d,,r,Y,r"))] "TARGET_HARD_FLOAT && TARGET_FPRS && !TARGET_POWERPC64 && (FLOAT128_2REG_P (mode) || int_reg_operand_not_pseudo (operands[0], mode) @@ -11907,7 +11919,7 @@ (const_int 1)) (label_ref (match_operand 0 "" "")) (pc))) - (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*c*l") + (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*d*c*l") (plus:P (match_dup 1) (const_int -1))) (clobber (match_scratch:CC 3 "=X,&x,&x,&x")) @@ -11931,7 +11943,7 @@ (const_int 1)) (pc) (label_ref (match_operand 0 "" "")))) - (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*c*l") + (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*d*c*l") (plus:P (match_dup 1) (const_int -1))) (clobber (match_scratch:CC 3 "=X,&x,&x,&x")) @@ -11957,7 +11969,7 @@ (const_int 1)) (label_ref (match_operand 0 "" "")) (pc))) - (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*c*l") + (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*d*c*l") (plus:P (match_dup 1) (const_int -1))) (clobber (match_scratch:CC 3 "=X,&x,&x,&x")) @@ -11981,7 +11993,7 @@ (const_int 1)) (pc) (label_ref (match_operand 0 "" "")))) - (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*c*l") + (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*d*c*l") (plus:P (match_dup 1) (const_int -1))) (clobber (match_scratch:CC 3 "=X,&x,&x,&x")) @@ -12008,7 +12020,7 @@ (const_int 1)]) (match_operand 5 "" "") (match_operand 6 "" ""))) - (set (match_operand:P 0 "gpc_reg_operand" "") + (set (match_operand:P 0 "int_reg_operand" "") (plus:P (match_dup 1) (const_int -1))) (clobber (match_scratch:CC 3 "")) (clobber (match_scratch:P 4 ""))] diff --git a/gcc/config/rs6000/vxworks.h b/gcc/config/rs6000/vxworks.h index 901a81c78d92..7b90fda3f8fa 100644 --- a/gcc/config/rs6000/vxworks.h +++ b/gcc/config/rs6000/vxworks.h @@ -138,3 +138,10 @@ VXWORKS_ADDITIONAL_CPP_SPEC /* No _mcount profiling on VxWorks. */ #undef FUNCTION_PROFILER #define FUNCTION_PROFILER(FILE,LABELNO) VXWORKS_FUNCTION_PROFILER(FILE,LABELNO) + +/* Define this to be nonzero if static stack checking is supported. */ +#define STACK_CHECK_STATIC_BUILTIN 1 + +/* This platform supports the probing method of stack checking (RTP mode). + 8K is reserved in the stack to propagate exceptions in case of overflow. */ +#define STACK_CHECK_PROTECT 8192 diff --git a/gcc/config/rs6000/vxworksae.h b/gcc/config/rs6000/vxworksae.h index e607973252a9..97e1c70495ff 100644 --- a/gcc/config/rs6000/vxworksae.h +++ b/gcc/config/rs6000/vxworksae.h @@ -21,3 +21,8 @@ along with GCC; see the file COPYING3. If not see /* VxWorksAE for E500V2 expects a specific CPU value to designate 8548. */ #undef VXCPU_FOR_8548 #define VXCPU_FOR_8548 "PPCE500V2" + +/* This platform supports the probing method of stack checking and + requires 4K of space for executing a possible last chance handler. */ +#undef STACK_CHECK_PROTECT +#define STACK_CHECK_PROTECT 4096 diff --git a/gcc/config/rx/rx.c b/gcc/config/rx/rx.c index 88cf18cf7b4c..3a374a01c70a 100644 --- a/gcc/config/rx/rx.c +++ b/gcc/config/rx/rx.c @@ -467,7 +467,7 @@ rx_print_operand_address (FILE * file, machine_mode /*mode*/, rtx addr) static void rx_print_integer (FILE * file, HOST_WIDE_INT val) { - if (IN_RANGE (val, -64, 64)) + if (val < 64) fprintf (file, HOST_WIDE_INT_PRINT_DEC, val); else fprintf (file, diff --git a/gcc/config/s390/constraints.md b/gcc/config/s390/constraints.md index c1d2c8ec8f81..78577002ad54 100644 --- a/gcc/config/s390/constraints.md +++ b/gcc/config/s390/constraints.md @@ -36,6 +36,7 @@ ;; jyy: constant consisting of byte chunks being either 0 or 0xff ;; jKK: constant vector with all elements having the same value and ;; matching K constraint +;; jm6: An integer operand with the lowest order 6 bits all ones. ;; t -- Access registers 36 and 37. ;; v -- Vector registers v0-v31. ;; C -- A signed 8-bit constant (-128..127) @@ -78,7 +79,7 @@ ;; does *not* refer to a literal pool entry. ;; U -- Pointer with short displacement. (deprecated - use ZQZR) ;; W -- Pointer with long displacement. (deprecated - use ZSZT) -;; Y -- Shift count operand. +;; Y -- Address style operand without index. ;; ZQ -- Pointer without index register and with short displacement. ;; ZR -- Pointer with index register and short displacement. ;; ZS -- Pointer without index register but with long displacement. @@ -188,12 +189,12 @@ (define_address_constraint "Y" - "Shift count operand" + "Address style operand without index register" -;; Simply check for the basic form of a shift count. Reload will -;; take care of making sure we have a proper base register. +;; Simply check for base + offset style operands. Reload will take +;; care of making sure we have a proper base register. - (match_test "s390_decompose_shift_count (op, NULL, NULL)" )) + (match_test "s390_decompose_addrstyle_without_index (op, NULL, NULL)" )) ;; N -- Multiple letter constraint followed by 4 parameter letters. @@ -415,6 +416,9 @@ (match_test "const_vec_duplicate_p (op)")) (match_test "satisfies_constraint_K (XVECEXP (op, 0, 0))"))) +(define_constraint "jm6" + "@internal An integer operand with the lowest order 6 bits all ones." + (match_operand 0 "const_int_6bitset_operand")) ;; ;; Memory constraints follow. diff --git a/gcc/config/s390/predicates.md b/gcc/config/s390/predicates.md index cbc809214798..e66f4a4110b8 100644 --- a/gcc/config/s390/predicates.md +++ b/gcc/config/s390/predicates.md @@ -87,7 +87,7 @@ ;; Return true if OP is a valid operand as scalar shift count or setmem. -(define_predicate "shift_count_or_setmem_operand" +(define_predicate "setmem_operand" (match_code "reg, subreg, plus, const_int") { HOST_WIDE_INT offset; @@ -98,7 +98,7 @@ return false; /* Extract base register and offset. */ - if (!s390_decompose_shift_count (op, &base, &offset)) + if (!s390_decompose_addrstyle_without_index (op, &base, &offset)) return false; /* Don't allow any non-base hard registers. Doing so without @@ -115,6 +115,10 @@ return true; }) +; An integer operand with the lowest order 6 bits all ones. +(define_predicate "const_int_6bitset_operand" + (and (match_code "const_int") + (match_test "(INTVAL (op) & 63) == 63"))) (define_predicate "nonzero_shift_count_operand" (and (match_code "const_int") (match_test "IN_RANGE (INTVAL (op), 1, GET_MODE_BITSIZE (mode) - 1)"))) diff --git a/gcc/config/s390/s390-protos.h b/gcc/config/s390/s390-protos.h index 792eaa710531..2ccf0bbb0ab1 100644 --- a/gcc/config/s390/s390-protos.h +++ b/gcc/config/s390/s390-protos.h @@ -139,7 +139,8 @@ extern rtx_insn *s390_load_got (void); extern rtx s390_get_thread_pointer (void); extern void s390_emit_tpf_eh_return (rtx); extern bool s390_legitimate_address_without_index_p (rtx); -extern bool s390_decompose_shift_count (rtx, rtx *, HOST_WIDE_INT *); +extern bool s390_decompose_addrstyle_without_index (rtx, rtx *, + HOST_WIDE_INT *); extern int s390_branch_condition_mask (rtx); extern int s390_compare_and_branch_condition_mask (rtx); extern bool s390_extzv_shift_ok (int, int, unsigned HOST_WIDE_INT); diff --git a/gcc/config/s390/s390.c b/gcc/config/s390/s390.c index cd53b15f1122..4f219bee17d0 100644 --- a/gcc/config/s390/s390.c +++ b/gcc/config/s390/s390.c @@ -2817,9 +2817,7 @@ s390_decompose_address (rtx addr, struct s390_address *out) return false; } - if (!REG_P (base) - || (GET_MODE (base) != SImode - && GET_MODE (base) != Pmode)) + if (!REG_P (base) || GET_MODE (base) != Pmode) return false; if (REGNO (base) == STACK_POINTER_REGNUM @@ -2865,9 +2863,7 @@ s390_decompose_address (rtx addr, struct s390_address *out) return false; } - if (!REG_P (indx) - || (GET_MODE (indx) != SImode - && GET_MODE (indx) != Pmode)) + if (!REG_P (indx) || GET_MODE (indx) != Pmode) return false; if (REGNO (indx) == STACK_POINTER_REGNUM @@ -2986,26 +2982,29 @@ s390_decompose_address (rtx addr, struct s390_address *out) return true; } -/* Decompose a RTL expression OP for a shift count into its components, - and return the base register in BASE and the offset in OFFSET. +/* Decompose a RTL expression OP for an address style operand into its + components, and return the base register in BASE and the offset in + OFFSET. While OP looks like an address it is never supposed to be + used as such. - Return true if OP is a valid shift count, false if not. */ + Return true if OP is a valid address operand, false if not. */ bool -s390_decompose_shift_count (rtx op, rtx *base, HOST_WIDE_INT *offset) +s390_decompose_addrstyle_without_index (rtx op, rtx *base, + HOST_WIDE_INT *offset) { - HOST_WIDE_INT off = 0; + rtx off = NULL_RTX; /* We can have an integer constant, an address register, or a sum of the two. */ - if (GET_CODE (op) == CONST_INT) + if (CONST_SCALAR_INT_P (op)) { - off = INTVAL (op); + off = op; op = NULL_RTX; } - if (op && GET_CODE (op) == PLUS && GET_CODE (XEXP (op, 1)) == CONST_INT) + if (op && GET_CODE (op) == PLUS && CONST_SCALAR_INT_P (XEXP (op, 1))) { - off = INTVAL (XEXP (op, 1)); + off = XEXP (op, 1); op = XEXP (op, 0); } while (op && GET_CODE (op) == SUBREG) @@ -3015,7 +3014,18 @@ s390_decompose_shift_count (rtx op, rtx *base, HOST_WIDE_INT *offset) return false; if (offset) - *offset = off; + { + if (off == NULL_RTX) + *offset = 0; + else if (CONST_INT_P (off)) + *offset = INTVAL (off); + else if (CONST_WIDE_INT_P (off)) + /* The offset will anyway be cut down to 12 bits so take just + the lowest order chunk of the wide int. */ + *offset = CONST_WIDE_INT_ELT (off, 0); + else + gcc_unreachable (); + } if (base) *base = op; @@ -3196,7 +3206,7 @@ s390_mem_constraint (const char *str, rtx op) case 'Y': /* Simply check for the basic form of a shift count. Reload will take care of making sure we have a proper base register. */ - if (!s390_decompose_shift_count (op, NULL, NULL)) + if (!s390_decompose_addrstyle_without_index (op, NULL, NULL)) return 0; break; case 'Z': @@ -6871,13 +6881,13 @@ s390_delegitimize_address (rtx orig_x) instead the rightmost bits are interpreted as the value. */ static void -print_shift_count_operand (FILE *file, rtx op) +print_addrstyle_operand (FILE *file, rtx op) { HOST_WIDE_INT offset; rtx base; /* Extract base register and offset. */ - if (!s390_decompose_shift_count (op, &base, &offset)) + if (!s390_decompose_addrstyle_without_index (op, &base, &offset)) gcc_unreachable (); /* Sanity check. */ @@ -7173,7 +7183,8 @@ print_operand_address (FILE *file, rtx addr) 'O': print only the displacement of a memory reference or address. 'R': print only the base register of a memory reference or address. 'S': print S-type memory reference (base+displacement). - 'Y': print shift count operand. + 'Y': print address style operand without index (e.g. shift count or setmem + operand). 'b': print integer X as if it's an unsigned byte. 'c': print integer X as if it's an signed byte. @@ -7341,7 +7352,7 @@ print_operand (FILE *file, rtx x, int code) break; case 'Y': - print_shift_count_operand (file, x); + print_addrstyle_operand (file, x); return; } diff --git a/gcc/config/s390/s390.md b/gcc/config/s390/s390.md index 8f92018f0b05..5a9f1c8a6066 100644 --- a/gcc/config/s390/s390.md +++ b/gcc/config/s390/s390.md @@ -338,6 +338,39 @@ (VR31_REGNUM 53) ]) +; Rounding modes for binary floating point numbers +(define_constants + [(BFP_RND_CURRENT 0) + (BFP_RND_NEAREST_TIE_AWAY_FROM_0 1) + (BFP_RND_PREP_FOR_SHORT_PREC 3) + (BFP_RND_NEAREST_TIE_TO_EVEN 4) + (BFP_RND_TOWARD_0 5) + (BFP_RND_TOWARD_INF 6) + (BFP_RND_TOWARD_MINF 7)]) + +; Rounding modes for decimal floating point numbers +; 1-7 were introduced with the floating point extension facility +; available with z196 +; With these rounding modes (1-7) a quantum exception might occur +; which is suppressed for the other modes. +(define_constants + [(DFP_RND_CURRENT 0) + (DFP_RND_NEAREST_TIE_AWAY_FROM_0_QUANTEXC 1) + (DFP_RND_CURRENT_QUANTEXC 2) + (DFP_RND_PREP_FOR_SHORT_PREC_QUANTEXC 3) + (DFP_RND_NEAREST_TIE_TO_EVEN_QUANTEXC 4) + (DFP_RND_TOWARD_0_QUANTEXC 5) + (DFP_RND_TOWARD_INF_QUANTEXC 6) + (DFP_RND_TOWARD_MINF_QUANTEXC 7) + (DFP_RND_NEAREST_TIE_TO_EVEN 8) + (DFP_RND_TOWARD_0 9) + (DFP_RND_TOWARD_INF 10) + (DFP_RND_TOWARD_MINF 11) + (DFP_RND_NEAREST_TIE_AWAY_FROM_0 12) + (DFP_RND_NEAREST_TIE_TO_0 13) + (DFP_RND_AWAY_FROM_0 14) + (DFP_RND_PREP_FOR_SHORT_PREC 15)]) + ;; ;; PFPO GPR0 argument format ;; @@ -366,7 +399,7 @@ ;; Used to determine defaults for length and other attribute values. (define_attr "op_type" - "NN,E,RR,RRE,RX,RS,RSI,RI,SI,S,SS,SSE,RXE,RSE,RIL,RIE,RXY,RSY,SIY,RRF,RRR,SIL,RRS,RIS,VRI,VRR,VRS,VRV,VRX" + "NN,E,RR,RRE,RX,RS,RSI,RI,SI,S,SS,SSE,RXE,RSE,RIL,RIE,RXY,RSY,SIY,RRF,SIL,RRS,RIS,VRI,VRR,VRS,VRV,VRX" (const_string "NN")) ;; Instruction type attribute used for scheduling. @@ -393,7 +426,7 @@ ;; reg: Instruction does not use the agen unit (define_attr "atype" "agen,reg" - (if_then_else (eq_attr "op_type" "E,RR,RI,RRE,RSI,RIL,RIE,RRF,RRR") + (if_then_else (eq_attr "op_type" "E,RR,RI,RRE,RSI,RIL,RIE,RRF") (const_string "reg") (const_string "agen"))) @@ -434,8 +467,8 @@ ;; Length in bytes. (define_attr "length" "" - (cond [(eq_attr "op_type" "E,RR") (const_int 2) - (eq_attr "op_type" "RX,RI,RRE,RS,RSI,S,SI,RRF,RRR") (const_int 4)] + (cond [(eq_attr "op_type" "E,RR") (const_int 2) + (eq_attr "op_type" "RX,RI,RRE,RS,RSI,S,SI,RRF") (const_int 4)] (const_int 6))) @@ -618,27 +651,14 @@ ;; fp register operands. The following attributes allow to merge the bfp and ;; dfp variants in a single insn definition. -;; This attribute is used to set op_type accordingly. -(define_mode_attr RRer [(TF "RRE") (DF "RRE") (SF "RRE") (TD "RRR") - (DD "RRR") (SD "RRR")]) - -;; This attribute is used in the operand constraint list in order to have the -;; first and the second operand match for bfp modes. -(define_mode_attr f0 [(TF "0") (DF "0") (SF "0") (TD "f") (DD "f") (DD "f")]) - -;; This attribute is used to merge the scalar vector instructions into -;; the FP patterns. For non-supported modes (all but DF) it expands -;; to constraints which are supposed to be matched by an earlier -;; variant. -(define_mode_attr v0 [(TF "0") (DF "v") (SF "0") (TD "0") (DD "0") (DD "0") (TI "0") (DI "v") (SI "0")]) -(define_mode_attr vf [(TF "f") (DF "v") (SF "f") (TD "f") (DD "f") (DD "f") (TI "f") (DI "v") (SI "f")]) -(define_mode_attr vd [(TF "d") (DF "v") (SF "d") (TD "d") (DD "d") (DD "d") (TI "d") (DI "v") (SI "d")]) - -;; This attribute is used in the operand list of the instruction to have an -;; additional operand for the dfp instructions. -(define_mode_attr op1 [(TF "") (DF "") (SF "") - (TD "%1,") (DD "%1,") (SD "%1,")]) - +;; These mode attributes are supposed to be used in the `enabled' insn +;; attribute to disable certain alternatives for certain modes. +(define_mode_attr nBFP [(TF "0") (DF "0") (SF "0") (TD "*") (DD "*") (DD "*")]) +(define_mode_attr nDFP [(TF "*") (DF "*") (SF "*") (TD "0") (DD "0") (DD "0")]) +(define_mode_attr DSF [(TF "0") (DF "*") (SF "*") (TD "0") (DD "0") (SD "0")]) +(define_mode_attr DFDI [(TF "0") (DF "*") (SF "0") + (TD "0") (DD "0") (DD "0") + (TI "0") (DI "*") (SI "0")]) ;; This attribute is used in the operand constraint list ;; for instructions dealing with the sign bit of 32 or 64bit fp values. @@ -648,10 +668,6 @@ ;; target operand uses the same fp register. (define_mode_attr fT0 [(TF "0") (DF "f") (SF "f")]) -;; In FP templates, "" will expand to "f" in TFmode and "R" otherwise. -;; This is used to disable the memory alternative in TFmode patterns. -(define_mode_attr Rf [(TF "f") (DF "R") (SF "R") (TD "f") (DD "f") (SD "f")]) - ;; This attribute adds b for bfp instructions and t for dfp instructions and is used ;; within instruction mnemonics. (define_mode_attr bt [(TF "b") (DF "b") (SF "b") (TD "t") (DD "t") (SD "t")]) @@ -758,6 +774,8 @@ (define_mode_attr asm_fcmp [(CCVEQ "e") (CCVFH "h") (CCVFHE "he")]) (define_mode_attr insn_cmp [(CCVEQ "eq") (CCVH "h") (CCVHU "hl") (CCVFH "h") (CCVFHE "he")]) +;; Subst pattern definitions +(include "subst.md") (include "vector.md") @@ -1260,13 +1278,14 @@ (define_insn "*cmp_ccs" [(set (reg CC_REGNUM) (compare (match_operand:FP 0 "register_operand" "f,f") - (match_operand:FP 1 "general_operand" "f,")))] + (match_operand:FP 1 "general_operand" "f,R")))] "s390_match_ccmode(insn, CCSmode) && TARGET_HARD_FLOAT" "@ cr\t%0,%1 cb\t%0,%1" [(set_attr "op_type" "RRE,RXE") - (set_attr "type" "fsimp")]) + (set_attr "type" "fsimp") + (set_attr "enabled" "*,")]) ; wfcedbs, wfchdbs, wfchedbs (define_insn "*vec_cmpdf_cconly" @@ -3310,7 +3329,7 @@ [(parallel [(clobber (match_dup 1)) (set (match_operand:BLK 0 "memory_operand" "") - (unspec:BLK [(match_operand:P 2 "shift_count_or_setmem_operand" "") + (unspec:BLK [(match_operand:P 2 "setmem_operand" "") (match_dup 4)] UNSPEC_REPLICATE_BYTE)) (use (match_dup 3)) (clobber (reg:CC CC_REGNUM))])] @@ -3340,7 +3359,7 @@ (define_insn "*setmem_long" [(clobber (match_operand: 0 "register_operand" "=d")) (set (mem:BLK (subreg:P (match_operand: 3 "register_operand" "0") 0)) - (unspec:BLK [(match_operand:P 2 "shift_count_or_setmem_operand" "Y") + (unspec:BLK [(match_operand:P 2 "setmem_operand" "Y") (subreg:P (match_dup 3) )] UNSPEC_REPLICATE_BYTE)) (use (match_operand: 1 "register_operand" "d")) @@ -3354,7 +3373,7 @@ [(clobber (match_operand: 0 "register_operand" "=d")) (set (mem:BLK (subreg:P (match_operand: 3 "register_operand" "0") 0)) (unspec:BLK [(and:P - (match_operand:P 2 "shift_count_or_setmem_operand" "Y") + (match_operand:P 2 "setmem_operand" "Y") (match_operand:P 4 "const_int_operand" "n")) (subreg:P (match_dup 3) )] UNSPEC_REPLICATE_BYTE)) @@ -3372,7 +3391,7 @@ (define_insn "*setmem_long_31z" [(clobber (match_operand:TI 0 "register_operand" "=d")) (set (mem:BLK (subreg:SI (match_operand:TI 3 "register_operand" "0") 4)) - (unspec:BLK [(match_operand:SI 2 "shift_count_or_setmem_operand" "Y") + (unspec:BLK [(match_operand:SI 2 "setmem_operand" "Y") (subreg:SI (match_dup 3) 12)] UNSPEC_REPLICATE_BYTE)) (use (match_operand:TI 1 "register_operand" "d")) (clobber (reg:CC CC_REGNUM))] @@ -3385,8 +3404,8 @@ [(clobber (match_operand:TI 0 "register_operand" "=d")) (set (mem:BLK (subreg:SI (match_operand:TI 3 "register_operand" "0") 4)) (unspec:BLK [(and:SI - (match_operand:SI 2 "shift_count_or_setmem_operand" "Y") - (match_operand:SI 4 "const_int_operand" "n")) + (match_operand:SI 2 "setmem_operand" "Y") + (match_operand:SI 4 "const_int_operand" "n")) (subreg:SI (match_dup 3) 12)] UNSPEC_REPLICATE_BYTE)) (use (match_operand:TI 1 "register_operand" "d")) (clobber (reg:CC CC_REGNUM))] @@ -4496,7 +4515,7 @@ [(parallel [(set (match_operand:DI 0 "register_operand" "") (unsigned_fix:DI (match_operand:DD 1 "register_operand" ""))) - (unspec:DI [(const_int 5)] UNSPEC_ROUND) + (unspec:DI [(const_int DFP_RND_TOWARD_0)] UNSPEC_ROUND) (clobber (reg:CC CC_REGNUM))])] "TARGET_HARD_DFP" @@ -4521,11 +4540,13 @@ LT, NULL_RTX, VOIDmode, 0, label1); emit_insn (gen_subtd3 (temp, temp, const_double_from_real_value (sub, TDmode))); - emit_insn (gen_fix_trunctddi2_dfp (operands[0], temp, GEN_INT (11))); + emit_insn (gen_fix_trunctddi2_dfp (operands[0], temp, + GEN_INT (DFP_RND_TOWARD_MINF))); emit_jump (label2); emit_label (label1); - emit_insn (gen_fix_truncdddi2_dfp (operands[0], operands[1], GEN_INT (9))); + emit_insn (gen_fix_truncdddi2_dfp (operands[0], operands[1], + GEN_INT (DFP_RND_TOWARD_0))); emit_label (label2); DONE; } @@ -4535,7 +4556,7 @@ [(parallel [(set (match_operand:DI 0 "register_operand" "") (unsigned_fix:DI (match_operand:TD 1 "register_operand" ""))) - (unspec:DI [(const_int 5)] UNSPEC_ROUND) + (unspec:DI [(const_int DFP_RND_TOWARD_0)] UNSPEC_ROUND) (clobber (reg:CC CC_REGNUM))])] "TARGET_HARD_DFP" @@ -4556,11 +4577,13 @@ LT, NULL_RTX, VOIDmode, 0, label1); emit_insn (gen_subtd3 (temp, operands[1], const_double_from_real_value (sub, TDmode))); - emit_insn (gen_fix_trunctddi2_dfp (operands[0], temp, GEN_INT (11))); + emit_insn (gen_fix_trunctddi2_dfp (operands[0], temp, + GEN_INT (DFP_RND_TOWARD_MINF))); emit_jump (label2); emit_label (label1); - emit_insn (gen_fix_trunctddi2_dfp (operands[0], operands[1], GEN_INT (9))); + emit_insn (gen_fix_trunctddi2_dfp (operands[0], operands[1], + GEN_INT (DFP_RND_TOWARD_0))); emit_label (label2); DONE; } @@ -4575,7 +4598,7 @@ [(parallel [(set (match_operand:GPR 0 "register_operand" "") (unsigned_fix:GPR (match_operand:BFP 1 "register_operand" ""))) - (unspec:GPR [(const_int 5)] UNSPEC_ROUND) + (unspec:GPR [(const_int BFP_RND_TOWARD_0)] UNSPEC_ROUND) (clobber (reg:CC CC_REGNUM))])] "TARGET_HARD_FLOAT" { @@ -4596,12 +4619,12 @@ emit_insn (gen_sub3 (temp, operands[1], const_double_from_real_value (sub, mode))); emit_insn (gen_fix_trunc2_bfp (operands[0], temp, - GEN_INT (7))); + GEN_INT (BFP_RND_TOWARD_MINF))); emit_jump (label2); emit_label (label1); emit_insn (gen_fix_trunc2_bfp (operands[0], - operands[1], GEN_INT (5))); + operands[1], GEN_INT (BFP_RND_TOWARD_0))); emit_label (label2); DONE; } @@ -4612,7 +4635,7 @@ [(parallel [(set (match_operand:SI 0 "register_operand" "") (unsigned_fix:SI (match_operand:DFP 1 "register_operand" ""))) - (unspec:SI [(const_int 5)] UNSPEC_ROUND) + (unspec:SI [(const_int DFP_RND_TOWARD_0)] UNSPEC_ROUND) (clobber (reg:CC CC_REGNUM))])] "TARGET_Z196 && TARGET_HARD_DFP" "") @@ -4650,7 +4673,7 @@ "TARGET_HARD_FLOAT" { emit_insn (gen_fix_trunc2_bfp (operands[0], operands[1], - GEN_INT (5))); + GEN_INT (BFP_RND_TOWARD_0))); DONE; }) @@ -4696,7 +4719,7 @@ { operands[1] = force_reg (mode, operands[1]); emit_insn (gen_fix_truncdi2_dfp (operands[0], operands[1], - GEN_INT (9))); + GEN_INT (DFP_RND_TOWARD_0))); DONE; }) @@ -4719,7 +4742,7 @@ (define_expand "fix_trunctf2" [(parallel [(set (match_operand:GPR 0 "register_operand" "") (fix:GPR (match_operand:TF 1 "register_operand" ""))) - (unspec:GPR [(const_int 5)] UNSPEC_ROUND) + (unspec:GPR [(const_int BFP_RND_TOWARD_0)] UNSPEC_ROUND) (clobber (reg:CC CC_REGNUM))])] "TARGET_HARD_FLOAT" "") @@ -4731,15 +4754,16 @@ ; cxgbr, cdgbr, cegbr, cxgtr, cdgtr (define_insn "floatdi2" - [(set (match_operand:FP 0 "register_operand" "=f,") - (float:FP (match_operand:DI 1 "register_operand" "d,")))] + [(set (match_operand:FP 0 "register_operand" "=f,v") + (float:FP (match_operand:DI 1 "register_operand" "d,v")))] "TARGET_ZARCH && TARGET_HARD_FLOAT" "@ cgr\t%0,%1 wcdgb\t%v0,%v1,0,0" [(set_attr "op_type" "RRE,VRR") (set_attr "type" "itof" ) - (set_attr "cpu_facility" "*,vec")]) + (set_attr "cpu_facility" "*,vec") + (set_attr "enabled" "*,")]) ; cxfbr, cdfbr, cefbr (define_insn "floatsi2" @@ -4823,12 +4847,22 @@ ; trunctddd2 and truncddsd2 instruction pattern(s). ; -(define_insn "trunctddd2" + +(define_expand "trunctddd2" + [(parallel + [(set (match_operand:DD 0 "register_operand" "") + (float_truncate:DD (match_operand:TD 1 "register_operand" ""))) + (unspec:DI [(const_int DFP_RND_CURRENT)] UNSPEC_ROUND) + (clobber (scratch:TD))])] + "TARGET_HARD_DFP") + +(define_insn "*trunctddd2" [(set (match_operand:DD 0 "register_operand" "=f") (float_truncate:DD (match_operand:TD 1 "register_operand" "f"))) - (clobber (match_scratch:TD 2 "=f"))] + (unspec:DI [(match_operand:DI 2 "const_mask_operand" "I")] UNSPEC_ROUND) + (clobber (match_scratch:TD 3 "=f"))] "TARGET_HARD_DFP" - "ldxtr\t%2,0,%1,0\;ldr\t%0,%2" + "ldxtr\t%3,%2,%1,0\;ldr\t%0,%3" [(set_attr "length" "6") (set_attr "type" "ftruncdd")]) @@ -4844,6 +4878,7 @@ [(parallel [(set (match_dup 3) (float_truncate:DD (match_operand:TD 1 "register_operand" ""))) + (unspec:DI [(const_int DFP_RND_PREP_FOR_SHORT_PREC)] UNSPEC_ROUND) (clobber (match_scratch:TD 2 ""))]) (set (match_operand:SD 0 "register_operand" "") (float_truncate:SD (match_dup 3)))] @@ -5498,47 +5533,53 @@ ; axbr, adbr, aebr, axb, adb, aeb, adtr, axtr ; FIXME: wfadb does not clobber cc (define_insn "add3" - [(set (match_operand:FP 0 "register_operand" "=f, f,") - (plus:FP (match_operand:FP 1 "nonimmediate_operand" "%, 0,") - (match_operand:FP 2 "general_operand" "f,,"))) + [(set (match_operand:FP 0 "register_operand" "=f,f,f,v") + (plus:FP (match_operand:FP 1 "nonimmediate_operand" "%f,0,0,v") + (match_operand:FP 2 "general_operand" "f,f,R,v"))) (clobber (reg:CC CC_REGNUM))] "TARGET_HARD_FLOAT" "@ - ar\t%0,%2 + atr\t%0,%1,%2 + abr\t%0,%2 ab\t%0,%2 wfadb\t%v0,%v1,%v2" - [(set_attr "op_type" ",RXE,VRR") + [(set_attr "op_type" "RRF,RRE,RXE,VRR") (set_attr "type" "fsimp") - (set_attr "cpu_facility" "*,*,vec")]) + (set_attr "cpu_facility" "*,*,*,vec") + (set_attr "enabled" ",,,")]) ; axbr, adbr, aebr, axb, adb, aeb, adtr, axtr (define_insn "*add3_cc" [(set (reg CC_REGNUM) - (compare (plus:FP (match_operand:FP 1 "nonimmediate_operand" "%,0") - (match_operand:FP 2 "general_operand" " f,")) + (compare (plus:FP (match_operand:FP 1 "nonimmediate_operand" "%f,0,0") + (match_operand:FP 2 "general_operand" "f,f,R")) (match_operand:FP 3 "const0_operand" ""))) - (set (match_operand:FP 0 "register_operand" "=f,f") + (set (match_operand:FP 0 "register_operand" "=f,f,f") (plus:FP (match_dup 1) (match_dup 2)))] "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT" "@ - ar\t%0,%2 + atr\t%0,%1,%2 + abr\t%0,%2 ab\t%0,%2" - [(set_attr "op_type" ",RXE") - (set_attr "type" "fsimp")]) + [(set_attr "op_type" "RRF,RRE,RXE") + (set_attr "type" "fsimp") + (set_attr "enabled" ",,")]) ; axbr, adbr, aebr, axb, adb, aeb, adtr, axtr (define_insn "*add3_cconly" [(set (reg CC_REGNUM) - (compare (plus:FP (match_operand:FP 1 "nonimmediate_operand" "%,0") - (match_operand:FP 2 "general_operand" " f,")) + (compare (plus:FP (match_operand:FP 1 "nonimmediate_operand" "%f,0,0") + (match_operand:FP 2 "general_operand" "f,f,R")) (match_operand:FP 3 "const0_operand" ""))) - (clobber (match_scratch:FP 0 "=f,f"))] + (clobber (match_scratch:FP 0 "=f,f,f"))] "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT" "@ - ar\t%0,%2 + atr\t%0,%1,%2 + abr\t%0,%2 ab\t%0,%2" - [(set_attr "op_type" ",RXE") - (set_attr "type" "fsimp")]) + [(set_attr "op_type" "RRF,RRE,RXE") + (set_attr "type" "fsimp") + (set_attr "enabled" ",,")]) ; ; Pointer add instruction patterns @@ -5922,47 +5963,53 @@ ; sxbr, sdbr, sebr, sdb, seb, sxtr, sdtr (define_insn "sub3" - [(set (match_operand:FP 0 "register_operand" "=f, f,") - (minus:FP (match_operand:FP 1 "register_operand" ", 0,") - (match_operand:FP 2 "general_operand" "f,,"))) + [(set (match_operand:FP 0 "register_operand" "=f,f,f,v") + (minus:FP (match_operand:FP 1 "register_operand" "f,0,0,v") + (match_operand:FP 2 "general_operand" "f,f,R,v"))) (clobber (reg:CC CC_REGNUM))] "TARGET_HARD_FLOAT" "@ - sr\t%0,%2 + str\t%0,%1,%2 + sbr\t%0,%2 sb\t%0,%2 wfsdb\t%v0,%v1,%v2" - [(set_attr "op_type" ",RXE,VRR") + [(set_attr "op_type" "RRF,RRE,RXE,VRR") (set_attr "type" "fsimp") - (set_attr "cpu_facility" "*,*,vec")]) + (set_attr "cpu_facility" "*,*,*,vec") + (set_attr "enabled" ",,,")]) ; sxbr, sdbr, sebr, sdb, seb, sxtr, sdtr (define_insn "*sub3_cc" [(set (reg CC_REGNUM) - (compare (minus:FP (match_operand:FP 1 "nonimmediate_operand" ",0") - (match_operand:FP 2 "general_operand" "f,")) + (compare (minus:FP (match_operand:FP 1 "nonimmediate_operand" "f,0,0") + (match_operand:FP 2 "general_operand" "f,f,R")) (match_operand:FP 3 "const0_operand" ""))) - (set (match_operand:FP 0 "register_operand" "=f,f") + (set (match_operand:FP 0 "register_operand" "=f,f,f") (minus:FP (match_dup 1) (match_dup 2)))] "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT" "@ - sr\t%0,%2 + str\t%0,%1,%2 + sbr\t%0,%2 sb\t%0,%2" - [(set_attr "op_type" ",RXE") - (set_attr "type" "fsimp")]) + [(set_attr "op_type" "RRF,RRE,RXE") + (set_attr "type" "fsimp") + (set_attr "enabled" ",,")]) ; sxbr, sdbr, sebr, sdb, seb, sxtr, sdtr (define_insn "*sub3_cconly" [(set (reg CC_REGNUM) - (compare (minus:FP (match_operand:FP 1 "nonimmediate_operand" ",0") - (match_operand:FP 2 "general_operand" "f,")) + (compare (minus:FP (match_operand:FP 1 "nonimmediate_operand" "f,0,0") + (match_operand:FP 2 "general_operand" "f,f,R")) (match_operand:FP 3 "const0_operand" ""))) - (clobber (match_scratch:FP 0 "=f,f"))] + (clobber (match_scratch:FP 0 "=f,f,f"))] "s390_match_ccmode (insn, CCSmode) && TARGET_HARD_FLOAT" "@ - sr\t%0,%2 + str\t%0,%1,%2 + sbr\t%0,%2 sb\t%0,%2" - [(set_attr "op_type" ",RXE") - (set_attr "type" "fsimp")]) + [(set_attr "op_type" "RRF,RRE,RXE") + (set_attr "type" "fsimp") + (set_attr "enabled" ",,")]) ;; @@ -6344,24 +6391,26 @@ ; mxbr, mdbr, meebr, mxb, mxb, meeb, mdtr, mxtr (define_insn "mul3" - [(set (match_operand:FP 0 "register_operand" "=f, f,") - (mult:FP (match_operand:FP 1 "nonimmediate_operand" "%, 0,") - (match_operand:FP 2 "general_operand" "f,,")))] + [(set (match_operand:FP 0 "register_operand" "=f,f,f,v") + (mult:FP (match_operand:FP 1 "nonimmediate_operand" "%f,0,0,v") + (match_operand:FP 2 "general_operand" "f,f,R,v")))] "TARGET_HARD_FLOAT" "@ - mr\t%0,%2 + mtr\t%0,%1,%2 + mbr\t%0,%2 mb\t%0,%2 wfmdb\t%v0,%v1,%v2" - [(set_attr "op_type" ",RXE,VRR") + [(set_attr "op_type" "RRF,RRE,RXE,VRR") (set_attr "type" "fmul") - (set_attr "cpu_facility" "*,*,vec")]) + (set_attr "cpu_facility" "*,*,*,vec") + (set_attr "enabled" ",,,")]) ; madbr, maebr, maxb, madb, maeb (define_insn "fma4" - [(set (match_operand:DSF 0 "register_operand" "=f,f,") - (fma:DSF (match_operand:DSF 1 "nonimmediate_operand" "%f,f,") - (match_operand:DSF 2 "nonimmediate_operand" "f,R,") - (match_operand:DSF 3 "register_operand" "0,0,")))] + [(set (match_operand:DSF 0 "register_operand" "=f,f,v") + (fma:DSF (match_operand:DSF 1 "nonimmediate_operand" "%f,f,v") + (match_operand:DSF 2 "nonimmediate_operand" "f,R,v") + (match_operand:DSF 3 "register_operand" "0,0,v")))] "TARGET_HARD_FLOAT" "@ mabr\t%0,%1,%2 @@ -6369,14 +6418,15 @@ wfmadb\t%v0,%v1,%v2,%v3" [(set_attr "op_type" "RRE,RXE,VRR") (set_attr "type" "fmadd") - (set_attr "cpu_facility" "*,*,vec")]) + (set_attr "cpu_facility" "*,*,vec") + (set_attr "enabled" "*,*,")]) ; msxbr, msdbr, msebr, msxb, msdb, mseb (define_insn "fms4" - [(set (match_operand:DSF 0 "register_operand" "=f,f,") - (fma:DSF (match_operand:DSF 1 "nonimmediate_operand" "%f,f,") - (match_operand:DSF 2 "nonimmediate_operand" "f,R,") - (neg:DSF (match_operand:DSF 3 "register_operand" "0,0,"))))] + [(set (match_operand:DSF 0 "register_operand" "=f,f,v") + (fma:DSF (match_operand:DSF 1 "nonimmediate_operand" "%f,f,v") + (match_operand:DSF 2 "nonimmediate_operand" "f,R,v") + (neg:DSF (match_operand:DSF 3 "register_operand" "0,0,v"))))] "TARGET_HARD_FLOAT" "@ msbr\t%0,%1,%2 @@ -6384,7 +6434,8 @@ wfmsdb\t%v0,%v1,%v2,%v3" [(set_attr "op_type" "RRE,RXE,VRR") (set_attr "type" "fmadd") - (set_attr "cpu_facility" "*,*,vec")]) + (set_attr "cpu_facility" "*,*,vec") + (set_attr "enabled" "*,*,")]) ;; ;;- Divide and modulo instructions. @@ -6810,17 +6861,19 @@ ; dxbr, ddbr, debr, dxb, ddb, deb, ddtr, dxtr (define_insn "div3" - [(set (match_operand:FP 0 "register_operand" "=f, f,") - (div:FP (match_operand:FP 1 "register_operand" ", 0,") - (match_operand:FP 2 "general_operand" "f,,")))] + [(set (match_operand:FP 0 "register_operand" "=f,f,f,v") + (div:FP (match_operand:FP 1 "register_operand" "f,0,0,v") + (match_operand:FP 2 "general_operand" "f,f,R,v")))] "TARGET_HARD_FLOAT" "@ - dr\t%0,%2 + dtr\t%0,%1,%2 + dbr\t%0,%2 db\t%0,%2 wfddb\t%v0,%v1,%v2" - [(set_attr "op_type" ",RXE,VRR") + [(set_attr "op_type" "RRF,RRE,RXE,VRR") (set_attr "type" "fdiv") - (set_attr "cpu_facility" "*,*,vec")]) + (set_attr "cpu_facility" "*,*,*,vec") + (set_attr "enabled" ",,,")]) ;; @@ -8031,8 +8084,8 @@ ; lcxbr, lcdbr, lcebr ; FIXME: wflcdb does not clobber cc (define_insn "*neg2" - [(set (match_operand:BFP 0 "register_operand" "=f,") - (neg:BFP (match_operand:BFP 1 "register_operand" "f,"))) + [(set (match_operand:BFP 0 "register_operand" "=f,v") + (neg:BFP (match_operand:BFP 1 "register_operand" "f,v"))) (clobber (reg:CC CC_REGNUM))] "TARGET_HARD_FLOAT" "@ @@ -8040,7 +8093,8 @@ wflcdb\t%0,%1" [(set_attr "op_type" "RRE,VRR") (set_attr "cpu_facility" "*,vec") - (set_attr "type" "fsimp,*")]) + (set_attr "type" "fsimp,*") + (set_attr "enabled" "*,")]) ;; @@ -8153,8 +8207,8 @@ ; lpxbr, lpdbr, lpebr ; FIXME: wflpdb does not clobber cc (define_insn "*abs2" - [(set (match_operand:BFP 0 "register_operand" "=f,") - (abs:BFP (match_operand:BFP 1 "register_operand" "f,"))) + [(set (match_operand:BFP 0 "register_operand" "=f,v") + (abs:BFP (match_operand:BFP 1 "register_operand" "f,v"))) (clobber (reg:CC CC_REGNUM))] "TARGET_HARD_FLOAT" "@ @@ -8162,7 +8216,8 @@ wflpdb\t%0,%1" [(set_attr "op_type" "RRE,VRR") (set_attr "cpu_facility" "*,vec") - (set_attr "type" "fsimp,*")]) + (set_attr "type" "fsimp,*") + (set_attr "enabled" "*,")]) ;; @@ -8268,8 +8323,8 @@ ; lnxbr, lndbr, lnebr ; FIXME: wflndb does not clobber cc (define_insn "*negabs2" - [(set (match_operand:BFP 0 "register_operand" "=f,") - (neg:BFP (abs:BFP (match_operand:BFP 1 "register_operand" "f,")))) + [(set (match_operand:BFP 0 "register_operand" "=f,v") + (neg:BFP (abs:BFP (match_operand:BFP 1 "register_operand" "f,v")))) (clobber (reg:CC CC_REGNUM))] "TARGET_HARD_FLOAT" "@ @@ -8277,7 +8332,8 @@ wflndb\t%0,%1" [(set_attr "op_type" "RRE,VRR") (set_attr "cpu_facility" "*,vec") - (set_attr "type" "fsimp,*")]) + (set_attr "type" "fsimp,*") + (set_attr "enabled" "*,")]) ;; ;;- Square root instructions. @@ -8289,8 +8345,8 @@ ; sqxbr, sqdbr, sqebr, sqdb, sqeb (define_insn "sqrt2" - [(set (match_operand:BFP 0 "register_operand" "=f, f,") - (sqrt:BFP (match_operand:BFP 1 "general_operand" "f,,")))] + [(set (match_operand:BFP 0 "register_operand" "=f,f,v") + (sqrt:BFP (match_operand:BFP 1 "general_operand" "f,R,v")))] "TARGET_HARD_FLOAT" "@ sqbr\t%0,%1 @@ -8298,7 +8354,8 @@ wfsqdb\t%v0,%v1" [(set_attr "op_type" "RRE,RXE,VRR") (set_attr "type" "fsqrt") - (set_attr "cpu_facility" "*,*,vec")]) + (set_attr "cpu_facility" "*,*,vec") + (set_attr "enabled" "*,,")]) ;; @@ -8369,28 +8426,23 @@ ; rotl(di|si)3 instruction pattern(s). ; -; rll, rllg -(define_insn "rotl3" - [(set (match_operand:GPR 0 "register_operand" "=d") - (rotate:GPR (match_operand:GPR 1 "register_operand" "d") - (match_operand:SI 2 "shift_count_or_setmem_operand" "Y")))] +(define_expand "rotl3" + [(set (match_operand:GPR 0 "register_operand" "") + (rotate:GPR (match_operand:GPR 1 "register_operand" "") + (match_operand:SI 2 "nonmemory_operand" "")))] "TARGET_CPU_ZARCH" - "rll\t%0,%1,%Y2" - [(set_attr "op_type" "RSE") - (set_attr "atype" "reg") - (set_attr "z10prop" "z10_super_E1")]) + "") ; rll, rllg -(define_insn "*rotl3_and" - [(set (match_operand:GPR 0 "register_operand" "=d") - (rotate:GPR (match_operand:GPR 1 "register_operand" "d") - (and:SI (match_operand:SI 2 "shift_count_or_setmem_operand" "Y") - (match_operand:SI 3 "const_int_operand" "n"))))] - "TARGET_CPU_ZARCH && (INTVAL (operands[3]) & 63) == 63" - "rll\t%0,%1,%Y2" +(define_insn "*rotl3" + [(set (match_operand:GPR 0 "register_operand" "=d") + (rotate:GPR (match_operand:GPR 1 "register_operand" "d") + (match_operand:SI 2 "nonmemory_operand" "an")))] + "TARGET_CPU_ZARCH" + "rll\t%0,%1," [(set_attr "op_type" "RSE") (set_attr "atype" "reg") - (set_attr "z10prop" "z10_super_E1")]) + (set_attr "z10prop" "z10_super_E1")]) ;; @@ -8404,60 +8456,37 @@ (define_expand "3" [(set (match_operand:DSI 0 "register_operand" "") (SHIFT:DSI (match_operand:DSI 1 "register_operand" "") - (match_operand:SI 2 "shift_count_or_setmem_operand" "")))] + (match_operand:SI 2 "nonmemory_operand" "")))] "" "") +; ESA 64 bit register pair shift with reg or imm shift count ; sldl, srdl -(define_insn "*di3_31" - [(set (match_operand:DI 0 "register_operand" "=d") - (SHIFT:DI (match_operand:DI 1 "register_operand" "0") - (match_operand:SI 2 "shift_count_or_setmem_operand" "Y")))] +(define_insn "*di3_31" + [(set (match_operand:DI 0 "register_operand" "=d") + (SHIFT:DI (match_operand:DI 1 "register_operand" "0") + (match_operand:SI 2 "nonmemory_operand" "an")))] "!TARGET_ZARCH" - "sdl\t%0,%Y2" + "sdl\t%0," [(set_attr "op_type" "RS") (set_attr "atype" "reg") (set_attr "z196prop" "z196_cracked")]) + +; 64 bit register shift with reg or imm shift count ; sll, srl, sllg, srlg, sllk, srlk -(define_insn "*3" - [(set (match_operand:GPR 0 "register_operand" "=d,d") - (SHIFT:GPR (match_operand:GPR 1 "register_operand" ",d") - (match_operand:SI 2 "shift_count_or_setmem_operand" "Y,Y")))] +(define_insn "*3" + [(set (match_operand:GPR 0 "register_operand" "=d, d") + (SHIFT:GPR (match_operand:GPR 1 "register_operand" ", d") + (match_operand:SI 2 "nonmemory_operand" "an,an")))] "" "@ - sl\t%0,<1>%Y2 - sl\t%0,%1,%Y2" - [(set_attr "op_type" "RS,RSY") - (set_attr "atype" "reg,reg") - (set_attr "cpu_facility" "*,z196") - (set_attr "z10prop" "z10_super_E1,*")]) - -; sldl, srdl -(define_insn "*di3_31_and" - [(set (match_operand:DI 0 "register_operand" "=d") - (SHIFT:DI (match_operand:DI 1 "register_operand" "0") - (and:SI (match_operand:SI 2 "shift_count_or_setmem_operand" "Y") - (match_operand:SI 3 "const_int_operand" "n"))))] - "!TARGET_ZARCH && (INTVAL (operands[3]) & 63) == 63" - "sdl\t%0,%Y2" - [(set_attr "op_type" "RS") - (set_attr "atype" "reg")]) - -; sll, srl, sllg, srlg, sllk, srlk -(define_insn "*3_and" - [(set (match_operand:GPR 0 "register_operand" "=d,d") - (SHIFT:GPR (match_operand:GPR 1 "register_operand" ",d") - (and:SI (match_operand:SI 2 "shift_count_or_setmem_operand" "Y,Y") - (match_operand:SI 3 "const_int_operand" "n,n"))))] - "(INTVAL (operands[3]) & 63) == 63" - "@ - sl\t%0,<1>%Y2 - sl\t%0,%1,%Y2" + sl\t%0,<1> + sl\t%0,%1," [(set_attr "op_type" "RS,RSY") (set_attr "atype" "reg,reg") (set_attr "cpu_facility" "*,z196") - (set_attr "z10prop" "z10_super_E1,*")]) + (set_attr "z10prop" "z10_super_E1,*")]) ; ; ashr(di|si)3 instruction pattern(s). @@ -8467,181 +8496,40 @@ [(parallel [(set (match_operand:DSI 0 "register_operand" "") (ashiftrt:DSI (match_operand:DSI 1 "register_operand" "") - (match_operand:SI 2 "shift_count_or_setmem_operand" ""))) + (match_operand:SI 2 "nonmemory_operand" ""))) (clobber (reg:CC CC_REGNUM))])] "" "") -(define_insn "*ashrdi3_cc_31" - [(set (reg CC_REGNUM) - (compare (ashiftrt:DI (match_operand:DI 1 "register_operand" "0") - (match_operand:SI 2 "shift_count_or_setmem_operand" "Y")) - (const_int 0))) - (set (match_operand:DI 0 "register_operand" "=d") - (ashiftrt:DI (match_dup 1) (match_dup 2)))] - "!TARGET_ZARCH && s390_match_ccmode(insn, CCSmode)" - "srda\t%0,%Y2" - [(set_attr "op_type" "RS") - (set_attr "atype" "reg")]) - -(define_insn "*ashrdi3_cconly_31" - [(set (reg CC_REGNUM) - (compare (ashiftrt:DI (match_operand:DI 1 "register_operand" "0") - (match_operand:SI 2 "shift_count_or_setmem_operand" "Y")) - (const_int 0))) - (clobber (match_scratch:DI 0 "=d"))] - "!TARGET_ZARCH && s390_match_ccmode(insn, CCSmode)" - "srda\t%0,%Y2" - [(set_attr "op_type" "RS") - (set_attr "atype" "reg")]) - -(define_insn "*ashrdi3_31" - [(set (match_operand:DI 0 "register_operand" "=d") - (ashiftrt:DI (match_operand:DI 1 "register_operand" "0") - (match_operand:SI 2 "shift_count_or_setmem_operand" "Y"))) +; FIXME: The number of alternatives is doubled here to match the fix +; number of 2 in the subst pattern for the (clobber (match_scratch... +; The right fix should be to support match_scratch in the output +; pattern of a define_subst. +(define_insn "*ashrdi3_31" + [(set (match_operand:DI 0 "register_operand" "=d, d") + (ashiftrt:DI (match_operand:DI 1 "register_operand" "0, 0") + (match_operand:SI 2 "nonmemory_operand" "an,an"))) (clobber (reg:CC CC_REGNUM))] "!TARGET_ZARCH" - "srda\t%0,%Y2" - [(set_attr "op_type" "RS") - (set_attr "atype" "reg")]) - -; sra, srag, srak -(define_insn "*ashr3_cc" - [(set (reg CC_REGNUM) - (compare (ashiftrt:GPR (match_operand:GPR 1 "register_operand" ",d") - (match_operand:SI 2 "shift_count_or_setmem_operand" "Y,Y")) - (const_int 0))) - (set (match_operand:GPR 0 "register_operand" "=d,d") - (ashiftrt:GPR (match_dup 1) (match_dup 2)))] - "s390_match_ccmode(insn, CCSmode)" "@ - sra\t%0,<1>%Y2 - sra\t%0,%1,%Y2" - [(set_attr "op_type" "RS,RSY") - (set_attr "atype" "reg,reg") - (set_attr "cpu_facility" "*,z196") - (set_attr "z10prop" "z10_super_E1,*")]) + srda\t%0, + srda\t%0," + [(set_attr "op_type" "RS") + (set_attr "atype" "reg")]) -; sra, srag, srak -(define_insn "*ashr3_cconly" - [(set (reg CC_REGNUM) - (compare (ashiftrt:GPR (match_operand:GPR 1 "register_operand" ",d") - (match_operand:SI 2 "shift_count_or_setmem_operand" "Y,Y")) - (const_int 0))) - (clobber (match_scratch:GPR 0 "=d,d"))] - "s390_match_ccmode(insn, CCSmode)" - "@ - sra\t%0,<1>%Y2 - sra\t%0,%1,%Y2" - [(set_attr "op_type" "RS,RSY") - (set_attr "atype" "reg,reg") - (set_attr "cpu_facility" "*,z196") - (set_attr "z10prop" "z10_super_E1,*")]) ; sra, srag -(define_insn "*ashr3" - [(set (match_operand:GPR 0 "register_operand" "=d,d") - (ashiftrt:GPR (match_operand:GPR 1 "register_operand" ",d") - (match_operand:SI 2 "shift_count_or_setmem_operand" "Y,Y"))) +(define_insn "*ashr3" + [(set (match_operand:GPR 0 "register_operand" "=d, d") + (ashiftrt:GPR (match_operand:GPR 1 "register_operand" ", d") + (match_operand:SI 2 "nonmemory_operand" "an,an"))) (clobber (reg:CC CC_REGNUM))] "" "@ - sra\t%0,<1>%Y2 - sra\t%0,%1,%Y2" + sra\t%0,<1> + sra\t%0,%1," [(set_attr "op_type" "RS,RSY") - (set_attr "atype" "reg,reg") - (set_attr "cpu_facility" "*,z196") - (set_attr "z10prop" "z10_super_E1,*")]) - - -; shift pattern with implicit ANDs - -(define_insn "*ashrdi3_cc_31_and" - [(set (reg CC_REGNUM) - (compare (ashiftrt:DI (match_operand:DI 1 "register_operand" "0") - (and:SI (match_operand:SI 2 "shift_count_or_setmem_operand" "Y") - (match_operand:SI 3 "const_int_operand" "n"))) - (const_int 0))) - (set (match_operand:DI 0 "register_operand" "=d") - (ashiftrt:DI (match_dup 1) (and:SI (match_dup 2) (match_dup 3))))] - "!TARGET_ZARCH && s390_match_ccmode(insn, CCSmode) - && (INTVAL (operands[3]) & 63) == 63" - "srda\t%0,%Y2" - [(set_attr "op_type" "RS") - (set_attr "atype" "reg")]) - -(define_insn "*ashrdi3_cconly_31_and" - [(set (reg CC_REGNUM) - (compare (ashiftrt:DI (match_operand:DI 1 "register_operand" "0") - (and:SI (match_operand:SI 2 "shift_count_or_setmem_operand" "Y") - (match_operand:SI 3 "const_int_operand" "n"))) - (const_int 0))) - (clobber (match_scratch:DI 0 "=d"))] - "!TARGET_ZARCH && s390_match_ccmode(insn, CCSmode) - && (INTVAL (operands[3]) & 63) == 63" - "srda\t%0,%Y2" - [(set_attr "op_type" "RS") - (set_attr "atype" "reg")]) - -(define_insn "*ashrdi3_31_and" - [(set (match_operand:DI 0 "register_operand" "=d") - (ashiftrt:DI (match_operand:DI 1 "register_operand" "0") - (and:SI (match_operand:SI 2 "shift_count_or_setmem_operand" "Y") - (match_operand:SI 3 "const_int_operand" "n")))) - (clobber (reg:CC CC_REGNUM))] - "!TARGET_ZARCH && (INTVAL (operands[3]) & 63) == 63" - "srda\t%0,%Y2" - [(set_attr "op_type" "RS") - (set_attr "atype" "reg")]) - -; sra, srag, srak -(define_insn "*ashr3_cc_and" - [(set (reg CC_REGNUM) - (compare (ashiftrt:GPR (match_operand:GPR 1 "register_operand" ",d") - (and:SI (match_operand:SI 2 "shift_count_or_setmem_operand" "Y,Y") - (match_operand:SI 3 "const_int_operand" "n,n"))) - (const_int 0))) - (set (match_operand:GPR 0 "register_operand" "=d,d") - (ashiftrt:GPR (match_dup 1) (and:SI (match_dup 2) (match_dup 3))))] - "s390_match_ccmode(insn, CCSmode) && (INTVAL (operands[3]) & 63) == 63" - "@ - sra\t%0,<1>%Y2 - sra\t%0,%1,%Y2" - [(set_attr "op_type" "RS,RSY") - (set_attr "atype" "reg,reg") - (set_attr "cpu_facility" "*,z196") - (set_attr "z10prop" "z10_super_E1,*")]) - -; sra, srag, srak -(define_insn "*ashr3_cconly_and" - [(set (reg CC_REGNUM) - (compare (ashiftrt:GPR (match_operand:GPR 1 "register_operand" ",d") - (and:SI (match_operand:SI 2 "shift_count_or_setmem_operand" "Y,Y") - (match_operand:SI 3 "const_int_operand" "n,n"))) - (const_int 0))) - (clobber (match_scratch:GPR 0 "=d,d"))] - "s390_match_ccmode(insn, CCSmode) && (INTVAL (operands[3]) & 63) == 63" - "@ - sra\t%0,<1>%Y2 - sra\t%0,%1,%Y2" - [(set_attr "op_type" "RS,RSY") - (set_attr "atype" "reg,reg") - (set_attr "cpu_facility" "*,z196") - (set_attr "z10prop" "z10_super_E1,*")]) - -; sra, srag, srak -(define_insn "*ashr3_and" - [(set (match_operand:GPR 0 "register_operand" "=d,d") - (ashiftrt:GPR (match_operand:GPR 1 "register_operand" ",d") - (and:SI (match_operand:SI 2 "shift_count_or_setmem_operand" "Y,Y") - (match_operand:SI 3 "const_int_operand" "n,n")))) - (clobber (reg:CC CC_REGNUM))] - "(INTVAL (operands[3]) & 63) == 63" - "@ - sra\t%0,<1>%Y2 - sra\t%0,%1,%Y2" - [(set_attr "op_type" "RS,RSY") - (set_attr "atype" "reg,reg") + (set_attr "atype" "reg") (set_attr "cpu_facility" "*,z196") (set_attr "z10prop" "z10_super_E1,*")]) @@ -10858,7 +10746,7 @@ ; Transaction abort (define_expand "tabort" - [(unspec_volatile [(match_operand:SI 0 "shift_count_or_setmem_operand" "")] + [(unspec_volatile [(match_operand:SI 0 "nonmemory_operand" "")] UNSPECV_TABORT)] "TARGET_HTM && operands != NULL" { @@ -10873,12 +10761,21 @@ }) (define_insn "*tabort_1" - [(unspec_volatile [(match_operand:SI 0 "shift_count_or_setmem_operand" "Y")] + [(unspec_volatile [(match_operand:SI 0 "nonmemory_operand" "aJ")] UNSPECV_TABORT)] "TARGET_HTM && operands != NULL" "tabort\t%Y0" [(set_attr "op_type" "S")]) +(define_insn "*tabort_1_plus" + [(unspec_volatile [(plus:SI (match_operand:SI 0 "register_operand" "a") + (match_operand:SI 1 "const_int_operand" "J"))] + UNSPECV_TABORT)] + "TARGET_HTM && operands != NULL + && CONST_OK_FOR_CONSTRAINT_P (INTVAL (operands[1]), 'J', \"J\")" + "tabort\t%1(%0)" + [(set_attr "op_type" "S")]) + ; Transaction extract nesting depth (define_insn "etnd" diff --git a/gcc/config/s390/subst.md b/gcc/config/s390/subst.md new file mode 100644 index 000000000000..8a1b8145fd00 --- /dev/null +++ b/gcc/config/s390/subst.md @@ -0,0 +1,122 @@ +;;- Machine description for GNU compiler -- S/390 / zSeries version. +;; Subst patterns. +;; Copyright (C) 2016 Free Software Foundation, Inc. +;; Contributed by Andreas Krebbel (Andreas.Krebbel@de.ibm.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 +;; . + +(define_code_iterator SUBST [rotate ashift lshiftrt ashiftrt]) +(define_mode_iterator DSI_VI [SI DI V2QI V4QI V8QI V16QI V2HI V4HI V8HI V2SI V4SI V2DI]) + +; This expands an register/immediate operand to a register+immediate +; operand to draw advantage of the address style operand format +; providing a addition for free. +(define_subst "addr_style_op_subst" + [(set (match_operand:DSI_VI 0 "" "") + (SUBST:DSI_VI (match_operand:DSI_VI 1 "" "") + (match_operand:SI 2 "" "")))] + "" + [(set (match_dup 0) + (SUBST:DSI_VI (match_dup 1) + (plus:SI (match_operand:SI 2 "register_operand" "a") + (match_operand 3 "const_int_operand" "n"))))]) + +; Use this in the insn name. +(define_subst_attr "addr_style_op" "addr_style_op_subst" "" "_plus") + +; In the subst pattern the additional const int operand will be used +; as displacement. In the normal version %Y is able to print the +; operand either as displacement or as base register. +(define_subst_attr "addr_style_op_ops" "addr_style_op_subst" "%Y2" "%Y3(%2)") + + +; This substitution adds an explicit AND operation to the second +; operand. This way previous operations on the now masked out bits +; might get optimized away. +(define_subst "masked_op_subst" + [(set (match_operand:DSI 0 "" "") + (SUBST:DSI (match_operand:DSI 1 "" "") + (match_operand:SI 2 "" "")))] + "" + [(set (match_dup 0) + (SUBST:DSI (match_dup 1) + (and:SI (match_dup 2) + (match_operand:SI 3 "const_int_6bitset_operand" "jm6"))))]) + +; Use this in the insn name. +(define_subst_attr "masked_op" "masked_op_subst" "" "_and") + + + +; This is like the addr_style_op substitution above but with a CC clobber. +(define_subst "addr_style_op_cc_subst" + [(set (match_operand:DSI 0 "" "") + (ashiftrt:DSI (match_operand:DSI 1 "" "") + (match_operand:SI 2 "" ""))) + (clobber (reg:CC CC_REGNUM))] + "REG_P (operands[2])" + [(set (match_dup 0) + (ashiftrt:DSI (match_dup 1) + (plus:SI (match_dup 2) + (match_operand 3 "const_int_operand" "n")))) + (clobber (reg:CC CC_REGNUM))]) + +(define_subst_attr "addr_style_op_cc" "addr_style_op_cc_subst" "" "_plus") +(define_subst_attr "addr_style_op_cc_ops" "addr_style_op_cc_subst" "%Y2" "%Y3(%2)") + + +; This is like the masked_op substitution but with a CC clobber. +(define_subst "masked_op_cc_subst" + [(set (match_operand:DSI 0 "" "") + (ashiftrt:DSI (match_operand:DSI 1 "" "") + (match_operand:SI 2 "" ""))) + (clobber (reg:CC CC_REGNUM))] + "" + [(set (match_dup 0) + (ashiftrt:DSI (match_dup 1) + (and:SI (match_dup 2) + (match_operand:SI 3 "const_int_6bitset_operand" "")))) + (clobber (reg:CC CC_REGNUM))]) +(define_subst_attr "masked_op_cc" "masked_op_cc_subst" "" "_and") + + +; This adds an explicit CC reg set to an operation while keeping the +; set for the operation result as well. +(define_subst "setcc_subst" + [(set (match_operand:DSI 0 "" "") + (match_operand:DSI 1 "" "")) + (clobber (reg:CC CC_REGNUM))] + "s390_match_ccmode(insn, CCSmode)" + [(set (reg CC_REGNUM) + (compare (match_dup 1) (const_int 0))) + (set (match_dup 0) (match_dup 1))]) + +; Use this in the insn name. +(define_subst_attr "setcc" "setcc_subst" "" "_cc") + +; This adds an explicit CC reg set to an operation while dropping the +; result of the operation. +(define_subst "cconly_subst" + [(set (match_operand:DSI 0 "" "") + (match_operand:DSI 1 "" "")) + (clobber (reg:CC CC_REGNUM))] + "s390_match_ccmode(insn, CCSmode)" + [(set (reg CC_REGNUM) + (compare (match_dup 1) (const_int 0))) + (clobber (match_scratch:DSI 0 "=d,d"))]) + +(define_subst_attr "cconly" "cconly_subst" "" "_cconly") diff --git a/gcc/config/s390/vector.md b/gcc/config/s390/vector.md index cc3287c78ff2..5b3cdafe3d69 100644 --- a/gcc/config/s390/vector.md +++ b/gcc/config/s390/vector.md @@ -307,47 +307,80 @@ ; vec_store_lanes? +; vec_set is supposed to *modify* an existing vector so operand 0 is +; duplicated as input operand. +(define_expand "vec_set" + [(set (match_operand:V 0 "register_operand" "") + (unspec:V [(match_operand: 1 "general_operand" "") + (match_operand:SI 2 "nonmemory_operand" "") + (match_dup 0)] + UNSPEC_VEC_SET))] + "TARGET_VX") + ; FIXME: Support also vector mode operands for 1 ; FIXME: A target memory operand seems to be useful otherwise we end ; up with vl vlvgg vst. Shouldn't the middle-end be able to handle ; that itself? (define_insn "*vec_set" - [(set (match_operand:V 0 "register_operand" "=v, v,v") - (unspec:V [(match_operand: 1 "general_operand" "d,QR,K") - (match_operand:SI 2 "shift_count_or_setmem_operand" "Y, I,I") - (match_operand:V 3 "register_operand" "0, 0,0")] + [(set (match_operand:V 0 "register_operand" "=v, v,v") + (unspec:V [(match_operand: 1 "general_operand" "d,QR,K") + (match_operand:SI 2 "nonmemory_operand" "an, I,I") + (match_operand:V 3 "register_operand" "0, 0,0")] UNSPEC_VEC_SET))] - "TARGET_VX" + "TARGET_VX + && (!CONST_INT_P (operands[2]) + || UINTVAL (operands[2]) < GET_MODE_NUNITS (mode))" "@ vlvg\t%v0,%1,%Y2 vle\t%v0,%1,%2 vlei\t%v0,%1,%2" [(set_attr "op_type" "VRS,VRX,VRI")]) -; vec_set is supposed to *modify* an existing vector so operand 0 is -; duplicated as input operand. -(define_expand "vec_set" - [(set (match_operand:V 0 "register_operand" "") - (unspec:V [(match_operand: 1 "general_operand" "") - (match_operand:SI 2 "shift_count_or_setmem_operand" "") - (match_dup 0)] - UNSPEC_VEC_SET))] - "TARGET_VX") +(define_insn "*vec_set_plus" + [(set (match_operand:V 0 "register_operand" "=v") + (unspec:V [(match_operand: 1 "general_operand" "d") + (plus:SI (match_operand:SI 2 "register_operand" "a") + (match_operand:SI 4 "const_int_operand" "n")) + (match_operand:V 3 "register_operand" "0")] + UNSPEC_VEC_SET))] + "TARGET_VX" + "vlvg\t%v0,%1,%Y4(%2)" + [(set_attr "op_type" "VRS")]) + ; FIXME: Support also vector mode operands for 0 ; FIXME: This should be (vec_select ..) or something but it does only allow constant selectors :( ; This is used via RTL standard name as well as for expanding the builtin -(define_insn "vec_extract" - [(set (match_operand: 0 "nonimmediate_operand" "=d,QR") - (unspec: [(match_operand:V 1 "register_operand" " v, v") - (match_operand:SI 2 "shift_count_or_setmem_operand" " Y, I")] +(define_expand "vec_extract" + [(set (match_operand: 0 "nonimmediate_operand" "") + (unspec: [(match_operand:V 1 "register_operand" "") + (match_operand:SI 2 "nonmemory_operand" "")] UNSPEC_VEC_EXTRACT))] - "TARGET_VX" + "TARGET_VX") + +(define_insn "*vec_extract" + [(set (match_operand: 0 "nonimmediate_operand" "=d,QR") + (unspec: [(match_operand:V 1 "register_operand" "v, v") + (match_operand:SI 2 "nonmemory_operand" "an, I")] + UNSPEC_VEC_EXTRACT))] + "TARGET_VX + && (!CONST_INT_P (operands[2]) + || UINTVAL (operands[2]) < GET_MODE_NUNITS (mode))" "@ vlgv\t%0,%v1,%Y2 vste\t%v1,%0,%2" [(set_attr "op_type" "VRS,VRX")]) +(define_insn "*vec_extract_plus" + [(set (match_operand: 0 "nonimmediate_operand" "=d") + (unspec: [(match_operand:V 1 "register_operand" "v") + (plus:SI (match_operand:SI 2 "nonmemory_operand" "a") + (match_operand:SI 3 "const_int_operand" "n"))] + UNSPEC_VEC_EXTRACT))] + "TARGET_VX" + "vlgv\t%0,%v1,%Y3(%2)" + [(set_attr "op_type" "VRS")]) + (define_expand "vec_init" [(match_operand:V_HW 0 "register_operand" "") (match_operand:V_HW 1 "nonmemory_operand" "")] @@ -667,17 +700,6 @@ [(set_attr "op_type" "VRR")]) -; Vector rotate instructions - -; Each vector element rotated by a scalar -; verllb, verllh, verllf, verllg -(define_insn "rotl3" - [(set (match_operand:VI 0 "register_operand" "=v") - (rotate:VI (match_operand:VI 1 "register_operand" "v") - (match_operand:SI 2 "shift_count_or_setmem_operand" "Y")))] - "TARGET_VX" - "verll\t%v0,%v1,%Y2" - [(set_attr "op_type" "VRS")]) ; Each vector element rotated by the corresponding vector element ; verllvb, verllvh, verllvf, verllvg @@ -690,36 +712,33 @@ [(set_attr "op_type" "VRR")]) -; Shift each element by scalar value +; Vector rotate and shift by scalar instructions -; veslb, veslh, veslf, veslg -(define_insn "ashl3" - [(set (match_operand:VI 0 "register_operand" "=v") - (ashift:VI (match_operand:VI 1 "register_operand" "v") - (match_operand:SI 2 "shift_count_or_setmem_operand" "Y")))] - "TARGET_VX" - "vesl\t%v0,%v1,%Y2" - [(set_attr "op_type" "VRS")]) +(define_code_iterator VEC_SHIFTS [ashift ashiftrt lshiftrt rotate]) +(define_code_attr vec_shifts_name [(ashift "ashl") (ashiftrt "ashr") + (lshiftrt "lshr") (rotate "rotl")]) +(define_code_attr vec_shifts_mnem [(ashift "vesl") (ashiftrt "vesra") + (lshiftrt "vesrl") (rotate "verll")]) -; vesrab, vesrah, vesraf, vesrag -(define_insn "ashr3" - [(set (match_operand:VI 0 "register_operand" "=v") - (ashiftrt:VI (match_operand:VI 1 "register_operand" "v") - (match_operand:SI 2 "shift_count_or_setmem_operand" "Y")))] - "TARGET_VX" - "vesra\t%v0,%v1,%Y2" - [(set_attr "op_type" "VRS")]) +; Each vector element rotated by a scalar +(define_expand "3" + [(set (match_operand:VI 0 "register_operand" "") + (VEC_SHIFTS:VI (match_operand:VI 1 "register_operand" "") + (match_operand:SI 2 "nonmemory_operand" "")))] + "TARGET_VX") +; verllb, verllh, verllf, verllg +; veslb, veslh, veslf, veslg +; vesrab, vesrah, vesraf, vesrag ; vesrlb, vesrlh, vesrlf, vesrlg -(define_insn "lshr3" - [(set (match_operand:VI 0 "register_operand" "=v") - (lshiftrt:VI (match_operand:VI 1 "register_operand" "v") - (match_operand:SI 2 "shift_count_or_setmem_operand" "Y")))] +(define_insn "*3" + [(set (match_operand:VI 0 "register_operand" "=v") + (VEC_SHIFTS:VI (match_operand:VI 1 "register_operand" "v") + (match_operand:SI 2 "nonmemory_operand" "an")))] "TARGET_VX" - "vesrl\t%v0,%v1,%Y2" + "\t%v0,%v1,%Y2" [(set_attr "op_type" "VRS")]) - ; Shift each element by corresponding vector element ; veslvb, veslvh, veslvf, veslvg diff --git a/gcc/config/s390/vx-builtins.md b/gcc/config/s390/vx-builtins.md index 489bbeec22df..c4a837b177d7 100644 --- a/gcc/config/s390/vx-builtins.md +++ b/gcc/config/s390/vx-builtins.md @@ -150,7 +150,7 @@ (define_expand "vec_insert" [(set (match_operand:V_HW 0 "register_operand" "") (unspec:V_HW [(match_operand: 2 "register_operand" "") - (match_operand:SI 3 "shift_count_or_setmem_operand" "") + (match_operand:SI 3 "nonmemory_operand" "") (match_operand:V_HW 1 "register_operand" "")] UNSPEC_VEC_SET))] "TARGET_VX" @@ -160,7 +160,7 @@ (define_expand "vec_promote" [(set (match_operand:V_HW 0 "register_operand" "") (unspec:V_HW [(match_operand: 1 "register_operand" "") - (match_operand:SI 2 "shift_count_or_setmem_operand" "") + (match_operand:SI 2 "nonmemory_operand" "") (match_dup 0)] UNSPEC_VEC_SET))] "TARGET_VX" diff --git a/gcc/config/sol2.c b/gcc/config/sol2.c index 560a07b60605..47b41fd14085 100644 --- a/gcc/config/sol2.c +++ b/gcc/config/sol2.c @@ -142,8 +142,11 @@ solaris_assemble_visibility (tree decl, int vis ATTRIBUTE_UNUSED) }; const char *name, *type; + tree id = DECL_ASSEMBLER_NAME (decl); - name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); + while (IDENTIFIER_TRANSPARENT_ALIAS (id)) + id = TREE_CHAIN (id); + name = IDENTIFIER_POINTER (id); type = visibility_types[vis]; fprintf (asm_out_file, "\t.%s\t", type); diff --git a/gcc/config/sparc/sparc.c b/gcc/config/sparc/sparc.c index 71609f277010..080be617a5aa 100644 --- a/gcc/config/sparc/sparc.c +++ b/gcc/config/sparc/sparc.c @@ -518,7 +518,6 @@ int sparc_indent_opcode = 0; static void sparc_option_override (void); static void sparc_init_modes (void); -static void scan_record_type (const_tree, int *, int *, int *); static int function_arg_slotno (const CUMULATIVE_ARGS *, machine_mode, const_tree, bool, bool, int *, int *); @@ -6086,8 +6085,8 @@ conventions. */ #define SPARC_INT_ARG_MAX 6 /* Maximum number of fp regs for args. */ #define SPARC_FP_ARG_MAX 16 - -#define ROUND_ADVANCE(SIZE) (((SIZE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD) +/* Number of words (partially) occupied for a given size in units. */ +#define CEIL_NWORDS(SIZE) CEIL((SIZE), UNITS_PER_WORD) /* Handle the INIT_CUMULATIVE_ARGS macro. Initialize a variable CUM of type CUMULATIVE_ARGS @@ -6095,25 +6094,20 @@ conventions. */ For a library call, FNTYPE is 0. */ void -init_cumulative_args (struct sparc_args *cum, tree fntype, - rtx libname ATTRIBUTE_UNUSED, - tree fndecl ATTRIBUTE_UNUSED) +init_cumulative_args (struct sparc_args *cum, tree fntype, rtx, tree) { cum->words = 0; cum->prototype_p = fntype && prototype_p (fntype); - cum->libcall_p = fntype == 0; + cum->libcall_p = !fntype; } /* Handle promotion of pointer and integer arguments. */ static machine_mode -sparc_promote_function_mode (const_tree type, - machine_mode mode, - int *punsignedp, - const_tree fntype ATTRIBUTE_UNUSED, - int for_return ATTRIBUTE_UNUSED) +sparc_promote_function_mode (const_tree type, machine_mode mode, + int *punsignedp, const_tree, int) { - if (type != NULL_TREE && POINTER_TYPE_P (type)) + if (type && POINTER_TYPE_P (type)) { *punsignedp = POINTERS_EXTEND_UNSIGNED; return Pmode; @@ -6135,36 +6129,75 @@ sparc_strict_argument_naming (cumulative_args_t ca ATTRIBUTE_UNUSED) return TARGET_ARCH64 ? true : false; } -/* Scan the record type TYPE and return the following predicates: - - INTREGS_P: the record contains at least one field or sub-field - that is eligible for promotion in integer registers. - - FP_REGS_P: the record contains at least one field or sub-field - that is eligible for promotion in floating-point registers. - - PACKED_P: the record contains at least one field that is packed. */ +/* Traverse the record TYPE recursively and call FUNC on its fields. + NAMED is true if this is for a named parameter. DATA is passed + to FUNC for each field. OFFSET is the starting position and + PACKED is true if we are inside a packed record. */ +template static void -scan_record_type (const_tree type, int *intregs_p, int *fpregs_p, - int *packed_p) +traverse_record_type (const_tree type, bool named, T *data, + HOST_WIDE_INT offset = 0, bool packed = false) { - for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) - { - if (TREE_CODE (field) == FIELD_DECL) + /* The ABI obviously doesn't specify how packed structures are passed. + These are passed in integer regs if possible, otherwise memory. */ + if (!packed) + for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) + if (TREE_CODE (field) == FIELD_DECL && DECL_PACKED (field)) { - tree field_type = TREE_TYPE (field); + packed = true; + break; + } - if (TREE_CODE (field_type) == RECORD_TYPE) - scan_record_type (field_type, intregs_p, fpregs_p, packed_p); - else if ((FLOAT_TYPE_P (field_type) - || TREE_CODE (field_type) == VECTOR_TYPE) - && TARGET_FPU) - *fpregs_p = 1; - else - *intregs_p = 1; + /* Walk the real fields, but skip those with no size or a zero size. + ??? Fields with variable offset are handled as having zero offset. */ + for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) + if (TREE_CODE (field) == FIELD_DECL) + { + if (!DECL_SIZE (field) || integer_zerop (DECL_SIZE (field))) + continue; - if (DECL_PACKED (field)) - *packed_p = 1; - } + HOST_WIDE_INT bitpos = offset; + if (TREE_CODE (DECL_FIELD_OFFSET (field)) == INTEGER_CST) + bitpos += int_bit_position (field); + + tree field_type = TREE_TYPE (field); + if (TREE_CODE (field_type) == RECORD_TYPE) + traverse_record_type (field_type, named, data, bitpos, + packed); + else + { + const bool fp_type + = FLOAT_TYPE_P (field_type) || VECTOR_TYPE_P (field_type); + Func (field, bitpos, fp_type && named && !packed && TARGET_FPU, + data); + } + } +} + +/* Handle recursive register classifying for structure layout. */ + +typedef struct +{ + bool int_regs; /* true if field eligible to int registers. */ + bool fp_regs; /* true if field eligible to FP registers. */ + bool fp_regs_in_first_word; /* true if such field in first word. */ +} classify_data_t; + +/* A subroutine of function_arg_slotno. Classify the field. */ + +inline void +classify_registers (const_tree, HOST_WIDE_INT bitpos, bool fp, + classify_data_t *data) +{ + if (fp) + { + data->fp_regs = true; + if (bitpos < BITS_PER_WORD) + data->fp_regs_in_first_word = true; } + else + data->int_regs = true; } /* Compute the slot number to pass an argument in. @@ -6178,16 +6211,16 @@ scan_record_type (const_tree type, int *intregs_p, int *fpregs_p, not be available. NAMED is nonzero if this argument is a named parameter (otherwise it is an extra parameter matching an ellipsis). - INCOMING_P is zero for FUNCTION_ARG, nonzero for FUNCTION_INCOMING_ARG. + INCOMING is zero for FUNCTION_ARG, nonzero for FUNCTION_INCOMING_ARG. *PREGNO records the register number to use if scalar type. *PPADDING records the amount of padding needed in words. */ static int function_arg_slotno (const struct sparc_args *cum, machine_mode mode, - const_tree type, bool named, bool incoming_p, + const_tree type, bool named, bool incoming, int *pregno, int *ppadding) { - int regbase = (incoming_p + int regbase = (incoming ? SPARC_INCOMING_INT_ARG_FIRST : SPARC_OUTGOING_INT_ARG_FIRST); int slotno = cum->words; @@ -6243,8 +6276,10 @@ function_arg_slotno (const struct sparc_args *cum, machine_mode mode, case MODE_VECTOR_INT: if (TARGET_ARCH64 && TARGET_FPU && named) { + /* If all arg slots are filled, then must pass on stack. */ if (slotno >= SPARC_FP_ARG_MAX) return -1; + regno = SPARC_FP_ARG_FIRST + slotno * 2; /* Arguments filling only one single FP register are right-justified in the outer double FP register. */ @@ -6256,8 +6291,10 @@ function_arg_slotno (const struct sparc_args *cum, machine_mode mode, case MODE_INT: case MODE_COMPLEX_INT: + /* If all arg slots are filled, then must pass on stack. */ if (slotno >= SPARC_INT_ARG_MAX) return -1; + regno = regbase + slotno; break; @@ -6270,42 +6307,43 @@ function_arg_slotno (const struct sparc_args *cum, machine_mode mode, if (TARGET_ARCH32 || !type - || (TREE_CODE (type) != VECTOR_TYPE - && TREE_CODE (type) != RECORD_TYPE)) + || (TREE_CODE (type) != RECORD_TYPE + && TREE_CODE (type) != VECTOR_TYPE)) { + /* If all arg slots are filled, then must pass on stack. */ if (slotno >= SPARC_INT_ARG_MAX) return -1; + regno = regbase + slotno; } else /* TARGET_ARCH64 && type */ { - int intregs_p = 0, fpregs_p = 0, packed_p = 0; - - /* First see what kinds of registers we would need. */ - if (TREE_CODE (type) == VECTOR_TYPE) - fpregs_p = 1; - else - scan_record_type (type, &intregs_p, &fpregs_p, &packed_p); - - /* The ABI obviously doesn't specify how packed structures - are passed. These are defined to be passed in int regs - if possible, otherwise memory. */ - if (packed_p || !named) - fpregs_p = 0, intregs_p = 1; - /* If all arg slots are filled, then must pass on stack. */ - if (fpregs_p && slotno >= SPARC_FP_ARG_MAX) + if (slotno >= SPARC_FP_ARG_MAX) return -1; - /* If there are only int args and all int arg slots are filled, - then must pass on stack. */ - if (!fpregs_p && intregs_p && slotno >= SPARC_INT_ARG_MAX) - return -1; + if (TREE_CODE (type) == RECORD_TYPE) + { + classify_data_t data = { false, false, false }; + traverse_record_type + (type, named, &data); + + /* If all slots are filled except for the last one, but there + is no FP field in the first word, then must pass on stack. */ + if (data.fp_regs + && !data.fp_regs_in_first_word + && slotno >= SPARC_FP_ARG_MAX - 1) + return -1; + + /* If there are only int args and all int slots are filled, + then must pass on stack. */ + if (!data.fp_regs + && data.int_regs + && slotno >= SPARC_INT_ARG_MAX) + return -1; + } - /* Note that even if all int arg slots are filled, fp members may - still be passed in regs if such regs are available. - *PREGNO isn't set because there may be more than one, it's up - to the caller to compute them. */ + /* PREGNO isn't set since both int and FP regs can be used. */ return slotno; } break; @@ -6318,277 +6356,211 @@ function_arg_slotno (const struct sparc_args *cum, machine_mode mode, return slotno; } -/* Handle recursive register counting for structure field layout. */ +/* Handle recursive register counting/assigning for structure layout. */ -struct function_arg_record_value_parms +typedef struct { - rtx ret; /* return expression being built. */ int slotno; /* slot number of the argument. */ - int named; /* whether the argument is named. */ int regbase; /* regno of the base register. */ - int stack; /* 1 if part of the argument is on the stack. */ int intoffset; /* offset of the first pending integer field. */ - unsigned int nregs; /* number of words passed in registers. */ -}; - -static void function_arg_record_value_3 - (HOST_WIDE_INT, struct function_arg_record_value_parms *); -static void function_arg_record_value_2 - (const_tree, HOST_WIDE_INT, struct function_arg_record_value_parms *, bool); -static void function_arg_record_value_1 - (const_tree, HOST_WIDE_INT, struct function_arg_record_value_parms *, bool); -static rtx function_arg_record_value (const_tree, machine_mode, int, int, int); -static rtx function_arg_union_value (int, machine_mode, int, int); + int nregs; /* number of words passed in registers. */ + bool stack; /* true if part of the argument is on the stack. */ + rtx ret; /* return expression being built. */ +} assign_data_t; -/* A subroutine of function_arg_record_value. Traverse the structure - recursively and determine how many registers will be required. */ +/* A subroutine of function_arg_record_value. Compute the number of integer + registers to be assigned between PARMS->intoffset and BITPOS. Return + true if at least one integer register is assigned or false otherwise. */ -static void -function_arg_record_value_1 (const_tree type, HOST_WIDE_INT startbitpos, - struct function_arg_record_value_parms *parms, - bool packed_p) +static bool +compute_int_layout (HOST_WIDE_INT bitpos, assign_data_t *data, int *pnregs) { - tree field; + if (data->intoffset < 0) + return false; - /* We need to compute how many registers are needed so we can - allocate the PARALLEL but before we can do that we need to know - whether there are any packed fields. The ABI obviously doesn't - specify how structures are passed in this case, so they are - defined to be passed in int regs if possible, otherwise memory, - regardless of whether there are fp values present. */ + const int intoffset = data->intoffset; + data->intoffset = -1; - if (! packed_p) - for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) - { - if (TREE_CODE (field) == FIELD_DECL && DECL_PACKED (field)) - { - packed_p = true; - break; - } - } + const int this_slotno = data->slotno + intoffset / BITS_PER_WORD; + const unsigned int startbit = ROUND_DOWN (intoffset, BITS_PER_WORD); + const unsigned int endbit = ROUND_UP (bitpos, BITS_PER_WORD); + int nregs = (endbit - startbit) / BITS_PER_WORD; - /* Compute how many registers we need. */ - for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) + if (nregs > 0 && nregs > SPARC_INT_ARG_MAX - this_slotno) { - if (TREE_CODE (field) == FIELD_DECL) - { - HOST_WIDE_INT bitpos = startbitpos; + nregs = SPARC_INT_ARG_MAX - this_slotno; - if (DECL_SIZE (field) != 0) - { - if (integer_zerop (DECL_SIZE (field))) - continue; + /* We need to pass this field (partly) on the stack. */ + data->stack = 1; + } - if (tree_fits_uhwi_p (bit_position (field))) - bitpos += int_bit_position (field); - } + if (nregs <= 0) + return false; - /* ??? FIXME: else assume zero offset. */ - - if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE) - function_arg_record_value_1 (TREE_TYPE (field), - bitpos, - parms, - packed_p); - else if ((FLOAT_TYPE_P (TREE_TYPE (field)) - || TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE) - && TARGET_FPU - && parms->named - && ! packed_p) - { - if (parms->intoffset != -1) - { - unsigned int startbit, endbit; - int intslots, this_slotno; + *pnregs = nregs; + return true; +} - startbit = ROUND_DOWN (parms->intoffset, BITS_PER_WORD); - endbit = ROUND_UP (bitpos, BITS_PER_WORD); +/* A subroutine of function_arg_record_value. Compute the number and the mode + of the FP registers to be assigned for FIELD. Return true if at least one + FP register is assigned or false otherwise. */ - intslots = (endbit - startbit) / BITS_PER_WORD; - this_slotno = parms->slotno + parms->intoffset - / BITS_PER_WORD; +static bool +compute_fp_layout (const_tree field, HOST_WIDE_INT bitpos, + assign_data_t *data, + int *pnregs, machine_mode *pmode) +{ + const int this_slotno = data->slotno + bitpos / BITS_PER_WORD; + machine_mode mode = DECL_MODE (field); + int nregs, nslots; - if (intslots > 0 && intslots > SPARC_INT_ARG_MAX - this_slotno) - { - intslots = MAX (0, SPARC_INT_ARG_MAX - this_slotno); - /* We need to pass this field on the stack. */ - parms->stack = 1; - } + /* Slots are counted as words while regs are counted as having the size of + the (inner) mode. */ + if (TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE && mode == BLKmode) + { + mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (field))); + nregs = TYPE_VECTOR_SUBPARTS (TREE_TYPE (field)); + } + else if (TREE_CODE (TREE_TYPE (field)) == COMPLEX_TYPE) + { + mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (field))); + nregs = 2; + } + else + nregs = 1; - parms->nregs += intslots; - parms->intoffset = -1; - } + nslots = CEIL_NWORDS (nregs * GET_MODE_SIZE (mode)); - /* There's no need to check this_slotno < SPARC_FP_ARG MAX. - If it wasn't true we wouldn't be here. */ - if (TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE - && DECL_MODE (field) == BLKmode) - parms->nregs += TYPE_VECTOR_SUBPARTS (TREE_TYPE (field)); - else if (TREE_CODE (TREE_TYPE (field)) == COMPLEX_TYPE) - parms->nregs += 2; - else - parms->nregs += 1; - } - else - { - if (parms->intoffset == -1) - parms->intoffset = bitpos; - } - } + if (nslots > SPARC_FP_ARG_MAX - this_slotno) + { + nslots = SPARC_FP_ARG_MAX - this_slotno; + nregs = (nslots * UNITS_PER_WORD) / GET_MODE_SIZE (mode); + + /* We need to pass this field (partly) on the stack. */ + data->stack = 1; + + if (nregs <= 0) + return false; } + + *pnregs = nregs; + *pmode = mode; + return true; } -/* A subroutine of function_arg_record_value. Assign the bits of the - structure between parms->intoffset and bitpos to integer registers. */ +/* A subroutine of function_arg_record_value. Count the number of registers + to be assigned for FIELD and between PARMS->intoffset and BITPOS. */ -static void -function_arg_record_value_3 (HOST_WIDE_INT bitpos, - struct function_arg_record_value_parms *parms) +inline void +count_registers (const_tree field, HOST_WIDE_INT bitpos, bool fp, + assign_data_t *data) { - machine_mode mode; - unsigned int regno; - unsigned int startbit, endbit; - int this_slotno, intslots, intoffset; - rtx reg; + if (fp) + { + int nregs; + machine_mode mode; - if (parms->intoffset == -1) - return; + if (compute_int_layout (bitpos, data, &nregs)) + data->nregs += nregs; - intoffset = parms->intoffset; - parms->intoffset = -1; + if (compute_fp_layout (field, bitpos, data, &nregs, &mode)) + data->nregs += nregs; + } + else + { + if (data->intoffset < 0) + data->intoffset = bitpos; + } +} - startbit = ROUND_DOWN (intoffset, BITS_PER_WORD); - endbit = ROUND_UP (bitpos, BITS_PER_WORD); - intslots = (endbit - startbit) / BITS_PER_WORD; - this_slotno = parms->slotno + intoffset / BITS_PER_WORD; +/* A subroutine of function_arg_record_value. Assign the bits of the + structure between PARMS->intoffset and BITPOS to integer registers. */ + +static void +assign_int_registers (HOST_WIDE_INT bitpos, assign_data_t *data) +{ + int intoffset = data->intoffset; + machine_mode mode; + int nregs; - intslots = MIN (intslots, SPARC_INT_ARG_MAX - this_slotno); - if (intslots <= 0) + if (!compute_int_layout (bitpos, data, &nregs)) return; /* If this is the trailing part of a word, only load that much into the register. Otherwise load the whole register. Note that in the latter case we may pick up unwanted bits. It's not a problem at the moment but may wish to revisit. */ - if (intoffset % BITS_PER_WORD != 0) mode = smallest_mode_for_size (BITS_PER_WORD - intoffset % BITS_PER_WORD, MODE_INT); else mode = word_mode; + const int this_slotno = data->slotno + intoffset / BITS_PER_WORD; + unsigned int regno = data->regbase + this_slotno; intoffset /= BITS_PER_UNIT; + do { - regno = parms->regbase + this_slotno; - reg = gen_rtx_REG (mode, regno); - XVECEXP (parms->ret, 0, parms->stack + parms->nregs) + rtx reg = gen_rtx_REG (mode, regno); + XVECEXP (data->ret, 0, data->stack + data->nregs) = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (intoffset)); - - this_slotno += 1; - intoffset = (intoffset | (UNITS_PER_WORD-1)) + 1; + data->nregs += 1; mode = word_mode; - parms->nregs += 1; - intslots -= 1; + regno += 1; + intoffset = (intoffset | (UNITS_PER_WORD - 1)) + 1; } - while (intslots > 0); + while (--nregs > 0); } -/* A subroutine of function_arg_record_value. Traverse the structure - recursively and assign bits to floating point registers. Track which - bits in between need integer registers; invoke function_arg_record_value_3 - to make that happen. */ +/* A subroutine of function_arg_record_value. Assign FIELD at position + BITPOS to FP registers. */ static void -function_arg_record_value_2 (const_tree type, HOST_WIDE_INT startbitpos, - struct function_arg_record_value_parms *parms, - bool packed_p) +assign_fp_registers (const_tree field, HOST_WIDE_INT bitpos, + assign_data_t *data) { - tree field; + int nregs; + machine_mode mode; - if (! packed_p) - for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) - { - if (TREE_CODE (field) == FIELD_DECL && DECL_PACKED (field)) - { - packed_p = true; - break; - } - } + if (!compute_fp_layout (field, bitpos, data, &nregs, &mode)) + return; + + const int this_slotno = data->slotno + bitpos / BITS_PER_WORD; + int regno = SPARC_FP_ARG_FIRST + this_slotno * 2; + if (GET_MODE_SIZE (mode) <= 4 && (bitpos & 32) != 0) + regno++; + int pos = bitpos / BITS_PER_UNIT; - for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) + do { - if (TREE_CODE (field) == FIELD_DECL) - { - HOST_WIDE_INT bitpos = startbitpos; + rtx reg = gen_rtx_REG (mode, regno); + XVECEXP (data->ret, 0, data->stack + data->nregs) + = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (pos)); + data->nregs += 1; + regno += GET_MODE_SIZE (mode) / 4; + pos += GET_MODE_SIZE (mode); + } + while (--nregs > 0); +} - if (DECL_SIZE (field) != 0) - { - if (integer_zerop (DECL_SIZE (field))) - continue; +/* A subroutine of function_arg_record_value. Assign FIELD and the bits of + the structure between PARMS->intoffset and BITPOS to registers. */ - if (tree_fits_uhwi_p (bit_position (field))) - bitpos += int_bit_position (field); - } +inline void +assign_registers (const_tree field, HOST_WIDE_INT bitpos, bool fp, + assign_data_t *data) +{ + if (fp) + { + assign_int_registers (bitpos, data); - /* ??? FIXME: else assume zero offset. */ - - if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE) - function_arg_record_value_2 (TREE_TYPE (field), - bitpos, - parms, - packed_p); - else if ((FLOAT_TYPE_P (TREE_TYPE (field)) - || TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE) - && TARGET_FPU - && parms->named - && ! packed_p) - { - int this_slotno = parms->slotno + bitpos / BITS_PER_WORD; - int regno, nregs, pos; - machine_mode mode = DECL_MODE (field); - rtx reg; - - function_arg_record_value_3 (bitpos, parms); - - if (TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE - && mode == BLKmode) - { - mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (field))); - nregs = TYPE_VECTOR_SUBPARTS (TREE_TYPE (field)); - } - else if (TREE_CODE (TREE_TYPE (field)) == COMPLEX_TYPE) - { - mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (field))); - nregs = 2; - } - else - nregs = 1; - - regno = SPARC_FP_ARG_FIRST + this_slotno * 2; - if (GET_MODE_SIZE (mode) <= 4 && (bitpos & 32) != 0) - regno++; - reg = gen_rtx_REG (mode, regno); - pos = bitpos / BITS_PER_UNIT; - XVECEXP (parms->ret, 0, parms->stack + parms->nregs) - = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (pos)); - parms->nregs += 1; - while (--nregs > 0) - { - regno += GET_MODE_SIZE (mode) / 4; - reg = gen_rtx_REG (mode, regno); - pos += GET_MODE_SIZE (mode); - XVECEXP (parms->ret, 0, parms->stack + parms->nregs) - = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (pos)); - parms->nregs += 1; - } - } - else - { - if (parms->intoffset == -1) - parms->intoffset = bitpos; - } - } + assign_fp_registers (field, bitpos, data); + } + else + { + if (data->intoffset < 0) + data->intoffset = bitpos; } } @@ -6602,52 +6574,33 @@ function_arg_record_value_2 (const_tree type, HOST_WIDE_INT startbitpos, not be available. MODE is the argument's machine mode. SLOTNO is the index number of the argument's slot in the parameter array. - NAMED is nonzero if this argument is a named parameter + NAMED is true if this argument is a named parameter (otherwise it is an extra parameter matching an ellipsis). REGBASE is the regno of the base register for the parameter array. */ static rtx function_arg_record_value (const_tree type, machine_mode mode, - int slotno, int named, int regbase) + int slotno, bool named, int regbase) { HOST_WIDE_INT typesize = int_size_in_bytes (type); - struct function_arg_record_value_parms parms; - unsigned int nregs; + assign_data_t data; + int nregs; - parms.ret = NULL_RTX; - parms.slotno = slotno; - parms.named = named; - parms.regbase = regbase; - parms.stack = 0; + data.slotno = slotno; + data.regbase = regbase; - /* Compute how many registers we need. */ - parms.nregs = 0; - parms.intoffset = 0; - function_arg_record_value_1 (type, 0, &parms, false); + /* Count how many registers we need. */ + data.nregs = 0; + data.intoffset = 0; + data.stack = false; + traverse_record_type (type, named, &data); /* Take into account pending integer fields. */ - if (parms.intoffset != -1) - { - unsigned int startbit, endbit; - int intslots, this_slotno; - - startbit = ROUND_DOWN (parms.intoffset, BITS_PER_WORD); - endbit = ROUND_UP (typesize*BITS_PER_UNIT, BITS_PER_WORD); - intslots = (endbit - startbit) / BITS_PER_WORD; - this_slotno = slotno + parms.intoffset / BITS_PER_WORD; - - if (intslots > 0 && intslots > SPARC_INT_ARG_MAX - this_slotno) - { - intslots = MAX (0, SPARC_INT_ARG_MAX - this_slotno); - /* We need to pass this field on the stack. */ - parms.stack = 1; - } - - parms.nregs += intslots; - } + if (compute_int_layout (typesize * BITS_PER_UNIT, &data, &nregs)) + data.nregs += nregs; /* Allocate the vector and handle some annoying special cases. */ - nregs = parms.nregs; + nregs = data.nregs; if (nregs == 0) { @@ -6670,7 +6623,7 @@ function_arg_record_value (const_tree type, machine_mode mode, gcc_assert (nregs > 0); - parms.ret = gen_rtx_PARALLEL (mode, rtvec_alloc (parms.stack + nregs)); + data.ret = gen_rtx_PARALLEL (mode, rtvec_alloc (data.stack + nregs)); /* If at least one field must be passed on the stack, generate (parallel [(expr_list (nil) ...) ...]) so that all fields will @@ -6678,19 +6631,21 @@ function_arg_record_value (const_tree type, machine_mode mode, semantics of TARGET_ARG_PARTIAL_BYTES doesn't handle the case of structures for which the fields passed exclusively in registers are not at the beginning of the structure. */ - if (parms.stack) - XVECEXP (parms.ret, 0, 0) + if (data.stack) + XVECEXP (data.ret, 0, 0) = gen_rtx_EXPR_LIST (VOIDmode, NULL_RTX, const0_rtx); - /* Fill in the entries. */ - parms.nregs = 0; - parms.intoffset = 0; - function_arg_record_value_2 (type, 0, &parms, false); - function_arg_record_value_3 (typesize * BITS_PER_UNIT, &parms); + /* Assign the registers. */ + data.nregs = 0; + data.intoffset = 0; + traverse_record_type (type, named, &data); - gcc_assert (parms.nregs == nregs); + /* Assign pending integer fields. */ + assign_int_registers (typesize * BITS_PER_UNIT, &data); - return parms.ret; + gcc_assert (data.nregs == nregs); + + return data.ret; } /* Used by function_arg and sparc_function_value_1 to implement the conventions @@ -6706,7 +6661,7 @@ static rtx function_arg_union_value (int size, machine_mode mode, int slotno, int regno) { - int nwords = ROUND_ADVANCE (size), i; + int nwords = CEIL_NWORDS (size), i; rtx regs; /* See comment in previous function for empty structures. */ @@ -6777,17 +6732,17 @@ function_arg_vector_value (int size, int regno) static rtx sparc_function_arg_1 (cumulative_args_t cum_v, machine_mode mode, - const_tree type, bool named, bool incoming_p) + const_tree type, bool named, bool incoming) { const CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); - int regbase = (incoming_p + int regbase = (incoming ? SPARC_INCOMING_INT_ARG_FIRST : SPARC_OUTGOING_INT_ARG_FIRST); int slotno, regno, padding; enum mode_class mclass = GET_MODE_CLASS (mode); - slotno = function_arg_slotno (cum, mode, type, named, incoming_p, + slotno = function_arg_slotno (cum, mode, type, named, incoming, ®no, &padding); if (slotno == -1) return 0; @@ -6837,35 +6792,7 @@ sparc_function_arg_1 (cumulative_args_t cum_v, machine_mode mode, { rtx reg = gen_rtx_REG (mode, regno); if (cum->prototype_p || cum->libcall_p) - { - /* "* 2" because fp reg numbers are recorded in 4 byte - quantities. */ -#if 0 - /* ??? This will cause the value to be passed in the fp reg and - in the stack. When a prototype exists we want to pass the - value in the reg but reserve space on the stack. That's an - optimization, and is deferred [for a bit]. */ - if ((regno - SPARC_FP_ARG_FIRST) >= SPARC_INT_ARG_MAX * 2) - return gen_rtx_PARALLEL (mode, - gen_rtvec (2, - gen_rtx_EXPR_LIST (VOIDmode, - NULL_RTX, const0_rtx), - gen_rtx_EXPR_LIST (VOIDmode, - reg, const0_rtx))); - else -#else - /* ??? It seems that passing back a register even when past - the area declared by REG_PARM_STACK_SPACE will allocate - space appropriately, and will not copy the data onto the - stack, exactly as we desire. - - This is due to locate_and_pad_parm being called in - expand_call whenever reg_parm_stack_space > 0, which - while beneficial to our example here, would seem to be - in error from what had been intended. Ho hum... -- r~ */ -#endif - return reg; - } + return reg; else { rtx v0, v1; @@ -6877,7 +6804,7 @@ sparc_function_arg_1 (cumulative_args_t cum_v, machine_mode mode, /* On incoming, we don't need to know that the value is passed in %f0 and %i0, and it confuses other parts causing needless spillage even on the simplest cases. */ - if (incoming_p) + if (incoming) return reg; intreg = (SPARC_OUTGOING_INT_ARG_FIRST @@ -6956,7 +6883,7 @@ sparc_arg_partial_bytes (cumulative_args_t cum, machine_mode mode, { int slotno, regno, padding; - /* We pass false for incoming_p here, it doesn't matter. */ + /* We pass false for incoming here, it doesn't matter. */ slotno = function_arg_slotno (get_cumulative_args (cum), mode, type, named, false, ®no, &padding); @@ -6966,8 +6893,8 @@ sparc_arg_partial_bytes (cumulative_args_t cum, machine_mode mode, if (TARGET_ARCH32) { if ((slotno + (mode == BLKmode - ? ROUND_ADVANCE (int_size_in_bytes (type)) - : ROUND_ADVANCE (GET_MODE_SIZE (mode)))) + ? CEIL_NWORDS (int_size_in_bytes (type)) + : CEIL_NWORDS (GET_MODE_SIZE (mode)))) > SPARC_INT_ARG_MAX) return (SPARC_INT_ARG_MAX - slotno) * UNITS_PER_WORD; } @@ -6982,7 +6909,8 @@ sparc_arg_partial_bytes (cumulative_args_t cum, machine_mode mode, int size = int_size_in_bytes (type); if (size > UNITS_PER_WORD - && slotno == SPARC_INT_ARG_MAX - 1) + && (slotno == SPARC_INT_ARG_MAX - 1 + || slotno == SPARC_FP_ARG_MAX - 1)) return UNITS_PER_WORD; } else if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT @@ -7068,18 +6996,16 @@ sparc_function_arg_advance (cumulative_args_t cum_v, machine_mode mode, CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); int regno, padding; - /* We pass false for incoming_p here, it doesn't matter. */ + /* We pass false for incoming here, it doesn't matter. */ function_arg_slotno (cum, mode, type, named, false, ®no, &padding); /* If argument requires leading padding, add it. */ cum->words += padding; if (TARGET_ARCH32) - { - cum->words += (mode != BLKmode - ? ROUND_ADVANCE (GET_MODE_SIZE (mode)) - : ROUND_ADVANCE (int_size_in_bytes (type))); - } + cum->words += (mode == BLKmode + ? CEIL_NWORDS (int_size_in_bytes (type)) + : CEIL_NWORDS (GET_MODE_SIZE (mode))); else { if (type && AGGREGATE_TYPE_P (type)) @@ -7094,11 +7020,9 @@ sparc_function_arg_advance (cumulative_args_t cum_v, machine_mode mode, ++cum->words; } else - { - cum->words += (mode != BLKmode - ? ROUND_ADVANCE (GET_MODE_SIZE (mode)) - : ROUND_ADVANCE (int_size_in_bytes (type))); - } + cum->words += (mode == BLKmode + ? CEIL_NWORDS (int_size_in_bytes (type)) + : CEIL_NWORDS (GET_MODE_SIZE (mode))); } } @@ -7109,7 +7033,7 @@ sparc_function_arg_advance (cumulative_args_t cum_v, machine_mode mode, enum direction function_arg_padding (machine_mode mode, const_tree type) { - if (TARGET_ARCH64 && type != 0 && AGGREGATE_TYPE_P (type)) + if (TARGET_ARCH64 && type && AGGREGATE_TYPE_P (type)) return upward; /* Fall back to the default. */ diff --git a/gcc/config/sparc/vxworks.h b/gcc/config/sparc/vxworks.h index 1bcbace2886e..81e0ffb2c760 100644 --- a/gcc/config/sparc/vxworks.h +++ b/gcc/config/sparc/vxworks.h @@ -55,3 +55,10 @@ along with GCC; see the file COPYING3. If not see /* We cannot use PC-relative accesses for VxWorks PIC because there is no fixed gap between segments. */ #undef ASM_PREFERRED_EH_DATA_FORMAT + +/* Define this to be nonzero if static stack checking is supported. */ +#define STACK_CHECK_STATIC_BUILTIN 1 + +/* This platform supports the probing method of stack checking (RTP mode). + 8K is reserved in the stack to propagate exceptions in case of overflow. */ +#define STACK_CHECK_PROTECT 8192 diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index ec991201009f..5cb8eaa252ca 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,353 @@ +2016-03-25 Jason Merrill + Martin Liška + + PR c++/64266 + PR c++/70353 + Core issue 1962 + * decl.c (cp_fname_init): Decay the initializer to pointer. + (cp_make_fname_decl): Set DECL_DECLARED_CONSTEXPR_P, + DECL_VALUE_EXPR, DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P. + Don't call cp_finish_decl. + * pt.c (tsubst_expr) [DECL_EXPR]: Set DECL_VALUE_EXPR, + DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P. Don't call cp_finish_decl. + * constexpr.c (cxx_eval_constant_expression) [VAR_DECL]: + Handle DECL_VALUE_EXPR. + +2016-03-24 Jason Merrill + + PR c++/70386 + * constexpr.c (cxx_eval_bare_aggregate): Handle PMFs. + + PR c++/70323 + * constexpr.c (cxx_eval_call_expression): Don't cache result if + *overflow_p. + +2016-03-24 Patrick Palka + + PR c++/62212 + * tree.c (build_cplus_array_type): Determine type-dependentess + with uses_template_parms instead of with dependent_type_p. + +2016-03-23 Patrick Palka + + PR c++/70347 + * typeck.c (process_init_constructor_union): If the initializer + is empty, use the union's NSDMI if it has one. + +2016-03-23 Patrick Palka + + PR c++/70332 + * pt.c (tsubst_copy) [PARM_DECL]: Handle the use of 'this' in an + NSDMI that's part of an aggregrate initialization. + +2016-03-23 Jakub Jelinek + + PR c++/70001 + * constexpr.c (cxx_eval_vec_init_1): Reuse CONSTRUCTOR initializers + for 1..max even for multi-dimensional arrays. Call unshare_expr + on it. + + PR c++/70323 + * constexpr.c (cxx_eval_constant_expression): Diagnose overflow + on TREE_OVERFLOW constants. + + PR c++/70376 + * cp-gimplify.c (genericize_omp_for_stmt): Don't walk OMP_FOR_CLAUSES + for OMP_TASKLOOP here. + (cp_genericize_r): Handle OMP_TASKLOOP like OMP_TASK, except do call + genericize_omp_for_stmt instead of cp_walk_tree on OMP_BODY. + +2016-03-23 Alexandre Oliva + Jason Merrill + Jakub Jelinek + + PR c++/69315 + * cp-tree.h (defer_mark_used_calls, deferred_mark_used_calls): Remove. + * decl.c (defer_mark_used_calls, deferred_mark_used_calls): Remove. + (finish_function): Don't set or test them. + * decl2.c (mark_used): Don't handle defer_mark_used_calls. + +2016-03-23 Jason Merrill + + PR c++/70344 + * constexpr.c (cxx_eval_call_expression): Catch invalid recursion. + +2016-03-23 Marek Polacek + + PR c++/69884 + * pt.c (canonicalize_type_argument): Use OPT_Wignored_attributes. + +2016-03-22 Ilya Enkovich + + * call.c (build_conditional_expr_1): Always use original + condition type for vector type checks and build. + +2016-03-22 Patrick Palka + + PR c++/70096 + * pt.c (tsubst_decl): Clear the DECL_MODE of the new decl. + +2016-03-22 Patrick Palka + + PR c++/70204 + * constexpr.c (non_const_var_error): Check + DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P. + +2016-03-21 Richard Henderson + + PR c++/70273 + * decl.c (notice_forced_label_r): New. + (cp_finish_decl): Use it. + +2016-03-21 Jason Merrill + + PR c++/70285 + * cp-gimplify.c (cp_fold) [COND_EXPR]: Handle bit-fields. + +2016-03-18 Jason Merrill + + PR c++/70139 + * constexpr.c (cxx_eval_call_expression): Fix trivial copy. + + PR c++/70147 + * class.c (vptr_via_virtual_p): New. + (most_primary_binfo): Factor out of build_rtti_vtbl_entries. + * cp-ubsan.c (cp_ubsan_dfs_initialize_vtbl_ptrs): Don't clear + a vptr from any virtual base in a not-in-charge 'structor. + + * decl.c (build_clobber_this): Factor out of + start_preparsed_function and begin_destructor_body. Handle + virtual bases better. + + * class.c (build_if_in_charge): Split out from build_base_path. + * init.c (expand_virtual_init, expand_default_init): Use it. + * call.c (build_special_member_call): Use it. + +2016-03-18 Jakub Jelinek + + PR c++/70267 + * init.c (build_new_1): Complain and return error_mark_node + if alloc_fn is not _Jv_AllocObject function returning pointer. + +2016-03-18 Patrick Palka + + PR c++/70205 + * search.c (adjust_result_of_qualified_name_lookup): Don't + update the BASELINK_BINFO of DECL if the second call + to lookup_base fails. + +2016-03-18 Patrick Palka + + PR c++/70218 + * parser.c (cp_parser_lambda_expression): Move call to + pop_deferring_access_checks ahead of the call to + cp_parser_end_tentative_firewall. + +2016-03-17 Jakub Jelinek + + PR c++/70144 + * cp-tree.h (magic_varargs_p): Return int instead of bool. + * call.c (magic_varargs_p): Return int instead of bool, return 2 for + Cilk+ reductions, otherwise 1 for magic varargs and 0 for normal + varargs. + (build_over_call): If magic_varargs_p == 2, call reject_gcc_builtin, + if magic_varargs_p == 1, call decay_conversion + instead of mark_type_use. Don't store error_mark_node arguments to + argarray, instead return error_mark_node. + + PR c++/70272 + * decl.c (begin_destructor_body): Don't insert clobber if + is_empty_class (current_class_type). + +2016-03-17 Marek Polacek + + PR c++/70194 + * typeck.c (warn_for_null_address): New function. + (cp_build_binary_op): Call it. + +2016-03-16 Jason Merrill + + PR c++/70259 + * decl.c (start_preparsed_function): Don't clobber an empty base. + +2016-03-16 Jakub Jelinek + + PR c++/70147 + * cp-ubsan.c (cp_ubsan_dfs_initialize_vtbl_ptrs): Conditionalize + BINFO_VIRTUAL_P vtable clearing on current_in_charge_parm. + + PR c++/70147 + * cp-ubsan.c (cp_ubsan_maybe_initialize_vtbl_ptrs): Temporarily + set in_base_initializer. + +2016-03-15 Marek Polacek + + PR c++/70209 + * tree.c (strip_typedefs): Call strip_typedefs again on the + DECL_ORIGINAL_TYPE result. + +2016-03-15 Jason Merrill + + PR c++/70095 + * pt.c (instantiate_decl): Fix call to variable_template_p. + + PR c++/70141 + * pt.c (for_each_template_parm_r): Always walk into TYPENAME_TYPE. + +2016-03-14 Casey Carter + Jason Merrill + + P0184R0: Generalizing the Range-Based For Loop + * parser.c (cp_convert_range_for): Set the type of __end separately. + (cp_parser_perform_range_for_lookup): Allow different begin/end + types if they are comparable. + +2016-03-12 Patrick Palka + + PR c++/70106 + * semantics.c (force_paren_expr): Just build a PAREN_EXPR when + processing_template_decl and EXPR is a SCOPE_REF. + +2016-03-10 Patrick Palka + Jakub Jelinek + + PR c++/70001 + * constexpr.c (cxx_eval_vec_init_1): For pre_init case, reuse + return value from cxx_eval_constant_expression from earlier + elements if it is valid constant initializer requiring no + relocations. + +2016-03-10 Marek Polacek + + PR c++/70153 + * cp-gimplify.c (cp_fold): Handle UNARY_PLUS_EXPR. + +2016-03-09 Cesar Philippidis + + * parser.c (cp_parser_oacc_loop): Update cclauses and clauses + when calling c_finish_omp_clauses. + +2016-03-08 Jason Merrill + + * parser.c (cp_parser_diagnose_invalid_type_name): Give helpful + diagnostic for use of "concept". + (cp_parser_requires_clause_opt): And "requires". + (cp_parser_type_parameter, cp_parser_late_return_type_opt) + (cp_parser_explicit_template_declaration): Adjust. + * Make-lang.in (check-c++-all): Add "concepts" to std list. + + P0036R0: Unary Folds and Empty Parameter Packs + * pt.c (expand_empty_fold): Remove special cases for *,+,&,|. + +2016-03-08 Jakub Jelinek + + PR c++/70135 + * constexpr.c (cxx_eval_loop_expr): Forget saved values of SAVE_EXPRs + even after the last iteration of the loop. + + * decl.c (duplicate_decls): Fix spelling - becuase -> because. + +2016-03-07 Patrick Palka + + PR c++/66786 + * pt.c (get_template_info): Handle PARM_DECL. + (template_class_depth): Check DECL_P instead of + VAR_OR_FUNCTION_DECL_P. + +2016-03-05 Jason Merrill + + PR c++/67364 + * constexpr.c (cxx_eval_store_expression): Replace + CONSTRUCTOR_ELTS in nested CONSTRUCTORs, too. + +2016-03-05 Patrick Palka + + PR c++/66786 + * pt.c (template_class_depth): Given a lambda type, iterate + into its LAMBDA_TYPE_EXTRA_SCOPE field instead of its + TYPE_CONTEXT. Given a VAR_DECL, iterate into its + CP_DECL_CONTEXT. + +2016-03-04 Jason Merrill + + PR c++/69203 + * cp-tree.h (COND_EXPR_IS_VEC_DELETE): New. + * init.c (build_vec_delete_1): Set it. + * constexpr.c (potential_constant_expression_1) [COND_EXPR]: Check it. + +2016-03-04 Jakub Jelinek + + * decl.c (start_preparsed_function): Don't emit start clobber at the + start of constructor clones. + + PR c++/70035 + * cp-tree.h (cp_ubsan_maybe_initialize_vtbl_ptrs): New prototype. + * decl.c (start_preparsed_function): Call + cp_ubsan_maybe_initialize_vtbl_ptrs if needed. + * cp-ubsan.c (cp_ubsan_dfs_initialize_vtbl_ptrs, + cp_ubsan_maybe_initialize_vtbl_ptrs): New functions. + +2016-03-04 Jason Merrill + + PR c++/67364 + * constexpr.c (cxx_eval_component_reference): Further tweak. + + * constexpr.c (struct constexpr_ctx): Add save_exprs field. + (cxx_eval_loop_expr): Discard SAVE_EXPR values before looping. + (cxx_eval_constant_expression) [SAVE_EXPR]: Add it to the set. + (cxx_eval_outermost_constant_expr, is_sub_constant_expr): Initialize. + + PR c++/70067 + * tree.c (strip_typedefs): Handle TYPENAME_TYPE lookup finding the + same type. + +2016-03-03 Jason Merrill + + * method.c (synthesized_method_walk): operator= can also be constexpr. + + * pt.c (tsubst_copy_and_build) [LAMBDA_EXPR]: Get + LAMBDA_EXPR_RETURN_TYPE from the instantiated closure. + + PR c++/67164 + * pt.c (copy_template_args): New. + (tsubst_pack_expansion): Use it. + + * call.c (build_aggr_conv): Use get_nsdmi. + + PR c++/51406 + * typeck.c (build_static_cast_1): Avoid folding back to lvalue. + + PR c++/67364 + * constexpr.c (cxx_eval_component_reference): Just return an empty + CONSTRUCTOR for an empty class. + +2016-03-01 Jason Merrill + + PR c++/70036 + * parser.c (cp_parser_requires_clause): Call + check_for_bare_parameter_packs. + + PR c++/51489 + * constexpr.c (cxx_eval_binary_expression): Don't VERIFY_CONSTANT + the operands. + + PR c++/69995 + * constexpr.c (cxx_eval_call_expression): Unshare arg. + (cxx_eval_constant_expression) [DECL_EXPR]: Unshare init. + [TARGET_EXPR]: Unshare init. + +2016-03-01 Patrick Palka + + PR c++/68948 + PR c++/69961 + * pt.c (tsubst_baselink): Reinstate the check for an invalid + constructor call. + +2016-02-28 Jason Merrill + + PR c++/69995 + * constexpr.c (cxx_eval_store_expression): Unshare init. + 2016-02-26 Jason Merrill PR c++/69958 diff --git a/gcc/cp/Make-lang.in b/gcc/cp/Make-lang.in index 2286c64a8fb4..8770f6ff1bed 100644 --- a/gcc/cp/Make-lang.in +++ b/gcc/cp/Make-lang.in @@ -152,7 +152,7 @@ check-c++1z: # Run the testsuite in all standard conformance levels. check-c++-all: - $(MAKE) RUNTESTFLAGS="$(RUNTESTFLAGS) --stds=98,11,14,1z" check-g++ + $(MAKE) RUNTESTFLAGS="$(RUNTESTFLAGS) --stds=98,11,14,1z,concepts" check-g++ # Run the testsuite with garbage collection at every opportunity. check-g++-strict-gc: diff --git a/gcc/cp/call.c b/gcc/cp/call.c index 4226094969a1..ed234904a63d 100644 --- a/gcc/cp/call.c +++ b/gcc/cp/call.c @@ -1,4 +1,4 @@ -/* Functions related to invoking methods and overloaded functions. +/* Functions related to invoking -*- C++ -*- methods and overloaded functions. Copyright (C) 1987-2016 Free Software Foundation, Inc. Contributed by Michael Tiemann (tiemann@cygnus.com) and modified by Brendan Kehoe (brendan@cygnus.com). @@ -897,6 +897,8 @@ build_aggr_conv (tree type, tree ctor, int flags, tsubst_flags_t complain) if (i < CONSTRUCTOR_NELTS (ctor)) val = CONSTRUCTOR_ELT (ctor, i)->value; + else if (DECL_INITIAL (field)) + val = get_nsdmi (field, /*ctor*/false); else if (TREE_CODE (ftype) == REFERENCE_TYPE) /* Value-initialization of reference is ill-formed. */ return NULL; @@ -4632,6 +4634,8 @@ build_conditional_expr_1 (location_t loc, tree arg1, tree arg2, tree arg3, if (VECTOR_INTEGER_TYPE_P (TREE_TYPE (arg1))) { + tree arg1_type = TREE_TYPE (arg1); + /* If arg1 is another cond_expr choosing between -1 and 0, then we can use its comparison. It may help to avoid additional comparison, produce more accurate diagnostics @@ -4651,7 +4655,6 @@ build_conditional_expr_1 (location_t loc, tree arg1, tree arg2, tree arg3, || error_operand_p (arg3)) return error_mark_node; - tree arg1_type = TREE_TYPE (arg1); arg2_type = TREE_TYPE (arg2); arg3_type = TREE_TYPE (arg3); @@ -7038,15 +7041,17 @@ convert_for_arg_passing (tree type, tree val, tsubst_flags_t complain) return val; } -/* Returns true iff FN is a function with magic varargs, i.e. ones for - which no conversions at all should be done. This is true for some - builtins which don't act like normal functions. */ +/* Returns non-zero iff FN is a function with magic varargs, i.e. ones for + which just decay_conversion or no conversions at all should be done. + This is true for some builtins which don't act like normal functions. + Return 2 if no conversions at all should be done, 1 if just + decay_conversion. */ -bool +int magic_varargs_p (tree fn) { if (flag_cilkplus && is_cilkplus_reduce_builtin (fn) != BUILT_IN_NONE) - return true; + return 2; if (DECL_BUILT_IN (fn)) switch (DECL_FUNCTION_CODE (fn)) @@ -7055,14 +7060,14 @@ magic_varargs_p (tree fn) case BUILT_IN_CONSTANT_P: case BUILT_IN_NEXT_ARG: case BUILT_IN_VA_START: - return true; + return 1; default:; return lookup_attribute ("type generic", TYPE_ATTRIBUTES (TREE_TYPE (fn))) != 0; } - return false; + return 0; } /* Returns the decl of the dispatcher function if FN is a function version. */ @@ -7513,9 +7518,17 @@ 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_varargs_p (fn)) - /* Do no conversions for magic varargs. */ - a = mark_type_use (a); + int magic = magic_varargs_p (fn); + if (magic == 2) + { + /* Do no conversions for certain magic varargs. */ + a = mark_type_use (a); + if (TREE_CODE (a) == FUNCTION_DECL && reject_gcc_builtin (a)) + return error_mark_node; + } + else if (magic == 1) + /* For other magic varargs only do decay_conversion. */ + a = decay_conversion (a, complain); else if (DECL_CONSTRUCTOR_P (fn) && same_type_ignoring_top_level_qualifiers_p (DECL_CONTEXT (fn), TREE_TYPE (a))) @@ -7528,6 +7541,8 @@ build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain) } else a = convert_arg_to_ellipsis (a, complain); + if (a == error_mark_node) + return error_mark_node; argarray[j++] = a; } @@ -7990,11 +8005,7 @@ build_special_member_call (tree instance, tree name, vec **args, vtt = decay_conversion (vtt, complain); if (vtt == error_mark_node) return error_mark_node; - vtt = build3 (COND_EXPR, TREE_TYPE (vtt), - build2 (EQ_EXPR, boolean_type_node, - current_in_charge_parm, integer_zero_node), - current_vtt_parm, - vtt); + vtt = build_if_in_charge (vtt, current_vtt_parm); if (BINFO_SUBVTT_INDEX (binfo)) sub_vtt = fold_build_pointer_plus (vtt, BINFO_SUBVTT_INDEX (binfo)); else diff --git a/gcc/cp/class.c b/gcc/cp/class.c index f6ad696c8f17..98cbab5a00f1 100644 --- a/gcc/cp/class.c +++ b/gcc/cp/class.c @@ -225,6 +225,24 @@ int n_convert_harshness = 0; int n_compute_conversion_costs = 0; int n_inner_fields_searched = 0; +/* Return a COND_EXPR that executes TRUE_STMT if this execution of the + 'structor is in charge of 'structing virtual bases, or FALSE_STMT + otherwise. */ + +tree +build_if_in_charge (tree true_stmt, tree false_stmt) +{ + gcc_assert (DECL_HAS_IN_CHARGE_PARM_P (current_function_decl)); + tree cmp = build2 (NE_EXPR, boolean_type_node, + current_in_charge_parm, integer_zero_node); + tree type = unlowered_expr_type (true_stmt); + if (VOID_TYPE_P (type)) + type = unlowered_expr_type (false_stmt); + tree cond = build3 (COND_EXPR, type, + cmp, true_stmt, false_stmt); + return cond; +} + /* Convert to or from a base subobject. EXPR is an expression of type `A' or `A*', an expression of type `B' or `B*' is returned. To convert A to a base B, CODE is PLUS_EXPR and BINFO is the binfo for @@ -470,12 +488,9 @@ build_base_path (enum tree_code code, /* Negative fixed_type_p means this is a constructor or destructor; virtual base layout is fixed in in-charge [cd]tors, but not in base [cd]tors. */ - offset = build3 (COND_EXPR, ptrdiff_type_node, - build2 (EQ_EXPR, boolean_type_node, - current_in_charge_parm, integer_zero_node), - v_offset, - convert_to_integer (ptrdiff_type_node, - BINFO_OFFSET (binfo))); + offset = build_if_in_charge + (convert_to_integer (ptrdiff_type_node, BINFO_OFFSET (binfo)), + v_offset); else offset = v_offset; } @@ -8475,6 +8490,40 @@ get_primary_binfo (tree binfo) return copied_binfo (primary_base, binfo); } +/* As above, but iterate until we reach the binfo that actually provides the + vptr for BINFO. */ + +static tree +most_primary_binfo (tree binfo) +{ + tree b = binfo; + while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b)) + && !BINFO_LOST_PRIMARY_P (b)) + { + tree primary_base = get_primary_binfo (b); + gcc_assert (BINFO_PRIMARY_P (primary_base) + && BINFO_INHERITANCE_CHAIN (primary_base) == b); + b = primary_base; + } + return b; +} + +/* Returns true if BINFO gets its vptr from a virtual base of the most derived + type. Note that the virtual inheritance might be above or below BINFO in + the hierarchy. */ + +bool +vptr_via_virtual_p (tree binfo) +{ + if (TYPE_P (binfo)) + binfo = TYPE_BINFO (binfo); + tree primary = most_primary_binfo (binfo); + /* Don't limit binfo_via_virtual, we want to return true when BINFO itself is + a morally virtual base. */ + tree virt = binfo_via_virtual (primary, NULL_TREE); + return virt != NULL_TREE; +} + /* If INDENTED_P is zero, indent to INDENT. Return nonzero. */ static int @@ -9762,17 +9811,7 @@ build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid) /* To find the complete object, we will first convert to our most primary base, and then add the offset in the vtbl to that value. */ - b = binfo; - while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b)) - && !BINFO_LOST_PRIMARY_P (b)) - { - tree primary_base; - - primary_base = get_primary_binfo (b); - gcc_assert (BINFO_PRIMARY_P (primary_base) - && BINFO_INHERITANCE_CHAIN (primary_base) == b); - b = primary_base; - } + b = most_primary_binfo (binfo); offset = size_diffop_loc (input_location, BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b)); diff --git a/gcc/cp/constexpr.c b/gcc/cp/constexpr.c index 8d9168c39507..7776caca4d3a 100644 --- a/gcc/cp/constexpr.c +++ b/gcc/cp/constexpr.c @@ -897,6 +897,9 @@ struct constexpr_ctx { /* Values for any temporaries or local variables within the constant-expression. */ hash_map *values; + /* SAVE_EXPRs that we've seen within the current LOOP_EXPR. NULL if we + aren't inside a loop. */ + hash_set *save_exprs; /* The CONSTRUCTOR we're currently building up for an aggregate initializer. */ tree ctor; @@ -1236,19 +1239,54 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t, return t; } + if (fun == current_function_decl) + { + /* A call to the current function, i.e. + constexpr int f (int i) { + constexpr int j = f(i-1); + return j; + } + This would be OK without the constexpr on the declaration of j. */ + if (!ctx->quiet) + error_at (loc, "%qD called in a constant expression before its " + "definition is complete", fun); + *non_constant_p = true; + return t; + } + + constexpr_ctx new_ctx = *ctx; + if (DECL_CONSTRUCTOR_P (fun) && !ctx->object + && TREE_CODE (t) == AGGR_INIT_EXPR) + { + /* We want to have an initialization target for an AGGR_INIT_EXPR. + If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */ + new_ctx.object = AGGR_INIT_EXPR_SLOT (t); + tree ctor = new_ctx.ctor = build_constructor (DECL_CONTEXT (fun), NULL); + CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor) = true; + ctx->values->put (new_ctx.object, ctor); + ctx = &new_ctx; + } + /* Shortcut trivial constructor/op=. */ if (trivial_fn_p (fun)) { + tree init = NULL_TREE; if (call_expr_nargs (t) == 2) - { - tree arg = convert_from_reference (get_nth_callarg (t, 1)); - return cxx_eval_constant_expression (ctx, arg, - lval, non_constant_p, - overflow_p); - } + init = convert_from_reference (get_nth_callarg (t, 1)); else if (TREE_CODE (t) == AGGR_INIT_EXPR && AGGR_INIT_ZERO_FIRST (t)) - return build_zero_init (DECL_CONTEXT (fun), NULL_TREE, false); + init = build_zero_init (DECL_CONTEXT (fun), NULL_TREE, false); + if (init) + { + tree op = get_nth_callarg (t, 0); + if (is_dummy_object (op)) + op = ctx->object; + else + op = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (op)), op); + tree set = build2 (MODIFY_EXPR, TREE_TYPE (op), op, init); + return cxx_eval_constant_expression (ctx, set, lval, + non_constant_p, overflow_p); + } } /* We can't defer instantiating the function any longer. */ @@ -1284,19 +1322,6 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t, } } - constexpr_ctx new_ctx = *ctx; - if (DECL_CONSTRUCTOR_P (fun) && !ctx->object - && TREE_CODE (t) == AGGR_INIT_EXPR) - { - /* We want to have an initialization target for an AGGR_INIT_EXPR. - If we don't already have one in CTX, use the AGGR_INIT_EXPR_SLOT. */ - new_ctx.object = AGGR_INIT_EXPR_SLOT (t); - tree ctor = new_ctx.ctor = build_constructor (DECL_CONTEXT (fun), NULL); - CONSTRUCTOR_NO_IMPLICIT_ZERO (ctor) = true; - ctx->values->put (new_ctx.object, ctor); - ctx = &new_ctx; - } - bool non_constant_args = false; cxx_bind_parameters_in_call (ctx, t, &new_call, non_constant_p, overflow_p, &non_constant_args); @@ -1365,6 +1390,8 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t, tree oparm = TREE_PURPOSE (bound); tree arg = TREE_VALUE (bound); gcc_assert (DECL_NAME (remapped) == DECL_NAME (oparm)); + /* Don't share a CONSTRUCTOR that might be changed. */ + arg = unshare_expr (arg); ctx->values->put (remapped, arg); bound = TREE_CHAIN (bound); remapped = DECL_CHAIN (remapped); @@ -1421,7 +1448,7 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t, if (result == error_mark_node) *non_constant_p = true; - if (*non_constant_p) + if (*non_constant_p || *overflow_p) result = error_mark_node; else if (!result) result = void_node; @@ -1610,15 +1637,14 @@ cxx_eval_binary_expression (const constexpr_ctx *ctx, tree t, tree lhs, rhs; lhs = cxx_eval_constant_expression (ctx, orig_lhs, /*lval*/false, non_constant_p, overflow_p); - /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to - a local array in a constexpr function. */ - bool ptr = POINTER_TYPE_P (TREE_TYPE (lhs)); - if (!ptr) - VERIFY_CONSTANT (lhs); + /* Don't VERIFY_CONSTANT here, it's unnecessary and will break pointer + subtraction. */ + if (*non_constant_p) + return t; rhs = cxx_eval_constant_expression (ctx, orig_rhs, /*lval*/false, non_constant_p, overflow_p); - if (!ptr) - VERIFY_CONSTANT (rhs); + if (*non_constant_p) + return t; location_t loc = EXPR_LOCATION (t); enum tree_code code = TREE_CODE (t); @@ -1651,6 +1677,9 @@ cxx_eval_binary_expression (const constexpr_ctx *ctx, tree t, } else if (cxx_eval_check_shift_p (loc, ctx, code, type, lhs, rhs)) *non_constant_p = true; + /* Don't VERIFY_CONSTANT if this might be dealing with a pointer to + a local array in a constexpr function. */ + bool ptr = POINTER_TYPE_P (TREE_TYPE (lhs)); if (!ptr) VERIFY_CONSTANT (r); return r; @@ -1983,12 +2012,16 @@ cxx_eval_component_reference (const constexpr_ctx *ctx, tree t, return t; } - if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole) - && !is_empty_class (TREE_TYPE (part))) + /* We only create a CONSTRUCTOR for a subobject when we modify it, so empty + classes never get represented; throw together a value now. */ + if (is_really_empty_class (TREE_TYPE (t))) + return build_constructor (TREE_TYPE (t), NULL); + + if (CONSTRUCTOR_NO_IMPLICIT_ZERO (whole)) { /* 'whole' is part of the aggregate initializer we're currently building; if there's no initializer for this member yet, that's an - error. */ + error. */ if (!ctx->quiet) error ("accessing uninitialized member %qD", part); *non_constant_p = true; @@ -2235,8 +2268,19 @@ cxx_eval_bare_aggregate (const constexpr_ctx *ctx, tree t, vec *v = CONSTRUCTOR_ELTS (t); bool changed = false; gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t)); + tree type = TREE_TYPE (t); - verify_ctor_sanity (ctx, TREE_TYPE (t)); + constexpr_ctx new_ctx; + if (TYPE_PTRMEMFUNC_P (type)) + { + /* We don't really need the ctx->ctor business for a PMF, but it's + simpler to use the same code. */ + new_ctx = *ctx; + new_ctx.ctor = build_constructor (type, NULL); + new_ctx.object = NULL_TREE; + ctx = &new_ctx; + }; + verify_ctor_sanity (ctx, type); vec **p = &CONSTRUCTOR_ELTS (ctx->ctor); vec_alloc (*p, vec_safe_length (v)); @@ -2247,7 +2291,6 @@ cxx_eval_bare_aggregate (const constexpr_ctx *ctx, tree t, FOR_EACH_CONSTRUCTOR_ELT (v, i, index, value) { tree orig_value = value; - constexpr_ctx new_ctx; init_subob_ctx (ctx, new_ctx, index, value); if (new_ctx.ctor != ctx->ctor) /* If we built a new CONSTRUCTOR, attach it now so that other @@ -2301,7 +2344,7 @@ cxx_eval_bare_aggregate (const constexpr_ctx *ctx, tree t, CONSTRUCTOR_NO_IMPLICIT_ZERO (t) = false; TREE_CONSTANT (t) = constant_p; TREE_SIDE_EFFECTS (t) = side_effects_p; - if (VECTOR_TYPE_P (TREE_TYPE (t))) + if (VECTOR_TYPE_P (type)) t = fold (t); return t; } @@ -2358,6 +2401,7 @@ cxx_eval_vec_init_1 (const constexpr_ctx *ctx, tree atype, tree init, { tree idx = build_int_cst (size_type_node, i); tree eltinit; + bool reuse = false; constexpr_ctx new_ctx; init_subob_ctx (ctx, new_ctx, idx, pre_init ? init : elttype); if (new_ctx.ctor != ctx->ctor) @@ -2366,7 +2410,10 @@ cxx_eval_vec_init_1 (const constexpr_ctx *ctx, tree atype, tree init, { /* A multidimensional array; recurse. */ if (value_init || init == NULL_TREE) - eltinit = NULL_TREE; + { + eltinit = NULL_TREE; + reuse = i == 0; + } else eltinit = cp_build_array_ref (input_location, init, idx, tf_warning_or_error); @@ -2378,9 +2425,9 @@ cxx_eval_vec_init_1 (const constexpr_ctx *ctx, tree atype, tree init, { /* Initializing an element using value or default initialization we just pre-built above. */ - eltinit = (cxx_eval_constant_expression - (&new_ctx, init, - lval, non_constant_p, overflow_p)); + eltinit = cxx_eval_constant_expression (&new_ctx, init, lval, + non_constant_p, overflow_p); + reuse = i == 0; } else { @@ -2406,6 +2453,23 @@ cxx_eval_vec_init_1 (const constexpr_ctx *ctx, tree atype, tree init, } else CONSTRUCTOR_APPEND_ELT (*p, idx, eltinit); + /* Reuse the result of cxx_eval_constant_expression call + from the first iteration to all others if it is a constant + initializer that doesn't require relocations. */ + if (reuse + && max > 1 + && (initializer_constant_valid_p (eltinit, TREE_TYPE (eltinit)) + == null_pointer_node)) + { + if (new_ctx.ctor != ctx->ctor) + eltinit = new_ctx.ctor; + for (i = 1; i < max; ++i) + { + idx = build_int_cst (size_type_node, i); + CONSTRUCTOR_APPEND_ELT (*p, idx, unshare_expr (eltinit)); + } + break; + } } if (!*non_constant_p) @@ -2735,7 +2799,8 @@ non_const_var_error (tree r) inform (DECL_SOURCE_LOCATION (r), "%q#D is volatile", r); else if (!DECL_INITIAL (r) - || !TREE_CONSTANT (DECL_INITIAL (r))) + || !TREE_CONSTANT (DECL_INITIAL (r)) + || !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)) inform (DECL_SOURCE_LOCATION (r), "%qD was not initialized with a constant " "expression", r); @@ -2925,40 +2990,37 @@ cxx_eval_store_expression (const constexpr_ctx *ctx, tree t, init = cxx_eval_constant_expression (&new_ctx, init, false, non_constant_p, overflow_p); + /* Don't share a CONSTRUCTOR that might be changed later. */ + init = unshare_expr (init); if (target == object) + /* The hash table might have moved since the get earlier. */ + valp = ctx->values->get (object); + + if (TREE_CODE (init) == CONSTRUCTOR) { - /* The hash table might have moved since the get earlier. */ - valp = ctx->values->get (object); - if (TREE_CODE (init) == CONSTRUCTOR) - { - /* An outer ctx->ctor might be pointing to *valp, so replace - its contents. */ - CONSTRUCTOR_ELTS (*valp) = CONSTRUCTOR_ELTS (init); - TREE_CONSTANT (*valp) = TREE_CONSTANT (init); - TREE_SIDE_EFFECTS (*valp) = TREE_SIDE_EFFECTS (init); - } - else - *valp = init; + /* An outer ctx->ctor might be pointing to *valp, so replace + its contents. */ + CONSTRUCTOR_ELTS (*valp) = CONSTRUCTOR_ELTS (init); + TREE_CONSTANT (*valp) = TREE_CONSTANT (init); + TREE_SIDE_EFFECTS (*valp) = TREE_SIDE_EFFECTS (init); } else - { - *valp = init; - - /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing - CONSTRUCTORs. */ - tree elt; - unsigned i; - bool c = TREE_CONSTANT (init); - bool s = TREE_SIDE_EFFECTS (init); - if (!c || s) - FOR_EACH_VEC_SAFE_ELT (ctors, i, elt) - { - if (!c) - TREE_CONSTANT (elt) = false; - if (s) - TREE_SIDE_EFFECTS (elt) = true; - } - } + *valp = init; + + /* Update TREE_CONSTANT and TREE_SIDE_EFFECTS on enclosing + CONSTRUCTORs, if any. */ + tree elt; + unsigned i; + bool c = TREE_CONSTANT (init); + bool s = TREE_SIDE_EFFECTS (init); + if (!c || s) + FOR_EACH_VEC_SAFE_ELT (ctors, i, elt) + { + if (!c) + TREE_CONSTANT (elt) = false; + if (s) + TREE_SIDE_EFFECTS (elt) = true; + } release_tree_vector (ctors); if (*non_constant_p) @@ -3154,16 +3216,27 @@ cxx_eval_loop_expr (const constexpr_ctx *ctx, tree t, bool *non_constant_p, bool *overflow_p, tree *jump_target) { + constexpr_ctx new_ctx = *ctx; + tree body = TREE_OPERAND (t, 0); - while (true) + do { - cxx_eval_statement_list (ctx, body, + hash_set save_exprs; + new_ctx.save_exprs = &save_exprs; + + cxx_eval_statement_list (&new_ctx, body, non_constant_p, overflow_p, jump_target); - if (returns (jump_target) || breaks (jump_target) || *non_constant_p) - break; + + /* Forget saved values of SAVE_EXPRs. */ + for (hash_set::iterator iter = save_exprs.begin(); + iter != save_exprs.end(); ++iter) + new_ctx.values->remove (*iter); } + while (!returns (jump_target) && !breaks (jump_target) && !*non_constant_p); + if (breaks (jump_target)) *jump_target = NULL_TREE; + return NULL_TREE; } @@ -3269,8 +3342,13 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t, } if (CONSTANT_CLASS_P (t)) { - if (TREE_OVERFLOW (t) && (!flag_permissive || ctx->quiet)) - *overflow_p = true; + if (TREE_OVERFLOW (t)) + { + if (!ctx->quiet) + permerror (input_location, "overflow in constant expression"); + if (!flag_permissive || ctx->quiet) + *overflow_p = true; + } return t; } @@ -3285,6 +3363,10 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t, return (*ctx->values->get (t)); case VAR_DECL: + if (DECL_HAS_VALUE_EXPR_P (t)) + return cxx_eval_constant_expression (ctx, DECL_VALUE_EXPR (t), lval, + non_constant_p, overflow_p); + /* Fall through. */ case CONST_DECL: /* We used to not check lval for CONST_DECL, but darwin.c uses CONST_DECL for aggregate constants. */ @@ -3364,6 +3446,8 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t, init = cxx_eval_constant_expression (ctx, init, false, non_constant_p, overflow_p); + /* Don't share a CONSTRUCTOR that might be changed. */ + init = unshare_expr (init); ctx->values->put (r, init); } else if (ctx == &new_ctx) @@ -3408,6 +3492,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t, if (lval) { tree slot = TARGET_EXPR_SLOT (t); + r = unshare_expr (r); ctx->values->put (slot, r); return slot; } @@ -3442,6 +3527,8 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t, r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), false, non_constant_p, overflow_p); ctx->values->put (t, r); + if (ctx->save_exprs) + ctx->save_exprs->add (t); } break; @@ -3865,7 +3952,10 @@ cxx_eval_outermost_constant_expr (tree t, bool allow_non_constant, bool non_constant_p = false; bool overflow_p = false; hash_map map; - constexpr_ctx ctx = { NULL, &map, NULL, NULL, allow_non_constant, strict }; + + constexpr_ctx ctx = { NULL, &map, NULL, NULL, NULL, + allow_non_constant, strict }; + tree type = initialized_type (t); tree r = t; if (AGGREGATE_TYPE_P (type) || VECTOR_TYPE_P (type)) @@ -3973,7 +4063,9 @@ is_sub_constant_expr (tree t) bool non_constant_p = false; bool overflow_p = false; hash_map map; - constexpr_ctx ctx = { NULL, &map, NULL, NULL, true, true }; + + constexpr_ctx ctx = { NULL, &map, NULL, NULL, NULL, true, true }; + cxx_eval_constant_expression (&ctx, t, false, &non_constant_p, &overflow_p); return !non_constant_p && !overflow_p; @@ -4851,8 +4943,16 @@ potential_constant_expression_1 (tree t, bool want_rval, bool strict, return false; return true; - case IF_STMT: case COND_EXPR: + if (COND_EXPR_IS_VEC_DELETE (t)) + { + if (flags & tf_error) + error_at (location_of (t), + "% is not a constant-expression"); + return false; + } + /* Fall through. */ + case IF_STMT: case VEC_COND_EXPR: /* If the condition is a known constant, we know which of the legs we care about; otherwise we only require that the condition and diff --git a/gcc/cp/cp-gimplify.c b/gcc/cp/cp-gimplify.c index 6af376081bd7..90b3464e5de7 100644 --- a/gcc/cp/cp-gimplify.c +++ b/gcc/cp/cp-gimplify.c @@ -386,7 +386,8 @@ genericize_omp_for_stmt (tree *stmt_p, int *walk_subtrees, void *data) tree clab = begin_bc_block (bc_continue, locus); cp_walk_tree (&OMP_FOR_BODY (stmt), cp_genericize_r, data, NULL); - cp_walk_tree (&OMP_FOR_CLAUSES (stmt), cp_genericize_r, data, NULL); + if (TREE_CODE (stmt) != OMP_TASKLOOP) + cp_walk_tree (&OMP_FOR_CLAUSES (stmt), cp_genericize_r, data, NULL); cp_walk_tree (&OMP_FOR_INIT (stmt), cp_genericize_r, data, NULL); cp_walk_tree (&OMP_FOR_COND (stmt), cp_genericize_r, data, NULL); cp_walk_tree (&OMP_FOR_INCR (stmt), cp_genericize_r, data, NULL); @@ -1272,7 +1273,9 @@ cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data) if (TREE_CODE (d) == VAR_DECL) gcc_assert (CP_DECL_THREAD_LOCAL_P (d) == DECL_THREAD_LOCAL_P (d)); } - else if (TREE_CODE (stmt) == OMP_PARALLEL || TREE_CODE (stmt) == OMP_TASK) + else if (TREE_CODE (stmt) == OMP_PARALLEL + || TREE_CODE (stmt) == OMP_TASK + || TREE_CODE (stmt) == OMP_TASKLOOP) { struct cp_genericize_omp_taskreg omp_ctx; tree c, decl; @@ -1312,7 +1315,10 @@ cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data) default: break; } - cp_walk_tree (&OMP_BODY (stmt), cp_genericize_r, data, NULL); + if (TREE_CODE (stmt) == OMP_TASKLOOP) + genericize_omp_for_stmt (stmt_p, walk_subtrees, data); + else + cp_walk_tree (&OMP_BODY (stmt), cp_genericize_r, data, NULL); wtd->omp_ctx = omp_ctx.outer; splay_tree_delete (omp_ctx.variables); } @@ -1380,8 +1386,7 @@ cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data) genericize_break_stmt (stmt_p); else if (TREE_CODE (stmt) == OMP_FOR || TREE_CODE (stmt) == OMP_SIMD - || TREE_CODE (stmt) == OMP_DISTRIBUTE - || TREE_CODE (stmt) == OMP_TASKLOOP) + || TREE_CODE (stmt) == OMP_DISTRIBUTE) genericize_omp_for_stmt (stmt_p, walk_subtrees, data); else if ((flag_sanitize & (SANITIZE_NULL | SANITIZE_ALIGNMENT | SANITIZE_VPTR)) @@ -1996,7 +2001,6 @@ cp_fold (tree x) case BIT_NOT_EXPR: case TRUTH_NOT_EXPR: case FIXED_CONVERT_EXPR: - case UNARY_PLUS_EXPR: case INDIRECT_REF: loc = EXPR_LOCATION (x); @@ -2016,6 +2020,14 @@ cp_fold (tree x) || !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (x, 0)))); break; + case UNARY_PLUS_EXPR: + op0 = cp_fold_rvalue (TREE_OPERAND (x, 0)); + if (op0 == error_mark_node) + x = error_mark_node; + else + x = fold_convert (TREE_TYPE (x), op0); + break; + case POSTDECREMENT_EXPR: case POSTINCREMENT_EXPR: case INIT_EXPR: @@ -2123,6 +2135,12 @@ cp_fold (tree x) else x = fold (x); + /* A COND_EXPR might have incompatible types in branches if one or both + arms are bitfields. If folding exposed such a branch, fix it up. */ + if (TREE_CODE (x) != code) + if (tree type = is_bitfield_expr_with_lowered_type (x)) + x = fold_convert (type, x); + break; case CALL_EXPR: diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index b1dc23cb5df1..b7b770f92008 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -107,6 +107,7 @@ operator == (const cp_expr &lhs, tree rhs) /* Usage of TREE_LANG_FLAG_?: 0: IDENTIFIER_MARKED (IDENTIFIER_NODEs) NEW_EXPR_USE_GLOBAL (in NEW_EXPR). + COND_EXPR_IS_VEC_DELETE (in COND_EXPR). DELETE_EXPR_USE_GLOBAL (in DELETE_EXPR). COMPOUND_EXPR_OVERLOADED (in COMPOUND_EXPR). CLEANUP_P (in TRY_BLOCK) @@ -404,6 +405,9 @@ typedef struct ptrmem_cst * ptrmem_cst_t; #define STMT_EXPR_NO_SCOPE(NODE) \ TREE_LANG_FLAG_0 (STMT_EXPR_CHECK (NODE)) +#define COND_EXPR_IS_VEC_DELETE(NODE) \ + TREE_LANG_FLAG_0 (COND_EXPR_CHECK (NODE)) + /* Returns nonzero iff TYPE1 and TYPE2 are the same type, in the usual sense of `same'. */ #define same_type_p(TYPE1, TYPE2) \ @@ -1984,7 +1988,7 @@ struct GTY(()) lang_type { #define CLASSTYPE_VBASECLASSES(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->vbases) /* The type corresponding to NODE when NODE is used as a base class, - i.e., NODE without virtual base classes. */ + i.e., NODE without virtual base classes or tail padding. */ #define CLASSTYPE_AS_BASE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->as_base) @@ -5559,7 +5563,7 @@ class cache_map /* in call.c */ extern bool check_dtor_name (tree, tree); -bool magic_varargs_p (tree); +int magic_varargs_p (tree); extern tree build_conditional_expr (location_t, tree, tree, tree, tsubst_flags_t); @@ -5634,6 +5638,7 @@ extern tree get_function_version_dispatcher (tree); /* in class.c */ extern tree build_vfield_ref (tree, tree); +extern tree build_if_in_charge (tree true_stmt, tree false_stmt = void_node); extern tree build_base_path (enum tree_code, tree, tree, int, tsubst_flags_t); extern tree convert_to_base (tree, tree, bool, bool, @@ -5672,6 +5677,7 @@ extern void invalidate_class_lookup_cache (void); extern void maybe_note_name_used_in_class (tree, tree); extern void note_name_declared_in_class (tree, tree); extern tree get_vtbl_decl_for_binfo (tree); +extern bool vptr_via_virtual_p (tree); extern void debug_class (tree); extern void debug_thunks (tree); extern void set_linkage_according_to_type (tree, tree); @@ -5840,8 +5846,6 @@ extern tree fndecl_declared_return_type (tree); extern bool undeduced_auto_decl (tree); extern void require_deduced_type (tree); -extern bool defer_mark_used_calls; -extern GTY(()) vec *deferred_mark_used_calls; extern tree finish_case_label (location_t, tree, tree); extern tree cxx_maybe_build_cleanup (tree, tsubst_flags_t); @@ -6940,6 +6944,7 @@ extern void cp_ubsan_maybe_instrument_member_call (tree); extern void cp_ubsan_instrument_member_accesses (tree *); extern tree cp_ubsan_maybe_instrument_downcast (location_t, tree, tree, tree); extern tree cp_ubsan_maybe_instrument_cast_to_vbase (location_t, tree, tree); +extern void cp_ubsan_maybe_initialize_vtbl_ptrs (tree); /* -- end of C++ */ diff --git a/gcc/cp/cp-ubsan.c b/gcc/cp/cp-ubsan.c index a5aefcf70bb2..be24a5ca5c8c 100644 --- a/gcc/cp/cp-ubsan.c +++ b/gcc/cp/cp-ubsan.c @@ -272,3 +272,66 @@ cp_ubsan_maybe_instrument_cast_to_vbase (location_t loc, tree type, tree op) return cp_ubsan_maybe_instrument_vptr (loc, op, type, true, UBSAN_CAST_TO_VBASE); } + +/* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base + which we want to initialize the vtable pointer for, DATA is + TREE_LIST whose TREE_VALUE is the this ptr expression. */ + +static tree +cp_ubsan_dfs_initialize_vtbl_ptrs (tree binfo, void *data) +{ + if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo))) + return dfs_skip_bases; + + if (!BINFO_PRIMARY_P (binfo)) + { + tree base_ptr = TREE_VALUE ((tree) data); + + base_ptr = build_base_path (PLUS_EXPR, base_ptr, binfo, /*nonnull=*/1, + tf_warning_or_error); + + /* Compute the location of the vtpr. */ + tree vtbl_ptr + = build_vfield_ref (cp_build_indirect_ref (base_ptr, RO_NULL, + tf_warning_or_error), + TREE_TYPE (binfo)); + gcc_assert (vtbl_ptr != error_mark_node); + + /* Assign NULL to the vptr. */ + tree vtbl = build_zero_cst (TREE_TYPE (vtbl_ptr)); + tree stmt = cp_build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl, + tf_warning_or_error); + if (vptr_via_virtual_p (binfo)) + /* If this vptr comes from a virtual base of the complete object, only + clear it if we're in charge of virtual bases. */ + stmt = build_if_in_charge (stmt); + finish_expr_stmt (stmt); + } + + return NULL_TREE; +} + +/* Initialize all the vtable pointers in the object pointed to by + ADDR to NULL, so that we catch invalid calls to methods before + mem-initializers are completed. */ + +void +cp_ubsan_maybe_initialize_vtbl_ptrs (tree addr) +{ + if (!cp_ubsan_instrument_vptr_p (NULL_TREE)) + return; + + tree type = TREE_TYPE (TREE_TYPE (addr)); + tree list = build_tree_list (type, addr); + /* We cannot rely on the vtable being set up. We have to indirect via the + vtt_parm. */ + int save_in_base_initializer = in_base_initializer; + in_base_initializer = 1; + + /* Walk through the hierarchy, initializing the vptr in each base + class to NULL. */ + dfs_walk_once (TYPE_BINFO (type), cp_ubsan_dfs_initialize_vtbl_ptrs, + NULL, list); + + in_base_initializer = save_in_base_initializer; +} diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index 5ec65892e68d..a88b642f8dd4 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -227,11 +227,6 @@ struct GTY((for_user)) named_label_entry { function, two inside the body of a function in a local class, etc.) */ int function_depth; -/* To avoid unwanted recursion, finish_function defers all mark_used calls - encountered during its execution until it finishes. */ -bool defer_mark_used_calls; -vec *deferred_mark_used_calls; - /* States indicating how grokdeclarator() should handle declspecs marked with __attribute__((deprecated)). An object declared as __attribute__((deprecated)) suppresses warnings of uses of other @@ -2646,7 +2641,7 @@ duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend) Before releasing the node, be sore to remove function from symbol table that might have been inserted there to record comdat group. - Be sure to however do not free DECL_STRUCT_FUNCTION becuase this + Be sure to however do not free DECL_STRUCT_FUNCTION because this structure is shared in between newdecl and oldecl. */ if (TREE_CODE (newdecl) == FUNCTION_DECL) DECL_STRUCT_FUNCTION (newdecl) = NULL; @@ -4190,13 +4185,15 @@ cp_fname_init (const char* name, tree *type_p) type = cp_build_qualified_type (char_type_node, TYPE_QUAL_CONST); type = build_cplus_array_type (type, domain); - *type_p = type; + *type_p = type_decays_to (type); if (init) TREE_TYPE (init) = type; else init = error_mark_node; + init = decay_conversion (init, tf_warning_or_error); + return init; } @@ -4222,12 +4219,20 @@ cp_make_fname_decl (location_t loc, tree id, int type_dep) /* As we're using pushdecl_with_scope, we must set the context. */ DECL_CONTEXT (decl) = current_function_decl; - TREE_STATIC (decl) = 1; TREE_READONLY (decl) = 1; DECL_ARTIFICIAL (decl) = 1; + DECL_DECLARED_CONSTEXPR_P (decl) = 1; TREE_USED (decl) = 1; + if (init) + { + SET_DECL_VALUE_EXPR (decl, init); + DECL_HAS_VALUE_EXPR_P (decl) = 1; + /* For decl_constant_var_p. */ + DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1; + } + if (current_function_decl) { cp_binding_level *b = current_binding_level; @@ -4236,13 +4241,12 @@ cp_make_fname_decl (location_t loc, tree id, int type_dep) while (b->level_chain->kind != sk_function_parms) b = b->level_chain; pushdecl_with_scope (decl, b, /*is_friend=*/false); - cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE, - LOOKUP_ONLYCONVERTING); + add_decl_expr (decl); } else { DECL_THIS_STATIC (decl) = true; - pushdecl_top_level_and_finish (decl, init); + pushdecl_top_level_and_finish (decl, NULL_TREE); } return decl; @@ -6499,6 +6503,19 @@ is_concept_var (tree decl) && DECL_DECLARED_CONCEPT_P (decl)); } +/* A helper function to be called via walk_tree. If any label exists + under *TP, it is (going to be) forced. Set has_forced_label_in_static. */ + +static tree +notice_forced_label_r (tree *tp, int *walk_subtrees, void *) +{ + if (TYPE_P (*tp)) + *walk_subtrees = 0; + if (TREE_CODE (*tp) == LABEL_DECL) + cfun->has_forced_label_in_static = 1; + return NULL_TREE; +} + /* Finish processing of a declaration; install its line number and initial value. If the length of an array type is not known before, @@ -6744,13 +6761,17 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p, && !DECL_ARTIFICIAL (decl)) { push_local_name (decl); - if (DECL_CONSTRUCTOR_P (current_function_decl) - || DECL_DESTRUCTOR_P (current_function_decl)) - /* Normally local_decls is populated during GIMPLE lowering, - but [cd]tors are never actually compiled directly. We need - to put statics on the list so we can deal with the label - address extension. FIXME. */ - add_local_decl (cfun, decl); + /* Normally has_forced_label_in_static is set during GIMPLE + lowering, but [cd]tors are never actually compiled directly. + We need to set this early so we can deal with the label + address extension. */ + if ((DECL_CONSTRUCTOR_P (current_function_decl) + || DECL_DESTRUCTOR_P (current_function_decl)) + && init) + { + walk_tree (&init, notice_forced_label_r, NULL, NULL); + add_local_decl (cfun, decl); + } /* And make sure it's in the symbol table for c_parse_final_cleanups to find. */ varpool_node::get_create (decl); @@ -13712,6 +13733,43 @@ implicit_default_ctor_p (tree fn) && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn))); } +/* Clobber the contents of *this to let the back end know that the object + storage is dead when we enter the constructor or leave the destructor. */ + +static tree +build_clobber_this () +{ + /* Clobbering an empty base is pointless, and harmful if its one byte + TYPE_SIZE overlays real data. */ + if (is_empty_class (current_class_type)) + return void_node; + + /* If we have virtual bases, clobber the whole object, but only if we're in + charge. If we don't have virtual bases, clobber the as-base type so we + don't mess with tail padding. */ + bool vbases = CLASSTYPE_VBASECLASSES (current_class_type); + + tree ctype = current_class_type; + if (!vbases) + ctype = CLASSTYPE_AS_BASE (ctype); + + tree clobber = build_constructor (ctype, NULL); + TREE_THIS_VOLATILE (clobber) = true; + + tree thisref = current_class_ref; + if (ctype != current_class_type) + { + thisref = build_nop (build_reference_type (ctype), current_class_ptr); + thisref = convert_from_reference (thisref); + } + + tree exprstmt = build2 (MODIFY_EXPR, void_type_node, thisref, clobber); + if (vbases) + exprstmt = build_if_in_charge (exprstmt); + + return exprstmt; +} + /* Create the FUNCTION_DECL for a function definition. DECLSPECS and DECLARATOR are the parts of the declaration; they describe the function's name and the type it returns, @@ -14120,21 +14178,21 @@ start_preparsed_function (tree decl1, tree attrs, int flags) if (!processing_template_decl && (flag_lifetime_dse > 1) && DECL_CONSTRUCTOR_P (decl1) + && !DECL_CLONED_FUNCTION_P (decl1) + /* Clobbering an empty base is harmful if it overlays real data. */ + && !is_empty_class (current_class_type) /* We can't clobber safely for an implicitly-defined default constructor because part of the initialization might happen before we enter the constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */ && !implicit_default_ctor_p (decl1)) - { - /* Insert a clobber to let the back end know that the object storage - is dead when we enter the constructor. */ - tree btype = CLASSTYPE_AS_BASE (current_class_type); - tree clobber = build_constructor (btype, NULL); - TREE_THIS_VOLATILE (clobber) = true; - tree bref = build_nop (build_reference_type (btype), current_class_ptr); - bref = convert_from_reference (bref); - tree exprstmt = build2 (MODIFY_EXPR, btype, bref, clobber); - finish_expr_stmt (exprstmt); - } + finish_expr_stmt (build_clobber_this ()); + + if (!processing_template_decl + && DECL_CONSTRUCTOR_P (decl1) + && (flag_sanitize & SANITIZE_VPTR) + && !DECL_CLONED_FUNCTION_P (decl1) + && !implicit_default_ctor_p (decl1)) + cp_ubsan_maybe_initialize_vtbl_ptrs (current_class_ptr); return true; } @@ -14344,19 +14402,10 @@ begin_destructor_body (void) initialize_vtbl_ptrs (current_class_ptr); finish_compound_stmt (compound_stmt); - if (flag_lifetime_dse) - { - /* Insert a cleanup to let the back end know that the object is dead - when we exit the destructor, either normally or via exception. */ - tree btype = CLASSTYPE_AS_BASE (current_class_type); - tree clobber = build_constructor (btype, NULL); - TREE_THIS_VOLATILE (clobber) = true; - tree bref = build_nop (build_reference_type (btype), - current_class_ptr); - bref = convert_from_reference (bref); - tree exprstmt = build2 (MODIFY_EXPR, btype, bref, clobber); - finish_decl_cleanup (NULL_TREE, exprstmt); - } + if (flag_lifetime_dse + /* Clobbering an empty base is harmful if it overlays real data. */ + && !is_empty_class (current_class_type)) + finish_decl_cleanup (NULL_TREE, build_clobber_this ()); /* And insert cleanups for our bases and members so that they will be properly destroyed if we throw. */ @@ -14549,9 +14598,6 @@ finish_function (int flags) if (c_dialect_objc ()) objc_finish_function (); - gcc_assert (!defer_mark_used_calls); - defer_mark_used_calls = true; - record_key_method_defined (fndecl); fntype = TREE_TYPE (fndecl); @@ -14801,17 +14847,6 @@ finish_function (int flags) /* Clean up. */ current_function_decl = NULL_TREE; - defer_mark_used_calls = false; - if (deferred_mark_used_calls) - { - unsigned int i; - tree decl; - - FOR_EACH_VEC_SAFE_ELT (deferred_mark_used_calls, i, decl) - mark_used (decl); - vec_free (deferred_mark_used_calls); - } - invoke_plugin_callbacks (PLUGIN_FINISH_PARSE_FUNCTION, fndecl); return fndecl; } diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c index 73b0d280c433..b3cc99a7dc1a 100644 --- a/gcc/cp/decl2.c +++ b/gcc/cp/decl2.c @@ -5140,14 +5140,6 @@ mark_used (tree decl, tsubst_flags_t complain) if (DECL_ODR_USED (decl)) return true; - /* If within finish_function, defer the rest until that function - finishes, otherwise it might recurse. */ - if (defer_mark_used_calls) - { - vec_safe_push (deferred_mark_used_calls, decl); - return true; - } - /* Normally, we can wait until instantiation-time to synthesize DECL. However, if DECL is a static data member initialized with a constant or a constexpr function, we need it right now because a reference to diff --git a/gcc/cp/init.c b/gcc/cp/init.c index 43f854c47838..aee3b8416e4b 100644 --- a/gcc/cp/init.c +++ b/gcc/cp/init.c @@ -1243,12 +1243,7 @@ expand_virtual_init (tree binfo, tree decl) /* The actual initializer is the VTT value only in the subobject constructor. In maybe_clone_body we'll substitute NULL for the vtt_parm in the case of the non-subobject constructor. */ - vtbl = build3 (COND_EXPR, - TREE_TYPE (vtbl), - build2 (EQ_EXPR, boolean_type_node, - current_in_charge_parm, integer_zero_node), - vtbl2, - vtbl); + vtbl = build_if_in_charge (vtbl, vtbl2); } /* Compute the location of the vtpr. */ @@ -1741,11 +1736,7 @@ expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags, &parms, binfo, flags, complain); base = fold_build_cleanup_point_expr (void_type_node, base); - rval = build3 (COND_EXPR, void_type_node, - build2 (EQ_EXPR, boolean_type_node, - current_in_charge_parm, integer_zero_node), - base, - complete); + rval = build_if_in_charge (complete, base); } else { @@ -2872,6 +2863,14 @@ build_new_1 (vec **placement, tree type, tree nelts, return error_mark_node; } alloc_fn = OVL_CURRENT (alloc_fn); + if (TREE_CODE (alloc_fn) != FUNCTION_DECL + || TREE_CODE (TREE_TYPE (alloc_fn)) != FUNCTION_TYPE + || !POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (alloc_fn)))) + { + if (complain & tf_error) + error ("%qD is not a function returning a pointer", alloc_fn); + return error_mark_node; + } class_addr = build1 (ADDR_EXPR, jclass_node, class_decl); alloc_call = cp_build_function_call_nary (alloc_fn, complain, class_addr, NULL_TREE); @@ -3685,6 +3684,7 @@ build_vec_delete_1 (tree base, tree maxindex, tree type, TREE_NO_WARNING (cond) = 1; body = build3_loc (input_location, COND_EXPR, void_type_node, cond, body, integer_zero_node); + COND_EXPR_IS_VEC_DELETE (body) = true; body = build1 (NOP_EXPR, void_type_node, body); if (controller) diff --git a/gcc/cp/method.c b/gcc/cp/method.c index 0235e6a9c22e..38f2a5427cc7 100644 --- a/gcc/cp/method.c +++ b/gcc/cp/method.c @@ -1379,9 +1379,18 @@ synthesized_method_walk (tree ctype, special_function_kind sfk, bool const_p, /* If that user-written default constructor would satisfy the requirements of a constexpr constructor (7.1.5), the - implicitly-defined default constructor is constexpr. */ + implicitly-defined default constructor is constexpr. + + The implicitly-defined copy/move assignment operator is constexpr if + - X is a literal type, and + - the assignment operator selected to copy/move each direct base class + subobject is a constexpr function, and + - for each non-static data member of X that is of class type (or array + thereof), the assignment operator selected to copy/move that member is a + constexpr function. */ if (constexpr_p) - *constexpr_p = ctor_p; + *constexpr_p = ctor_p + || (assign_p && cxx_dialect >= cxx14); move_p = false; switch (sfk) diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index 53decdc16170..7e13c6e74f67 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -3172,6 +3172,8 @@ cp_parser_diagnose_invalid_type_name (cp_parser *parser, tree id, && !strcmp (IDENTIFIER_POINTER (id), "thread_local")) inform (location, "C++11 % only available with " "-std=c++11 or -std=gnu++11"); + else if (!flag_concepts && id == ridpointers[(int)RID_CONCEPT]) + inform (location, "% only available with -fconcepts"); else if (processing_template_decl && current_class_type && TYPE_BINFO (current_class_type)) { @@ -9779,8 +9781,6 @@ cp_parser_lambda_expression (cp_parser* parser) = auto_is_implicit_function_template_parm_p; } - pop_deferring_access_checks (); - /* This field is only used during parsing of the lambda. */ LAMBDA_EXPR_THIS_CAPTURE (lambda_expr) = NULL_TREE; @@ -9796,6 +9796,8 @@ cp_parser_lambda_expression (cp_parser* parser) cp_parser_end_tentative_firewall (parser, start, lambda_expr); + pop_deferring_access_checks (); + return lambda_expr; } @@ -11351,6 +11353,8 @@ cp_convert_range_for (tree statement, tree range_decl, tree range_expr, /*is_constant_init*/false, NULL_TREE, LOOKUP_ONLYCONVERTING); + if (cxx_dialect >= cxx1z) + iter_type = cv_unqualified (TREE_TYPE (end_expr)); end = build_decl (input_location, VAR_DECL, get_identifier ("__for_end"), iter_type); TREE_USED (end) = 1; @@ -11486,9 +11490,21 @@ cp_parser_perform_range_for_lookup (tree range, tree *begin, tree *end) /* The unqualified type of the __begin and __end temporaries should be the same, as required by the multiple auto declaration. */ if (!same_type_p (iter_type, cv_unqualified (TREE_TYPE (*end)))) - error ("inconsistent begin/end types in range-based % " - "statement: %qT and %qT", - TREE_TYPE (*begin), TREE_TYPE (*end)); + { + if (cxx_dialect >= cxx1z + && (build_x_binary_op (input_location, NE_EXPR, + *begin, ERROR_MARK, + *end, ERROR_MARK, + NULL, tf_none) + != error_mark_node)) + /* P0184R0 allows __begin and __end to have different types, + but make sure they are comparable so we can give a better + diagnostic. */; + else + error ("inconsistent begin/end types in range-based % " + "statement: %qT and %qT", + TREE_TYPE (*begin), TREE_TYPE (*end)); + } return iter_type; } } @@ -14668,13 +14684,10 @@ cp_parser_type_parameter (cp_parser* parser, bool *is_parameter_pack) cp_parser_require (parser, CPP_GREATER, RT_GREATER); // If template requirements are present, parse them. - if (flag_concepts) - { - tree reqs = get_shorthand_constraints (current_template_parms); - if (tree r = cp_parser_requires_clause_opt (parser)) - reqs = conjoin_constraints (reqs, make_predicate_constraint (r)); - TEMPLATE_PARMS_CONSTRAINTS (current_template_parms) = reqs; - } + tree reqs = get_shorthand_constraints (current_template_parms); + if (tree r = cp_parser_requires_clause_opt (parser)) + reqs = conjoin_constraints (reqs, make_predicate_constraint (r)); + TEMPLATE_PARMS_CONSTRAINTS (current_template_parms) = reqs; /* Look for the `class' or 'typename' keywords. */ cp_parser_type_parameter_key (parser); @@ -19745,6 +19758,8 @@ cp_parser_late_return_type_opt (cp_parser* parser, cp_declarator *declarator, /* A late-specified return type is indicated by an initial '->'. */ if (token->type != CPP_DEREF && token->keyword != RID_REQUIRES + && !(token->type == CPP_NAME + && token->u.value == ridpointers[RID_REQUIRES]) && !(declare_simd_p || cilk_simd_fn_vector_p || oacc_routine_p)) return NULL_TREE; @@ -24206,6 +24221,8 @@ cp_parser_requires_clause (cp_parser *parser) ++processing_template_decl; tree expr = cp_parser_binary_expression (parser, false, false, PREC_NOT_OPERATOR, NULL); + if (check_for_bare_parameter_packs (expr)) + expr = error_mark_node; --processing_template_decl; return expr; } @@ -24214,8 +24231,20 @@ cp_parser_requires_clause (cp_parser *parser) static tree cp_parser_requires_clause_opt (cp_parser *parser) { - if (!cp_lexer_next_token_is_keyword (parser->lexer, RID_REQUIRES)) - return NULL_TREE; + cp_token *tok = cp_lexer_peek_token (parser->lexer); + if (tok->keyword != RID_REQUIRES) + { + if (!flag_concepts && tok->type == CPP_NAME + && tok->u.value == ridpointers[RID_REQUIRES]) + { + error_at (cp_lexer_peek_token (parser->lexer)->location, + "% only available with -fconcepts"); + /* Parse and discard the requires-clause. */ + cp_lexer_consume_token (parser->lexer); + cp_parser_requires_clause (parser); + } + return NULL_TREE; + } cp_lexer_consume_token (parser->lexer); return cp_parser_requires_clause (parser); } @@ -25606,13 +25635,10 @@ cp_parser_explicit_template_declaration (cp_parser* parser, bool member_p) cp_parser_skip_to_end_of_template_parameter_list (parser); /* Manage template requirements */ - if (flag_concepts) - { - tree reqs = get_shorthand_constraints (current_template_parms); - if (tree r = cp_parser_requires_clause_opt (parser)) - reqs = conjoin_constraints (reqs, make_predicate_constraint (r)); - TEMPLATE_PARMS_CONSTRAINTS (current_template_parms) = reqs; - } + tree reqs = get_shorthand_constraints (current_template_parms); + if (tree r = cp_parser_requires_clause_opt (parser)) + reqs = conjoin_constraints (reqs, make_predicate_constraint (r)); + TEMPLATE_PARMS_CONSTRAINTS (current_template_parms) = reqs; cp_parser_template_declaration_after_parameters (parser, parameter_list, member_p); @@ -30060,7 +30086,7 @@ cp_parser_oacc_data_clause (cp_parser *parser, pragma_omp_clause c_kind, kind = GOMP_MAP_FORCE_ALLOC; break; case PRAGMA_OACC_CLAUSE_DELETE: - kind = GOMP_MAP_FORCE_DEALLOC; + kind = GOMP_MAP_DELETE; break; case PRAGMA_OACC_CLAUSE_DEVICE: kind = GOMP_MAP_FORCE_TO; @@ -35334,9 +35360,9 @@ cp_parser_oacc_loop (cp_parser *parser, cp_token *pragma_tok, char *p_name, { clauses = c_oacc_split_loop_clauses (clauses, cclauses); if (*cclauses) - finish_omp_clauses (*cclauses, false); + *cclauses = finish_omp_clauses (*cclauses, false); if (clauses) - finish_omp_clauses (clauses, false); + clauses = finish_omp_clauses (clauses, false); } tree block = begin_omp_structured_block (); diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index b5855a8d13cc..e0b7a2a90aab 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -178,6 +178,7 @@ static int check_cv_quals_for_unify (int, tree, tree); static void template_parm_level_and_index (tree, int*, int*); static int unify_pack_expansion (tree, tree, tree, tree, unification_kind_t, bool, bool); +static tree copy_template_args (tree); static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree); static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree); static tree tsubst_template_parms (tree, tree, tsubst_flags_t); @@ -329,7 +330,8 @@ get_template_info (const_tree t) if (!t || t == error_mark_node) return NULL; - if (TREE_CODE (t) == NAMESPACE_DECL) + if (TREE_CODE (t) == NAMESPACE_DECL + || TREE_CODE (t) == PARM_DECL) return NULL; if (DECL_P (t) && DECL_LANG_SPECIFIC (t)) @@ -369,16 +371,20 @@ template_class_depth (tree type) { int depth; - for (depth = 0; - type && TREE_CODE (type) != NAMESPACE_DECL; - type = (TREE_CODE (type) == FUNCTION_DECL) - ? CP_DECL_CONTEXT (type) : CP_TYPE_CONTEXT (type)) + for (depth = 0; type && TREE_CODE (type) != NAMESPACE_DECL; ) { tree tinfo = get_template_info (type); if (tinfo && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo)) && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo)))) ++depth; + + if (DECL_P (type)) + type = CP_DECL_CONTEXT (type); + else if (LAMBDA_TYPE_P (type)) + type = LAMBDA_TYPE_EXTRA_SCOPE (type); + else + type = CP_TYPE_CONTEXT (type); } return depth; @@ -6944,7 +6950,8 @@ canonicalize_type_argument (tree arg, tsubst_flags_t complain) tree canon = strip_typedefs (arg, &removed_attributes); if (removed_attributes && (complain & tf_warning)) - warning (0, "ignoring attributes on template argument %qT", arg); + warning (OPT_Wignored_attributes, + "ignoring attributes on template argument %qT", arg); return canon; } @@ -8845,8 +8852,9 @@ for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d) break; case TYPENAME_TYPE: - if (!fn) - WALK_SUBTREE (TYPENAME_TYPE_FULLNAME (t)); + /* A template-id in a TYPENAME_TYPE might be a deduced context after + partial instantiation. */ + WALK_SUBTREE (TYPENAME_TYPE_FULLNAME (t)); break; case CONSTRUCTOR: @@ -10623,10 +10631,6 @@ gen_elem_of_pack_expansion_instantiation (tree pattern, sequence, the value of the expression is as follows; the program is ill-formed if the operator is not listed in this table. - * 1 - + 0 - & -1 - | 0 && true || false , void() */ @@ -10638,14 +10642,6 @@ expand_empty_fold (tree t, tsubst_flags_t complain) if (!FOLD_EXPR_MODIFY_P (t)) switch (code) { - case MULT_EXPR: - return integer_one_node; - case PLUS_EXPR: - return integer_zero_node; - case BIT_AND_EXPR: - return integer_minus_one_node; - case BIT_IOR_EXPR: - return integer_zero_node; case TRUTH_ANDIF_EXPR: return boolean_true_node; case TRUTH_ORIF_EXPR: @@ -11037,11 +11033,12 @@ tsubst_pack_expansion (tree t, tree args, tsubst_flags_t complain, /* For each argument in each argument pack, substitute into the pattern. */ result = make_tree_vec (len); + tree elem_args = copy_template_args (args); for (i = 0; i < len; ++i) { t = gen_elem_of_pack_expansion_instantiation (pattern, packs, i, - args, complain, + elem_args, complain, in_decl); TREE_VEC_ELT (result, i) = t; if (t == error_mark_node) @@ -11136,6 +11133,32 @@ make_argument_pack (tree vec) return pack; } +/* Return an exact copy of template args T that can be modified + independently. */ + +static tree +copy_template_args (tree t) +{ + if (t == error_mark_node) + return t; + + int len = TREE_VEC_LENGTH (t); + tree new_vec = make_tree_vec (len); + + for (int i = 0; i < len; ++i) + { + tree elt = TREE_VEC_ELT (t, i); + if (elt && TREE_CODE (elt) == TREE_VEC) + elt = copy_template_args (elt); + TREE_VEC_ELT (new_vec, i) = elt; + } + + NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_vec) + = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t); + + return new_vec; +} + /* Substitute ARGS into the vector or list of template arguments T. */ static tree @@ -12352,6 +12375,8 @@ tsubst_decl (tree t, tree args, tsubst_flags_t complain) /* The initializer must not be expanded until it is required; see [temp.inst]. */ DECL_INITIAL (r) = NULL_TREE; + if (VAR_P (r)) + DECL_MODE (r) = VOIDmode; if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL)) SET_DECL_RTL (r, NULL); DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0; @@ -13622,7 +13647,15 @@ tsubst_baselink (tree baselink, tree object_type, name = mangle_conv_op_name_for_type (optype); baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1); if (!baselink) - return error_mark_node; + { + if (constructor_name_p (name, qualifying_scope)) + { + if (complain & tf_error) + error ("cannot call constructor %<%T::%D%> directly", + qualifying_scope, name); + } + return error_mark_node; + } /* If lookup found a single function, mark it as used at this point. (If it lookup found multiple functions the one selected @@ -13845,10 +13878,13 @@ tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl) if (r == NULL_TREE) { - /* We get here for a use of 'this' in an NSDMI. */ + /* We get here for a use of 'this' in an NSDMI as part of a + constructor call or as part of an aggregate initialization. */ if (DECL_NAME (t) == this_identifier - && current_function_decl - && DECL_CONSTRUCTOR_P (current_function_decl)) + && ((current_function_decl + && DECL_CONSTRUCTOR_P (current_function_decl)) + || (current_class_ref + && TREE_CODE (current_class_ref) == PLACEHOLDER_EXPR))) return current_class_ptr; /* This can happen for a parameter name used later in a function @@ -15158,21 +15194,25 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl, DECL_CONTEXT (decl) = current_function_decl; cp_check_omp_declare_reduction (decl); } + else if (VAR_P (decl) + && DECL_PRETTY_FUNCTION_P (decl)) + { + /* For __PRETTY_FUNCTION__ we have to adjust the + initializer. */ + const char *const name + = cxx_printable_name (current_function_decl, 2); + init = cp_fname_init (name, &TREE_TYPE (decl)); + SET_DECL_VALUE_EXPR (decl, init); + DECL_HAS_VALUE_EXPR_P (decl) = 1; + DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1; + maybe_push_decl (decl); + } else { int const_init = false; maybe_push_decl (decl); - if (VAR_P (decl) - && DECL_PRETTY_FUNCTION_P (decl)) - { - /* For __PRETTY_FUNCTION__ we have to adjust the - initializer. */ - const char *const name - = cxx_printable_name (current_function_decl, 2); - init = cp_fname_init (name, &TREE_TYPE (decl)); - } - else - init = tsubst_init (init, decl, args, complain, in_decl); + + init = tsubst_init (init, decl, args, complain, in_decl); if (VAR_P (decl)) const_init = (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P @@ -17067,8 +17107,6 @@ tsubst_copy_and_build (tree t, else gcc_unreachable (); LAMBDA_EXPR_EXTRA_SCOPE (r) = scope; - LAMBDA_EXPR_RETURN_TYPE (r) - = tsubst (LAMBDA_EXPR_RETURN_TYPE (t), args, complain, in_decl); gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t) == NULL_TREE && LAMBDA_EXPR_PENDING_PROXIES (t) == NULL); @@ -17079,6 +17117,9 @@ tsubst_copy_and_build (tree t, declaration of the op() for later calls to lambda_function. */ complete_type (type); + if (tree fn = lambda_function (type)) + LAMBDA_EXPR_RETURN_TYPE (r) = TREE_TYPE (TREE_TYPE (fn)); + LAMBDA_EXPR_THIS_CAPTURE (r) = NULL_TREE; insert_pending_capture_proxies (); @@ -21904,7 +21945,7 @@ instantiate_decl (tree d, int defer_ok, if (enter_context) pop_nested_class (); - if (variable_template_p (td)) + if (variable_template_p (gen_tmpl)) note_variable_template_instantiation (d); } else if (TREE_CODE (d) == FUNCTION_DECL && DECL_DEFAULTED_FN (code_pattern)) diff --git a/gcc/cp/search.c b/gcc/cp/search.c index 792461189152..503e34b7f2e5 100644 --- a/gcc/cp/search.c +++ b/gcc/cp/search.c @@ -1751,9 +1751,11 @@ adjust_result_of_qualified_name_lookup (tree decl, if (base && base != error_mark_node) { BASELINK_ACCESS_BINFO (decl) = base; - BASELINK_BINFO (decl) + tree decl_binfo = lookup_base (base, BINFO_TYPE (BASELINK_BINFO (decl)), ba_unique, NULL, tf_none); + if (decl_binfo && decl_binfo != error_mark_node) + BASELINK_BINFO (decl) = decl_binfo; } } diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c index fd83c46e950c..1574e60199e4 100644 --- a/gcc/cp/semantics.c +++ b/gcc/cp/semantics.c @@ -1649,7 +1649,15 @@ force_paren_expr (tree expr) if (TREE_CODE (expr) == COMPONENT_REF) REF_PARENTHESIZED_P (expr) = true; - else if (type_dependent_expression_p (expr)) + else if (type_dependent_expression_p (expr) + /* When processing_template_decl, a SCOPE_REF may actually be + referring to a non-static data member of the current class, in + which case its TREE_TYPE may not be properly cv-qualified (the + cv-qualifiers of the implicit *this object haven't yet been taken + into account) so we have to delay building a static_cast until + instantiation. */ + || (processing_template_decl + && TREE_CODE (expr) == SCOPE_REF)) expr = build1 (PAREN_EXPR, TREE_TYPE (expr), expr); else if (VAR_P (expr) && DECL_HARD_REGISTER (expr)) /* We can't bind a hard register variable to a reference. */; diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c index 0b7b1443b609..5d9de344e7c8 100644 --- a/gcc/cp/tree.c +++ b/gcc/cp/tree.c @@ -824,9 +824,8 @@ build_cplus_array_type (tree elt_type, tree index_type) if (elt_type == error_mark_node || index_type == error_mark_node) return error_mark_node; - bool dependent = (processing_template_decl - && (dependent_type_p (elt_type) - || (index_type && dependent_type_p (index_type)))); + bool dependent = (uses_template_parms (elt_type) + || (index_type && uses_template_parms (index_type))); if (elt_type != TYPE_MAIN_VARIANT (elt_type)) /* Start with an array of the TYPE_MAIN_VARIANT. */ @@ -1437,6 +1436,9 @@ strip_typedefs (tree t, bool *remove_attributes) result = make_typename_type (strip_typedefs (TYPE_CONTEXT (t), remove_attributes), fullname, typename_type, tf_none); + /* Handle 'typedef typename A::N N;' */ + if (typedef_variant_p (result)) + result = TYPE_MAIN_VARIANT (DECL_ORIGINAL_TYPE (TYPE_NAME (result))); } break; case DECLTYPE_TYPE: @@ -1457,9 +1459,12 @@ strip_typedefs (tree t, bool *remove_attributes) if (!result) { if (typedef_variant_p (t)) - /* Explicitly get the underlying type, as TYPE_MAIN_VARIANT doesn't - strip typedefs with attributes. */ - result = TYPE_MAIN_VARIANT (DECL_ORIGINAL_TYPE (TYPE_NAME (t))); + { + /* Explicitly get the underlying type, as TYPE_MAIN_VARIANT doesn't + strip typedefs with attributes. */ + result = TYPE_MAIN_VARIANT (DECL_ORIGINAL_TYPE (TYPE_NAME (t))); + result = strip_typedefs (result); + } else result = TYPE_MAIN_VARIANT (t); } diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c index 51458798c5ba..447006cb3274 100644 --- a/gcc/cp/typeck.c +++ b/gcc/cp/typeck.c @@ -3974,6 +3974,38 @@ build_vec_cmp (tree_code code, tree type, return build3 (VEC_COND_EXPR, type, cmp, minus_one_vec, zero_vec); } +/* Possibly warn about an address never being NULL. */ + +static void +warn_for_null_address (location_t location, tree op, tsubst_flags_t complain) +{ + if (!warn_address + || (complain & tf_warning) == 0 + || c_inhibit_evaluation_warnings != 0 + || TREE_NO_WARNING (op)) + return; + + tree cop = fold_non_dependent_expr (op); + + if (TREE_CODE (cop) == ADDR_EXPR + && decl_with_nonnull_addr_p (TREE_OPERAND (cop, 0)) + && !TREE_NO_WARNING (cop)) + warning_at (location, OPT_Waddress, "the address of %qD will never " + "be NULL", TREE_OPERAND (cop, 0)); + + if (CONVERT_EXPR_P (op) + && TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == REFERENCE_TYPE) + { + tree inner_op = op; + STRIP_NOPS (inner_op); + + if (DECL_P (inner_op)) + warning_at (location, OPT_Waddress, + "the compiler can assume that the address of " + "%qD will never be NULL", inner_op); + } +} + /* Build a binary-operation expression without default conversions. CODE is the kind of expression to build. LOCATION is the location_t of the operator in the source code. @@ -4520,32 +4552,7 @@ cp_build_binary_op (location_t location, else result_type = type0; - if (TREE_CODE (op0) == ADDR_EXPR - && decl_with_nonnull_addr_p (TREE_OPERAND (op0, 0))) - { - if ((complain & tf_warning) - && c_inhibit_evaluation_warnings == 0 - && !TREE_NO_WARNING (op0)) - warning (OPT_Waddress, "the address of %qD will never be NULL", - TREE_OPERAND (op0, 0)); - } - - if (CONVERT_EXPR_P (op0) - && TREE_CODE (TREE_TYPE (TREE_OPERAND (op0, 0))) - == REFERENCE_TYPE) - { - tree inner_op0 = op0; - STRIP_NOPS (inner_op0); - - if ((complain & tf_warning) - && c_inhibit_evaluation_warnings == 0 - && !TREE_NO_WARNING (op0) - && DECL_P (inner_op0)) - warning_at (location, OPT_Waddress, - "the compiler can assume that the address of " - "%qD will never be NULL", - inner_op0); - } + warn_for_null_address (location, op0, complain); } else if (((code1 == POINTER_TYPE || TYPE_PTRDATAMEM_P (type1)) && null_ptr_cst_p (op0)) @@ -4559,32 +4566,7 @@ cp_build_binary_op (location_t location, else result_type = type1; - if (TREE_CODE (op1) == ADDR_EXPR - && decl_with_nonnull_addr_p (TREE_OPERAND (op1, 0))) - { - if ((complain & tf_warning) - && c_inhibit_evaluation_warnings == 0 - && !TREE_NO_WARNING (op1)) - warning (OPT_Waddress, "the address of %qD will never be NULL", - TREE_OPERAND (op1, 0)); - } - - if (CONVERT_EXPR_P (op1) - && TREE_CODE (TREE_TYPE (TREE_OPERAND (op1, 0))) - == REFERENCE_TYPE) - { - tree inner_op1 = op1; - STRIP_NOPS (inner_op1); - - if ((complain & tf_warning) - && c_inhibit_evaluation_warnings == 0 - && !TREE_NO_WARNING (op1) - && DECL_P (inner_op1)) - warning_at (location, OPT_Waddress, - "the compiler can assume that the address of " - "%qD will never be NULL", - inner_op1); - } + warn_for_null_address (location, op1, complain); } else if ((code0 == POINTER_TYPE && code1 == POINTER_TYPE) || (TYPE_PTRDATAMEM_P (type0) && TYPE_PTRDATAMEM_P (type1))) @@ -6704,11 +6686,7 @@ build_static_cast_1 (tree type, tree expr, bool c_cast_p, tree lref = cp_build_reference_type (TREE_TYPE (type), false); result = (perform_direct_initialization_if_possible (lref, expr, c_cast_p, complain)); - result = cp_fold_convert (type, result); - /* Make sure we don't fold back down to a named rvalue reference, - because that would be an lvalue. */ - if (DECL_P (result)) - result = build1 (NON_LVALUE_EXPR, type, result); + result = build1 (NON_LVALUE_EXPR, type, result); return convert_from_reference (result); } else diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c index 2a76c96c7d48..4ab77cda387c 100644 --- a/gcc/cp/typeck2.c +++ b/gcc/cp/typeck2.c @@ -1499,9 +1499,24 @@ process_init_constructor_union (tree type, tree init, constructor_elt *ce; int len; - /* If the initializer was empty, use default zero initialization. */ + /* If the initializer was empty, use the union's NSDMI if it has one. + Otherwise use default zero initialization. */ if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init))) - return 0; + { + for (tree field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) + { + if (DECL_INITIAL (field)) + { + CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (init), + field, + get_nsdmi (field, /*in_ctor=*/false)); + break; + } + } + + if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init))) + return 0; + } len = CONSTRUCTOR_ELTS (init)->length (); if (len > 1) diff --git a/gcc/diagnostic-show-locus.c b/gcc/diagnostic-show-locus.c index 3acdb32089c9..bf956661252e 100644 --- a/gcc/diagnostic-show-locus.c +++ b/gcc/diagnostic-show-locus.c @@ -117,7 +117,10 @@ class layout_point class layout_range { public: - layout_range (const location_range *loc_range); + layout_range (const expanded_location *start_exploc, + const expanded_location *finish_exploc, + bool show_caret_p, + const expanded_location *caret_exploc); bool contains_point (int row, int column) const; @@ -328,11 +331,14 @@ colorizer::finish_state (int state) Initialize various layout_point fields from expanded_location equivalents; we've already filtered on file. */ -layout_range::layout_range (const location_range *loc_range) -: m_start (loc_range->m_start), - m_finish (loc_range->m_finish), - m_show_caret_p (loc_range->m_show_caret_p), - m_caret (loc_range->m_caret) +layout_range::layout_range (const expanded_location *start_exploc, + const expanded_location *finish_exploc, + bool show_caret_p, + const expanded_location *caret_exploc) +: m_start (*start_exploc), + m_finish (*finish_exploc), + m_show_caret_p (show_caret_p), + m_caret (*caret_exploc) { } @@ -457,6 +463,82 @@ get_line_width_without_trailing_whitespace (const char *line, int line_width) return result; } +/* Helper function for layout's ctor, for sanitizing locations relative + to the primary location within a diagnostic. + + Compare LOC_A and LOC_B to see if it makes sense to print underlines + connecting their expanded locations. Doing so is only guaranteed to + make sense if the locations share the same macro expansion "history" + i.e. they can be traced through the same macro expansions, eventually + reaching an ordinary map. + + This may be too strong a condition, but it effectively sanitizes + PR c++/70105, which has an example of printing an expression where the + final location of the expression is in a different macro, which + erroneously was leading to hundreds of lines of irrelevant source + being printed. */ + +static bool +compatible_locations_p (location_t loc_a, location_t loc_b) +{ + if (IS_ADHOC_LOC (loc_a)) + loc_a = get_location_from_adhoc_loc (line_table, loc_a); + if (IS_ADHOC_LOC (loc_b)) + loc_b = get_location_from_adhoc_loc (line_table, loc_b); + + /* If either location is one of the special locations outside of a + linemap, they are only compatible if they are equal. */ + if (loc_a < RESERVED_LOCATION_COUNT + || loc_b < RESERVED_LOCATION_COUNT) + return loc_a == loc_b; + + const line_map *map_a = linemap_lookup (line_table, loc_a); + linemap_assert (map_a); + + const line_map *map_b = linemap_lookup (line_table, loc_b); + linemap_assert (map_b); + + /* Are they within the same map? */ + if (map_a == map_b) + { + /* Are both within the same macro expansion? */ + if (linemap_macro_expansion_map_p (map_a)) + { + /* Expand each location towards the spelling location, and + recurse. */ + const line_map_macro *macro_map = linemap_check_macro (map_a); + source_location loc_a_toward_spelling + = linemap_macro_map_loc_unwind_toward_spelling (line_table, + macro_map, + loc_a); + source_location loc_b_toward_spelling + = linemap_macro_map_loc_unwind_toward_spelling (line_table, + macro_map, + loc_b); + return compatible_locations_p (loc_a_toward_spelling, + loc_b_toward_spelling); + } + + /* Otherwise they are within the same ordinary map. */ + return true; + } + else + { + /* Within different maps. */ + + /* If either is within a macro expansion, they are incompatible. */ + if (linemap_macro_expansion_map_p (map_a) + || linemap_macro_expansion_map_p (map_b)) + return false; + + /* Within two different ordinary maps; they are compatible iff they + are in the same file. */ + const line_map_ordinary *ord_map_a = linemap_check_ordinary (map_a); + const line_map_ordinary *ord_map_b = linemap_check_ordinary (map_b); + return ord_map_a->to_file == ord_map_b->to_file; + } +} + /* Implementation of class layout. */ /* Constructor for class layout. @@ -473,7 +555,7 @@ layout::layout (diagnostic_context * context, : m_context (context), m_pp (context->printer), m_diagnostic_kind (diagnostic->kind), - m_exploc (diagnostic->richloc->lazily_expand_location ()), + m_exploc (diagnostic->richloc->get_expanded_location (0)), m_colorizer (context, diagnostic), m_colorize_source_p (context->colorize_source_p), m_layout_ranges (rich_location::MAX_RANGES), @@ -481,31 +563,57 @@ layout::layout (diagnostic_context * context, m_x_offset (0) { rich_location *richloc = diagnostic->richloc; + source_location primary_loc = richloc->get_range (0)->m_loc; + for (unsigned int idx = 0; idx < richloc->get_num_locations (); idx++) { /* This diagnostic printer can only cope with "sufficiently sane" ranges. Ignore any ranges that are awkward to handle. */ const location_range *loc_range = richloc->get_range (idx); + /* Split the "range" into caret and range information. */ + source_range src_range = get_range_from_loc (line_table, loc_range->m_loc); + + /* Expand the various locations. */ + expanded_location start + = linemap_client_expand_location_to_spelling_point (src_range.m_start); + expanded_location finish + = linemap_client_expand_location_to_spelling_point (src_range.m_finish); + expanded_location caret + = linemap_client_expand_location_to_spelling_point (loc_range->m_loc); + /* If any part of the range isn't in the same file as the primary location of this diagnostic, ignore the range. */ - if (loc_range->m_start.file != m_exploc.file) + if (start.file != m_exploc.file) continue; - if (loc_range->m_finish.file != m_exploc.file) + if (finish.file != m_exploc.file) continue; if (loc_range->m_show_caret_p) - if (loc_range->m_caret.file != m_exploc.file) + if (caret.file != m_exploc.file) continue; + /* Sanitize the caret location for non-primary ranges. */ + if (m_layout_ranges.length () > 0) + if (loc_range->m_show_caret_p) + if (!compatible_locations_p (loc_range->m_loc, primary_loc)) + /* Discard any non-primary ranges that can't be printed + sanely relative to the primary location. */ + continue; + /* Everything is now known to be in the correct source file, but it may require further sanitization. */ - layout_range ri (loc_range); + layout_range ri (&start, &finish, loc_range->m_show_caret_p, &caret); /* If we have a range that finishes before it starts (perhaps from something built via macro expansion), printing the range is likely to be nonsensical. Also, attempting to do so - breaks assumptions within the printing code (PR c/68473). */ - if (loc_range->m_start.line > loc_range->m_finish.line) + breaks assumptions within the printing code (PR c/68473). + Similarly, don't attempt to print ranges if one or both ends + of the range aren't sane to print relative to the + primary location (PR c++/70105). */ + if (start.line > finish.line + || !compatible_locations_p (src_range.m_start, primary_loc) + || !compatible_locations_p (src_range.m_finish, primary_loc)) { /* Is this the primary location? */ if (m_layout_ranges.length () == 0) diff --git a/gcc/diagnostic.c b/gcc/diagnostic.c index 322f2d9f5c08..6a679cb45a41 100644 --- a/gcc/diagnostic.c +++ b/gcc/diagnostic.c @@ -1338,17 +1338,3 @@ real_abort (void) { abort (); } - -/* Display the given source_range instance, with MSG as a descriptive - comment. This issues a "note" diagnostic at the range. - - This is declared within libcpp, but implemented here, since it - makes use of the diagnostic-printing machinery. */ - -DEBUG_FUNCTION void -source_range::debug (const char *msg) const -{ - rich_location richloc (line_table, m_start); - richloc.add_range (m_start, m_finish, false); - inform_at_rich_loc (&richloc, "%s", msg); -} diff --git a/gcc/diagnostic.h b/gcc/diagnostic.h index 017ddcae0bf0..ff5735770849 100644 --- a/gcc/diagnostic.h +++ b/gcc/diagnostic.h @@ -339,7 +339,7 @@ diagnostic_num_locations (const diagnostic_info * diagnostic) static inline expanded_location diagnostic_expand_location (const diagnostic_info * diagnostic, int which = 0) { - return diagnostic->richloc->get_range (which)->m_caret; + return diagnostic->richloc->get_expanded_location (which); } /* This is somehow the right-side margin of a caret line, that is, we diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi index 5713829ca19d..6e2702992c67 100644 --- a/gcc/doc/extend.texi +++ b/gcc/doc/extend.texi @@ -2772,29 +2772,40 @@ refer to the following subsections for details. @item leaf @cindex @code{leaf} function attribute -Calls to external functions with this attribute must return to the current -compilation unit only by return or by exception handling. In particular, leaf -functions are not allowed to call callback function passed to it from the current -compilation unit or directly call functions exported by the unit or longjmp -into the unit. Leaf function might still call functions from other compilation -units and thus they are not necessarily leaf in the sense that they contain no -function calls at all. - -The attribute is intended for library functions to improve dataflow analysis. -The compiler takes the hint that any data not escaping the current compilation unit can -not be used or modified by the leaf function. For example, the @code{sin} function -is a leaf function, but @code{qsort} is not. - -Note that leaf functions might invoke signals and signal handlers might be -defined in the current compilation unit and use static variables. The only -compliant way to write such a signal handler is to declare such variables -@code{volatile}. - -The attribute has no effect on functions defined within the current compilation -unit. This is to allow easy merging of multiple compilation units into one, -for example, by using the link-time optimization. For this reason the -attribute is not allowed on types to annotate indirect calls. - +Calls to external functions with this attribute must return to the +current compilation unit only by return or by exception handling. In +particular, a leaf function is not allowed to invoke callback functions +passed to it from the current compilation unit, directly call functions +exported by the unit, or @code{longjmp} into the unit. Leaf functions +might still call functions from other compilation units and thus they +are not necessarily leaf in the sense that they contain no function +calls at all. + +The attribute is intended for library functions to improve dataflow +analysis. The compiler takes the hint that any data not escaping the +current compilation unit cannot be used or modified by the leaf +function. For example, the @code{sin} function is a leaf function, but +@code{qsort} is not. + +Note that leaf functions might indirectly run a signal handler defined +in the current compilation unit that uses static variables. Similarly, +when lazy symbol resolution is in effect, leaf functions might invoke +indirect functions whose resolver function or implementation function is +defined in the current compilation unit and uses static variables. There +is no standard-compliant way to write such a signal handler, resolver +function, or implementation function, and the best that you can do is to +remove the @code{leaf} attribute or mark all such static variables +@code{volatile}. Lastly, for ELF-based systems that support symbol +interposition, care should be taken that functions defined in the +current compilation unit do not unexpectedly interpose other symbols +based on the defined standards mode and defined feature test macros; +otherwise an inadvertent callback would be added. + +The attribute has no effect on functions defined within the current +compilation unit. This is to allow easy merging of multiple compilation +units into one, for example, by using the link-time optimization. For +this reason the attribute is not allowed on types to annotate indirect +calls. @item malloc @cindex @code{malloc} function attribute @@ -3034,7 +3045,7 @@ int square (int) __attribute__ ((pure)); says that the hypothetical function @code{square} is safe to call fewer times than the program says. -Some of common examples of pure functions are @code{strlen} or @code{memcmp}. +Some common examples of pure functions are @code{strlen} or @code{memcmp}. Interesting non-pure functions are functions with infinite loops or those depending on volatile memory or other system resource, that may change between two consecutive calls (such as @code{feof} in a multithreading environment). @@ -7441,10 +7452,10 @@ note that some assembler dialects use semicolons to start a comment. @end table @subsubheading Remarks -Using extended @code{asm} typically produces smaller, safer, and more -efficient code, and in most cases it is a better solution than basic -@code{asm}. However, there are two situations where only basic @code{asm} -can be used: +Using extended @code{asm} (@pxref{Extended Asm}) typically produces +smaller, safer, and more efficient code, and in most cases it is a +better solution than basic @code{asm}. However, there are two +situations where only basic @code{asm} can be used: @itemize @bullet @item @@ -7481,9 +7492,24 @@ assembly code when optimizing. This can lead to unexpected duplicate symbol errors during compilation if your assembly code defines symbols or labels. -Since GCC does not parse the @var{AssemblerInstructions}, it has no -visibility of any symbols it references. This may result in GCC discarding -those symbols as unreferenced. +@strong{Warning:} The C standards do not specify semantics for @code{asm}, +making it a potential source of incompatibilities between compilers. These +incompatibilities may not produce compiler warnings/errors. + +GCC does not parse basic @code{asm}'s @var{AssemblerInstructions}, which +means there is no way to communicate to the compiler what is happening +inside them. GCC has no visibility of symbols in the @code{asm} and may +discard them as unreferenced. It also does not know about side effects of +the assembler code, such as modifications to memory or registers. Unlike +some compilers, GCC assumes that no changes to either memory or registers +occur. This assumption may change in a future release. + +To avoid complications from future changes to the semantics and the +compatibility issues between compilers, consider replacing basic @code{asm} +with extended @code{asm}. See +@uref{https://gcc.gnu.org/wiki/ConvertBasicAsmToExtended, How to convert +from basic asm to extended asm} for information about how to perform this +conversion. The compiler copies the assembler instructions in a basic @code{asm} verbatim to the assembly language output file, without @@ -10714,10 +10740,11 @@ it is the responsibility of its caller to make sure the argument doesn't cause it to exceed the stack size limit. The @code{__builtin_alloca} function is provided to make it possible to allocate on the stack arrays of bytes with an upper bound that may be -computed at run time. Since C99 @xref{Variable Length} Arrays offer +computed at run time. Since C99 Variable Length Arrays offer similar functionality under a portable, more convenient, and safer interface they are recommended instead, in both C99 and C++ programs where GCC provides them as an extension. +@xref{Variable Length}, for details. @end deftypefn @@ -10761,10 +10788,10 @@ the argument doesn't cause it to exceed the stack size limit. The @code{__builtin_alloca_with_align} function is provided to make it possible to allocate on the stack overaligned arrays of bytes with an upper bound that may be computed at run time. Since C99 -@xref{Variable Length} Arrays offer the same functionality under +Variable Length Arrays offer the same functionality under a portable, more convenient, and safer interface they are recommended instead, in both C99 and C++ programs where GCC provides them as -an extension. +an extension. @xref{Variable Length}, for details. @end deftypefn diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index 4b5df0b7edd0..9e54bb75737f 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -267,7 +267,7 @@ Objective-C and Objective-C++ Dialects}. -Wno-format-contains-nul -Wno-format-extra-args -Wformat-nonliteral @gol -Wformat-security -Wformat-signedness -Wformat-y2k -Wframe-address @gol -Wframe-larger-than=@var{len} -Wno-free-nonheap-object -Wjump-misses-init @gol --Wignored-qualifiers -Wincompatible-pointer-types @gol +-Wignored-qualifiers -Wignored-attributes -Wincompatible-pointer-types @gol -Wimplicit -Wimplicit-function-declaration -Wimplicit-int @gol -Winit-self -Winline -Wno-int-conversion @gol -Wno-int-to-pointer-cast -Winvalid-memory-model -Wno-invalid-offsetof @gol @@ -408,7 +408,7 @@ Objective-C and Objective-C++ Dialects}. -ftree-parallelize-loops=@var{n} -ftree-pre -ftree-partial-pre -ftree-pta @gol -ftree-reassoc -ftree-sink -ftree-slsr -ftree-sra @gol -ftree-switch-conversion -ftree-tail-merge -ftree-ter @gol --ftree-vectorize -ftree-vrp @gol +-ftree-vectorize -ftree-vrp -funconstrained-commons @gol -funit-at-a-time -funroll-all-loops -funroll-loops @gol -funsafe-loop-optimizations -funsafe-math-optimizations -funswitch-loops @gol -fipa-ra -fvariable-expansion-in-unroller -fvect-cost-model -fvpt @gol @@ -2238,6 +2238,16 @@ return value even without this option. In all other cases, when exhaustion is signalled by throwing @code{std::bad_alloc}. See also @samp{new (nothrow)}. +@item -fconcepts +@opindex fconcepts +Enable support for the C++ Extensions for Concepts Technical +Specification, ISO 19217 (2015), which allows code like + +@smallexample +template concept bool Addable = requires (T t) @{ t + t; @}; +template T add (T a, T b) @{ return a + b; @} +@end smallexample + @item -fconstexpr-depth=@var{n} @opindex fconstexpr-depth Set the maximum nested evaluation depth for C++11 constexpr functions @@ -3876,6 +3886,14 @@ even without this option. This warning is also enabled by @option{-Wextra}. +@item -Wignored-attributes @r{(C and C++ only)} +@opindex Wignored-attributes +@opindex Wno-ignored-attributes +Warn when an attribute is ignored. This is different from the +@option{-Wattributes} option in that it warns whenever the compiler decides +to drop an attribute, not that the attribute is either unknown, used in a +wrong place, etc. This warning is enabled by default. + @item -Wmain @opindex Wmain @opindex Wno-main @@ -6541,11 +6559,14 @@ life-range analysis. This option is effective only with @item -fno-branch-count-reg @opindex fno-branch-count-reg -Do not use ``decrement and branch'' instructions on a count register, -but instead generate a sequence of instructions that decrement a -register, compare it against zero, then branch based upon the result. -This option is only meaningful on architectures that support such -instructions, which include x86, PowerPC, IA-64 and S/390. +Avoid running a pass scanning for opportunities to use ``decrement and +branch'' instructions on a count register instead of generating sequences +of instructions that decrement a register, compare it against zero, and +then branch based upon the result. This option is only meaningful on +architectures that support such instructions, which include x86, PowerPC, +IA-64 and S/390. Note that the @option{-fno-branch-count-reg} option +doesn't remove the decrement and branch instructions from the generated +instruction stream introduced by other optimization passes. Enabled by default at @option{-O1} and higher. @@ -6686,6 +6707,12 @@ the loop optimizer itself cannot prove that these assumptions are valid. If you use @option{-Wunsafe-loop-optimizations}, the compiler warns you if it finds this kind of loop. +@item -funconstrained-commons +@opindex funconstrained-commons +This option tells the compiler that variables declared in common blocks +(e.g. Fortran) may later be overridden with longer trailing arrays. This +prevents certain optimizations that depend on knowing the array bounds. + @item -fcrossjumping @opindex fcrossjumping Perform cross-jumping transformation. @@ -13980,7 +14007,8 @@ Permissible names are: @samp{arm2}, @samp{arm250}, @samp{cortex-a9}, @samp{cortex-a12}, @samp{cortex-a15}, @samp{cortex-a17}, @samp{cortex-a32}, @samp{cortex-a35}, @samp{cortex-a53}, @samp{cortex-a57}, @samp{cortex-a72}, @samp{cortex-r4}, -@samp{cortex-r4f}, @samp{cortex-r5}, @samp{cortex-r7}, @samp{cortex-m7}, +@samp{cortex-r4f}, @samp{cortex-r5}, @samp{cortex-r7}, @samp{cortex-r8}, +@samp{cortex-m7}, @samp{cortex-m4}, @samp{cortex-m3}, @samp{cortex-m1}, diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi index 8b3bccda9673..745910f9a331 100644 --- a/gcc/doc/tm.texi +++ b/gcc/doc/tm.texi @@ -2861,7 +2861,7 @@ A target hook which can change allocno class for given pseudo from @end deftypefn @deftypefn {Target Hook} bool TARGET_LRA_P (void) -A target hook which returns true if we use LRA instead of reload pass. It means that LRA was ported to the target. The default version of this target hook returns always false. +A target hook which returns true if we use LRA instead of reload pass. The default version of this target hook returns always false, but new ports should use LRA. @end deftypefn @deftypefn {Target Hook} int TARGET_REGISTER_PRIORITY (int) diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c index a8c21d809ce5..0bbff87a95ee 100644 --- a/gcc/dwarf2out.c +++ b/gcc/dwarf2out.c @@ -25641,11 +25641,29 @@ prune_unused_types_walk_loc_descr (dw_loc_descr_ref loc) for (; loc != NULL; loc = loc->dw_loc_next) switch (loc->dw_loc_opc) { + case DW_OP_GNU_implicit_pointer: + case DW_OP_GNU_convert: + case DW_OP_GNU_reinterpret: + if (loc->dw_loc_oprnd1.val_class == dw_val_class_die_ref) + prune_unused_types_mark (loc->dw_loc_oprnd1.v.val_die_ref.die, 1); + break; case DW_OP_call2: case DW_OP_call4: case DW_OP_call_ref: + case DW_OP_GNU_const_type: + case DW_OP_GNU_parameter_ref: + gcc_assert (loc->dw_loc_oprnd1.val_class == dw_val_class_die_ref); prune_unused_types_mark (loc->dw_loc_oprnd1.v.val_die_ref.die, 1); break; + case DW_OP_GNU_regval_type: + case DW_OP_GNU_deref_type: + gcc_assert (loc->dw_loc_oprnd2.val_class == dw_val_class_die_ref); + prune_unused_types_mark (loc->dw_loc_oprnd2.v.val_die_ref.die, 1); + break; + case DW_OP_GNU_entry_value: + gcc_assert (loc->dw_loc_oprnd1.val_class == dw_val_class_loc); + prune_unused_types_walk_loc_descr (loc->dw_loc_oprnd1.v.val_loc); + break; default: break; } @@ -27263,12 +27281,15 @@ optimize_location_lists (dw_die_ref die) static void flush_limbo_die_list (void) { - limbo_die_node *node, *next_node; + limbo_die_node *node; - for (node = limbo_die_list; node; node = next_node) + /* get_context_die calls force_decl_die, which can put new DIEs on the + limbo list in LTO mode when nested functions are put in a different + partition than that of their parent function. */ + while ((node = limbo_die_list)) { dw_die_ref die = node->die; - next_node = node->next; + limbo_die_list = node->next; if (die->die_parent == NULL) { @@ -27306,8 +27327,6 @@ flush_limbo_die_list (void) } } } - - limbo_die_list = NULL; } /* Output stuff that dwarf requires at the end of every file, @@ -27667,10 +27686,15 @@ dwarf2out_finish (const char *filename) static void dwarf2out_early_finish (void) { - limbo_die_node *node; + /* The point here is to flush out the limbo list so that it is empty + and we don't need to stream it for LTO. */ + flush_limbo_die_list (); + + gen_scheduled_generic_parms_dies (); + gen_remaining_tmpl_value_param_die_attribute (); /* Add DW_AT_linkage_name for all deferred DIEs. */ - for (node = deferred_asm_name; node; node = node->next) + for (limbo_die_node *node = deferred_asm_name; node; node = node->next) { tree decl = node->created_for; if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl) @@ -27684,13 +27708,6 @@ dwarf2out_early_finish (void) } } deferred_asm_name = NULL; - - /* The point here is to flush out the limbo list so that it is empty - and we don't need to stream it for LTO. */ - flush_limbo_die_list (); - - gen_scheduled_generic_parms_dies (); - gen_remaining_tmpl_value_param_die_attribute (); } /* Reset all state within dwarf2out.c so that we can rerun the compiler diff --git a/gcc/explow.c b/gcc/explow.c index cd7c56813f30..249318f44b58 100644 --- a/gcc/explow.c +++ b/gcc/explow.c @@ -1566,7 +1566,7 @@ probe_stack_range (HOST_WIDE_INT first, rtx size) stack_pointer_rtx, plus_constant (Pmode, size, first))); - emit_library_call (stack_check_libfunc, LCT_NORMAL, VOIDmode, 1, addr, + emit_library_call (stack_check_libfunc, LCT_THROW, VOIDmode, 1, addr, Pmode); } diff --git a/gcc/expmed.c b/gcc/expmed.c index 829b967b3ca2..31d905bd3d57 100644 --- a/gcc/expmed.c +++ b/gcc/expmed.c @@ -658,24 +658,28 @@ store_bit_field_using_insv (const extraction_insn *insv, rtx op0, { if (GET_MODE_BITSIZE (GET_MODE (value)) >= bitsize) { + rtx tmp; /* Optimization: Don't bother really extending VALUE if it has all the bits we will actually use. However, if we must narrow it, be sure we do it correctly. */ if (GET_MODE_SIZE (GET_MODE (value)) < GET_MODE_SIZE (op_mode)) { - rtx tmp; - tmp = simplify_subreg (op_mode, value1, GET_MODE (value), 0); if (! tmp) tmp = simplify_gen_subreg (op_mode, force_reg (GET_MODE (value), value1), GET_MODE (value), 0); - value1 = tmp; } else - value1 = gen_lowpart (op_mode, value1); + { + tmp = gen_lowpart_if_possible (op_mode, value1); + if (! tmp) + tmp = gen_lowpart (op_mode, force_reg (GET_MODE (value), + value1)); + } + value1 = tmp; } else if (CONST_INT_P (value)) value1 = gen_int_mode (INTVAL (value), op_mode); diff --git a/gcc/fold-const.c b/gcc/fold-const.c index 5376d4d499c0..44fe2a27d4f5 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -3032,6 +3032,9 @@ operand_equal_p (const_tree arg0, const_tree arg1, unsigned int flags) TYPE_SIZE (TREE_TYPE (arg1)), flags))) return 0; + /* Verify that access happens in similar types. */ + if (!types_compatible_p (TREE_TYPE (arg0), TREE_TYPE (arg1))) + return 0; /* Verify that accesses are TBAA compatible. */ if (!alias_ptr_types_compatible_p (TREE_TYPE (TREE_OPERAND (arg0, 1)), @@ -6113,11 +6116,9 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type, { tree tem = const_binop (code, fold_convert (ctype, t), fold_convert (ctype, c)); - /* If the multiplication overflowed to INT_MIN then we lost sign - information on it and a subsequent multiplication might - spuriously overflow. See PR68142. */ - if (TREE_OVERFLOW (tem) - && wi::eq_p (tem, wi::min_value (TYPE_PRECISION (ctype), SIGNED))) + /* If the multiplication overflowed, we lost information on it. + See PR68142 and PR69845. */ + if (TREE_OVERFLOW (tem)) return NULL_TREE; return tem; } @@ -6373,18 +6374,17 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type, bool overflow_p = false; bool overflow_mul_p; signop sign = TYPE_SIGN (ctype); - wide_int mul = wi::mul (op1, c, sign, &overflow_mul_p); + unsigned prec = TYPE_PRECISION (ctype); + wide_int mul = wi::mul (wide_int::from (op1, prec, sign), + wide_int::from (c, prec, sign), + sign, &overflow_mul_p); overflow_p = TREE_OVERFLOW (c) | TREE_OVERFLOW (op1); if (overflow_mul_p && ((sign == UNSIGNED && tcode != MULT_EXPR) || sign == SIGNED)) overflow_p = true; if (!overflow_p) - { - mul = wide_int::from (mul, TYPE_PRECISION (ctype), - TYPE_SIGN (TREE_TYPE (op1))); - return fold_build2 (tcode, ctype, fold_convert (ctype, op0), - wide_int_to_tree (ctype, mul)); - } + return fold_build2 (tcode, ctype, fold_convert (ctype, op0), + wide_int_to_tree (ctype, mul)); } /* If these operations "cancel" each other, we have the main @@ -14218,17 +14218,20 @@ fold_indirect_ref_1 (location_t loc, tree type, tree op0) if (TREE_CODE (op00type) == VECTOR_TYPE && type == TREE_TYPE (op00type)) { - HOST_WIDE_INT offset = tree_to_shwi (op01); tree part_width = TYPE_SIZE (type); - unsigned HOST_WIDE_INT part_widthi = tree_to_shwi (part_width)/BITS_PER_UNIT; - unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT; - tree index = bitsize_int (indexi); - - if (offset / part_widthi < TYPE_VECTOR_SUBPARTS (op00type)) - return fold_build3_loc (loc, - BIT_FIELD_REF, type, op00, - part_width, index); - + unsigned HOST_WIDE_INT max_offset + = (tree_to_uhwi (part_width) / BITS_PER_UNIT + * TYPE_VECTOR_SUBPARTS (op00type)); + if (tree_int_cst_sign_bit (op01) == 0 + && compare_tree_int (op01, max_offset) == -1) + { + unsigned HOST_WIDE_INT offset = tree_to_uhwi (op01); + unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT; + tree index = bitsize_int (indexi); + return fold_build3_loc (loc, + BIT_FIELD_REF, type, op00, + part_width, index); + } } /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */ else if (TREE_CODE (op00type) == COMPLEX_TYPE diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog index 54950beffd2a..dac67d1fc845 100644 --- a/gcc/fortran/ChangeLog +++ b/gcc/fortran/ChangeLog @@ -1,3 +1,47 @@ +2016-03-19 Jerry DeLisle + + PR fortran/69043 + * scanner.c (load_file): Update to use S_ISREG macro. + +2016-03-17 Thomas Schwinge + + * gfortran.h (enum gfc_omp_map_op): Rename OMP_MAP_FORCE_DEALLOC + to OMP_MAP_DELETE. Adjust all users. + +2016-03-13 Jerry DeLisle + Jim MacArthur + + PR fortran/69043 + * scanner.c (load_file): Check that included file is regular. + +2016-03-12 Jerry DeLisle + Harold Anlauf + + PR fortran/69520 + * invoke.texi: Explain use of the 'no-' construct within the + -fcheck= option. + * options.c (gfc_handle_runtime_check_option): Enable use of + 'no-' prefix for the various options with -fcheck= to allow + negating previously enabled check options. + +2016-03-12 Paul Thomas + + PR fortran/70031 + * decl.c (gfc_match_prefix): Treat the 'module' prefix in the + same way as the others, rather than fixing it to come last. + (gfc_match_function_decl, gfc_match_subroutine): After errors + in 'copy_prefix', emit them immediately in the case of module + procedures to prevent a later ICE. + + PR fortran/69524 + * decl.c (gfc_match_submod_proc): Permit 'module procedure' + declarations within the contains section of modules as well as + submodules. + * resolve.c (resolve_fl_procedure): Likewise. + *trans-decl.c (build_function_decl): Change the gcc_assert to + allow all forms of module procedure declarations within module + contains sections. + 2016-02-28 Thomas Koenig PR fortran/68147 diff --git a/gcc/fortran/decl.c b/gcc/fortran/decl.c index d3ddda2d5f54..80ec39cb86b4 100644 --- a/gcc/fortran/decl.c +++ b/gcc/fortran/decl.c @@ -764,7 +764,7 @@ char_len_param_value (gfc_expr **expr, bool *deferred) gfc_reduce_init_expr (e); if ((e->ref && e->ref->type == REF_ARRAY - && e->ref->u.ar.type != AR_ELEMENT) + && e->ref->u.ar.type != AR_ELEMENT) || (!e->ref && e->expr_type == EXPR_ARRAY)) { gfc_free_expr (e); @@ -1183,8 +1183,8 @@ gfc_verify_c_interop_param (gfc_symbol *sym) else if (sym->attr.optional == 1 && !gfc_notify_std (GFC_STD_F2008_TS, "Variable %qs " "at %L with OPTIONAL attribute in " - "procedure %qs which is BIND(C)", - sym->name, &(sym->declared_at), + "procedure %qs which is BIND(C)", + sym->name, &(sym->declared_at), sym->ns->proc_name->name)) retval = false; @@ -1195,8 +1195,8 @@ gfc_verify_c_interop_param (gfc_symbol *sym) && !gfc_notify_std (GFC_STD_F2008_TS, "Assumed-shape array %qs " "at %L as dummy argument to the BIND(C) " "procedure %qs at %L", sym->name, - &(sym->declared_at), - sym->ns->proc_name->name, + &(sym->declared_at), + sym->ns->proc_name->name, &(sym->ns->proc_name->declared_at))) retval = false; } @@ -1286,7 +1286,7 @@ build_sym (const char *name, gfc_charlen *cl, bool cl_deferred, { /* Set the binding label and verify that if a NAME= was specified then only one identifier was in the entity-decl-list. */ - if (!set_binding_label (&sym->binding_label, sym->name, + if (!set_binding_label (&sym->binding_label, sym->name, num_idents_on_line)) return false; } @@ -1505,7 +1505,7 @@ add_init_expr_to_sym (const char *name, gfc_expr **initp, locus *var_locus) else if (init->value.constructor) { gfc_constructor *c; - c = gfc_constructor_first (init->value.constructor); + c = gfc_constructor_first (init->value.constructor); clen = c->expr->value.character.length; } else @@ -1570,7 +1570,7 @@ add_init_expr_to_sym (const char *name, gfc_expr **initp, locus *var_locus) lower = sym->as->lower[dim]; - /* If the lower bound is an array element from another + /* If the lower bound is an array element from another parameterized array, then it is marked with EXPR_VARIABLE and is an initialization expression. Try to reduce it. */ if (lower->expr_type == EXPR_VARIABLE) @@ -1998,7 +1998,7 @@ variable_decl (int elem) as->type = AS_IMPLIED_SHAPE; if (as->type == AS_IMPLIED_SHAPE - && !gfc_notify_std (GFC_STD_F2008, "Implied-shape array at %L", + && !gfc_notify_std (GFC_STD_F2008, "Implied-shape array at %L", &var_locus)) { m = MATCH_ERROR; @@ -2314,8 +2314,8 @@ gfc_match_old_kind_spec (gfc_typespec *ts) return MATCH_ERROR; } - if (!gfc_notify_std (GFC_STD_GNU, - "Nonstandard type declaration %s*%d at %C", + if (!gfc_notify_std (GFC_STD_GNU, + "Nonstandard type declaration %s*%d at %C", gfc_basic_typename(ts->type), original_kind)) return MATCH_ERROR; @@ -2918,7 +2918,7 @@ gfc_match_decl_type_spec (gfc_typespec *ts, int implicit_flag) /* This is essential to force the construction of unlimited polymorphic component class containers. */ upe->attr.zero_comp = 1; - if (!gfc_add_flavor (&upe->attr, FL_DERIVED, NULL, + if (!gfc_add_flavor (&upe->attr, FL_DERIVED, NULL, &gfc_current_locus)) return MATCH_ERROR; } @@ -3938,7 +3938,7 @@ match_attr_spec (void) && gfc_state_stack->previous->state == COMP_MODULE) { if (!gfc_notify_std (GFC_STD_F2003, "Attribute %s " - "at %L in a TYPE definition", attr, + "at %L in a TYPE definition", attr, &seen_at[d])) { m = MATCH_ERROR; @@ -4345,7 +4345,7 @@ set_verify_bind_c_com_block (gfc_common_head *com_block, int num_idents) bool retval = true; /* destLabel, common name, typespec (which may have binding label). */ - if (!set_binding_label (&com_block->binding_label, com_block->name, + if (!set_binding_label (&com_block->binding_label, com_block->name, num_idents)) return false; @@ -4606,6 +4606,19 @@ gfc_match_prefix (gfc_typespec *ts) { found_prefix = false; + /* MODULE is a prefix like PURE, ELEMENTAL, etc., having a + corresponding attribute seems natural and distinguishes these + procedures from procedure types of PROC_MODULE, which these are + as well. */ + if (gfc_match ("module% ") == MATCH_YES) + { + if (!gfc_notify_std (GFC_STD_F2008, "MODULE prefix at %C")) + goto error; + + current_attr.module_procedure = 1; + found_prefix = true; + } + if (!seen_type && ts != NULL && gfc_match_decl_type_spec (ts, 0) == MATCH_YES && gfc_match_space () == MATCH_YES) @@ -4670,21 +4683,6 @@ gfc_match_prefix (gfc_typespec *ts) /* At this point, the next item is not a prefix. */ gcc_assert (gfc_matching_prefix); - /* MODULE should be the last prefix before FUNCTION or SUBROUTINE. - Since this is a prefix like PURE, ELEMENTAL, etc., having a - corresponding attribute seems natural and distinguishes these - procedures from procedure types of PROC_MODULE, which these are - as well. */ - if ((gfc_current_state () == COMP_INTERFACE - || gfc_current_state () == COMP_CONTAINS) - && gfc_match ("module% ") == MATCH_YES) - { - if (!gfc_notify_std (GFC_STD_F2008, "MODULE prefix at %C")) - goto error; - else - current_attr.module_procedure = 1; - } - gfc_matching_prefix = false; return MATCH_YES; @@ -5142,7 +5140,7 @@ match_procedure_interface (gfc_symbol **proc_if) if ((*proc_if)->attr.flavor == FL_UNKNOWN && (*proc_if)->ts.type == BT_UNKNOWN - && !gfc_add_flavor (&(*proc_if)->attr, FL_PROCEDURE, + && !gfc_add_flavor (&(*proc_if)->attr, FL_PROCEDURE, (*proc_if)->name, NULL)) return MATCH_ERROR; } @@ -5639,10 +5637,17 @@ gfc_match_function_decl (void) if (!gfc_add_function (&sym->attr, sym->name, NULL)) goto cleanup; - if (!gfc_missing_attr (&sym->attr, NULL) - || !copy_prefix (&sym->attr, &sym->declared_at)) + if (!gfc_missing_attr (&sym->attr, NULL)) goto cleanup; + if (!copy_prefix (&sym->attr, &sym->declared_at)) + { + if(!sym->attr.module_procedure) + goto cleanup; + else + gfc_error_check (); + } + /* Delay matching the function characteristics until after the specification block by signalling kind=-1. */ sym->declared_at = old_loc; @@ -5666,6 +5671,7 @@ gfc_match_function_decl (void) sym->result = result; } + /* Warn if this procedure has the same name as an intrinsic. */ do_warn_intrinsic_shadow (sym, true); @@ -5890,7 +5896,7 @@ gfc_match_entry (void) gfc_error ("Missing required parentheses before BIND(C) at %C"); return MATCH_ERROR; } - if (!gfc_add_is_bind_c (&(entry->attr), entry->name, + if (!gfc_add_is_bind_c (&(entry->attr), entry->name, &(entry->declared_at), 1)) return MATCH_ERROR; } @@ -6096,7 +6102,7 @@ gfc_match_subroutine (void) gfc_error ("Missing required parentheses before BIND(C) at %C"); return MATCH_ERROR; } - if (!gfc_add_is_bind_c (&(sym->attr), sym->name, + if (!gfc_add_is_bind_c (&(sym->attr), sym->name, &(sym->declared_at), 1)) return MATCH_ERROR; } @@ -6108,7 +6114,12 @@ gfc_match_subroutine (void) } if (!copy_prefix (&sym->attr, &sym->declared_at)) - return MATCH_ERROR; + { + if(!sym->attr.module_procedure) + return MATCH_ERROR; + else + gfc_error_check (); + } /* Warn if it has the same name as an intrinsic. */ do_warn_intrinsic_shadow (sym, false); @@ -6516,7 +6527,7 @@ gfc_match_end (gfc_statement *st) if (!eos_ok && (*st == ST_END_SUBROUTINE || *st == ST_END_FUNCTION)) { if (!gfc_notify_std (GFC_STD_F2008, "END statement " - "instead of %s statement at %L", + "instead of %s statement at %L", abreviated_modproc_decl ? "END PROCEDURE" : gfc_ascii_statement(*st), &old_loc)) goto cleanup; @@ -7148,16 +7159,16 @@ access_attr_decl (gfc_statement st) if (gfc_get_symbol (name, NULL, &sym)) goto done; - if (!gfc_add_access (&sym->attr, - (st == ST_PUBLIC) - ? ACCESS_PUBLIC : ACCESS_PRIVATE, + if (!gfc_add_access (&sym->attr, + (st == ST_PUBLIC) + ? ACCESS_PUBLIC : ACCESS_PRIVATE, sym->name, NULL)) return MATCH_ERROR; if (sym->attr.generic && (dt_sym = gfc_find_dt_in_generic (sym)) - && !gfc_add_access (&dt_sym->attr, - (st == ST_PUBLIC) - ? ACCESS_PUBLIC : ACCESS_PRIVATE, + && !gfc_add_access (&dt_sym->attr, + (st == ST_PUBLIC) + ? ACCESS_PUBLIC : ACCESS_PRIVATE, sym->name, NULL)) return MATCH_ERROR; @@ -7481,7 +7492,7 @@ gfc_match_save (void) switch (m) { case MATCH_YES: - if (!gfc_add_save (&sym->attr, SAVE_EXPLICIT, sym->name, + if (!gfc_add_save (&sym->attr, SAVE_EXPLICIT, sym->name, &gfc_current_locus)) return MATCH_ERROR; goto next_item; @@ -7697,7 +7708,8 @@ gfc_match_submod_proc (void) if (gfc_current_state () != COMP_CONTAINS || !(gfc_state_stack->previous - && gfc_state_stack->previous->state == COMP_SUBMODULE)) + && (gfc_state_stack->previous->state == COMP_SUBMODULE + || gfc_state_stack->previous->state == COMP_MODULE))) return MATCH_NO; m = gfc_match (" module% procedure% %n", name); @@ -8127,7 +8139,7 @@ gfc_match_derived_decl (void) return MATCH_ERROR; else if (sym->attr.access == ACCESS_UNKNOWN && gensym->attr.access != ACCESS_UNKNOWN - && !gfc_add_access (&sym->attr, gensym->attr.access, + && !gfc_add_access (&sym->attr, gensym->attr.access, sym->name, NULL)) return MATCH_ERROR; diff --git a/gcc/fortran/gfortran.h b/gcc/fortran/gfortran.h index 33fffd8bdcfe..a0fb5fda9e57 100644 --- a/gcc/fortran/gfortran.h +++ b/gcc/fortran/gfortran.h @@ -1112,8 +1112,8 @@ enum gfc_omp_map_op OMP_MAP_TO, OMP_MAP_FROM, OMP_MAP_TOFROM, + OMP_MAP_DELETE, OMP_MAP_FORCE_ALLOC, - OMP_MAP_FORCE_DEALLOC, OMP_MAP_FORCE_TO, OMP_MAP_FORCE_FROM, OMP_MAP_FORCE_TOFROM, diff --git a/gcc/fortran/invoke.texi b/gcc/fortran/invoke.texi index 7fbbc4b01a9b..e90656e4eeff 100644 --- a/gcc/fortran/invoke.texi +++ b/gcc/fortran/invoke.texi @@ -1398,7 +1398,8 @@ library needs to be linked. @cindex checking array temporaries Enable the generation of run-time checks; the argument shall be -a comma-delimited list of the following keywords. +a comma-delimited list of the following keywords. Prefixing a check with +@option{no-} disables it if it was activated by a previous specification. @table @asis @item @samp{all} @@ -1444,6 +1445,13 @@ Note: This check does not work for OpenMP programs and is disabled if used together with @option{-frecursive} and @option{-fopenmp}. @end table +Example: Assuming you have a file @file{foo.f90}, the command +@smallexample + gfortran -fcheck=all,no-array-temps foo.f90 +@end smallexample +will compile the file with all checks enabled as specified above except +warnings for generated array temporaries. + @item -fbounds-check @opindex @code{fbounds-check} diff --git a/gcc/fortran/openmp.c b/gcc/fortran/openmp.c index 51ab96ec6e5f..a6c39cda6942 100644 --- a/gcc/fortran/openmp.c +++ b/gcc/fortran/openmp.c @@ -764,7 +764,7 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, uint64_t mask, if ((mask & OMP_CLAUSE_DELETE) && gfc_match ("delete ( ") == MATCH_YES && gfc_match_omp_map_clause (&c->lists[OMP_LIST_MAP], - OMP_MAP_FORCE_DEALLOC)) + OMP_MAP_DELETE)) continue; if ((mask & OMP_CLAUSE_PRESENT) && gfc_match ("present ( ") == MATCH_YES diff --git a/gcc/fortran/options.c b/gcc/fortran/options.c index f8d8f8d5c82c..0fcda1d48402 100644 --- a/gcc/fortran/options.c +++ b/gcc/fortran/options.c @@ -515,6 +515,15 @@ gfc_handle_runtime_check_option (const char *arg) result = 1; break; } + else if (optname[n] && pos > 3 && strncmp ("no-", arg, 3) == 0 + && strncmp (optname[n], arg+3, pos-3) == 0) + { + gfc_option.rtcheck &= ~optmask[n]; + arg += pos; + pos = 0; + result = 1; + break; + } } if (!result) gfc_fatal_error ("Argument to %<-fcheck%> is not valid: %s", arg); diff --git a/gcc/fortran/resolve.c b/gcc/fortran/resolve.c index 556c8469d281..55ab2ecfcebe 100644 --- a/gcc/fortran/resolve.c +++ b/gcc/fortran/resolve.c @@ -11905,7 +11905,7 @@ resolve_fl_procedure (gfc_symbol *sym, int mp_flag) "in %qs at %L", sym->name, &sym->declared_at); return false; } - if (sym->attr.external && sym->attr.function + if (sym->attr.external && sym->attr.function && !sym->attr.module_procedure && ((sym->attr.if_source == IFSRC_DECL && !sym->attr.procedure) || sym->attr.contained)) { diff --git a/gcc/fortran/scanner.c b/gcc/fortran/scanner.c index c4e7974ed4a5..f4dedd69757a 100644 --- a/gcc/fortran/scanner.c +++ b/gcc/fortran/scanner.c @@ -2200,6 +2200,8 @@ load_file (const char *realfilename, const char *displayedname, bool initial) FILE *input; int len, line_len; bool first_line; + struct stat st; + int stat_result; const char *filename; /* If realfilename and displayedname are different and non-null then surely realfilename is the preprocessed form of @@ -2227,6 +2229,7 @@ load_file (const char *realfilename, const char *displayedname, bool initial) } else input = gfc_open_file (realfilename); + if (input == NULL) { gfc_error_now ("Can't open file %qs", filename); @@ -2242,6 +2245,15 @@ load_file (const char *realfilename, const char *displayedname, bool initial) current_file->filename, current_file->line, filename); return false; } + stat_result = stat (realfilename, &st); + if (stat_result == 0 && !S_ISREG(st.st_mode)) + { + fprintf (stderr, "%s:%d: Error: Included path '%s'" + " is not a regular file\n", + current_file->filename, current_file->line, filename); + fclose (input); + return false; + } } /* Load the file. diff --git a/gcc/fortran/trans-decl.c b/gcc/fortran/trans-decl.c index 4e7129e150a9..4bd7dc4e8531 100644 --- a/gcc/fortran/trans-decl.c +++ b/gcc/fortran/trans-decl.c @@ -2062,7 +2062,12 @@ build_function_decl (gfc_symbol * sym, bool global) tree result_decl; gfc_formal_arglist *f; - gcc_assert (!sym->attr.external); + bool module_procedure = sym->attr.module_procedure + && sym->ns + && sym->ns->proc_name + && sym->ns->proc_name->attr.flavor == FL_MODULE; + + gcc_assert (!sym->attr.external || module_procedure); if (sym->backend_decl) return; diff --git a/gcc/fortran/trans-openmp.c b/gcc/fortran/trans-openmp.c index 5990202c68c3..a905ca607aee 100644 --- a/gcc/fortran/trans-openmp.c +++ b/gcc/fortran/trans-openmp.c @@ -2119,12 +2119,12 @@ gfc_trans_omp_clauses (stmtblock_t *block, gfc_omp_clauses *clauses, case OMP_MAP_TOFROM: OMP_CLAUSE_SET_MAP_KIND (node, GOMP_MAP_TOFROM); break; + case OMP_MAP_DELETE: + OMP_CLAUSE_SET_MAP_KIND (node, GOMP_MAP_DELETE); + break; case OMP_MAP_FORCE_ALLOC: OMP_CLAUSE_SET_MAP_KIND (node, GOMP_MAP_FORCE_ALLOC); break; - case OMP_MAP_FORCE_DEALLOC: - OMP_CLAUSE_SET_MAP_KIND (node, GOMP_MAP_FORCE_DEALLOC); - break; case OMP_MAP_FORCE_TO: OMP_CLAUSE_SET_MAP_KIND (node, GOMP_MAP_FORCE_TO); break; diff --git a/gcc/function.h b/gcc/function.h index c4368cda7f22..501ef6848401 100644 --- a/gcc/function.h +++ b/gcc/function.h @@ -328,6 +328,10 @@ struct GTY(()) function { from nested functions. */ unsigned int has_nonlocal_label : 1; + /* Nonzero if function being compiled has a forced label + placed into static storage. */ + unsigned int has_forced_label_in_static : 1; + /* Nonzero if we've set cannot_be_copied_reason. I.e. if (cannot_be_copied_set && !cannot_be_copied_reason), the function can in fact be copied. */ diff --git a/gcc/gcc-rich-location.c b/gcc/gcc-rich-location.c index 9ab4314a875c..a03ce0ee5fa9 100644 --- a/gcc/gcc-rich-location.c +++ b/gcc/gcc-rich-location.c @@ -41,28 +41,6 @@ along with GCC; see the file COPYING3. If not see #include "cpplib.h" #include "diagnostic.h" -/* Extract any source range information from EXPR and write it - to *R. */ - -static bool -get_range_for_expr (tree expr, location_range *r) -{ - if (EXPR_HAS_RANGE (expr)) - { - source_range sr = EXPR_LOCATION_RANGE (expr); - - /* Do we have meaningful data? */ - if (sr.m_start && sr.m_finish) - { - r->m_start = expand_location (sr.m_start); - r->m_finish = expand_location (sr.m_finish); - return true; - } - } - - return false; -} - /* Add a range to the rich_location, covering expression EXPR. */ void @@ -70,10 +48,8 @@ gcc_rich_location::add_expr (tree expr) { gcc_assert (expr); - location_range r; - r.m_show_caret_p = false; - if (get_range_for_expr (expr, &r)) - add_range (&r); + if (CAN_HAVE_RANGE_P (expr)) + add_range (EXPR_LOCATION (expr), false); } /* If T is an expression, add a range for it to the rich_location. */ diff --git a/gcc/gcse.c b/gcc/gcse.c index 51277a1cb613..a3a7dc31353d 100644 --- a/gcc/gcse.c +++ b/gcc/gcse.c @@ -3796,10 +3796,8 @@ compute_ld_motion_mems (void) { rtx src = SET_SRC (PATTERN (insn)); rtx dest = SET_DEST (PATTERN (insn)); - rtx note = find_reg_equal_equiv_note (insn); - rtx src_eq; - /* Check for a simple LOAD... */ + /* Check for a simple load. */ if (MEM_P (src) && simple_mem (src)) { ptr = ldst_entry (src); @@ -3814,12 +3812,11 @@ compute_ld_motion_mems (void) invalidate_any_buried_refs (src); } - if (note != 0 && REG_NOTE_KIND (note) == REG_EQUAL) - src_eq = XEXP (note, 0); - else - src_eq = NULL_RTX; - - if (src_eq != NULL_RTX + /* Check for a simple load through a REG_EQUAL note. */ + rtx note = find_reg_equal_equiv_note (insn), src_eq; + if (note + && REG_NOTE_KIND (note) == REG_EQUAL + && (src_eq = XEXP (note, 0)) && !(MEM_P (src_eq) && simple_mem (src_eq))) invalidate_any_buried_refs (src_eq); @@ -3843,7 +3840,17 @@ compute_ld_motion_mems (void) } } else - invalidate_any_buried_refs (PATTERN (insn)); + { + /* Invalidate all MEMs in the pattern and... */ + invalidate_any_buried_refs (PATTERN (insn)); + + /* ...in REG_EQUAL notes for PARALLELs with single SET. */ + rtx note = find_reg_equal_equiv_note (insn), src_eq; + if (note + && REG_NOTE_KIND (note) == REG_EQUAL + && (src_eq = XEXP (note, 0))) + invalidate_any_buried_refs (src_eq); + } } } } diff --git a/gcc/genmatch.c b/gcc/genmatch.c index 19218fdaf2ec..1f5f45c206a0 100644 --- a/gcc/genmatch.c +++ b/gcc/genmatch.c @@ -548,7 +548,7 @@ struct operand { virtual void gen_transform (FILE *, int, const char *, bool, int, const char *, capture_info *, dt_operand ** = 0, - bool = true) + int = 0) { gcc_unreachable (); } }; @@ -590,7 +590,7 @@ struct expr : public operand bool force_single_use; virtual void gen_transform (FILE *f, int, const char *, bool, int, const char *, capture_info *, - dt_operand ** = 0, bool = true); + dt_operand ** = 0, int = 0); }; /* An operator that is represented by native C code. This is always @@ -622,7 +622,7 @@ struct c_expr : public operand vec ids; virtual void gen_transform (FILE *f, int, const char *, bool, int, const char *, capture_info *, - dt_operand ** = 0, bool = true); + dt_operand ** = 0, int = 0); }; /* A wrapper around another operand that captures its value. */ @@ -637,7 +637,7 @@ struct capture : public operand operand *what; virtual void gen_transform (FILE *f, int, const char *, bool, int, const char *, capture_info *, - dt_operand ** = 0, bool = true); + dt_operand ** = 0, int = 0); }; /* if expression. */ @@ -2149,7 +2149,7 @@ get_operand_type (id_base *op, const char *in_type, void expr::gen_transform (FILE *f, int indent, const char *dest, bool gimple, int depth, const char *in_type, capture_info *cinfo, - dt_operand **indexes, bool) + dt_operand **indexes, int) { id_base *opr = operation; /* When we delay operator substituting during lowering of fors we @@ -2213,9 +2213,8 @@ expr::gen_transform (FILE *f, int indent, const char *dest, bool gimple, i == 0 ? NULL : op0type); ops[i]->gen_transform (f, indent, dest, gimple, depth + 1, optype, cinfo, indexes, - ((!(*opr == COND_EXPR) - && !(*opr == VEC_COND_EXPR)) - || i != 0)); + (*opr == COND_EXPR + || *opr == VEC_COND_EXPR) && i == 0 ? 1 : 2); } const char *opr_name; @@ -2306,7 +2305,7 @@ expr::gen_transform (FILE *f, int indent, const char *dest, bool gimple, void c_expr::gen_transform (FILE *f, int indent, const char *dest, bool, int, const char *, capture_info *, - dt_operand **, bool) + dt_operand **, int) { if (dest && nr_stmts == 1) fprintf_indent (f, indent, "%s = ", dest); @@ -2378,7 +2377,7 @@ c_expr::gen_transform (FILE *f, int indent, const char *dest, void capture::gen_transform (FILE *f, int indent, const char *dest, bool gimple, int depth, const char *in_type, capture_info *cinfo, - dt_operand **indexes, bool expand_compares) + dt_operand **indexes, int cond_handling) { if (what && is_a (what)) { @@ -2394,20 +2393,29 @@ capture::gen_transform (FILE *f, int indent, const char *dest, bool gimple, fprintf_indent (f, indent, "%s = captures[%u];\n", dest, where); /* ??? Stupid tcc_comparison GENERIC trees in COND_EXPRs. Deal - with substituting a capture of that. - ??? Returning false here will also not allow any other patterns - to match. */ - if (gimple && expand_compares + with substituting a capture of that. */ + if (gimple + && cond_handling != 0 && cinfo->info[where].cond_expr_cond_p) { - fprintf_indent (f, indent, "if (COMPARISON_CLASS_P (%s))\n", dest); - fprintf_indent (f, indent, " {\n"); - fprintf_indent (f, indent, " if (!seq) return false;\n"); - fprintf_indent (f, indent, " %s = gimple_build (seq, TREE_CODE (%s)," - " TREE_TYPE (%s), TREE_OPERAND (%s, 0)," - " TREE_OPERAND (%s, 1));\n", - dest, dest, dest, dest, dest); - fprintf_indent (f, indent, " }\n"); + /* If substituting into a cond_expr condition, unshare. */ + if (cond_handling == 1) + fprintf_indent (f, indent, "%s = unshare_expr (%s);\n", dest, dest); + /* If substituting elsewhere we might need to decompose it. */ + else if (cond_handling == 2) + { + /* ??? Returning false here will also not allow any other patterns + to match unless this generator was split out. */ + fprintf_indent (f, indent, "if (COMPARISON_CLASS_P (%s))\n", dest); + fprintf_indent (f, indent, " {\n"); + fprintf_indent (f, indent, " if (!seq) return false;\n"); + fprintf_indent (f, indent, " %s = gimple_build (seq," + " TREE_CODE (%s)," + " TREE_TYPE (%s), TREE_OPERAND (%s, 0)," + " TREE_OPERAND (%s, 1));\n", + dest, dest, dest, dest, dest); + fprintf_indent (f, indent, " }\n"); + } } } @@ -2615,7 +2623,7 @@ dt_node::gen_kids (FILE *f, int indent, bool gimple) preds.safe_push (op); else { - if (gimple) + if (gimple && !e->is_generic) gimple_exprs.safe_push (op); else generic_exprs.safe_push (op); @@ -3043,18 +3051,14 @@ dt_simplify::gen_1 (FILE *f, int indent, bool gimple, operand *result) "type", e->expr_type, j == 0 ? NULL : "TREE_TYPE (res_ops[0])"); /* We need to expand GENERIC conditions we captured from - COND_EXPRs. */ - bool expand_generic_cond_exprs_p - = (!is_predicate - /* But avoid doing that if the GENERIC condition is - valid - which it is in the first operand of COND_EXPRs - and VEC_COND_EXRPs. */ - && ((!(*opr == COND_EXPR) - && !(*opr == VEC_COND_EXPR)) - || j != 0)); + COND_EXPRs and we need to unshare them when substituting + into COND_EXPRs. */ + int cond_handling = 0; + if (!is_predicate) + cond_handling = ((*opr == COND_EXPR + || *opr == VEC_COND_EXPR) && j == 0) ? 1 : 2; e->ops[j]->gen_transform (f, indent, dest, true, 1, optype, - &cinfo, - indexes, expand_generic_cond_exprs_p); + &cinfo, indexes, cond_handling); } /* Re-fold the toplevel result. It's basically an embedded @@ -3068,7 +3072,7 @@ dt_simplify::gen_1 (FILE *f, int indent, bool gimple, operand *result) || result->type == operand::OP_C_EXPR) { result->gen_transform (f, indent, "res_ops[0]", true, 1, "type", - &cinfo, indexes, false); + &cinfo, indexes); fprintf_indent (f, indent, "*res_code = TREE_CODE (res_ops[0]);\n"); if (is_a (result) && cinfo.info[as_a (result)->where].cond_expr_cond_p) diff --git a/gcc/genrecog.c b/gcc/genrecog.c index f8b8ef46dc57..47e42660fcc8 100644 --- a/gcc/genrecog.c +++ b/gcc/genrecog.c @@ -4037,7 +4037,7 @@ match_pattern_2 (state *s, md_rtx_info *info, position *pos, rtx pattern) /* Check the mode first, to distinguish things like SImode and DImode register_operands, as described above. */ machine_mode mode = GET_MODE (e->pattern); - if (safe_predicate_mode (pred, mode)) + if (pred && safe_predicate_mode (pred, mode)) s = add_decision (s, rtx_test::mode (e->pos), mode, true); /* Assign to operands[] first, so that the rtx usually doesn't diff --git a/gcc/gimple-expr.c b/gcc/gimple-expr.c index 15bef7f1665c..29e9c0a33dcc 100644 --- a/gcc/gimple-expr.c +++ b/gcc/gimple-expr.c @@ -519,8 +519,8 @@ create_tmp_reg_fn (struct function *fn, tree type, const char *prefix) *OP1_P, *OP2_P and *OP3_P respectively. */ void -extract_ops_from_tree_1 (tree expr, enum tree_code *subcode_p, tree *op1_p, - tree *op2_p, tree *op3_p) +extract_ops_from_tree (tree expr, enum tree_code *subcode_p, tree *op1_p, + tree *op2_p, tree *op3_p) { enum gimple_rhs_class grhs_class; diff --git a/gcc/gimple-expr.h b/gcc/gimple-expr.h index 7f9c90d4f1b1..f2ccd29a94a6 100644 --- a/gcc/gimple-expr.h +++ b/gcc/gimple-expr.h @@ -35,8 +35,8 @@ extern tree create_tmp_reg (tree, const char * = NULL); extern tree create_tmp_reg_fn (struct function *, tree, const char *); -extern void extract_ops_from_tree_1 (tree, enum tree_code *, tree *, tree *, - tree *); +extern void extract_ops_from_tree (tree, enum tree_code *, tree *, tree *, + tree *); extern void gimple_cond_get_ops_from_tree (tree, enum tree_code *, tree *, tree *); extern bool is_gimple_lvalue (tree); @@ -146,15 +146,15 @@ is_gimple_constant (const_tree t) } } -/* A wrapper around extract_ops_from_tree_1, for callers which expect - to see only a maximum of two operands. */ +/* A wrapper around extract_ops_from_tree with 3 ops, for callers which + expect to see only a maximum of two operands. */ static inline void extract_ops_from_tree (tree expr, enum tree_code *code, tree *op0, tree *op1) { tree op2; - extract_ops_from_tree_1 (expr, code, op0, op1, &op2); + extract_ops_from_tree (expr, code, op0, op1, &op2); gcc_assert (op2 == NULL_TREE); } diff --git a/gcc/gimple-match-head.c b/gcc/gimple-match-head.c index 3e6d15f1b365..c86a4ffb0e34 100644 --- a/gcc/gimple-match-head.c +++ b/gcc/gimple-match-head.c @@ -38,6 +38,7 @@ along with GCC; see the file COPYING3. If not see #include "tree-pass.h" #include "internal-fn.h" #include "case-cfn-macros.h" +#include "gimplify.h" /* Forward declarations of the private auto-generated matchers. diff --git a/gcc/gimple-ssa-split-paths.c b/gcc/gimple-ssa-split-paths.c index ac6de8147df0..d566f64c70be 100644 --- a/gcc/gimple-ssa-split-paths.c +++ b/gcc/gimple-ssa-split-paths.c @@ -294,6 +294,24 @@ split_paths () basic_block pred0 = EDGE_PRED (bb, 0)->src; transform_duplicate (pred0, bb); changed = true; + + /* If BB has an outgoing edge marked as IRREDUCIBLE, then + duplicating BB may result in an irreducible region turning + into a natural loop. + + Long term we might want to hook this into the block + duplication code, but as we've seen with similar changes + for edge removal, that can be somewhat risky. */ + if (EDGE_SUCC (bb, 0)->flags & EDGE_IRREDUCIBLE_LOOP + || EDGE_SUCC (bb, 1)->flags & EDGE_IRREDUCIBLE_LOOP) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, + "Join block %d has EDGE_IRREDUCIBLE_LOOP set. " + "Scheduling loop fixups.\n", + bb->index); + loops_state_set (LOOPS_NEED_FIXUP); + } } } diff --git a/gcc/gimple.c b/gcc/gimple.c index 850e54669cd6..b0e19d515cf0 100644 --- a/gcc/gimple.c +++ b/gcc/gimple.c @@ -387,7 +387,7 @@ gimple_build_assign (tree lhs, tree rhs MEM_STAT_DECL) enum tree_code subcode; tree op1, op2, op3; - extract_ops_from_tree_1 (rhs, &subcode, &op1, &op2, &op3); + extract_ops_from_tree (rhs, &subcode, &op1, &op2, &op3); return gimple_build_assign (lhs, subcode, op1, op2, op3 PASS_MEM_STAT); } @@ -1578,7 +1578,7 @@ gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *gsi, tree expr) enum tree_code subcode; tree op1, op2, op3; - extract_ops_from_tree_1 (expr, &subcode, &op1, &op2, &op3); + extract_ops_from_tree (expr, &subcode, &op1, &op2, &op3); gimple_assign_set_rhs_with_ops (gsi, subcode, op1, op2, op3); } diff --git a/gcc/gimplify.c b/gcc/gimplify.c index 7be6bd708f1e..b9757db4c893 100644 --- a/gcc/gimplify.c +++ b/gcc/gimplify.c @@ -1414,7 +1414,10 @@ force_labels_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) if (TYPE_P (*tp)) *walk_subtrees = 0; if (TREE_CODE (*tp) == LABEL_DECL) - FORCED_LABEL (*tp) = 1; + { + FORCED_LABEL (*tp) = 1; + cfun->has_forced_label_in_static = 1; + } return NULL_TREE; } @@ -1436,14 +1439,22 @@ gimplify_decl_expr (tree *stmt_p, gimple_seq *seq_p) if ((TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == VAR_DECL) && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl))) - gimplify_type_sizes (TREE_TYPE (decl), seq_p); + { + gimplify_type_sizes (TREE_TYPE (decl), seq_p); + if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE) + gimplify_type_sizes (TREE_TYPE (TREE_TYPE (decl)), seq_p); + } /* ??? DECL_ORIGINAL_TYPE is streamed for LTO so it needs to be gimplified in case its size expressions contain problematic nodes like CALL_EXPR. */ if (TREE_CODE (decl) == TYPE_DECL && DECL_ORIGINAL_TYPE (decl) && !TYPE_SIZES_GIMPLIFIED (DECL_ORIGINAL_TYPE (decl))) - gimplify_type_sizes (DECL_ORIGINAL_TYPE (decl), seq_p); + { + gimplify_type_sizes (DECL_ORIGINAL_TYPE (decl), seq_p); + if (TREE_CODE (DECL_ORIGINAL_TYPE (decl)) == REFERENCE_TYPE) + gimplify_type_sizes (TREE_TYPE (DECL_ORIGINAL_TYPE (decl)), seq_p); + } if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl)) { @@ -4830,7 +4841,8 @@ gimplify_modify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, } notice_special_calls (call_stmt); if (!gimple_call_noreturn_p (call_stmt) - || TREE_ADDRESSABLE (TREE_TYPE (*to_p))) + || TREE_ADDRESSABLE (TREE_TYPE (*to_p)) + || TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (*to_p))) != INTEGER_CST) gimple_call_set_lhs (call_stmt, *to_p); assign = call_stmt; } @@ -4838,6 +4850,8 @@ gimplify_modify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, { assign = gimple_build_assign (*to_p, *from_p); gimple_set_location (assign, EXPR_LOCATION (*expr_p)); + if (COMPARISON_CLASS_P (*from_p)) + gimple_set_no_warning (assign, TREE_NO_WARNING (*from_p)); } if (gimplify_ctxp->into_ssa && is_gimple_reg (*to_p)) @@ -5177,6 +5191,32 @@ gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p) ret = tret; } + /* If the constraint does not allow memory make sure we gimplify + it to a register if it is not already but its base is. This + happens for complex and vector components. */ + if (!allows_mem) + { + tree op = TREE_VALUE (link); + if (! is_gimple_val (op) + && is_gimple_reg_type (TREE_TYPE (op)) + && is_gimple_reg (get_base_address (op))) + { + tree tem = create_tmp_reg (TREE_TYPE (op)); + tree ass; + if (is_inout) + { + ass = build2 (MODIFY_EXPR, TREE_TYPE (tem), + tem, unshare_expr (op)); + gimplify_and_add (ass, pre_p); + } + ass = build2 (MODIFY_EXPR, TREE_TYPE (tem), op, tem); + gimplify_and_add (ass, post_p); + + TREE_VALUE (link) = tem; + tret = GS_OK; + } + } + vec_safe_push (outputs, link); TREE_CHAIN (link) = NULL_TREE; @@ -6264,16 +6304,30 @@ omp_notice_variable (struct gimplify_omp_ctx *ctx, tree decl, bool in_code) if ((n->value & (GOVD_SEEN | GOVD_LOCAL)) == 0 && (flags & (GOVD_SEEN | GOVD_LOCAL)) == GOVD_SEEN - && DECL_SIZE (decl) - && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST) + && DECL_SIZE (decl)) { - splay_tree_node n2; - tree t = DECL_VALUE_EXPR (decl); - gcc_assert (TREE_CODE (t) == INDIRECT_REF); - t = TREE_OPERAND (t, 0); - gcc_assert (DECL_P (t)); - n2 = splay_tree_lookup (ctx->variables, (splay_tree_key) t); - n2->value |= GOVD_SEEN; + if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST) + { + splay_tree_node n2; + tree t = DECL_VALUE_EXPR (decl); + gcc_assert (TREE_CODE (t) == INDIRECT_REF); + t = TREE_OPERAND (t, 0); + gcc_assert (DECL_P (t)); + n2 = splay_tree_lookup (ctx->variables, (splay_tree_key) t); + n2->value |= GOVD_SEEN; + } + else if (lang_hooks.decls.omp_privatize_by_reference (decl) + && TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl))) + && (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)))) + != INTEGER_CST)) + { + splay_tree_node n2; + tree t = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl))); + gcc_assert (DECL_P (t)); + n2 = splay_tree_lookup (ctx->variables, (splay_tree_key) t); + if (n2) + n2->value |= GOVD_SEEN; + } } shared = ((flags | n->value) & GOVD_SHARED) != 0; @@ -8168,7 +8222,7 @@ gimplify_oacc_declare_1 (tree clause) case GOMP_MAP_ALLOC: case GOMP_MAP_FORCE_ALLOC: case GOMP_MAP_FORCE_TO: - new_op = GOMP_MAP_FORCE_DEALLOC; + new_op = GOMP_MAP_DELETE; ret = true; break; @@ -10773,8 +10827,23 @@ gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, goto expr_2; } - case FMA_EXPR: case VEC_COND_EXPR: + { + enum gimplify_status r0, r1, r2; + + r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, + post_p, is_gimple_condexpr, fb_rvalue); + r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, + post_p, is_gimple_val, fb_rvalue); + r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p, + post_p, is_gimple_val, fb_rvalue); + + ret = MIN (MIN (r0, r1), r2); + recalculate_side_effects (*expr_p); + } + break; + + case FMA_EXPR: case VEC_PERM_EXPR: /* Classified as tcc_expression. */ goto expr_3; @@ -11573,24 +11642,28 @@ gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, { static bool gave_help; bool warned; + /* Use the expansion point to handle cases such as passing bool (defined + in a system header) through `...'. */ + source_location xloc + = expansion_point_location_if_in_system_header (loc); /* Unfortunately, this is merely undefined, rather than a constraint violation, so we cannot make this an error. If this call is never executed, the program is still strictly conforming. */ - warned = warning_at (loc, 0, - "%qT is promoted to %qT when passed through %<...%>", + warned = warning_at (xloc, 0, + "%qT is promoted to %qT when passed through %<...%>", type, promoted_type); if (!gave_help && warned) { gave_help = true; - inform (loc, "(so you should pass %qT not %qT to %)", + inform (xloc, "(so you should pass %qT not %qT to %)", promoted_type, type); } /* We can, however, treat "undefined" any way we please. Call abort to encourage the user to fix the program. */ if (warned) - inform (loc, "if this code is reached, the program will abort"); + inform (xloc, "if this code is reached, the program will abort"); /* Before the abort, allow the evaluation of the va_list expression to exit or longjmp. */ gimplify_and_add (valist, pre_p); diff --git a/gcc/graphite-isl-ast-to-gimple.c b/gcc/graphite-isl-ast-to-gimple.c index d3614e48cd8f..8dd5dc8bb843 100644 --- a/gcc/graphite-isl-ast-to-gimple.c +++ b/gcc/graphite-isl-ast-to-gimple.c @@ -821,7 +821,8 @@ graphite_create_new_loop_guard (edge entry_edge, if (integer_onep (cond_expr)) exit_edge = entry_edge; else - exit_edge = create_empty_if_region_on_edge (entry_edge, cond_expr); + exit_edge = create_empty_if_region_on_edge (entry_edge, + unshare_expr (cond_expr)); return exit_edge; } @@ -1403,6 +1404,8 @@ gsi_insert_earliest (gimple_seq seq) void translate_isl_ast_to_gimple:: collect_all_ssa_names (tree new_expr, vec *vec_ssa) { + if (new_expr == NULL_TREE) + return; /* Rename all uses in new_expr. */ if (TREE_CODE (new_expr) == SSA_NAME) @@ -1801,7 +1804,7 @@ get_new_name (basic_block new_bb, tree op, basic_block old_bb, phi_node_kind phi_kind) const { /* For constants the names are the same. */ - if (is_constant (op)) + if (TREE_CODE (op) != SSA_NAME) return op; return get_rename (new_bb, op, old_bb, phi_kind); diff --git a/gcc/graphite-scop-detection.c b/gcc/graphite-scop-detection.c index 03b1c49d728e..7615842b332d 100644 --- a/gcc/graphite-scop-detection.c +++ b/gcc/graphite-scop-detection.c @@ -273,8 +273,10 @@ trivially_empty_bb_p (basic_block bb) static inline bool same_close_phi_node (gphi *p1, gphi *p2) { - return operand_equal_p (gimple_phi_arg_def (p1, 0), - gimple_phi_arg_def (p2, 0), 0); + return (types_compatible_p (TREE_TYPE (gimple_phi_result (p1)), + TREE_TYPE (gimple_phi_result (p2))) + && operand_equal_p (gimple_phi_arg_def (p1, 0), + gimple_phi_arg_def (p2, 0), 0)); } static void make_close_phi_nodes_unique (basic_block bb); @@ -834,7 +836,9 @@ scop_detection::merge_sese (sese_l first, sese_l second) const { /* Find the first empty succ (with single exit) of combined.exit. */ basic_block imm_succ = combined.exit->dest; - if (single_succ_p (imm_succ) && trivially_empty_bb_p (imm_succ)) + if (single_succ_p (imm_succ) + && single_pred_p (imm_succ) + && trivially_empty_bb_p (imm_succ)) combined.exit = single_succ_edge (imm_succ); else { diff --git a/gcc/hsa-brig.c b/gcc/hsa-brig.c index 61cfd8b8c238..9b6c0b888e0e 100644 --- a/gcc/hsa-brig.c +++ b/gcc/hsa-brig.c @@ -643,6 +643,8 @@ emit_function_directives (hsa_function_representation *f, bool is_declaration) if (!f->m_declaration_p) for (int i = 0; f->m_global_symbols.iterate (i, &sym); i++) { + gcc_assert (!sym->m_emitted_to_brig); + sym->m_emitted_to_brig = true; emit_directive_variable (sym); brig_insn_count++; } @@ -2006,8 +2008,6 @@ hsa_brig_emit_omp_symbols (void) emit_directive_variable (hsa_num_threads); } -static GTY(()) tree hsa_cdtor_statements[2]; - /* Create and return __hsa_global_variables symbol that contains all informations consumed by libgomp to link global variables with their string names used by an HSA kernel. */ @@ -2408,6 +2408,7 @@ hsa_output_libgomp_mapping (tree brig_decl) = builtin_decl_explicit (BUILT_IN_GOMP_OFFLOAD_REGISTER); gcc_checking_assert (offload_register); + tree *hsa_ctor_stmts = hsa_get_ctor_statements (); append_to_statement_list (build_call_expr (offload_register, 4, build_int_cstu (unsigned_type_node, @@ -2416,15 +2417,15 @@ hsa_output_libgomp_mapping (tree brig_decl) build_fold_addr_expr (hsa_libgomp_host_table), build_int_cst (integer_type_node, GOMP_DEVICE_HSA), build_fold_addr_expr (hsa_img_descriptor)), - &hsa_cdtor_statements[0]); + hsa_ctor_stmts); - cgraph_build_static_cdtor ('I', hsa_cdtor_statements[0], - DEFAULT_INIT_PRIORITY); + cgraph_build_static_cdtor ('I', *hsa_ctor_stmts, DEFAULT_INIT_PRIORITY); tree offload_unregister = builtin_decl_explicit (BUILT_IN_GOMP_OFFLOAD_UNREGISTER); gcc_checking_assert (offload_unregister); + tree *hsa_dtor_stmts = hsa_get_dtor_statements (); append_to_statement_list (build_call_expr (offload_unregister, 4, build_int_cstu (unsigned_type_node, @@ -2433,9 +2434,8 @@ hsa_output_libgomp_mapping (tree brig_decl) build_fold_addr_expr (hsa_libgomp_host_table), build_int_cst (integer_type_node, GOMP_DEVICE_HSA), build_fold_addr_expr (hsa_img_descriptor)), - &hsa_cdtor_statements[1]); - cgraph_build_static_cdtor ('D', hsa_cdtor_statements[1], - DEFAULT_INIT_PRIORITY); + hsa_dtor_stmts); + cgraph_build_static_cdtor ('D', *hsa_dtor_stmts, DEFAULT_INIT_PRIORITY); } /* Emit the brig module we have compiled to a section in the final assembly and diff --git a/gcc/hsa-dump.c b/gcc/hsa-dump.c index c5f1f69cd39b..b69b34d8ff05 100644 --- a/gcc/hsa-dump.c +++ b/gcc/hsa-dump.c @@ -721,6 +721,9 @@ dump_hsa_symbol (FILE *f, hsa_symbol *symbol) if (symbol->m_type & BRIG_TYPE_ARRAY_MASK) fprintf (f, "[%lu]", (unsigned long) symbol->m_dim); + + if (symbol->m_directive_offset) + fprintf (f, " /* BRIG offset: %u */", symbol->m_directive_offset); } /* Dump textual representation of HSA IL operand OP to file F. */ @@ -929,7 +932,8 @@ dump_hsa_insn_1 (FILE *f, hsa_insn_basic *insn, int *indent) fprintf (f, ", "); } - fprintf (f, "]"); + fprintf (f, "] /* default: BB %i */", + hsa_bb_for_bb (sbr->m_default_bb)->m_index); } else if (is_a (insn)) { diff --git a/gcc/hsa-gen.c b/gcc/hsa-gen.c index d7d39f09c1ef..72eecf9462e5 100644 --- a/gcc/hsa-gen.c +++ b/gcc/hsa-gen.c @@ -162,7 +162,7 @@ hsa_symbol::hsa_symbol () m_directive_offset (0), m_type (BRIG_TYPE_NONE), m_segment (BRIG_SEGMENT_NONE), m_linkage (BRIG_LINKAGE_NONE), m_dim (0), m_cst_value (NULL), m_global_scope_p (false), m_seen_error (false), - m_allocation (BRIG_ALLOCATION_AUTOMATIC) + m_allocation (BRIG_ALLOCATION_AUTOMATIC), m_emitted_to_brig (false) { } @@ -174,7 +174,7 @@ hsa_symbol::hsa_symbol (BrigType16_t type, BrigSegment8_t segment, m_directive_offset (0), m_type (type), m_segment (segment), m_linkage (linkage), m_dim (0), m_cst_value (NULL), m_global_scope_p (global_scope_p), m_seen_error (false), - m_allocation (allocation) + m_allocation (allocation), m_emitted_to_brig (false) { } @@ -880,11 +880,28 @@ get_symbol_for_decl (tree decl) gcc_checking_assert (slot); if (*slot) { + hsa_symbol *sym = (*slot); + /* If the symbol is problematic, mark current function also as problematic. */ - if ((*slot)->m_seen_error) + if (sym->m_seen_error) hsa_fail_cfun (); + /* PR hsa/70234: If a global variable was marked to be emitted, + but HSAIL generation of a function using the variable fails, + we should retry to emit the variable in context of a different + function. + + Iterate elements whether a symbol is already in m_global_symbols + of not. */ + if (is_in_global_vars && !sym->m_emitted_to_brig) + { + for (unsigned i = 0; i < hsa_cfun->m_global_symbols.length (); i++) + if (hsa_cfun->m_global_symbols[i] == sym) + return *slot; + hsa_cfun->m_global_symbols.safe_push (sym); + } + return *slot; } else @@ -3772,20 +3789,19 @@ gen_set_num_threads (tree value, hsa_bb *hbb) hbb->append_insn (basic); } -static GTY (()) tree hsa_kernel_dispatch_type = NULL; - /* Return byte offset of a FIELD_NAME in GOMP_hsa_kernel_dispatch which is defined in plugin-hsa.c. */ static HOST_WIDE_INT get_hsa_kernel_dispatch_offset (const char *field_name) { - if (hsa_kernel_dispatch_type == NULL) + tree *hsa_kernel_dispatch_type = hsa_get_kernel_dispatch_type (); + if (*hsa_kernel_dispatch_type == NULL) { /* Collection of information needed for a dispatch of a kernel from a kernel. Keep in sync with libgomp's plugin-hsa.c. */ - hsa_kernel_dispatch_type = make_node (RECORD_TYPE); + *hsa_kernel_dispatch_type = make_node (RECORD_TYPE); tree id_f1 = build_decl (BUILTINS_LOCATION, FIELD_DECL, get_identifier ("queue"), ptr_type_node); DECL_CHAIN (id_f1) = NULL_TREE; @@ -3835,12 +3851,12 @@ get_hsa_kernel_dispatch_offset (const char *field_name) DECL_CHAIN (id_f12) = id_f11; - finish_builtin_struct (hsa_kernel_dispatch_type, "__hsa_kernel_dispatch", + finish_builtin_struct (*hsa_kernel_dispatch_type, "__hsa_kernel_dispatch", id_f12, NULL_TREE); - TYPE_ARTIFICIAL (hsa_kernel_dispatch_type) = 1; + TYPE_ARTIFICIAL (*hsa_kernel_dispatch_type) = 1; } - for (tree chain = TYPE_FIELDS (hsa_kernel_dispatch_type); + for (tree chain = TYPE_FIELDS (*hsa_kernel_dispatch_type); chain != NULL_TREE; chain = TREE_CHAIN (chain)) if (strcmp (field_name, IDENTIFIER_POINTER (DECL_NAME (chain))) == 0) return int_byte_position (chain); @@ -5498,7 +5514,7 @@ gen_body_from_gimple () gen_hsa_phi_from_gimple_phi (gsi_stmt (gsi), hbb); } - if (dump_file) + if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, "------- Generated SSA form -------\n"); dump_hsa_cfun (dump_file); diff --git a/gcc/hsa-regalloc.c b/gcc/hsa-regalloc.c index 9437132416ed..16cde8bb8acd 100644 --- a/gcc/hsa-regalloc.c +++ b/gcc/hsa-regalloc.c @@ -605,7 +605,7 @@ linear_scan_regalloc (struct m_reg_class_desc *classes) spill_at_interval (reg, active); /* Some interesting dumping as we go. */ - if (dump_file) + if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, " reg%d: [%5d, %5d)->", reg->m_order, reg->m_lr_begin, reg->m_lr_end); @@ -637,7 +637,7 @@ linear_scan_regalloc (struct m_reg_class_desc *classes) BITMAP_FREE (work); free (bbs); - if (dump_file) + if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, "------- After liveness: -------\n"); dump_hsa_cfun_regalloc (dump_file); @@ -702,7 +702,7 @@ hsa_regalloc (void) { naive_outof_ssa (); - if (dump_file) + if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, "------- After out-of-SSA: -------\n"); dump_hsa_cfun (dump_file); @@ -710,7 +710,7 @@ hsa_regalloc (void) regalloc (); - if (dump_file) + if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, "------- After register allocation: -------\n"); dump_hsa_cfun (dump_file); diff --git a/gcc/hsa.c b/gcc/hsa.c index 09bfd28b4378..9eacb59f7596 100644 --- a/gcc/hsa.c +++ b/gcc/hsa.c @@ -712,6 +712,31 @@ hsa_add_kernel_dependency (tree caller, const char *called_function) s->safe_push (called_function); } +/* Expansion to HSA needs a few gc roots to hold types, constructors etc. In + order to minimize the number of GTY roots, we'll root them all in the + following array. The individual elements should only be accessed by the + very simple getters (of a pointer-to-tree) below. */ + +static GTY(()) tree hsa_tree_gt_roots[3]; + +tree * +hsa_get_ctor_statements (void) +{ + return &hsa_tree_gt_roots[0]; +} + +tree * +hsa_get_dtor_statements (void) +{ + return &hsa_tree_gt_roots[1]; +} + +tree * +hsa_get_kernel_dispatch_type (void) +{ + return &hsa_tree_gt_roots[2]; +} + /* Modify the name P in-place so that it is a valid HSA identifier. */ void diff --git a/gcc/hsa.h b/gcc/hsa.h index 3a13fbd147a6..1d6baaba9b51 100644 --- a/gcc/hsa.h +++ b/gcc/hsa.h @@ -110,6 +110,9 @@ struct hsa_symbol /* Symbol allocation. */ BrigAllocation m_allocation; + /* Flag used for global variables if a variable is already emitted or not. */ + bool m_emitted_to_brig; + private: /* Default constructor. */ hsa_symbol (); @@ -1353,6 +1356,9 @@ char *hsa_get_decl_kernel_mapping_name (unsigned i); unsigned hsa_get_decl_kernel_mapping_omp_size (unsigned i); bool hsa_get_decl_kernel_mapping_gridified (unsigned i); void hsa_free_decl_kernel_mapping (void); +tree *hsa_get_ctor_statements (void); +tree *hsa_get_dtor_statements (void); +tree *hsa_get_kernel_dispatch_type (void); void hsa_add_kernel_dependency (tree caller, const char *called_function); void hsa_sanitize_name (char *p); char *hsa_brig_function_name (const char *p); diff --git a/gcc/ipa-chkp.c b/gcc/ipa-chkp.c index 4a6b43e7a8a3..5f5df6483a79 100644 --- a/gcc/ipa-chkp.c +++ b/gcc/ipa-chkp.c @@ -470,7 +470,7 @@ chkp_instrumentable_p (tree fndecl) return (!lookup_attribute ("bnd_legacy", DECL_ATTRIBUTES (fndecl)) && (!flag_chkp_instrument_marked_only || lookup_attribute ("bnd_instrument", DECL_ATTRIBUTES (fndecl))) - && (!fn || !copy_forbidden (fn, fndecl))); + && (!fn || !copy_forbidden (fn))); } /* Return clone created for instrumentation of NODE or NULL. */ @@ -644,22 +644,22 @@ chkp_versioning (void) FOR_EACH_DEFINED_FUNCTION (node) { + tree decl = node->decl; if (!node->instrumentation_clone && !node->instrumented_version && !node->alias && !node->thunk.thunk_p - && (!DECL_BUILT_IN (node->decl) - || (DECL_BUILT_IN_CLASS (node->decl) == BUILT_IN_NORMAL - && DECL_FUNCTION_CODE (node->decl) < BEGIN_CHKP_BUILTINS))) + && (!DECL_BUILT_IN (decl) + || (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL + && DECL_FUNCTION_CODE (decl) < BEGIN_CHKP_BUILTINS))) { - if (chkp_instrumentable_p (node->decl)) - chkp_maybe_create_clone (node->decl); - else if ((reason = copy_forbidden (DECL_STRUCT_FUNCTION (node->decl), - node->decl))) + if (chkp_instrumentable_p (decl)) + chkp_maybe_create_clone (decl); + else if ((reason = copy_forbidden (DECL_STRUCT_FUNCTION (decl)))) { - if (warning_at (DECL_SOURCE_LOCATION (node->decl), OPT_Wchkp, + if (warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wchkp, "function cannot be instrumented")) - inform (DECL_SOURCE_LOCATION (node->decl), reason, node->decl); + inform (DECL_SOURCE_LOCATION (decl), reason, decl); } } } diff --git a/gcc/ipa-devirt.c b/gcc/ipa-devirt.c index deb2a274b7b0..4df171bc1160 100644 --- a/gcc/ipa-devirt.c +++ b/gcc/ipa-devirt.c @@ -393,7 +393,7 @@ odr_vtable_hasher::hash (const odr_type_d *odr_type) When STRICT is true, we compare types by their names for purposes of ODR violation warnings. When strict is false, we consider variants - equivalent, becuase it is all that matters for devirtualization machinery. + equivalent, because it is all that matters for devirtualization machinery. */ bool @@ -3177,11 +3177,11 @@ possible_polymorphic_call_targets (tree otr_type, if (!outer_type->all_derivations_known) { - if (!speculative && final_warning_records) + if (!speculative && final_warning_records + && nodes.length () == 1 + && TREE_CODE (TREE_TYPE (nodes[0]->decl)) == METHOD_TYPE) { if (complete - && nodes.length () == 1 - && TREE_CODE (TREE_TYPE (nodes[0]->decl)) == METHOD_TYPE && warn_suggest_final_types && !outer_type->derived_types.length ()) { @@ -3197,7 +3197,6 @@ possible_polymorphic_call_targets (tree otr_type, } if (complete && warn_suggest_final_methods - && nodes.length () == 1 && types_same_for_odr (DECL_CONTEXT (nodes[0]->decl), outer_type->type)) { diff --git a/gcc/ipa-icf.c b/gcc/ipa-icf.c index ef04c559bf40..aa6589c16e1a 100644 --- a/gcc/ipa-icf.c +++ b/gcc/ipa-icf.c @@ -1697,6 +1697,11 @@ sem_function::parse (cgraph_node *node, bitmap_obstack *stack) if (lookup_attribute_by_prefix ("omp ", DECL_ATTRIBUTES (node->decl)) != NULL) return NULL; + /* PR ipa/70306. */ + if (DECL_STATIC_CONSTRUCTOR (node->decl) + || DECL_STATIC_DESTRUCTOR (node->decl)) + return NULL; + sem_function *f = new sem_function (node, 0, stack); f->init (); @@ -2209,6 +2214,16 @@ sem_variable::merge (sem_item *alias_item) "adress of original and alias may be compared.\n\n"); return false; } + + if (DECL_ALIGN (original->decl) < DECL_ALIGN (alias->decl)) + { + if (dump_file) + fprintf (dump_file, "Not unifying; " + "original and alias have incompatible alignments\n\n"); + + return false; + } + if (DECL_COMDAT_GROUP (original->decl) != DECL_COMDAT_GROUP (alias->decl)) { if (dump_file) diff --git a/gcc/ipa-inline-transform.c b/gcc/ipa-inline-transform.c index 5dc0b5af2875..f966fb00ffb7 100644 --- a/gcc/ipa-inline-transform.c +++ b/gcc/ipa-inline-transform.c @@ -329,8 +329,7 @@ inline_call (struct cgraph_edge *e, bool update_original, { struct gcc_options opts = global_options; - cl_optimization_restore (&opts, - TREE_OPTIMIZATION (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (to->decl))); + cl_optimization_restore (&opts, opts_for_fn (to->decl)); opts.x_flag_strict_aliasing = false; if (dump_file) fprintf (dump_file, "Dropping flag_strict_aliasing on %s:%i\n", diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c index 57a45883d897..55899ef17302 100644 --- a/gcc/ipa-inline.c +++ b/gcc/ipa-inline.c @@ -2688,7 +2688,7 @@ early_inliner (function *fun) /* If some always_inline functions was inlined, apply the changes. This way we will not account always inline into growth limits and moreover we will inline calls from always inlines that we skipped - previously becuase of conditional above. */ + previously because of conditional above. */ if (inlined) { timevar_push (TV_INTEGRATION); diff --git a/gcc/ipa-polymorphic-call.c b/gcc/ipa-polymorphic-call.c index 91c41f99f2c4..842ca13cd06d 100644 --- a/gcc/ipa-polymorphic-call.c +++ b/gcc/ipa-polymorphic-call.c @@ -812,7 +812,7 @@ walk_ssa_copies (tree op, hash_set **global_visited = NULL) ptr = ptr.foo; This pattern is implicitly produced for casts to non-primary bases. When doing context analysis, we do not really care - about the case pointer is NULL, becuase the call will be + about the case pointer is NULL, because the call will be undefined anyway. */ if (gimple_code (SSA_NAME_DEF_STMT (op)) == GIMPLE_PHI) { diff --git a/gcc/ipa-reference.c b/gcc/ipa-reference.c index 6a3f6c35ce43..b52db42ed28f 100644 --- a/gcc/ipa-reference.c +++ b/gcc/ipa-reference.c @@ -104,7 +104,7 @@ static splay_tree reference_vars_to_consider; static we are considering. This is added to the local info when asm code is found that clobbers all memory. */ static bitmap all_module_statics; -/* Set of all statics that should be ignored becuase they are touched by +/* Set of all statics that should be ignored because they are touched by -fno-ipa-reference code. */ static bitmap ignore_module_statics; diff --git a/gcc/ipa.c b/gcc/ipa.c index 3c8fc00e6b54..6722d3b806ed 100644 --- a/gcc/ipa.c +++ b/gcc/ipa.c @@ -41,7 +41,7 @@ along with GCC; see the file COPYING3. If not see static bool has_addr_references_p (struct cgraph_node *node, - void *data ATTRIBUTE_UNUSED) + void *) { int i; struct ipa_ref *ref = NULL; @@ -52,6 +52,14 @@ has_addr_references_p (struct cgraph_node *node, return false; } +/* Return true when NODE can be target of an indirect call. */ + +static bool +is_indirect_call_target_p (struct cgraph_node *node, void *) +{ + return node->indirect_call_target; +} + /* Look for all functions inlined to NODE and update their inlined_to pointers to INLINED_TO. */ @@ -172,23 +180,24 @@ walk_polymorphic_call_targets (hash_set *reachable_call_targets, (TYPE_METHOD_BASETYPE (TREE_TYPE (n->decl)))) continue; - symtab_node *body = n->function_symbol (); + n->indirect_call_target = true; + symtab_node *body = n->function_symbol (); /* Prior inlining, keep alive bodies of possible targets for devirtualization. */ - if (n->definition - && (before_inlining_p - && opt_for_fn (body->decl, optimize) - && opt_for_fn (body->decl, flag_devirtualize))) - { - /* Be sure that we will not optimize out alias target - body. */ - if (DECL_EXTERNAL (n->decl) - && n->alias - && before_inlining_p) - reachable->add (body); - reachable->add (n); - } + if (n->definition + && (before_inlining_p + && opt_for_fn (body->decl, optimize) + && opt_for_fn (body->decl, flag_devirtualize))) + { + /* Be sure that we will not optimize out alias target + body. */ + if (DECL_EXTERNAL (n->decl) + && n->alias + && before_inlining_p) + reachable->add (body); + reachable->add (n); + } /* Even after inlining we want to keep the possible targets in the boundary, so late passes can still produce direct call even if the chance for inlining is lost. */ @@ -323,6 +332,7 @@ symbol_table::remove_unreachable_nodes (FILE *file) FOR_EACH_FUNCTION (node) { node->used_as_abstract_origin = false; + node->indirect_call_target = false; if (node->definition && !node->global.inlined_to && !node->in_other_partition @@ -659,7 +669,14 @@ symbol_table::remove_unreachable_nodes (FILE *file) fprintf (file, " %s", node->name ()); node->address_taken = false; changed = true; - if (node->local_p ()) + if (node->local_p () + /* Virtual functions may be kept in cgraph just because + of possible later devirtualization. Do not mark them as + local too early so we won't optimize them out before + we are done with polymorphic call analysis. */ + && (!before_inlining_p + || !node->call_for_symbol_and_aliases + (is_indirect_call_target_p, NULL, true))) { node->local.local = true; if (file) diff --git a/gcc/ira.c b/gcc/ira.c index 6b4a104cf8bb..c12318a6227b 100644 --- a/gcc/ira.c +++ b/gcc/ira.c @@ -3225,13 +3225,18 @@ memref_referenced_p (rtx memref, rtx x) } /* TRUE if some insn in the range (START, END] references a memory location - that would be affected by a store to MEMREF. */ + that would be affected by a store to MEMREF. + + Callers should not call this routine if START is after END in the + RTL chain. */ + static int memref_used_between_p (rtx memref, rtx_insn *start, rtx_insn *end) { rtx_insn *insn; - for (insn = NEXT_INSN (start); insn != NEXT_INSN (end); + for (insn = NEXT_INSN (start); + insn && insn != NEXT_INSN (end); insn = NEXT_INSN (insn)) { if (!NONDEBUG_INSN_P (insn)) @@ -3245,6 +3250,7 @@ memref_used_between_p (rtx memref, rtx_insn *start, rtx_insn *end) return 1; } + gcc_assert (insn == NEXT_INSN (end)); return 0; } @@ -3319,9 +3325,6 @@ adjust_cleared_regs (rtx loc, const_rtx old_rtx ATTRIBUTE_UNUSED, void *data) return NULL_RTX; } -/* Nonzero if we recorded an equivalence for a LABEL_REF. */ -static int recorded_label_ref; - /* Find registers that are equivalent to a single value throughout the compilation (either because they can be referenced in memory or are set once from a single constant). Lower their priority for a @@ -3331,10 +3334,8 @@ static int recorded_label_ref; value into the using insn. If it succeeds, we can eliminate the register completely. - Initialize init_insns in ira_reg_equiv array. - - Return non-zero if jump label rebuilding should be done. */ -static int + Initialize init_insns in ira_reg_equiv array. */ +static void update_equiv_regs (void) { rtx_insn *insn; @@ -3342,10 +3343,7 @@ update_equiv_regs (void) int loop_depth; bitmap cleared_regs; bool *pdx_subregs; - - /* We need to keep track of whether or not we recorded a LABEL_REF so - that we know if the jump optimizer needs to be rerun. */ - recorded_label_ref = 0; + bitmap_head seen_insns; /* Use pdx_subregs to show whether a reg is used in a paradoxical subreg. */ @@ -3578,17 +3576,6 @@ update_equiv_regs (void) = gen_rtx_INSN_LIST (VOIDmode, insn, ira_reg_equiv[regno].init_insns); - /* Record whether or not we created a REG_EQUIV note for a LABEL_REF. - We might end up substituting the LABEL_REF for uses of the - pseudo here or later. That kind of transformation may turn an - indirect jump into a direct jump, in which case we must rerun the - jump optimizer to ensure that the JUMP_LABEL fields are valid. */ - if (GET_CODE (x) == LABEL_REF - || (GET_CODE (x) == CONST - && GET_CODE (XEXP (x, 0)) == PLUS - && (GET_CODE (XEXP (XEXP (x, 0), 0)) == LABEL_REF))) - recorded_label_ref = 1; - reg_equiv[regno].replacement = x; reg_equiv[regno].src_p = &SET_SRC (set); reg_equiv[regno].loop_depth = (short) loop_depth; @@ -3626,11 +3613,14 @@ update_equiv_regs (void) /* A second pass, to gather additional equivalences with memory. This needs to be done after we know which registers we are going to replace. */ + bitmap_initialize (&seen_insns, NULL); for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) { rtx set, src, dest; unsigned regno; + bitmap_set_bit (&seen_insns, INSN_UID (insn)); + if (! INSN_P (insn)) continue; @@ -3671,6 +3661,7 @@ update_equiv_regs (void) rtx_insn *init_insn = as_a (XEXP (reg_equiv[regno].init_insns, 0)); if (validate_equiv_mem (init_insn, src, dest) + && bitmap_bit_p (&seen_insns, INSN_UID (init_insn)) && ! memref_used_between_p (dest, init_insn, insn) /* Attaching a REG_EQUIV note will fail if INIT_INSN has multiple sets. */ @@ -3681,9 +3672,15 @@ update_equiv_regs (void) ira_reg_equiv[regno].init_insns = gen_rtx_INSN_LIST (VOIDmode, insn, NULL_RTX); df_notes_rescan (init_insn); + if (dump_file) + fprintf (dump_file, + "Adding REG_EQUIV to insn %d for source of insn %d\n", + INSN_UID (init_insn), + INSN_UID (insn)); } } } + bitmap_clear (&seen_insns); cleared_regs = BITMAP_ALLOC (NULL); /* Now scan all regs killed in an insn to see if any of them are @@ -3706,9 +3703,9 @@ update_equiv_regs (void) if (! INSN_P (insn)) continue; - /* Don't substitute into a non-local goto, this confuses CFG. */ - if (JUMP_P (insn) - && find_reg_note (insn, REG_NON_LOCAL_GOTO, NULL_RTX)) + /* Don't substitute into jumps. indirect_jump_optimize does + this for anything we are prepared to handle. */ + if (JUMP_P (insn)) continue; for (link = REG_NOTES (insn); link; link = XEXP (link, 1)) @@ -3860,11 +3857,60 @@ update_equiv_regs (void) end_alias_analysis (); free (reg_equiv); free (pdx_subregs); - return recorded_label_ref; } - +/* A pass over indirect jumps, converting simple cases to direct jumps. + Combine does this optimization too, but only within a basic block. */ +static void +indirect_jump_optimize (void) +{ + basic_block bb; + bool rebuild_p = false; + FOR_EACH_BB_REVERSE_FN (bb, cfun) + { + rtx_insn *insn = BB_END (bb); + if (!JUMP_P (insn)) + continue; + + rtx x = pc_set (insn); + if (!x || !REG_P (SET_SRC (x))) + continue; + + int regno = REGNO (SET_SRC (x)); + if (DF_REG_DEF_COUNT (regno) == 1) + { + df_ref def = DF_REG_DEF_CHAIN (regno); + if (!DF_REF_IS_ARTIFICIAL (def)) + { + rtx_insn *def_insn = DF_REF_INSN (def); + rtx note = find_reg_note (def_insn, REG_LABEL_OPERAND, NULL_RTX); + + if (note) + { + /* Substitute a LABEL_REF to the label given by the + note rather than using SET_SRC of DEF_INSN. + DEF_INSN might be loading the label constant from + a constant pool, which isn't what we want in a + direct branch. */ + rtx lab = gen_rtx_LABEL_REF (Pmode, XEXP (note, 0)); + if (validate_replace_rtx (SET_SRC (x), lab, insn)) + rebuild_p = true; + } + } + } + } + + if (rebuild_p) + { + timevar_push (TV_JUMP); + rebuild_jump_labels (get_insns ()); + if (purge_all_dead_edges ()) + delete_unreachable_blocks (); + timevar_pop (TV_JUMP); + } +} + /* Set up fields memory, constant, and invariant from init_insns in the structures of array ira_reg_equiv. */ static void @@ -5090,7 +5136,6 @@ ira (FILE *f) { bool loops_p; int ira_max_point_before_emit; - int rebuild_p; bool saved_flag_caller_saves = flag_caller_saves; enum ira_region saved_flag_ira_region = flag_ira_region; @@ -5167,6 +5212,10 @@ ira (FILE *f) df_clear_flags (DF_NO_INSN_RESCAN); + indirect_jump_optimize (); + if (delete_trivially_dead_insns (get_insns (), max_reg_num ())) + df_analyze (); + regstat_init_n_sets_and_refs (); regstat_compute_ri (); @@ -5184,32 +5233,12 @@ ira (FILE *f) if (resize_reg_info () && flag_ira_loop_pressure) ira_set_pseudo_classes (true, ira_dump_file); - rebuild_p = update_equiv_regs (); + update_equiv_regs (); setup_reg_equiv (); setup_reg_equiv_init (); - bool update_regstat = false; - - if (optimize && rebuild_p) - { - timevar_push (TV_JUMP); - rebuild_jump_labels (get_insns ()); - if (purge_all_dead_edges ()) - { - delete_unreachable_blocks (); - update_regstat = true; - } - timevar_pop (TV_JUMP); - } - allocated_reg_info_size = max_reg_num (); - if (delete_trivially_dead_insns (get_insns (), max_reg_num ())) - { - df_analyze (); - update_regstat = true; - } - /* It is not worth to do such improvement when we use a simple allocation because of -O0 usage or because the function is too big. */ @@ -5319,7 +5348,7 @@ ira (FILE *f) check_allocation (); #endif - if (update_regstat || max_regno != max_regno_before_ira) + if (max_regno != max_regno_before_ira) { regstat_free_n_sets_and_refs (); regstat_free_ri (); @@ -5404,9 +5433,8 @@ do_reload (void) { df_set_flags (DF_NO_INSN_RESCAN); build_insn_chain (); - - need_dce = reload (get_insns (), ira_conflicts_p); + need_dce = reload (get_insns (), ira_conflicts_p); } timevar_pop (TV_RELOAD); @@ -5484,6 +5512,20 @@ do_reload (void) inform (DECL_SOURCE_LOCATION (decl), "for %qD", decl); } + /* If we are doing generic stack checking, give a warning if this + function's frame size is larger than we expect. */ + if (flag_stack_check == GENERIC_STACK_CHECK) + { + HOST_WIDE_INT size = get_frame_size () + STACK_CHECK_FIXED_FRAME_SIZE; + + for (int i = 0; i < FIRST_PSEUDO_REGISTER; i++) + if (df_regs_ever_live_p (i) && !fixed_regs[i] && call_used_regs[i]) + size += UNITS_PER_WORD; + + if (size > STACK_CHECK_MAX_FRAME_SIZE) + warning (0, "frame size too large for reliable stack checking"); + } + if (pic_offset_table_regno != INVALID_REGNUM) pic_offset_table_rtx = gen_rtx_REG (Pmode, pic_offset_table_regno); diff --git a/gcc/loop-invariant.c b/gcc/loop-invariant.c index 707f044f6dc1..dcbe9326a5b8 100644 --- a/gcc/loop-invariant.c +++ b/gcc/loop-invariant.c @@ -52,6 +52,7 @@ along with GCC; see the file COPYING3. If not see #include "cfgloop.h" #include "expr.h" #include "params.h" +#include "rtl-iter.h" #include "dumpfile.h" /* The data stored for the loop. */ @@ -754,6 +755,130 @@ create_new_invariant (struct def *def, rtx_insn *insn, bitmap depends_on, return inv; } +/* Return a canonical version of X for the address, from the point of view, + that all multiplications are represented as MULT instead of the multiply + by a power of 2 being represented as ASHIFT. + + Callers should prepare a copy of X because this function may modify it + in place. */ + +static void +canonicalize_address_mult (rtx x) +{ + subrtx_var_iterator::array_type array; + FOR_EACH_SUBRTX_VAR (iter, array, x, NONCONST) + { + rtx sub = *iter; + + if (GET_CODE (sub) == ASHIFT + && CONST_INT_P (XEXP (sub, 1)) + && INTVAL (XEXP (sub, 1)) < GET_MODE_BITSIZE (GET_MODE (sub)) + && INTVAL (XEXP (sub, 1)) >= 0) + { + HOST_WIDE_INT shift = INTVAL (XEXP (sub, 1)); + PUT_CODE (sub, MULT); + XEXP (sub, 1) = gen_int_mode ((HOST_WIDE_INT) 1 << shift, + GET_MODE (sub)); + iter.skip_subrtxes (); + } + } +} + +/* Maximum number of sub expressions in address. We set it to + a small integer since it's unlikely to have a complicated + address expression. */ + +#define MAX_CANON_ADDR_PARTS (5) + +/* Collect sub expressions in address X with PLUS as the seperator. + Sub expressions are stored in vector ADDR_PARTS. */ + +static void +collect_address_parts (rtx x, vec *addr_parts) +{ + subrtx_var_iterator::array_type array; + FOR_EACH_SUBRTX_VAR (iter, array, x, NONCONST) + { + rtx sub = *iter; + + if (GET_CODE (sub) != PLUS) + { + addr_parts->safe_push (sub); + iter.skip_subrtxes (); + } + } +} + +/* Compare function for sorting sub expressions X and Y based on + precedence defined for communitive operations. */ + +static int +compare_address_parts (const void *x, const void *y) +{ + const rtx *rx = (const rtx *)x; + const rtx *ry = (const rtx *)y; + int px = commutative_operand_precedence (*rx); + int py = commutative_operand_precedence (*ry); + + return (py - px); +} + +/* Return a canonical version address for X by following steps: + 1) Rewrite ASHIFT into MULT recursively. + 2) Divide address into sub expressions with PLUS as the + separator. + 3) Sort sub expressions according to precedence defined + for communative operations. + 4) Simplify CONST_INT_P sub expressions. + 5) Create new canonicalized address and return. + Callers should prepare a copy of X because this function may + modify it in place. */ + +static rtx +canonicalize_address (rtx x) +{ + rtx res; + unsigned int i, j; + machine_mode mode = GET_MODE (x); + auto_vec addr_parts; + + /* Rewrite ASHIFT into MULT. */ + canonicalize_address_mult (x); + /* Divide address into sub expressions. */ + collect_address_parts (x, &addr_parts); + /* Unlikely to have very complicated address. */ + if (addr_parts.length () < 2 + || addr_parts.length () > MAX_CANON_ADDR_PARTS) + return x; + + /* Sort sub expressions according to canonicalization precedence. */ + addr_parts.qsort (compare_address_parts); + + /* Simplify all constant int summary if possible. */ + for (i = 0; i < addr_parts.length (); i++) + if (CONST_INT_P (addr_parts[i])) + break; + + for (j = i + 1; j < addr_parts.length (); j++) + { + gcc_assert (CONST_INT_P (addr_parts[j])); + addr_parts[i] = simplify_gen_binary (PLUS, mode, + addr_parts[i], + addr_parts[j]); + } + + /* Chain PLUS operators to the left for !CONST_INT_P sub expressions. */ + res = addr_parts[0]; + for (j = 1; j < i; j++) + res = simplify_gen_binary (PLUS, mode, res, addr_parts[j]); + + /* Pickup the last CONST_INT_P sub expression. */ + if (i < addr_parts.length ()) + res = simplify_gen_binary (PLUS, mode, res, addr_parts[i]); + + return res; +} + /* Given invariant DEF and its address USE, check if the corresponding invariant expr can be propagated into the use or not. */ @@ -761,7 +886,7 @@ static bool inv_can_prop_to_addr_use (struct def *def, df_ref use) { struct invariant *inv; - rtx *pos = DF_REF_REAL_LOC (use), def_set; + rtx *pos = DF_REF_REAL_LOC (use), def_set, use_set; rtx_insn *use_insn = DF_REF_INSN (use); rtx_insn *def_insn; bool ok; @@ -778,6 +903,29 @@ inv_can_prop_to_addr_use (struct def *def, df_ref use) validate_unshare_change (use_insn, pos, SET_SRC (def_set), true); ok = verify_changes (0); + /* Try harder with canonicalization in address expression. */ + if (!ok && (use_set = single_set (use_insn)) != NULL_RTX) + { + rtx src, dest, mem = NULL_RTX; + + src = SET_SRC (use_set); + dest = SET_DEST (use_set); + if (MEM_P (src)) + mem = src; + else if (MEM_P (dest)) + mem = dest; + + if (mem != NULL_RTX + && !memory_address_addr_space_p (GET_MODE (mem), + XEXP (mem, 0), + MEM_ADDR_SPACE (mem))) + { + rtx addr = canonicalize_address (copy_rtx (XEXP (mem, 0))); + if (memory_address_addr_space_p (GET_MODE (mem), + addr, MEM_ADDR_SPACE (mem))) + ok = true; + } + } cancel_changes (0); return ok; } diff --git a/gcc/lra-assigns.c b/gcc/lra-assigns.c index 1d9693ad618f..fb3de849ec11 100644 --- a/gcc/lra-assigns.c +++ b/gcc/lra-assigns.c @@ -1620,7 +1620,12 @@ lra_assign (void) timevar_pop (TV_LRA_ASSIGN); if (former_reload_pseudo_spill_p) lra_assignment_iter_after_spill++; - if (lra_assignment_iter_after_spill > LRA_MAX_ASSIGNMENT_ITERATION_NUMBER) + /* This is conditional on flag_checking because valid code can take + more than this maximum number of iteration, but at the same time + the test can uncover errors in machine descriptions. */ + if (flag_checking + && (lra_assignment_iter_after_spill + > LRA_MAX_ASSIGNMENT_ITERATION_NUMBER)) internal_error ("Maximum number of LRA assignment passes is achieved (%d)\n", LRA_MAX_ASSIGNMENT_ITERATION_NUMBER); diff --git a/gcc/lra-constraints.c b/gcc/lra-constraints.c index f33f8c54876c..4883eefc5323 100644 --- a/gcc/lra-constraints.c +++ b/gcc/lra-constraints.c @@ -840,6 +840,36 @@ narrow_reload_pseudo_class (rtx reg, enum reg_class cl) lra_change_class (REGNO (reg), rclass, " Change to", true); } +/* Searches X for any reference to a reg with the same value as REGNO, + returning the rtx of the reference found if any. Otherwise, + returns NULL_RTX. */ +static rtx +regno_val_use_in (unsigned int regno, rtx x) +{ + const char *fmt; + int i, j; + rtx tem; + + if (REG_P (x) && lra_reg_info[REGNO (x)].val == lra_reg_info[regno].val) + return x; + + fmt = GET_RTX_FORMAT (GET_CODE (x)); + for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--) + { + if (fmt[i] == 'e') + { + if ((tem = regno_val_use_in (regno, XEXP (x, i)))) + return tem; + } + else if (fmt[i] == 'E') + for (j = XVECLEN (x, i) - 1; j >= 0; j--) + if ((tem = regno_val_use_in (regno , XVECEXP (x, i, j)))) + return tem; + } + + return NULL_RTX; +} + /* Generate reloads for matching OUT and INS (array of input operand numbers with end marker -1) with reg class GOAL_CLASS. Add input and output reloads correspondingly to the lists *BEFORE and *AFTER. @@ -942,7 +972,8 @@ match_reload (signed char out, signed char *ins, enum reg_class goal_class, = (! early_clobber_p && ins[1] < 0 && REG_P (in_rtx) && (int) REGNO (in_rtx) < lra_new_regno_start && find_regno_note (curr_insn, REG_DEAD, REGNO (in_rtx)) - && (out < 0 || regno_use_in (REGNO (in_rtx), out_rtx) == NULL_RTX) + && (out < 0 + || regno_val_use_in (REGNO (in_rtx), out_rtx) == NULL_RTX) ? lra_create_new_reg (inmode, in_rtx, goal_class, "") : lra_create_new_reg_with_unique_value (outmode, out_rtx, goal_class, "")); @@ -4941,6 +4972,7 @@ split_reg (bool before_p, int original_regno, rtx_insn *insn, rtx_insn *restore, *save; bool after_p; bool call_save_p; + machine_mode mode; if (original_regno < FIRST_PSEUDO_REGISTER) { @@ -4948,24 +4980,37 @@ split_reg (bool before_p, int original_regno, rtx_insn *insn, hard_regno = original_regno; call_save_p = false; nregs = 1; + mode = lra_reg_info[hard_regno].biggest_mode; + machine_mode reg_rtx_mode = GET_MODE (regno_reg_rtx[hard_regno]); + /* A reg can have a biggest_mode of VOIDmode if it was only ever seen + as part of a multi-word register. In that case, or if the biggest + mode was larger than a register, just use the reg_rtx. Otherwise, + limit the size to that of the biggest access in the function. */ + if (mode == VOIDmode + || GET_MODE_SIZE (mode) > GET_MODE_SIZE (reg_rtx_mode)) + { + original_reg = regno_reg_rtx[hard_regno]; + mode = reg_rtx_mode; + } + else + original_reg = gen_rtx_REG (mode, hard_regno); } else { + mode = PSEUDO_REGNO_MODE (original_regno); hard_regno = reg_renumber[original_regno]; - nregs = hard_regno_nregs[hard_regno][PSEUDO_REGNO_MODE (original_regno)]; + nregs = hard_regno_nregs[hard_regno][mode]; rclass = lra_get_allocno_class (original_regno); original_reg = regno_reg_rtx[original_regno]; call_save_p = need_for_call_save_p (original_regno); } - original_reg = regno_reg_rtx[original_regno]; lra_assert (hard_regno >= 0); if (lra_dump_file != NULL) fprintf (lra_dump_file, " ((((((((((((((((((((((((((((((((((((((((((((((((\n"); + if (call_save_p) { - machine_mode mode = GET_MODE (original_reg); - mode = HARD_REGNO_CALLER_SAVE_MODE (hard_regno, hard_regno_nregs[hard_regno][mode], mode); @@ -4973,8 +5018,7 @@ split_reg (bool before_p, int original_regno, rtx_insn *insn, } else { - rclass = choose_split_class (rclass, hard_regno, - GET_MODE (original_reg)); + rclass = choose_split_class (rclass, hard_regno, mode); if (rclass == NO_REGS) { if (lra_dump_file != NULL) @@ -4992,8 +5036,7 @@ split_reg (bool before_p, int original_regno, rtx_insn *insn, } return false; } - new_reg = lra_create_new_reg (GET_MODE (original_reg), original_reg, - rclass, "split"); + new_reg = lra_create_new_reg (mode, original_reg, rclass, "split"); reg_renumber[REGNO (new_reg)] = hard_regno; } save = emit_spill_move (true, new_reg, original_reg); @@ -5819,6 +5862,24 @@ get_regno (rtx reg) return -1; } +/* Delete a move INSN with destination reg DREGNO and a previous + clobber insn with the same regno. The inheritance/split code can + generate moves with preceding clobber and when we delete such moves + we should delete the clobber insn too to keep the correct life + info. */ +static void +delete_move_and_clobber (rtx_insn *insn, int dregno) +{ + rtx_insn *prev_insn = PREV_INSN (insn); + + lra_set_insn_deleted (insn); + lra_assert (dregno >= 0); + if (prev_insn != NULL && NONDEBUG_INSN_P (prev_insn) + && GET_CODE (PATTERN (prev_insn)) == CLOBBER + && dregno == get_regno (XEXP (PATTERN (prev_insn), 0))) + lra_set_insn_deleted (prev_insn); +} + /* Remove inheritance/split pseudos which are in REMOVE_PSEUDOS and return true if we did any change. The undo transformations for inheritance looks like @@ -5891,7 +5952,7 @@ remove_inheritance_pseudos (bitmap remove_pseudos) ? "split" : "inheritance"); dump_insn_slim (lra_dump_file, curr_insn); } - lra_set_insn_deleted (curr_insn); + delete_move_and_clobber (curr_insn, dregno); done_p = true; } else if (bitmap_bit_p (remove_pseudos, sregno) @@ -6091,7 +6152,7 @@ undo_optional_reloads (void) INSN_UID (insn)); dump_insn_slim (lra_dump_file, insn); } - lra_set_insn_deleted (insn); + delete_move_and_clobber (insn, REGNO (dest)); continue; } /* We should not worry about generation memory-memory diff --git a/gcc/lra-lives.c b/gcc/lra-lives.c index 67dda47df2a3..8811198cfd31 100644 --- a/gcc/lra-lives.c +++ b/gcc/lra-lives.c @@ -700,12 +700,13 @@ process_bb_lives (basic_block bb, int &curr_point, bool dead_insn_p) /* Update max ref width and hard reg usage. */ for (reg = curr_id->regs; reg != NULL; reg = reg->next) - if (reg->regno >= FIRST_PSEUDO_REGISTER - && (GET_MODE_SIZE (reg->biggest_mode) - > GET_MODE_SIZE (lra_reg_info[reg->regno].biggest_mode))) - lra_reg_info[reg->regno].biggest_mode = reg->biggest_mode; - else if (reg->regno < FIRST_PSEUDO_REGISTER) - lra_hard_reg_usage[reg->regno] += freq; + { + if (GET_MODE_SIZE (reg->biggest_mode) + > GET_MODE_SIZE (lra_reg_info[reg->regno].biggest_mode)) + lra_reg_info[reg->regno].biggest_mode = reg->biggest_mode; + if (reg->regno < FIRST_PSEUDO_REGISTER) + lra_hard_reg_usage[reg->regno] += freq; + } call_p = CALL_P (curr_insn); src_regno = (set != NULL_RTX && REG_P (SET_SRC (set)) @@ -1208,7 +1209,7 @@ lra_create_live_ranges_1 (bool all_p, bool dead_insn_p) conservative because of recent transformation. Here in this file we recalculate it again as it costs practically nothing. */ - if (regno_reg_rtx[i] != NULL_RTX) + if (i >= FIRST_PSEUDO_REGISTER && regno_reg_rtx[i] != NULL_RTX) lra_reg_info[i].biggest_mode = GET_MODE (regno_reg_rtx[i]); else lra_reg_info[i].biggest_mode = VOIDmode; diff --git a/gcc/lra-remat.c b/gcc/lra-remat.c index 785d53190f27..187ee3e7752d 100644 --- a/gcc/lra-remat.c +++ b/gcc/lra-remat.c @@ -413,6 +413,10 @@ operand_to_remat (rtx_insn *insn) if (reg->regno >= FIRST_PSEUDO_REGISTER && bitmap_bit_p (&subreg_regs, reg->regno)) return -1; + + /* Don't allow hard registers to be rematerialized. */ + if (reg->regno < FIRST_PSEUDO_REGISTER) + return -1; } if (found_reg == NULL) return -1; @@ -718,21 +722,46 @@ calculate_local_reg_remat_bb_data (void) -/* Return true if REGNO is an input operand of INSN. */ +/* Return true if REG overlaps an input operand of INSN. */ static bool -input_regno_present_p (rtx_insn *insn, int regno) +reg_overlap_for_remat_p (lra_insn_reg *reg, rtx_insn *insn) { int iter; lra_insn_recog_data_t id = lra_get_insn_recog_data (insn); struct lra_static_insn_data *static_id = id->insn_static_data; - struct lra_insn_reg *reg; - + unsigned regno = reg->regno; + int nregs; + + if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] >= 0) + regno = reg_renumber[regno]; + if (regno >= FIRST_PSEUDO_REGISTER) + nregs = 1; + else + nregs = hard_regno_nregs[regno][reg->biggest_mode]; + + struct lra_insn_reg *reg2; + for (iter = 0; iter < 2; iter++) - for (reg = (iter == 0 ? id->regs : static_id->hard_regs); - reg != NULL; - reg = reg->next) - if (reg->type == OP_IN && reg->regno == regno) - return true; + for (reg2 = (iter == 0 ? id->regs : static_id->hard_regs); + reg2 != NULL; + reg2 = reg2->next) + { + if (reg2->type != OP_IN) + continue; + unsigned regno2 = reg2->regno; + int nregs2; + + if (regno2 >= FIRST_PSEUDO_REGISTER && reg_renumber[regno2] >= 0) + regno2 = reg_renumber[regno2]; + if (regno >= FIRST_PSEUDO_REGISTER) + nregs2 = 1; + else + nregs2 = hard_regno_nregs[regno2][reg->biggest_mode]; + + if ((regno2 + nregs2 - 1 >= regno && regno2 < regno + nregs) + || (regno + nregs - 1 >= regno2 && regno < regno2 + nregs2)) + return true; + } return false; } @@ -833,7 +862,7 @@ calculate_gen_cands (void) && dst_regno == cand->regno) continue; if (cand->regno == reg->regno - || input_regno_present_p (insn2, reg->regno)) + || reg_overlap_for_remat_p (reg, insn2)) { bitmap_clear_bit (gen_cands, cand->index); bitmap_set_bit (&temp_bitmap, uid); @@ -1219,7 +1248,7 @@ do_remat (void) && dst_regno == cand->regno) continue; if (cand->regno == reg->regno - || input_regno_present_p (cand->insn, reg->regno)) + || reg_overlap_for_remat_p (reg, cand->insn)) bitmap_set_bit (&temp_bitmap, cand->index); } diff --git a/gcc/lra.c b/gcc/lra.c index a6ce36529f8d..a724ef782c25 100644 --- a/gcc/lra.c +++ b/gcc/lra.c @@ -1967,6 +1967,10 @@ restore_scratches (void) for (i = 0; scratches.iterate (i, &loc); i++) { + /* Ignore already deleted insns. */ + if (NOTE_P (loc->insn) + && NOTE_KIND (loc->insn) == NOTE_INSN_DELETED) + continue; if (last != loc->insn) { last = loc->insn; diff --git a/gcc/lto-streamer-in.c b/gcc/lto-streamer-in.c index 48a1c868bac9..dd48777effa2 100644 --- a/gcc/lto-streamer-in.c +++ b/gcc/lto-streamer-in.c @@ -1008,6 +1008,7 @@ input_struct_function_base (struct function *fn, struct data_in *data_in, fn->after_inlining = bp_unpack_value (&bp, 1); fn->stdarg = bp_unpack_value (&bp, 1); fn->has_nonlocal_label = bp_unpack_value (&bp, 1); + fn->has_forced_label_in_static = bp_unpack_value (&bp, 1); fn->calls_alloca = bp_unpack_value (&bp, 1); fn->calls_setjmp = bp_unpack_value (&bp, 1); fn->has_force_vectorize_loops = bp_unpack_value (&bp, 1); diff --git a/gcc/lto-streamer-out.c b/gcc/lto-streamer-out.c index 997a28b01598..6703d4106dee 100644 --- a/gcc/lto-streamer-out.c +++ b/gcc/lto-streamer-out.c @@ -2014,6 +2014,7 @@ output_struct_function_base (struct output_block *ob, struct function *fn) bp_pack_value (&bp, fn->after_inlining, 1); bp_pack_value (&bp, fn->stdarg, 1); bp_pack_value (&bp, fn->has_nonlocal_label, 1); + bp_pack_value (&bp, fn->has_forced_label_in_static, 1); bp_pack_value (&bp, fn->calls_alloca, 1); bp_pack_value (&bp, fn->calls_setjmp, 1); bp_pack_value (&bp, fn->has_force_vectorize_loops, 1); diff --git a/gcc/lto/ChangeLog b/gcc/lto/ChangeLog index 6496fd900a79..dbb69a2e076c 100644 --- a/gcc/lto/ChangeLog +++ b/gcc/lto/ChangeLog @@ -1,3 +1,14 @@ +2016-03-17 H.J. Lu + + PR lto/70258 + * lto-lang.c (lto_post_options): Set flag_pic to flag_pie for + PIE. + +2016-03-08 Jakub Jelinek + + * lto-symtab.h (lto_symtab_prevail_decl): Fix spelling + - becuase -> because. + 2016-02-15 Tom de Vries PR lto/69655 diff --git a/gcc/lto/lto-lang.c b/gcc/lto/lto-lang.c index 691e9e209052..b5efe3aab7e1 100644 --- a/gcc/lto/lto-lang.c +++ b/gcc/lto/lto-lang.c @@ -836,7 +836,7 @@ lto_post_options (const char **pfilename ATTRIBUTE_UNUSED) /* If -fPIC or -fPIE was used at compile time, be sure that flag_pie is 2. */ flag_pie = MAX (flag_pie, flag_pic); - flag_pic = 0; + flag_pic = flag_pie; break; case LTO_LINKER_OUTPUT_EXEC: /* Normal executable */ diff --git a/gcc/lto/lto-symtab.h b/gcc/lto/lto-symtab.h index 2dccde6e9297..821e2e0b4808 100644 --- a/gcc/lto/lto-symtab.h +++ b/gcc/lto/lto-symtab.h @@ -25,7 +25,7 @@ extern tree lto_symtab_prevailing_virtual_decl (tree decl); /* Mark DECL to be previailed by PREVAILING. Use DECL_ABSTRACT_ORIGIN and DECL_CHAIN as special markers; those do not disturb debug_tree and diagnostics. - We are safe to modify them as we wish, becuase the declarations disappear + We are safe to modify them as we wish, because the declarations disappear from the IL after the merging. */ inline void diff --git a/gcc/match.pd b/gcc/match.pd index 590378250c32..c0ed305ed0e8 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -293,7 +293,8 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) /* X % -Y is the same as X % Y. */ (simplify (trunc_mod @0 (convert? (negate @1))) - (if (!TYPE_UNSIGNED (type) + (if (INTEGRAL_TYPE_P (type) + && !TYPE_UNSIGNED (type) && !TYPE_OVERFLOW_TRAPS (type) && tree_nop_conversion_p (type, TREE_TYPE (@1)) /* Avoid this transformation if X might be INT_MIN or @@ -1751,26 +1752,26 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) (cnd (logical_inverted_value truth_valued_p@0) @1 @2) (cnd @0 @2 @1))) -/* A + (B vcmp C ? 1 : 0) -> A - (B vcmp C), since vector comparisons - return all-1 or all-0 results. */ +/* A + (B vcmp C ? 1 : 0) -> A - (B vcmp C ? -1 : 0), since vector comparisons + return all -1 or all 0 results. */ /* ??? We could instead convert all instances of the vec_cond to negate, but that isn't necessarily a win on its own. */ (simplify - (plus:c @3 (view_convert? (vec_cond @0 integer_each_onep@1 integer_zerop@2))) + (plus:c @3 (view_convert? (vec_cond:s @0 integer_each_onep@1 integer_zerop@2))) (if (VECTOR_TYPE_P (type) - && TYPE_VECTOR_SUBPARTS (type) == TYPE_VECTOR_SUBPARTS (TREE_TYPE (@0)) + && TYPE_VECTOR_SUBPARTS (type) == TYPE_VECTOR_SUBPARTS (TREE_TYPE (@1)) && (TYPE_MODE (TREE_TYPE (type)) - == TYPE_MODE (TREE_TYPE (TREE_TYPE (@0))))) - (minus @3 (view_convert @0)))) + == TYPE_MODE (TREE_TYPE (TREE_TYPE (@1))))) + (minus @3 (view_convert (vec_cond @0 (negate @1) @2))))) -/* ... likewise A - (B vcmp C ? 1 : 0) -> A + (B vcmp C). */ +/* ... likewise A - (B vcmp C ? 1 : 0) -> A + (B vcmp C ? -1 : 0). */ (simplify - (minus @3 (view_convert? (vec_cond @0 integer_each_onep@1 integer_zerop@2))) + (minus @3 (view_convert? (vec_cond:s @0 integer_each_onep@1 integer_zerop@2))) (if (VECTOR_TYPE_P (type) - && TYPE_VECTOR_SUBPARTS (type) == TYPE_VECTOR_SUBPARTS (TREE_TYPE (@0)) + && TYPE_VECTOR_SUBPARTS (type) == TYPE_VECTOR_SUBPARTS (TREE_TYPE (@1)) && (TYPE_MODE (TREE_TYPE (type)) - == TYPE_MODE (TREE_TYPE (TREE_TYPE (@0))))) - (plus @3 (view_convert @0)))) + == TYPE_MODE (TREE_TYPE (TREE_TYPE (@1))))) + (plus @3 (view_convert (vec_cond @0 (negate @1) @2))))) /* Simplifications of comparisons. */ @@ -1863,7 +1864,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) (simplify (cmp @0 @0) (if (! FLOAT_TYPE_P (TREE_TYPE (@0)) - || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (@0)))) + || ! HONOR_NANS (@0)) { constant_boolean_node (true, type); } (if (cmp != EQ_EXPR) (eq @0 @0))))) @@ -1872,7 +1873,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) (cmp @0 @0) (if (cmp != NE_EXPR || ! FLOAT_TYPE_P (TREE_TYPE (@0)) - || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (@0)))) + || ! HONOR_NANS (@0)) { constant_boolean_node (false, type); }))) (for cmp (unle unge uneq) (simplify diff --git a/gcc/omp-low.c b/gcc/omp-low.c index 989d03ef7740..3fd6eb304b66 100644 --- a/gcc/omp-low.c +++ b/gcc/omp-low.c @@ -241,8 +241,9 @@ struct oacc_loop tree routine; /* Pseudo-loop enclosing a routine. */ unsigned mask; /* Partitioning mask. */ - unsigned flags; /* Partitioning flags. */ - tree chunk_size; /* Chunk size. */ + unsigned flags; /* Partitioning flags. */ + unsigned ifns; /* Contained loop abstraction functions. */ + tree chunk_size; /* Chunk size. */ gcall *head_end; /* Final marker of head sequence. */ }; @@ -3236,19 +3237,26 @@ check_omp_nesting_restrictions (gimple *stmt, omp_context *ctx) /* No nesting of non-OpenACC STMT (that is, an OpenMP one, or a GOMP builtin) inside an OpenACC CTX. */ if (!(is_gimple_omp (stmt) - && is_gimple_omp_oacc (stmt))) - { - for (omp_context *octx = ctx; octx != NULL; octx = octx->outer) - if (is_gimple_omp (octx->stmt) - && is_gimple_omp_oacc (octx->stmt) - /* Except for atomic codes that we share with OpenMP. */ - && ! (gimple_code (stmt) == GIMPLE_OMP_ATOMIC_LOAD - || gimple_code (stmt) == GIMPLE_OMP_ATOMIC_STORE)) - { - error_at (gimple_location (stmt), - "non-OpenACC construct inside of OpenACC region"); - return false; - } + && is_gimple_omp_oacc (stmt)) + /* Except for atomic codes that we share with OpenMP. */ + && !(gimple_code (stmt) == GIMPLE_OMP_ATOMIC_LOAD + || gimple_code (stmt) == GIMPLE_OMP_ATOMIC_STORE)) + { + if (get_oacc_fn_attrib (cfun->decl) != NULL) + { + error_at (gimple_location (stmt), + "non-OpenACC construct inside of OpenACC routine"); + return false; + } + else + for (omp_context *octx = ctx; octx != NULL; octx = octx->outer) + if (is_gimple_omp (octx->stmt) + && is_gimple_omp_oacc (octx->stmt)) + { + error_at (gimple_location (stmt), + "non-OpenACC construct inside of OpenACC region"); + return false; + } } if (ctx != NULL) @@ -3715,6 +3723,14 @@ check_omp_nesting_restrictions (gimple *stmt, omp_context *ctx) kind == OMP_CLAUSE_DEPEND_SOURCE ? "source" : "sink"); return false; } + if (is_gimple_omp_offloaded (stmt) + && get_oacc_fn_attrib (cfun->decl) != NULL) + { + error_at (gimple_location (stmt), + "OpenACC region inside of OpenACC routine, nested " + "parallelism not supported yet"); + return false; + } for (; ctx != NULL; ctx = ctx->outer) { if (gimple_code (ctx->stmt) != GIMPLE_OMP_TARGET) @@ -15730,7 +15746,7 @@ lower_omp_target (gimple_stmt_iterator *gsi_p, omp_context *ctx) case GOMP_MAP_TOFROM: case GOMP_MAP_POINTER: case GOMP_MAP_TO_PSET: - case GOMP_MAP_FORCE_DEALLOC: + case GOMP_MAP_DELETE: case GOMP_MAP_RELEASE: case GOMP_MAP_ALWAYS_TO: case GOMP_MAP_ALWAYS_FROM: @@ -16472,13 +16488,7 @@ lower_omp_target (gimple_stmt_iterator *gsi_p, omp_context *ctx) x = build_fold_addr_expr_loc (clause_loc, x); } else - { - tree atmp - = builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN); - tree rtype = TREE_TYPE (TREE_TYPE (new_var)); - tree al = size_int (TYPE_ALIGN (rtype)); - x = build_call_expr_loc (clause_loc, atmp, 2, x, al); - } + break; x = fold_convert_loc (clause_loc, TREE_TYPE (new_var), x); gimplify_expr (&x, &new_body, NULL, is_gimple_val, fb_rvalue); @@ -16545,7 +16555,8 @@ lower_omp_target (gimple_stmt_iterator *gsi_p, omp_context *ctx) } /* Handle GOMP_MAP_FIRSTPRIVATE_{POINTER,REFERENCE} in second pass, so that firstprivate vars holding OMP_CLAUSE_SIZE if needed - are already handled. */ + are already handled. Similarly OMP_CLAUSE_PRIVATE for VLAs + or references to VLAs. */ for (c = clauses; c; c = OMP_CLAUSE_CHAIN (c)) switch (OMP_CLAUSE_CODE (c)) { @@ -16687,6 +16698,27 @@ lower_omp_target (gimple_stmt_iterator *gsi_p, omp_context *ctx) gimple_seq_add_stmt (&new_body, gimple_build_assign (new_pvar, x)); } + else if (is_reference (var) && !is_gimple_omp_oacc (ctx->stmt)) + { + location_t clause_loc = OMP_CLAUSE_LOCATION (c); + tree new_var = lookup_decl (var, ctx); + tree x = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (new_var))); + if (TREE_CONSTANT (x)) + break; + else + { + tree atmp + = builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN); + tree rtype = TREE_TYPE (TREE_TYPE (new_var)); + tree al = size_int (TYPE_ALIGN (rtype)); + x = build_call_expr_loc (clause_loc, atmp, 2, x, al); + } + + x = fold_convert_loc (clause_loc, TREE_TYPE (new_var), x); + gimplify_expr (&x, &new_body, NULL, is_gimple_val, fb_rvalue); + gimple_seq_add_stmt (&new_body, + gimple_build_assign (new_var, x)); + } break; } @@ -20411,6 +20443,7 @@ new_oacc_loop_raw (oacc_loop *parent, location_t loc) loop->routine = NULL_TREE; loop->mask = loop->flags = 0; + loop->ifns = 0; loop->chunk_size = 0; loop->head_end = NULL; @@ -20472,6 +20505,9 @@ new_oacc_loop_routine (oacc_loop *parent, gcall *call, tree decl, tree attrs) static oacc_loop * finish_oacc_loop (oacc_loop *loop) { + /* If the loop has been collapsed, don't partition it. */ + if (!loop->ifns) + loop->mask = loop->flags = 0; return loop->parent; } @@ -20602,43 +20638,54 @@ oacc_loop_discover_walk (oacc_loop *loop, basic_block bb) if (!gimple_call_internal_p (call)) continue; - if (gimple_call_internal_fn (call) != IFN_UNIQUE) - continue; - - enum ifn_unique_kind kind - = (enum ifn_unique_kind) TREE_INT_CST_LOW (gimple_call_arg (call, 0)); - if (kind == IFN_UNIQUE_OACC_HEAD_MARK - || kind == IFN_UNIQUE_OACC_TAIL_MARK) + switch (gimple_call_internal_fn (call)) { - if (gimple_call_num_args (call) == 2) - { - gcc_assert (marker && !remaining); - marker = 0; - if (kind == IFN_UNIQUE_OACC_TAIL_MARK) - loop = finish_oacc_loop (loop); - else - loop->head_end = call; - } - else - { - int count = TREE_INT_CST_LOW (gimple_call_arg (call, 2)); + default: + break; - if (!marker) + case IFN_GOACC_LOOP: + /* Count the goacc loop abstraction fns, to determine if the + loop was collapsed already. */ + loop->ifns++; + break; + + case IFN_UNIQUE: + enum ifn_unique_kind kind + = (enum ifn_unique_kind) (TREE_INT_CST_LOW + (gimple_call_arg (call, 0))); + if (kind == IFN_UNIQUE_OACC_HEAD_MARK + || kind == IFN_UNIQUE_OACC_TAIL_MARK) + { + if (gimple_call_num_args (call) == 2) { - if (kind == IFN_UNIQUE_OACC_HEAD_MARK) - loop = new_oacc_loop (loop, call); - remaining = count; + gcc_assert (marker && !remaining); + marker = 0; + if (kind == IFN_UNIQUE_OACC_TAIL_MARK) + loop = finish_oacc_loop (loop); + else + loop->head_end = call; } - gcc_assert (count == remaining); - if (remaining) + else { - remaining--; - if (kind == IFN_UNIQUE_OACC_HEAD_MARK) - loop->heads[marker] = call; - else - loop->tails[remaining] = call; + int count = TREE_INT_CST_LOW (gimple_call_arg (call, 2)); + + if (!marker) + { + if (kind == IFN_UNIQUE_OACC_HEAD_MARK) + loop = new_oacc_loop (loop, call); + remaining = count; + } + gcc_assert (count == remaining); + if (remaining) + { + remaining--; + if (kind == IFN_UNIQUE_OACC_HEAD_MARK) + loop->heads[marker] = call; + else + loop->tails[remaining] = call; + } + marker++; } - marker++; } } } @@ -20741,13 +20788,19 @@ oacc_loop_xform_head_tail (gcall *from, int level) } /* Transform the IFN_GOACC_LOOP internal functions by providing the - determined partitioning mask and chunking argument. */ + determined partitioning mask and chunking argument. END_MARKER + points at the end IFN_HEAD_TAIL call intgroducing the loop. IFNS + is the number of IFN_GOACC_LOOP calls for the loop. MASK_ARG is + the replacement partitioning mask and CHUNK_ARG is the replacement + chunking arg. */ static void -oacc_loop_xform_loop (gcall *end_marker, tree mask_arg, tree chunk_arg) +oacc_loop_xform_loop (gcall *end_marker, unsigned ifns, + tree mask_arg, tree chunk_arg) { gimple_stmt_iterator gsi = gsi_for_stmt (end_marker); + gcc_checking_assert (ifns); for (;;) { for (; !gsi_end_p (gsi); gsi_next (&gsi)) @@ -20767,13 +20820,13 @@ oacc_loop_xform_loop (gcall *end_marker, tree mask_arg, tree chunk_arg) *gimple_call_arg_ptr (call, 5) = mask_arg; *gimple_call_arg_ptr (call, 4) = chunk_arg; - if (TREE_INT_CST_LOW (gimple_call_arg (call, 0)) - == IFN_GOACC_LOOP_BOUND) + ifns--; + if (!ifns) return; } - /* If we didn't see LOOP_BOUND, it should be in the single - successor block. */ + /* The LOOP_BOUND ifn could be in the single successor + block. */ basic_block bb = single_succ (gsi_bb (gsi)); gsi = gsi_start_bb (bb); } @@ -20796,7 +20849,7 @@ oacc_loop_process (oacc_loop *loop) tree mask_arg = build_int_cst (unsigned_type_node, mask); tree chunk_arg = loop->chunk_size; - oacc_loop_xform_loop (loop->head_end, mask_arg, chunk_arg); + oacc_loop_xform_loop (loop->head_end, loop->ifns, mask_arg, chunk_arg); for (ix = 0; ix != GOMP_DIM_MAX && loop->heads[ix]; ix++) { diff --git a/gcc/opts.c b/gcc/opts.c index 2f453122b098..0f9431a0b323 100644 --- a/gcc/opts.c +++ b/gcc/opts.c @@ -766,13 +766,18 @@ finish_options (struct gcc_options *opts, struct gcc_options *opts_set, default value. */ if (opts->x_flag_pie == -1) { - if (opts->x_flag_pic == 0) + /* We initialize opts->x_flag_pic to -1 so that we can tell if + -fpic, -fPIC, -fno-pic or -fno-PIC is used. */ + if (opts->x_flag_pic == -1) opts->x_flag_pie = DEFAULT_FLAG_PIE; else opts->x_flag_pie = 0; } + /* If -fPIE or -fpie is used, turn on PIC. */ if (opts->x_flag_pie) opts->x_flag_pic = opts->x_flag_pie; + else if (opts->x_flag_pic == -1) + opts->x_flag_pic = 0; if (opts->x_flag_pic && !opts->x_flag_pie) opts->x_flag_shlib = 1; opts->x_flag_opts_finished = true; diff --git a/gcc/params.def b/gcc/params.def index 2ee631d9fc59..9362c1588de8 100644 --- a/gcc/params.def +++ b/gcc/params.def @@ -502,7 +502,7 @@ DEFPARAM(PARAM_LIM_EXPENSIVE, DEFPARAM(PARAM_IV_CONSIDER_ALL_CANDIDATES_BOUND, "iv-consider-all-candidates-bound", "Bound on number of candidates below that all candidates are considered in iv optimizations.", - 30, 0, 0) + 40, 0, 0) /* The induction variable optimizations give up on loops that contain more induction variable uses. */ diff --git a/gcc/passes.c b/gcc/passes.c index 1bf89edc9217..9d9025116f46 100644 --- a/gcc/passes.c +++ b/gcc/passes.c @@ -2214,7 +2214,7 @@ execute_one_ipa_transform_pass (struct cgraph_node *node, check_profile_consistency (pass->static_pass_number, 1, true); if (dump_file) - do_per_function (execute_function_dump, NULL); + do_per_function (execute_function_dump, pass); pass_fini_dump_file (pass); current_pass = NULL; @@ -2351,15 +2351,15 @@ execute_one_pass (opt_pass *pass) check_profile_consistency (pass->static_pass_number, 1, true); verify_interpass_invariants (); - if (dump_file) - do_per_function (execute_function_dump, pass); - if (pass->type == IPA_PASS) + if (pass->type == IPA_PASS + && ((ipa_opt_pass_d *)pass)->function_transform) { struct cgraph_node *node; - if (((ipa_opt_pass_d *)pass)->function_transform) - FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node) - node->ipa_transforms_to_apply.safe_push ((ipa_opt_pass_d *)pass); + FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node) + node->ipa_transforms_to_apply.safe_push ((ipa_opt_pass_d *)pass); } + else if (dump_file) + do_per_function (execute_function_dump, pass); if (!current_function_decl) symtab->process_new_functions (); diff --git a/gcc/po/ChangeLog b/gcc/po/ChangeLog index a22e375b7e76..4a5069f0193a 100644 --- a/gcc/po/ChangeLog +++ b/gcc/po/ChangeLog @@ -1,3 +1,19 @@ +2016-03-17 Joseph Myers + + * fr.po: Update. + +2016-03-12 Joseph Myers + + * sv.po: Update. + +2016-03-08 Joseph Myers + + * sv.po: Update. + +2016-02-29 Joseph Myers + + * sv.po: Update. + 2016-02-22 Joseph Myers * sv.po, vi.po: Update. diff --git a/gcc/po/fr.po b/gcc/po/fr.po index 80ebf4cde1a8..1baca52fd01d 100644 --- a/gcc/po/fr.po +++ b/gcc/po/fr.po @@ -5,7 +5,7 @@ # # Michel Robitaille , traducteur depuis/since 1996. # François-Xavier Coudert , 2008. -# Stéphane Aulery , 2015. +# Stéphane Aulery , 2015, 2016. # # Vocabulaire utilisé # lvalue = membre gauche @@ -122,10 +122,10 @@ # msgid "" msgstr "" -"Project-Id-Version: gcc 5.2.0\n" +"Project-Id-Version: gcc 6.1-b20160131\n" "Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n" "POT-Creation-Date: 2016-01-31 15:50+0000\n" -"PO-Revision-Date: 2015-12-30 14:31+0100\n" +"PO-Revision-Date: 2016-03-17 00:28+0100\n" "Last-Translator: Stéphane Aulery \n" "Language-Team: French \n" "Language: fr\n" @@ -391,185 +391,125 @@ msgid "Options:\n" msgstr "Options :\n" #: gcc.c:3384 -#, fuzzy -#| msgid " -pass-exit-codes Exit with highest error code from a phase\n" msgid " -pass-exit-codes Exit with highest error code from a phase.\n" -msgstr " -pass-exit-codes Quitter avec le plus grand code d’erreur d’une phase\n" +msgstr " -pass-exit-codes Quitter avec le plus grand code d’erreur d’une phase.\n" #: gcc.c:3385 -#, fuzzy -#| msgid " --help Display this information\n" msgid " --help Display this information.\n" -msgstr " --help Afficher cette aide\n" +msgstr " --help Afficher cette aide.\n" #: gcc.c:3386 -#, fuzzy -#| msgid " --target-help Display target specific command line options\n" msgid " --target-help Display target specific command line options.\n" -msgstr " --target-help Afficher les options de ligne de commande spécifiques à la cible\n" +msgstr " --target-help Afficher les options de ligne de commande spécifiques à la cible.\n" #: gcc.c:3387 -#, fuzzy -#| msgid " --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...]\n" msgid " --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].\n" -msgstr " --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,…]\n" +msgstr " --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,…].\n" #: gcc.c:3388 -#, fuzzy -#| msgid " Display specific types of command line options\n" msgid " Display specific types of command line options.\n" -msgstr " Afficher les types spécifiques des options de la ligne de commande\n" +msgstr " Afficher les types spécifiques des options de la ligne de commande.\n" #: gcc.c:3390 -#, fuzzy -#| msgid " (Use '-v --help' to display command line options of sub-processes)\n" msgid " (Use '-v --help' to display command line options of sub-processes).\n" -msgstr " (Utiliser « -v --help » pour afficher les options de la ligne de commande des sous-processus)\n" +msgstr " (Utiliser « -v --help » pour afficher les options de la ligne de commande des sous-processus).\n" #: gcc.c:3391 -#, fuzzy -#| msgid " --version Display compiler version information\n" msgid " --version Display compiler version information.\n" -msgstr " --help Afficher des informations sur la version du compilateur\n" +msgstr " --help Afficher des informations sur la version du compilateur.\n" #: gcc.c:3392 -#, fuzzy -#| msgid " -dumpspecs Display all of the built in spec strings\n" msgid " -dumpspecs Display all of the built in spec strings.\n" -msgstr " -dumpspecs Afficher tous les chaînes de specs internes\n" +msgstr " -dumpspecs Afficher tous les chaînes de specs internes.\n" #: gcc.c:3393 -#, fuzzy -#| msgid " -dumpversion Display the version of the compiler\n" msgid " -dumpversion Display the version of the compiler.\n" -msgstr " -dumpversion Afficher la version du compilateur\n" +msgstr " -dumpversion Afficher la version du compilateur.\n" #: gcc.c:3394 -#, fuzzy -#| msgid " -dumpmachine Display the compiler's target processor\n" msgid " -dumpmachine Display the compiler's target processor.\n" -msgstr " -dumpmachine Afficher le processeur ciblé par le compilateur\n" +msgstr " -dumpmachine Afficher le processeur ciblé par le compilateur.\n" #: gcc.c:3395 -#, fuzzy -#| msgid " -print-search-dirs Display the directories in the compiler's search path\n" msgid " -print-search-dirs Display the directories in the compiler's search path.\n" -msgstr " -print-search-dirs Afficher les répertoires du chemin de recherche du compilateur\n" +msgstr " -print-search-dirs Afficher les répertoires du chemin de recherche du compilateur.\n" #: gcc.c:3396 -#, fuzzy -#| msgid " -print-libgcc-file-name Display the name of the compiler's companion library\n" msgid " -print-libgcc-file-name Display the name of the compiler's companion library.\n" -msgstr " -print-libgcc-file-name Afficher le nom de la bibliothèque accompagnant le compilateur\n" +msgstr " -print-libgcc-file-name Afficher le nom de la bibliothèque accompagnant le compilateur.\n" #: gcc.c:3397 -#, fuzzy -#| msgid " -print-file-name= Display the full path to library \n" msgid " -print-file-name= Display the full path to library .\n" -msgstr " -print-file-name= Afficher le chemin d’accès complet vers la bibliothèque \n" +msgstr " -print-file-name= Afficher le chemin d’accès complet vers la bibliothèque .\n" #: gcc.c:3398 -#, fuzzy -#| msgid " -print-prog-name= Display the full path to compiler component \n" msgid " -print-prog-name= Display the full path to compiler component .\n" -msgstr " -print-prog-name= Afficher le chemin d’accès complet vers le composant du compilateur \n" +msgstr " -print-prog-name= Afficher le chemin d’accès complet vers le composant du compilateur .\n" #: gcc.c:3399 -#, fuzzy -#| msgid "" -#| " -print-multiarch Display the target's normalized GNU triplet, used as\n" -#| " a component in the library path\n" msgid "" " -print-multiarch Display the target's normalized GNU triplet, used as\n" " a component in the library path.\n" msgstr "" " -print-multiarch Afficher le triplet GNU normalisé de la cible, utilisé comme\n" -" un composant dans le chemin d’accès de la bibliothèque\n" +" un composant dans le chemin d’accès de la bibliothèque.\n" #: gcc.c:3402 -#, fuzzy -#| msgid " -print-multi-directory Display the root directory for versions of libgcc\n" msgid " -print-multi-directory Display the root directory for versions of libgcc.\n" -msgstr " -print-multi-directory Afficher la racine du répertoire des versions de libgcc\n" +msgstr " -print-multi-directory Afficher la racine du répertoire des versions de libgcc.\n" #: gcc.c:3403 -#, fuzzy -#| msgid "" -#| " -print-multi-lib Display the mapping between command line options and\n" -#| " multiple library search directories\n" msgid "" " -print-multi-lib Display the mapping between command line options and\n" " multiple library search directories.\n" msgstr "" " -print-multi-lib Afficher la table de correspondance entre les options de\n" " la ligne de commande et les multiples répertoires de\n" -" recherche des bibliothèques\n" +" recherche des bibliothèques.\n" #: gcc.c:3406 -#, fuzzy -#| msgid " -print-multi-os-directory Display the relative path to OS libraries\n" msgid " -print-multi-os-directory Display the relative path to OS libraries.\n" -msgstr " -print-multi-os-directory Afficher le chemin relatif du répertoire vers les bibliothèques de l’OS\n" +msgstr " -print-multi-os-directory Afficher le chemin relatif du répertoire vers les bibliothèques de l’OS.\n" #: gcc.c:3407 -#, fuzzy -#| msgid " -print-sysroot Display the target libraries directory\n" msgid " -print-sysroot Display the target libraries directory.\n" -msgstr " -print-sysroot Afficher le répertoire des bibliothèques de la cible\n" +msgstr " -print-sysroot Afficher le répertoire des bibliothèques de la cible.\n" #: gcc.c:3408 -#, fuzzy -#| msgid " -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n" msgid " -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.\n" -msgstr " -print-sysroot-headers-suffix Afficher le suffixe de la racine système utilisé pour trouver les en-têtes\n" +msgstr " -print-sysroot-headers-suffix Afficher le suffixe de la racine système utilisé pour trouver les en-têtes.\n" #: gcc.c:3409 -#, fuzzy -#| msgid " -Wa, Pass comma-separated on to the assembler\n" msgid " -Wa, Pass comma-separated on to the assembler.\n" -msgstr " -Wa, Passer les séparées par des virgules à l’assembleur\n" +msgstr " -Wa, Passer les séparées par des virgules à l’assembleur.\n" #: gcc.c:3410 -#, fuzzy -#| msgid " -Wp, Pass comma-separated on to the preprocessor\n" msgid " -Wp, Pass comma-separated on to the preprocessor.\n" -msgstr " -Wp, Passer les séparées par des virgules au préprocesseur\n" +msgstr " -Wp, Passer les séparées par des virgules au préprocesseur.\n" #: gcc.c:3411 -#, fuzzy -#| msgid " -Wl, Pass comma-separated on to the linker\n" msgid " -Wl, Pass comma-separated on to the linker.\n" -msgstr " -Wl, Passer les séparées par des virgules à l'éditeur de liens\n" +msgstr " -Wl, Passer les séparées par des virgules à l'éditeur de liens.\n" #: gcc.c:3412 -#, fuzzy -#| msgid " -Xassembler Pass on to the assembler\n" msgid " -Xassembler Pass on to the assembler.\n" -msgstr " -Xassembler Passer l’ à l’assembleur\n" +msgstr " -Xassembler Passer l’ à l’assembleur.\n" #: gcc.c:3413 -#, fuzzy -#| msgid " -Xpreprocessor Pass on to the preprocessor\n" msgid " -Xpreprocessor Pass on to the preprocessor.\n" -msgstr " -Xpreprocessor Passer l’ au préprocesseur\n" +msgstr " -Xpreprocessor Passer l’ au préprocesseur.\n" #: gcc.c:3414 -#, fuzzy -#| msgid " -Xlinker Pass on to the linker\n" msgid " -Xlinker Pass on to the linker.\n" -msgstr " -Xlinker Passer l’ à l’éditeur de liens\n" +msgstr " -Xlinker Passer l’ à l’éditeur de liens.\n" #: gcc.c:3415 -#, fuzzy -#| msgid " -save-temps Do not delete intermediate files\n" msgid " -save-temps Do not delete intermediate files.\n" -msgstr " -save-temps ne pas détruire les fichiers intermédiaires\n" +msgstr " -save-temps Ne pas détruire les fichiers intermédiaires.\n" #: gcc.c:3416 -#, fuzzy -#| msgid " -save-temps= Do not delete intermediate files\n" msgid " -save-temps= Do not delete intermediate files.\n" -msgstr " -save-temps= ne pas détruire les fichiers intermédiaires\n" +msgstr " -save-temps= Ne pas détruire les fichiers intermédiaires.\n" #: gcc.c:3417 msgid "" @@ -578,28 +518,20 @@ msgid "" msgstr "" #: gcc.c:3420 -#, fuzzy -#| msgid " -pipe Use pipes rather than intermediate files\n" msgid " -pipe Use pipes rather than intermediate files.\n" -msgstr " -pipe utiliser des pipes au lieu de fichiers intermédiaires\n" +msgstr " -pipe Utiliser des pipes au lieu de fichiers intermédiaires.\n" #: gcc.c:3421 -#, fuzzy -#| msgid " -time Time the execution of each subprocess\n" msgid " -time Time the execution of each subprocess.\n" -msgstr " -time mesurer le temps d'exécution de chaque sous-processus\n" +msgstr " -time Mesurer le temps d'exécution de chaque sous-processus.\n" #: gcc.c:3422 -#, fuzzy -#| msgid " -specs= Override built-in specs with the contents of \n" msgid " -specs= Override built-in specs with the contents of .\n" -msgstr " -specs= écraser les specs internes à l'aide du contenu du \n" +msgstr " -specs= Écraser les specs internes à l'aide du contenu du .\n" #: gcc.c:3423 -#, fuzzy -#| msgid " -std= Assume that the input sources are for \n" msgid " -std= Assume that the input sources are for .\n" -msgstr " -std= Présumer que les fichiers sources respectent le \n" +msgstr " -std= Présumer que les fichiers sources respectent le .\n" #: gcc.c:3424 msgid "" @@ -608,76 +540,52 @@ msgid "" msgstr "" #: gcc.c:3427 -#, fuzzy -#| msgid " -B Add to the compiler's search paths\n" msgid " -B Add to the compiler's search paths.\n" -msgstr " -B ajouter le aux chemins de recherche du compilateur\n" +msgstr " -B Ajouter le aux chemins de recherche du compilateur.\n" #: gcc.c:3428 -#, fuzzy -#| msgid " -v Display the programs invoked by the compiler\n" msgid " -v Display the programs invoked by the compiler.\n" -msgstr " -v afficher les programmes invoqués par le compilateur\n" +msgstr " -v Afficher les programmes invoqués par le compilateur.\n" #: gcc.c:3429 -#, fuzzy -#| msgid " -### Like -v but options quoted and commands not executed\n" msgid " -### Like -v but options quoted and commands not executed.\n" -msgstr " -### identique à -v mais les options et les commandes entre guillemets ne sont pas exécutées\n" +msgstr " -### Identique à -v mais les options et les commandes entre guillemets ne sont pas exécutées.\n" #: gcc.c:3430 -#, fuzzy -#| msgid " -E Preprocess only; do not compile, assemble or link\n" msgid " -E Preprocess only; do not compile, assemble or link.\n" -msgstr " -E pré-traiter seulement ; ne pas compiler, assembler ou éditer les liens\n" +msgstr " -E Pré-traiter seulement ; ne pas compiler, assembler ou éditer les liens.\n" #: gcc.c:3431 -#, fuzzy -#| msgid " -S Compile only; do not assemble or link\n" msgid " -S Compile only; do not assemble or link.\n" -msgstr " -S compiler seulement ; ne pas assembler ou éditer les liens\n" +msgstr " -S Compiler seulement ; ne pas assembler ou éditer les liens.\n" #: gcc.c:3432 -#, fuzzy -#| msgid " -c Compile and assemble, but do not link\n" msgid " -c Compile and assemble, but do not link.\n" -msgstr " -S compiler et assembler, mais ne pas éditer les liens\n" +msgstr " -S Compiler et assembler, mais ne pas éditer les liens.\n" #: gcc.c:3433 -#, fuzzy -#| msgid " -o Place the output into \n" msgid " -o Place the output into .\n" -msgstr " -o placer la sortie dans le \n" +msgstr " -o Placer la sortie dans le .\n" #: gcc.c:3434 -#, fuzzy -#| msgid " -pie Create a position independent executable\n" msgid " -pie Create a position independent executable.\n" -msgstr " -pipe créer un exécutable à chargement aléatoire en mémoire (PIE)\n" +msgstr " -pipe Créer un exécutable à chargement aléatoire en mémoire (PIE).\n" #: gcc.c:3435 -#, fuzzy -#| msgid " -shared Create a shared library\n" msgid " -shared Create a shared library.\n" -msgstr " -shared créer une bibliothèque partagée\n" +msgstr " -shared Créer une bibliothèque partagée.\n" #: gcc.c:3436 -#, fuzzy -#| msgid "" -#| " -x Specify the language of the following input files\n" -#| " Permissible languages include: c c++ assembler none\n" -#| " 'none' means revert to the default behavior of\n" -#| " guessing the language based on the file's extension\n" msgid "" " -x Specify the language of the following input files.\n" " Permissible languages include: c c++ assembler none\n" " 'none' means revert to the default behavior of\n" " guessing the language based on the file's extension.\n" msgstr "" -" -x spécifier le langage des fichiers suivants d'entrée\n" +" -x Spécifier le langage des fichiers suivants d'entrée.\n" " Les langages permis sont: c c++ assembler none\n" " « none » signifiant d'utiliser le comportement par défaut\n" -" en tentant d'identifier le langage par l'extension du fichier\n" +" en tentant d'identifier le langage par l'extension du fichier.\n" #: gcc.c:3443 #, c-format @@ -944,10 +852,9 @@ msgstr "" "%s.\n" #: gcov-tool.c:526 -#, fuzzy, c-format -#| msgid "Copyright %s 2014-2015 Free Software Foundation, Inc.\n" +#, c-format msgid "Copyright %s 2014-2016 Free Software Foundation, Inc.\n" -msgstr "Copyright %s 2014-2015 Free Software Foundation, Inc.\n" +msgstr "Copyright %s 2014-2016 Free Software Foundation, Inc.\n" #: gcov-tool.c:529 gcov.c:506 #, c-format @@ -1405,10 +1312,8 @@ msgstr "incapable de générer des recharges pour:" #. What to print when a switch has no documentation. #: opts.c:184 -#, fuzzy -#| msgid "This switch lacks documentation" msgid "This option lacks documentation." -msgstr "Cette option manque de documentation" +msgstr "Cette option manque de documentation." #: opts.c:185 msgid "Uses of this option are diagnosed." @@ -1457,70 +1362,48 @@ msgid " All options with the desired characteristics have already been displayed msgstr "" #: opts.c:1332 -#, fuzzy -#| msgid "The following options are language-independent:\n" msgid "The following options are target specific" -msgstr "Les options suivantes sont indépendantes du langage:\n" +msgstr "Les options suivantes sont spécifiques à la cible" #: opts.c:1335 -#, fuzzy -#| msgid "The following options are language-independent:\n" msgid "The following options control compiler warning messages" -msgstr "Les options suivantes sont indépendantes du langage:\n" +msgstr "Les options suivantes contrôlent les messages d’avertissement du compilateur" #: opts.c:1338 -#, fuzzy -#| msgid "Perform loop optimizations" msgid "The following options control optimizations" -msgstr "Exécuter l'optimisation des boucles" +msgstr "Les options suivantes contrôlent les optimisations" #: opts.c:1341 opts.c:1380 -#, fuzzy -#| msgid "The following options are language-independent:\n" msgid "The following options are language-independent" -msgstr "Les options suivantes sont indépendantes du langage:\n" +msgstr "Les options suivantes sont indépendantes du langage" #: opts.c:1344 -#, fuzzy -#| msgid "The --param option recognizes the following as parameters:\n" msgid "The --param option recognizes the following as parameters" -msgstr "L'option --param reconnaît les paramètres suivant:\n" +msgstr "L'option --param reconnaît les paramètres suivant" #: opts.c:1350 -#, fuzzy -#| msgid "The following options are language-independent:\n" msgid "The following options are specific to just the language " -msgstr "Les options suivantes sont indépendantes du langage:\n" +msgstr "Les options suivantes sont spécifiques au langage " #: opts.c:1352 -#, fuzzy -#| msgid "The following options are language-independent:\n" msgid "The following options are supported by the language " -msgstr "Les options suivantes sont indépendantes du langage:\n" +msgstr "Les options suivantes sont prises en charge pour le langage " #: opts.c:1363 -#, fuzzy -#| msgid "The following options are language-independent:\n" msgid "The following options are not documented" -msgstr "Les options suivantes sont indépendantes du langage:\n" +msgstr "Les options suivantes sont non documentées" #: opts.c:1365 -#, fuzzy -#| msgid "The following options are language-independent:\n" msgid "The following options take separate arguments" -msgstr "Les options suivantes sont indépendantes du langage:\n" +msgstr "Les options suivantes prennent des arguments séparées" #: opts.c:1367 -#, fuzzy -#| msgid "The following options are language-independent:\n" msgid "The following options take joined arguments" -msgstr "Les options suivantes sont indépendantes du langage:\n" +msgstr "Les options suivantes prennent des arguments communs" #: opts.c:1378 -#, fuzzy -#| msgid "The following options are language-independent:\n" msgid "The following options are language-related" -msgstr "Les options suivantes sont indépendantes du langage:\n" +msgstr "Les options suivantes concernent les langages" #: plugin.c:796 msgid "Event" @@ -1610,10 +1493,9 @@ msgid "%s%s%s %sversion %s (%s) compiled by CC, " msgstr "%s%s%s %sversion %s (%s) compilé par CC, " #: toplev.c:646 -#, fuzzy, c-format -#| msgid "GMP version %s, MPFR version %s, MPC version %s\n" +#, c-format msgid "GMP version %s, MPFR version %s, MPC version %s, isl version %s\n" -msgstr "GMP version %s, MPFR version %s, MPC version %s\n" +msgstr "GMP version %s, MPFR version %s, MPC version %s, isl version %s\n" #: toplev.c:648 #, c-format @@ -1676,20 +1558,16 @@ msgid "--param large-function-growth limit reached" msgstr "--param large-function-growth limite atteinte" #: cif-code.def:70 -#, fuzzy -#| msgid "--param large-function-growth limit reached" msgid "--param large-stack-frame-growth limit reached" -msgstr "--param large-function-growth limite atteinte" +msgstr "--param large-stack-frame-growth limite atteinte" #: cif-code.def:72 msgid "--param max-inline-insns-single limit reached" msgstr "--param max-inline-insns-single limite atteinte" #: cif-code.def:74 -#, fuzzy -#| msgid "--param max-inline-insns-single limit reached" msgid "--param max-inline-insns-auto limit reached" -msgstr "--param max-inline-insns-single limite atteinte" +msgstr "--param max-inline-insns-auto limite atteinte" #: cif-code.def:76 msgid "--param inline-unit-growth limit reached" @@ -1708,10 +1586,8 @@ msgid "function not declared inline and code size would grow" msgstr "" #: cif-code.def:92 -#, fuzzy -#| msgid "mismatched braces in specs" msgid "mismatched arguments" -msgstr "accolades non concordantes dans les specs" +msgstr "arguments non concordantes" #: cif-code.def:96 #, fuzzy @@ -1763,7 +1639,7 @@ msgstr "votre fonction sera mal compilée" #: cif-code.def:133 msgid "unreachable" -msgstr "" +msgstr "introuvable" #. The remainder are real diagnostic types. #: diagnostic.def:33 @@ -1805,10 +1681,8 @@ msgstr "débogage : " #. These two would be re-classified as DK_WARNING or DK_ERROR, so the #. prefix does not matter. #: diagnostic.def:43 -#, fuzzy -#| msgid "warning: " msgid "pedwarn: " -msgstr "attention : " +msgstr "pédant : " #: diagnostic.def:44 msgid "permerror: " @@ -1825,16 +1699,14 @@ msgid "The minimal estimated speedup allowing inliner to ignore inline-insns-sin msgstr "" #: params.def:71 -#, fuzzy, no-c-format -#| msgid "The maximum number of instructions in a single function eligible for inlining" +#, no-c-format msgid "The maximum number of instructions in a single function eligible for inlining." -msgstr "Le nombre maximum d'instructions dans une fonction simple éligible au type enligne" +msgstr "Le nombre maximum d'instructions dans une fonction simple éligible au type enligne." #: params.def:83 -#, fuzzy, no-c-format -#| msgid "The maximum number of instructions when automatically inlining" +#, no-c-format msgid "The maximum number of instructions when automatically inlining." -msgstr "Le nombre maximum d'instructions lorsqu'automatiquement de type enligne" +msgstr "Le nombre maximum d'instructions lorsqu'automatiquement de type enligne." #: params.def:88 #, fuzzy, no-c-format @@ -1891,22 +1763,19 @@ msgid "If -ftree-vectorize is used, the minimal loop bound of a loop to be consi msgstr "" #: params.def:152 -#, fuzzy, no-c-format -#| msgid "The maximum number of instructions to consider to fill a delay slot" +#, no-c-format msgid "The maximum number of instructions to consider to fill a delay slot." -msgstr "Le nombre maximum d'instructions à considérer pour remplir une slot délai" +msgstr "Le nombre maximum d'instructions à considérer pour remplir une slot délai." #: params.def:163 -#, fuzzy, no-c-format -#| msgid "The maximum number of instructions to consider to find accurate live register information" +#, no-c-format msgid "The maximum number of instructions to consider to find accurate live register information." -msgstr "Le nombre maximum d'instructions à considérer pour repérer un registre d'information actif et précis" +msgstr "Le nombre maximum d'instructions à considérer pour repérer un registre d'information actif et précis." #: params.def:173 -#, fuzzy, no-c-format -#| msgid "The maximum length of scheduling's pending operations list" +#, no-c-format msgid "The maximum length of scheduling's pending operations list." -msgstr "La longueur maximale de la liste des opération en attente d'ordonnancement" +msgstr "La longueur maximale de la liste des opération en attente d'ordonnancement." #: params.def:180 #, fuzzy, no-c-format @@ -1915,16 +1784,14 @@ msgid "The maximum number of backtrack attempts the scheduler should make when m msgstr "Le nombre maximum d'instructions à considérer à inclure dans une boucle" #: params.def:185 -#, fuzzy, no-c-format -#| msgid "The size of function body to be considered large" +#, no-c-format msgid "The size of function body to be considered large." -msgstr "La taille du corps de la fonction est considéré comme étant grande" +msgstr "La taille du corps de la fonction est considéré comme étant grande." #: params.def:189 -#, fuzzy, no-c-format -#| msgid "Maximal growth due to inlining of large function (in percent)" +#, no-c-format msgid "Maximal growth due to inlining of large function (in percent)." -msgstr "Croissance maximal en raison de l'enlignage d'une grande fonction (en pourcentage)" +msgstr "Croissance maximal en raison de l'enlignage d'une grande fonction (en pourcentage)." #: params.def:193 #, fuzzy, no-c-format @@ -1933,16 +1800,15 @@ msgid "The size of translation unit to be considered large." msgstr "La taille du corps de la fonction est considéré comme étant grande" #: params.def:197 -#, fuzzy, no-c-format -#| msgid "how much can given compilation unit grow because of the inlining (in percent)" +#, no-c-format msgid "How much can given compilation unit grow because of the inlining (in percent)." -msgstr "quelle croissance d'une unité de compilation peut être tolérée en raison de l'enlignage (en pourcentage)" +msgstr "Quelle croissance d'une unité de compilation peut être tolérée en raison de l'enlignage (en pourcentage)." #: params.def:201 #, fuzzy, no-c-format #| msgid "how much can given compilation unit grow because of the inlining (in percent)" msgid "How much can given compilation unit grow because of the interprocedural constant propagation (in percent)." -msgstr "quelle croissance d'une unité de compilation peut être tolérée en raison de l'enlignage (en pourcentage)" +msgstr "Quelle croissance d'une unité de compilation peut être tolérée en raison de l'enlignage (en pourcentage)" #: params.def:205 #, no-c-format @@ -1962,10 +1828,9 @@ msgid "Maximal stack frame growth due to inlining (in percent)." msgstr "Croissance maximal en raison de l'enlignage d'une grande fonction (en pourcentage)" #: params.def:220 -#, fuzzy, no-c-format -#| msgid "The maximum amount of memory to be allocated by GCSE" +#, no-c-format msgid "The maximum amount of memory to be allocated by GCSE." -msgstr "La taille maximale de mémoire à être alloué par GCSE" +msgstr "La taille maximale de mémoire à être alloué par GCSE." #: params.def:227 #, fuzzy, no-c-format @@ -2004,34 +1869,29 @@ msgid "Maximum depth of sqrt chains to use when synthesizing exponentiation by a msgstr "" #: params.def:287 -#, fuzzy, no-c-format -#| msgid "The maximum number of instructions to consider to unroll in a loop" +#, no-c-format msgid "The maximum number of instructions to consider to unroll in a loop." -msgstr "Le nombre maximum d'instructions à considérer à inclure dans une boucle" +msgstr "Le nombre maximum d'instructions à considérer à inclure dans une boucle." #: params.def:293 -#, fuzzy, no-c-format -#| msgid "The maximum number of instructions to consider to unroll in a loop on average" +#, no-c-format msgid "The maximum number of instructions to consider to unroll in a loop on average." -msgstr "Le nombre maximum d'instructions à considérer à inclure dans une boucle en moyenne" +msgstr "Le nombre maximum d'instructions à considérer à inclure dans une boucle en moyenne." #: params.def:298 -#, fuzzy, no-c-format -#| msgid "The maximum number of unrollings of a single loop" +#, no-c-format msgid "The maximum number of unrollings of a single loop." -msgstr "Le nombre maximum d'instructions à inclure dans une boucle simple" +msgstr "Le nombre maximum d'instructions à inclure dans une boucle simple." #: params.def:303 -#, fuzzy, no-c-format -#| msgid "The maximum number of insns of a peeled loop" +#, no-c-format msgid "The maximum number of insns of a peeled loop." -msgstr "Le nombre maximum d'insns de boucle réduite" +msgstr "Le nombre maximum d'insns de boucle réduite." #: params.def:308 -#, fuzzy, no-c-format -#| msgid "The maximum number of peelings of a single loop" +#, no-c-format msgid "The maximum number of peelings of a single loop." -msgstr "Le nombre maximum de passes de réduction d'une boucle simple" +msgstr "Le nombre maximum de passes de réduction d'une boucle simple." #: params.def:313 #, fuzzy, no-c-format @@ -2040,22 +1900,19 @@ msgid "The maximum number of branches on the path through the peeled sequence." msgstr "Le nombre maximum d'insns d'une boucle complètement réduite" #: params.def:318 -#, fuzzy, no-c-format -#| msgid "The maximum number of insns of a completely peeled loop" +#, no-c-format msgid "The maximum number of insns of a completely peeled loop." -msgstr "Le nombre maximum d'insns d'une boucle complètement réduite" +msgstr "Le nombre maximum d'insns d'une boucle complètement réduite." #: params.def:323 -#, fuzzy, no-c-format -#| msgid "The maximum number of peelings of a single loop that is peeled completely" +#, no-c-format msgid "The maximum number of peelings of a single loop that is peeled completely." -msgstr "Le nombre maximum de réductions d'une boucle simple qui a été complètement réduite" +msgstr "Le nombre maximum de réductions d'une boucle simple qui a été complètement réduite." #: params.def:328 -#, fuzzy, no-c-format -#| msgid "The maximum number of insns of a peeled loop that rolls only once" +#, no-c-format msgid "The maximum number of insns of a peeled loop that rolls only once." -msgstr "Le nombre maximum d'insns d'une boucle réduite qui tourne une seule fois" +msgstr "Le nombre maximum d'insns d'une boucle réduite qui tourne une seule fois." #: params.def:333 #, fuzzy, no-c-format @@ -2064,16 +1921,14 @@ msgid "The maximum depth of a loop nest we completely peel." msgstr "Le nombre maximum d'insns d'une boucle complètement réduite" #: params.def:339 -#, fuzzy, no-c-format -#| msgid "The maximum number of insns of an unswitched loop" +#, no-c-format msgid "The maximum number of insns of an unswitched loop." -msgstr "Le nombre maximum d'insns d'une boucle sans branchement" +msgstr "Le nombre maximum d'insns d'une boucle sans branchement." #: params.def:344 -#, fuzzy, no-c-format -#| msgid "The maximum number of unswitchings in a single loop" +#, no-c-format msgid "The maximum number of unswitchings in a single loop." -msgstr "Le nombre maximum de non branchement dans une boucle simple" +msgstr "Le nombre maximum de non branchement dans une boucle simple." #: params.def:351 #, no-c-format @@ -2111,10 +1966,9 @@ msgid "A basic block profile count is considered hot if it contributes to the gi msgstr "" #: params.def:386 -#, fuzzy, no-c-format -#| msgid "Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot" +#, no-c-format msgid "Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot." -msgstr "Sélectionner la fraction de la fréquence maximale d'exécutions du bloc de base dans la fonction selon le bloc de base donné doit être considéré comme chaud « hot »" +msgstr "Sélectionner la fraction de la fréquence maximale d'exécutions du bloc de base dans la fonction selon le bloc de base donné doit être considéré comme chaud « hot »." #: params.def:391 #, no-c-format @@ -2144,46 +1998,39 @@ msgid "Set the estimated probability in percentage for builtin expect. The defau msgstr "" #: params.def:434 -#, fuzzy, no-c-format -#| msgid "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available" +#, no-c-format msgid "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available." -msgstr "Le pourcentage de fonction, pondéré par la fréquence d'exécutions, qui doit être couvert la formation de la trace. Utilisé lorsque le feedback par profile est disponible" +msgstr "Le pourcentage de fonction, pondéré par la fréquence d'exécutions, qui doit être couvert la formation de la trace. Utilisé lorsque le feedback par profile est disponible." #: params.def:438 -#, fuzzy, no-c-format -#| msgid "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is not available" +#, no-c-format msgid "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is not available." -msgstr "Le pourcentage de fonction, pondéré par la fréquence d'exécutions, qui doit être couvert la formation de la trace. Utilisé lorsque le feedback par profilage n'est disponible" +msgstr "Le pourcentage de fonction, pondéré par la fréquence d'exécutions, qui doit être couvert la formation de la trace. Utilisé lorsque le feedback par profilage n'est disponible." #: params.def:442 -#, fuzzy, no-c-format -#| msgid "Maximal code growth caused by tail duplication (in percent)" +#, no-c-format msgid "Maximal code growth caused by tail duplication (in percent)." -msgstr "Croissance maximal du code en raison de duplication de queue (en pourcentage)" +msgstr "Croissance maximal du code en raison de duplication de queue (en pourcentage)." #: params.def:446 -#, fuzzy, no-c-format -#| msgid "Stop reverse growth if the reverse probability of best edge is less than this threshold (in percent)" +#, no-c-format msgid "Stop reverse growth if the reverse probability of best edge is less than this threshold (in percent)." -msgstr "Stopper la croissance renversée si la probabilité inverse des meilleures bordures est inférieure à ce seuil (en pourcentage)" +msgstr "Stopper la croissance renversée si la probabilité inverse des meilleures bordures est inférieure à ce seuil (en pourcentage)." #: params.def:450 -#, fuzzy, no-c-format -#| msgid "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is available" +#, no-c-format msgid "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is available." -msgstr "Stopper la croissance anticipée si la probabilité des meilleures bordures est inférieure à ce seuil (en pourcentage). Utilisé lorsque le feedback par profilage est disponible" +msgstr "Stopper la croissance anticipée si la probabilité des meilleures bordures est inférieure à ce seuil (en pourcentage). Utilisé lorsque le feedback par profilage est disponible." #: params.def:454 -#, fuzzy, no-c-format -#| msgid "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is not available" +#, no-c-format msgid "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is not available." -msgstr "Stopper la croissance anticipée si la probabilité des meilleures bordures est inférieure à ce seuil (en pourcentage). Utilisé lorsque le feedback par profilage n'est pas disponible" +msgstr "Stopper la croissance anticipée si la probabilité des meilleures bordures est inférieure à ce seuil (en pourcentage). Utilisé lorsque le feedback par profilage n'est pas disponible." #: params.def:460 -#, fuzzy, no-c-format -#| msgid "The maximum number of incoming edges to consider for crossjumping" +#, no-c-format msgid "The maximum number of incoming edges to consider for crossjumping." -msgstr "Le nombre maximum de bordures à considérer pour les sauts croisés" +msgstr "Le nombre maximum de bordures à considérer pour les sauts croisés." #: params.def:466 #, fuzzy, no-c-format @@ -2203,10 +2050,9 @@ msgid "The maximum number of insns to duplicate when unfactoring computed gotos. msgstr "Le nombre maximum d'insns d'une boucle sans branchement" #: params.def:484 -#, fuzzy, no-c-format -#| msgid "The maximum length of path considered in cse" +#, no-c-format msgid "The maximum length of path considered in cse." -msgstr "La longueur maximale des chemins considérés dans cse" +msgstr "La longueur maximale des chemins considérés dans cse." #: params.def:488 #, fuzzy, no-c-format @@ -2262,28 +2108,24 @@ msgid "Max number of loop peels to enhancement alignment of data references in a msgstr "" #: params.def:550 -#, fuzzy, no-c-format -#| msgid "The maximum memory locations recorded by cselib" +#, no-c-format msgid "The maximum memory locations recorded by cselib." -msgstr "Le nombre maximum de localisations mémoire enregistrées par cselib" +msgstr "Le nombre maximum de localisations mémoire enregistrées par cselib." #: params.def:563 -#, fuzzy, no-c-format -#| msgid "Minimum heap expansion to trigger garbage collection, as a percentage of the total size of the heap" +#, no-c-format msgid "Minimum heap expansion to trigger garbage collection, as a percentage of the total size of the heap." msgstr "L'expansion minimale des tas pour lancer la collecte des rebuts, en pourcentage de la taille totale du tas." #: params.def:568 -#, fuzzy, no-c-format -#| msgid "Minimum heap size before we start collecting garbage, in kilobytes" +#, no-c-format msgid "Minimum heap size before we start collecting garbage, in kilobytes." msgstr "La taille minimale du tas avant de lancer la collecte des rebuts, en ko." #: params.def:576 -#, fuzzy, no-c-format -#| msgid "The maximum number of instructions to search backward when looking for equivalent reload" +#, no-c-format msgid "The maximum number of instructions to search backward when looking for equivalent reload." -msgstr "Le nombre maximum d'instructions à rechercher antérieurement lors d'une recherche d'une recharge équivalente" +msgstr "Le nombre maximum d'instructions à rechercher antérieurement lors d'une recherche d'une recharge équivalente." #: params.def:581 #, no-c-format @@ -2417,22 +2259,19 @@ msgid "The number of prefetches that can run at the same time." msgstr "" #: params.def:743 -#, fuzzy, no-c-format -#| msgid "The size of L1 cache" +#, no-c-format msgid "The size of L1 cache." -msgstr "La taille du cache L1" +msgstr "La taille du cache L1." #: params.def:750 -#, fuzzy, no-c-format -#| msgid "The size of L1 cache" +#, no-c-format msgid "The size of L1 cache line." -msgstr "La taille du cache L1" +msgstr "La taille du cache L1." #: params.def:757 -#, fuzzy, no-c-format -#| msgid "The size of L2 cache" +#, no-c-format msgid "The size of L2 cache." -msgstr "La taille du cache L2" +msgstr "La taille du cache L2." #: params.def:768 #, no-c-format @@ -2803,16 +2642,12 @@ msgid "format" msgstr "format" #: c-family/c-format.c:418 -#, fuzzy -#| msgid "field width" msgid "field width specifier" -msgstr "largeur de champ" +msgstr "spécificateur de largeur de champ" #: c-family/c-format.c:419 -#, fuzzy -#| msgid "field precision" msgid "field precision specifier" -msgstr "champ de précision" +msgstr "spécificateur de champ de précision" #: c-family/c-format.c:536 c-family/c-format.c:560 config/i386/msformat-c.c:42 msgid "' ' flag" @@ -2915,10 +2750,8 @@ msgid "'q' flag" msgstr "fanion « q »" #: c-family/c-format.c:593 -#, fuzzy -#| msgid "the `'' printf flag" msgid "the 'q' diagnostic flag" -msgstr "le fanion « ' » de printf" +msgstr "le fanion « d » de diagnostique" #: c-family/c-format.c:606 config/i386/msformat-c.c:63 msgid "assignment suppression" diff --git a/gcc/po/sv.po b/gcc/po/sv.po index abcee285787d..4e486f88f7a7 100644 --- a/gcc/po/sv.po +++ b/gcc/po/sv.po @@ -10,14 +10,17 @@ # assumed type antagen typ # cast typkonvertering # kind sort +# load ladda # offset avstånd +# overload överlagra # rank ordning +# store lagra msgid "" msgstr "" "Project-Id-Version: gcc 6.1-b20160131\n" "Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n" "POT-Creation-Date: 2016-01-31 15:50+0000\n" -"PO-Revision-Date: 2016-02-21 21:15+0100\n" +"PO-Revision-Date: 2016-03-09 22:57+0100\n" "Last-Translator: Göran Uddeborg \n" "Language-Team: Swedish \n" "Language: sv\n" @@ -1713,35 +1716,30 @@ msgid "The maximum ratio of insertions to deletions of expressions in GCSE." msgstr "Det maximala förhållandet mellan insättningar och raderingar av uttryck i GCSE." #: params.def:238 -#, fuzzy, no-c-format -#| msgid "The threshold ratio for performing partial redundancy elimination after reload" +#, no-c-format msgid "The threshold ratio for performing partial redundancy elimination after reload." -msgstr "Tröskelförhållandet för att utföra partiell redundanselimination efter omläsning" +msgstr "Tröskelförhållandet för att utföra partiell redundanselimination efter omläsning." # Undrar om jag fattat syftningen i "critical edges execution count" rätt! #: params.def:245 -#, fuzzy, no-c-format -#| msgid "The threshold ratio of critical edges execution count that permit performing redundancy elimination after reload" +#, no-c-format msgid "The threshold ratio of critical edges execution count that permit performing redundancy elimination after reload." -msgstr "Tröskelförhållandet av antal beräkningar av kritiska bågar som tillåter att göra redundanseliminering efter omläsning" +msgstr "Tröskelförhållandet av antal beräkningar av kritiska bågar som tillåter att göra redundanseliminering efter omläsning." #: params.def:253 -#, fuzzy, no-c-format -#| msgid "Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimizations" +#, no-c-format msgid "Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimizations." -msgstr "Skalfaktor vid beräkning av maximala distansen ett uttryck kan flyttas genom GCSE-optimeringar" +msgstr "Skalfaktor vid beräkning av maximala distansen ett uttryck kan flyttas genom GCSE-optimeringar." #: params.def:259 -#, fuzzy, no-c-format -#| msgid "Cost at which GCSE optimizations will not constraint the distance an expression can travel" +#, no-c-format msgid "Cost at which GCSE optimizations will not constraint the distance an expression can travel." -msgstr "Kostnaden vid vilken GCSE-optimeringar inte kommer begränsa avståndet ett uttryck kan flytta" +msgstr "Kostnaden vid vilken GCSE-optimeringar inte kommer begränsa avståndet ett uttryck kan flytta." #: params.def:267 -#, fuzzy, no-c-format -#| msgid "Maximum depth of search in the dominator tree for expressions to hoist" +#, no-c-format msgid "Maximum depth of search in the dominator tree for expressions to hoist." -msgstr "Maximalt djup på sökningen i dominansträd för uttryck att hissa upp" +msgstr "Maximalt djup på sökningen i dominansträd för uttryck att hissa upp." #: params.def:275 #, no-c-format @@ -1749,95 +1747,80 @@ msgid "Maximum depth of sqrt chains to use when synthesizing exponentiation by a msgstr "Maximalt djup av sqrt-kedjor att använda vid syntetisering av exponentiering av en reell konstant." #: params.def:287 -#, fuzzy, no-c-format -#| msgid "The maximum number of instructions to consider to unroll in a loop" +#, no-c-format msgid "The maximum number of instructions to consider to unroll in a loop." -msgstr "Det maximala antalet instruktioner för att överväga att rulla ut i en slinga" +msgstr "Det maximala antalet instruktioner för att överväga att rulla ut i en slinga." #: params.def:293 -#, fuzzy, no-c-format -#| msgid "The maximum number of instructions to consider to unroll in a loop on average" +#, no-c-format msgid "The maximum number of instructions to consider to unroll in a loop on average." -msgstr "Det maximala antalet instruktioner för att överväga att rulle ut i en slinga i genomsnitt" +msgstr "Det maximala antalet instruktioner för att överväga att rulle ut i en slinga i genomsnitt." #: params.def:298 -#, fuzzy, no-c-format -#| msgid "The maximum number of unrollings of a single loop" +#, no-c-format msgid "The maximum number of unrollings of a single loop." -msgstr "Det maximala antalet utrullningar av en enskild slinga" +msgstr "Det maximala antalet utrullningar av en enskild slinga." #: params.def:303 -#, fuzzy, no-c-format -#| msgid "The maximum number of insns of a peeled loop" +#, no-c-format msgid "The maximum number of insns of a peeled loop." -msgstr "Det maximala antalet instruktioner i en avskalad slinga" +msgstr "Det maximala antalet instruktioner i en avskalad slinga." #: params.def:308 -#, fuzzy, no-c-format -#| msgid "The maximum number of peelings of a single loop" +#, no-c-format msgid "The maximum number of peelings of a single loop." -msgstr "Det maximala antalet avskalningar av en enskild slinga" +msgstr "Det maximala antalet avskalningar av en enskild slinga." #: params.def:313 -#, fuzzy, no-c-format -#| msgid "The maximum number of branches on the path through the peeled sequence" +#, no-c-format msgid "The maximum number of branches on the path through the peeled sequence." -msgstr "Det maximala antalet grenar på vägen genom den skalade sekvensen" +msgstr "Det maximala antalet grenar på vägen genom den skalade sekvensen." #: params.def:318 -#, fuzzy, no-c-format -#| msgid "The maximum number of insns of a completely peeled loop" +#, no-c-format msgid "The maximum number of insns of a completely peeled loop." -msgstr "Det maximala antalet instruktioner i en helt avskalad slinga" +msgstr "Det maximala antalet instruktioner i en helt avskalad slinga." #: params.def:323 -#, fuzzy, no-c-format -#| msgid "The maximum number of peelings of a single loop that is peeled completely" +#, no-c-format msgid "The maximum number of peelings of a single loop that is peeled completely." -msgstr "Det maximala antalet avskalningar av en enskild slinga som är helt avskalad" +msgstr "Det maximala antalet avskalningar av en enskild slinga som är helt avskalad." #: params.def:328 -#, fuzzy, no-c-format -#| msgid "The maximum number of insns of a peeled loop that rolls only once" +#, no-c-format msgid "The maximum number of insns of a peeled loop that rolls only once." -msgstr "Det maximala antalet instruktioner i en avskalad slinga som bara snurrar en gång" +msgstr "Det maximala antalet instruktioner i en avskalad slinga som bara snurrar en gång." #: params.def:333 -#, fuzzy, no-c-format -#| msgid "The maximum depth of a loop nest we completely peel" +#, no-c-format msgid "The maximum depth of a loop nest we completely peel." -msgstr "Det maximala djupet av nästade slingor som vi skalar helt" +msgstr "Det maximala djupet av nästade slingor som vi skalar helt." #: params.def:339 -#, fuzzy, no-c-format -#| msgid "The maximum number of insns of an unswitched loop" +#, no-c-format msgid "The maximum number of insns of an unswitched loop." -msgstr "Det maximala antalet instruktioner i en oväxlad slinga" +msgstr "Det maximala antalet instruktioner i en oväxlad slinga." #: params.def:344 -#, fuzzy, no-c-format -#| msgid "The maximum number of unswitchings in a single loop" +#, no-c-format msgid "The maximum number of unswitchings in a single loop." -msgstr "Det maximala antalet omväxlingar i en enskild slinga" +msgstr "Det maximala antalet omväxlingar i en enskild slinga." # Är syftningarna rätt här? #: params.def:351 -#, fuzzy, no-c-format -#| msgid "Bound on the number of iterations the brute force # of iterations analysis algorithm evaluates" +#, no-c-format msgid "Bound on the number of iterations the brute force # of iterations analysis algorithm evaluates." -msgstr "Begränsning på antalet iterationer som utvärderas av råstyrkealgoritmen för att analysera antalet iterationer" +msgstr "Begränsning på antalet iterationer som utvärderas av råstyrkealgoritmen för att analysera antalet iterationer." #: params.def:357 -#, fuzzy, no-c-format -#| msgid "Bound on the cost of an expression to compute the number of iterations" +#, no-c-format msgid "Bound on the cost of an expression to compute the number of iterations." -msgstr "Begränsningen av kostnaden för ett uttryck för att beräkna antalet iterationer" +msgstr "Begränsningen av kostnaden för ett uttryck för att beräkna antalet iterationer." #: params.def:363 -#, fuzzy, no-c-format -#| msgid "A factor for tuning the upper bound that swing modulo scheduler uses for scheduling a loop" +#, no-c-format msgid "A factor for tuning the upper bound that swing modulo scheduler uses for scheduling a loop." -msgstr "En faktor för att trimma den övre gränsen som pendlingsmoduloschemaläggaren använder för att schemalägga en slinga" +msgstr "En faktor för att trimma den övre gränsen som pendlingsmoduloschemaläggaren använder för att schemalägga en slinga." #: params.def:368 #, no-c-format @@ -1845,245 +1828,204 @@ msgid "The minimum value of stage count that swing modulo scheduler will generat msgstr "Minimivärdet på steglängden som pendlingsschemaläggaren kommer generera." #: params.def:372 -#, fuzzy, no-c-format -#| msgid "The number of cycles the swing modulo scheduler considers when checking conflicts using DFA" +#, no-c-format msgid "The number of cycles the swing modulo scheduler considers when checking conflicts using DFA." -msgstr "Antalet cykler som pendlingsschemaläggaren beaktar när den söker efter konflikter med DFA" +msgstr "Antalet cykler som pendlingsschemaläggaren beaktar när den söker efter konflikter med DFA." #: params.def:376 -#, fuzzy, no-c-format -#| msgid "A threshold on the average loop count considered by the swing modulo scheduler" +#, no-c-format msgid "A threshold on the average loop count considered by the swing modulo scheduler." -msgstr "Ett tröskelvärde på det genomsnittliga antalet varv som beaktas av pendlingsmoduloschemaläggaren" +msgstr "Ett tröskelvärde på det genomsnittliga antalet varv som beaktas av pendlingsmoduloschemaläggaren." #: params.def:381 -#, fuzzy, no-c-format -#| msgid "A basic block profile count is considered hot if it contributes to the given permillage of the entire profiled execution" +#, no-c-format msgid "A basic block profile count is considered hot if it contributes to the given permillage of the entire profiled execution." -msgstr "Ett grundblocks profilräknare anses het om den bidrar till den givna promillesatsen för hela den profilerade körningen" +msgstr "Ett grundblocks profilräknare anses het om den bidrar till den givna promillesatsen för hela den profilerade körningen." #: params.def:386 -#, fuzzy, no-c-format -#| msgid "Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot" +#, no-c-format msgid "Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot." -msgstr "Välj andel av den maximala exekveringsfrekvensen av grundblock i funktion givet grundblock måste ha för att anses hett" +msgstr "Välj andel av den maximala exekveringsfrekvensen av grundblock i funktion givet grundblock måste ha för att anses hett." #: params.def:391 -#, fuzzy, no-c-format -#| msgid "The minimum fraction of profile runs a given basic block execution count must be not to be considered unlikely" +#, no-c-format msgid "The minimum fraction of profile runs a given basic block execution count must be not to be considered unlikely." -msgstr "Minsta andelen av profileringskörningar ett givet grundblocks exekveringsräknare måste ha för att inte anses osannolik" +msgstr "Minsta andelen av profileringskörningar ett givet grundblocks exekveringsräknare måste ha för att inte anses osannolik." #: params.def:396 -#, fuzzy, no-c-format -#| msgid "Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment" +#, no-c-format msgid "Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment." -msgstr "Välj andel av den maximala exekveringsfrekvensen av grundblock i funktion givet grundblock måste ha för att få justering" +msgstr "Välj andel av den maximala exekveringsfrekvensen av grundblock i funktion givet grundblock måste ha för att få justering." #: params.def:401 -#, fuzzy, no-c-format -#| msgid "Loops iterating at least selected number of iterations will get loop alignement." +#, no-c-format msgid "Loops iterating at least selected number of iterations will get loop alignement.." msgstr "Slingor som itererar åtminstone det valda antalet gånger kommer att få slingjustering." #: params.def:417 -#, fuzzy, no-c-format -#| msgid "The maximum number of loop iterations we predict statically" +#, no-c-format msgid "The maximum number of loop iterations we predict statically." -msgstr "Det maximala antalet slingiterationer vi förutsäger statiskt" +msgstr "Det maximala antalet slingiterationer vi förutsäger statiskt." -# Ett extra "p" efter procenttecknet p.g.a. -# http://gcc.gnu.org/bugzilla/show_bug.cgi?id=60149 #: params.def:430 #, no-c-format msgid "Set the estimated probability in percentage for builtin expect. The default value is 90% probability." -msgstr "Ange den uppskattade sannolikheten i procent för den inbyggda expect. Standardvärdet är 90 %p sannolikhet." +msgstr "Ange den uppskattade sannolikheten i procent för den inbyggda expect. Standardvärdet är 90 % sannolikhet." #: params.def:434 -#, fuzzy, no-c-format -#| msgid "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available" +#, no-c-format msgid "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available." -msgstr "Andelen av funktion i procent, viktad efter exekveringsfrekvens, som måste täckas av spårinformation. Används när profileringsdata är tillgängligt" +msgstr "Andelen av funktion i procent, viktad efter exekveringsfrekvens, som måste täckas av spårinformation. Används när profileringsdata är tillgängligt." #: params.def:438 -#, fuzzy, no-c-format -#| msgid "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is not available" +#, no-c-format msgid "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is not available." -msgstr "Andelen av funktion i procent, viktad efter exekveringsfrekvens, som måste täckas av spårinformation. Används när profileringsdata inte är tillgängligt" +msgstr "Andelen av funktion i procent, viktad efter exekveringsfrekvens, som måste täckas av spårinformation. Används när profileringsdata inte är tillgängligt." #: params.def:442 -#, fuzzy, no-c-format -#| msgid "Maximal code growth caused by tail duplication (in percent)" +#, no-c-format msgid "Maximal code growth caused by tail duplication (in percent)." -msgstr "Maximal kodtillväxt orsakad av svansduplicering (i procent)" +msgstr "Maximal kodtillväxt orsakad av svansduplicering (i procent)." #: params.def:446 -#, fuzzy, no-c-format -#| msgid "Stop reverse growth if the reverse probability of best edge is less than this threshold (in percent)" +#, no-c-format msgid "Stop reverse growth if the reverse probability of best edge is less than this threshold (in percent)." -msgstr "Stoppa omvänd tillväxt om den omvända sannolikheten av bästa båge är mindre än detta tröskelvärde (i procent)" +msgstr "Stoppa omvänd tillväxt om den omvända sannolikheten av bästa båge är mindre än detta tröskelvärde (i procent)." #: params.def:450 -#, fuzzy, no-c-format -#| msgid "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is available" +#, no-c-format msgid "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is available." -msgstr "Stoppa framåttillväxt om sannolikheten av bästa båge är mindre än detta tröskelvärde (i procent). Används när profileringsdata är tillgänglig" +msgstr "Stoppa framåttillväxt om sannolikheten av bästa båge är mindre än detta tröskelvärde (i procent). Används när profileringsdata är tillgänglig." #: params.def:454 -#, fuzzy, no-c-format -#| msgid "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is not available" +#, no-c-format msgid "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is not available." -msgstr "Stoppa framåttillväxt om sannolikheten av bästa båge är mindre än detta tröskelvärde (i procent). Används när profileringsdata inte är tillgänglig" +msgstr "Stoppa framåttillväxt om sannolikheten av bästa båge är mindre än detta tröskelvärde (i procent). Används när profileringsdata inte är tillgänglig." #: params.def:460 -#, fuzzy, no-c-format -#| msgid "The maximum number of incoming edges to consider for crossjumping" +#, no-c-format msgid "The maximum number of incoming edges to consider for crossjumping." -msgstr "Det maximala antalet ingående bågar att överväga för korshopp" +msgstr "Det maximala antalet ingående bågar att överväga för korshopp." #: params.def:466 -#, fuzzy, no-c-format -#| msgid "The minimum number of matching instructions to consider for crossjumping" +#, no-c-format msgid "The minimum number of matching instructions to consider for crossjumping." -msgstr "Det minsta antal av matchande instruktioner att överväga för korshopp" +msgstr "Det minsta antal av matchande instruktioner att överväga för korshopp." #: params.def:472 -#, fuzzy, no-c-format -#| msgid "The maximum expansion factor when copying basic blocks" +#, no-c-format msgid "The maximum expansion factor when copying basic blocks." -msgstr "Den maximala expansionsfaktorn vid kopiering av grundblock" +msgstr "Den maximala expansionsfaktorn vid kopiering av grundblock." #: params.def:478 -#, fuzzy, no-c-format -#| msgid "The maximum number of insns to duplicate when unfactoring computed gotos" +#, no-c-format msgid "The maximum number of insns to duplicate when unfactoring computed gotos." -msgstr "Det maximala antalet instruktioner att duplicera vid avfaktorering av beräknade goto" +msgstr "Det maximala antalet instruktioner att duplicera vid avfaktorering av beräknade goto." #: params.def:484 -#, fuzzy, no-c-format -#| msgid "The maximum length of path considered in cse" +#, no-c-format msgid "The maximum length of path considered in cse." -msgstr "Den maximala längden på sökvägar som övervägs i cse" +msgstr "Den maximala längden på sökvägar som övervägs i cse." #: params.def:488 -#, fuzzy, no-c-format -#| msgid "The maximum instructions CSE process before flushing" +#, no-c-format msgid "The maximum instructions CSE process before flushing." -msgstr "Det maximala antalet instruktioner CSE bearbetar före tömning" +msgstr "Det maximala antalet instruktioner CSE bearbetar före tömning." #: params.def:495 -#, fuzzy, no-c-format -#| msgid "The minimum cost of an expensive expression in the loop invariant motion" +#, no-c-format msgid "The minimum cost of an expensive expression in the loop invariant motion." -msgstr "Den minsta kostnaden av ett dyrt uttryck vid flyttning av slinginvariant" +msgstr "Den minsta kostnaden av ett dyrt uttryck vid flyttning av slinginvariant." #: params.def:504 -#, fuzzy, no-c-format -#| msgid "Bound on number of candidates below that all candidates are considered in iv optimizations" +#, no-c-format msgid "Bound on number of candidates below that all candidates are considered in iv optimizations." -msgstr "Gräns för antalet kandidater under vilken alla kandidater övervägs i iv-optimeringar" +msgstr "Gräns för antalet kandidater under vilken alla kandidater övervägs i iv-optimeringar." #: params.def:512 -#, fuzzy, no-c-format -#| msgid "Bound on number of iv uses in loop optimized in iv optimizations" +#, no-c-format msgid "Bound on number of iv uses in loop optimized in iv optimizations." -msgstr "Gräns för antal iv-användningar i en slinga optimerad i iv-optimeringar" +msgstr "Gräns för antal iv-användningar i en slinga optimerad i iv-optimeringar." #: params.def:520 -#, fuzzy, no-c-format -#| msgid "If number of candidates in the set is smaller, we always try to remove unused ivs during its optimization" +#, no-c-format msgid "If number of candidates in the set is smaller, we always try to remove unused ivs during its optimization." -msgstr "Om antalet kandidater i mängden är mindre, försöker vi alltid ta bort oanvända iv under deras optimering" +msgstr "Om antalet kandidater i mängden är mindre, försöker vi alltid ta bort oanvända iv under deras optimering." #: params.def:525 -#, fuzzy, no-c-format -#| msgid "Bound on size of expressions used in the scalar evolutions analyzer" +#, no-c-format msgid "Bound on size of expressions used in the scalar evolutions analyzer." -msgstr "Gräns för storleken av uttryck som används i analyseraren av skalära uttryck" +msgstr "Gräns för storleken av uttryck som används i analyseraren av skalära uttryck." #: params.def:530 -#, fuzzy, no-c-format -#| msgid "Bound on the complexity of the expressions in the scalar evolutions analyzer" +#, no-c-format msgid "Bound on the complexity of the expressions in the scalar evolutions analyzer." -msgstr "Gräns på komplexiteten av uttryck som används i analyseraren av skalära uttryck" +msgstr "Gräns på komplexiteten av uttryck som används i analyseraren av skalära uttryck." #: params.def:535 -#, fuzzy, no-c-format -#| msgid "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check" +#, no-c-format msgid "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check." -msgstr "Gräns för antalet körtidskontroller som läggs in av vektoriserarens slingversionering för justeringskontroller" +msgstr "Gräns för antalet körtidskontroller som läggs in av vektoriserarens slingversionering för justeringskontroller." #: params.def:540 -#, fuzzy, no-c-format -#| msgid "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check" +#, no-c-format msgid "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check." -msgstr "Gräns för antalet körtidskontroller som läggs in av vektoriserarens slingversionering för aliaskontroller" +msgstr "Gräns för antalet körtidskontroller som läggs in av vektoriserarens slingversionering för aliaskontroller." #: params.def:545 -#, fuzzy, no-c-format -#| msgid "Max number of loop peels to enhancement alignment of data references in a loop" +#, no-c-format msgid "Max number of loop peels to enhancement alignment of data references in a loop." -msgstr "Maximala antalet slingavskalningar för att förbättra justering av datareferenser i en slinga" +msgstr "Maximala antalet slingavskalningar för att förbättra justering av datareferenser i en slinga." #: params.def:550 -#, fuzzy, no-c-format -#| msgid "The maximum memory locations recorded by cselib" +#, no-c-format msgid "The maximum memory locations recorded by cselib." -msgstr "Det maximala antalet minnesplatser noterade av cselib" +msgstr "Det maximala antalet minnesplatser noterade av cselib." #: params.def:563 -#, fuzzy, no-c-format -#| msgid "Minimum heap expansion to trigger garbage collection, as a percentage of the total size of the heap" +#, no-c-format msgid "Minimum heap expansion to trigger garbage collection, as a percentage of the total size of the heap." -msgstr "Minsta heap-expansion för att utlösa skräpsamling, som en procent av den totala storleken på heap:en" +msgstr "Minsta heap-expansion för att utlösa skräpsamling, som en procent av den totala storleken på heap:en." #: params.def:568 -#, fuzzy, no-c-format -#| msgid "Minimum heap size before we start collecting garbage, in kilobytes" +#, no-c-format msgid "Minimum heap size before we start collecting garbage, in kilobytes." -msgstr "Minsta heap-storlek före vi börjar samla skräp, i kilobyte" +msgstr "Minsta heap-storlek före vi börjar samla skräp, i kilobyte." #: params.def:576 -#, fuzzy, no-c-format -#| msgid "The maximum number of instructions to search backward when looking for equivalent reload" +#, no-c-format msgid "The maximum number of instructions to search backward when looking for equivalent reload." -msgstr "Det största antalet instruktioner att söka bakåt för att leta efter ekvivalent omläsning" +msgstr "Det största antalet instruktioner att söka bakåt för att leta efter ekvivalent omläsning." #: params.def:581 -#, fuzzy, no-c-format -#| msgid "Target block's relative execution frequency (as a percentage) required to sink a statement" +#, no-c-format msgid "Target block's relative execution frequency (as a percentage) required to sink a statement." -msgstr "Målet för blocks relativa exekveringsfrekvens (som en procentsats) som behövs för att sänka en sats" +msgstr "Målet för blocks relativa exekveringsfrekvens (som en procentsats) som behövs för att sänka en sats." #: params.def:586 params.def:596 -#, fuzzy, no-c-format -#| msgid "The maximum number of blocks in a region to be considered for interblock scheduling" +#, no-c-format msgid "The maximum number of blocks in a region to be considered for interblock scheduling." -msgstr "Det maximala antalet block i en region som övervägs för interblockschemaläggning" +msgstr "Det maximala antalet block i en region som övervägs för interblockschemaläggning." #: params.def:591 params.def:601 -#, fuzzy, no-c-format -#| msgid "The maximum number of insns in a region to be considered for interblock scheduling" +#, no-c-format msgid "The maximum number of insns in a region to be considered for interblock scheduling." -msgstr "Det maximala antalet instruktioner i en region för att övervägas för interblockschemaläggning" +msgstr "Det maximala antalet instruktioner i en region för att övervägas för interblockschemaläggning." #: params.def:606 -#, fuzzy, no-c-format -#| msgid "The minimum probability of reaching a source block for interblock speculative scheduling" +#, no-c-format msgid "The minimum probability of reaching a source block for interblock speculative scheduling." -msgstr "Den minsta sannolikheten för att nå ett källkodsblock för spekulativ schemaläggning mellan block" +msgstr "Den minsta sannolikheten för att nå ett källkodsblock för spekulativ schemaläggning mellan block." #: params.def:611 -#, fuzzy, no-c-format -#| msgid "The maximum number of iterations through CFG to extend regions" +#, no-c-format msgid "The maximum number of iterations through CFG to extend regions." -msgstr "Det maximala antal iterationer genom CFG för utökade regioner" +msgstr "Det maximala antal iterationer genom CFG för utökade regioner." #: params.def:616 -#, fuzzy, no-c-format -#| msgid "The maximum conflict delay for an insn to be considered for speculative motion" +#, no-c-format msgid "The maximum conflict delay for an insn to be considered for speculative motion." -msgstr "Den maximala konfliktfördröjningen för att en instruktion skall övervägas för spekulativ förflyttning" +msgstr "Den maximala konfliktfördröjningen för att en instruktion skall övervägas för spekulativ förflyttning." #: params.def:621 #, no-c-format @@ -2096,28 +2038,24 @@ msgid "The minimum probability an edge must have for the scheduler to save its s msgstr "Den minsta sannolikhet en båge måste ha för att schemaläggaren skall spara sitt tillstånd över den." #: params.def:631 -#, fuzzy, no-c-format -#| msgid "The maximum size of the lookahead window of selective scheduling" +#, no-c-format msgid "The maximum size of the lookahead window of selective scheduling." -msgstr "Den maximala storleken på fönstret för framåtblickar vid selektiv schemaläggning" +msgstr "Den maximala storleken på fönstret för framåtblickar vid selektiv schemaläggning." #: params.def:636 -#, fuzzy, no-c-format -#| msgid "Maximum number of times that an insn could be scheduled" +#, no-c-format msgid "Maximum number of times that an insn could be scheduled." -msgstr "Maximalt antal gånger som en instruktion kan schemaläggas" +msgstr "Maximalt antal gånger som en instruktion kan schemaläggas." #: params.def:641 -#, fuzzy, no-c-format -#| msgid "Maximum number of instructions in the ready list that are considered eligible for renaming" +#, no-c-format msgid "Maximum number of instructions in the ready list that are considered eligible for renaming." -msgstr "Det maximala antalet instruktioner i redolistan som betraktas som valbara för namnändring" +msgstr "Det maximala antalet instruktioner i redolistan som betraktas som valbara för namnändring." #: params.def:646 -#, fuzzy, no-c-format -#| msgid "Minimal distance between possibly conflicting store and load" +#, no-c-format msgid "Minimal distance between possibly conflicting store and load." -msgstr "Minimala avståndet mellan lagring och läsning som kan vara i konflikt" +msgstr "Minimala avståndet mellan lagring och laddning som kan vara i konflikt." #: params.def:651 #, no-c-format @@ -2125,448 +2063,374 @@ msgid "Hardware autoprefetcher scheduler model control flag. Number of lookahea msgstr "Styrflagga för schemaläggningsmodell av automatisk förhandshämtning i hårdvara. Antalet cykler av framförhållning modellen tittar in i; vid ”0” aktiveras endast heuristik för instruktionssortering. Avaktiverat som standard." #: params.def:656 -#, fuzzy, no-c-format -#| msgid "The maximum number of RTL nodes that can be recorded as combiner's last value" +#, no-c-format msgid "The maximum number of RTL nodes that can be recorded as combiner's last value." -msgstr "Det maximala antalet RTL-noder som kan noteras som kombinerarens sista värde" +msgstr "Det maximala antalet RTL-noder som kan noteras som kombinerarens sista värde." #: params.def:661 -#, fuzzy, no-c-format -#| msgid "The maximum number of insns combine tries to combine" +#, no-c-format msgid "The maximum number of insns combine tries to combine." -msgstr "Det maximala antalet instruktionskombinationsförsök att kombinera" +msgstr "Det maximala antalet instruktionskombinationsförsök att kombinera." #: params.def:670 -#, fuzzy, no-c-format -#| msgid "The upper bound for sharing integer constants" +#, no-c-format msgid "The upper bound for sharing integer constants." -msgstr "Övre gränsen för att dela heltalskonstanter" +msgstr "Övre gränsen för att dela heltalskonstanter." #: params.def:675 -#, fuzzy, no-c-format -#| msgid "The lower bound for a buffer to be considered for stack smashing protection" +#, no-c-format msgid "The lower bound for a buffer to be considered for stack smashing protection." -msgstr "Den undre gränsen för att en buffer skall övervägas för skydd mot stacksprängning" +msgstr "Den undre gränsen för att en buffer skall övervägas för skydd mot stacksprängning." #: params.def:680 -#, fuzzy, no-c-format -#| msgid "The minimum size of variables taking part in stack slot sharing when not optimizing" +#, no-c-format msgid "The minimum size of variables taking part in stack slot sharing when not optimizing." -msgstr "Minsta storleken på variabler som är med i stackutrymmesdelning utan optimering" +msgstr "Minsta storleken på variabler som är med i stackutrymmesdelning utan optimering." #: params.def:699 -#, fuzzy, no-c-format -#| msgid "Maximum number of statements allowed in a block that needs to be duplicated when threading jumps" +#, no-c-format msgid "Maximum number of statements allowed in a block that needs to be duplicated when threading jumps." -msgstr "Maximalt antal satser som tillåts i ett block som behöver dubbleras när hopp trådas" +msgstr "Maximalt antal satser som tillåts i ett block som behöver dubbleras när hopp trådas." #: params.def:708 -#, fuzzy, no-c-format -#| msgid "Maximum number of fields in a structure before pointer analysis treats the structure as a single variable" +#, no-c-format msgid "Maximum number of fields in a structure before pointer analysis treats the structure as a single variable." -msgstr "Maximalt antal fält i en post före pekaranalys behandlar posten som en enda variabel" +msgstr "Maximalt antal fält i en post före pekaranalys behandlar posten som en enda variabel." #: params.def:713 -#, fuzzy, no-c-format -#| msgid "The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass" +#, no-c-format msgid "The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass." -msgstr "Det maximala antalet instruktioner redo att matas ut för att övervägas under det första schemaläggningspasset" +msgstr "Det maximala antalet instruktioner redo att matas ut för att övervägas under det första schemaläggningspasset." #: params.def:719 -#, fuzzy, no-c-format -#| msgid "Maximum number of active local stores in RTL dead store elimination" +#, no-c-format msgid "Maximum number of active local stores in RTL dead store elimination." -msgstr "Maximalt antal aktiva lokala lagringar i RTL vid eliminering av döda lagringar" +msgstr "Maximalt antal aktiva lokala lagringar i RTL vid eliminering av döda lagringar." #: params.def:729 -#, fuzzy, no-c-format -#| msgid "The number of insns executed before prefetch is completed" +#, no-c-format msgid "The number of insns executed before prefetch is completed." -msgstr "Antalet instruktioner som körs före förhandshämtning (prefetch) är klar" +msgstr "Antalet instruktioner som körs före förhandshämtning (prefetch) är klar." #: params.def:736 -#, fuzzy, no-c-format -#| msgid "The number of prefetches that can run at the same time" +#, no-c-format msgid "The number of prefetches that can run at the same time." -msgstr "Antalet förhandshämtningar (prefetch) som kan vara igång samtidigt" +msgstr "Antalet förhandshämtningar (prefetch) som kan vara igång samtidigt." #: params.def:743 -#, fuzzy, no-c-format -#| msgid "The size of L1 cache" +#, no-c-format msgid "The size of L1 cache." -msgstr "Storleken på L1-cachen" +msgstr "Storleken på L1-cachen." #: params.def:750 -#, fuzzy, no-c-format -#| msgid "The size of L1 cache line" +#, no-c-format msgid "The size of L1 cache line." -msgstr "Storleken på cache-raderna i L1" +msgstr "Storleken på cache-raderna i L1." #: params.def:757 -#, fuzzy, no-c-format -#| msgid "The size of L2 cache" +#, no-c-format msgid "The size of L2 cache." -msgstr "Storleken på L2-cachen" +msgstr "Storleken på L2-cachen." #: params.def:768 -#, fuzzy, no-c-format -#| msgid "Whether to use canonical types" +#, no-c-format msgid "Whether to use canonical types." -msgstr "Om kanoniska typer skall användas" +msgstr "Om kanoniska typer skall användas." #: params.def:773 -#, fuzzy, no-c-format -#| msgid "Maximum length of partial antic set when performing tree pre optimization" +#, no-c-format msgid "Maximum length of partial antic set when performing tree pre optimization." -msgstr "Maximal längd på partial förväntansmängd när föroptimeringar på träd görs" +msgstr "Maximal längd på partial förväntansmängd när föroptimeringar på träd görs." #: params.def:783 -#, fuzzy, no-c-format -#| msgid "Maximum size of a SCC before SCCVN stops processing a function" +#, no-c-format msgid "Maximum size of a SCC before SCCVN stops processing a function." -msgstr "Maximal storlek på en SCC före SCCVN slutar bearbeta en funktion" +msgstr "Maximal storlek på en SCC före SCCVN slutar bearbeta en funktion." #: params.def:794 -#, fuzzy, no-c-format -#| msgid "Maximum number of disambiguations to perform per memory access" +#, no-c-format msgid "Maximum number of disambiguations to perform per memory access." -msgstr "Maximalt antal upplösningar av tvetydigheter att utföra per minnesåtkomst" +msgstr "Maximalt antal upplösningar av tvetydigheter att utföra per minnesåtkomst." #: params.def:799 -#, fuzzy, no-c-format -#| msgid "Max loops number for regional RA" +#, no-c-format msgid "Max loops number for regional RA." -msgstr "Maximalt slingantal för regional RA" +msgstr "Maximalt slingantal för regional RA." #: params.def:804 -#, fuzzy, no-c-format -#| msgid "Max size of conflict table in MB" +#, no-c-format msgid "Max size of conflict table in MB." -msgstr "Maximal storlek på konflikttabell i MB" +msgstr "Maximal storlek på konflikttabell i MB." #: params.def:809 -#, fuzzy, no-c-format -#| msgid "The number of registers in each class kept unused by loop invariant motion" +#, no-c-format msgid "The number of registers in each class kept unused by loop invariant motion." -msgstr "Antalet register i varje klass som behålls oanvänt vid flyttning av slinginvariant" +msgstr "Antalet register i varje klass som behålls oanvänt vid flyttning av slinginvariant." #: params.def:814 -#, fuzzy, no-c-format -#| msgid "The max number of reload pseudos which are considered during spilling a non-reload pseudo" +#, no-c-format msgid "The max number of reload pseudos which are considered during spilling a non-reload pseudo." -msgstr "Maximalt antal omläsningar av pseudoregister som övervägs när ett icke-omläst pseudoregister spills" +msgstr "Maximalt antal omläsningar av pseudoregister som övervägs när ett icke-omläst pseudoregister spills." #: params.def:819 -#, fuzzy, no-c-format -#| msgid "Minimal fall-through edge probability in percentage used to add BB to inheritance EBB in LRA" +#, no-c-format msgid "Minimal fall-through edge probability in percentage used to add BB to inheritance EBB in LRA." -msgstr "Minimal sannolikhet för bågar att falla igenom i procent som används för att lägga till GB till arvs-EBB i LRA" +msgstr "Minimal sannolikhet för bågar att falla igenom i procent som används för att lägga till GB till arvs-EBB i LRA." #: params.def:827 -#, fuzzy, no-c-format -#| msgid "The maximum ratio between array size and switch branches for a switch conversion to take place" +#, no-c-format msgid "The maximum ratio between array size and switch branches for a switch conversion to take place." -msgstr "Det maximala förhållandet mellan vektorstorlek och switch-grenar för att en switch-konvertering skall ske" +msgstr "Det maximala förhållandet mellan vektorstorlek och switch-grenar för att en switch-konvertering skall ske." #: params.def:835 -#, fuzzy, no-c-format -#| msgid "size of tiles for loop blocking" +#, no-c-format msgid "size of tiles for loop blocking." -msgstr "storlek på bitar för slingblockning" +msgstr "storlek på bitar för slingblockning." #: params.def:842 -#, fuzzy, no-c-format -#| msgid "maximum number of parameters in a SCoP" +#, no-c-format msgid "maximum number of parameters in a SCoP." -msgstr "maximalt antal parameter i en SCoP" +msgstr "maximalt antal parameter i en SCoP." #: params.def:849 -#, fuzzy, no-c-format -#| msgid "maximum number of basic blocks per function to be analyzed by Graphite" +#, no-c-format msgid "maximum number of basic blocks per function to be analyzed by Graphite." -msgstr "maximalt antal grundblock per funktion att analyseras av Graphite" +msgstr "maximalt antal grundblock per funktion att analyseras av Graphite." #: params.def:856 -#, fuzzy, no-c-format -#| msgid "maximum number of parameters in a SCoP" +#, no-c-format msgid "maximum number of arrays per scop." -msgstr "maximalt antal parameter i en SCoP" +msgstr "maximalt antal vektorer per scop." #: params.def:863 -#, fuzzy, no-c-format -#| msgid "maximum number of basic blocks per function to be analyzed by Graphite" +#, no-c-format msgid "minimal number of loops per function to be analyzed by Graphite." -msgstr "maximalt antal grundblock per funktion att analyseras av Graphite" +msgstr "maximalt antal slingor per funktion att analyseras av Graphite." #: params.def:868 -#, fuzzy, no-c-format -#| msgid "The maximum number of insns of an unswitched loop" +#, no-c-format msgid "maximum number of isl operations, 0 means unlimited" -msgstr "Det maximala antalet instruktioner i en oväxlad slinga" +msgstr "maximala antalet isl-operationer, 0 betyder obegränsat" #: params.def:874 -#, fuzzy, no-c-format -#| msgid "Maximum number of datarefs in loop for building loop data dependencies" +#, no-c-format msgid "Maximum number of datarefs in loop for building loop data dependencies." -msgstr "Maximalt antal datareferenser i en slinga för att bygga slingdataberoenden" +msgstr "Maximalt antal datareferenser i en slinga för att bygga slingdataberoenden." #: params.def:881 -#, fuzzy, no-c-format -#| msgid "Max basic blocks number in loop for loop invariant motion" +#, no-c-format msgid "Max basic blocks number in loop for loop invariant motion." -msgstr "Maximalt antal grundblock i slinga-för-slinga-invarianta förflyttningar" +msgstr "Maximalt antal grundblock i slinga-för-slinga-invarianta förflyttningar." #: params.def:889 -#, fuzzy, no-c-format -#| msgid "use internal function id in profile lookup" +#, no-c-format msgid "use internal function id in profile lookup." -msgstr "använd internt funktions-id i profileringsuppslagningar" +msgstr "använd internt funktions-id i profileringsuppslagningar." #: params.def:897 -#, fuzzy, no-c-format -#| msgid "track topn target addresses in indirect-call profile" +#, no-c-format msgid "track topn target addresses in indirect-call profile." -msgstr "spåra topn måladresser i indirekt-anropsprofil" +msgstr "spåra topn måladresser i indirekt-anropsprofil." #: params.def:903 -#, fuzzy, no-c-format -#| msgid "Maximum number of instructions in basic block to be considered for SLP vectorization" +#, no-c-format msgid "Maximum number of instructions in basic block to be considered for SLP vectorization." -msgstr "Det maximala antalet instruktioner i grundblock för beaktas för SLP-vektorisering" +msgstr "Det maximala antalet instruktioner i grundblock för beaktas för SLP-vektorisering." #: params.def:908 -#, fuzzy, no-c-format -#| msgid "Min. ratio of insns to prefetches to enable prefetching for a loop with an unknown trip count" +#, no-c-format msgid "Min. ratio of insns to prefetches to enable prefetching for a loop with an unknown trip count." -msgstr "Minsta förhållande av instruktioner till minnesoperationer för att aktivera förhandshämtning (prefetching) för en slinga med okänt antal turer" +msgstr "Minsta förhållande av instruktioner till minnesoperationer för att aktivera förhandshämtning (prefetching) för en slinga med okänt antal turer." #: params.def:914 -#, fuzzy, no-c-format -#| msgid "Min. ratio of insns to mem ops to enable prefetching in a loop" +#, no-c-format msgid "Min. ratio of insns to mem ops to enable prefetching in a loop." -msgstr "Minsta förhållande av instruktioner till minnesoperationer för att aktivera förhandshämtning (prefetching) i en slinga" +msgstr "Minsta förhållande av instruktioner till minnesoperationer för att aktivera förhandshämtning (prefetching) i en slinga." #: params.def:921 -#, fuzzy, no-c-format -#| msgid "Max. size of var tracking hash tables" +#, no-c-format msgid "Max. size of var tracking hash tables." -msgstr "Max storlek på hashtabell för variabelspårning" +msgstr "Max storlek på hashtabell för variabelspårning." #: params.def:929 -#, fuzzy, no-c-format -#| msgid "Max. recursion depth for expanding var tracking expressions" +#, no-c-format msgid "Max. recursion depth for expanding var tracking expressions." -msgstr "Maximalt rekursionsdjup för att expandera variabelspårningsuttryck" +msgstr "Maximalt rekursionsdjup för att expandera variabelspårningsuttryck." #: params.def:937 -#, fuzzy, no-c-format -#| msgid "Max. size of loc list for which reverse ops should be added" +#, no-c-format msgid "Max. size of loc list for which reverse ops should be added." -msgstr "Maximal storlek på loc-listan för vilken omvända operationer skall läggas till" +msgstr "Maximal storlek på loc-listan för vilken omvända operationer skall läggas till." #: params.def:944 -#, fuzzy, no-c-format -#| msgid "The minimum UID to be used for a nondebug insn" +#, no-c-format msgid "The minimum UID to be used for a nondebug insn." -msgstr "Minsta UID som får användas för en icke-felsökningsinstruktion" +msgstr "Minsta UID som får användas för en icke-felsökningsinstruktion." #: params.def:949 -#, fuzzy, no-c-format -#| msgid "Maximum allowed growth of size of new parameters ipa-sra replaces a pointer to an aggregate with" +#, no-c-format msgid "Maximum allowed growth of size of new parameters ipa-sra replaces a pointer to an aggregate with." -msgstr "Största tillåtna storleksökning för nya parametrar som ipa-sra ersätter en pekare till ett aggregat med" +msgstr "Största tillåtna storleksökning för nya parametrar som ipa-sra ersätter en pekare till ett aggregat med." #: params.def:955 -#, fuzzy, no-c-format -#| msgid "Size in bytes after which thread-local aggregates should be instrumented with the logging functions instead of save/restore pairs" +#, no-c-format msgid "Size in bytes after which thread-local aggregates should be instrumented with the logging functions instead of save/restore pairs." -msgstr "Storlek i byte efter vilken trådlokala aggregat skall instrumenteras med loggningsfunktioner istället för spara/återställ-par" +msgstr "Storlek i byte efter vilken trådlokala aggregat skall instrumenteras med loggningsfunktioner istället för spara/återställ-par." #: params.def:962 -#, fuzzy, no-c-format -#| msgid "Maximum size, in storage units, of an aggregate which should be considered for scalarization when compiling for speed" +#, no-c-format msgid "Maximum size, in storage units, of an aggregate which should be considered for scalarization when compiling for speed." -msgstr "Maximal storlek, i lagringsenheter, av ett aggregat som skall övervägas för skalärisering vid kompilering för hastighet" +msgstr "Maximal storlek, i lagringsenheter, av ett aggregat som skall övervägas för skalärisering vid kompilering för hastighet." #: params.def:968 -#, fuzzy, no-c-format -#| msgid "Maximum size, in storage units, of an aggregate which should be considered for scalarization when compiling for size" +#, no-c-format msgid "Maximum size, in storage units, of an aggregate which should be considered for scalarization when compiling for size." -msgstr "Maximal storlek, i lagringsenheter, av ett aggregat som skall övervägas för skalärisering vid kompilering för storlek" +msgstr "Maximal storlek, i lagringsenheter, av ett aggregat som skall övervägas för skalärisering vid kompilering för storlek." #: params.def:974 -#, fuzzy, no-c-format -#| msgid "Maximum size of a list of values associated with each parameter for interprocedural constant propagation" +#, no-c-format msgid "Maximum size of a list of values associated with each parameter for interprocedural constant propagation." -msgstr "Maximal storlek för en lista på värden associerad med varje parameter för konstantpropagering mellan procedurer" +msgstr "Maximal storlek för en lista på värden associerad med varje parameter för konstantpropagering mellan procedurer." #: params.def:980 -#, fuzzy, no-c-format -#| msgid "Threshold ipa-cp opportunity evaluation that is still considered beneficial to clone." +#, no-c-format msgid "Threshold ipa-cp opportunity evaluation that is still considered beneficial to clone.." msgstr "Tröskelvärde för ipa-cp-tillfällesberäkning som fortfarande betraktas som fördelaktig att klona." #: params.def:986 -#, fuzzy, no-c-format -#| msgid "Percentage penalty the recursive functions will receive when they are evaluated for cloning." +#, no-c-format msgid "Percentage penalty the recursive functions will receive when they are evaluated for cloning.." msgstr "Procentuellt straff de rekursiva funktionerna kommer få när de utvärderas för kloning." #: params.def:992 -#, fuzzy, no-c-format -#| msgid "Percentage penalty functions containg a single call to another function will receive when they are evaluated for cloning." +#, no-c-format msgid "Percentage penalty functions containg a single call to another function will receive when they are evaluated for cloning.." msgstr "Procentuellt straff funktioner som innehåller ett ensamt anrop av en annan funktion kommer få när de utvärderas för kloning." #: params.def:998 -#, fuzzy, no-c-format -#| msgid "Maximum number of aggregate content items for a parameter in jump functions and lattices" +#, no-c-format msgid "Maximum number of aggregate content items for a parameter in jump functions and lattices." -msgstr "Maximalt antal av sammansatta innehållsposter för en parameter i hoppfunktioner och gitter" +msgstr "Maximalt antal av sammansatta innehållsposter för en parameter i hoppfunktioner och gitter." #: params.def:1004 -#, fuzzy, no-c-format -#| msgid "Compile-time bonus IPA-CP assigns to candidates which make loop bounds or strides known." +#, no-c-format msgid "Compile-time bonus IPA-CP assigns to candidates which make loop bounds or strides known.." msgstr "Bonus IPA-CP tilldelar vid kompileringstillfället till kandidater vilka gör slingbegränsningar eller -steg kända." #: params.def:1010 -#, fuzzy, no-c-format -#| msgid "Compile-time bonus IPA-CP assigns to candidates which make an array index known." +#, no-c-format msgid "Compile-time bonus IPA-CP assigns to candidates which make an array index known.." msgstr "Bonus IPA-CP tilldelar vid kompileringstillfället till kandidater som gör ett vektorindex känt." #: params.def:1016 -#, fuzzy, no-c-format -#| msgid "Maximum number of statements that will be visited by IPA formal parameter analysis based on alias analysis in any given function" +#, no-c-format msgid "Maximum number of statements that will be visited by IPA formal parameter analysis based on alias analysis in any given function." -msgstr "Maximalt antal satser som kommer besökas av IPA-formatparameteranalysen baserat på aliasanalys i varje given funktion" +msgstr "Maximalt antal satser som kommer besökas av IPA-formatparameteranalysen baserat på aliasanalys i varje given funktion." #: params.def:1024 -#, fuzzy, no-c-format -#| msgid "Number of partitions the program should be split to" +#, no-c-format msgid "Number of partitions the program should be split to." -msgstr "Antal partitioner programmet skall delas upp i" +msgstr "Antal partitioner programmet skall delas upp i." #: params.def:1029 -#, fuzzy, no-c-format -#| msgid "Minimal size of a partition for LTO (in estimated instructions)" +#, no-c-format msgid "Minimal size of a partition for LTO (in estimated instructions)." -msgstr "Minimal storlek på en partition för LTO (i uppskattade instruktioner)" +msgstr "Minimal storlek på en partition för LTO (i uppskattade instruktioner)." #: params.def:1036 -#, fuzzy, no-c-format -#| msgid "Maximum number of namespaces to search for alternatives when name lookup fails" +#, no-c-format msgid "Maximum number of namespaces to search for alternatives when name lookup fails." -msgstr "Det maximala antalet namnrymder att söka i för alternativ när namnuppslagning misslyckas" +msgstr "Det maximala antalet namnrymder att söka i för alternativ när namnuppslagning misslyckas." #: params.def:1043 -#, fuzzy, no-c-format -#| msgid "Maximum number of conditional store pairs that can be sunk" +#, no-c-format msgid "Maximum number of conditional store pairs that can be sunk." -msgstr "Maximalt antal villkorliga lagringspar som kan sänkas" +msgstr "Maximalt antal villkorliga lagringspar som kan sänkas." #: params.def:1051 -#, fuzzy, no-c-format -#| msgid "The smallest number of different values for which it is best to use a jump-table instead of a tree of conditional branches, if 0, use the default for the machine" +#, no-c-format msgid "The smallest number of different values for which it is best to use a jump-table instead of a tree of conditional branches, if 0, use the default for the machine." -msgstr "Det minsta antalet olika värden för vilka det är bäst att använda hopptabeller istället för ett träd med villkorliga grenar, om 0, använd standardvärdet för maskinen" +msgstr "Det minsta antalet olika värden för vilka det är bäst att använda hopptabeller istället för ett träd med villkorliga grenar, om 0, använd standardvärdet för maskinen." #: params.def:1059 -#, fuzzy, no-c-format -#| msgid "Allow new data races on stores to be introduced" +#, no-c-format msgid "Allow new data races on stores to be introduced." -msgstr "Tillåt att nya datakapplöpningar vid lagringar introduceras" +msgstr "Tillåt att nya datakapplöpningar vid lagringar introduceras." #: params.def:1065 -#, fuzzy, no-c-format -#| msgid "Set the maximum number of instructions executed in parallel in reassociated tree. If 0, use the target dependent heuristic." +#, no-c-format msgid "Set the maximum number of instructions executed in parallel in reassociated tree. If 0, use the target dependent heuristic.." msgstr "Sätt maximala antalet instruktioner som exekveras parallellt i ett reassociativt träd. Om 0, använd den målberoende heuristiken." #: params.def:1071 -#, fuzzy, no-c-format -#| msgid "Maximum amount of similar bbs to compare a bb with" +#, no-c-format msgid "Maximum amount of similar bbs to compare a bb with." -msgstr "Maximalt antal liknande gb att jämföra ett gb med" +msgstr "Maximalt antal liknande gb att jämföra ett gb med." #: params.def:1076 -#, fuzzy, no-c-format -#| msgid "Maximum amount of iterations of the pass over a function" +#, no-c-format msgid "Maximum amount of iterations of the pass over a function." -msgstr "Maximalt antal iterationer för passet över en funktion" +msgstr "Maximalt antal iterationer för passet över en funktion." #: params.def:1083 -#, fuzzy, no-c-format -#| msgid "Maximum number of strings for which strlen optimization pass will track string lengths" +#, no-c-format msgid "Maximum number of strings for which strlen optimization pass will track string lengths." -msgstr "Maximalt antal strängar för vilket strlen-optimeringspasset kommer följa stränglängder" +msgstr "Maximalt antal strängar för vilket strlen-optimeringspasset kommer följa stränglängder." #: params.def:1090 -#, fuzzy, no-c-format -#| msgid "Which -fsched-pressure algorithm to apply" +#, no-c-format msgid "Which -fsched-pressure algorithm to apply." -msgstr "Vilken -fsched-pressure-algoritm som skall användas" +msgstr "Vilken -fsched-pressure-algoritm som skall användas." #: params.def:1096 -#, fuzzy, no-c-format -#| msgid "Maximum length of candidate scans for straight-line strength reduction" +#, no-c-format msgid "Maximum length of candidate scans for straight-line strength reduction." -msgstr "Maximal längd på kandidatskanningar efter rätlinjiga styrkereduktioner" +msgstr "Maximal längd på kandidatskanningar efter rätlinjiga styrkereduktioner." #: params.def:1102 -#, fuzzy, no-c-format -#| msgid "Enable asan stack protection" +#, no-c-format msgid "Enable asan stack protection." -msgstr "Aktivera asan-skydd av stack" +msgstr "Aktivera asan-skydd av stack." #: params.def:1107 -#, fuzzy, no-c-format -#| msgid "Enable asan globals protection" +#, no-c-format msgid "Enable asan globals protection." -msgstr "Aktivera globalt asan-skydd" +msgstr "Aktivera globalt asan-skydd." #: params.def:1112 -#, fuzzy, no-c-format -#| msgid "Enable asan store operations protection" +#, no-c-format msgid "Enable asan store operations protection." -msgstr "Aktivera asan-skydd av lagringsoperationer" +msgstr "Aktivera asan-skydd av lagringsoperationer." #: params.def:1117 -#, fuzzy, no-c-format -#| msgid "Enable asan load operations protection" +#, no-c-format msgid "Enable asan load operations protection." -msgstr "Aktivera asan-skydd av laddningsoperationer" +msgstr "Aktivera asan-skydd av laddningsoperationer." #: params.def:1122 -#, fuzzy, no-c-format -#| msgid "Enable asan builtin functions protection" +#, no-c-format msgid "Enable asan builtin functions protection." -msgstr "Aktivera asan-skydd av inbyggda funktioner" +msgstr "Aktivera asan-skydd av inbyggda funktioner." #: params.def:1127 -#, fuzzy, no-c-format -#| msgid "Enable asan detection of use-after-return bugs" +#, no-c-format msgid "Enable asan detection of use-after-return bugs." -msgstr "Aktivera asan-detektering av använd-efter-retur-fel" +msgstr "Aktivera asan-detektering av använd-efter-retur-fel." #: params.def:1132 -#, fuzzy, no-c-format -#| msgid "Use callbacks instead of inline code if number of accesses in function becomes greater or equal to this number" +#, no-c-format msgid "Use callbacks instead of inline code if number of accesses in function becomes greater or equal to this number." -msgstr "Använd återanrop istället för inline:ad kod om antalet åtkomster i funktioner blir större eller lika med detta tal" +msgstr "Använd återanrop istället för inline:ad kod om antalet åtkomster i funktioner blir större eller lika med detta tal." #: params.def:1138 -#, fuzzy, no-c-format -#| msgid "Maximum number of nested calls to search for control dependencies during uninitialized variable analysis" +#, no-c-format msgid "Maximum number of nested calls to search for control dependencies during uninitialized variable analysis." -msgstr "Det maximala antalet nästade anrop att söka i efter styrberoenden under analys av oinitierade variabler" +msgstr "Det maximala antalet nästade anrop att söka i efter styrberoenden under analys av oinitierade variabler." #: params.def:1144 -#, fuzzy, no-c-format -#| msgid "Maximum number of statements to be included into a single static constructor generated by Pointer Bounds Checker" +#, no-c-format msgid "Maximum number of statements to be included into a single static constructor generated by Pointer Bounds Checker." -msgstr "Maximalt antal satser som skall inkluderas i en enskild statisk konstruerare genererad av pekargränskontrolleraren" +msgstr "Maximalt antal satser som skall inkluderas i en enskild statisk konstruerare genererad av pekargränskontrolleraren." #: params.def:1150 #, no-c-format @@ -2579,22 +2443,19 @@ msgid "Scale factor to apply to the number of blocks in a threading path when co msgstr "Skalfaktor att använda på antalet block i en trådningsväg vid jämförelse med antalet av (skalade) satser." #: params.def:1160 -#, fuzzy, no-c-format -#| msgid "Maximum number of instructions to copy when duplicating blocks on a finite state automaton jump thread path" +#, no-c-format msgid "Maximum number of instructions to copy when duplicating blocks on a finite state automaton jump thread path." -msgstr "Maximalt antal instruktioner att kopiera vid duplicering av block på hopptrådvägen för en ändlig tillståndsmaskin" +msgstr "Maximalt antal instruktioner att kopiera vid duplicering av block på hopptrådvägen för en ändlig tillståndsmaskin." #: params.def:1165 -#, fuzzy, no-c-format -#| msgid "Maximum number of basic blocks on a finite state automaton jump thread path" +#, no-c-format msgid "Maximum number of basic blocks on a finite state automaton jump thread path." -msgstr "Maximalt antal grundblock i en ändlig tillståndsmaskins hopptrådsvägar" +msgstr "Maximalt antal grundblock i en ändlig tillståndsmaskins hopptrådsvägar." #: params.def:1170 -#, fuzzy, no-c-format -#| msgid "Maximum number of new jump thread paths to create for a finite state automaton" +#, no-c-format msgid "Maximum number of new jump thread paths to create for a finite state automaton." -msgstr "Det maximala antalet nya hopptrådvägar att skapa för en ändlig tillståndsmaskin" +msgstr "Det maximala antalet nya hopptrådvägar att skapa för en ändlig tillståndsmaskin." #: params.def:1175 #, no-c-format @@ -2612,10 +2473,9 @@ msgid "Maximum recursion depth allowed when querying a property of an SSA name." msgstr "Maximalt tillåtet rekursionsdjup när en egenskap efterfrågas från ett SSA-namn." #: params.def:1193 -#, fuzzy, no-c-format -#| msgid "Maximum number of instructions in basic block to be considered for SLP vectorization" +#, no-c-format msgid "Maximum number of insns in a basic block to consider for RTL if-conversion." -msgstr "Det maximala antalet instruktioner i grundblock för beaktas för SLP-vektorisering" +msgstr "Det maximala antalet instruktioner i grundblock att beaktas för RTL if-konvertering." #: params.def:1199 #, no-c-format @@ -3508,10 +3368,9 @@ msgid "unknown insn mode" msgstr "okänt instruktionsläge" #: config/i386/djgpp.h:146 -#, fuzzy, c-format -#| msgid "-f%s not supported: ignored" +#, c-format msgid "-f%s ignored (not supported for DJGPP)\n" -msgstr "-f%s stödjs inte: ignoreras" +msgstr "-f%s ignoreras (stödjs inte för DJGPP)\n" #: config/i386/i386-interix.h:77 msgid "Use native (MS) bitfield layout" @@ -3562,7 +3421,7 @@ msgstr "ogiltig användning av %%d, %%x eller %%x" #: config/lm32/lm32.c:507 #, c-format msgid "only 0.0 can be loaded as an immediate" -msgstr "endast 0.0 kan läsas in som en omedelbar" +msgstr "endast 0.0 kan laddas som en omedelbar" #: config/lm32/lm32.c:577 msgid "bad operand" @@ -3775,10 +3634,8 @@ msgid "-mquad-memory is not available in little endian mode" msgstr "-mquad-memory är inte tillgängligt i läget med omvänd byteordning" #: config/rs6000/rs6000.c:4154 -#, fuzzy -#| msgid "-mquad-memory requires 64-bit mode" msgid "-mtoc-fusion requires 64-bit" -msgstr "--mquad-memory kräver 64-bitarsläge" +msgstr "--mtoc-fusion kräver 64-bitar" #: config/rs6000/rs6000.c:4161 msgid "-mtoc-fusion requires medium/large code model" @@ -3872,10 +3729,8 @@ msgid "__float128 and __ibm128 cannot be used in the same expression" msgstr "__float128 och __ibm128 kan inte användas i samma uttryck" #: config/rs6000/rs6000.c:20899 -#, fuzzy -#| msgid "Cilk array notation cannot be used for a throw expression" msgid "__ibm128 and long double cannot be used in the same expression" -msgstr "Cilk-vektornotation kan inte användas till ett throw-uttryck" +msgstr "__ibm128 och long double inte användas i samma uttryck" #: config/rs6000/rs6000.c:20905 msgid "__float128 and long double cannot be used in the same expression" @@ -3890,10 +3745,8 @@ msgid "Could not generate addis value for fusion" msgstr "Kunde inte generera addis-värde för sammanslagning" #: config/rs6000/rs6000.c:36058 -#, fuzzy -#| msgid "Unable to generate load offset for fusion" msgid "Unable to generate load/store offset for fusion" -msgstr "Kan inte generera laddningsavstånd för sammanslagning" +msgstr "Kan inte generera ladda/lagra-avstånd för sammanslagning" #: config/rs6000/rs6000.c:36162 msgid "Bad GPR fusion" @@ -3984,10 +3837,9 @@ msgid "invalid constant - try using an output modifier" msgstr "ogiltig konstant - försök med att använda en utmatningsmodifierare" #: config/s390/s390.c:7343 -#, fuzzy, c-format -#| msgid "invalid constant for output modifier '%c'" +#, c-format msgid "invalid constant vector for output modifier '%c'" -msgstr "ogiltig konstant för utmatningsmodifieraren ”%c”" +msgstr "ogiltig konstant vektor för utmatningsmodifieraren ”%c”" #: config/s390/s390.c:7350 #, c-format @@ -4000,26 +3852,20 @@ msgid "invalid expression for output modifier '%c'" msgstr "ogiltigt uttryck för utmatningsmodifieraren ”%c”" #: config/s390/s390.c:11001 -#, fuzzy -#| msgid "AltiVec argument passed to unprototyped function" msgid "Vector argument passed to unprototyped function" -msgstr "AltiVec-argument skickat till funktion utan prototyp" +msgstr "Vektorargument skickat till funktion utan prototyp" #: config/s390/s390.c:14505 -#, fuzzy -#| msgid "pointer targets in return differ in signedness" msgid "types differ in signess" -msgstr "pekarmål i retur skiljer i teckenhet" +msgstr "typer skiljer i teckenhet" #: config/s390/s390.c:14515 msgid "binary operator does not support two vector bool operands" msgstr "binäroperator stödjer inte två vektorbooleanoperander" #: config/s390/s390.c:14518 -#, fuzzy -#| msgid "Your target platform does not support -fcheck-pointer-bounds" msgid "binary operator does not support vector bool operand" -msgstr "Din målplattform stödjer inte -fcheck-pointer-bounds" +msgstr "den binära operatorn stödjer inte vektor-bool-operand" #: config/s390/s390.c:14526 msgid "binary operator does not support mixing vector bool with floating point vector operands" @@ -4084,8 +3930,7 @@ msgid "invalid %%s operand" msgstr "ogiltig %%s-operand" #: config/sparc/sparc.c:8934 -#, fuzzy, c-format -#| msgid "floating point constant not a valid immediate operand" +#, c-format msgid "floating-point constant not a valid immediate operand" msgstr "flyttalskonstant inte en giltig omedelbar operand" @@ -4643,16 +4488,12 @@ msgid "required from %q#D\n" msgstr "begärs från %q#D\n" #: cp/error.c:3368 -#, fuzzy -#| msgid "recursively required from here" msgid "recursively required from here\n" -msgstr "rekursivt begärd härifrån" +msgstr "rekursivt begärd härifrån\n" #: cp/error.c:3369 -#, fuzzy -#| msgid "required from here" msgid "required from here\n" -msgstr "begärd härifrån" +msgstr "begärd härifrån\n" #: cp/error.c:3421 msgid "%r%s:%d:%d:%R [ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n" @@ -4869,10 +4710,8 @@ msgid "Nonnegative width required" msgstr "Ickenegativ bredd krävs" #: fortran/io.c:552 -#, fuzzy -#| msgid "Unexpected element %<%c%> in format string at %L" msgid "Unexpected element %qc in format string at %L" -msgstr "Oväntat element %<%c%> i formatsträng vid %L" +msgstr "Oväntat element %qc i formatsträng vid %L" #: fortran/io.c:554 msgid "Unexpected end of format string" @@ -5140,16 +4979,14 @@ msgid "Invalid context for NULL() pointer at %%L" msgstr "Ogiltigt sammanhang för NULL()-pekare vid %%L" #: fortran/resolve.c:3568 -#, fuzzy, c-format -#| msgid "Operand of unary numeric operator '%s' at %%L is %s" +#, c-format msgid "Operand of unary numeric operator %%<%s%%> at %%L is %s" -msgstr "Operand till unär numerisk operator ”%s” vid %%L är %s" +msgstr "Operand till unär numerisk operator %%<%s%%> vid %%L är %s" #: fortran/resolve.c:3584 -#, fuzzy, c-format -#| msgid "Operands of binary numeric operator '%s' at %%L are %s/%s" +#, c-format msgid "Operands of binary numeric operator %%<%s%%> at %%L are %s/%s" -msgstr "Operander till binär numerisk operator ”%s” vid %%L är %s/%s" +msgstr "Operander till binär numerisk operator %%<%s%%> vid %%L är %s/%s" #: fortran/resolve.c:3599 #, c-format @@ -5157,10 +4994,9 @@ msgid "Operands of string concatenation operator at %%L are %s/%s" msgstr "Operanderna till strängkonkateneringsoperatorn vid %%L är %s/%s" #: fortran/resolve.c:3618 -#, fuzzy, c-format -#| msgid "Operands of logical operator '%s' at %%L are %s/%s" +#, c-format msgid "Operands of logical operator %%<%s%%> at %%L are %s/%s" -msgstr "Operanderna till logiska operatorn ”%s” vid %%L är %s/%s" +msgstr "Operanderna till logiska operatorn %%<%s%%> vid %%L är %s/%s" #: fortran/resolve.c:3632 #, c-format @@ -5177,28 +5013,24 @@ msgid "Logicals at %%L must be compared with %s instead of %s" msgstr "Logiska vid %%L måste jämföras med %s istället för %s" #: fortran/resolve.c:3703 -#, fuzzy, c-format -#| msgid "Operands of comparison operator '%s' at %%L are %s/%s" +#, c-format msgid "Operands of comparison operator %%<%s%%> at %%L are %s/%s" -msgstr "Operanderna till jämförelseoperatorn ”%s” vid %%L är %s/%s" +msgstr "Operanderna till jämförelseoperatorn %%<%s%%> vid %%L är %s/%s" #: fortran/resolve.c:3711 -#, fuzzy, c-format -#| msgid "Unknown operator '%s' at %%L" +#, c-format msgid "Unknown operator %%<%s%%> at %%L" -msgstr "Okänd operator ”%s” vid %%L" +msgstr "Okänd operator %%<%s%%> vid %%L" #: fortran/resolve.c:3714 -#, fuzzy, c-format -#| msgid "Operand of user operator '%s' at %%L is %s" +#, c-format msgid "Operand of user operator %%<%s%%> at %%L is %s" -msgstr "Operanderna till användaroperatorn ”%s” vid %%L är %s" +msgstr "Operanderna till användaroperatorn %%<%s%%> vid %%L är %s" #: fortran/resolve.c:3718 -#, fuzzy, c-format -#| msgid "Operands of user operator '%s' at %%L are %s/%s" +#, c-format msgid "Operands of user operator %%<%s%%> at %%L are %s/%s" -msgstr "Operanderna till användaroperatorn ”%s” vid %%L är %s/%s" +msgstr "Operanderna till användaroperatorn %%<%s%%> vid %%L är %s/%s" #: fortran/resolve.c:3806 #, c-format @@ -5611,20 +5443,16 @@ msgid "-c required for gnat2scil" msgstr "-c krävs för gnat2scil" #: config/sol2.h:181 -#, fuzzy -#| msgid "weakref is not supported in this configuration" msgid "-fvtable-verify is not supported in this configuration" -msgstr "weakref stödjs inte i denna konfiguration" +msgstr "-fvtable-verify stödjs inte i denna konfiguration" #: config/sol2.h:268 config/sol2.h:273 msgid "does not support multilib" msgstr "stödjer inte multilib" #: config/sol2.h:365 -#, fuzzy -#| msgid "-gz is not supported in this configuration" msgid "-pie is not supported in this configuration" -msgstr "-gz stödjs inte i denna konfiguration" +msgstr "-pie stödjs inte i denna konfiguration" #: config/darwin.h:251 msgid "-current_version only allowed with -dynamiclib" @@ -5812,218 +5640,148 @@ msgid "-femit-class-file should used along with -fsyntax-only" msgstr "-femit-class-file skall användas tillsammans med -fsyntax-only" #: fortran/lang.opt:146 -#, fuzzy -#| msgid "-J\tPut MODULE files in 'directory'" msgid "-J\tPut MODULE files in 'directory'." -msgstr "-J\tLägg MODULE-filer i ”katalog”" +msgstr "-J\tLägg MODULE-filer i ”katalog”." #: fortran/lang.opt:198 -#, fuzzy -#| msgid "Warn about possible aliasing of dummy arguments" msgid "Warn about possible aliasing of dummy arguments." -msgstr "Varna för eventuella attrappargumentalias" +msgstr "Varna för eventuella attrappargumentalias." #: fortran/lang.opt:202 -#, fuzzy -#| msgid "Warn about alignment of COMMON blocks" msgid "Warn about alignment of COMMON blocks." -msgstr "Varna för justering av COMMON-block" +msgstr "Varna för justering av COMMON-block." #: fortran/lang.opt:206 -#, fuzzy -#| msgid "Warn about missing ampersand in continued character constants" msgid "Warn about missing ampersand in continued character constants." -msgstr "Varna för saknade et-tecken i fortsatta teckenkonstanter" +msgstr "Varna för saknade et-tecken i fortsatta teckenkonstanter." #: fortran/lang.opt:210 -#, fuzzy -#| msgid "Warn about creation of array temporaries" msgid "Warn about creation of array temporaries." -msgstr "Varna om vektortemporärer skapas" +msgstr "Varna om vektortemporärer skapas." #: fortran/lang.opt:214 -#, fuzzy -#| msgid "Warn if the type of a variable might be not interoperable with C" msgid "Warn if the type of a variable might be not interoperable with C." -msgstr "Varna om typen på en variabel kanske inte är interoperabel med C" +msgstr "Varna om typen på en variabel kanske inte är interoperabel med C." #: fortran/lang.opt:222 -#, fuzzy -#| msgid "Warn about truncated character expressions" msgid "Warn about truncated character expressions." -msgstr "Varna för avhuggna teckenuttryck" +msgstr "Varna för avhuggna teckenuttryck." #: fortran/lang.opt:226 -#, fuzzy -#| msgid "Warn about equality comparisons involving REAL or COMPLEX expressions" msgid "Warn about equality comparisons involving REAL or COMPLEX expressions." -msgstr "Varna för likhetsjämförelser som involverar REAL- eller COMPLEX-uttryck" +msgstr "Varna för likhetsjämförelser som involverar REAL- eller COMPLEX-uttryck." #: fortran/lang.opt:234 -#, fuzzy -#| msgid "Warn about most implicit conversions" msgid "Warn about most implicit conversions." -msgstr "Varna för de flesta implicita konverteringar" +msgstr "Varna för de flesta implicita konverteringar." #: fortran/lang.opt:242 -#, fuzzy -#| msgid "Warn about function call elimination" msgid "Warn about function call elimination." -msgstr "Varna för eliminering av funktionsanrop" +msgstr "Varna för eliminering av funktionsanrop." #: fortran/lang.opt:246 -#, fuzzy -#| msgid "Warn about calls with implicit interface" msgid "Warn about calls with implicit interface." -msgstr "Varna för anrop med implicit gränssnitt" +msgstr "Varna för anrop med implicit gränssnitt." #: fortran/lang.opt:250 -#, fuzzy -#| msgid "Warn about called procedures not explicitly declared" msgid "Warn about called procedures not explicitly declared." -msgstr "Varna för anrop av procedurer som inte explicit deklarerats" +msgstr "Varna för anrop av procedurer som inte explicit deklarerats." #: fortran/lang.opt:254 -#, fuzzy -#| msgid "Warn about compile-time integer division by zero" msgid "Warn about constant integer divisions with truncated results." -msgstr "Varna för heltalsdivision med noll vid kompileringstillfället" +msgstr "Varna för konstant heltalsdivision med avhuggna resultat." #: fortran/lang.opt:258 -#, fuzzy -#| msgid "Warn about truncated source lines" msgid "Warn about truncated source lines." -msgstr "Varna för avhuggna källkodsrader" +msgstr "Varna för avhuggna källkodsrader." #: fortran/lang.opt:262 -#, fuzzy -#| msgid "Warn on intrinsics not part of the selected standard" msgid "Warn on intrinsics not part of the selected standard." -msgstr "Inbyggd för inbyggda om inte är med i den valda standarden" +msgstr "Inbyggd för inbyggda om inte är med i den valda standarden." #: fortran/lang.opt:274 -#, fuzzy -#| msgid "Warn about USE statements that have no ONLY qualifier" msgid "Warn about USE statements that have no ONLY qualifier." -msgstr "Varna för USE-satser som inte har någon ONLY-kvalificerare" +msgstr "Varna för USE-satser som inte har någon ONLY-kvalificerare." #: fortran/lang.opt:286 -#, fuzzy -#| msgid "Warn about real-literal-constants with 'q' exponent-letter" msgid "Warn about real-literal-constants with 'q' exponent-letter." -msgstr "Varna för reella literala konstanter med exponentbokstav ”q”" +msgstr "Varna för reella literala konstanter med exponentbokstav ”q”." #: fortran/lang.opt:290 -#, fuzzy -#| msgid "Warn when a left-hand-side array variable is reallocated" msgid "Warn when a left-hand-side array variable is reallocated." -msgstr "Varna när en vektorvariabel på vänsterhandssidan allokeras om" +msgstr "Varna när en vektorvariabel på vänsterhandssidan allokeras om." #: fortran/lang.opt:294 -#, fuzzy -#| msgid "Warn when a left-hand-side variable is reallocated" msgid "Warn when a left-hand-side variable is reallocated." -msgstr "Varna när en variabel på vänsterhandssidan allokeras om" +msgstr "Varna när en variabel på vänsterhandssidan allokeras om." #: fortran/lang.opt:298 -#, fuzzy -#| msgid "Warn if the pointer in a pointer assignment might outlive its target" msgid "Warn if the pointer in a pointer assignment might outlive its target." -msgstr "Varna om pekaren i en pekartilldelning kan överleva sitt mål" +msgstr "Varna om pekaren i en pekartilldelning kan överleva sitt mål." #: fortran/lang.opt:306 -#, fuzzy -#| msgid "Warn about \"suspicious\" constructs" msgid "Warn about \"suspicious\" constructs." -msgstr "Varna för ”misstänkta” konstruktioner" +msgstr "Varna för ”misstänkta” konstruktioner." #: fortran/lang.opt:310 -#, fuzzy -#| msgid "Permit nonconforming uses of the tab character" msgid "Permit nonconforming uses of the tab character." -msgstr "Tillåt ej konforma användningar av tabulatortecken" +msgstr "Tillåt ej konforma användningar av tabulatortecken." #: fortran/lang.opt:314 -#, fuzzy -#| msgid "Warn about underflow of numerical constant expressions" msgid "Warn about underflow of numerical constant expressions." -msgstr "Varna för underspill i numeriska konstantuttryck" +msgstr "Varna för underspill i numeriska konstantuttryck." #: fortran/lang.opt:322 -#, fuzzy -#| msgid "Warn if a user-procedure has the same name as an intrinsic" msgid "Warn if a user-procedure has the same name as an intrinsic." -msgstr "Varna om en användarprocedur har samma namn som en inbyggd" +msgstr "Varna om en användarprocedur har samma namn som en inbyggd." #: fortran/lang.opt:330 msgid "Warn about unused dummy arguments." msgstr "Varna för oanvända attrappargument." #: fortran/lang.opt:334 -#, fuzzy -#| msgid "Warn about zero-trip DO loops" msgid "Warn about zero-trip DO loops." -msgstr "Varna för DO-slingor med noll-trippar" +msgstr "Varna för DO-slingor med noll-trippar." #: fortran/lang.opt:338 -#, fuzzy -#| msgid "Enable preprocessing" msgid "Enable preprocessing." -msgstr "Aktivera preprocessning" +msgstr "Aktivera preprocessning." #: fortran/lang.opt:346 -#, fuzzy -#| msgid "Disable preprocessing" msgid "Disable preprocessing." -msgstr "Avaktivera preprocessning" +msgstr "Avaktivera preprocessning." #: fortran/lang.opt:354 -#, fuzzy -#| msgid "Eliminate multiple function invokations also for impure functions" msgid "Eliminate multiple function invokations also for impure functions." -msgstr "Eliminera multipla funktionsanrop även för orena funktioner" +msgstr "Eliminera multipla funktionsanrop även för orena funktioner." #: fortran/lang.opt:358 -#, fuzzy -#| msgid "Enable alignment of COMMON blocks" msgid "Enable alignment of COMMON blocks." -msgstr "Aktivera justering av COMMON-block" +msgstr "Aktivera justering av COMMON-block." #: fortran/lang.opt:362 -#, fuzzy -#| msgid "All intrinsics procedures are available regardless of selected standard" msgid "All intrinsics procedures are available regardless of selected standard." -msgstr "Alla inbyggda procedurer är tillgängliga oavsett av vald standard" +msgstr "Alla inbyggda procedurer är tillgängliga oavsett av vald standard." #: fortran/lang.opt:370 -#, fuzzy -#| msgid "Do not treat local variables and COMMON blocks as if they were named in SAVE statements" msgid "Do not treat local variables and COMMON blocks as if they were named in SAVE statements." -msgstr "Behandla inte lokala variabler och COMMON-block som om de vore namngivna i SAVE-satser" +msgstr "Behandla inte lokala variabler och COMMON-block som om de vore namngivna i SAVE-satser." #: fortran/lang.opt:374 -#, fuzzy -#| msgid "Specify that backslash in string introduces an escape character" msgid "Specify that backslash in string introduces an escape character." -msgstr "Ange att omvänt snedstreck i strängar inleder ett specialtecken" +msgstr "Ange att omvänt snedstreck i strängar inleder ett specialtecken." #: fortran/lang.opt:378 -#, fuzzy -#| msgid "Produce a backtrace when a runtime error is encountered" msgid "Produce a backtrace when a runtime error is encountered." -msgstr "Skapa en stackspårning när ett fel inträffar under körning" +msgstr "Skapa en stackspårning när ett fel inträffar under körning." #: fortran/lang.opt:382 -#, fuzzy -#| msgid "-fblas-matmul-limit=\tSize of the smallest matrix for which matmul will use BLAS" msgid "-fblas-matmul-limit=\tSize of the smallest matrix for which matmul will use BLAS." -msgstr "-fblas-matmul-limit=\tStorlek på den minsta matris för vilken matmul kommer använda BLAS" +msgstr "-fblas-matmul-limit=\tStorlek på den minsta matris för vilken matmul kommer använda BLAS." #: fortran/lang.opt:386 -#, fuzzy -#| msgid "Produce a warning at runtime if a array temporary has been created for a procedure argument" msgid "Produce a warning at runtime if a array temporary has been created for a procedure argument." -msgstr "Producera en varning vid körning om en vektortemporär har skapats för ett procedurargument" +msgstr "Producera en varning vid körning om en vektortemporär har skapats för ett procedurargument." #: fortran/lang.opt:390 msgid "-fconvert= The endianness used for unformatted files." @@ -6035,46 +5793,32 @@ msgid "Unrecognized option to endianess value: %qs" msgstr "Okänd flagga till byteordervärde: %qs" #: fortran/lang.opt:409 -#, fuzzy -#| msgid "Use the Cray Pointer extension" msgid "Use the Cray Pointer extension." -msgstr "Använd Cray-pekarutökningen" +msgstr "Använd Cray-pekarutökningen." #: fortran/lang.opt:413 -#, fuzzy -#| msgid "Ignore 'D' in column one in fixed form" msgid "Ignore 'D' in column one in fixed form." -msgstr "Ignorera ”D” i kolumn ett i fix form" +msgstr "Ignorera ”D” i kolumn ett i fix form." #: fortran/lang.opt:417 -#, fuzzy -#| msgid "Treat lines with 'D' in column one as comments" msgid "Treat lines with 'D' in column one as comments." -msgstr "Tolka rader med ”D” i kolumn ett som kommentarer" +msgstr "Tolka rader med ”D” i kolumn ett som kommentarer." #: fortran/lang.opt:421 -#, fuzzy -#| msgid "Set the default double precision kind to an 8 byte wide type" msgid "Set the default double precision kind to an 8 byte wide type." -msgstr "Ange standard för sorten dubbel precision till en 8 byte bred typ" +msgstr "Ange standard för sorten dubbel precision till en 8 byte bred typ." #: fortran/lang.opt:425 -#, fuzzy -#| msgid "Set the default integer kind to an 8 byte wide type" msgid "Set the default integer kind to an 8 byte wide type." -msgstr "Ange standard för sorten heltal till en 8 byte bred typ" +msgstr "Ange standard för sorten heltal till en 8 byte bred typ." #: fortran/lang.opt:429 -#, fuzzy -#| msgid "Set the default real kind to an 8 byte wide type" msgid "Set the default real kind to an 8 byte wide type." -msgstr "Ange standard för sorten reell till en 8 byte bred typ" +msgstr "Ange standard för sorten reell till en 8 byte bred typ." #: fortran/lang.opt:433 -#, fuzzy -#| msgid "Allow dollar signs in entity names" msgid "Allow dollar signs in entity names." -msgstr "Tillåt dollartecken i entitetsnamn" +msgstr "Tillåt dollartecken i entitetsnamn." #: fortran/lang.opt:437 config/alpha/alpha.opt:31 common.opt:728 #: common.opt:916 common.opt:920 common.opt:924 common.opt:928 common.opt:1417 @@ -6084,136 +5828,92 @@ msgid "Does nothing. Preserved for backward compatibility." msgstr "Gör ingenting. Bevarad för bakåtkompatibilitet." #: fortran/lang.opt:441 -#, fuzzy -#| msgid "Display the code tree after parsing" msgid "Display the code tree after parsing." -msgstr "Visa kodträdet efter tolkning" +msgstr "Visa kodträdet efter tolkning." #: fortran/lang.opt:445 -#, fuzzy -#| msgid "Display the code tree after front end optimization" msgid "Display the code tree after front end optimization." -msgstr "Visa kodträdet efter framändesoptimering" +msgstr "Visa kodträdet efter framändesoptimering." #: fortran/lang.opt:449 -#, fuzzy -#| msgid "Display the code tree after parsing; deprecated option" msgid "Display the code tree after parsing; deprecated option." -msgstr "Visa kodträdet efter tolkning, flaggan bör undvikas" +msgstr "Visa kodträdet efter tolkning, flaggan bör undvikas." #: fortran/lang.opt:453 -#, fuzzy -#| msgid "Specify that an external BLAS library should be used for matmul calls on large-size arrays" msgid "Specify that an external BLAS library should be used for matmul calls on large-size arrays." -msgstr "Ange att ett externt BLAS-bibliotek skall användas för matmul-anrop på större vektorer" +msgstr "Ange att ett externt BLAS-bibliotek skall användas för matmul-anrop på större vektorer." #: fortran/lang.opt:457 -#, fuzzy -#| msgid "Use f2c calling convention" msgid "Use f2c calling convention." -msgstr "Använd f2c:s anropskonvention" +msgstr "Använd f2c:s anropskonvention." #: fortran/lang.opt:461 -#, fuzzy -#| msgid "Assume that the source file is fixed form" msgid "Assume that the source file is fixed form." -msgstr "Anta att källkodsfilen är i fix form" +msgstr "Anta att källkodsfilen är i fix form." #: fortran/lang.opt:465 -#, fuzzy -#| msgid "Interpret any INTEGER(4) as an INTEGER(8)" msgid "Interpret any INTEGER(4) as an INTEGER(8)." -msgstr "Tolka en INTEGER(4) som en INTEGER(8)" +msgstr "Tolka en INTEGER(4) som en INTEGER(8)." #: fortran/lang.opt:469 fortran/lang.opt:473 -#, fuzzy -#| msgid "Specify where to find the compiled intrinsic modules" msgid "Specify where to find the compiled intrinsic modules." -msgstr "Ange var de kompilerade inbyggda modulerna finns" +msgstr "Ange var de kompilerade inbyggda modulerna finns." #: fortran/lang.opt:477 -#, fuzzy -#| msgid "Allow arbitrary character line width in fixed mode" msgid "Allow arbitrary character line width in fixed mode." -msgstr "Tillåt radlängd med godtyckligt antal tecken i fast läge" +msgstr "Tillåt radlängd med godtyckligt antal tecken i fast läge." #: fortran/lang.opt:481 -#, fuzzy -#| msgid "-ffixed-line-length-\tUse n as character line width in fixed mode" msgid "-ffixed-line-length-\tUse n as character line width in fixed mode." -msgstr "-ffixed-line-length-\tAnvänd radlängd med n tecken i fast läge" +msgstr "-ffixed-line-length-\tAnvänd radlängd med n tecken i fast läge." #: fortran/lang.opt:485 -#, fuzzy -#| msgid "-ffpe-trap=[...]\tStop on following floating point exceptions" msgid "-ffpe-trap=[...]\tStop on following floating point exceptions." -msgstr "-ffpe-trap=[...]\tStanna vid följande flyttalsundantag" +msgstr "-ffpe-trap=[…]\tStanna vid följande flyttalsundantag." #: fortran/lang.opt:489 -#, fuzzy -#| msgid "-ffpe-summary=[...]\tPrint summary of floating point exceptions" msgid "-ffpe-summary=[...]\tPrint summary of floating point exceptions." -msgstr "-ffpe-summary=[…]\tSkriv ut en sammanfattning av flyttalsundantag" +msgstr "-ffpe-summary=[…]\tSkriv ut en sammanfattning av flyttalsundantag." #: fortran/lang.opt:493 -#, fuzzy -#| msgid "Assume that the source file is free form" msgid "Assume that the source file is free form." -msgstr "Anta att källkodsfilen är i fritt format" +msgstr "Anta att källkodsfilen är i fritt format." #: fortran/lang.opt:497 -#, fuzzy -#| msgid "Allow arbitrary character line width in free mode" msgid "Allow arbitrary character line width in free mode." -msgstr "Tillåt radlängd med godtyckligt antal tecken i fri form" +msgstr "Tillåt radlängd med godtyckligt antal tecken i fri form." #: fortran/lang.opt:501 -#, fuzzy -#| msgid "-ffree-line-length-\tUse n as character line width in free mode" msgid "-ffree-line-length-\tUse n as character line width in free mode." -msgstr "-ffree-line-length-\tAnvänd radlängd med n tecken i fri form" +msgstr "-ffree-line-length-\tAnvänd radlängd med n tecken i fri form." #: fortran/lang.opt:505 -#, fuzzy -#| msgid "Enable front end optimization" msgid "Enable front end optimization." -msgstr "Aktivera framändesoptimeringar" +msgstr "Aktivera framändesoptimeringar." #: fortran/lang.opt:509 -#, fuzzy -#| msgid "Specify that no implicit typing is allowed, unless overridden by explicit IMPLICIT statements" msgid "Specify that no implicit typing is allowed, unless overridden by explicit IMPLICIT statements." -msgstr "Ange att ingen implicit typning är tillåten, om inte åsidosatt med uttryckliga IMPLICIT-satser" +msgstr "Ange att ingen implicit typning är tillåten, om inte åsidosatt med uttryckliga IMPLICIT-satser." #: fortran/lang.opt:513 -#, fuzzy -#| msgid "-finit-character=\tInitialize local character variables to ASCII value n" msgid "-finit-character=\tInitialize local character variables to ASCII value n." -msgstr "-finit-character=\tInitiera lokala teckenvariabler med ASCII-värde n" +msgstr "-finit-character=\tInitiera lokala teckenvariabler med ASCII-värde n." #: fortran/lang.opt:517 -#, fuzzy -#| msgid "-finit-integer=\tInitialize local integer variables to n" msgid "-finit-integer=\tInitialize local integer variables to n." -msgstr "-finit-integer=\tInitiera lokala heltalsvariabler med n" +msgstr "-finit-integer=\tInitiera lokala heltalsvariabler med n." #: fortran/lang.opt:521 -#, fuzzy -#| msgid "Initialize local variables to zero (from g77)" msgid "Initialize local variables to zero (from g77)." -msgstr "Initiera lokala variabler med noll (från g77)" +msgstr "Initiera lokala variabler med noll (från g77)." #: fortran/lang.opt:525 -#, fuzzy -#| msgid "-finit-logical=\tInitialize local logical variables" msgid "-finit-logical=\tInitialize local logical variables." -msgstr "-finit-logical=\tInitiera lokala logiska variabler" +msgstr "-finit-logical=\tInitiera lokala logiska variabler." #: fortran/lang.opt:529 -#, fuzzy -#| msgid "-finit-real=\tInitialize local real variables" msgid "-finit-real=\tInitialize local real variables." -msgstr "-finit-real=\tInitiera lokala reella variabler" +msgstr "-finit-real=\tInitiera lokala reella variabler." #: fortran/lang.opt:532 #, c-format @@ -6221,34 +5921,24 @@ msgid "Unrecognized option to floating-point init value: %qs" msgstr "Okänt argument till -floating-point initieringsvärde: %qs" #: fortran/lang.opt:551 -#, fuzzy -#| msgid "-fblas-matmul-limit=\tSize of the smallest matrix for which matmul will use BLAS" msgid "-finline-matmul-limit=\tSpecify the size of the largest matrix for which matmul will be inlined." -msgstr "-fblas-matmul-limit=\tStorlek på den minsta matris för vilken matmul kommer använda BLAS" +msgstr "-fblas-matmul-limit=\tSpecificera storleken på den största matris för vilken matmul kommer inline:as." #: fortran/lang.opt:555 -#, fuzzy -#| msgid "-fmax-array-constructor=\tMaximum number of objects in an array constructor" msgid "-fmax-array-constructor=\tMaximum number of objects in an array constructor." -msgstr "-fmax-array-constructor=\tMaximalt antal objekt i en vektorkonstruerare" +msgstr "-fmax-array-constructor=\tMaximalt antal objekt i en vektorkonstruerare." #: fortran/lang.opt:559 -#, fuzzy -#| msgid "-fmax-identifier-length=\tMaximum identifier length" msgid "-fmax-identifier-length=\tMaximum identifier length." -msgstr "-fmax-identifier-length=\tMaximal identifierarlängd" +msgstr "-fmax-identifier-length=\tMaximal identifierarlängd." #: fortran/lang.opt:563 -#, fuzzy -#| msgid "-fmax-subrecord-length=\tMaximum length for subrecords" msgid "-fmax-subrecord-length=\tMaximum length for subrecords." -msgstr "-fmax-subrecord-length=\tMaximal längd för underposter" +msgstr "-fmax-subrecord-length=\tMaximal längd för underposter." #: fortran/lang.opt:567 -#, fuzzy -#| msgid "-fmax-stack-var-size=\tSize in bytes of the largest array that will be put on the stack" msgid "-fmax-stack-var-size=\tSize in bytes of the largest array that will be put on the stack." -msgstr "-fmax-stack-var-size=\tStorlek i byte på den största vektorn som läggs på stacken" +msgstr "-fmax-stack-var-size=\tStorlek i byte på den största vektorn som läggs på stacken." #: fortran/lang.opt:571 msgid "Put all local arrays on stack." @@ -6259,94 +5949,64 @@ msgid "Set default accessibility of module entities to PRIVATE." msgstr "Sätt modulentiteternas standardtillgänglighet till PRIVATE." #: fortran/lang.opt:591 -#, fuzzy -#| msgid "Try to lay out derived types as compactly as possible" msgid "Try to lay out derived types as compactly as possible." -msgstr "Försök placera ut härledda typer så kompakt som möjligt" +msgstr "Försök placera ut härledda typer så kompakt som möjligt." #: fortran/lang.opt:599 -#, fuzzy -#| msgid "Protect parentheses in expressions" msgid "Protect parentheses in expressions." -msgstr "Skydda parenteser i uttryck" +msgstr "Skydda parenteser i uttryck." #: fortran/lang.opt:603 -#, fuzzy -#| msgid "Enable range checking during compilation" msgid "Enable range checking during compilation." -msgstr "Aktivera intervallkontroller under kompilering" +msgstr "Aktivera intervallkontroller under kompilering." #: fortran/lang.opt:607 -#, fuzzy -#| msgid "Interpret any REAL(4) as a REAL(8)" msgid "Interpret any REAL(4) as a REAL(8)." -msgstr "Tolka en REAL(4) som en REAL(8)" +msgstr "Tolka en REAL(4) som en REAL(8)." #: fortran/lang.opt:611 -#, fuzzy -#| msgid "Interpret any REAL(4) as a REAL(10)" msgid "Interpret any REAL(4) as a REAL(10)." -msgstr "Tolka en REAL(4) som en REAL(10)" +msgstr "Tolka en REAL(4) som en REAL(10)." #: fortran/lang.opt:615 -#, fuzzy -#| msgid "Interpret any REAL(4) as a REAL(16)" msgid "Interpret any REAL(4) as a REAL(16)." -msgstr "Tolka en REAL(4) som en REAL(16)" +msgstr "Tolka en REAL(4) som en REAL(16)." #: fortran/lang.opt:619 -#, fuzzy -#| msgid "Interpret any REAL(8) as a REAL(4)" msgid "Interpret any REAL(8) as a REAL(4)." -msgstr "Tolka en REAL(8) som en REAL(4)" +msgstr "Tolka en REAL(8) som en REAL(4)." #: fortran/lang.opt:623 -#, fuzzy -#| msgid "Interpret any REAL(8) as a REAL(10)" msgid "Interpret any REAL(8) as a REAL(10)." -msgstr "Tolka en REAL(8) som en REAL(10)" +msgstr "Tolka en REAL(8) som en REAL(10)." #: fortran/lang.opt:627 -#, fuzzy -#| msgid "Interpret any REAL(8) as a REAL(16)" msgid "Interpret any REAL(8) as a REAL(16)." -msgstr "Tolka en REAL(8) som en REAL(16)" +msgstr "Tolka en REAL(8) som en REAL(16)." #: fortran/lang.opt:631 -#, fuzzy -#| msgid "Reallocate the LHS in assignments" msgid "Reallocate the LHS in assignments." -msgstr "Omallokera vänsterhandssidan i tilldelningar" +msgstr "Omallokera vänsterhandssidan i tilldelningar." #: fortran/lang.opt:635 -#, fuzzy -#| msgid "Use a 4-byte record marker for unformatted files" msgid "Use a 4-byte record marker for unformatted files." -msgstr "Använd 4-bytes postmarkeringar för oformaterade filer" +msgstr "Använd 4-bytes postmarkeringar för oformaterade filer." #: fortran/lang.opt:639 -#, fuzzy -#| msgid "Use an 8-byte record marker for unformatted files" msgid "Use an 8-byte record marker for unformatted files." -msgstr "Använd 8-bytes postmarkeringar för oformaterade filer" +msgstr "Använd 8-bytes postmarkeringar för oformaterade filer." #: fortran/lang.opt:643 -#, fuzzy -#| msgid "Allocate local variables on the stack to allow indirect recursion" msgid "Allocate local variables on the stack to allow indirect recursion." -msgstr "Allokera lokala variabler på stacken för att möjliggöra indirekt rekursion" +msgstr "Allokera lokala variabler på stacken för att möjliggöra indirekt rekursion." #: fortran/lang.opt:647 -#, fuzzy -#| msgid "Copy array sections into a contiguous block on procedure entry" msgid "Copy array sections into a contiguous block on procedure entry." -msgstr "Kopiera vektorsektioner till sammanhängande block vid procedurstart" +msgstr "Kopiera vektorsektioner till sammanhängande block vid procedurstart." #: fortran/lang.opt:651 -#, fuzzy -#| msgid "-fcoarray=\tSpecify which coarray parallelization should be used" msgid "-fcoarray=\tSpecify which coarray parallelization should be used." -msgstr "-fcoarray=\tAnge vilken co-vektorsparallellisering som skall användas" +msgstr "-fcoarray=\tAnge vilken co-vektorsparallellisering som skall användas." #: fortran/lang.opt:654 #, c-format @@ -6354,28 +6014,20 @@ msgid "Unrecognized option: %qs" msgstr "Okänd flagga: %qs" #: fortran/lang.opt:667 -#, fuzzy -#| msgid "-fcheck=[...]\tSpecify which runtime checks are to be performed" msgid "-fcheck=[...]\tSpecify which runtime checks are to be performed." -msgstr "-fcheck=[...]\tAnge vilka körtidskontroller som skall utföras" +msgstr "-fcheck=[...]\tAnge vilka körtidskontroller som skall utföras." #: fortran/lang.opt:671 -#, fuzzy -#| msgid "Append a second underscore if the name already contains an underscore" msgid "Append a second underscore if the name already contains an underscore." -msgstr "Lägg till ett andra understrykningstecken om namnet redan innehåller ett understrykningstecken" +msgstr "Lägg till ett andra understrykningstecken om namnet redan innehåller ett understrykningstecken." #: fortran/lang.opt:679 -#, fuzzy -#| msgid "Apply negative sign to zero values" msgid "Apply negative sign to zero values." -msgstr "Använd negativt tecken på nollvärden" +msgstr "Använd negativt tecken på nollvärden." #: fortran/lang.opt:683 -#, fuzzy -#| msgid "Append underscores to externally visible names" msgid "Append underscores to externally visible names." -msgstr "Lägg till understrykningstecken till externt synliga namn" +msgstr "Lägg till understrykningstecken till externt synliga namn." #: fortran/lang.opt:687 c-family/c.opt:1139 c-family/c.opt:1163 #: c-family/c.opt:1389 config/pa/pa.opt:42 config/pa/pa.opt:66 @@ -6387,46 +6039,32 @@ msgid "Does nothing. Preserved for backward compatibility." msgstr "Gör ingenting. Bevarad för bakåtkompatibilitet." #: fortran/lang.opt:727 -#, fuzzy -#| msgid "Statically link the GNU Fortran helper library (libgfortran)" msgid "Statically link the GNU Fortran helper library (libgfortran)." -msgstr "Länka statiskt till GNU:s Fortran-hjälpbibliotek (libgfortran)" +msgstr "Länka statiskt till GNU:s Fortran-hjälpbibliotek (libgfortran)." #: fortran/lang.opt:731 -#, fuzzy -#| msgid "Conform to the ISO Fortran 2003 standard" msgid "Conform to the ISO Fortran 2003 standard." -msgstr "Följ standarden ISO Fortran 2003" +msgstr "Följ standarden ISO Fortran 2003." #: fortran/lang.opt:735 -#, fuzzy -#| msgid "Conform to the ISO Fortran 2008 standard" msgid "Conform to the ISO Fortran 2008 standard." -msgstr "Följ standarden ISO Fortran 2008" +msgstr "Följ standarden ISO Fortran 2008." #: fortran/lang.opt:739 -#, fuzzy -#| msgid "Conform to the ISO Fortran 2008 standard including TS 29113" msgid "Conform to the ISO Fortran 2008 standard including TS 29113." -msgstr "Följ standarden ISO Fortran 2008 inklusive TS 29113" +msgstr "Följ standarden ISO Fortran 2008 inklusive TS 29113." #: fortran/lang.opt:743 -#, fuzzy -#| msgid "Conform to the ISO Fortran 95 standard" msgid "Conform to the ISO Fortran 95 standard." -msgstr "Följ standarden ISO Fortran 95" +msgstr "Följ standarden ISO Fortran 95." #: fortran/lang.opt:747 -#, fuzzy -#| msgid "Conform to nothing in particular" msgid "Conform to nothing in particular." -msgstr "Följ inget särskilt" +msgstr "Följ inget särskilt." #: fortran/lang.opt:751 -#, fuzzy -#| msgid "Accept extensions to support legacy code" msgid "Accept extensions to support legacy code." -msgstr "Acceptera utökningar för att stödja gammal kod" +msgstr "Acceptera utökningar för att stödja gammal kod." #: c-family/c.opt:43 c-family/c.opt:46 c-family/c.opt:181 #, c-format @@ -6455,88 +6093,60 @@ msgid "missing path after %qs" msgstr "sökväg saknas efter %qs" #: c-family/c.opt:182 -#, fuzzy -#| msgid "-A=\tAssert the to . Putting '-' before disables the to " msgid "-A=\tAssert the to . Putting '-' before disables the to ." -msgstr "-A=\tIntyga på . Om ”-” sätts före avaktiveras :et till :n" +msgstr "-A=\tIntyga på . Om ”-” sätts före avaktiveras :et till :n." #: c-family/c.opt:186 -#, fuzzy -#| msgid "Do not discard comments" msgid "Do not discard comments." -msgstr "Kasta inte kommentarer" +msgstr "Kasta inte kommentarer." #: c-family/c.opt:190 -#, fuzzy -#| msgid "Do not discard comments in macro expansions" msgid "Do not discard comments in macro expansions." -msgstr "Släng inte kommentarer vid makroexpansioner" +msgstr "Släng inte kommentarer vid makroexpansioner." #: c-family/c.opt:194 -#, fuzzy -#| msgid "-D[=]\tDefine a with as its value. If just is given, is taken to be 1" msgid "-D[=]\tDefine a with as its value. If just is given, is taken to be 1." -msgstr "-D[=]\tDefiniera ett med som sitt värde. Om bara anges sätts till 1" +msgstr "-D[=]\tDefiniera ett med som sitt värde. Om bara anges sätts till 1." #: c-family/c.opt:201 -#, fuzzy -#| msgid "-F \tAdd to the end of the main framework include path" msgid "-F \tAdd to the end of the main framework include path." -msgstr "-F \tLägg till till slutet av huvudramverkets inkluderingssökväg" +msgstr "-F \tLägg till till slutet av huvudramverkets inkluderingssökväg." #: c-family/c.opt:205 -#, fuzzy -#| msgid "Print the name of header files as they are used" msgid "Print the name of header files as they are used." -msgstr "Skriv ut namnet på huvudfiler allteftersom de används" +msgstr "Skriv ut namnet på huvudfiler allteftersom de används." #: c-family/c.opt:209 -#, fuzzy -#| msgid "-I \tAdd to the end of the main include path" msgid "-I \tAdd to the end of the main include path." -msgstr "-I \tLägg till till slutet av huvudsökvägen" +msgstr "-I \tLägg till till slutet av huvudsökvägen." #: c-family/c.opt:213 -#, fuzzy -#| msgid "Generate make dependencies" msgid "Generate make dependencies." -msgstr "Generera make-beroenden" +msgstr "Generera make-beroenden." #: c-family/c.opt:217 -#, fuzzy -#| msgid "Generate make dependencies and compile" msgid "Generate make dependencies and compile." -msgstr "Generera make-beroenden och kompilera" +msgstr "Generera make-beroenden och kompilera." #: c-family/c.opt:221 -#, fuzzy -#| msgid "-MF \tWrite dependency output to the given file" msgid "-MF \tWrite dependency output to the given file." -msgstr "-MF \tSkriv beroendeutdata till den angivna filen" +msgstr "-MF \tSkriv beroendeutdata till den angivna filen." #: c-family/c.opt:225 -#, fuzzy -#| msgid "Treat missing header files as generated files" msgid "Treat missing header files as generated files." -msgstr "Behandla saknade huvudfiler som genererade filer" +msgstr "Behandla saknade huvudfiler som genererade filer." #: c-family/c.opt:229 -#, fuzzy -#| msgid "Like -M but ignore system header files" msgid "Like -M but ignore system header files." -msgstr "Som -M men ignorera systemhuvudfiler" +msgstr "Som -M men ignorera systemhuvudfiler." #: c-family/c.opt:233 -#, fuzzy -#| msgid "Like -MD but ignore system header files" msgid "Like -MD but ignore system header files." -msgstr "Som -MD men ignorera systemhuvudfiler" +msgstr "Som -MD men ignorera systemhuvudfiler." #: c-family/c.opt:237 -#, fuzzy -#| msgid "Generate phony targets for all headers" msgid "Generate phony targets for all headers." -msgstr "Generera låtsasmål för alla huvuden" +msgstr "Generera låtsasmål för alla huvuden." #: c-family/c.opt:240 c-family/c.opt:244 #, c-format @@ -6544,458 +6154,312 @@ msgid "missing makefile target after %qs" msgstr "makefile-mål saknas efter %qs" #: c-family/c.opt:241 -#, fuzzy -#| msgid "-MQ \tAdd a MAKE-quoted target" msgid "-MQ \tAdd a MAKE-quoted target." -msgstr "-MQ \tLägg till ett MAKE-citerat mål" +msgstr "-MQ \tLägg till ett MAKE-citerat mål." #: c-family/c.opt:245 -#, fuzzy -#| msgid "-MT \tAdd an unquoted target" msgid "-MT \tAdd an unquoted target." -msgstr "-MT \tLägg till ett ociterat mål" +msgstr "-MT \tLägg till ett ociterat mål." #: c-family/c.opt:249 -#, fuzzy -#| msgid "Do not generate #line directives" msgid "Do not generate #line directives." -msgstr "Generera inte #line-direktiv" +msgstr "Generera inte #line-direktiv." #: c-family/c.opt:253 -#, fuzzy -#| msgid "-U\tUndefine " msgid "-U\tUndefine ." -msgstr "-U\tAvdefiniera " +msgstr "-U\tAvdefiniera ." #: c-family/c.opt:257 -#, fuzzy -#| msgid "Warn about things that will change when compiling with an ABI-compliant compiler" msgid "Warn about things that will change when compiling with an ABI-compliant compiler." -msgstr "Varna för saker som skulle ändras vid kompilering med en kompilator som följer ABI" +msgstr "Varna för saker som skulle ändras vid kompilering med en kompilator som följer ABI." #: c-family/c.opt:261 -#, fuzzy -#| msgid "Warn about things that change between the current -fabi-version and the specified version" msgid "Warn about things that change between the current -fabi-version and the specified version." -msgstr "Varna för saker som ändras mellan den nuvarande -fabi-version och den angivna versionen" +msgstr "Varna för saker som ändras mellan den nuvarande -fabi-version och den angivna versionen." #: c-family/c.opt:265 -#, fuzzy -#| msgid "Warn if a subobject has an abi_tag attribute that the complete object type does not have" msgid "Warn if a subobject has an abi_tag attribute that the complete object type does not have." -msgstr "Varna om ett underobjekt har ett abi_tag-attribut som det fullständiga objektets typ inte har" +msgstr "Varna om ett underobjekt har ett abi_tag-attribut som det fullständiga objektets typ inte har." #: c-family/c.opt:272 -#, fuzzy -#| msgid "Warn about suspicious uses of memory addresses" msgid "Warn about suspicious uses of memory addresses." -msgstr "Varna för misstänkt användning av minnesadresser" +msgstr "Varna för misstänkt användning av minnesadresser." #: c-family/c.opt:276 ada/gcc-interface/lang.opt:57 -#, fuzzy -#| msgid "Enable most warning messages" msgid "Enable most warning messages." -msgstr "Aktivera de flesta varningsmeddelanden" +msgstr "Aktivera de flesta varningsmeddelanden." #: c-family/c.opt:288 -#, fuzzy -#| msgid "Warn whenever an Objective-C assignment is being intercepted by the garbage collector" msgid "Warn whenever an Objective-C assignment is being intercepted by the garbage collector." -msgstr "Varna när en Objective-C-tilldelning fångas upp av skräpsamlaren" +msgstr "Varna när en Objective-C-tilldelning fångas upp av skräpsamlaren." #: c-family/c.opt:292 -#, fuzzy -#| msgid "Warn about casting functions to incompatible types" msgid "Warn about casting functions to incompatible types." -msgstr "Varna för typkonvertering av funktioner till inkompatibla typer" +msgstr "Varna för typkonvertering av funktioner till inkompatibla typer." #: c-family/c.opt:296 -#, fuzzy -#| msgid "Warn about boolean expression compared with an integer value different from true/false" msgid "Warn about boolean expression compared with an integer value different from true/false." -msgstr "Varna för booleska uttryck som jämförs med ett heltalsvärde annat skilt från sant/falskt" +msgstr "Varna för booleska uttryck som jämförs med ett heltalsvärde annat skilt från sant/falskt." #: c-family/c.opt:300 msgid "Warn when __builtin_frame_address or __builtin_return_address is used unsafely." msgstr "Varna när __builtin_frame_address eller __builtin_return_address används osäkert." #: c-family/c.opt:304 -#, fuzzy -#| msgid "Warn when a built-in preprocessor macro is undefined or redefined" msgid "Warn when a built-in preprocessor macro is undefined or redefined." -msgstr "Varna när ett inbyggt preprocessormakro avdefinieras eller omdefinieras" +msgstr "Varna när ett inbyggt preprocessormakro avdefinieras eller omdefinieras." #: c-family/c.opt:308 -#, fuzzy -#| msgid "Warn about features not present in ISO C90, but present in ISO C99" msgid "Warn about features not present in ISO C90, but present in ISO C99." -msgstr "Varna för funktioner som inte finns i ISO C90, men finns i ISO C99" +msgstr "Varna för funktioner som inte finns i ISO C90, men finns i ISO C99." #: c-family/c.opt:312 -#, fuzzy -#| msgid "Warn about features not present in ISO C99, but present in ISO C11" msgid "Warn about features not present in ISO C99, but present in ISO C11." -msgstr "Varna för funktioner som inte finns i ISO C99, men finns i ISO C11" +msgstr "Varna för funktioner som inte finns i ISO C99, men finns i ISO C11." #: c-family/c.opt:316 -#, fuzzy -#| msgid "Warn about C constructs that are not in the common subset of C and C++" msgid "Warn about C constructs that are not in the common subset of C and C++." -msgstr "Varna för C-konstruktioner som inte är i den gemensamma delmängden av C och C++" +msgstr "Varna för C-konstruktioner som inte är i den gemensamma delmängden av C och C++." #: c-family/c.opt:323 -#, fuzzy -#| msgid "Warn about C++ constructs whose meaning differs between ISO C++ 1998 and ISO C++ 2011" msgid "Warn about C++ constructs whose meaning differs between ISO C++ 1998 and ISO C++ 2011." -msgstr "Varna för C++-konstruktioner vars betydelse skiljer mellan ISO C++ 1998 och ISO C++ 2011" +msgstr "Varna för C++-konstruktioner vars betydelse skiljer mellan ISO C++ 1998 och ISO C++ 2011." #: c-family/c.opt:327 -#, fuzzy -#| msgid "Warn about C++ constructs whose meaning differs between ISO C++ 2011 and ISO C++ 2014" msgid "Warn about C++ constructs whose meaning differs between ISO C++ 2011 and ISO C++ 2014." -msgstr "Varna för C++-konstruktioner vars betydelse skiljer mellan ISO C++ 2011 och ISO C++ 2014" +msgstr "Varna för C++-konstruktioner vars betydelse skiljer mellan ISO C++ 2011 och ISO C++ 2014." #: c-family/c.opt:331 -#, fuzzy -#| msgid "Warn about casts which discard qualifiers" msgid "Warn about casts which discard qualifiers." -msgstr "Varna för typkonvertering som slänger kvalificerare" +msgstr "Varna för typkonvertering som slänger kvalificerare." #: c-family/c.opt:335 -#, fuzzy -#| msgid "Warn about subscripts whose type is \"char\"" msgid "Warn about subscripts whose type is \"char\"." -msgstr "Varna för index vars typ är ”char”" +msgstr "Varna för index vars typ är ”char”." #: c-family/c.opt:339 -#, fuzzy -#| msgid "Warn about memory access errors found by Pointer Bounds Checker" msgid "Warn about memory access errors found by Pointer Bounds Checker." -msgstr "Farna för minnesåtkomstfel som hittas av pekargränskontrollen" +msgstr "Farna för minnesåtkomstfel som hittas av pekargränskontrollen." #: c-family/c.opt:343 -#, fuzzy -#| msgid "Warn about variables that might be changed by \"longjmp\" or \"vfork\"" msgid "Warn about variables that might be changed by \"longjmp\" or \"vfork\"." -msgstr "Varna för variabler som kan ändras av ”longjmp” eller ”vfork”" +msgstr "Varna för variabler som kan ändras av ”longjmp” eller ”vfork”." #: c-family/c.opt:347 -#, fuzzy -#| msgid "Warn about possibly nested block comments, and C++ comments spanning more than one physical line" msgid "Warn about possibly nested block comments, and C++ comments spanning more than one physical line." -msgstr "Varna för möjliga nästade blockkommentarer, och C++-kommentarer som spänner över mer än en fysisk rad" +msgstr "Varna för möjliga nästade blockkommentarer, och C++-kommentarer som spänner över mer än en fysisk rad." #: c-family/c.opt:351 -#, fuzzy -#| msgid "Synonym for -Wcomment" msgid "Synonym for -Wcomment." -msgstr "Synonym för -Wcomment" +msgstr "Synonym för -Wcomment." #: c-family/c.opt:355 -#, fuzzy -#| msgid "Warn for conditionally-supported constructs" msgid "Warn for conditionally-supported constructs." -msgstr "Varna för konstruktioner med villkorligt stöd" +msgstr "Varna för konstruktioner med villkorligt stöd." #: c-family/c.opt:359 -#, fuzzy -#| msgid "Warn for implicit type conversions that may change a value" msgid "Warn for implicit type conversions that may change a value." -msgstr "Varna för implicita typkonverteringar som kan ändra ett värde" +msgstr "Varna för implicita typkonverteringar som kan ändra ett värde." #: c-family/c.opt:363 -#, fuzzy -#| msgid "Warn for converting NULL from/to a non-pointer type" msgid "Warn for converting NULL from/to a non-pointer type." -msgstr "Varna för konvertering av NULL till icke-pekartyp" +msgstr "Varna för konvertering av NULL till icke-pekartyp." #: c-family/c.opt:371 -#, fuzzy -#| msgid "Warn when all constructors and destructors are private" msgid "Warn when all constructors and destructors are private." -msgstr "Varna när ett alla konstruerare och destruerare är privata" +msgstr "Varna när ett alla konstruerare och destruerare är privata." #: c-family/c.opt:375 -#, fuzzy -#| msgid "Warn about __TIME__, __DATE__ and __TIMESTAMP__ usage" msgid "Warn about __TIME__, __DATE__ and __TIMESTAMP__ usage." -msgstr "Varna för användning av __TIME__, __DATE__ och __TIMESTAMP__" +msgstr "Varna för användning av __TIME__, __DATE__ och __TIMESTAMP__." #: c-family/c.opt:379 -#, fuzzy -#| msgid "Warn when a declaration is found after a statement" msgid "Warn when a declaration is found after a statement." -msgstr "Varna när en deklaration hittas efter en sats" +msgstr "Varna när en deklaration hittas efter en sats." #: c-family/c.opt:383 -#, fuzzy -#| msgid "Warn when deleting a pointer to incomplete type" msgid "Warn when deleting a pointer to incomplete type." -msgstr "Varna när en pekare till en ofullständig typ raderas" +msgstr "Varna när en pekare till en ofullständig typ raderas." #: c-family/c.opt:387 -#, fuzzy -#| msgid "Warn about deleting polymorphic objects with non-virtual destructors" msgid "Warn about deleting polymorphic objects with non-virtual destructors." -msgstr "Varna för radering av polymorfa objekt med ickevirtuella destruerare" +msgstr "Varna för radering av polymorfa objekt med ickevirtuella destruerare." #: c-family/c.opt:391 -#, fuzzy -#| msgid "Warn if a deprecated compiler feature, class, method, or field is used" msgid "Warn if a deprecated compiler feature, class, method, or field is used." -msgstr "Varna för en kompilatorfunktion, klass, metod eller fält som bör undvikas används" +msgstr "Varna för en kompilatorfunktion, klass, metod eller fält som bör undvikas används." #: c-family/c.opt:395 -#, fuzzy -#| msgid "Warn about positional initialization of structs requiring designated initializers" msgid "Warn about positional initialization of structs requiring designated initializers." -msgstr "Varna för positionsinitiering av poster som kräver designerade initierare" +msgstr "Varna för positionsinitiering av poster som kräver designerade initierare." #: c-family/c.opt:399 -#, fuzzy -#| msgid "Warn if qualifiers on arrays which are pointer targets are discarded" msgid "Warn if qualifiers on arrays which are pointer targets are discarded." -msgstr "Varna om kvalificerare på vektorer som är pekarmål kastas bort" +msgstr "Varna om kvalificerare på vektorer som är pekarmål kastas bort." #: c-family/c.opt:403 -#, fuzzy -#| msgid "Warn if type qualifiers on pointers are discarded" msgid "Warn if type qualifiers on pointers are discarded." -msgstr "Varna om typkvalificerare på pekare kastas bort" +msgstr "Varna om typkvalificerare på pekare kastas bort." #: c-family/c.opt:407 -#, fuzzy -#| msgid "Warn about compile-time integer division by zero" msgid "Warn about compile-time integer division by zero." -msgstr "Varna för heltalsdivision med noll vid kompileringstillfället" +msgstr "Varna för heltalsdivision med noll vid kompileringstillfället." #: c-family/c.opt:411 msgid "Warn about duplicated conditions in an if-else-if chain." msgstr "Varna för dubblerade villkor i en if-else-if-kedja." #: c-family/c.opt:415 -#, fuzzy -#| msgid "Warn about violations of Effective C++ style rules" msgid "Warn about violations of Effective C++ style rules." -msgstr "Varna för brott mot stilreglerna i Effective C++" +msgstr "Varna för brott mot stilreglerna i Effective C++." #: c-family/c.opt:419 -#, fuzzy -#| msgid "Warn about an empty body in an if or else statement" msgid "Warn about an empty body in an if or else statement." -msgstr "Varna för en tom kropp i en if- eller else-sats" +msgstr "Varna för en tom kropp i en if- eller else-sats." #: c-family/c.opt:423 -#, fuzzy -#| msgid "Warn about stray tokens after #elif and #endif" msgid "Warn about stray tokens after #elif and #endif." -msgstr "Varna för vilsekomna symboler efter #elif och #endif" +msgstr "Varna för vilsekomna symboler efter #elif och #endif." #: c-family/c.opt:427 -#, fuzzy -#| msgid "Warn about comparison of different enum types" msgid "Warn about comparison of different enum types." -msgstr "Varna för jämförelser av skilda uppräkningstyper" +msgstr "Varna för jämförelser av skilda uppräkningstyper." #: c-family/c.opt:435 -#, fuzzy -#| msgid "This switch is deprecated; use -Werror=implicit-function-declaration instead" msgid "This switch is deprecated; use -Werror=implicit-function-declaration instead." -msgstr "Denna flagga bör undvikas, använd -Werror=implicit-function-declaration istället" +msgstr "Denna flagga bör undvikas, använd -Werror=implicit-function-declaration istället." #: c-family/c.opt:439 -#, fuzzy -#| msgid "Warn for implicit type conversions that cause loss of floating point precision" msgid "Warn for implicit type conversions that cause loss of floating point precision." -msgstr "Varna för implicita typkonverteringar som orsakar förlust av flyttalsprecision" +msgstr "Varna för implicita typkonverteringar som orsakar förlust av flyttalsprecision." #: c-family/c.opt:443 -#, fuzzy -#| msgid "Warn if testing floating point numbers for equality" msgid "Warn if testing floating point numbers for equality." -msgstr "Varna vid test av flyttal på likhet" +msgstr "Varna vid test av flyttal på likhet." #: c-family/c.opt:447 c-family/c.opt:479 -#, fuzzy -#| msgid "Warn about printf/scanf/strftime/strfmon format string anomalies" msgid "Warn about printf/scanf/strftime/strfmon format string anomalies." -msgstr "Varna för anomalier i formatsträngar till printf/scanf/strftime/strfmon" +msgstr "Varna för anomalier i formatsträngar till printf/scanf/strftime/strfmon." #: c-family/c.opt:451 -#, fuzzy -#| msgid "Warn about format strings that contain NUL bytes" msgid "Warn about format strings that contain NUL bytes." -msgstr "Varna för formatsträngar som innehåller NUL-byte:ar" +msgstr "Varna för formatsträngar som innehåller NUL-byte:ar." #: c-family/c.opt:455 -#, fuzzy -#| msgid "Warn if passing too many arguments to a function for its format string" msgid "Warn if passing too many arguments to a function for its format string." -msgstr "Varna för för många argument argument till en funktion för dess formatsträng" +msgstr "Varna för för många argument argument till en funktion för dess formatsträng." #: c-family/c.opt:459 -#, fuzzy -#| msgid "Warn about format strings that are not literals" msgid "Warn about format strings that are not literals." -msgstr "Varna för formatsträngar som inte är literaler" +msgstr "Varna för formatsträngar som inte är literaler." #: c-family/c.opt:463 -#, fuzzy -#| msgid "Warn about possible security problems with format functions" msgid "Warn about possible security problems with format functions." -msgstr "Varna för möjliga säkerhetsproblem med formatfunktioner" +msgstr "Varna för möjliga säkerhetsproblem med formatfunktioner." #: c-family/c.opt:467 -#, fuzzy -#| msgid "Warn about sign differences with format functions" msgid "Warn about sign differences with format functions." -msgstr "Varna för teckenskillnader i formatfunktioner" +msgstr "Varna för teckenskillnader i formatfunktioner." #: c-family/c.opt:471 -#, fuzzy -#| msgid "Warn about strftime formats yielding 2-digit years" msgid "Warn about strftime formats yielding 2-digit years." -msgstr "Varna för format till strftime som ger 2-siffrigt årtal" +msgstr "Varna för format till strftime som ger 2-siffrigt årtal." #: c-family/c.opt:475 -#, fuzzy -#| msgid "Warn about zero-length formats" msgid "Warn about zero-length formats." -msgstr "Varna för format med längden noll" +msgstr "Varna för format med längden noll." #: c-family/c.opt:483 msgid "Warn whenever type qualifiers are ignored." msgstr "Varna när typkvalificerare ignoreras." #: c-family/c.opt:487 -#, fuzzy -#| msgid "Warn when there is a conversion between pointers that have incompatible types" msgid "Warn when there is a conversion between pointers that have incompatible types." -msgstr "Varna när det är en konvertering mellan pekare som har ofullständiga typer" +msgstr "Varna när det är en konvertering mellan pekare som har ofullständiga typer." #: c-family/c.opt:491 -#, fuzzy -#| msgid "Warn about variables which are initialized to themselves" msgid "Warn about variables which are initialized to themselves." -msgstr "Varna för variabler som initieras till sig själva" +msgstr "Varna för variabler som initieras till sig själva." #: c-family/c.opt:495 -#, fuzzy -#| msgid "Warn about implicit declarations" msgid "Warn about implicit declarations." -msgstr "Varna för implicita deklarationer" +msgstr "Varna för implicita deklarationer." #: c-family/c.opt:499 -#, fuzzy -#| msgid "Warn about implicit conversions from \"float\" to \"double\"" msgid "Warn about implicit conversions from \"float\" to \"double\"." -msgstr "Varna för implicita konverteringar från ”float” till ”double”" +msgstr "Varna för implicita konverteringar från ”float” till ”double”." #: c-family/c.opt:503 -#, fuzzy -#| msgid "Warn about implicit function declarations" msgid "Warn about implicit function declarations." -msgstr "Varna för implicita funktionsdeklarationer" +msgstr "Varna för implicita funktionsdeklarationer." #: c-family/c.opt:507 -#, fuzzy -#| msgid "Warn when a declaration does not specify a type" msgid "Warn when a declaration does not specify a type." -msgstr "Varna när en deklaration inte anger en typ" +msgstr "Varna när en deklaration inte anger en typ." #: c-family/c.opt:514 -#, fuzzy -#| msgid "Warn about C++11 inheriting constructors when the base has a variadic constructor" msgid "Warn about C++11 inheriting constructors when the base has a variadic constructor." -msgstr "Varna för C++11 ärvda konstruerare när basen har en variadisk konstruerare" +msgstr "Varna för C++11 ärvda konstruerare när basen har en variadisk konstruerare." #: c-family/c.opt:518 -#, fuzzy -#| msgid "Warn about incompatible integer to pointer and pointer to integer conversions" msgid "Warn about incompatible integer to pointer and pointer to integer conversions." -msgstr "Varna för inkompatibla konverteringar från heltal till pekare och pekare till heltal" +msgstr "Varna för inkompatibla konverteringar från heltal till pekare och pekare till heltal." #: c-family/c.opt:522 -#, fuzzy -#| msgid "Warn when there is a cast to a pointer from an integer of a different size" msgid "Warn when there is a cast to a pointer from an integer of a different size." -msgstr "Varna för typkonverteringar till pekare från ett heltal med annan storlek" +msgstr "Varna för typkonverteringar till pekare från ett heltal med annan storlek." #: c-family/c.opt:526 -#, fuzzy -#| msgid "Warn about invalid uses of the \"offsetof\" macro" msgid "Warn about invalid uses of the \"offsetof\" macro." -msgstr "Varna för ogiltiga användningar av makrot ”offsetof”" +msgstr "Varna för ogiltiga användningar av makrot ”offsetof”." #: c-family/c.opt:530 -#, fuzzy -#| msgid "Warn about PCH files that are found but not used" msgid "Warn about PCH files that are found but not used." -msgstr "Varna för PCH-filer som hittas men inte används" +msgstr "Varna för PCH-filer som hittas men inte används." #: c-family/c.opt:534 -#, fuzzy -#| msgid "Warn when a jump misses a variable initialization" msgid "Warn when a jump misses a variable initialization." -msgstr "Varna när ett hopp missar en variabelinitiering" +msgstr "Varna när ett hopp missar en variabelinitiering." #: c-family/c.opt:538 msgid "Warn when a string or character literal is followed by a ud-suffix which does not begin with an underscore." msgstr "Varna när en sträng- eller teckenkonstant följs av ett ud-suffix som inte börjar med ett understrykningstecken." #: c-family/c.opt:542 -#, fuzzy -#| msgid "Warn when a logical operator is suspiciously always evaluating to true or false" msgid "Warn when a logical operator is suspiciously always evaluating to true or false." -msgstr "Varna när en logisk operator misstänkt nog alltid beräknas till sant eller falskt" +msgstr "Varna när en logisk operator misstänkt nog alltid beräknas till sant eller falskt." #: c-family/c.opt:546 -#, fuzzy -#| msgid "Warn when logical not is used on the left hand side operand of a comparison" msgid "Warn when logical not is used on the left hand side operand of a comparison." -msgstr "Varna när logiskt icke används på den vänstra operanden i en jämförelse" +msgstr "Varna när logiskt icke används på den vänstra operanden i en jämförelse." #: c-family/c.opt:550 -#, fuzzy -#| msgid "Do not warn about using \"long long\" when -pedantic" msgid "Do not warn about using \"long long\" when -pedantic." -msgstr "Varna inte om användning av ”long long” vid -pedantic" +msgstr "Varna inte om användning av ”long long” vid -pedantic." #: c-family/c.opt:554 -#, fuzzy -#| msgid "Warn about suspicious declarations of \"main\"" msgid "Warn about suspicious declarations of \"main\"." -msgstr "Varna för tveksamma deklarationer av ”main”" +msgstr "Varna för tveksamma deklarationer av ”main”." #: c-family/c.opt:562 -#, fuzzy -#| msgid "Warn about suspicious calls to memset where the third argument is constant literal zero and the second is not" msgid "Warn about suspicious calls to memset where the third argument is constant literal zero and the second is not." -msgstr "Varna för misstänkta anrop till memset där det tredje argumentet är en konstant literal nolla och det andra inte är det" +msgstr "Varna för misstänkta anrop till memset där det tredje argumentet är en konstant literal nolla och det andra inte är det." #: c-family/c.opt:566 -#, fuzzy -#| msgid "Warn when the packed attribute has no effect on struct layout" msgid "Warn when the indentation of the code does not reflect the block structure." -msgstr "Varna när attributet packed inte har någon effekt på postformatet" +msgstr "Varna när indenteringen av koden inte avspeglar blockstrukturen." #: c-family/c.opt:570 -#, fuzzy -#| msgid "Warn about possibly missing braces around initializers" msgid "Warn about possibly missing braces around initializers." -msgstr "Varna för eventuellt saknade klamrar runt initierare" +msgstr "Varna för eventuellt saknade klamrar runt initierare." #: c-family/c.opt:574 -#, fuzzy -#| msgid "Warn about global functions without previous declarations" msgid "Warn about global functions without previous declarations." -msgstr "Varna för globala funktioner utan tidigare deklaration" +msgstr "Varna för globala funktioner utan tidigare deklaration." #: c-family/c.opt:578 -#, fuzzy -#| msgid "Warn about missing fields in struct initializers" msgid "Warn about missing fields in struct initializers." -msgstr "Varna för saknade fält i postinitierare" +msgstr "Varna för saknade fält i postinitierare." #: c-family/c.opt:582 msgid "Warn on direct multiple inheritance." @@ -7006,80 +6470,56 @@ msgid "Warn on namespace definition." msgstr "Varna vid namnrymdsdefinition." #: c-family/c.opt:590 -#, fuzzy -#| msgid "Warn about missing sized deallocation functions" msgid "Warn about missing sized deallocation functions." -msgstr "Varna för saknade storleksbestämda deallokeringsfunktioner" +msgstr "Varna för saknade storleksbestämda deallokeringsfunktioner." #: c-family/c.opt:594 -#, fuzzy -#| msgid "Warn about suspicious length parameters to certain string functions if the argument uses sizeof" msgid "Warn about suspicious length parameters to certain string functions if the argument uses sizeof." -msgstr "Varna för misstänkta längdparametrar till vissa strängfunktioner om argumentet använder sizeof" +msgstr "Varna för misstänkta längdparametrar till vissa strängfunktioner om argumentet använder sizeof." #: c-family/c.opt:598 -#, fuzzy -#| msgid "Warn when sizeof is applied on a parameter declared as an array" msgid "Warn when sizeof is applied on a parameter declared as an array." -msgstr "Varna när sizeof används på en parameter som är deklarerad som en vektor" +msgstr "Varna när sizeof används på en parameter som är deklarerad som en vektor." #: c-family/c.opt:602 -#, fuzzy -#| msgid "Warn about functions which might be candidates for format attributes" msgid "Warn about functions which might be candidates for format attributes." -msgstr "Varna för funktioner som kan vara kandidater för formatattribut" +msgstr "Varna för funktioner som kan vara kandidater för formatattribut." #: c-family/c.opt:606 msgid "Suggest that the override keyword be used when the declaration of a virtual" msgstr "Föreslå att använda nyckelordet override när deklarationen av en virtuell funktion åsidosätter en annan" #: c-family/c.opt:611 -#, fuzzy -#| msgid "Warn about enumerated switches, with no default, missing a case" msgid "Warn about enumerated switches, with no default, missing a case." -msgstr "Varna när hopptabeller för uppräkningstyper inte har standardfall och saknar ett fall" +msgstr "Varna när hopptabeller för uppräkningstyper inte har standardfall och saknar ett fall." #: c-family/c.opt:615 -#, fuzzy -#| msgid "Warn about enumerated switches missing a \"default:\" statement" msgid "Warn about enumerated switches missing a \"default:\" statement." -msgstr "Varna för uppräkningshopptabeller saknar en ”default:”-sats" +msgstr "Varna för uppräkningshopptabeller saknar en ”default:”-sats." #: c-family/c.opt:619 -#, fuzzy -#| msgid "Warn about all enumerated switches missing a specific case" msgid "Warn about all enumerated switches missing a specific case." -msgstr "Varna för alla uppräkningshopptabeller som saknar ett specifikt fall" +msgstr "Varna för alla uppräkningshopptabeller som saknar ett specifikt fall." #: c-family/c.opt:623 -#, fuzzy -#| msgid "Warn about switches with boolean controlling expression" msgid "Warn about switches with boolean controlling expression." -msgstr "Varna för hopptabeller med booleska styruttryck" +msgstr "Varna för hopptabeller med booleska styruttryck." #: c-family/c.opt:627 -#, fuzzy -#| msgid "for template declaration %q+D" msgid "Warn on primary template declaration." -msgstr "för malldeklaration %q+D" +msgstr "Varna vid primär malldeklaration." #: c-family/c.opt:635 -#, fuzzy -#| msgid "Warn about user-specified include directories that do not exist" msgid "Warn about user-specified include directories that do not exist." -msgstr "Varna för användarangivna inkluderingskataloger som inte finns" +msgstr "Varna för användarangivna inkluderingskataloger som inte finns." #: c-family/c.opt:639 -#, fuzzy -#| msgid "Warn about function parameters declared without a type specifier in K&R-style functions" msgid "Warn about function parameters declared without a type specifier in K&R-style functions." -msgstr "Varna för funktionsparametrar som deklarerats utan en typangivelse i K&R-stilfunktioner" +msgstr "Varna för funktionsparametrar som deklarerats utan en typangivelse i K&R-stilfunktioner." #: c-family/c.opt:643 -#, fuzzy -#| msgid "Warn about global functions without prototypes" msgid "Warn about global functions without prototypes." -msgstr "Varna för globala funktioner utan prototyper" +msgstr "Varna för globala funktioner utan prototyper." #: c-family/c.opt:646 c-family/c.opt:1008 c-family/c.opt:1015 #: c-family/c.opt:1189 c-family/c.opt:1208 c-family/c.opt:1231 @@ -7094,453 +6534,313 @@ msgid "switch %qs is no longer supported" msgstr "flaggan %qs stödjs inte längre" #: c-family/c.opt:650 -#, fuzzy -#| msgid "Warn about use of multi-character character constants" msgid "Warn about use of multi-character character constants." -msgstr "Varna vid användning av flerteckens teckenkonstant" +msgstr "Varna vid användning av flerteckens teckenkonstant." #: c-family/c.opt:654 -#, fuzzy -#| msgid "Warn about narrowing conversions within { } that are ill-formed in C++11" msgid "Warn about narrowing conversions within { } that are ill-formed in C++11." -msgstr "Varna för avsmalnande konverteringar inom { } som är felformulerad i C++11" +msgstr "Varna för avsmalnande konverteringar inom { } som är felformulerad i C++11." #: c-family/c.opt:658 -#, fuzzy -#| msgid "Warn about \"extern\" declarations not at file scope" msgid "Warn about \"extern\" declarations not at file scope." -msgstr "Varna för ”extern”-deklaration som inte är på filnivå" +msgstr "Varna för ”extern”-deklaration som inte är på filnivå." #: c-family/c.opt:662 -#, fuzzy -#| msgid "Warn when a noexcept expression evaluates to false even though the expression can't actually throw" msgid "Warn when a noexcept expression evaluates to false even though the expression can't actually throw." -msgstr "Varna när ett noexcept-uttryck beräknas till false även om uttrycket inte faktiskt kan kasta" +msgstr "Varna när ett noexcept-uttryck beräknas till false även om uttrycket inte faktiskt kan kasta." #: c-family/c.opt:666 -#, fuzzy -#| msgid "Warn when non-templatized friend functions are declared within a template" msgid "Warn when non-templatized friend functions are declared within a template." -msgstr "Varna när en vänfuktion som inte är en mall deklareras inuti en mall" +msgstr "Varna när en vänfuktion som inte är en mall deklareras inuti en mall." #: c-family/c.opt:670 -#, fuzzy -#| msgid "Warn about non-virtual destructors" msgid "Warn about non-virtual destructors." -msgstr "Varna för ickevirtuella destruerare" +msgstr "Varna för ickevirtuella destruerare." #: c-family/c.opt:674 -#, fuzzy -#| msgid "Warn about NULL being passed to argument slots marked as requiring non-NULL" msgid "Warn about NULL being passed to argument slots marked as requiring non-NULL." -msgstr "Varna om NULL skickas som argument som är markerade att de kräver icke-NULL" +msgstr "Varna om NULL skickas som argument som är markerade att de kräver icke-NULL." #: c-family/c.opt:686 -#, fuzzy -#| msgid "-Wnormalized=\tWarn about non-normalised Unicode strings" msgid "-Wnormalized=\tWarn about non-normalised Unicode strings." -msgstr "-Wnormalized=\tVarna för icke normaliserade Unicodesträngar" +msgstr "-Wnormalized=\tVarna för icke normaliserade Unicodesträngar." #: c-family/c.opt:693 msgid "argument %qs to %<-Wnormalized%> not recognized" msgstr "argumentet %qs till %<-Wnormalized%> är inte känt" #: c-family/c.opt:709 -#, fuzzy -#| msgid "Warn if a C-style cast is used in a program" msgid "Warn if a C-style cast is used in a program." -msgstr "Varna för en typkonvertering i C-stil används i ett program" +msgstr "Varna för en typkonvertering i C-stil används i ett program." #: c-family/c.opt:713 -#, fuzzy -#| msgid "Warn for obsolescent usage in a declaration" msgid "Warn for obsolescent usage in a declaration." -msgstr "Varna för föråldrad användning i en deklaration" +msgstr "Varna för föråldrad användning i en deklaration." #: c-family/c.opt:717 -#, fuzzy -#| msgid "Warn if an old-style parameter definition is used" msgid "Warn if an old-style parameter definition is used." -msgstr "Varna för en gammaldags parameterdefinition används" +msgstr "Varna för en gammaldags parameterdefinition används." #: c-family/c.opt:721 -#, fuzzy -#| msgid "Warn if a simd directive is overridden by the vectorizer cost model" msgid "Warn if a simd directive is overridden by the vectorizer cost model." -msgstr "Varna om ett simd-direktiv åsidosätts av vektoriserarens kostnadsmodell" +msgstr "Varna om ett simd-direktiv åsidosätts av vektoriserarens kostnadsmodell." #: c-family/c.opt:725 -#, fuzzy -#| msgid "Warn if a string is longer than the maximum portable length specified by the standard" msgid "Warn if a string is longer than the maximum portable length specified by the standard." -msgstr "Varna om en sträng är längre än den maximala portabla längden som anges i standarden" +msgstr "Varna om en sträng är längre än den maximala portabla längden som anges i standarden." #: c-family/c.opt:729 -#, fuzzy -#| msgid "Warn about overloaded virtual function names" msgid "Warn about overloaded virtual function names." -msgstr "Varna för överlagrade virtuella funktionsnamn" +msgstr "Varna för överlagrade virtuella funktionsnamn." #: c-family/c.opt:733 -#, fuzzy -#| msgid "Warn about overriding initializers without side effects" msgid "Warn about overriding initializers without side effects." -msgstr "Varna för åsidosättande initierare utan sidoeffekter" +msgstr "Varna för åsidosättande initierare utan sidoeffekter." #: c-family/c.opt:737 -#, fuzzy -#| msgid "Warn about overriding initializers without side effects" msgid "Warn about overriding initializers with side effects." -msgstr "Varna för åsidosättande initierare utan sidoeffekter" +msgstr "Varna för åsidosättande initierare utan sidoeffekter." #: c-family/c.opt:741 -#, fuzzy -#| msgid "Warn about packed bit-fields whose offset changed in GCC 4.4" msgid "Warn about packed bit-fields whose offset changed in GCC 4.4." -msgstr "Varna för packade bitfält vars avstånd ändrats i GCC 4.4" +msgstr "Varna för packade bitfält vars avstånd ändrats i GCC 4.4." #: c-family/c.opt:745 -#, fuzzy -#| msgid "Warn about possibly missing parentheses" msgid "Warn about possibly missing parentheses." -msgstr "Varna för eventuellt saknade parenteser" +msgstr "Varna för eventuellt saknade parenteser." #: c-family/c.opt:753 -#, fuzzy -#| msgid "Warn when converting the type of pointers to member functions" msgid "Warn when converting the type of pointers to member functions." -msgstr "Varna vid typkonvertering av pekare till medlemsfunktioner" +msgstr "Varna vid typkonvertering av pekare till medlemsfunktioner." #: c-family/c.opt:757 -#, fuzzy -#| msgid "Warn about function pointer arithmetic" msgid "Warn about function pointer arithmetic." -msgstr "Varna för aritmetik med funktionspekare" +msgstr "Varna för aritmetik med funktionspekare." #: c-family/c.opt:761 -#, fuzzy -#| msgid "Warn when a pointer differs in signedness in an assignment" msgid "Warn when a pointer differs in signedness in an assignment." -msgstr "Varna när en pekare skiljer i teckenhet i en tilldelning" +msgstr "Varna när en pekare skiljer i teckenhet i en tilldelning." #: c-family/c.opt:765 -#, fuzzy -#| msgid "Warn when a pointer is cast to an integer of a different size" msgid "Warn when a pointer is cast to an integer of a different size." -msgstr "Varna när en pekare typkonverteras till ett heltal av annan storlek" +msgstr "Varna när en pekare typkonverteras till ett heltal av annan storlek." #: c-family/c.opt:769 -#, fuzzy -#| msgid "Warn about misuses of pragmas" msgid "Warn about misuses of pragmas." -msgstr "Varna för missbruk av pragman" +msgstr "Varna för missbruk av pragman." #: c-family/c.opt:773 -#, fuzzy -#| msgid "Warn if a property for an Objective-C object has no assign semantics specified" msgid "Warn if a property for an Objective-C object has no assign semantics specified." -msgstr "Varna om en egenskap för ett Objective-C-objekt inte har någon tilldelningssemantik angiven" +msgstr "Varna om en egenskap för ett Objective-C-objekt inte har någon tilldelningssemantik angiven." #: c-family/c.opt:777 -#, fuzzy -#| msgid "Warn if inherited methods are unimplemented" msgid "Warn if inherited methods are unimplemented." -msgstr "Varna för ärvda metoder är oimplementerade" +msgstr "Varna för ärvda metoder är oimplementerade." #: c-family/c.opt:781 -#, fuzzy -#| msgid "Warn if a loop with constant number of iterations triggers undefined behavior" msgid "Warn for placement new expressions with undefined behavior." -msgstr "Varna om en slinga med konstant antal iterationer orsakar odefinierat beteende" +msgstr "Varna för placerande new-uttryck med odefinierat beteende." #: c-family/c.opt:785 -#, fuzzy -#| msgid "Warn about multiple declarations of the same object" msgid "Warn about multiple declarations of the same object." -msgstr "Varna för multipla deklarationer av samma objekt" +msgstr "Varna för multipla deklarationer av samma objekt." #: c-family/c.opt:789 -#, fuzzy -#| msgid "Warn when the compiler reorders code" msgid "Warn when the compiler reorders code." -msgstr "Varna när kompilatorn ändrar ordning på kod" +msgstr "Varna när kompilatorn ändrar ordning på kod." #: c-family/c.opt:793 -#, fuzzy -#| msgid "Warn whenever a function's return type defaults to \"int\" (C), or about inconsistent return types (C++)" msgid "Warn whenever a function's return type defaults to \"int\" (C), or about inconsistent return types (C++)." -msgstr "Varna när en funktions returtyp får ”int” som skönsvärde (C), eller om inkonsistenta returtyper (C++)" +msgstr "Varna när en funktions returtyp får ”int” som skönsvärde (C), eller om inkonsistenta returtyper (C++)." #: c-family/c.opt:797 msgid "Warn on suspicious constructs involving reverse scalar storage order." msgstr "Varna vid misstänkta konstruktioner med omvänd ordning av skalärlagring inblandad." #: c-family/c.opt:801 -#, fuzzy -#| msgid "Warn if a selector has multiple methods" msgid "Warn if a selector has multiple methods." -msgstr "Varna för en väljare har multipla metoder" +msgstr "Varna för en väljare har multipla metoder." #: c-family/c.opt:805 -#, fuzzy -#| msgid "Warn about possible violations of sequence point rules" msgid "Warn about possible violations of sequence point rules." -msgstr "Varna för möjliga brott mot sekvenspunktregler" +msgstr "Varna för möjliga brott mot sekvenspunktregler." #: c-family/c.opt:809 -#, fuzzy -#| msgid "Warn if a local declaration hides an instance variable" msgid "Warn if a local declaration hides an instance variable." -msgstr "Varna om en lokal deklaration döljer en instansvariabel" +msgstr "Varna om en lokal deklaration döljer en instansvariabel." #: c-family/c.opt:813 c-family/c.opt:817 msgid "Warn if left shift of a signed value overflows." msgstr "Varna om vänsterskift av ett värde med tecken spiller över." #: c-family/c.opt:821 -#, fuzzy -#| msgid "Warn if shift count is negative" msgid "Warn if shift count is negative." -msgstr "Varna om skiftantalet är negativt" +msgstr "Varna om skiftantalet är negativt." #: c-family/c.opt:825 -#, fuzzy -#| msgid "Warn if shift count >= width of type" msgid "Warn if shift count >= width of type." -msgstr "Varna om skiftantalet ≥ bredden på typen" +msgstr "Varna om skiftantalet ≥ bredden på typen." #: c-family/c.opt:829 -#, fuzzy -#| msgid "Warn if shift count is negative" msgid "Warn if left shifting a negative value." -msgstr "Varna om skiftantalet är negativt" +msgstr "Varna vid vänsterskift med ett negativt värde." #: c-family/c.opt:833 -#, fuzzy -#| msgid "Warn about signed-unsigned comparisons" msgid "Warn about signed-unsigned comparisons." -msgstr "Varna för jämförelser mellan signed/unsigned" +msgstr "Varna för jämförelser mellan signed/unsigned." #: c-family/c.opt:841 -#, fuzzy -#| msgid "Warn for implicit type conversions between signed and unsigned integers" msgid "Warn for implicit type conversions between signed and unsigned integers." -msgstr "Varna för implicita typkonverteringar mellan heltalsuttryck med och utan tecken" +msgstr "Varna för implicita typkonverteringar mellan heltalsuttryck med och utan tecken." #: c-family/c.opt:845 -#, fuzzy -#| msgid "Warn when overload promotes from unsigned to signed" msgid "Warn when overload promotes from unsigned to signed." -msgstr "Varna när överlagring anpassar från teckenlöst till med tecken" +msgstr "Varna när överlagring anpassar från teckenlöst till med tecken." #: c-family/c.opt:849 -#, fuzzy -#| msgid "Warn about uncasted NULL used as sentinel" msgid "Warn about uncasted NULL used as sentinel." -msgstr "Varna för ej typkonverterad NULL används som vaktpost" +msgstr "Varna för ej typkonverterad NULL används som vaktpost." #: c-family/c.opt:853 -#, fuzzy -#| msgid "Warn about unprototyped function declarations" msgid "Warn about unprototyped function declarations." -msgstr "Varna för funktionsdeklarationer utan prototyp" +msgstr "Varna för funktionsdeklarationer utan prototyp." #: c-family/c.opt:865 -#, fuzzy -#| msgid "Warn if type signatures of candidate methods do not match exactly" msgid "Warn if type signatures of candidate methods do not match exactly." -msgstr "Varna för typsignaturer till kandidatmetoder inte stämmer exakt" +msgstr "Varna för typsignaturer till kandidatmetoder inte stämmer exakt." #: c-family/c.opt:869 -#, fuzzy -#| msgid "Warn when __sync_fetch_and_nand and __sync_nand_and_fetch built-in functions are used" msgid "Warn when __sync_fetch_and_nand and __sync_nand_and_fetch built-in functions are used." -msgstr "Varna när de inbyggda funktionerna __sync_fetch_and_nand och __sync_nand_and_fetch används" +msgstr "Varna när de inbyggda funktionerna __sync_fetch_and_nand och __sync_nand_and_fetch används." #: c-family/c.opt:873 -#, fuzzy -#| msgid "Deprecated. This switch has no effect" msgid "Deprecated. This switch has no effect." -msgstr "Avrådes ifrån. Denna flagga har ingen effekt" +msgstr "Avrådes ifrån. Denna flagga har ingen effekt." #: c-family/c.opt:881 -#, fuzzy -#| msgid "Warn when a logical operator is suspiciously always evaluating to true or false" msgid "Warn if a comparison always evaluates to true or false." -msgstr "Varna när en logisk operator misstänkt nog alltid beräknas till sant eller falskt" +msgstr "Varna om en logisk jämförelse alltid beräknas till sant eller falskt." #: c-family/c.opt:885 msgid "Warn if a throw expression will always result in a call to terminate()." msgstr "Varna om ett throw-uttryck alltid kommer resultera i ett anrop av terminate()." #: c-family/c.opt:889 -#, fuzzy -#| msgid "Warn about features not present in traditional C" msgid "Warn about features not present in traditional C." -msgstr "Varna för funktioner som inte finns i traditionell C" +msgstr "Varna för funktioner som inte finns i traditionell C." #: c-family/c.opt:893 -#, fuzzy -#| msgid "Warn of prototypes causing type conversions different from what would happen in the absence of prototype" msgid "Warn of prototypes causing type conversions different from what would happen in the absence of prototype." -msgstr "Varna för prototyper som orsakar andra typkonverteringar än de som skulle skett i frånvaro av prototyp" +msgstr "Varna för prototyper som orsakar andra typkonverteringar än de som skulle skett i frånvaro av prototyp." #: c-family/c.opt:897 -#, fuzzy -#| msgid "Warn if trigraphs are encountered that might affect the meaning of the program" msgid "Warn if trigraphs are encountered that might affect the meaning of the program." -msgstr "Varna för trigrafer upptäcks som kan påverka betydelsen av programmet" +msgstr "Varna för trigrafer upptäcks som kan påverka betydelsen av programmet." #: c-family/c.opt:901 -#, fuzzy -#| msgid "Warn about @selector()s without previously declared methods" msgid "Warn about @selector()s without previously declared methods." -msgstr "Varna för @selector()er utan tidigare deklarerade metoder" +msgstr "Varna för @selector()er utan tidigare deklarerade metoder." #: c-family/c.opt:905 -#, fuzzy -#| msgid "Warn if an undefined macro is used in an #if directive" msgid "Warn if an undefined macro is used in an #if directive." -msgstr "Varna för ett odefinierat makro används i ett #if-direktiv" +msgstr "Varna för ett odefinierat makro används i ett #if-direktiv." #: c-family/c.opt:917 -#, fuzzy -#| msgid "Warn about unrecognized pragmas" msgid "Warn about unrecognized pragmas." -msgstr "Varna för okända pragman" +msgstr "Varna för okända pragman." #: c-family/c.opt:921 -#, fuzzy -#| msgid "Warn about unsuffixed float constants" msgid "Warn about unsuffixed float constants." -msgstr "Varna för flyttalskonstanter utan suffix" +msgstr "Varna för flyttalskonstanter utan suffix." #: c-family/c.opt:929 -#, fuzzy -#| msgid "Warn when typedefs locally defined in a function are not used" msgid "Warn when typedefs locally defined in a function are not used." -msgstr "Varna när typedef:ar lokalt definierade i en funktion inte används" +msgstr "Varna när typedef:ar lokalt definierade i en funktion inte används." #: c-family/c.opt:933 -#, fuzzy -#| msgid "Warn about macros defined in the main file that are not used" msgid "Warn about macros defined in the main file that are not used." -msgstr "Varna för makron definierade i huvudfilen som inte används" +msgstr "Varna för makron definierade i huvudfilen som inte används." #: c-family/c.opt:937 -#, fuzzy -#| msgid "Warn if a caller of a function, marked with attribute warn_unused_result, does not use its return value" msgid "Warn if a caller of a function, marked with attribute warn_unused_result, does not use its return value." -msgstr "Varna om anroparen av en funktion, deklarerad med attributet warn_unused_result, inte använder dess returvärde" +msgstr "Varna om anroparen av en funktion, deklarerad med attributet warn_unused_result, inte använder dess returvärde." #: c-family/c.opt:945 -#, fuzzy -#| msgid "Warn when a variable is unused" msgid "Warn when a const variable is unused." -msgstr "Varna när en variabel är oanvänd" +msgstr "Varna när en const-variabel är oanvänd." #: c-family/c.opt:949 -#, fuzzy -#| msgid "Warn about using variadic macros" msgid "Warn about using variadic macros." -msgstr "Varna för användning av variadiska makron" +msgstr "Varna för användning av variadiska makron." #: c-family/c.opt:953 -#, fuzzy -#| msgid "Warn about questionable usage of the macros used to retrieve variable arguments" msgid "Warn about questionable usage of the macros used to retrieve variable arguments." -msgstr "Varna för tveksam användning av de makron som används för att hämta variabla argument." +msgstr "Varna för tveksam användning av de makron som används för att hämta variabla argument.." #: c-family/c.opt:957 -#, fuzzy -#| msgid "Warn if a variable length array is used" msgid "Warn if a variable length array is used." -msgstr "Varna om en vektor med variabel längd används" +msgstr "Varna om en vektor med variabel längd används." #: c-family/c.opt:961 -#, fuzzy -#| msgid "Warn when a register variable is declared volatile" msgid "Warn when a register variable is declared volatile." -msgstr "Varna när en registervariabel är deklarerad volatile" +msgstr "Varna när en registervariabel är deklarerad volatile." #: c-family/c.opt:965 msgid "Warn on direct virtual inheritance." msgstr "Varna vid direkt virtuellt arv." #: c-family/c.opt:969 -#, fuzzy -#| msgid "Warn if a virtual base has a non-trivial move assignment operator" msgid "Warn if a virtual base has a non-trivial move assignment operator." -msgstr "Varna om en virtuella bas har en icketrivial flyttningstilldelningsoperator" +msgstr "Varna om en virtuella bas har en icketrivial flyttningstilldelningsoperator." #: c-family/c.opt:973 msgid "In C++, nonzero means warn about deprecated conversion from string literals to 'char *'. In C, similar warning, except that the conversion is of course not deprecated by the ISO C standard." msgstr "I C++ betyder nollskilt att varna för konverteringar som bör undvikas från strängliteraler till ”char *”. I C, liknande varning, bortsett från att ISO C-standarden naturligtvis inte säger att konverteringen bör undvikas." #: c-family/c.opt:977 -#, fuzzy -#| msgid "Warn when a literal '0' is used as null pointer" msgid "Warn when a literal '0' is used as null pointer." -msgstr "Varna när en ordagrann ”0” används som en nollpekare" +msgstr "Varna när en ordagrann ”0” används som en nollpekare." #: c-family/c.opt:981 -#, fuzzy -#| msgid "Warn about useless casts" msgid "Warn about useless casts." -msgstr "Varna för oanvändbara typkonverteringar" +msgstr "Varna för oanvändbara typkonverteringar." #: c-family/c.opt:985 msgid "Warn if a class type has a base or a field whose type uses the anonymous namespace or depends on a type with no linkage." msgstr "Varna om en klasstyp har en bas eller ett fält vars typ använder den anonyma namnrymden eller beror på en typ utan länkningsklass." #: c-family/c.opt:989 -#, fuzzy -#| msgid "A synonym for -std=c89 (for C) or -std=c++98 (for C++)" msgid "A synonym for -std=c89 (for C) or -std=c++98 (for C++)." -msgstr "En synonym för -std=c89 (för C) or -std=c++98 (för C++)" +msgstr "En synonym för -std=c89 (för C) or -std=c++98 (för C++)." #: c-family/c.opt:997 -#, fuzzy -#| msgid "The version of the C++ ABI used for -Wabi warnings and link compatibility aliases" msgid "The version of the C++ ABI used for -Wabi warnings and link compatibility aliases." -msgstr "Versionen på det C++-ABI som används för -Wabi-varningar och länkkompatibilitetsalias" +msgstr "Versionen på det C++-ABI som används för -Wabi-varningar och länkkompatibilitetsalias." #: c-family/c.opt:1001 -#, fuzzy -#| msgid "Enforce class member access control semantics" msgid "Enforce class member access control semantics." -msgstr "Upprätthåll åtkomstsemantik för klassmedlemmar" +msgstr "Upprätthåll åtkomstsemantik för klassmedlemmar." #: c-family/c.opt:1005 -#, fuzzy -#| msgid "-fada-spec-parent=unit Dump Ada specs as child units of given parent" msgid "-fada-spec-parent=unit Dump Ada specs as child units of given parent." -msgstr "-fada-spec-parent=unit Skriv ut Ada-specifikationer som barnenheter till den givna föräldern" +msgstr "-fada-spec-parent=unit Skriv ut Ada-specifikationer som barnenheter till den givna föräldern." #: c-family/c.opt:1012 -#, fuzzy -#| msgid "Allow variadic functions without named parameter" msgid "Allow variadic functions without named parameter." -msgstr "Tillåt variadiska funktioner utan namngiven parameter" +msgstr "Tillåt variadiska funktioner utan namngiven parameter." #: c-family/c.opt:1016 c-family/c.opt:1245 c-family/c.opt:1533 #: c-family/c.opt:1537 c-family/c.opt:1553 -#, fuzzy -#| msgid "No longer supported" msgid "No longer supported." -msgstr "Stödjs inte längre" +msgstr "Stödjs inte längre." #: c-family/c.opt:1020 -#, fuzzy -#| msgid "Recognize the \"asm\" keyword" msgid "Recognize the \"asm\" keyword." -msgstr "Acceptera nyckelordet ”asm”" +msgstr "Acceptera nyckelordet ”asm”." #: c-family/c.opt:1028 -#, fuzzy -#| msgid "Recognize built-in functions" msgid "Recognize built-in functions." -msgstr "Acceptera inbyggda funktioner" +msgstr "Acceptera inbyggda funktioner." #: c-family/c.opt:1035 msgid "Where shorter, use canonicalized paths to systems headers." @@ -7551,10 +6851,8 @@ msgid "Add Pointer Bounds Checker instrumentation. fchkp-* flags are used to" msgstr "Lägg till instrumentering för pekargränskontroller. fchkp-*-flaggor används för att styra instrumenteringen. För närvarande tillgängligt för C, C++ och ObjC." #: c-family/c.opt:1044 -#, fuzzy -#| msgid "Generate pointer bounds checks for variables with incomplete type" msgid "Generate pointer bounds checks for variables with incomplete type." -msgstr "Generera pekargränskontroller för variabler med ofullständig typ" +msgstr "Generera pekargränskontroller för variabler med ofullständig typ." #: c-family/c.opt:1048 msgid "Use zero bounds for all incoming arguments in 'main' function. It helps when" @@ -7621,22 +6919,16 @@ msgid "Transform instrumented builtin calls into calls to wrappers." msgstr "Transformera instrumenterade inbyggda anrop till anrop av inkapslingar." #: c-family/c.opt:1127 -#, fuzzy -#| msgid "Enable Cilk Plus" msgid "Enable Cilk Plus." -msgstr "Aktiver Cilk Plus" +msgstr "Aktiver Cilk Plus." #: c-family/c.opt:1131 -#, fuzzy -#| msgid "Enable support for GNU transactional memory" msgid "Enable support for C++ concepts." -msgstr "Aktivera stöd för GNU:s transationsminne" +msgstr "Aktivera stöd för C++-koncept." #: c-family/c.opt:1135 -#, fuzzy -#| msgid "Allow the arguments of the '?' operator to have different types" msgid "Allow the arguments of the '?' operator to have different types." -msgstr "Tillåt argument till ”?”-operatorn att ha olika typer" +msgstr "Tillåt argument till ”?”-operatorn att ha olika typer." #: c-family/c.opt:1142 #, c-format @@ -7644,188 +6936,132 @@ msgid "no class name specified with %qs" msgstr "inget klassnamn angivet med %qs" #: c-family/c.opt:1143 -#, fuzzy -#| msgid "-fconst-string-class=\tUse class for constant strings" msgid "-fconst-string-class=\tUse class for constant strings." -msgstr "-fconst-string-class=\tAnvänd klassen för konstanta strängar" +msgstr "-fconst-string-class=\tAnvänd klassen för konstanta strängar." #: c-family/c.opt:1147 -#, fuzzy -#| msgid "-fconstexpr-depth=\tSpecify maximum constexpr recursion depth" msgid "-fconstexpr-depth=\tSpecify maximum constexpr recursion depth." -msgstr "-fconstexpr-depth=\tAnge maximalt rekursionsdjup för konstantuttryck" +msgstr "-fconstexpr-depth=\tAnge maximalt rekursionsdjup för konstantuttryck." #: c-family/c.opt:1151 -#, fuzzy -#| msgid "Emit debug annotations during preprocessing" msgid "Emit debug annotations during preprocessing." -msgstr "Mata ut felsökningsannoteringar under preprocessning" +msgstr "Mata ut felsökningsannoteringar under preprocessning." #: c-family/c.opt:1155 -#, fuzzy -#| msgid "-fdeduce-init-list\tenable deduction of std::initializer_list for a template type parameter from a brace-enclosed initializer-list" msgid "-fdeduce-init-list\tenable deduction of std::initializer_list for a template type parameter from a brace-enclosed initializer-list." -msgstr "-fdeduce-init-list\taktivera härledning av std::initializer_list för en malltypparameter från en klammeromsluten initierarlista" +msgstr "-fdeduce-init-list\taktivera härledning av std::initializer_list för en malltypparameter från en klammeromsluten initierarlista." #: c-family/c.opt:1159 -#, fuzzy -#| msgid "Factor complex constructors and destructors to favor space over speed" msgid "Factor complex constructors and destructors to favor space over speed." -msgstr "Faktorisera komplexa konstruerare och destruerare till förmån för utrymme snarare än hastighet" +msgstr "Faktorisera komplexa konstruerare och destruerare till förmån för utrymme snarare än hastighet." #: c-family/c.opt:1167 msgid "Preprocess directives only." msgstr "Preprocessa endast direktiv." #: c-family/c.opt:1171 -#, fuzzy -#| msgid "Permit '$' as an identifier character" msgid "Permit '$' as an identifier character." -msgstr "Tillåt ”$” som ett identifierartecken" +msgstr "Tillåt ”$” som ett identifierartecken." #: c-family/c.opt:1175 -#, fuzzy -#| msgid "Write all declarations as Ada code transitively" msgid "Write all declarations as Ada code transitively." -msgstr "Skriv alla deklarationer som Adakod transitivt" +msgstr "Skriv alla deklarationer som Adakod transitivt." #: c-family/c.opt:1179 -#, fuzzy -#| msgid "Write all declarations as Ada code for the given file only" msgid "Write all declarations as Ada code for the given file only." -msgstr "Skriv alla deklarationer som Adakod endast för den angivna filen" +msgstr "Skriv alla deklarationer som Adakod endast för den angivna filen." #: c-family/c.opt:1186 -#, fuzzy -#| msgid "Generate code to check exception specifications" msgid "Generate code to check exception specifications." -msgstr "Generera kod för att kontrollera undantagsspecifikationer" +msgstr "Generera kod för att kontrollera undantagsspecifikationer." #: c-family/c.opt:1193 -#, fuzzy -#| msgid "-fexec-charset=\tConvert all strings and character constants to character set " msgid "-fexec-charset=\tConvert all strings and character constants to character set ." -msgstr "-fexec-charset=\tKonvertera alla strängar och teckenkonstanter till teckenuppsättningen " +msgstr "-fexec-charset=\tKonvertera alla strängar och teckenkonstanter till teckenuppsättningen ." #: c-family/c.opt:1197 -#, fuzzy -#| msgid "Permit universal character names (\\u and \\U) in identifiers" msgid "Permit universal character names (\\u and \\U) in identifiers." -msgstr "Tillåt universella teckennamn (\\u och \\U) i identifierare" +msgstr "Tillåt universella teckennamn (\\u och \\U) i identifierare." #: c-family/c.opt:1201 -#, fuzzy -#| msgid "-finput-charset=\tSpecify the default character set for source files" msgid "-finput-charset=\tSpecify the default character set for source files." -msgstr "-finput-charset=\tAnge standardteckenuppsättning för källkodsfiler" +msgstr "-finput-charset=\tAnge standardteckenuppsättning för källkodsfiler." #: c-family/c.opt:1205 -#, fuzzy -#| msgid "Support dynamic initialization of thread-local variables in a different translation unit" msgid "Support dynamic initialization of thread-local variables in a different translation unit." -msgstr "Stöd dynamisk initiering av trådlokala variabler i en annan översättningsenhet" +msgstr "Stöd dynamisk initiering av trådlokala variabler i en annan översättningsenhet." #: c-family/c.opt:1212 -#, fuzzy -#| msgid "Scope of for-init-statement variables is local to the loop" msgid "Scope of for-init-statement variables is local to the loop." -msgstr "Räckvidden av for-init-satsvariabler är lokal till slingan" +msgstr "Räckvidden av for-init-satsvariabler är lokal till slingan." #: c-family/c.opt:1216 -#, fuzzy -#| msgid "Do not assume that standard C libraries and \"main\" exist" msgid "Do not assume that standard C libraries and \"main\" exist." -msgstr "Anta inte att standard C-bibliotek och ”main” finns" +msgstr "Anta inte att standard C-bibliotek och ”main” finns." #: c-family/c.opt:1220 -#, fuzzy -#| msgid "Recognize GNU-defined keywords" msgid "Recognize GNU-defined keywords." -msgstr "Acceptera GNU-definierade nyckelord" +msgstr "Acceptera GNU-definierade nyckelord." #: c-family/c.opt:1224 -#, fuzzy -#| msgid "Generate code for GNU runtime environment" msgid "Generate code for GNU runtime environment." -msgstr "Generera kod för GNU:s körtidsmiljö" +msgstr "Generera kod för GNU:s körtidsmiljö." #: c-family/c.opt:1228 -#, fuzzy -#| msgid "Use traditional GNU semantics for inline functions" msgid "Use traditional GNU semantics for inline functions." -msgstr "Använd traditionell C-semantik för inline-funktioner" +msgstr "Använd traditionell C-semantik för inline-funktioner." #: c-family/c.opt:1234 msgid "-fhandle-exceptions has been renamed -fexceptions (and is now on by default)" msgstr "-fhandle-exceptions har bytt namn till -fexceptions (och är nu normalt påslagen)" #: c-family/c.opt:1241 -#, fuzzy -#| msgid "Assume normal C execution environment" msgid "Assume normal C execution environment." -msgstr "Anta normal C-körmiljö" +msgstr "Anta normal C-körmiljö." #: c-family/c.opt:1249 -#, fuzzy -#| msgid "Export functions even if they can be inlined" msgid "Export functions even if they can be inlined." -msgstr "Exportera funktioner även om de kan inline:as" +msgstr "Exportera funktioner även om de kan inline:as." #: c-family/c.opt:1253 -#, fuzzy -#| msgid "Emit implicit instantiations of inline templates" msgid "Emit implicit instantiations of inline templates." -msgstr "Skapa implicita instansieringar av inline:ade mallar" +msgstr "Skapa implicita instansieringar av inline:ade mallar." #: c-family/c.opt:1257 -#, fuzzy -#| msgid "Emit implicit instantiations of templates" msgid "Emit implicit instantiations of templates." -msgstr "Skapa implicita instansieringar av mallar" +msgstr "Skapa implicita instansieringar av mallar." #: c-family/c.opt:1261 -#, fuzzy -#| msgid "Inject friend functions into enclosing namespace" msgid "Inject friend functions into enclosing namespace." -msgstr "Skjut in friend-funktioner i omgivande namnrymd" +msgstr "Skjut in friend-funktioner i omgivande namnrymd." #: c-family/c.opt:1265 -#, fuzzy -#| msgid "Don't emit dllexported inline functions unless needed" msgid "Don't emit dllexported inline functions unless needed." -msgstr "Avge inte dll-exporterade inline-funktioner om det inte behövs" +msgstr "Avge inte dll-exporterade inline-funktioner om det inte behövs." #: c-family/c.opt:1272 msgid "Allow implicit conversions between vectors with differing numbers of subparts and/or differing element types." msgstr "Tillåt implicit konvertering mellan vektorer med olika antal underdelar och/eller olika elementtyper." #: c-family/c.opt:1276 -#, fuzzy -#| msgid "Don't warn about uses of Microsoft extensions" msgid "Don't warn about uses of Microsoft extensions." -msgstr "Varna inte om användning av Microsoftutökningar" +msgstr "Varna inte om användning av Microsoftutökningar." #: c-family/c.opt:1295 -#, fuzzy -#| msgid "Generate code for NeXT (Apple Mac OS X) runtime environment" msgid "Generate code for NeXT (Apple Mac OS X) runtime environment." -msgstr "Generera kod för körtidsmiljön NeXT (Apple Mac OS X)" +msgstr "Generera kod för körtidsmiljön NeXT (Apple Mac OS X)." #: c-family/c.opt:1299 -#, fuzzy -#| msgid "Assume that receivers of Objective-C messages may be nil" msgid "Assume that receivers of Objective-C messages may be nil." -msgstr "Anta att mottagare av Objective-C-meddelanden kan var nil" +msgstr "Anta att mottagare av Objective-C-meddelanden kan var nil." #: c-family/c.opt:1303 msgid "Allow access to instance variables as if they were local declarations within instance method implementations." msgstr "Tillåt åtkomst till instansvariabler som om de vore lokala deklarationer i instansmetodimplementationer." #: c-family/c.opt:1307 -#, fuzzy -#| msgid "-fvisibility=[private|protected|public|package]\tSet the default symbol visibility" msgid "-fvisibility=[private|protected|public|package]\tSet the default symbol visibility." -msgstr "-fvisibility=[private|protected|public|package]\tAnge standardvärde för symbolsynlighet" +msgstr "-fvisibility=[private|protected|public|package]\tAnge standardvärde för symbolsynlighet." #: c-family/c.opt:1310 #, c-format @@ -7833,658 +7069,449 @@ msgid "unrecognized ivar visibility value %qs" msgstr "okänt ivar-synlighetsvärde %qs" #: c-family/c.opt:1332 -#, fuzzy -#| msgid "Treat a throw() exception specification as noexcept to improve code size" msgid "Treat a throw() exception specification as noexcept to improve code size." -msgstr "Behandla en undantagsspecifikation throw() som noexcept för att förbättra kodstorleken" +msgstr "Behandla en undantagsspecifikation throw() som noexcept för att förbättra kodstorleken." #: c-family/c.opt:1336 msgid "Specify which ABI to use for Objective-C family code and meta-data generation." msgstr "Ange vilket ABI som skall användas för kodfamiljen Objective-C och generering av metadata." #: c-family/c.opt:1342 -#, fuzzy -#| msgid "Generate special Objective-C methods to initialize/destroy non-POD C++ ivars, if needed" msgid "Generate special Objective-C methods to initialize/destroy non-POD C++ ivars, if needed." -msgstr "Generera speciella Objective-C-metoder för att initiera/destruera icke-POD-C++-ivariabler, om det behövs" +msgstr "Generera speciella Objective-C-metoder för att initiera/destruera icke-POD-C++-ivariabler, om det behövs." #: c-family/c.opt:1346 -#, fuzzy -#| msgid "Allow fast jumps to the message dispatcher" msgid "Allow fast jumps to the message dispatcher." -msgstr "Tillåt snabba hopp till meddelandehanteraren" +msgstr "Tillåt snabba hopp till meddelandehanteraren." #: c-family/c.opt:1352 -#, fuzzy -#| msgid "Enable Objective-C exception and synchronization syntax" msgid "Enable Objective-C exception and synchronization syntax." -msgstr "Aktivera Objective-C-undantags- och synkroniseringssyntax" +msgstr "Aktivera Objective-C-undantags- och synkroniseringssyntax." #: c-family/c.opt:1356 -#, fuzzy -#| msgid "Enable garbage collection (GC) in Objective-C/Objective-C++ programs" msgid "Enable garbage collection (GC) in Objective-C/Objective-C++ programs." -msgstr "Aktivera skräpsamling (GC) i Objective-C-/Objective-C++-program" +msgstr "Aktivera skräpsamling (GC) i Objective-C-/Objective-C++-program." #: c-family/c.opt:1360 msgid "Enable inline checks for nil receivers with the NeXT runtime and ABI version 2." msgstr "Aktivera inline-kontroller av nil-mottagare med NeXT-körtidskod och ABI-version 2." #: c-family/c.opt:1365 -#, fuzzy -#| msgid "Enable Objective-C setjmp exception handling runtime" msgid "Enable Objective-C setjmp exception handling runtime." -msgstr "Aktivera Objective-C:s setjmp-undantagshantering i körtidsmiljön" +msgstr "Aktivera Objective-C:s setjmp-undantagshantering i körtidsmiljön." #: c-family/c.opt:1369 -#, fuzzy -#| msgid "Conform to the Objective-C 1.0 language as implemented in GCC 4.0" msgid "Conform to the Objective-C 1.0 language as implemented in GCC 4.0." -msgstr "Följ språket Objective-C 1.0 så som det implementerades i GCC 4.0" +msgstr "Följ språket Objective-C 1.0 så som det implementerades i GCC 4.0." #: c-family/c.opt:1373 -#, fuzzy -#| msgid "Enable OpenACC" msgid "Enable OpenACC." -msgstr "Aktivera OpenACC" +msgstr "Aktivera OpenACC." #: c-family/c.opt:1377 -#, fuzzy -#| msgid "Enable OpenMP (implies -frecursive in Fortran)" msgid "Enable OpenMP (implies -frecursive in Fortran)." -msgstr "Aktivera OpenMP (implicerar -frecursive i Fortran)" +msgstr "Aktivera OpenMP (implicerar -frecursive i Fortran)." #: c-family/c.opt:1381 -#, fuzzy -#| msgid "Enable OpenMP's SIMD directives" msgid "Enable OpenMP's SIMD directives." -msgstr "Aktivera OpenMP:s SIMD-direktiv" +msgstr "Aktivera OpenMP:s SIMD-direktiv." #: c-family/c.opt:1385 -#, fuzzy -#| msgid "Recognize C++ keywords like \"compl\" and \"xor\"" msgid "Recognize C++ keywords like \"compl\" and \"xor\"." -msgstr "Acceptera C++-nyckelord som ”compl” och ”xor”" +msgstr "Acceptera C++-nyckelord som ”compl” och ”xor”." #: c-family/c.opt:1396 -#, fuzzy -#| msgid "Look for and use PCH files even when preprocessing" msgid "Look for and use PCH files even when preprocessing." -msgstr "Sök efter och använd PCH-filer även vid preprocessning" +msgstr "Sök efter och använd PCH-filer även vid preprocessning." #: c-family/c.opt:1400 -#, fuzzy -#| msgid "Downgrade conformance errors to warnings" msgid "Downgrade conformance errors to warnings." -msgstr "Nedgradera följsamhetsfel till varningar" +msgstr "Nedgradera följsamhetsfel till varningar." #: c-family/c.opt:1404 -#, fuzzy -#| msgid "Enable Plan 9 language extensions" msgid "Enable Plan 9 language extensions." -msgstr "Aktivera språkutvidgningar från Plan 9" +msgstr "Aktivera språkutvidgningar från Plan 9." #: c-family/c.opt:1408 -#, fuzzy -#| msgid "Treat the input file as already preprocessed" msgid "Treat the input file as already preprocessed." -msgstr "Betrakta indatafilen som redan preprocessad" +msgstr "Betrakta indatafilen som redan preprocessad." #: c-family/c.opt:1416 -#, fuzzy -#| msgid "-ftrack-macro-expansion=<0|1|2> Track locations of tokens coming from macro expansion and display them in error messages" msgid "-ftrack-macro-expansion=<0|1|2> Track locations of tokens coming from macro expansion and display them in error messages." -msgstr "-ftrack-macro-expansion=<0|1|2> Spåra platser för symboler som kommer från makroexpansion och visa dem i felmeddelanden" +msgstr "-ftrack-macro-expansion=<0|1|2> Spåra platser för symboler som kommer från makroexpansion och visa dem i felmeddelanden." #: c-family/c.opt:1420 -#, fuzzy -#| msgid "-fno-pretty-templates Do not pretty-print template specializations as the template signature followed by the arguments" msgid "-fno-pretty-templates Do not pretty-print template specializations as the template signature followed by the arguments." -msgstr "-fno-pretty-templates Finskriv inte mallspecialiceringar som mallsignaturer följda av argumenten" +msgstr "-fno-pretty-templates Finskriv inte mallspecialiceringar som mallsignaturer följda av argumenten." #: c-family/c.opt:1424 -#, fuzzy -#| msgid "Used in Fix-and-Continue mode to indicate that object files may be swapped in at runtime" msgid "Used in Fix-and-Continue mode to indicate that object files may be swapped in at runtime." -msgstr "Används i Fix-and-Continue-läge för att objektfiler kan bytas ut vid körtillfället" +msgstr "Används i Fix-and-Continue-läge för att objektfiler kan bytas ut vid körtillfället." #: c-family/c.opt:1428 -#, fuzzy -#| msgid "Enable automatic template instantiation" msgid "Enable automatic template instantiation." -msgstr "Slå på automatisk mallinstansiering" +msgstr "Slå på automatisk mallinstansiering." #: c-family/c.opt:1432 -#, fuzzy -#| msgid "Generate run time type descriptor information" msgid "Generate run time type descriptor information." -msgstr "Generera typbeskrivarinformation för körtid" +msgstr "Generera typbeskrivarinformation för körtid." #: c-family/c.opt:1436 -#, fuzzy -#| msgid "Use the same size for double as for float" msgid "Use the same size for double as for float." -msgstr "Använd samma storlek för double som för float" +msgstr "Använd samma storlek för double som för float." #: c-family/c.opt:1440 ada/gcc-interface/lang.opt:77 -#, fuzzy -#| msgid "Use the narrowest integer type possible for enumeration types" msgid "Use the narrowest integer type possible for enumeration types." -msgstr "Använd den smalaste möjliga heltalstypen för uppräkningstyper" +msgstr "Använd den smalaste möjliga heltalstypen för uppräkningstyper." #: c-family/c.opt:1444 -#, fuzzy -#| msgid "Force the underlying type for \"wchar_t\" to be \"unsigned short\"" msgid "Force the underlying type for \"wchar_t\" to be \"unsigned short\"." -msgstr "Tvinga den underliggande typen för ”wchar_t” att vara ”unsigned short”" +msgstr "Tvinga den underliggande typen för ”wchar_t” att vara ”unsigned short”." #: c-family/c.opt:1448 -#, fuzzy -#| msgid "When \"signed\" or \"unsigned\" is not given make the bitfield signed" msgid "When \"signed\" or \"unsigned\" is not given make the bitfield signed." -msgstr "När ”signed” eller ”unsigned” inte anges låt bitfältet ha tecken" +msgstr "När ”signed” eller ”unsigned” inte anges låt bitfältet ha tecken." #: c-family/c.opt:1452 ada/gcc-interface/lang.opt:81 -#, fuzzy -#| msgid "Make \"char\" signed by default" msgid "Make \"char\" signed by default." -msgstr "Låt ”char” ha tecken som standard" +msgstr "Låt ”char” ha tecken som standard." #: c-family/c.opt:1456 -#, fuzzy -#| msgid "Enable C++14 sized deallocation support" msgid "Enable C++14 sized deallocation support." -msgstr "Slå på stöd för C++14 storleksbestämd deallokering" +msgstr "Slå på stöd för C++14 storleksbestämd deallokering." #: c-family/c.opt:1463 msgid "-fsso-struct=[big-endian|little-endian]\tSet the default scalar storage order." msgstr "-fsso-struct=[big-endian|little-endian]\tSätt standardordning för skalärlagring." #: c-family/c.opt:1466 -#, fuzzy, c-format -#| msgid "unrecognized ivar visibility value %qs" +#, c-format msgid "unrecognized scalar storage order value %qs" -msgstr "okänt ivar-synlighetsvärde %qs" +msgstr "okänt värde för skalär lagringsordning %qs" #: c-family/c.opt:1476 -#, fuzzy -#| msgid "Display statistics accumulated during compilation" msgid "Display statistics accumulated during compilation." -msgstr "Visa statistik som samlats under kompilering" +msgstr "Visa statistik som samlats under kompilering." #: c-family/c.opt:1480 -#, fuzzy -#| msgid "Assume that values of enumeration type are always within the minimum range of that type" msgid "Assume that values of enumeration type are always within the minimum range of that type." -msgstr "Antag att värdena i uppräkningstyper alltid finns inom det minsta intervallet av den typen" +msgstr "Antag att värdena i uppräkningstyper alltid finns inom det minsta intervallet av den typen." #: c-family/c.opt:1487 -#, fuzzy -#| msgid "-ftabstop=\tDistance between tab stops for column reporting" msgid "-ftabstop=\tDistance between tab stops for column reporting." -msgstr "-ftabstop=\tAvstånd mellan tabulatorstopp för kolumnvis rapportering" +msgstr "-ftabstop=\tAvstånd mellan tabulatorstopp för kolumnvis rapportering." #: c-family/c.opt:1491 -#, fuzzy -#| msgid "Set the maximum number of template instantiation notes for a single warning or error" msgid "Set the maximum number of template instantiation notes for a single warning or error." -msgstr "Sätt det maximala antalet mallinstansieringsnoter för en enskild varning eller fel" +msgstr "Sätt det maximala antalet mallinstansieringsnoter för en enskild varning eller fel." #: c-family/c.opt:1498 -#, fuzzy -#| msgid "-ftemplate-depth=\tSpecify maximum template instantiation depth" msgid "-ftemplate-depth=\tSpecify maximum template instantiation depth." -msgstr "-ftemplate-depth=\tAnge maximalt instansieringsdjup för mallar" +msgstr "-ftemplate-depth=\tAnge maximalt instansieringsdjup för mallar." #: c-family/c.opt:1505 -#, fuzzy -#| msgid "-fno-threadsafe-statics\tDo not generate thread-safe code for initializing local statics" msgid "-fno-threadsafe-statics\tDo not generate thread-safe code for initializing local statics." -msgstr "-fno-threadsafe-statics\tGenerera inte trådsäker kod för initiering a lokala statiska variabler" +msgstr "-fno-threadsafe-statics\tGenerera inte trådsäker kod för initiering a lokala statiska variabler." #: c-family/c.opt:1509 -#, fuzzy -#| msgid "When \"signed\" or \"unsigned\" is not given make the bitfield unsigned" msgid "When \"signed\" or \"unsigned\" is not given make the bitfield unsigned." -msgstr "När ”signed” eller ”unsigned” inte anges görs bitfälten teckenlösa" +msgstr "När ”signed” eller ”unsigned” inte anges görs bitfälten teckenlösa." #: c-family/c.opt:1513 -#, fuzzy -#| msgid "Make \"char\" unsigned by default" msgid "Make \"char\" unsigned by default." -msgstr "Gör ”char” teckenlöst som standard" +msgstr "Gör ”char” teckenlöst som standard." #: c-family/c.opt:1517 -#, fuzzy -#| msgid "Use __cxa_atexit to register destructors" msgid "Use __cxa_atexit to register destructors." -msgstr "Använd __cxa_atexit till registerdestruerare" +msgstr "Använd __cxa_atexit till registerdestruerare." #: c-family/c.opt:1521 -#, fuzzy -#| msgid "Use __cxa_get_exception_ptr in exception handling" msgid "Use __cxa_get_exception_ptr in exception handling." -msgstr "Använd __cxa_get_exception_ptr i undantagshantering" +msgstr "Använd __cxa_get_exception_ptr i undantagshantering." #: c-family/c.opt:1525 -#, fuzzy -#| msgid "Marks all inlined functions and methods as having hidden visibility" msgid "Marks all inlined functions and methods as having hidden visibility." -msgstr "Markerar alla inline:ade funktioner och metoder att ha dold synlighet" +msgstr "Markerar alla inline:ade funktioner och metoder att ha dold synlighet." #: c-family/c.opt:1529 -#, fuzzy -#| msgid "Changes visibility to match Microsoft Visual Studio by default" msgid "Changes visibility to match Microsoft Visual Studio by default." -msgstr "Ändrar synlighet till att vara som Microsoft Visual Studio som standard" +msgstr "Ändrar synlighet till att vara som Microsoft Visual Studio som standard." #: c-family/c.opt:1541 -#, fuzzy -#| msgid "Emit common-like symbols as weak symbols" msgid "Emit common-like symbols as weak symbols." -msgstr "Mata ut common-liknande symboler som svaga symboler" +msgstr "Mata ut common-liknande symboler som svaga symboler." #: c-family/c.opt:1545 -#, fuzzy -#| msgid "-fwide-exec-charset=\tConvert all wide strings and character constants to character set " msgid "-fwide-exec-charset=\tConvert all wide strings and character constants to character set ." -msgstr "-fwide-exec-charset=\tKonvertera alla breda strängar och teckenkonstanter till teckenuppsättningen " +msgstr "-fwide-exec-charset=\tKonvertera alla breda strängar och teckenkonstanter till teckenuppsättningen ." #: c-family/c.opt:1549 -#, fuzzy -#| msgid "Generate a #line directive pointing at the current working directory" msgid "Generate a #line directive pointing at the current working directory." -msgstr "Generera ett #line-direktiv som pekar på aktuell katalog" +msgstr "Generera ett #line-direktiv som pekar på aktuell katalog." #: c-family/c.opt:1557 -#, fuzzy -#| msgid "Generate lazy class lookup (via objc_getClass()) for use in Zero-Link mode" msgid "Generate lazy class lookup (via objc_getClass()) for use in Zero-Link mode." -msgstr "Generera lata klassuppslagningar (via objc_getClass()) att användas i läget Zero-Link" +msgstr "Generera lata klassuppslagningar (via objc_getClass()) att användas i läget Zero-Link." #: c-family/c.opt:1561 -#, fuzzy -#| msgid "Dump declarations to a .decl file" msgid "Dump declarations to a .decl file." -msgstr "Skicka deklarationer till en .decl-fil" +msgstr "Skicka deklarationer till en .decl-fil." #: c-family/c.opt:1565 -#, fuzzy -#| msgid "-femit-struct-debug-baseonly\tAggressive reduced debug info for structs" msgid "-femit-struct-debug-baseonly\tAggressive reduced debug info for structs." -msgstr "-femit-struct-debug-baseonly\tAggressivt reducerad felsökningsinformation för poster" +msgstr "-femit-struct-debug-baseonly\tAggressivt reducerad felsökningsinformation för poster." #: c-family/c.opt:1569 -#, fuzzy -#| msgid "-femit-struct-debug-reduced\tConservative reduced debug info for structs" msgid "-femit-struct-debug-reduced\tConservative reduced debug info for structs." -msgstr "-femit-struct-debug-reduced\tKonservativt reducerad felsökningsinformation för poster" +msgstr "-femit-struct-debug-reduced\tKonservativt reducerad felsökningsinformation för poster." #: c-family/c.opt:1573 -#, fuzzy -#| msgid "-femit-struct-debug-detailed=\tDetailed reduced debug info for structs" msgid "-femit-struct-debug-detailed=\tDetailed reduced debug info for structs." -msgstr "-femit-struct-debug-detailed=\tDetaljreducerad felsökningsinformation för poster" +msgstr "-femit-struct-debug-detailed=\tDetaljreducerad felsökningsinformation för poster." #: c-family/c.opt:1577 msgid "Interpret imaginary, fixed-point, or other gnu number suffix as the corresponding" msgstr "Tolka imaginära, flyttals-, eller andra gnu-suffix på tal som motsvarande talkonstant snarare än en användardefinierad talkonstant" #: c-family/c.opt:1582 -#, fuzzy -#| msgid "-idirafter \tAdd to the end of the system include path" msgid "-idirafter \tAdd to the end of the system include path." -msgstr "-idirafter \tLägg till till slutet av sökvägen för systeminkluderingar" +msgstr "-idirafter \tLägg till till slutet av sökvägen för systeminkluderingar." #: c-family/c.opt:1586 -#, fuzzy -#| msgid "-imacros \tAccept definition of macros in " msgid "-imacros \tAccept definition of macros in ." -msgstr "-imacros \tTag med definitioner av makron i " +msgstr "-imacros \tTag med definitioner av makron i ." #: c-family/c.opt:1590 -#, fuzzy -#| msgid "-imultilib \tSet to be the multilib include subdirectory" msgid "-imultilib \tSet to be the multilib include subdirectory." -msgstr "-imultilib \tSätt att vara inkluderingsunderbiblioteket för multibibliotek" +msgstr "-imultilib \tSätt att vara inkluderingsunderbiblioteket för multibibliotek." #: c-family/c.opt:1594 -#, fuzzy -#| msgid "-include \tInclude the contents of before other files" msgid "-include \tInclude the contents of before other files." -msgstr "-include \tInkludera innehållet i före andra filer" +msgstr "-include \tInkludera innehållet i före andra filer." #: c-family/c.opt:1598 -#, fuzzy -#| msgid "-iprefix \tSpecify as a prefix for next two options" msgid "-iprefix \tSpecify as a prefix for next two options." -msgstr "-iprefix \tAnge som ett prefix för de följande två flaggorna" +msgstr "-iprefix \tAnge som ett prefix för de följande två flaggorna." #: c-family/c.opt:1602 -#, fuzzy -#| msgid "-isysroot \tSet to be the system root directory" msgid "-isysroot \tSet to be the system root directory." -msgstr "-isysroot \tSätt som rotkatalog för systemet" +msgstr "-isysroot \tSätt som rotkatalog för systemet." #: c-family/c.opt:1606 -#, fuzzy -#| msgid "-isystem \tAdd to the start of the system include path" msgid "-isystem \tAdd to the start of the system include path." -msgstr "-isystem \tLägg till till början av sökvägen för systeminkluderingar" +msgstr "-isystem \tLägg till till början av sökvägen för systeminkluderingar." #: c-family/c.opt:1610 -#, fuzzy -#| msgid "-iquote \tAdd to the end of the quote include path" msgid "-iquote \tAdd to the end of the quote include path." -msgstr "-iquote \tLägg till till slutet av sökvägen för citerade inkluderingar" +msgstr "-iquote \tLägg till till slutet av sökvägen för citerade inkluderingar." #: c-family/c.opt:1614 -#, fuzzy -#| msgid "-iwithprefix \tAdd to the end of the system include path" msgid "-iwithprefix \tAdd to the end of the system include path." -msgstr "-iwithprefix \tLägg till till slutet av sökvägen för systeminkluderingar" +msgstr "-iwithprefix \tLägg till till slutet av sökvägen för systeminkluderingar." #: c-family/c.opt:1618 -#, fuzzy -#| msgid "-iwithprefixbefore \tAdd to the end of the main include path" msgid "-iwithprefixbefore \tAdd to the end of the main include path." -msgstr "-iwithprefixbefore \tLägg till till slutet av huvudsökvägen" +msgstr "-iwithprefixbefore \tLägg till till slutet av huvudsökvägen." #: c-family/c.opt:1628 -#, fuzzy -#| msgid "Do not search standard system include directories (those specified with -isystem will still be used)" msgid "Do not search standard system include directories (those specified with -isystem will still be used)." -msgstr "Sök inte standardkataloger för inkluderingar (de som anges med -isystem kommer fortfarande att användas)" +msgstr "Sök inte standardkataloger för inkluderingar (de som anges med -isystem kommer fortfarande att användas)." #: c-family/c.opt:1632 -#, fuzzy -#| msgid "Do not search standard system include directories for C++" msgid "Do not search standard system include directories for C++." -msgstr "Sök inte i standardkataloger för systeminkluderingar för C++" +msgstr "Sök inte i standardkataloger för systeminkluderingar för C++." #: c-family/c.opt:1644 -#, fuzzy -#| msgid "Generate C header of platform-specific features" msgid "Generate C header of platform-specific features." -msgstr "Generera C-huvuden för plattformsspecifika funktioner" +msgstr "Generera C-huvuden för plattformsspecifika funktioner." #: c-family/c.opt:1648 -#, fuzzy -#| msgid "Remap file names when including files" msgid "Remap file names when including files." -msgstr "Översätt filnamn när filer inkluderas" +msgstr "Översätt filnamn när filer inkluderas." #: c-family/c.opt:1652 c-family/c.opt:1656 -#, fuzzy -#| msgid "Conform to the ISO 1998 C++ standard revised by the 2003 technical corrigendum" msgid "Conform to the ISO 1998 C++ standard revised by the 2003 technical corrigendum." -msgstr "Följ standarden ISO 1998 C++ reviderad av 2003 års tekniska rättelser" +msgstr "Följ standarden ISO 1998 C++ reviderad av 2003 års tekniska rättelser." #: c-family/c.opt:1660 -#, fuzzy -#| msgid "Conform to the ISO 2011 C++ standard" msgid "Conform to the ISO 2011 C++ standard." -msgstr "Följ standarden ISO 2011 C++" +msgstr "Följ standarden ISO 2011 C++." #: c-family/c.opt:1664 -#, fuzzy -#| msgid "Deprecated in favor of -std=c++11" msgid "Deprecated in favor of -std=c++11." -msgstr "Undanbedes till förmån för -std=c++11" +msgstr "Undanbedes till förmån för -std=c++11." #: c-family/c.opt:1668 -#, fuzzy -#| msgid "Deprecated in favor of -std=c++14" msgid "Deprecated in favor of -std=c++14." -msgstr "Undanbedes till förmån för -std=c++14" +msgstr "Undanbedes till förmån för -std=c++14." #: c-family/c.opt:1672 -#, fuzzy -#| msgid "Conform to the ISO 2011 C++ standard" msgid "Conform to the ISO 2014 C++ standard." -msgstr "Följ standarden ISO 2011 C++" +msgstr "Följ standarden ISO 2014 C++." #: c-family/c.opt:1676 -#, fuzzy -#| msgid "Conform to the ISO 2017(?) C++ draft standard (experimental and incomplete support)" msgid "Conform to the ISO 2017(?) C++ draft standard (experimental and incomplete support)." -msgstr "Följ standardutkastet ISO 2017(?) C++ (experimentellt och ofullständigt stöd)" +msgstr "Följ standardutkastet ISO 2017(?) C++ (experimentellt och ofullständigt stöd)." #: c-family/c.opt:1683 c-family/c.opt:1780 -#, fuzzy -#| msgid "Conform to the ISO 2011 C++ standard" msgid "Conform to the ISO 2011 C standard." -msgstr "Följ standarden ISO 2011 C++" +msgstr "Följ standarden ISO 2011 C." #: c-family/c.opt:1687 -#, fuzzy -#| msgid "Deprecated in favor of -std=c11" msgid "Deprecated in favor of -std=c11." -msgstr "Undanbedes till förmån för -std=c11" +msgstr "Undanbedes till förmån för -std=c11." #: c-family/c.opt:1691 c-family/c.opt:1695 c-family/c.opt:1764 -#, fuzzy -#| msgid "Conform to the ISO 1990 C standard" msgid "Conform to the ISO 1990 C standard." -msgstr "Följ standarden ISO 1990 C" +msgstr "Följ standarden ISO 1990 C." #: c-family/c.opt:1699 c-family/c.opt:1772 -#, fuzzy -#| msgid "Conform to the ISO 1999 C standard" msgid "Conform to the ISO 1999 C standard." -msgstr "Följ standarden ISO 1999 C" +msgstr "Följ standarden ISO 1999 C." #: c-family/c.opt:1703 -#, fuzzy -#| msgid "Deprecated in favor of -std=c99" msgid "Deprecated in favor of -std=c99." -msgstr "Undanbedes till förmån för -std=c99" +msgstr "Undanbedes till förmån för -std=c99." #: c-family/c.opt:1707 c-family/c.opt:1712 msgid "Conform to the ISO 1998 C++ standard revised by the 2003 technical" msgstr "Följ standarden ISO 1998 C++ reviderad av 2003 års tekniska rättelser" #: c-family/c.opt:1717 -#, fuzzy -#| msgid "Conform to the ISO 1990 C standard with GNU extensions" msgid "Conform to the ISO 2011 C++ standard with GNU extensions." -msgstr "Följ standarden ISO 1990 C med GNU-utökningar" +msgstr "Följ standarden ISO 2011 C med GNU-utökningar." #: c-family/c.opt:1721 -#, fuzzy -#| msgid "Deprecated in favor of -std=gnu++11" msgid "Deprecated in favor of -std=gnu++11." -msgstr "Undanbedes till förmån för -std=gnu++11" +msgstr "Undanbedes till förmån för -std=gnu++11." #: c-family/c.opt:1725 -#, fuzzy -#| msgid "Deprecated in favor of -std=gnu++11" msgid "Deprecated in favor of -std=gnu++14." -msgstr "Undanbedes till förmån för -std=gnu++11" +msgstr "Undanbedes till förmån för -std=gnu++14." #: c-family/c.opt:1729 -#, fuzzy -#| msgid "Conform to the ISO 1990 C standard with GNU extensions" msgid "Conform to the ISO 2014 C++ standard with GNU extensions." -msgstr "Följ standarden ISO 1990 C med GNU-utökningar" +msgstr "Följ standarden ISO 2014 C++ med GNU-utökningar" #: c-family/c.opt:1733 -#, fuzzy -#| msgid "Conform to the ISO 201z(7?) C++ draft standard with GNU extensions (experimental and incomplete support)" msgid "Conform to the ISO 201z(7?) C++ draft standard with GNU extensions (experimental and incomplete support)." -msgstr "Följ standardutkastet ISO 201z(7?) C++ med GNU-utökningar (experimentellt och ofullständigt stöd)" +msgstr "Följ standardutkastet ISO 201z(7?) C++ med GNU-utökningar (experimentellt och ofullständigt stöd)." #: c-family/c.opt:1740 -#, fuzzy -#| msgid "Conform to the ISO 1990 C standard with GNU extensions" msgid "Conform to the ISO 2011 C standard with GNU extensions." -msgstr "Följ standarden ISO 1990 C med GNU-utökningar" +msgstr "Följ standarden ISO 2011 C med GNU-utökningar" #: c-family/c.opt:1744 -#, fuzzy -#| msgid "Deprecated in favor of -std=gnu11" msgid "Deprecated in favor of -std=gnu11." -msgstr "Undanbedes till förmån för -std=gnu11" +msgstr "Undanbedes till förmån för -std=gnu11." #: c-family/c.opt:1748 c-family/c.opt:1752 -#, fuzzy -#| msgid "Conform to the ISO 1990 C standard with GNU extensions" msgid "Conform to the ISO 1990 C standard with GNU extensions." -msgstr "Följ standarden ISO 1990 C med GNU-utökningar" +msgstr "Följ standarden ISO 1990 C med GNU-utökningar." #: c-family/c.opt:1756 -#, fuzzy -#| msgid "Conform to the ISO 1999 C standard with GNU extensions" msgid "Conform to the ISO 1999 C standard with GNU extensions." -msgstr "Följ standarden ISO 1999 C med GNU-utökningar" +msgstr "Följ standarden ISO 1999 C med GNU-utökningar." #: c-family/c.opt:1760 -#, fuzzy -#| msgid "Deprecated in favor of -std=gnu99" msgid "Deprecated in favor of -std=gnu99." -msgstr "Undanbedes till förmån för -std=gnu99" +msgstr "Undanbedes till förmån för -std=gnu99." #: c-family/c.opt:1768 -#, fuzzy -#| msgid "Conform to the ISO 1990 C standard as amended in 1994" msgid "Conform to the ISO 1990 C standard as amended in 1994." -msgstr "Följ standarden ISO 1990 C med tillägg från 1994" +msgstr "Följ standarden ISO 1990 C med tillägg från 1994." #: c-family/c.opt:1776 -#, fuzzy -#| msgid "Deprecated in favor of -std=iso9899:1999" msgid "Deprecated in favor of -std=iso9899:1999." -msgstr "Undanbedes till förmån för -std=iso9899:1999" +msgstr "Undanbedes till förmån för -std=iso9899:1999." #: c-family/c.opt:1787 -#, fuzzy -#| msgid "Enable traditional preprocessing" msgid "Enable traditional preprocessing." -msgstr "Aktivera traditionell preprocessning" +msgstr "Aktivera traditionell preprocessning." #: c-family/c.opt:1791 -#, fuzzy -#| msgid "-trigraphs\tSupport ISO C trigraphs" msgid "-trigraphs\tSupport ISO C trigraphs." -msgstr "-trigraphs\tStöd trigrafer enligt ISO C" +msgstr "-trigraphs\tStöd trigrafer enligt ISO C." #: c-family/c.opt:1795 -#, fuzzy -#| msgid "Do not predefine system-specific and GCC-specific macros" msgid "Do not predefine system-specific and GCC-specific macros." -msgstr "Fördefiniera inte systemspecifika och GCC-specifika makron" +msgstr "Fördefiniera inte systemspecifika och GCC-specifika makron." #: ada/gcc-interface/lang.opt:61 -#, fuzzy -#| msgid "Synonym of -gnatk8" msgid "Synonym of -gnatk8." -msgstr "Synonym för -gnatk8" +msgstr "Synonym för -gnatk8." #: ada/gcc-interface/lang.opt:69 -#, fuzzy -#| msgid "Do not look for object files in standard path" msgid "Do not look for object files in standard path." -msgstr "Titta inte efter objektfiler i standardsökvägen" +msgstr "Titta inte efter objektfiler i standardsökvägen." #: ada/gcc-interface/lang.opt:73 -#, fuzzy -#| msgid "Select the runtime" msgid "Select the runtime." -msgstr "Välj körtidssystem" +msgstr "Välj körtidssystem." #: ada/gcc-interface/lang.opt:85 -#, fuzzy -#| msgid "Catch typos" msgid "Catch typos." -msgstr "Fånga skrivfel" +msgstr "Fånga skrivfel." #: ada/gcc-interface/lang.opt:89 -#, fuzzy -#| msgid "Set name of output ALI file (internal switch)" msgid "Set name of output ALI file (internal switch)." -msgstr "Sätt namnet på utmatnings-ALI-filen (intern flagga)" +msgstr "Sätt namnet på utmatnings-ALI-filen (intern flagga)." #: ada/gcc-interface/lang.opt:93 -#, fuzzy -#| msgid "-gnat\tSpecify options to GNAT" msgid "-gnat\tSpecify options to GNAT." -msgstr "-gnat\tAnge flaggor till GNAT" +msgstr "-gnat\tAnge flaggor till GNAT." #: ada/gcc-interface/lang.opt:97 msgid "Ignored." msgstr "Ignorerad." #: go/lang.opt:42 -#, fuzzy -#| msgid "Add explicit checks for division by zero" msgid "Add explicit checks for division by zero." -msgstr "Lägg till explicita kontroller av division med noll" +msgstr "Lägg till explicita kontroller av division med noll." #: go/lang.opt:46 -#, fuzzy -#| msgid "Add explicit checks for division overflow in INT_MIN / -1" msgid "Add explicit checks for division overflow in INT_MIN / -1." -msgstr "Lägg till explicita kontroller av spill vid division av INT_MIN / -1" +msgstr "Lägg till explicita kontroller av spill vid division av INT_MIN / -1." #: go/lang.opt:50 -#, fuzzy -#| msgid "-fgo-dump-\tDump Go frontend internal information" msgid "-fgo-dump-\tDump Go frontend internal information." -msgstr "-fgo-dump-\tSkriv ut Go-framändens interna information" +msgstr "-fgo-dump-\tSkriv ut Go-framändens interna information." #: go/lang.opt:54 -#, fuzzy -#| msgid "-fgo-optimize-\tTurn on optimization passes in the frontend" msgid "-fgo-optimize-\tTurn on optimization passes in the frontend." -msgstr "-fgo-optimize-\tSlå på optimeringspass i framänden" +msgstr "-fgo-optimize-\tSlå på optimeringspass i framänden." #: go/lang.opt:58 -#, fuzzy -#| msgid "-fgo-pkgpath=\tSet Go package path" msgid "-fgo-pkgpath=\tSet Go package path." -msgstr "-fgo-pkgpath=\tSätt Go-paketsökväg" +msgstr "-fgo-pkgpath=\tSätt Go-paketsökväg." #: go/lang.opt:62 -#, fuzzy -#| msgid "-fgo-prefix=\tSet package-specific prefix for exported Go names" msgid "-fgo-prefix=\tSet package-specific prefix for exported Go names." -msgstr "-fgo-prefix=\tSätt paketspecifika prefix för exporterade Go-namn" +msgstr "-fgo-prefix=\tSätt paketspecifika prefix för exporterade Go-namn." #: go/lang.opt:66 -#, fuzzy -#| msgid "-fgo-relative-import-path= Treat a relative import as relative to path" msgid "-fgo-relative-import-path= Treat a relative import as relative to path." -msgstr "-fgo-relative-import-path= Hantera en relativ import som relativ till sökv" +msgstr "-fgo-relative-import-path= Hantera en relativ import som relativ till sökv." #: go/lang.opt:70 -#, fuzzy -#| msgid "Functions which return values must end with return statements" msgid "Functions which return values must end with return statements." -msgstr "Funktioner med returvärden måste sluta med retursatser" +msgstr "Funktioner med returvärden måste sluta med retursatser." #: config/vms/vms.opt:27 -#, fuzzy -#| msgid "Malloc data into P2 space" msgid "Malloc data into P2 space." -msgstr "Malloc-data till P2-utrymmet" +msgstr "Malloc-data till P2-utrymmet." #: config/vms/vms.opt:31 -#, fuzzy -#| msgid "Set name of main routine for the debugger" msgid "Set name of main routine for the debugger." -msgstr "Ange namnet på huvudrutinen för felsökaren" +msgstr "Ange namnet på huvudrutinen för felsökaren." #: config/vms/vms.opt:35 -#, fuzzy -#| msgid "Use VMS exit codes instead of posix ones" msgid "Use VMS exit codes instead of posix ones." -msgstr "Använd VMS-slutkoder istället för posix-koder" +msgstr "Använd VMS-slutkoder istället för posix-koder." #: config/vms/vms.opt:39 -#, fuzzy -#| msgid "-mpointer-size=[no,32,short,64,long]\tSet the default pointer size" msgid "-mpointer-size=[no,32,short,64,long]\tSet the default pointer size." -msgstr "-mpointer-size=[no,32,short,64,long]\tSätt standardstorlek på pekare" +msgstr "-mpointer-size=[no,32,short,64,long]\tSätt standardstorlek på pekare." #: config/vms/vms.opt:42 #, c-format @@ -8500,261 +7527,177 @@ msgid "Generate code for the M*Core M340" msgstr "Generera kod för M*Core M340" #: config/mcore/mcore.opt:31 -#, fuzzy -#| msgid "Force functions to be aligned to a 4 byte boundary" msgid "Force functions to be aligned to a 4 byte boundary." -msgstr "Tvinga funktioner till att vara justerade till en 4-bytegräns" +msgstr "Tvinga funktioner till att vara justerade till en 4-bytegräns." #: config/mcore/mcore.opt:35 config/moxie/moxie.opt:23 -#, fuzzy -#| msgid "Generate big-endian code" msgid "Generate big-endian code." -msgstr "Generera kod med rak byteordning" +msgstr "Generera kod med rak byteordning." #: config/mcore/mcore.opt:39 -#, fuzzy -#| msgid "Emit call graph information" msgid "Emit call graph information." -msgstr "Mata ut anropsgrafsinformation" +msgstr "Mata ut anropsgrafsinformation." #: config/mcore/mcore.opt:43 -#, fuzzy -#| msgid "Use the divide instruction" msgid "Use the divide instruction." -msgstr "Använd divisionsinstruktionen" +msgstr "Använd divisionsinstruktionen." #: config/mcore/mcore.opt:47 -#, fuzzy -#| msgid "Inline constants if it can be done in 2 insns or less" msgid "Inline constants if it can be done in 2 insns or less." -msgstr "Inline:a konstanter om det kan göras på 2 instruktioner eller mindre" +msgstr "Inline:a konstanter om det kan göras på 2 instruktioner eller mindre." #: config/mcore/mcore.opt:51 config/moxie/moxie.opt:27 -#, fuzzy -#| msgid "Generate little-endian code" msgid "Generate little-endian code." -msgstr "Generera kod med omvänd byteordning" +msgstr "Generera kod med omvänd byteordning." #: config/mcore/mcore.opt:56 config/fr30/fr30.opt:27 -#, fuzzy -#| msgid "Assume that run-time support has been provided, so omit -lsim from the linker command line" msgid "Assume that run-time support has been provided, so omit -lsim from the linker command line." -msgstr "Anta att körtidsstöd finns, så utelämna -lsim från länkningskommandoraden" +msgstr "Anta att körtidsstöd finns, så utelämna -lsim från länkningskommandoraden." #: config/mcore/mcore.opt:60 -#, fuzzy -#| msgid "Use arbitrary sized immediates in bit operations" msgid "Use arbitrary sized immediates in bit operations." -msgstr "Använd godtyckligt stora omedelbara i bitoperationer" +msgstr "Använd godtyckligt stora omedelbara i bitoperationer." #: config/mcore/mcore.opt:64 -#, fuzzy -#| msgid "Prefer word accesses over byte accesses" msgid "Prefer word accesses over byte accesses." -msgstr "Föredra ordåtkomst före byteåtkomst" +msgstr "Föredra ordåtkomst före byteåtkomst." #: config/mcore/mcore.opt:71 -#, fuzzy -#| msgid "Set the maximum amount for a single stack increment operation" msgid "Set the maximum amount for a single stack increment operation." -msgstr "Ange maximal storlek på en ensam stackökningsoperation" +msgstr "Ange maximal storlek på en ensam stackökningsoperation." #: config/mcore/mcore.opt:75 -#, fuzzy -#| msgid "Always treat bitfields as int-sized" msgid "Always treat bitfields as int-sized." -msgstr "Hantera alltid bitfält som int-stora" +msgstr "Hantera alltid bitfält som int-stora." #: config/linux-android.opt:23 msgid "Generate code for the Android platform." msgstr "Generera kod för plattformen Android." #: config/mmix/mmix.opt:24 -#, fuzzy -#| msgid "For intrinsics library: pass all parameters in registers" msgid "For intrinsics library: pass all parameters in registers." -msgstr "För inbyggt bibliotek: skicka alla parametrar i register" +msgstr "För inbyggt bibliotek: skicka alla parametrar i register." #: config/mmix/mmix.opt:28 -#, fuzzy -#| msgid "Use register stack for parameters and return value" msgid "Use register stack for parameters and return value." -msgstr "Använd registerstacken för parametrar och returvärde" +msgstr "Använd registerstacken för parametrar och returvärde." #: config/mmix/mmix.opt:32 -#, fuzzy -#| msgid "Use call-clobbered registers for parameters and return value" msgid "Use call-clobbered registers for parameters and return value." -msgstr "Använd anropsöverskrivna register för parametrar och returvärde" +msgstr "Använd anropsöverskrivna register för parametrar och returvärde." #: config/mmix/mmix.opt:37 -#, fuzzy -#| msgid "Use epsilon-respecting floating point compare instructions" msgid "Use epsilon-respecting floating point compare instructions." -msgstr "Använd flyttalsjämförelseinstruktioner som respekterar epsilon" +msgstr "Använd flyttalsjämförelseinstruktioner som respekterar epsilon." #: config/mmix/mmix.opt:41 -#, fuzzy -#| msgid "Use zero-extending memory loads, not sign-extending ones" msgid "Use zero-extending memory loads, not sign-extending ones." -msgstr "Använd nollutfyllda minnesladdningar, inte teckenutfyllda" +msgstr "Använd nollutfyllda minnesladdningar, inte teckenutfyllda." #: config/mmix/mmix.opt:45 -#, fuzzy -#| msgid "Generate divide results with reminder having the same sign as the divisor (not the dividend)" msgid "Generate divide results with reminder having the same sign as the divisor (not the dividend)." -msgstr "Generera divisionsresultat så att resten har samma tecken som täljaren (inte nämnaren)" +msgstr "Generera divisionsresultat så att resten har samma tecken som täljaren (inte nämnaren)." #: config/mmix/mmix.opt:49 -#, fuzzy -#| msgid "Prepend global symbols with \":\" (for use with PREFIX)" msgid "Prepend global symbols with \":\" (for use with PREFIX)." -msgstr "Inled globala symboler med ”:” (för användning tillsammans med PREFIX)" +msgstr "Inled globala symboler med ”:” (för användning tillsammans med PREFIX)." #: config/mmix/mmix.opt:53 -#, fuzzy -#| msgid "Do not provide a default start-address 0x100 of the program" msgid "Do not provide a default start-address 0x100 of the program." -msgstr "Ge inte en standard startadress 0x100 för programmet" +msgstr "Ge inte en standard startadress 0x100 för programmet." #: config/mmix/mmix.opt:57 -#, fuzzy -#| msgid "Link to emit program in ELF format (rather than mmo)" msgid "Link to emit program in ELF format (rather than mmo)." -msgstr "Länka för att skapa program i ELF-format (snarare än mmo)" +msgstr "Länka för att skapa program i ELF-format (snarare än mmo)." #: config/mmix/mmix.opt:61 -#, fuzzy -#| msgid "Use P-mnemonics for branches statically predicted as taken" msgid "Use P-mnemonics for branches statically predicted as taken." -msgstr "Använd P-mnemonics för grenar som statiskt förutsägs tas" +msgstr "Använd P-mnemonics för grenar som statiskt förutsägs tas." #: config/mmix/mmix.opt:65 -#, fuzzy -#| msgid "Don't use P-mnemonics for branches" msgid "Don't use P-mnemonics for branches." -msgstr "Använd inte P-mnemonics för grenar" +msgstr "Använd inte P-mnemonics för grenar." #: config/mmix/mmix.opt:79 -#, fuzzy -#| msgid "Use addresses that allocate global registers" msgid "Use addresses that allocate global registers." -msgstr "Använd adresser som allokerar globala register" +msgstr "Använd adresser som allokerar globala register." #: config/mmix/mmix.opt:83 -#, fuzzy -#| msgid "Do not use addresses that allocate global registers" msgid "Do not use addresses that allocate global registers." -msgstr "Använd inte adresser som allokerar globala register" +msgstr "Använd inte adresser som allokerar globala register." #: config/mmix/mmix.opt:87 -#, fuzzy -#| msgid "Generate a single exit point for each function" msgid "Generate a single exit point for each function." -msgstr "Generera en enda utgångspunkt för varje funktion" +msgstr "Generera en enda utgångspunkt för varje funktion." #: config/mmix/mmix.opt:91 -#, fuzzy -#| msgid "Do not generate a single exit point for each function" msgid "Do not generate a single exit point for each function." -msgstr "Generera inte en ensam utgångspunkt för varje funktion" +msgstr "Generera inte en ensam utgångspunkt för varje funktion." #: config/mmix/mmix.opt:95 -#, fuzzy -#| msgid "Set start-address of the program" msgid "Set start-address of the program." -msgstr "Ange startadressen för programmet" +msgstr "Ange startadressen för programmet." #: config/mmix/mmix.opt:99 -#, fuzzy -#| msgid "Set start-address of data" msgid "Set start-address of data." -msgstr "Sätt startadress för data" +msgstr "Sätt startadress för data." #: config/darwin.opt:114 -#, fuzzy -#| msgid "Generate compile-time CFString objects" msgid "Generate compile-time CFString objects." -msgstr "Generera CFString-objekt vid kompileringstillfället" +msgstr "Generera CFString-objekt vid kompileringstillfället." #: config/darwin.opt:211 -#, fuzzy -#| msgid "Warn if constant CFString objects contain non-portable characters" msgid "Warn if constant CFString objects contain non-portable characters." -msgstr "Varna om konstanta CFString-objekt innehåller icke-portabla tecken" +msgstr "Varna om konstanta CFString-objekt innehåller icke-portabla tecken." #: config/darwin.opt:216 -#, fuzzy -#| msgid "Generate AT&T-style stubs for Mach-O" msgid "Generate AT&T-style stubs for Mach-O." -msgstr "Generera stubbar i AT&T-stil för Mach-O" +msgstr "Generera stubbar i AT&T-stil för Mach-O." #: config/darwin.opt:220 -#, fuzzy -#| msgid "Generate code suitable for executables (NOT shared libs)" msgid "Generate code suitable for executables (NOT shared libs)." -msgstr "Generera kod lämplig för körbara program (INTE delade bibliotek)" +msgstr "Generera kod lämplig för körbara program (INTE delade bibliotek)." #: config/darwin.opt:224 -#, fuzzy -#| msgid "Generate code suitable for fast turn around debugging" msgid "Generate code suitable for fast turn around debugging." -msgstr "Generera kod lämplig för korta felsökningscykler" +msgstr "Generera kod lämplig för korta felsökningscykler." #: config/darwin.opt:232 -#, fuzzy -#| msgid "The earliest MacOS X version on which this program will run" msgid "The earliest MacOS X version on which this program will run." -msgstr "Den tidigaste MacOS X-versionen som detta program kommer köra på" +msgstr "Den tidigaste MacOS X-versionen som detta program kommer köra på." #: config/darwin.opt:236 -#, fuzzy -#| msgid "Set sizeof(bool) to 1" msgid "Set sizeof(bool) to 1." -msgstr "Sätt sizeof(bool) till 1" +msgstr "Sätt sizeof(bool) till 1." #: config/darwin.opt:240 -#, fuzzy -#| msgid "Generate code for darwin loadable kernel extensions" msgid "Generate code for darwin loadable kernel extensions." -msgstr "Generera kod för darwin laddbara kärnutvidgningar" +msgstr "Generera kod för darwin laddbara kärnutvidgningar." #: config/darwin.opt:244 -#, fuzzy -#| msgid "Generate code for the kernel or loadable kernel extensions" msgid "Generate code for the kernel or loadable kernel extensions." -msgstr "Generera kod för kärnan eller laddbara kärnutvidgningar" +msgstr "Generera kod för kärnan eller laddbara kärnutvidgningar." #: config/darwin.opt:248 -#, fuzzy -#| msgid "-iframework \tAdd to the end of the system framework include path" msgid "-iframework \tAdd to the end of the system framework include path." -msgstr "-iframework \tLägg till till slutet av systemramverkets inkluderingssökväg" +msgstr "-iframework \tLägg till till slutet av systemramverkets inkluderingssökväg." #: config/bfin/bfin.opt:40 config/msp430/msp430.opt:3 config/c6x/c6x.opt:38 #: config/mep/mep.opt:143 -#, fuzzy -#| msgid "Use simulator runtime" msgid "Use simulator runtime." -msgstr "Använd simulatorkörtider" +msgstr "Använd simulatorkörtider." #: config/bfin/bfin.opt:44 config/arm/arm.opt:106 -#, fuzzy -#| msgid "Specify the name of the target CPU" msgid "Specify the name of the target CPU." -msgstr "Ange namnet på målprocessorn" +msgstr "Ange namnet på målprocessorn." #: config/bfin/bfin.opt:48 -#, fuzzy -#| msgid "Omit frame pointer for leaf functions" msgid "Omit frame pointer for leaf functions." -msgstr "Utelämna rampekaren i lövfunktioner" +msgstr "Utelämna rampekaren i lövfunktioner." #: config/bfin/bfin.opt:52 -#, fuzzy -#| msgid "Program is entirely located in low 64k of memory" msgid "Program is entirely located in low 64k of memory." -msgstr "Programmet ligger helt i låga 64 kB minne" +msgstr "Programmet ligger helt i låga 64 kB minne." #: config/bfin/bfin.opt:56 msgid "Work around a hardware anomaly by adding a number of NOPs before a" @@ -8762,13 +7705,11 @@ msgstr "Gå runt en hårdvaruanomali genom att lägga till ett antal NOP:ar för #: config/bfin/bfin.opt:61 msgid "Avoid speculative loads to work around a hardware anomaly." -msgstr "Undvik spekulativa lastningar för att gå runt en hårdvaruanomali." +msgstr "Undvik spekulativa laddningar för att gå runt en hårdvaruanomali." #: config/bfin/bfin.opt:65 -#, fuzzy -#| msgid "Enabled ID based shared library" msgid "Enabled ID based shared library." -msgstr "Aktivera ID-baserat delat bibliotek" +msgstr "Aktivera ID-baserat delat bibliotek." # Avhugget p.g.a. http://gcc.gnu.org/bugzilla/show_bug.cgi?id=34352 # Hela meddelandet är översatt @@ -8777,70 +7718,48 @@ msgid "Generate code that won't be linked against any other ID shared libraries, msgstr "Generera kod som inte kommer länkas mot några andra delade ID-bibliotek men kan användas av ett delat bibliotek." #: config/bfin/bfin.opt:74 config/m68k/m68k.opt:171 -#, fuzzy -#| msgid "ID of shared library to build" msgid "ID of shared library to build." -msgstr "ID för delat bibliotek att bygga" +msgstr "ID för delat bibliotek att bygga." #: config/bfin/bfin.opt:78 config/m68k/m68k.opt:167 -#, fuzzy -#| msgid "Enable separate data segment" msgid "Enable separate data segment." -msgstr "Aktivera separat datasegment" +msgstr "Aktivera separat datasegment." #: config/bfin/bfin.opt:82 config/c6x/c6x.opt:63 -#, fuzzy -#| msgid "Avoid generating pc-relative calls; use indirection" msgid "Avoid generating pc-relative calls; use indirection." -msgstr "Undvik att generera pc-relativa anrop, använd indirekt anrop" +msgstr "Undvik att generera pc-relativa anrop, använd indirekt anrop." #: config/bfin/bfin.opt:86 -#, fuzzy -#| msgid "Link with the fast floating-point library" msgid "Link with the fast floating-point library." -msgstr "Länka med de snabba flyttalsbiblioteken" +msgstr "Länka med de snabba flyttalsbiblioteken." #: config/bfin/bfin.opt:90 config/frv/frv.opt:130 -#, fuzzy -#| msgid "Enable Function Descriptor PIC mode" msgid "Enable Function Descriptor PIC mode." -msgstr "Aktivera funktionsbeskrivar-PIC-läge" +msgstr "Aktivera funktionsbeskrivar-PIC-läge." #: config/bfin/bfin.opt:94 config/frv/frv.opt:162 -#, fuzzy -#| msgid "Enable inlining of PLT in function calls" msgid "Enable inlining of PLT in function calls." -msgstr "Aktivera inline:ing av PLT i funktionsanrop" +msgstr "Aktivera inline:ing av PLT i funktionsanrop." #: config/bfin/bfin.opt:98 -#, fuzzy -#| msgid "Do stack checking using bounds in L1 scratch memory" msgid "Do stack checking using bounds in L1 scratch memory." -msgstr "Gör stackkontroll med gränser i L1:s fria minne" +msgstr "Gör stackkontroll med gränser i L1:s fria minne." #: config/bfin/bfin.opt:102 -#, fuzzy -#| msgid "Enable multicore support" msgid "Enable multicore support." -msgstr "Aktivera stöd för flera kärnor" +msgstr "Aktivera stöd för flera kärnor." #: config/bfin/bfin.opt:106 -#, fuzzy -#| msgid "Build for Core A" msgid "Build for Core A." -msgstr "Bygg för kärna A" +msgstr "Bygg för kärna A." #: config/bfin/bfin.opt:110 -#, fuzzy -#| msgid "Build for Core B" msgid "Build for Core B." -msgstr "Bygg för kärna B" +msgstr "Bygg för kärna B." #: config/bfin/bfin.opt:114 -#, fuzzy -#| msgid "Build for SDRAM" msgid "Build for SDRAM." -msgstr "Bygg för SDRAM" +msgstr "Bygg för SDRAM." #: config/bfin/bfin.opt:118 msgid "Assume ICPLBs are enabled at runtime." @@ -8859,118 +7778,80 @@ msgid "Known M68K ISAs (for use with the -march= option):" msgstr "Kända M68K-ISA:er (att användas med flaggan -march=):" #: config/m68k/ieee.opt:24 config/i386/i386.opt:358 -#, fuzzy -#| msgid "Use IEEE math for fp comparisons" msgid "Use IEEE math for fp comparisons." -msgstr "Använd IEEE matematik för flyttaljämförelser" +msgstr "Använd IEEE matematik för flyttaljämförelser." #: config/m68k/m68k.opt:30 -#, fuzzy -#| msgid "Generate code for a 520X" msgid "Generate code for a 520X." -msgstr "Generera kod för en 520X" +msgstr "Generera kod för en 520X." #: config/m68k/m68k.opt:34 -#, fuzzy -#| msgid "Generate code for a 5206e" msgid "Generate code for a 5206e." -msgstr "Generera kod för en 5206e" +msgstr "Generera kod för en 5206e." #: config/m68k/m68k.opt:38 -#, fuzzy -#| msgid "Generate code for a 528x" msgid "Generate code for a 528x." -msgstr "Generera kod för en 528x" +msgstr "Generera kod för en 528x." #: config/m68k/m68k.opt:42 -#, fuzzy -#| msgid "Generate code for a 5307" msgid "Generate code for a 5307." -msgstr "Generera kod för en 5307" +msgstr "Generera kod för en 5307." #: config/m68k/m68k.opt:46 -#, fuzzy -#| msgid "Generate code for a 5407" msgid "Generate code for a 5407." -msgstr "Generera kod för en 5407" +msgstr "Generera kod för en 5407." #: config/m68k/m68k.opt:50 config/m68k/m68k.opt:111 -#, fuzzy -#| msgid "Generate code for a 68000" msgid "Generate code for a 68000." -msgstr "Generera kod för en 68000" +msgstr "Generera kod för en 68000." #: config/m68k/m68k.opt:54 -#, fuzzy -#| msgid "Generate code for a 68010" msgid "Generate code for a 68010." -msgstr "Generera kod för en 68010" +msgstr "Generera kod för en 68010." #: config/m68k/m68k.opt:58 config/m68k/m68k.opt:115 -#, fuzzy -#| msgid "Generate code for a 68020" msgid "Generate code for a 68020." -msgstr "Generera kod för en 68020" +msgstr "Generera kod för en 68020." #: config/m68k/m68k.opt:62 -#, fuzzy -#| msgid "Generate code for a 68040, without any new instructions" msgid "Generate code for a 68040, without any new instructions." -msgstr "Generera kod för en 68040, utan några nya instruktioner" +msgstr "Generera kod för en 68040, utan några nya instruktioner." #: config/m68k/m68k.opt:66 -#, fuzzy -#| msgid "Generate code for a 68060, without any new instructions" msgid "Generate code for a 68060, without any new instructions." -msgstr "Generera kod för en 68060, utan några nya instruktioner" +msgstr "Generera kod för en 68060, utan några nya instruktioner." #: config/m68k/m68k.opt:70 -#, fuzzy -#| msgid "Generate code for a 68030" msgid "Generate code for a 68030." -msgstr "Generera kod för en 68030" +msgstr "Generera kod för en 68030." #: config/m68k/m68k.opt:74 -#, fuzzy -#| msgid "Generate code for a 68040" msgid "Generate code for a 68040." -msgstr "Generera kod för en 68040" +msgstr "Generera kod för en 68040." #: config/m68k/m68k.opt:78 -#, fuzzy -#| msgid "Generate code for a 68060" msgid "Generate code for a 68060." -msgstr "Generera kod för en 68060" +msgstr "Generera kod för en 68060." #: config/m68k/m68k.opt:82 -#, fuzzy -#| msgid "Generate code for a 68302" msgid "Generate code for a 68302." -msgstr "Generera kod för en 68302" +msgstr "Generera kod för en 68302." #: config/m68k/m68k.opt:86 -#, fuzzy -#| msgid "Generate code for a 68332" msgid "Generate code for a 68332." -msgstr "Generera kod för en 68332" +msgstr "Generera kod för en 68332." #: config/m68k/m68k.opt:91 -#, fuzzy -#| msgid "Generate code for a 68851" msgid "Generate code for a 68851." -msgstr "Generera kod för en 68851" +msgstr "Generera kod för en 68851." #: config/m68k/m68k.opt:95 -#, fuzzy -#| msgid "Generate code that uses 68881 floating-point instructions" msgid "Generate code that uses 68881 floating-point instructions." -msgstr "Generera kod som använder flyttalsinstruktioner för 68881" +msgstr "Generera kod som använder flyttalsinstruktioner för 68881." #: config/m68k/m68k.opt:99 -#, fuzzy -#| msgid "Align variables on a 32-bit boundary" msgid "Align variables on a 32-bit boundary." -msgstr "Justera variabler på en 32-bitarsgräns" +msgstr "Justera variabler på en 32-bitarsgräns." #: config/m68k/m68k.opt:103 config/arm/arm.opt:81 config/nios2/nios2.opt:570 #: config/nds32/nds32.opt:66 config/c6x/c6x.opt:67 @@ -8978,160 +7859,108 @@ msgid "Specify the name of the target architecture." msgstr "Ange namnet på målarkitekturen." #: config/m68k/m68k.opt:107 -#, fuzzy -#| msgid "Use the bit-field instructions" msgid "Use the bit-field instructions." -msgstr "Använd bitfältsinstruktionerna" +msgstr "Använd bitfältsinstruktionerna." #: config/m68k/m68k.opt:119 -#, fuzzy -#| msgid "Generate code for a ColdFire v4e" msgid "Generate code for a ColdFire v4e." -msgstr "Generera kod för en ColdFire v4e" +msgstr "Generera kod för en ColdFire v4e." #: config/m68k/m68k.opt:123 -#, fuzzy -#| msgid "Specify the target CPU" msgid "Specify the target CPU." -msgstr "Ange mål-CPU:n" +msgstr "Ange mål-CPU:n." #: config/m68k/m68k.opt:127 -#, fuzzy -#| msgid "Generate code for a cpu32" msgid "Generate code for a cpu32." -msgstr "Generera kod för en cpu32" +msgstr "Generera kod för en cpu32." #: config/m68k/m68k.opt:131 -#, fuzzy -#| msgid "Use hardware division instructions on ColdFire" msgid "Use hardware division instructions on ColdFire." -msgstr "Använd hårdvarudivisionsinstruktioner på ColdFire" +msgstr "Använd hårdvarudivisionsinstruktioner på ColdFire." #: config/m68k/m68k.opt:135 -#, fuzzy -#| msgid "Generate code for a Fido A" msgid "Generate code for a Fido A." -msgstr "Generera kod för en Fido A" +msgstr "Generera kod för en Fido A." #: config/m68k/m68k.opt:139 -#, fuzzy -#| msgid "Generate code which uses hardware floating point instructions" msgid "Generate code which uses hardware floating point instructions." -msgstr "Generera kod som använder hårdvaruflyttalsinstruktioner" +msgstr "Generera kod som använder hårdvaruflyttalsinstruktioner." #: config/m68k/m68k.opt:143 -#, fuzzy -#| msgid "Enable ID based shared library" msgid "Enable ID based shared library." -msgstr "Aktivera ID-baserat delat bibliotek" +msgstr "Aktivera ID-baserat delat bibliotek." #: config/m68k/m68k.opt:147 -#, fuzzy -#| msgid "Do not use the bit-field instructions" msgid "Do not use the bit-field instructions." -msgstr "Använd inte bitfältsinstruktionerna" +msgstr "Använd inte bitfältsinstruktionerna." #: config/m68k/m68k.opt:151 -#, fuzzy -#| msgid "Use normal calling convention" msgid "Use normal calling convention." -msgstr "Använd normal anropskonvention" +msgstr "Använd normal anropskonvention." #: config/m68k/m68k.opt:155 -#, fuzzy -#| msgid "Consider type 'int' to be 32 bits wide" msgid "Consider type 'int' to be 32 bits wide." -msgstr "Betrakta typen ”int” som 32 bitar bred" +msgstr "Betrakta typen ”int” som 32 bitar bred." #: config/m68k/m68k.opt:159 -#, fuzzy -#| msgid "Generate pc-relative code" msgid "Generate pc-relative code." -msgstr "Generera pc-relativ kod" +msgstr "Generera pc-relativ kod." #: config/m68k/m68k.opt:163 -#, fuzzy -#| msgid "Use different calling convention using 'rtd'" msgid "Use different calling convention using 'rtd'." -msgstr "Använd en annan anropskonvention som använder ”rtd”" +msgstr "Använd en annan anropskonvention som använder ”rtd”." #: config/m68k/m68k.opt:175 -#, fuzzy -#| msgid "Consider type 'int' to be 16 bits wide" msgid "Consider type 'int' to be 16 bits wide." -msgstr "Betrakta typen ”int” som 16 bitar bred" +msgstr "Betrakta typen ”int” som 16 bitar bred." #: config/m68k/m68k.opt:179 -#, fuzzy -#| msgid "Generate code with library calls for floating point" msgid "Generate code with library calls for floating point." -msgstr "Generera kod med biblioteksanrop för flyttal" +msgstr "Generera kod med biblioteksanrop för flyttal." #: config/m68k/m68k.opt:183 -#, fuzzy -#| msgid "Do not use unaligned memory references" msgid "Do not use unaligned memory references." -msgstr "Använd inte ojusterade minnesreferenser" +msgstr "Använd inte ojusterade minnesreferenser." #: config/m68k/m68k.opt:187 -#, fuzzy -#| msgid "Tune for the specified target CPU or architecture" msgid "Tune for the specified target CPU or architecture." -msgstr "Trimma för den angivna mål-CPU:n eller arkitekturen" +msgstr "Trimma för den angivna mål-CPU:n eller arkitekturen." #: config/m68k/m68k.opt:191 -#, fuzzy -#| msgid "Support more than 8192 GOT entries on ColdFire" msgid "Support more than 8192 GOT entries on ColdFire." -msgstr "Stöd mer än 8192 GOT-poster på ColdFire" +msgstr "Stöd mer än 8192 GOT-poster på ColdFire." #: config/m68k/m68k.opt:195 -#, fuzzy -#| msgid "Support TLS segment larger than 64K" msgid "Support TLS segment larger than 64K." -msgstr "Stöd TLS-segment större än 64 k" +msgstr "Stöd TLS-segment större än 64 k." #: config/m32c/m32c.opt:23 -#, fuzzy -#| msgid "-msim\tUse simulator runtime" msgid "-msim\tUse simulator runtime." -msgstr "-msim\tAnvänd simulatorkörtider" +msgstr "-msim\tAnvänd simulatorkörtider." #: config/m32c/m32c.opt:27 -#, fuzzy -#| msgid "-mcpu=r8c\tCompile code for R8C variants" msgid "-mcpu=r8c\tCompile code for R8C variants." -msgstr "-mcpu=r8c\tKompilera kod för R8C-varianter" +msgstr "-mcpu=r8c\tKompilera kod för R8C-varianter." #: config/m32c/m32c.opt:31 -#, fuzzy -#| msgid "-mcpu=m16c\tCompile code for M16C variants" msgid "-mcpu=m16c\tCompile code for M16C variants." -msgstr "-mcpu=m16c\tKompilera kod för M16C-varianter" +msgstr "-mcpu=m16c\tKompilera kod för M16C-varianter." #: config/m32c/m32c.opt:35 -#, fuzzy -#| msgid "-mcpu=m32cm\tCompile code for M32CM variants" msgid "-mcpu=m32cm\tCompile code for M32CM variants." -msgstr "-mcpu=m32cm\tKompilera kod för M32CM-varianter" +msgstr "-mcpu=m32cm\tKompilera kod för M32CM-varianter." #: config/m32c/m32c.opt:39 -#, fuzzy -#| msgid "-mcpu=m32c\tCompile code for M32C variants" msgid "-mcpu=m32c\tCompile code for M32C variants." -msgstr "-mcpu=m32c\tKompilera kod för M32C-varianter" +msgstr "-mcpu=m32c\tKompilera kod för M32C-varianter." #: config/m32c/m32c.opt:43 -#, fuzzy -#| msgid "-memregs=\tNumber of memreg bytes (default: 16, range: 0..16)" msgid "-memregs=\tNumber of memreg bytes (default: 16, range: 0..16)." -msgstr "-memregs=\tAntal memreg-byte (standard: 16, intervall: 0..16)" +msgstr "-memregs=\tAntal memreg-byte (standard: 16, intervall: 0..16)." #: config/msp430/msp430.opt:7 -#, fuzzy -#| msgid "Force assembly output to always use hex constants" msgid "Force assembly output to always use hex constants." -msgstr "Tvinga assemblerutdata att alltid använda hexadecimala konstanter" +msgstr "Tvinga assemblerutdata att alltid använda hexadecimala konstanter." #: config/msp430/msp430.opt:11 msgid "Specify the MCU to build for." @@ -9142,44 +7971,32 @@ msgid "Warn if an MCU name is unrecognised or conflicts with other options (defa msgstr "Varna om ett MCU-namn inte känns igen eller står i konflikt med andra flaggor (standar: på)." #: config/msp430/msp430.opt:19 -#, fuzzy -#| msgid "Specify the ISA to build for: msp430, mdsp430x, msp430xv2" msgid "Specify the ISA to build for: msp430, msp430x, msp430xv2." -msgstr "Ange ISA:n att bygga för: msp430, mdsp430x, msp430xv2" +msgstr "Ange ISA:n att bygga för: msp430, msp430x, msp430xv2." #: config/msp430/msp430.opt:23 -#, fuzzy -#| msgid "Select large model - 20-bit addresses/pointers" msgid "Select large model - 20-bit addresses/pointers." -msgstr "Välj stor modell — 20-bitars adresser/pekare" +msgstr "Välj stor modell — 20-bitars adresser/pekare." #: config/msp430/msp430.opt:27 -#, fuzzy -#| msgid "Select small model - 16-bit addresses/pointers (default)" msgid "Select small model - 16-bit addresses/pointers (default)." -msgstr "Välj liten modell — 16-bitars adresser/pekare (standard)" +msgstr "Välj liten modell — 16-bitars adresser/pekare (standard)." #: config/msp430/msp430.opt:31 -#, fuzzy -#| msgid "Optimize opcode sizes at link time" msgid "Optimize opcode sizes at link time." -msgstr "Optimera op-kodsstorlekar vid länkningstillfället" +msgstr "Optimera op-kodsstorlekar vid länkningstillfället." #: config/msp430/msp430.opt:38 msgid "Use a minimum runtime (no static initializers or ctors) for memory-constrained devices." msgstr "Använd en minimal körmiljö (inga statiska initierare eller ctors) för minnesbegränsade enheter." #: config/msp430/msp430.opt:45 -#, fuzzy -#| msgid "Specify the type of hardware multiply to support" msgid "Specify the type of hardware multiply to support." -msgstr "Ange typen av hårdvarumultiplikation att stödja" +msgstr "Ange typen av hårdvarumultiplikation att stödja." #: config/msp430/msp430.opt:67 -#, fuzzy -#| msgid "Specifies whether interrupt functions should save and restore the accumulator register." msgid "Specify whether functions should be placed into low or high memory." -msgstr "Anger om avbrottsfunktioner skall spara och återställa ackumulatorregistret." +msgstr "Ange om funktioner skall placeras i lågt eller högt minne." #: config/msp430/msp430.opt:71 msgid "Specify whether variables should be placed into low or high memory." @@ -9203,89 +8020,61 @@ msgstr "Namnen för flaggan för kodmodell för -mcmodel:" #: config/aarch64/aarch64.opt:65 config/arm/arm.opt:94 #: config/microblaze/microblaze.opt:60 -#, fuzzy -#| msgid "Assume target CPU is configured as big endian" msgid "Assume target CPU is configured as big endian." -msgstr "Antag att mål-CPU:n är konfigurerad för rak byteordning" +msgstr "Antag att mål-CPU:n är konfigurerad för rak byteordning." #: config/aarch64/aarch64.opt:69 -#, fuzzy -#| msgid "Generate code which uses only the general registers" msgid "Generate code which uses only the general registers." -msgstr "Generera kod som använder endast generella register" +msgstr "Generera kod som använder endast generella register." #: config/aarch64/aarch64.opt:73 -#, fuzzy -#| msgid "Workaround for ARM Cortex-A53 Erratum number 835769" msgid "Workaround for ARM Cortex-A53 Erratum number 835769." -msgstr "Sätt att gå runt ARM Cortex-A53:s errata nummer 835796" +msgstr "Sätt att gå runt ARM Cortex-A53:s errata nummer 835796." #: config/aarch64/aarch64.opt:77 -#, fuzzy -#| msgid "Workaround for ARM Cortex-A53 Erratum number 843419" msgid "Workaround for ARM Cortex-A53 Erratum number 843419." -msgstr "Sätt att gå runt ARM Cortex-A53:s errata nummer 843419" +msgstr "Sätt att gå runt ARM Cortex-A53:s errata nummer 843419." #: config/aarch64/aarch64.opt:81 config/arm/arm.opt:155 #: config/microblaze/microblaze.opt:64 -#, fuzzy -#| msgid "Assume target CPU is configured as little endian" msgid "Assume target CPU is configured as little endian." -msgstr "Antag att mål-CPU:n är konfigurerad med omvänd byteordning" +msgstr "Antag att mål-CPU:n är konfigurerad med omvänd byteordning." #: config/aarch64/aarch64.opt:85 -#, fuzzy -#| msgid "Specify the code model" msgid "Specify the code model." -msgstr "Ange kodmodellen" +msgstr "Ange kodmodellen." #: config/aarch64/aarch64.opt:89 -#, fuzzy -#| msgid "Don't assume that unaligned accesses are handled by the system" msgid "Don't assume that unaligned accesses are handled by the system." -msgstr "Anta inte att ojusterade åtkomster hanteras av systemet" +msgstr "Anta inte att ojusterade åtkomster hanteras av systemet." #: config/aarch64/aarch64.opt:93 config/i386/i386.opt:390 -#, fuzzy -#| msgid "Omit the frame pointer in leaf functions" msgid "Omit the frame pointer in leaf functions." -msgstr "Utelämna rampekaren i lövfunktioner" +msgstr "Utelämna rampekaren i lövfunktioner." #: config/aarch64/aarch64.opt:97 -#, fuzzy -#| msgid "Specify TLS dialect" msgid "Specify TLS dialect." -msgstr "Ange TLS-dialekt" +msgstr "Ange TLS-dialekt." #: config/aarch64/aarch64.opt:101 -#, fuzzy -#| msgid "Specify bit size of immediate TLS offsets" msgid "Specifies bit size of immediate TLS offsets. Valid values are 12, 24, 32, 48." -msgstr "Ange bitstorlek på omedelbara TLS-avstånd" +msgstr "Ange bitstorlek på omedelbara TLS-avstånd. Giltiga värden är 12, 24, 32, 48." #: config/aarch64/aarch64.opt:120 -#, fuzzy -#| msgid "-march=ARCH\tUse features of architecture ARCH" msgid "-march=ARCH\tUse features of architecture ARCH." -msgstr "-march=ARK\tAnvänd funktioner i arkitekturen ARK" +msgstr "-march=ARK\tAnvänd funktioner i arkitekturen ARK." #: config/aarch64/aarch64.opt:124 -#, fuzzy -#| msgid "-mcpu=CPU\tUse features of and optimize for CPU" msgid "-mcpu=CPU\tUse features of and optimize for CPU." -msgstr "-mcpu=CPU\tAnvänd funktioner i och optimera för angiven CPU" +msgstr "-mcpu=CPU\tAnvänd funktioner i och optimera för angiven CPU." #: config/aarch64/aarch64.opt:128 -#, fuzzy -#| msgid "-mtune=CPU\tOptimize for CPU" msgid "-mtune=CPU\tOptimize for CPU." -msgstr "-mtune=CPU\tOptimera för CPU" +msgstr "-mtune=CPU\tOptimera för CPU." #: config/aarch64/aarch64.opt:132 -#, fuzzy -#| msgid "-mabi=ABI\tGenerate code that conforms to the specified ABI" msgid "-mabi=ABI\tGenerate code that conforms to the specified ABI." -msgstr "-mabi=ABI\tGenerera kod som följer det angivna ABI:et" +msgstr "-mabi=ABI\tGenerera kod som följer det angivna ABI:et." #: config/aarch64/aarch64.opt:136 msgid "-moverride=STRING\tPower users only! Override CPU optimization parameters." @@ -9297,391 +8086,267 @@ msgstr "Kända AArch64-ABI:er (att användas med flaggan -mabi=):" #: config/aarch64/aarch64.opt:150 msgid "PC relative literal loads." -msgstr "PC-relativa literala läsningar." +msgstr "PC-relativa literala laddningar." #: config/aarch64/aarch64.opt:154 msgid "When calculating a sqrt approximation, run fewer steps." msgstr "Vid beräkning av sqrt-approximering, kör färre steg." #: config/linux.opt:24 -#, fuzzy -#| msgid "Use Bionic C library" msgid "Use Bionic C library." -msgstr "Använd C-biblioteket Bionic" +msgstr "Använd C-biblioteket Bionic." #: config/linux.opt:28 -#, fuzzy -#| msgid "Use GNU C library" msgid "Use GNU C library." -msgstr "Använd GNU C-bibliotek" +msgstr "Använd GNU C-bibliotek." #: config/linux.opt:32 -#, fuzzy -#| msgid "Use uClibc C library" msgid "Use uClibc C library." -msgstr "Använd C-biblioteket uClibc" +msgstr "Använd C-biblioteket uClibc." #: config/linux.opt:36 -#, fuzzy -#| msgid "Use uClibc C library" msgid "Use musl C library." -msgstr "Använd C-biblioteket uClibc" +msgstr "Använd C-biblioteket musl." #: config/ia64/ilp32.opt:3 -#, fuzzy -#| msgid "Generate ILP32 code" msgid "Generate ILP32 code." -msgstr "Generera ILP32-kod" +msgstr "Generera ILP32-kod." #: config/ia64/ilp32.opt:7 -#, fuzzy -#| msgid "Generate LP64 code" msgid "Generate LP64 code." -msgstr "Generera LP64-kod" +msgstr "Generera LP64-kod." #: config/ia64/ia64.opt:28 -#, fuzzy -#| msgid "Generate big endian code" msgid "Generate big endian code." -msgstr "Generera kod med rak byteordning" +msgstr "Generera kod med rak byteordning." #: config/ia64/ia64.opt:32 -#, fuzzy -#| msgid "Generate little endian code" msgid "Generate little endian code." -msgstr "Generera kod med omvänd byteordning" +msgstr "Generera kod med omvänd byteordning." #: config/ia64/ia64.opt:36 -#, fuzzy -#| msgid "Generate code for GNU as" msgid "Generate code for GNU as." -msgstr "Generera kod för GNU as" +msgstr "Generera kod för GNU as." #: config/ia64/ia64.opt:40 -#, fuzzy -#| msgid "Generate code for GNU ld" msgid "Generate code for GNU ld." -msgstr "Generera kod för GNU ld" +msgstr "Generera kod för GNU ld." #: config/ia64/ia64.opt:44 -#, fuzzy -#| msgid "Emit stop bits before and after volatile extended asms" msgid "Emit stop bits before and after volatile extended asms." -msgstr "Mata ut stoppbitar före och efter flyktiga utökade asm:er" +msgstr "Mata ut stoppbitar före och efter flyktiga utökade asm:er." #: config/ia64/ia64.opt:48 -#, fuzzy -#| msgid "Use in/loc/out register names" msgid "Use in/loc/out register names." -msgstr "Använd in/loc/out-registernamn" +msgstr "Använd in/loc/out-registernamn." #: config/ia64/ia64.opt:55 -#, fuzzy -#| msgid "Enable use of sdata/scommon/sbss" msgid "Enable use of sdata/scommon/sbss." -msgstr "Aktivera användningen av sdata/scommon/sbss" +msgstr "Aktivera användningen av sdata/scommon/sbss." #: config/ia64/ia64.opt:59 -#, fuzzy -#| msgid "Generate code without GP reg" msgid "Generate code without GP reg." -msgstr "Generera kod utan GP-reg" +msgstr "Generera kod utan GP-reg." #: config/ia64/ia64.opt:63 -#, fuzzy -#| msgid "gp is constant (but save/restore gp on indirect calls)" msgid "gp is constant (but save/restore gp on indirect calls)." -msgstr "gp är konstant (men spara/återställ gp vid indirekta anrop)" +msgstr "gp är konstant (men spara/återställ gp vid indirekta anrop)." #: config/ia64/ia64.opt:67 -#, fuzzy -#| msgid "Generate self-relocatable code" msgid "Generate self-relocatable code." -msgstr "Generera självomlokaliserbar kod" +msgstr "Generera självomlokaliserbar kod." #: config/ia64/ia64.opt:71 -#, fuzzy -#| msgid "Generate inline floating point division, optimize for latency" msgid "Generate inline floating point division, optimize for latency." -msgstr "Generera inline flyttalsdivision, optimera för svarstid" +msgstr "Generera inline flyttalsdivision, optimera för svarstid." #: config/ia64/ia64.opt:75 -#, fuzzy -#| msgid "Generate inline floating point division, optimize for throughput" msgid "Generate inline floating point division, optimize for throughput." -msgstr "Generera inline flyttalsdivision, optimera för genomströmning" +msgstr "Generera inline flyttalsdivision, optimera för genomströmning." #: config/ia64/ia64.opt:82 -#, fuzzy -#| msgid "Generate inline integer division, optimize for latency" msgid "Generate inline integer division, optimize for latency." -msgstr "Generera inline heltalsdivision, optimera för svarstid" +msgstr "Generera inline heltalsdivision, optimera för svarstid." #: config/ia64/ia64.opt:86 -#, fuzzy -#| msgid "Generate inline integer division, optimize for throughput" msgid "Generate inline integer division, optimize for throughput." -msgstr "Generera inline heltalsdivision, optimera för genomströmning" +msgstr "Generera inline heltalsdivision, optimera för genomströmning." #: config/ia64/ia64.opt:90 -#, fuzzy -#| msgid "Do not inline integer division" msgid "Do not inline integer division." -msgstr "Inline:a inte heltalsdivision" +msgstr "Inline:a inte heltalsdivision." #: config/ia64/ia64.opt:94 -#, fuzzy -#| msgid "Generate inline square root, optimize for latency" msgid "Generate inline square root, optimize for latency." -msgstr "Generera inline kvadratrot, optimera för svarstid" +msgstr "Generera inline kvadratrot, optimera för svarstid." #: config/ia64/ia64.opt:98 -#, fuzzy -#| msgid "Generate inline square root, optimize for throughput" msgid "Generate inline square root, optimize for throughput." -msgstr "Generera inline kvadratrot, optimera för genomströmning" +msgstr "Generera inline kvadratrot, optimera för genomströmning." #: config/ia64/ia64.opt:102 -#, fuzzy -#| msgid "Do not inline square root" msgid "Do not inline square root." -msgstr "Inline:a inte kvadratrot" +msgstr "Inline:a inte kvadratrot." #: config/ia64/ia64.opt:106 -#, fuzzy -#| msgid "Enable Dwarf 2 line debug info via GNU as" msgid "Enable DWARF line debug info via GNU as." -msgstr "Aktivera Dwarf 2 radfelsökningsinformation via GNU as" +msgstr "Aktivera DWARF radfelsökningsinformation via GNU as." #: config/ia64/ia64.opt:110 -#, fuzzy -#| msgid "Enable earlier placing stop bits for better scheduling" msgid "Enable earlier placing stop bits for better scheduling." -msgstr "Aktivera tidigare utplacering av stoppbitar för bättre schemaläggning" +msgstr "Aktivera tidigare utplacering av stoppbitar för bättre schemaläggning." #: config/ia64/ia64.opt:114 config/spu/spu.opt:72 config/pa/pa.opt:58 #: config/sh/sh.opt:273 -#, fuzzy -#| msgid "Specify range of registers to make fixed" msgid "Specify range of registers to make fixed." -msgstr "Ange intervall av register att fixera" +msgstr "Ange intervall av register att fixera." #: config/ia64/ia64.opt:118 config/rs6000/sysv4.opt:32 #: config/alpha/alpha.opt:130 -#, fuzzy -#| msgid "Specify bit size of immediate TLS offsets" msgid "Specify bit size of immediate TLS offsets." -msgstr "Ange bitstorlek på omedelbara TLS-avstånd" +msgstr "Ange bitstorlek på omedelbara TLS-avstånd." #: config/ia64/ia64.opt:122 config/spu/spu.opt:84 config/i386/i386.opt:504 #: config/s390/s390.opt:170 config/sparc/sparc.opt:126 #: config/visium/visium.opt:49 -#, fuzzy -#| msgid "Schedule code for given CPU" msgid "Schedule code for given CPU." -msgstr "Schemalägg kod för en given CPU" +msgstr "Schemalägg kod för en given CPU." #: config/ia64/ia64.opt:126 msgid "Known Itanium CPUs (for use with the -mtune= option):" msgstr "Kända Itanium-CPU:er (att användas med flaggan -mtune=):" #: config/ia64/ia64.opt:136 -#, fuzzy -#| msgid "Use data speculation before reload" msgid "Use data speculation before reload." -msgstr "Använd dataspekulation före omläsning" +msgstr "Använd dataspekulation före omläsning." #: config/ia64/ia64.opt:140 -#, fuzzy -#| msgid "Use data speculation after reload" msgid "Use data speculation after reload." -msgstr "Använd dataspekulation efter omläsning" +msgstr "Använd dataspekulation efter omläsning." #: config/ia64/ia64.opt:144 -#, fuzzy -#| msgid "Use control speculation" msgid "Use control speculation." -msgstr "Använd styrspekulation" +msgstr "Använd styrspekulation." #: config/ia64/ia64.opt:148 -#, fuzzy -#| msgid "Use in block data speculation before reload" msgid "Use in block data speculation before reload." -msgstr "Använd inblocksdataspekulation före omläsning" +msgstr "Använd inblocksdataspekulation före omläsning." #: config/ia64/ia64.opt:152 -#, fuzzy -#| msgid "Use in block data speculation after reload" msgid "Use in block data speculation after reload." -msgstr "Använd inblocksdataspekulation efter omläsning" +msgstr "Använd inblocksdataspekulation efter omläsning." #: config/ia64/ia64.opt:156 -#, fuzzy -#| msgid "Use in block control speculation" msgid "Use in block control speculation." -msgstr "Använd inblocksstyrspekulation" +msgstr "Använd inblocksstyrspekulation." #: config/ia64/ia64.opt:160 -#, fuzzy -#| msgid "Use simple data speculation check" msgid "Use simple data speculation check." -msgstr "Använd enkel dataspekulationskontroll" +msgstr "Använd enkel dataspekulationskontroll." #: config/ia64/ia64.opt:164 -#, fuzzy -#| msgid "Use simple data speculation check for control speculation" msgid "Use simple data speculation check for control speculation." -msgstr "Använd enkel dataspekulationskontroll för styrspekulation" +msgstr "Använd enkel dataspekulationskontroll för styrspekulation." #: config/ia64/ia64.opt:174 -#, fuzzy -#| msgid "Count speculative dependencies while calculating priority of instructions" msgid "Count speculative dependencies while calculating priority of instructions." -msgstr "Räkna spekulativa beroenden vid beräkning av prioritet för instruktioner" +msgstr "Räkna spekulativa beroenden vid beräkning av prioritet för instruktioner." #: config/ia64/ia64.opt:178 -#, fuzzy -#| msgid "Place a stop bit after every cycle when scheduling" msgid "Place a stop bit after every cycle when scheduling." -msgstr "Placera en stoppbit efter varje cykel vid schemaläggning" +msgstr "Placera en stoppbit efter varje cykel vid schemaläggning." #: config/ia64/ia64.opt:182 -#, fuzzy -#| msgid "Assume that floating-point stores and loads are not likely to cause conflict when placed into one instruction group" msgid "Assume that floating-point stores and loads are not likely to cause conflict when placed into one instruction group." -msgstr "Anta att flyttalslagringar och -laddningar troligen inte orsakar konflikter när de placeras i en instruktionsgrupp" +msgstr "Anta att flyttalslagringar och -laddningar troligen inte orsakar konflikter när de placeras i en instruktionsgrupp." #: config/ia64/ia64.opt:186 -#, fuzzy -#| msgid "Soft limit on number of memory insns per instruction group, giving lower priority to subsequent memory insns attempting to schedule in the same insn group. Frequently useful to prevent cache bank conflicts. Default value is 1" msgid "Soft limit on number of memory insns per instruction group, giving lower priority to subsequent memory insns attempting to schedule in the same insn group. Frequently useful to prevent cache bank conflicts. Default value is 1." -msgstr "Mjuk gräns på antalet minnesinstruktioner per instruktionsgrupp, ger lägre prioritet till försök att schemalägga senare minnesinstruktioner i samma instruktionsgrupp. Ofta användbart för att hindra konflikter mellan cache-bankar. Standardvärdet är 1" +msgstr "Mjuk gräns på antalet minnesinstruktioner per instruktionsgrupp, ger lägre prioritet till försök att schemalägga senare minnesinstruktioner i samma instruktionsgrupp. Ofta användbart för att hindra konflikter mellan cache-bankar. Standardvärdet är 1." #: config/ia64/ia64.opt:190 -#, fuzzy -#| msgid "Disallow more than 'msched-max-memory-insns' in instruction group. Otherwise, limit is 'soft' (prefer non-memory operations when limit is reached)" msgid "Disallow more than 'msched-max-memory-insns' in instruction group. Otherwise, limit is 'soft' (prefer non-memory operations when limit is reached)." -msgstr "Tillåt inte mer än ”msched-max-memory-insns” i instruktionsgrupper. Annars är gränsen ”mjuk” (föredra icke-minnesoperationer när gränsen är nådd)" +msgstr "Tillåt inte mer än ”msched-max-memory-insns” i instruktionsgrupper. Annars är gränsen ”mjuk” (föredra icke-minnesoperationer när gränsen är nådd)." #: config/ia64/ia64.opt:194 -#, fuzzy -#| msgid "Don't generate checks for control speculation in selective scheduling" msgid "Don't generate checks for control speculation in selective scheduling." -msgstr "Generera inte kontroller av styrningsspekulation i selektiv schemaläggning" +msgstr "Generera inte kontroller av styrningsspekulation i selektiv schemaläggning." #: config/spu/spu.opt:20 -#, fuzzy -#| msgid "Emit warnings when run-time relocations are generated" msgid "Emit warnings when run-time relocations are generated." -msgstr "Generera varningar när körtidsomlokaliseringar genereras" +msgstr "Generera varningar när körtidsomlokaliseringar genereras." #: config/spu/spu.opt:24 -#, fuzzy -#| msgid "Emit errors when run-time relocations are generated" msgid "Emit errors when run-time relocations are generated." -msgstr "Generera felmeddelanden när körtidsomlokaliseringar genereras" +msgstr "Generera felmeddelanden när körtidsomlokaliseringar genereras." #: config/spu/spu.opt:28 -#, fuzzy -#| msgid "Specify cost of branches (Default 20)" msgid "Specify cost of branches (Default 20)." -msgstr "Ange kostnaden för grenar (normalt 20)" +msgstr "Ange kostnaden för grenar (normalt 20)." #: config/spu/spu.opt:32 -#, fuzzy -#| msgid "Make sure loads and stores are not moved past DMA instructions" msgid "Make sure loads and stores are not moved past DMA instructions." -msgstr "Säkerställ att inläsningar och lagringar inte flyttas förbi DMA-instruktioner" +msgstr "Säkerställ att laddningar och lagringar inte flyttas förbi DMA-instruktioner." #: config/spu/spu.opt:36 -#, fuzzy -#| msgid "volatile must be specified on any memory that is effected by DMA" msgid "volatile must be specified on any memory that is effected by DMA." -msgstr "volatile måste anges för allt minne som påverkas av DMA" +msgstr "volatile måste anges för allt minne som påverkas av DMA." #: config/spu/spu.opt:40 config/spu/spu.opt:44 -#, fuzzy -#| msgid "Insert nops when it might improve performance by allowing dual issue (default)" msgid "Insert nops when it might improve performance by allowing dual issue (default)." -msgstr "Skjut in nop:ar när det kan förbättra prestanda genom att tillåta dubbel utgivning (standard)" +msgstr "Skjut in nop:ar när det kan förbättra prestanda genom att tillåta dubbel utgivning (standard)." #: config/spu/spu.opt:48 -#, fuzzy -#| msgid "Use standard main function as entry for startup" msgid "Use standard main function as entry for startup." -msgstr "Använd standard main-funktion som ingång vid uppstart" +msgstr "Använd standard main-funktion som ingång vid uppstart." #: config/spu/spu.opt:52 -#, fuzzy -#| msgid "Generate branch hints for branches" msgid "Generate branch hints for branches." -msgstr "Generera grentips för grenar" +msgstr "Generera grentips för grenar." #: config/spu/spu.opt:56 -#, fuzzy -#| msgid "Maximum number of nops to insert for a hint (Default 2)" msgid "Maximum number of nops to insert for a hint (Default 2)." -msgstr "Det maximala antalet nop-instruktioner att skjuta in för ett tips (standard 2)" +msgstr "Det maximala antalet nop-instruktioner att skjuta in för ett tips (standard 2)." #: config/spu/spu.opt:60 -#, fuzzy -#| msgid "Approximate maximum number of instructions to allow between a hint and its branch [125]" msgid "Approximate maximum number of instructions to allow between a hint and its branch [125]." -msgstr "Ungefärligt antal instruktioner att tillåta mellan ett tips och dess gren [125]" +msgstr "Ungefärligt antal instruktioner att tillåta mellan ett tips och dess gren [125]." #: config/spu/spu.opt:64 -#, fuzzy -#| msgid "Generate code for 18 bit addressing" msgid "Generate code for 18 bit addressing." -msgstr "Generera kod för 18-bitars adressering" +msgstr "Generera kod för 18-bitars adressering." #: config/spu/spu.opt:68 -#, fuzzy -#| msgid "Generate code for 32 bit addressing" msgid "Generate code for 32 bit addressing." -msgstr "Generera kod för 32-bitars adressering" +msgstr "Generera kod för 32-bitars adressering." #: config/spu/spu.opt:76 -#, fuzzy -#| msgid "Insert hbrp instructions after hinted branch targets to avoid the SPU hang issue" msgid "Insert hbrp instructions after hinted branch targets to avoid the SPU hang issue." -msgstr "Lägg in hbrp-instruktioner efter grenmål med tips för att undvika problemet med hängd SPU" +msgstr "Lägg in hbrp-instruktioner efter grenmål med tips för att undvika problemet med hängd SPU." #: config/spu/spu.opt:80 config/i386/i386.opt:247 config/s390/s390.opt:56 -#, fuzzy -#| msgid "Generate code for given CPU" msgid "Generate code for given CPU." -msgstr "Generera kod för en given CPU" +msgstr "Generera kod för en given CPU." #: config/spu/spu.opt:88 -#, fuzzy -#| msgid "Access variables in 32-bit PPU objects (default)" msgid "Access variables in 32-bit PPU objects (default)." -msgstr "Kom åt variabler i 32-bitars PPU-objekt (standard)" +msgstr "Kom åt variabler i 32-bitars PPU-objekt (standard)." #: config/spu/spu.opt:92 -#, fuzzy -#| msgid "Access variables in 64-bit PPU objects" msgid "Access variables in 64-bit PPU objects." -msgstr "Kom åt variabler i 64-bitars PPU-objekt" +msgstr "Kom åt variabler i 64-bitars PPU-objekt." #: config/spu/spu.opt:96 -#, fuzzy -#| msgid "Allow conversions between __ea and generic pointers (default)" msgid "Allow conversions between __ea and generic pointers (default)." -msgstr "Tillåt konvertering mellan __ea och generiska pekare (standard)" +msgstr "Tillåt konvertering mellan __ea och generiska pekare (standard)." #: config/spu/spu.opt:100 -#, fuzzy -#| msgid "Size (in KB) of software data cache" msgid "Size (in KB) of software data cache." -msgstr "Storlek (i kB) på programmets data-cache" +msgstr "Storlek (i kB) på programmets data-cache." #: config/spu/spu.opt:104 -#, fuzzy -#| msgid "Atomically write back software data cache lines (default)" msgid "Atomically write back software data cache lines (default)." -msgstr "Skriv atomärt tillbaka programmets data-cache-rader (standard)" +msgstr "Skriv atomärt tillbaka programmets data-cache-rader (standard)." #: config/epiphany/epiphany.opt:24 msgid "Don't use any of r32..r63." @@ -9692,44 +8357,32 @@ msgid "preferentially allocate registers that allow short instruction generation msgstr "allokera företrädesvis register som tillåter generering av korta instruktioner" #: config/epiphany/epiphany.opt:32 -#, fuzzy -#| msgid "Set branch cost" msgid "Set branch cost." -msgstr "Sätt grenkostnad" +msgstr "Sätt grenkostnad." #: config/epiphany/epiphany.opt:36 msgid "enable conditional move instruction usage." msgstr "aktivera användning av villkorliga flyttinstruktioner." #: config/epiphany/epiphany.opt:40 -#, fuzzy -#| msgid "set number of nops to emit before each insn pattern" msgid "set number of nops to emit before each insn pattern." -msgstr "sätt antalet nop:ar att mata ut före varje instruktionsmönster" +msgstr "sätt antalet nop:ar att mata ut före varje instruktionsmönster." #: config/epiphany/epiphany.opt:52 -#, fuzzy -#| msgid "Use software floating point comparisons" msgid "Use software floating point comparisons." -msgstr "Använd flyttalsjämförelser i programvara" +msgstr "Använd flyttalsjämförelser i programvara." #: config/epiphany/epiphany.opt:56 -#, fuzzy -#| msgid "Enable split of 32 bit immediate loads into low / high part" msgid "Enable split of 32 bit immediate loads into low / high part." -msgstr "Aktivera delning av 32-bitars omedelbara laddningar i låg/hög del" +msgstr "Aktivera delning av 32-bitars omedelbara laddningar i låg/hög del." #: config/epiphany/epiphany.opt:60 -#, fuzzy -#| msgid "Enable use of POST_INC / POST_DEC" msgid "Enable use of POST_INC / POST_DEC." -msgstr "Aktivera användning av POST_INC/POST_DEC" +msgstr "Aktivera användning av POST_INC/POST_DEC." #: config/epiphany/epiphany.opt:64 -#, fuzzy -#| msgid "Enable use of POST_MODIFY" msgid "Enable use of POST_MODIFY." -msgstr "Aktivera användning av POST_MODIFY" +msgstr "Aktivera användning av POST_MODIFY." #: config/epiphany/epiphany.opt:68 msgid "Set number of bytes on the stack preallocated for use by the callee." @@ -9740,26 +8393,20 @@ msgid "Assume round to nearest is selected for purposes of scheduling." msgstr "Anta avrundning till närmaste är valt i schemaläggningssyfte." #: config/epiphany/epiphany.opt:76 -#, fuzzy -#| msgid "Generate call insns as indirect calls" msgid "Generate call insns as indirect calls." -msgstr "Generera anropsinstruktioner som indirekta anrop" +msgstr "Generera anropsinstruktioner som indirekta anrop." #: config/epiphany/epiphany.opt:80 -#, fuzzy -#| msgid "Generate call insns as direct calls" msgid "Generate call insns as direct calls." -msgstr "Generera anropsinstruktioner som indirekta anrop" +msgstr "Generera anropsinstruktioner som indirekta anrop." #: config/epiphany/epiphany.opt:84 msgid "Assume labels and symbols can be addressed using 16 bit absolute addresses." msgstr "Anta att etiketter och symboler kan adresseras med 16-bitars absoluta adresser." #: config/epiphany/epiphany.opt:108 -#, fuzzy -#| msgid "A floatig point to integer truncation may be replaced with rounding to save mode switching" msgid "A floatig point to integer truncation may be replaced with rounding to save mode switching." -msgstr "En avhuggning från flyttal till heltal får ersättas med avrundning för att spara lägesbyten" +msgstr "En avhuggning från flyttal till heltal får ersättas med avrundning för att spara lägesbyten." #: config/epiphany/epiphany.opt:112 msgid "Vectorize for double-word operations." @@ -9783,406 +8430,280 @@ msgstr "ha programvarusimulatorn som mål." #: config/ft32/ft32.opt:27 config/s390/s390.opt:201 #: config/rs6000/rs6000.opt:474 config/mips/mips.opt:385 -#, fuzzy -#| msgid "Use LRA instead of reload" msgid "Use LRA instead of reload." -msgstr "Använd LRA istället för omladdning" +msgstr "Använd LRA istället för omladdning." #: config/h8300/h8300.opt:23 -#, fuzzy -#| msgid "Generate H8S code" msgid "Generate H8S code." -msgstr "Generera H8S-kod" +msgstr "Generera H8S-kod." #: config/h8300/h8300.opt:27 -#, fuzzy -#| msgid "Generate H8SX code" msgid "Generate H8SX code." -msgstr "Generera H8SX-kod" +msgstr "Generera H8SX-kod." #: config/h8300/h8300.opt:31 -#, fuzzy -#| msgid "Generate H8S/2600 code" msgid "Generate H8S/2600 code." -msgstr "Generera H8S/2600-kod" +msgstr "Generera H8S/2600-kod." #: config/h8300/h8300.opt:35 -#, fuzzy -#| msgid "Make integers 32 bits wide" msgid "Make integers 32 bits wide." -msgstr "Gör heltal 32 bitar stora" +msgstr "Gör heltal 32 bitar stora." #: config/h8300/h8300.opt:42 -#, fuzzy -#| msgid "Use registers for argument passing" msgid "Use registers for argument passing." -msgstr "Använd register för argumentskickning" +msgstr "Använd register för argumentskickning." #: config/h8300/h8300.opt:46 -#, fuzzy -#| msgid "Consider access to byte sized memory slow" msgid "Consider access to byte sized memory slow." -msgstr "Betrakta åtkomst till bytestort minne som långsam" +msgstr "Betrakta åtkomst till bytestort minne som långsam." #: config/h8300/h8300.opt:50 -#, fuzzy -#| msgid "Enable linker relaxing" msgid "Enable linker relaxing." -msgstr "Aktivera länkaravslappning" +msgstr "Aktivera länkaravslappning." #: config/h8300/h8300.opt:54 -#, fuzzy -#| msgid "Generate H8/300H code" msgid "Generate H8/300H code." -msgstr "Generera H8/300H-kod" +msgstr "Generera H8/300H-kod." #: config/h8300/h8300.opt:58 -#, fuzzy -#| msgid "Enable the normal mode" msgid "Enable the normal mode." -msgstr "Aktivera normalt läge" +msgstr "Aktivera normalt läge." #: config/h8300/h8300.opt:62 -#, fuzzy -#| msgid "Use H8/300 alignment rules" msgid "Use H8/300 alignment rules." -msgstr "Använd H8/300-regler för justering" +msgstr "Använd H8/300-regler för justering." #: config/h8300/h8300.opt:66 -#, fuzzy -#| msgid "Push extended registers on stack in monitor functions" msgid "Push extended registers on stack in monitor functions." -msgstr "Skicka ut utökade register på stacken i övervakningsfunktioner" +msgstr "Skicka ut utökade register på stacken i övervakningsfunktioner." #: config/h8300/h8300.opt:70 -#, fuzzy -#| msgid "Do not push extended registers on stack in monitor functions" msgid "Do not push extended registers on stack in monitor functions." -msgstr "Skicka inte ut utökade register på stacken i övervakningsfunktioner" +msgstr "Skicka inte ut utökade register på stacken i övervakningsfunktioner." #: config/pdp11/pdp11.opt:23 -#, fuzzy -#| msgid "Generate code for an 11/10" msgid "Generate code for an 11/10." -msgstr "Generera kod för 11/10" +msgstr "Generera kod för 11/10." #: config/pdp11/pdp11.opt:27 -#, fuzzy -#| msgid "Generate code for an 11/40" msgid "Generate code for an 11/40." -msgstr "Generera kod för 11/40" +msgstr "Generera kod för 11/40." #: config/pdp11/pdp11.opt:31 -#, fuzzy -#| msgid "Generate code for an 11/45" msgid "Generate code for an 11/45." -msgstr "Generera kod för 11/45" +msgstr "Generera kod för 11/45." #: config/pdp11/pdp11.opt:35 -#, fuzzy -#| msgid "Return floating-point results in ac0 (fr0 in Unix assembler syntax)" msgid "Return floating-point results in ac0 (fr0 in Unix assembler syntax)." -msgstr "Returnera flyttalsresultat i ac0 (fr0 i assemblersyntax för Unix)" +msgstr "Returnera flyttalsresultat i ac0 (fr0 i assemblersyntax för Unix)." #: config/pdp11/pdp11.opt:39 -#, fuzzy -#| msgid "Do not use inline patterns for copying memory" msgid "Do not use inline patterns for copying memory." -msgstr "Använd inte inline-mönster för att kopiera minne" +msgstr "Använd inte inline-mönster för att kopiera minne." #: config/pdp11/pdp11.opt:43 -#, fuzzy -#| msgid "Use inline patterns for copying memory" msgid "Use inline patterns for copying memory." -msgstr "Använd inline-mönster för att kopiera minne" +msgstr "Använd inline-mönster för att kopiera minne." #: config/pdp11/pdp11.opt:47 -#, fuzzy -#| msgid "Do not pretend that branches are expensive" msgid "Do not pretend that branches are expensive." -msgstr "Låtsas inte att grenar är dyra" +msgstr "Låtsas inte att grenar är dyra." #: config/pdp11/pdp11.opt:51 -#, fuzzy -#| msgid "Pretend that branches are expensive" msgid "Pretend that branches are expensive." -msgstr "Låtsas att grenar är dyra" +msgstr "Låtsas att grenar är dyra." #: config/pdp11/pdp11.opt:55 -#, fuzzy -#| msgid "Use the DEC assembler syntax" msgid "Use the DEC assembler syntax." -msgstr "Använd assemblersyntax för DEC" +msgstr "Använd assemblersyntax för DEC." #: config/pdp11/pdp11.opt:59 -#, fuzzy -#| msgid "Use 32 bit float" msgid "Use 32 bit float." -msgstr "Använd 32 bits float" +msgstr "Använd 32 bits float." #: config/pdp11/pdp11.opt:63 -#, fuzzy -#| msgid "Use 64 bit float" msgid "Use 64 bit float." -msgstr "Använd 64 bits float" +msgstr "Använd 64 bits float." #: config/pdp11/pdp11.opt:67 config/rs6000/rs6000.opt:177 #: config/frv/frv.opt:158 -#, fuzzy -#| msgid "Use hardware floating point" msgid "Use hardware floating point." -msgstr "Använd hårdvaruflyttal" +msgstr "Använd hårdvaruflyttal." #: config/pdp11/pdp11.opt:71 -#, fuzzy -#| msgid "Use 16 bit int" msgid "Use 16 bit int." -msgstr "Använd 16 bits int" +msgstr "Använd 16 bits int." #: config/pdp11/pdp11.opt:75 -#, fuzzy -#| msgid "Use 32 bit int" msgid "Use 32 bit int." -msgstr "Använd 32 bits int" +msgstr "Använd 32 bits int." #: config/pdp11/pdp11.opt:79 config/rs6000/rs6000.opt:173 -#, fuzzy -#| msgid "Do not use hardware floating point" msgid "Do not use hardware floating point." -msgstr "Använd inte hårdvaruflyttal" +msgstr "Använd inte hårdvaruflyttal." #: config/pdp11/pdp11.opt:83 -#, fuzzy -#| msgid "Target has split I&D" msgid "Target has split I&D." -msgstr "Målet har uppdelat I&D" +msgstr "Målet har uppdelat I&D." #: config/pdp11/pdp11.opt:87 -#, fuzzy -#| msgid "Use UNIX assembler syntax" msgid "Use UNIX assembler syntax." -msgstr "Använd assemblersyntax för UNIX" +msgstr "Använd assemblersyntax för UNIX." #: config/xtensa/xtensa.opt:23 -#, fuzzy -#| msgid "Use CONST16 instruction to load constants" msgid "Use CONST16 instruction to load constants." -msgstr "Använd CONST16-instruktioner för att läsa konstanter" +msgstr "Använd CONST16-instruktioner för att ladda konstanter." #: config/xtensa/xtensa.opt:27 -#, fuzzy -#| msgid "Disable position-independent code (PIC) for use in OS kernel code" msgid "Disable position-independent code (PIC) for use in OS kernel code." -msgstr "Avaktivera positionsoberoende kod (PIC) för användning i OS-kärnkod" +msgstr "Avaktivera positionsoberoende kod (PIC) för användning i OS-kärnkod." #: config/xtensa/xtensa.opt:31 -#, fuzzy -#| msgid "Use indirect CALLXn instructions for large programs" msgid "Use indirect CALLXn instructions for large programs." -msgstr "Använd indirekta CALLXn-instruktioner för stora program" +msgstr "Använd indirekta CALLXn-instruktioner för stora program." #: config/xtensa/xtensa.opt:35 -#, fuzzy -#| msgid "Automatically align branch targets to reduce branch penalties" msgid "Automatically align branch targets to reduce branch penalties." -msgstr "Justera automatiskt grenmål för att reducera grenstraff" +msgstr "Justera automatiskt grenmål för att reducera grenstraff." #: config/xtensa/xtensa.opt:39 -#, fuzzy -#| msgid "Intersperse literal pools with code in the text section" msgid "Intersperse literal pools with code in the text section." -msgstr "Växla mellan bokstavliga pooler och kod i textsektionen" +msgstr "Växla mellan bokstavliga pooler och kod i textsektionen." #: config/xtensa/xtensa.opt:43 msgid "Relax literals in assembler and place them automatically in the text section." msgstr "Lätta på literaler i assemblern och placera dem automatiskt i textsegmentet." #: config/xtensa/xtensa.opt:47 -#, fuzzy -#| msgid "-mno-serialize-volatile\tDo not serialize volatile memory references with MEMW instructions" msgid "-mno-serialize-volatile\tDo not serialize volatile memory references with MEMW instructions." -msgstr "-mno-serialize-volatile\tSerialisera inte minnesreferenser till flyktigt minne med MEMW-instruktioner" +msgstr "-mno-serialize-volatile\tSerialisera inte minnesreferenser till flyktigt minne med MEMW-instruktioner." #: config/i386/cygming.opt:23 -#, fuzzy -#| msgid "Create console application" msgid "Create console application." -msgstr "Skapa konsolapplikation" +msgstr "Skapa konsolapplikation." #: config/i386/cygming.opt:27 -#, fuzzy -#| msgid "Generate code for a DLL" msgid "Generate code for a DLL." -msgstr "Generera kod för en DLL" +msgstr "Generera kod för en DLL." #: config/i386/cygming.opt:31 -#, fuzzy -#| msgid "Ignore dllimport for functions" msgid "Ignore dllimport for functions." -msgstr "Ignorera dllimport för funktioner" +msgstr "Ignorera dllimport för funktioner." #: config/i386/cygming.opt:35 -#, fuzzy -#| msgid "Use Mingw-specific thread support" msgid "Use Mingw-specific thread support." -msgstr "Använd Mingw-specifikt trådstöd" +msgstr "Använd Mingw-specifikt trådstöd." #: config/i386/cygming.opt:39 -#, fuzzy -#| msgid "Set Windows defines" msgid "Set Windows defines." -msgstr "Sätt Windows-definitioner" +msgstr "Sätt Windows-definitioner." #: config/i386/cygming.opt:43 -#, fuzzy -#| msgid "Create GUI application" msgid "Create GUI application." -msgstr "Skapa GUI-applikation" +msgstr "Skapa GUI-applikation." #: config/i386/cygming.opt:47 config/i386/interix.opt:32 -#, fuzzy -#| msgid "Use the GNU extension to the PE format for aligned common data" msgid "Use the GNU extension to the PE format for aligned common data." -msgstr "Använd GNU-utvidgningarna för PE-formatet för justerade common-data" +msgstr "Använd GNU-utvidgningarna för PE-formatet för justerade common-data." #: config/i386/cygming.opt:51 -#, fuzzy -#| msgid "Compile code that relies on Cygwin DLL wrappers to support C++ operator new/delete replacement" msgid "Compile code that relies on Cygwin DLL wrappers to support C++ operator new/delete replacement." -msgstr "Kompilera kod som litar på Cygwin:s DLL-inkapsling för att stödja ersättning av C++-operatorerna new/delete" +msgstr "Kompilera kod som litar på Cygwin:s DLL-inkapsling för att stödja ersättning av C++-operatorerna new/delete." #: config/i386/cygming.opt:58 msgid "Put relocated read-only data into .data section." msgstr "Placera relokerad endast läsbar data i .data-sektionen." #: config/i386/mingw.opt:29 -#, fuzzy -#| msgid "Warn about none ISO msvcrt scanf/printf width extensions" msgid "Warn about none ISO msvcrt scanf/printf width extensions." -msgstr "Varna för msvcrt-breddutökningar av scanf/printf som inte följer ISO" +msgstr "Varna för msvcrt-breddutökningar av scanf/printf som inte följer ISO." #: config/i386/mingw.opt:33 msgid "For nested functions on stack executable permission is set." msgstr "För nästade funktioner på stacken sätts exekveringsrättigheter." #: config/i386/mingw-w64.opt:23 -#, fuzzy -#| msgid "Use unicode startup and define UNICODE macro" msgid "Use unicode startup and define UNICODE macro." -msgstr "Använd unicode-uppstart och definiera ett UNICODE-makro" +msgstr "Använd unicode-uppstart och definiera ett UNICODE-makro." #: config/i386/i386.opt:182 -#, fuzzy -#| msgid "sizeof(long double) is 16" msgid "sizeof(long double) is 16." -msgstr "sizeof(long double) är 16" +msgstr "sizeof(long double) är 16." # fixme: fp = flyttal, men hur skall man skriva det. Förkortat eller FPU? #: config/i386/i386.opt:186 config/i386/i386.opt:354 -#, fuzzy -#| msgid "Use hardware fp" msgid "Use hardware fp." -msgstr "Använd hårdvaru-fp" +msgstr "Använd hårdvaru-fp." #: config/i386/i386.opt:190 -#, fuzzy -#| msgid "sizeof(long double) is 12" msgid "sizeof(long double) is 12." -msgstr "sizeof(long double) är 12" +msgstr "sizeof(long double) är 12." #: config/i386/i386.opt:194 -#, fuzzy -#| msgid "Use 80-bit long double" msgid "Use 80-bit long double." -msgstr "Använd 80-bitars long double" +msgstr "Använd 80-bitars long double." #: config/i386/i386.opt:198 config/s390/s390.opt:130 #: config/sparc/long-double-switch.opt:27 config/alpha/alpha.opt:102 -#, fuzzy -#| msgid "Use 64-bit long double" msgid "Use 64-bit long double." -msgstr "Använd 64-bitars long double" +msgstr "Använd 64-bitars long double." #: config/i386/i386.opt:202 config/s390/s390.opt:126 #: config/sparc/long-double-switch.opt:23 config/alpha/alpha.opt:98 -#, fuzzy -#| msgid "Use 128-bit long double" msgid "Use 128-bit long double." -msgstr "Använd 128-bitars long double" +msgstr "Använd 128-bitars long double." #: config/i386/i386.opt:206 config/sh/sh.opt:209 -#, fuzzy -#| msgid "Reserve space for outgoing arguments in the function prologue" msgid "Reserve space for outgoing arguments in the function prologue." -msgstr "Reservera utrymmer för utgående argument i funktionsprologen" +msgstr "Reservera utrymmer för utgående argument i funktionsprologen." #: config/i386/i386.opt:210 -#, fuzzy -#| msgid "Align some doubles on dword boundary" msgid "Align some doubles on dword boundary." -msgstr "Justera några double på dword-gräns" +msgstr "Justera några double på dword-gräns." #: config/i386/i386.opt:214 -#, fuzzy -#| msgid "Function starts are aligned to this power of 2" msgid "Function starts are aligned to this power of 2." -msgstr "Funktionsbörjan justeras till denna 2-potens" +msgstr "Funktionsbörjan justeras till denna 2-potens." #: config/i386/i386.opt:218 -#, fuzzy -#| msgid "Jump targets are aligned to this power of 2" msgid "Jump targets are aligned to this power of 2." -msgstr "Hoppmål justeras till denna 2-potens" +msgstr "Hoppmål justeras till denna 2-potens." #: config/i386/i386.opt:222 -#, fuzzy -#| msgid "Loop code aligned to this power of 2" msgid "Loop code aligned to this power of 2." -msgstr "Loop-kod justeras till denna 2-potens" +msgstr "Loop-kod justeras till denna 2-potens." #: config/i386/i386.opt:226 -#, fuzzy -#| msgid "Align destination of the string operations" msgid "Align destination of the string operations." -msgstr "Justera målet för strängoperationerna" +msgstr "Justera målet för strängoperationerna." #: config/i386/i386.opt:230 -#, fuzzy -#| msgid "Use the given data alignment" msgid "Use the given data alignment." -msgstr "Använd den angivna datajusteringen" +msgstr "Använd den angivna datajusteringen." #: config/i386/i386.opt:234 msgid "Known data alignment choices (for use with the -malign-data= option):" msgstr "Kända val av datajustering (att användas med flaggan -malign-data=):" #: config/i386/i386.opt:251 -#, fuzzy -#| msgid "Use given assembler dialect" msgid "Use given assembler dialect." -msgstr "Använd angiven assemblerdialekt" +msgstr "Använd angiven assemblerdialekt." #: config/i386/i386.opt:255 msgid "Known assembler dialects (for use with the -masm-dialect= option):" msgstr "Kända assemblerdialekter (att användas med flaggan -masm-dialect=):" #: config/i386/i386.opt:265 -#, fuzzy -#| msgid "Branches are this expensive (1-5, arbitrary units)" msgid "Branches are this expensive (1-5, arbitrary units)." -msgstr "Hopp är så här dyra (1-5, godtyckliga enheter)" +msgstr "Hopp är så här dyra (1-5, godtyckliga enheter)." #: config/i386/i386.opt:269 -#, fuzzy -#| msgid "Data greater than given threshold will go into .ldata section in x86-64 medium model" msgid "Data greater than given threshold will go into .ldata section in x86-64 medium model." -msgstr "Data större än den angivna gränsen kommer hamna i .ldata-sektionen i x86-64 medelmodell" +msgstr "Data större än den angivna gränsen kommer hamna i .ldata-sektionen i x86-64 medelmodell." #: config/i386/i386.opt:273 -#, fuzzy -#| msgid "Use given x86-64 code model" msgid "Use given x86-64 code model." -msgstr "Använd angiven x86-64 kodmodell" +msgstr "Använd angiven x86-64 kodmodell." #: config/i386/i386.opt:277 config/rs6000/aix64.opt:36 #: config/rs6000/linux64.opt:32 config/tilegx/tilegx.opt:57 @@ -10190,10 +8711,8 @@ msgid "Known code models (for use with the -mcmodel= option):" msgstr "Kända kodmodeller (att användas med flaggan -mcmodel=):" #: config/i386/i386.opt:296 -#, fuzzy -#| msgid "Use given address mode" msgid "Use given address mode." -msgstr "Använd angivet adressläge" +msgstr "Använd angivet adressläge." #: config/i386/i386.opt:300 msgid "Known address mode (for use with the -maddress-mode= option):" @@ -10204,214 +8723,153 @@ msgid "%<-mcpu=%> is deprecated; use %<-mtune=%> or %<-march=%> instead" msgstr "%<-mcpu=%> bör undvikas. Använd %<-mtune=%> eller %<-march=%> istället." #: config/i386/i386.opt:313 -#, fuzzy -#| msgid "Generate sin, cos, sqrt for FPU" msgid "Generate sin, cos, sqrt for FPU." -msgstr "Generera sin, cos, sqrt för FPU" +msgstr "Generera sin, cos, sqrt för FPU." #: config/i386/i386.opt:317 -#, fuzzy -#| msgid "Always use Dynamic Realigned Argument Pointer (DRAP) to realign stack" msgid "Always use Dynamic Realigned Argument Pointer (DRAP) to realign stack." -msgstr "Använd alltid Dynamic Realigned Argument Pointer (DRAP) för att justera stacken" +msgstr "Använd alltid Dynamic Realigned Argument Pointer (DRAP) för att justera stacken." #: config/i386/i386.opt:321 -#, fuzzy -#| msgid "Return values of functions in FPU registers" msgid "Return values of functions in FPU registers." -msgstr "Returnera värden från funktioner i FPU-register" +msgstr "Returnera värden från funktioner i FPU-register." #: config/i386/i386.opt:325 -#, fuzzy -#| msgid "Generate floating point mathematics using given instruction set" msgid "Generate floating point mathematics using given instruction set." -msgstr "Generera flyttalsmatematik med den angivna instruktionsuppsättningen" +msgstr "Generera flyttalsmatematik med den angivna instruktionsuppsättningen." #: config/i386/i386.opt:329 msgid "Valid arguments to -mfpmath=:" msgstr "Giltiga argument till -mfpmath=:" #: config/i386/i386.opt:362 -#, fuzzy -#| msgid "Inline all known string operations" msgid "Inline all known string operations." -msgstr "Inline:a alla kända strängoperationer" +msgstr "Inline:a alla kända strängoperationer." #: config/i386/i386.opt:366 -#, fuzzy -#| msgid "Inline memset/memcpy string operations, but perform inline version only for small blocks" msgid "Inline memset/memcpy string operations, but perform inline version only for small blocks." -msgstr "Inline:a memset/memcpy-strängoperationer, men använd inline-versionen endast för små block" +msgstr "Inline:a memset/memcpy-strängoperationer, men använd inline-versionen endast för små block." #: config/i386/i386.opt:369 msgid "%<-mintel-syntax%> and %<-mno-intel-syntax%> are deprecated; use %<-masm=intel%> and %<-masm=att%> instead" msgstr "%<-mintel-syntax%> och %<-mno-intel-syntax%> bör undvikas. Använd %<-masm=intel%> och %<-masm=att%> istället" #: config/i386/i386.opt:374 -#, fuzzy -#| msgid "Use native (MS) bitfield layout" msgid "Use native (MS) bitfield layout." -msgstr "Använd inbyggd (MS) bitfältslayout" +msgstr "Använd inbyggd (MS) bitfältslayout." #: config/i386/i386.opt:394 -#, fuzzy -#| msgid "Set 80387 floating-point precision to 32-bit" msgid "Set 80387 floating-point precision to 32-bit." -msgstr "Ange flyttalsprecision för 80387 till 32-bits" +msgstr "Ange flyttalsprecision för 80387 till 32-bits." #: config/i386/i386.opt:398 -#, fuzzy -#| msgid "Set 80387 floating-point precision to 64-bit" msgid "Set 80387 floating-point precision to 64-bit." -msgstr "Ange flyttalsprecision för 80387 till 64-bits" +msgstr "Ange flyttalsprecision för 80387 till 64-bits." #: config/i386/i386.opt:402 -#, fuzzy -#| msgid "Set 80387 floating-point precision to 80-bit" msgid "Set 80387 floating-point precision to 80-bit." -msgstr "Ange flyttalsprecision för 80387 till 80-bits" +msgstr "Ange flyttalsprecision för 80387 till 80-bits." #: config/i386/i386.opt:406 -#, fuzzy -#| msgid "Attempt to keep stack aligned to this power of 2" msgid "Attempt to keep stack aligned to this power of 2." -msgstr "Försök håll stacken justerad till denna 2-potens" +msgstr "Försök håll stacken justerad till denna 2-potens." #: config/i386/i386.opt:410 -#, fuzzy -#| msgid "Assume incoming stack aligned to this power of 2" msgid "Assume incoming stack aligned to this power of 2." -msgstr "Anta att inkommande stack är justerad till denna 2-potens" +msgstr "Anta att inkommande stack är justerad till denna 2-potens." #: config/i386/i386.opt:414 -#, fuzzy -#| msgid "Use push instructions to save outgoing arguments" msgid "Use push instructions to save outgoing arguments." -msgstr "Använd push-instruktioner för att spara utgående argument" +msgstr "Använd push-instruktioner för att spara utgående argument." #: config/i386/i386.opt:418 -#, fuzzy -#| msgid "Use red-zone in the x86-64 code" msgid "Use red-zone in the x86-64 code." -msgstr "Använd röd zon i x86-64-koden" +msgstr "Använd röd zon i x86-64-koden." #: config/i386/i386.opt:422 -#, fuzzy -#| msgid "Number of registers used to pass integer arguments" msgid "Number of registers used to pass integer arguments." -msgstr "Antal register för att skicka heltalsargument" +msgstr "Antal register för att skicka heltalsargument." #: config/i386/i386.opt:426 -#, fuzzy -#| msgid "Alternate calling convention" msgid "Alternate calling convention." -msgstr "Alternativ anropskonvention" +msgstr "Alternativ anropskonvention." #: config/i386/i386.opt:430 config/alpha/alpha.opt:23 -#, fuzzy -#| msgid "Do not use hardware fp" msgid "Do not use hardware fp." -msgstr "Använd inte hårdvaru-fp" +msgstr "Använd inte hårdvaru-fp." #: config/i386/i386.opt:434 -#, fuzzy -#| msgid "Use SSE register passing conventions for SF and DF mode" msgid "Use SSE register passing conventions for SF and DF mode." -msgstr "Använd konventioner för att skicka SSE-register i SF- och DF-läge" +msgstr "Använd konventioner för att skicka SSE-register i SF- och DF-läge." #: config/i386/i386.opt:438 -#, fuzzy -#| msgid "Realign stack in prologue" msgid "Realign stack in prologue." -msgstr "Justera om stacken i prologen" +msgstr "Justera om stacken i prologen." #: config/i386/i386.opt:442 -#, fuzzy -#| msgid "Enable stack probing" msgid "Enable stack probing." -msgstr "Aktivera stackavkänning" +msgstr "Aktivera stackavkänning." #: config/i386/i386.opt:446 -#, fuzzy -#| msgid "Specify memcpy expansion strategy when expected size is known" msgid "Specify memcpy expansion strategy when expected size is known." -msgstr "Ange strategi för expansion av memcpy när den förväntade storleken är känd" +msgstr "Ange strategi för expansion av memcpy när den förväntade storleken är känd." #: config/i386/i386.opt:450 -#, fuzzy -#| msgid "Specify memset expansion strategy when expected size is known" msgid "Specify memset expansion strategy when expected size is known." -msgstr "Ange strategi för expansion av memset när den förväntade storleken är känd" +msgstr "Ange strategi för expansion av memset när den förväntade storleken är känd." #: config/i386/i386.opt:454 -#, fuzzy -#| msgid "Chose strategy to generate stringop using" msgid "Chose strategy to generate stringop using." -msgstr "Välj strategi för att generera stringop med" +msgstr "Välj strategi för att generera stringop med." #: config/i386/i386.opt:458 msgid "Valid arguments to -mstringop-strategy=:" msgstr "Giltiga argument till -mstringop-strategy=:" #: config/i386/i386.opt:486 -#, fuzzy -#| msgid "Use given thread-local storage dialect" msgid "Use given thread-local storage dialect." -msgstr "Använd angiven trådlokal lagringsdialekt" +msgstr "Använd angiven trådlokal lagringsdialekt." #: config/i386/i386.opt:490 msgid "Known TLS dialects (for use with the -mtls-dialect= option):" msgstr "Kända TLS-dialekter (att användas med flaggan -mtls-dialect=):" #: config/i386/i386.opt:500 -#, fuzzy, c-format -#| msgid "Use direct references against %gs when accessing tls data" +#, c-format msgid "Use direct references against %gs when accessing tls data." -msgstr "Använd direkta referenser mot %gs vid åtkomst av tls-data" +msgstr "Använd direkta referenser mot %gs vid åtkomst av tls-data." #: config/i386/i386.opt:508 -#, fuzzy -#| msgid "Fine grain control of tune features" msgid "Fine grain control of tune features." -msgstr "Finkornig styrning av trimningsfunktioner" +msgstr "Finkornig styrning av trimningsfunktioner." #: config/i386/i386.opt:512 -#, fuzzy -#| msgid "Clear all tune features" msgid "Clear all tune features." -msgstr "Nollställ alla trimningsfunktioner" +msgstr "Nollställ alla trimningsfunktioner." #: config/i386/i386.opt:519 -#, fuzzy -#| msgid "Generate code that conforms to the given ABI" msgid "Generate code that conforms to Intel MCU psABI." -msgstr "Generera kod som följer det angivna ABI:et" +msgstr "Generera kod som följer Intel MCU psABI." #: config/i386/i386.opt:523 -#, fuzzy -#| msgid "Generate code that conforms to the given ABI" msgid "Generate code that conforms to the given ABI." -msgstr "Generera kod som följer det angivna ABI:et" +msgstr "Generera kod som följer det angivna ABI:et." #: config/i386/i386.opt:527 msgid "Known ABIs (for use with the -mabi= option):" msgstr "Kända ABI:er (att användas med flaggan -mabi=):" #: config/i386/i386.opt:537 config/rs6000/rs6000.opt:189 -#, fuzzy -#| msgid "Vector library ABI to use" msgid "Vector library ABI to use." -msgstr "Vektorbiblioteks-ABI att använda" +msgstr "Vektorbiblioteks-ABI att använda." #: config/i386/i386.opt:541 msgid "Known vectorization library ABIs (for use with the -mveclibabi= option):" msgstr "Kända ABI:er till vektoriseringsbibliotek (att användas med flaggan -mveclibabi=):" #: config/i386/i386.opt:551 -#, fuzzy -#| msgid "Return 8-byte vectors in memory" msgid "Return 8-byte vectors in memory." -msgstr "Returnera 8-bytesvektorer i minnet" +msgstr "Returnera 8-bytesvektorer i minnet." #: config/i386/i386.opt:555 msgid "Generate reciprocals instead of divss and sqrtss." @@ -10436,198 +8894,136 @@ msgid "Disable Scalar to Vector optimization pass transforming 64-bit integer" msgstr "Avaktivera transformering av 64-bitar heltal i optimeringspasset skalär till vektor" #: config/i386/i386.opt:577 -#, fuzzy -#| msgid "Do dispatch scheduling if processor is bdver1 or bdver2 or bdver3 or bdver4 and Haifa scheduling" msgid "Do dispatch scheduling if processor is bdver1, bdver2, bdver3, bdver4" -msgstr "Gör sändningsschemaläggning om processorn är bdver1 eller bdver2 eller bdver3 eller bdver4 och Haifa-schemaläggning" +msgstr "Gör sändningsschemaläggning om processorn är bdver1, bdver2, bdver3, bdver4" #: config/i386/i386.opt:582 msgid "Use 128-bit AVX instructions instead of 256-bit AVX instructions in the auto-vectorizer." msgstr "Använd 128-bitars AVX-instruktioner istället för 256-bitars AVX-instruktioner i automatvektoriseraren." #: config/i386/i386.opt:588 -#, fuzzy -#| msgid "Generate 32bit i386 code" msgid "Generate 32bit i386 code." -msgstr "Generera 32-bitars i386-kod" +msgstr "Generera 32-bitars i386-kod." #: config/i386/i386.opt:592 -#, fuzzy -#| msgid "Generate 64bit x86-64 code" msgid "Generate 64bit x86-64 code." -msgstr "Generera 64-bitars x86-64-kod" +msgstr "Generera 64-bitars x86-64-kod." #: config/i386/i386.opt:596 -#, fuzzy -#| msgid "Generate 32bit x86-64 code" msgid "Generate 32bit x86-64 code." -msgstr "Generera 32-bitars x86-64-kod" +msgstr "Generera 32-bitars x86-64-kod." #: config/i386/i386.opt:600 -#, fuzzy -#| msgid "Generate 16bit i386 code" msgid "Generate 16bit i386 code." -msgstr "Generera 16-bitars i386-kod" +msgstr "Generera 16-bitars i386-kod." #: config/i386/i386.opt:604 -#, fuzzy -#| msgid "Support MMX built-in functions" msgid "Support MMX built-in functions." -msgstr "Stöd inbyggda MMX-funktioner" +msgstr "Stöd inbyggda MMX-funktioner." #: config/i386/i386.opt:608 -#, fuzzy -#| msgid "Support 3DNow! built-in functions" msgid "Support 3DNow! built-in functions." -msgstr "Stöd inbyggda 3DNow!-funktioner" +msgstr "Stöd inbyggda 3DNow!-funktioner." #: config/i386/i386.opt:612 -#, fuzzy -#| msgid "Support Athlon 3Dnow! built-in functions" msgid "Support Athlon 3Dnow! built-in functions." -msgstr "Stöd inbyggda Athlon 3Dnow!-funktioner" +msgstr "Stöd inbyggda Athlon 3Dnow!-funktioner." #: config/i386/i386.opt:616 -#, fuzzy -#| msgid "Support MMX and SSE built-in functions and code generation" msgid "Support MMX and SSE built-in functions and code generation." -msgstr "Stöd inbyggda MMX- och SSE-funktioner och -kodgenerering" +msgstr "Stöd inbyggda MMX- och SSE-funktioner och -kodgenerering." #: config/i386/i386.opt:620 -#, fuzzy -#| msgid "Support MMX, SSE and SSE2 built-in functions and code generation" msgid "Support MMX, SSE and SSE2 built-in functions and code generation." -msgstr "Stöd inbyggda MMX-, SSE- och SSE2-funktioner och -kodgenerering" +msgstr "Stöd inbyggda MMX-, SSE- och SSE2-funktioner och -kodgenerering." #: config/i386/i386.opt:624 -#, fuzzy -#| msgid "Support MMX, SSE, SSE2 and SSE3 built-in functions and code generation" msgid "Support MMX, SSE, SSE2 and SSE3 built-in functions and code generation." -msgstr "Stöd inbyggda MMX-, SSE-, SSE2- och SSE3-funktioner och -kodgenerering" +msgstr "Stöd inbyggda MMX-, SSE-, SSE2- och SSE3-funktioner och -kodgenerering." #: config/i386/i386.opt:628 -#, fuzzy -#| msgid "Support MMX, SSE, SSE2, SSE3 and SSSE3 built-in functions and code generation" msgid "Support MMX, SSE, SSE2, SSE3 and SSSE3 built-in functions and code generation." -msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3- och SSSE3-funktioner och -kodgenerering" +msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3- och SSSE3-funktioner och -kodgenerering." #: config/i386/i386.opt:632 -#, fuzzy -#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3 and SSE4.1 built-in functions and code generation" msgid "Support MMX, SSE, SSE2, SSE3, SSSE3 and SSE4.1 built-in functions and code generation." -msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3- och SSE4.1-funktioner och -kodgenerering" +msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3- och SSE4.1-funktioner och -kodgenerering." #: config/i386/i386.opt:636 config/i386/i386.opt:640 -#, fuzzy -#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1 and SSE4.2 built-in functions and code generation" msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1 and SSE4.2 built-in functions and code generation." -msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1- och SSE4.2-funktioner och -kodgenerering" +msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1- och SSE4.2-funktioner och -kodgenerering." #: config/i386/i386.opt:644 -#, fuzzy -#| msgid "Do not support SSE4.1 and SSE4.2 built-in functions and code generation" msgid "Do not support SSE4.1 and SSE4.2 built-in functions and code generation." -msgstr "Stöd inte inbyggda SSE4.1- och SSE4.2-funktioner och -kodgenerering" +msgstr "Stöd inte inbyggda SSE4.1- och SSE4.2-funktioner och -kodgenerering." #: config/i386/i386.opt:647 msgid "%<-msse5%> was removed" msgstr "%<-msse5%> togs bort" #: config/i386/i386.opt:652 -#, fuzzy -#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2 and AVX built-in functions and code generation" msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2 and AVX built-in functions and code generation." -msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2- och AVX-funktioner och -kodgenerering" +msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2- och AVX-funktioner och -kodgenerering." #: config/i386/i386.opt:656 -#, fuzzy -#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and AVX2 built-in functions and code generation" msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and AVX2 built-in functions and code generation." -msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX- och AVX2-funktioner och -kodgenerering" +msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX- och AVX2-funktioner och -kodgenerering." #: config/i386/i386.opt:660 -#, fuzzy -#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F built-in functions and code generation" msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F built-in functions and code generation." -msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX-, AVX2- och AVX512F-funktioner och -kodgenerering" +msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX-, AVX2- och AVX512F-funktioner och -kodgenerering." #: config/i386/i386.opt:664 -#, fuzzy -#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512PF built-in functions and code generation" msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512PF built-in functions and code generation." -msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX-, AVX2- och AVX512F- och AVX512PF-funktioner och -kodgenerering" +msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX-, AVX2- och AVX512F- och AVX512PF-funktioner och -kodgenerering." #: config/i386/i386.opt:668 -#, fuzzy -#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512ER built-in functions and code generation" msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512ER built-in functions and code generation." -msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX-, AVX2- och AVX512F- och AVX512ER-funktioner och -kodgenerering" +msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX-, AVX2- och AVX512F- och AVX512ER-funktioner och -kodgenerering." #: config/i386/i386.opt:672 -#, fuzzy -#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512CD built-in functions and code generation" msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512CD built-in functions and code generation." -msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX-, AVX2- och AVX512F- och AVX512CD-funktioner och -kodgenerering" +msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX-, AVX2- och AVX512F- och AVX512CD-funktioner och -kodgenerering." #: config/i386/i386.opt:676 -#, fuzzy -#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512DQ built-in functions and code generation" msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512DQ built-in functions and code generation." -msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX-, AVX2- och AVX512F- och AVX512DQ-funktioner och -kodgenerering" +msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX-, AVX2- och AVX512F- och AVX512DQ-funktioner och -kodgenerering." #: config/i386/i386.opt:680 -#, fuzzy -#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512BW built-in functions and code generation" msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512BW built-in functions and code generation." -msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX-, AVX2- och AVX512F- och AVX512BW-funktioner och -kodgenerering" +msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX-, AVX2- och AVX512F- och AVX512BW-funktioner och -kodgenerering." #: config/i386/i386.opt:684 -#, fuzzy -#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512VL built-in functions and code generation" msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512VL built-in functions and code generation." -msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX-, AVX2- och AVX512F- och AVX512VL-funktioner och -kodgenerering" +msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX-, AVX2- och AVX512F- och AVX512VL-funktioner och -kodgenerering." #: config/i386/i386.opt:688 -#, fuzzy -#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512IFMA built-in functions and code generation" msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512IFMA built-in functions and code generation." -msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX-, AVX2- och AVX512F- och AVX512IFMA-funktioner och -kodgenerering" +msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX-, AVX2- och AVX512F- och AVX512IFMA-funktioner och -kodgenerering." #: config/i386/i386.opt:692 -#, fuzzy -#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512VBMI built-in functions and code generation" msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512VBMI built-in functions and code generation." -msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX-, AVX2- och AVX512F- och AVX512VBMI-funktioner och -kodgenerering" +msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX-, AVX2- och AVX512F- och AVX512VBMI-funktioner och -kodgenerering." #: config/i386/i386.opt:696 -#, fuzzy -#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and FMA built-in functions and code generation" msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and FMA built-in functions and code generation." -msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX- och FMA-funktioner och -kodgenerering" +msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3-, SSSE3-, SSE4.1-, SSE4.2-, AVX- och FMA-funktioner och -kodgenerering." #: config/i386/i386.opt:700 -#, fuzzy -#| msgid "Support MMX, SSE, SSE2, SSE3 and SSE4A built-in functions and code generation" msgid "Support MMX, SSE, SSE2, SSE3 and SSE4A built-in functions and code generation." -msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3- och SSE4A-funktioner och -kodgenerering" +msgstr "Stöd inbyggda MMX-, SSE-, SSE2-, SSE3- och SSE4A-funktioner och -kodgenerering." #: config/i386/i386.opt:704 -#, fuzzy -#| msgid "Support FMA4 built-in functions and code generation " msgid "Support FMA4 built-in functions and code generation." -msgstr "Stöd inbyggda FMA4-funktioner och -kodgenerering " +msgstr "Stöd inbyggda FMA4-funktioner och -kodgenerering." #: config/i386/i386.opt:708 -#, fuzzy -#| msgid "Support XOP built-in functions and code generation " msgid "Support XOP built-in functions and code generation." -msgstr "Stöd inbyggda XOP-funktioner och -kodgenerering " +msgstr "Stöd inbyggda XOP-funktioner och -kodgenerering." #: config/i386/i386.opt:712 -#, fuzzy -#| msgid "Support LWP built-in functions and code generation " msgid "Support LWP built-in functions and code generation." -msgstr "Stöd inbyggda LWP-funktioner och -kodgenerering " +msgstr "Stöd inbyggda LWP-funktioner och -kodgenerering." #: config/i386/i386.opt:716 msgid "Support code generation of Advanced Bit Manipulation (ABM) instructions." @@ -10638,100 +9034,68 @@ msgid "Support code generation of popcnt instruction." msgstr "Stöd kodgenerering av popcnt-instruktioner." #: config/i386/i386.opt:724 -#, fuzzy -#| msgid "Support BMI built-in functions and code generation" msgid "Support BMI built-in functions and code generation." -msgstr "Stöd inbyggda BMI-funktioner och -kodgenerering " +msgstr "Stöd inbyggda BMI-funktioner och -kodgenerering ." #: config/i386/i386.opt:728 -#, fuzzy -#| msgid "Support BMI2 built-in functions and code generation" msgid "Support BMI2 built-in functions and code generation." -msgstr "Stöd inbyggda BMI2-funktioner och -kodgenerering " +msgstr "Stöd inbyggda BMI2-funktioner och -kodgenerering ." #: config/i386/i386.opt:732 -#, fuzzy -#| msgid "Support LZCNT built-in function and code generation" msgid "Support LZCNT built-in function and code generation." -msgstr "Stöd inbyggda LZCNT-funktioner och -kodgenerering " +msgstr "Stöd inbyggda LZCNT-funktioner och -kodgenerering ." #: config/i386/i386.opt:736 -#, fuzzy -#| msgid "Support Hardware Lock Elision prefixes" msgid "Support Hardware Lock Elision prefixes." -msgstr "Stöd prefix får hårdvarulåselidering" +msgstr "Stöd prefix får hårdvarulåselidering." #: config/i386/i386.opt:740 -#, fuzzy -#| msgid "Support RDSEED instruction" msgid "Support RDSEED instruction." -msgstr "Använd instruktionen RDSEED" +msgstr "Använd instruktionen RDSEED." #: config/i386/i386.opt:744 -#, fuzzy -#| msgid "Support PREFETCHW instruction" msgid "Support PREFETCHW instruction." -msgstr "Stöd instruktionen PREFETCHW" +msgstr "Stöd instruktionen PREFETCHW." #: config/i386/i386.opt:748 -#, fuzzy -#| msgid "Support flag-preserving add-carry instructions" msgid "Support flag-preserving add-carry instructions." -msgstr "Stöd flaggbevarande add-carry-instruktioner" +msgstr "Stöd flaggbevarande add-carry-instruktioner." #: config/i386/i386.opt:752 -#, fuzzy -#| msgid "Support CLFLUSHOPT instructions" msgid "Support CLFLUSHOPT instructions." -msgstr "Stöd instruktionerna CLFLUSHOPT" +msgstr "Stöd instruktionerna CLFLUSHOPT." #: config/i386/i386.opt:756 -#, fuzzy -#| msgid "Support CLWB instruction" msgid "Support CLWB instruction." -msgstr "Stöd instruktionen CLWB" +msgstr "Stöd instruktionen CLWB." #: config/i386/i386.opt:760 -#, fuzzy -#| msgid "Support PCOMMIT instruction" msgid "Support PCOMMIT instruction." -msgstr "Stöd instruktionen PCOMMIT" +msgstr "Stöd instruktionen PCOMMIT." #: config/i386/i386.opt:764 -#, fuzzy -#| msgid "Support FXSAVE and FXRSTOR instructions" msgid "Support FXSAVE and FXRSTOR instructions." -msgstr "Stöd instruktionerna FXSAVE och FXRSTOR" +msgstr "Stöd instruktionerna FXSAVE och FXRSTOR." #: config/i386/i386.opt:768 -#, fuzzy -#| msgid "Support XSAVE and XRSTOR instructions" msgid "Support XSAVE and XRSTOR instructions." -msgstr "Stöd instruktionerna XSAVE och XRSTOR" +msgstr "Stöd instruktionerna XSAVE och XRSTOR." #: config/i386/i386.opt:772 -#, fuzzy -#| msgid "Support XSAVEOPT instruction" msgid "Support XSAVEOPT instruction." -msgstr "Stöd instruktionen XSAVEOPT" +msgstr "Stöd instruktionen XSAVEOPT." #: config/i386/i386.opt:776 -#, fuzzy -#| msgid "Support XSAVEC instructions" msgid "Support XSAVEC instructions." -msgstr "Stöd instruktionerna XSAVEC" +msgstr "Stöd instruktionerna XSAVEC." #: config/i386/i386.opt:780 -#, fuzzy -#| msgid "Support XSAVES and XRSTORS instructions" msgid "Support XSAVES and XRSTORS instructions." -msgstr "Stöd instruktionerna XSAVES och XRSTORS" +msgstr "Stöd instruktionerna XSAVES och XRSTORS." #: config/i386/i386.opt:784 -#, fuzzy -#| msgid "Support TBM built-in functions and code generation" msgid "Support TBM built-in functions and code generation." -msgstr "Stöd inbyggda TBM-funktioner och -kodgenerering " +msgstr "Stöd inbyggda TBM-funktioner och -kodgenerering ." #: config/i386/i386.opt:788 msgid "Support code generation of cmpxchg16b instruction." @@ -10750,52 +9114,36 @@ msgid "Support code generation of crc32 instruction." msgstr "Stöd kodgenerering av crc32-instruktioner." #: config/i386/i386.opt:804 -#, fuzzy -#| msgid "Support AES built-in functions and code generation" msgid "Support AES built-in functions and code generation." -msgstr "Stöd inbyggda AES-funktioner och -kodgenerering" +msgstr "Stöd inbyggda AES-funktioner och -kodgenerering." #: config/i386/i386.opt:808 -#, fuzzy -#| msgid "Support SHA1 and SHA256 built-in functions and code generation" msgid "Support SHA1 and SHA256 built-in functions and code generation." -msgstr "Stöd inbyggda SHA1- och SHA256-funktioner och -kodgenerering" +msgstr "Stöd inbyggda SHA1- och SHA256-funktioner och -kodgenerering." #: config/i386/i386.opt:812 -#, fuzzy -#| msgid "Support PCLMUL built-in functions and code generation" msgid "Support PCLMUL built-in functions and code generation." -msgstr "Stöd inbyggda PCLMUL-funktioner och -kodgenerering" +msgstr "Stöd inbyggda PCLMUL-funktioner och -kodgenerering." #: config/i386/i386.opt:816 -#, fuzzy -#| msgid "Encode SSE instructions with VEX prefix" msgid "Encode SSE instructions with VEX prefix." -msgstr "Koda SSE-instruktioner med VEX-prefix" +msgstr "Koda SSE-instruktioner med VEX-prefix." #: config/i386/i386.opt:820 -#, fuzzy -#| msgid "Support FSGSBASE built-in functions and code generation" msgid "Support FSGSBASE built-in functions and code generation." -msgstr "Stöd inbyggda FSGSBASE-funktioner och -kodgenerering" +msgstr "Stöd inbyggda FSGSBASE-funktioner och -kodgenerering." #: config/i386/i386.opt:824 -#, fuzzy -#| msgid "Support RDRND built-in functions and code generation" msgid "Support RDRND built-in functions and code generation." -msgstr "Stöd inbyggda RDRND-funktioner och -kodgenerering" +msgstr "Stöd inbyggda RDRND-funktioner och -kodgenerering." #: config/i386/i386.opt:828 -#, fuzzy -#| msgid "Support F16C built-in functions and code generation" msgid "Support F16C built-in functions and code generation." -msgstr "Stöd inbyggda F16C-funktioner och -kodgenerering " +msgstr "Stöd inbyggda F16C-funktioner och -kodgenerering ." #: config/i386/i386.opt:832 -#, fuzzy -#| msgid "Support PREFETCHWT1 built-in functions and code generation" msgid "Support PREFETCHWT1 built-in functions and code generation." -msgstr "Stöd inbyggda PREFETCHWT1-funktioner och -kodgenerering " +msgstr "Stöd inbyggda PREFETCHWT1-funktioner och -kodgenerering ." #: config/i386/i386.opt:836 msgid "Emit profiling counter call at function entry before prologue." @@ -10814,58 +9162,40 @@ msgid "Skip setting up RAX register when passing variable arguments." msgstr "Hoppa över att sätta upp RAX-register när variabelt antal argument skickas." #: config/i386/i386.opt:853 -#, fuzzy -#| msgid "Expand 32bit/64bit integer divide into 8bit unsigned integer divide with run-time check" msgid "Expand 32bit/64bit integer divide into 8bit unsigned integer divide with run-time check." -msgstr "Expandera 32bits/64bits heltalsdivision till 8bitars teckenlös heltalsdivision med kontroll vid körning." +msgstr "Expandera 32bits/64bits heltalsdivision till 8bitars teckenlös heltalsdivision med kontroll vid körning.." #: config/i386/i386.opt:857 -#, fuzzy -#| msgid "Split 32-byte AVX unaligned load" msgid "Split 32-byte AVX unaligned load." -msgstr "Dela 32-bytes AVX ojusterade laddningar" +msgstr "Dela 32-bytes AVX ojusterade laddningar." #: config/i386/i386.opt:861 -#, fuzzy -#| msgid "Split 32-byte AVX unaligned store" msgid "Split 32-byte AVX unaligned store." -msgstr "Dela 32-bytes AVX ojusterade lagringar" +msgstr "Dela 32-bytes AVX ojusterade lagringar." #: config/i386/i386.opt:865 -#, fuzzy -#| msgid "Support RTM built-in functions and code generation" msgid "Support RTM built-in functions and code generation." -msgstr "Stöd inbyggda RTM-funktioner och -kodgenerering " +msgstr "Stöd inbyggda RTM-funktioner och -kodgenerering ." #: config/i386/i386.opt:869 -#, fuzzy -#| msgid "Support MPX code generation" msgid "Support MPX code generation." -msgstr "Stöd MPX-kodgenerering " +msgstr "Stöd MPX-kodgenerering ." #: config/i386/i386.opt:873 -#, fuzzy -#| msgid "Support MWAITX and MONITORX built-in functions and code generation" msgid "Support MWAITX and MONITORX built-in functions and code generation." -msgstr "Stöd inbyggda MWAITX- och MONITORX-funktioner och -kodgenerering" +msgstr "Stöd inbyggda MWAITX- och MONITORX-funktioner och -kodgenerering." #: config/i386/i386.opt:877 -#, fuzzy -#| msgid "Support AES built-in functions and code generation" msgid "Support CLZERO built-in functions and code generation." -msgstr "Stöd inbyggda AES-funktioner och -kodgenerering" +msgstr "Stöd inbyggda CLZERO-funktioner och -kodgenerering." #: config/i386/i386.opt:881 -#, fuzzy -#| msgid "Support PCLMUL built-in functions and code generation" msgid "Support PKU built-in functions and code generation." -msgstr "Stöd inbyggda PCLMUL-funktioner och -kodgenerering" +msgstr "Stöd inbyggda PKU-funktioner och -kodgenerering." #: config/i386/i386.opt:885 -#, fuzzy -#| msgid "Use given stack-protector guard" msgid "Use given stack-protector guard." -msgstr "Använd angiven stackskyddsvakt" +msgstr "Använd angiven stackskyddsvakt." #: config/i386/i386.opt:889 msgid "Known stack protector guard (for use with the -mstack-protector-guard= option):" @@ -10888,335 +9218,225 @@ msgid "see . */" msgstr "se . */" #: config/pa/pa64-hpux.opt:23 -#, fuzzy -#| msgid "Assume code will be linked by GNU ld" msgid "Assume code will be linked by GNU ld." -msgstr "Anta kod kommer länkas av GNU ld" +msgstr "Anta kod kommer länkas av GNU ld." #: config/pa/pa64-hpux.opt:27 -#, fuzzy -#| msgid "Assume code will be linked by HP ld" msgid "Assume code will be linked by HP ld." -msgstr "Anta kod kommer länkas av HP ld" +msgstr "Anta kod kommer länkas av HP ld." #: config/pa/pa-hpux1010.opt:23 config/pa/pa-hpux.opt:31 #: config/pa/pa-hpux1131.opt:23 config/pa/pa-hpux1111.opt:23 -#, fuzzy -#| msgid "Specify UNIX standard for predefines and linking" msgid "Specify UNIX standard for predefines and linking." -msgstr "Ange UNIX-standard för fördefinitioner och länkning" +msgstr "Ange UNIX-standard för fördefinitioner och länkning." #: config/pa/pa-hpux.opt:27 -#, fuzzy -#| msgid "Generate cpp defines for server IO" msgid "Generate cpp defines for server IO." -msgstr "Generera cpp-definitioner för server-IO" +msgstr "Generera cpp-definitioner för server-IO." #: config/pa/pa-hpux.opt:35 -#, fuzzy -#| msgid "Generate cpp defines for workstation IO" msgid "Generate cpp defines for workstation IO." -msgstr "Generera cpp-definitioner för arbetsstations-IO" +msgstr "Generera cpp-definitioner för arbetsstations-IO." #: config/pa/pa.opt:30 config/pa/pa.opt:83 config/pa/pa.opt:91 -#, fuzzy -#| msgid "Generate PA1.0 code" msgid "Generate PA1.0 code." -msgstr "Generera PA1.0-kod" +msgstr "Generera PA1.0-kod." #: config/pa/pa.opt:34 config/pa/pa.opt:95 config/pa/pa.opt:136 -#, fuzzy -#| msgid "Generate PA1.1 code" msgid "Generate PA1.1 code." -msgstr "Generera PA1.1-kod" +msgstr "Generera PA1.1-kod." #: config/pa/pa.opt:38 config/pa/pa.opt:99 -#, fuzzy -#| msgid "Generate PA2.0 code (requires binutils 2.10 or later)" msgid "Generate PA2.0 code (requires binutils 2.10 or later)." -msgstr "Generera kod för PA2.0 (kräver binutils 2.10 eller senare)" +msgstr "Generera kod för PA2.0 (kräver binutils 2.10 eller senare)." #: config/pa/pa.opt:46 -#, fuzzy -#| msgid "Disable FP regs" msgid "Disable FP regs." -msgstr "Avaktivera FP-register" +msgstr "Avaktivera FP-register." #: config/pa/pa.opt:50 -#, fuzzy -#| msgid "Disable indexed addressing" msgid "Disable indexed addressing." -msgstr "Avaktivera indexerad adressering" +msgstr "Avaktivera indexerad adressering." #: config/pa/pa.opt:54 -#, fuzzy -#| msgid "Generate fast indirect calls" msgid "Generate fast indirect calls." -msgstr "Generera snabba indirekta anrop" +msgstr "Generera snabba indirekta anrop." #: config/pa/pa.opt:62 -#, fuzzy -#| msgid "Assume code will be assembled by GAS" msgid "Assume code will be assembled by GAS." -msgstr "Anta att kod kommer assembleras av GAS" +msgstr "Anta att kod kommer assembleras av GAS." #: config/pa/pa.opt:71 -#, fuzzy -#| msgid "Enable linker optimizations" msgid "Enable linker optimizations." -msgstr "Aktivera länkningsoptimeringar" +msgstr "Aktivera länkningsoptimeringar." #: config/pa/pa.opt:75 -#, fuzzy -#| msgid "Always generate long calls" msgid "Always generate long calls." -msgstr "Generera alltid långa anrop" +msgstr "Generera alltid långa anrop." #: config/pa/pa.opt:79 -#, fuzzy -#| msgid "Emit long load/store sequences" msgid "Emit long load/store sequences." -msgstr "Mata ut långa load-/store-sekvenser" +msgstr "Mata ut långa ladda/lagra-sekvenser." #: config/pa/pa.opt:87 -#, fuzzy -#| msgid "Disable space regs" msgid "Disable space regs." -msgstr "Avaktivera utrymmesregister" +msgstr "Avaktivera utrymmesregister." #: config/pa/pa.opt:103 -#, fuzzy -#| msgid "Use portable calling conventions" msgid "Use portable calling conventions." -msgstr "Använd portabla anropskonventioner" +msgstr "Använd portabla anropskonventioner." #: config/pa/pa.opt:107 -#, fuzzy -#| msgid "Specify CPU for scheduling purposes. Valid arguments are 700, 7100, 7100LC, 7200, 7300, and 8000" msgid "Specify CPU for scheduling purposes. Valid arguments are 700, 7100, 7100LC, 7200, 7300, and 8000." -msgstr "Ange CPU för schemaläggningsändamål. Giltiga argument är 700, 7100, 7100LC, 7200, 7300 och 8000" +msgstr "Ange CPU för schemaläggningsändamål. Giltiga argument är 700, 7100, 7100LC, 7200, 7300 och 8000." #: config/pa/pa.opt:132 config/frv/frv.opt:215 -#, fuzzy -#| msgid "Use software floating point" msgid "Use software floating point." -msgstr "Använd mjukvaruflyttal" +msgstr "Använd mjukvaruflyttal." #: config/pa/pa.opt:140 -#, fuzzy -#| msgid "Do not disable space regs" msgid "Do not disable space regs." -msgstr "Avaktivera inte utrymmesregister" +msgstr "Avaktivera inte utrymmesregister." #: config/v850/v850.opt:29 -#, fuzzy -#| msgid "Use registers r2 and r5" msgid "Use registers r2 and r5." -msgstr "Använd registren r2 och r5" +msgstr "Använd registren r2 och r5." #: config/v850/v850.opt:33 -#, fuzzy -#| msgid "Use 4 byte entries in switch tables" msgid "Use 4 byte entries in switch tables." -msgstr "Använd 4-byteposter i hopptabeller" +msgstr "Använd 4-byteposter i hopptabeller." #: config/v850/v850.opt:37 -#, fuzzy -#| msgid "Enable backend debugging" msgid "Enable backend debugging." -msgstr "Aktivera bakändefelsökning" +msgstr "Aktivera bakändefelsökning." #: config/v850/v850.opt:41 -#, fuzzy -#| msgid "Do not use the callt instruction (default)" msgid "Do not use the callt instruction (default)." -msgstr "Använd inte callt-instruktionen (standard)" +msgstr "Använd inte callt-instruktionen (standard)." #: config/v850/v850.opt:45 -#, fuzzy -#| msgid "Reuse r30 on a per function basis" msgid "Reuse r30 on a per function basis." -msgstr "Återanvänd r30 i varje funktion" +msgstr "Återanvänd r30 i varje funktion." #: config/v850/v850.opt:52 -#, fuzzy -#| msgid "Prohibit PC relative function calls" msgid "Prohibit PC relative function calls." -msgstr "Förhindra PC-relativa funktionsanrop" +msgstr "Förhindra PC-relativa funktionsanrop." #: config/v850/v850.opt:56 -#, fuzzy -#| msgid "Use stubs for function prologues" msgid "Use stubs for function prologues." -msgstr "Använd stubbar för funktionsprologer" +msgstr "Använd stubbar för funktionsprologer." #: config/v850/v850.opt:60 -#, fuzzy -#| msgid "Set the max size of data eligible for the SDA area" msgid "Set the max size of data eligible for the SDA area." -msgstr "Ange den maximala storleken på data som är lämpliga för SDA-arean" +msgstr "Ange den maximala storleken på data som är lämpliga för SDA-arean." #: config/v850/v850.opt:67 -#, fuzzy -#| msgid "Enable the use of the short load instructions" msgid "Enable the use of the short load instructions." -msgstr "Möjliggör användning av de korta load-instruktionerna" +msgstr "Möjliggör användning av de korta laddinstruktionerna." #: config/v850/v850.opt:71 -#, fuzzy -#| msgid "Same as: -mep -mprolog-function" msgid "Same as: -mep -mprolog-function." -msgstr "Samma som: -mep -mprolog-function" +msgstr "Samma som: -mep -mprolog-function." #: config/v850/v850.opt:75 -#, fuzzy -#| msgid "Set the max size of data eligible for the TDA area" msgid "Set the max size of data eligible for the TDA area." -msgstr "Ange den maximala storleken på data som är lämpliga för TDA-arean" +msgstr "Ange den maximala storleken på data som är lämpliga för TDA-arean." #: config/v850/v850.opt:82 -#, fuzzy -#| msgid "Do not enforce strict alignment" msgid "Do not enforce strict alignment." -msgstr "Framtvinga inte strikt justering" +msgstr "Framtvinga inte strikt justering." #: config/v850/v850.opt:86 -#, fuzzy -#| msgid "Put jump tables for switch statements into the .data section rather than the .code section" msgid "Put jump tables for switch statements into the .data section rather than the .code section." -msgstr "Lägg hopptabeller för switch-satser i .data-sektionen istället för .code-sektionen." +msgstr "Lägg hopptabeller för switch-satser i .data-sektionen istället för .code-sektionen.." #: config/v850/v850.opt:93 -#, fuzzy -#| msgid "Compile for the v850 processor" msgid "Compile for the v850 processor." -msgstr "Kompilera för processorn v850" +msgstr "Kompilera för processorn v850." #: config/v850/v850.opt:97 -#, fuzzy -#| msgid "Compile for the v850e processor" msgid "Compile for the v850e processor." -msgstr "Kompilera för processorn v850e" +msgstr "Kompilera för processorn v850e." #: config/v850/v850.opt:101 -#, fuzzy -#| msgid "Compile for the v850e1 processor" msgid "Compile for the v850e1 processor." -msgstr "Kompilera för processorn v850e1" +msgstr "Kompilera för processorn v850e1." #: config/v850/v850.opt:105 -#, fuzzy -#| msgid "Compile for the v850es variant of the v850e1" msgid "Compile for the v850es variant of the v850e1." -msgstr "Kompilera för varianten v850es av v850el" +msgstr "Kompilera för varianten v850es av v850el." #: config/v850/v850.opt:109 -#, fuzzy -#| msgid "Compile for the v850e2 processor" msgid "Compile for the v850e2 processor." -msgstr "Kompilera för processorn v850e2" +msgstr "Kompilera för processorn v850e2." #: config/v850/v850.opt:113 -#, fuzzy -#| msgid "Compile for the v850e2v3 processor" msgid "Compile for the v850e2v3 processor." -msgstr "Kompilera för processorn v850e2v3" +msgstr "Kompilera för processorn v850e2v3." #: config/v850/v850.opt:117 -#, fuzzy -#| msgid "Compile for the v850e3v5 processor" msgid "Compile for the v850e3v5 processor." -msgstr "Kompilera för processorn v850e3v5" +msgstr "Kompilera för processorn v850e3v5." #: config/v850/v850.opt:124 -#, fuzzy -#| msgid "Enable v850e3v5 loop instructions" msgid "Enable v850e3v5 loop instructions." -msgstr "Använd slinginstruktionerna i v850e3v5" +msgstr "Använd slinginstruktionerna i v850e3v5." #: config/v850/v850.opt:128 -#, fuzzy -#| msgid "Set the max size of data eligible for the ZDA area" msgid "Set the max size of data eligible for the ZDA area." -msgstr "Ange den maximala storleken på data som är lämpliga för ZDA-arean" +msgstr "Ange den maximala storleken på data som är lämpliga för ZDA-arean." #: config/v850/v850.opt:135 -#, fuzzy -#| msgid "Enable relaxing in the assembler" msgid "Enable relaxing in the assembler." -msgstr "Aktivera avslappning i assemblern" +msgstr "Aktivera avslappning i assemblern." #: config/v850/v850.opt:139 -#, fuzzy -#| msgid "Prohibit PC relative jumps" msgid "Prohibit PC relative jumps." -msgstr "Förhindra PC-relativa hopp" +msgstr "Förhindra PC-relativa hopp." #: config/v850/v850.opt:143 -#, fuzzy -#| msgid "Inhibit the use of hardware floating point instructions" msgid "Inhibit the use of hardware floating point instructions." -msgstr "Stäng av användningen av alla flyttalsinstruktioner i hårdvara" +msgstr "Stäng av användningen av alla flyttalsinstruktioner i hårdvara." #: config/v850/v850.opt:147 -#, fuzzy -#| msgid "Allow the use of hardware floating point instructions for V850E2V3 and up" msgid "Allow the use of hardware floating point instructions for V850E2V3 and up." -msgstr "Tillåt användningen av flyttalsinstruktioner för V850E2V3 och uppåt" +msgstr "Tillåt användningen av flyttalsinstruktioner för V850E2V3 och uppåt." #: config/v850/v850.opt:151 -#, fuzzy -#| msgid "Enable support for the RH850 ABI. This is the default" msgid "Enable support for the RH850 ABI. This is the default." -msgstr "Aktivera stöd för ABI:et RH850. Detta är standard." +msgstr "Aktivera stöd för ABI:et RH850. Detta är standard.." #: config/v850/v850.opt:155 -#, fuzzy -#| msgid "Enable support for the old GCC ABI" msgid "Enable support for the old GCC ABI." -msgstr "Aktivera stöd för det gamla GCC-ABI:et" +msgstr "Aktivera stöd för det gamla GCC-ABI:et." #: config/v850/v850.opt:159 -#, fuzzy -#| msgid "Support alignments of up to 64-bits" msgid "Support alignments of up to 64-bits." -msgstr "Stöd justering av upp till 64 bitar" +msgstr "Stöd justering av upp till 64 bitar." #: config/g.opt:27 -#, fuzzy -#| msgid "-G\tPut global and static data smaller than bytes into a special section (on some targets)" msgid "-G\tPut global and static data smaller than bytes into a special section (on some targets)." -msgstr "-G\tPlacera globala and statiska data mindre än byte i en speciell sektion (vissa arkitekturer)" +msgstr "-G\tPlacera globala and statiska data mindre än byte i en speciell sektion (vissa arkitekturer)." #: config/lynx.opt:23 -#, fuzzy -#| msgid "Support legacy multi-threading" msgid "Support legacy multi-threading." -msgstr "Stöd gammaldags multitrådning" +msgstr "Stöd gammaldags multitrådning." #: config/lynx.opt:27 -#, fuzzy -#| msgid "Use shared libraries" msgid "Use shared libraries." -msgstr "Använd delade bibliotek" +msgstr "Använd delade bibliotek." #: config/lynx.opt:31 -#, fuzzy -#| msgid "Support multi-threading" msgid "Support multi-threading." -msgstr "Stöd multitrådning" +msgstr "Stöd multitrådning." #: config/nvptx/nvptx.opt:22 -#, fuzzy -#| msgid "Generate code for a 32-bit ABI" msgid "Generate code for a 32-bit ABI." -msgstr "Generera kod för ett 32-bitars ABI" +msgstr "Generera kod för ett 32-bitars ABI." #: config/nvptx/nvptx.opt:26 -#, fuzzy -#| msgid "Generate code for a 64-bit ABI" msgid "Generate code for a 64-bit ABI." -msgstr "Generera kod för ett 64-bitars ABI" +msgstr "Generera kod för ett 64-bitars ABI." #: config/nvptx/nvptx.opt:30 msgid "Link in code for a __main kernel." @@ -11227,62 +9447,44 @@ msgid "Optimize partition neutering" msgstr "Optimera partitionssterilisering" #: config/vxworks.opt:36 -#, fuzzy -#| msgid "Assume the VxWorks RTP environment" msgid "Assume the VxWorks RTP environment." -msgstr "Anta miljön VxWorks RTP" +msgstr "Anta miljön VxWorks RTP." #: config/vxworks.opt:43 -#, fuzzy -#| msgid "Assume the VxWorks vThreads environment" msgid "Assume the VxWorks vThreads environment." -msgstr "Anta miljön VxWorks vThreads" +msgstr "Anta miljön VxWorks vThreads." #: config/cr16/cr16.opt:23 -#, fuzzy -#| msgid "-msim Use simulator runtime" msgid "-msim Use simulator runtime." -msgstr "-msim Använd simulatorkörtider" +msgstr "-msim Använd simulatorkörtider." #: config/cr16/cr16.opt:27 -#, fuzzy -#| msgid "Generate SBIT, CBIT instructions" msgid "Generate SBIT, CBIT instructions." -msgstr "Generera SBIT-, CBIT-instruktioner" +msgstr "Generera SBIT-, CBIT-instruktioner." #: config/cr16/cr16.opt:31 -#, fuzzy -#| msgid "Support multiply accumulate instructions" msgid "Support multiply accumulate instructions." -msgstr "Använd multiplicera-ackumulerainstruktioner" +msgstr "Använd multiplicera-ackumulerainstruktioner." #: config/cr16/cr16.opt:38 -#, fuzzy -#| msgid "Treat data references as near, far or medium. medium is default" msgid "Treat data references as near, far or medium. medium is default." -msgstr "Behandla datareferenser som nära, fjärran eller medium, medium är standard" +msgstr "Behandla datareferenser som nära, fjärran eller medium, medium är standard." #: config/cr16/cr16.opt:42 -#, fuzzy -#| msgid "Generate code for CR16C architecture" msgid "Generate code for CR16C architecture." -msgstr "Generera kod för arkitekturen CR16C" +msgstr "Generera kod för arkitekturen CR16C." #: config/cr16/cr16.opt:46 -#, fuzzy -#| msgid "Generate code for CR16C+ architecture (Default)" msgid "Generate code for CR16C+ architecture (Default)." -msgstr "Generera kod för arkitekturen CR16C+ (Standard)" +msgstr "Generera kod för arkitekturen CR16C+ (Standard)." #: config/cr16/cr16.opt:50 msgid "Treat integers as 32-bit." msgstr "Behandla heltal som 32-bitars." #: config/avr/avr.opt:23 -#, fuzzy -#| msgid "Use subroutines for function prologues and epilogues" msgid "Use subroutines for function prologues and epilogues." -msgstr "Använd subrutiner för funktionprologer och -epiloger" +msgstr "Använd subrutiner för funktionprologer och -epiloger." #: config/avr/avr.opt:26 #, c-format @@ -11290,56 +9492,40 @@ msgid "missing device or architecture after %qs" msgstr "enhet eller arkitektur saknas efter %qs" #: config/avr/avr.opt:27 -#, fuzzy -#| msgid "-mmcu=MCU\tSelect the target MCU" msgid "-mmcu=MCU\tSelect the target MCU." -msgstr "-mmcu=MCU\tVälj mål-MCU:n" +msgstr "-mmcu=MCU\tVälj mål-MCU:n." #: config/avr/avr.opt:31 -#, fuzzy -#| msgid "Set the number of 64 KiB flash segments" msgid "Set the number of 64 KiB flash segments." -msgstr "Sätt antalet 64 KiB flash-segment" +msgstr "Sätt antalet 64 KiB flash-segment." #: config/avr/avr.opt:35 -#, fuzzy -#| msgid "Indicate presence of a processor erratum" msgid "Indicate presence of a processor erratum." -msgstr "Indikera närvaron av ett processor-errata" +msgstr "Indikera närvaron av ett processor-errata." #: config/avr/avr.opt:39 -#, fuzzy -#| msgid "Enable Read-Modify-Write (RMW) instructions support/use" msgid "Enable Read-Modify-Write (RMW) instructions support/use." -msgstr "Aktivera stöd/användning av Läs-Ändra-Skriv- (RMW-)instruktioner" +msgstr "Aktivera stöd/användning av Läs-Ändra-Skriv- (RMW-)instruktioner." #: config/avr/avr.opt:49 -#, fuzzy -#| msgid "Use an 8-bit 'int' type" msgid "Use an 8-bit 'int' type." -msgstr "Använd en 8-bitars ”int”-typ" +msgstr "Använd en 8-bitars ”int”-typ." #: config/avr/avr.opt:53 -#, fuzzy -#| msgid "Change the stack pointer without disabling interrupts" msgid "Change the stack pointer without disabling interrupts." -msgstr "Ändra stackpekaren utan att avaktivera avbrott" +msgstr "Ändra stackpekaren utan att avaktivera avbrott." #: config/avr/avr.opt:57 msgid "Set the branch costs for conditional branch instructions. Reasonable values are small, non-negative integers. The default branch cost is 0." msgstr "Ställ in grenkostnaden för villkorliga greninstruktioner. Rimliga värden är små, ickenegativa heltal. Standardkostnaden för grenar är 0." #: config/avr/avr.opt:67 -#, fuzzy -#| msgid "Change only the low 8 bits of the stack pointer" msgid "Change only the low 8 bits of the stack pointer." -msgstr "Ändra endast de låga 8 bitarna av stackpekaren" +msgstr "Ändra endast de låga 8 bitarna av stackpekaren." #: config/avr/avr.opt:71 -#, fuzzy -#| msgid "Relax branches" msgid "Relax branches." -msgstr "Lätta på grenar" +msgstr "Lätta på grenar." #: config/avr/avr.opt:75 msgid "Make the linker relaxation machine assume that a program counter wrap-around occurs." @@ -11362,242 +9548,168 @@ msgid "Warn if the address space of an address is changed." msgstr "Varna om adressrymden för en adress ändras." #: config/avr/avr.opt:96 -#, fuzzy -#| msgid "Allow to use truncation instead of rounding towards 0 for fractional int types" msgid "Allow to use truncation instead of rounding towards 0 for fractional int types." -msgstr "Tillåt avhuggning istället för avrundning mot 0 för decimalheltalstyper" +msgstr "Tillåt avhuggning istället för avrundning mot 0 för decimalheltalstyper." #: config/avr/avr.opt:100 -#, fuzzy -#| msgid "Do not link against the device-specific library lib.a" msgid "Do not link against the device-specific library lib.a." -msgstr "Länka inte mot det enhetsspecifika biblioteket lib.a" +msgstr "Länka inte mot det enhetsspecifika biblioteket lib.a." #: config/m32r/m32r.opt:34 -#, fuzzy -#| msgid "Compile for the m32rx" msgid "Compile for the m32rx." -msgstr "Kompilera för en m32rx" +msgstr "Kompilera för en m32rx." #: config/m32r/m32r.opt:38 -#, fuzzy -#| msgid "Compile for the m32r2" msgid "Compile for the m32r2." -msgstr "Kompilera för en m32r2" +msgstr "Kompilera för en m32r2." #: config/m32r/m32r.opt:42 -#, fuzzy -#| msgid "Compile for the m32r" msgid "Compile for the m32r." -msgstr "Kompilera för en m32r" +msgstr "Kompilera för en m32r." #: config/m32r/m32r.opt:46 -#, fuzzy -#| msgid "Align all loops to 32 byte boundary" msgid "Align all loops to 32 byte boundary." -msgstr "Justera alla slingor till 32-bytesgräns" +msgstr "Justera alla slingor till 32-bytesgräns." #: config/m32r/m32r.opt:50 -#, fuzzy -#| msgid "Prefer branches over conditional execution" msgid "Prefer branches over conditional execution." -msgstr "Föredra hopp framför villkorlig körning" +msgstr "Föredra hopp framför villkorlig körning." #: config/m32r/m32r.opt:54 -#, fuzzy -#| msgid "Give branches their default cost" msgid "Give branches their default cost." -msgstr "Ge grenar sin normalkostnad" +msgstr "Ge grenar sin normalkostnad." #: config/m32r/m32r.opt:58 -#, fuzzy -#| msgid "Display compile time statistics" msgid "Display compile time statistics." -msgstr "Visa kompileringstidsstatistik" +msgstr "Visa kompileringstidsstatistik." #: config/m32r/m32r.opt:62 -#, fuzzy -#| msgid "Specify cache flush function" msgid "Specify cache flush function." -msgstr "Ange cache-tömningsfunktion" +msgstr "Ange cache-tömningsfunktion." #: config/m32r/m32r.opt:66 -#, fuzzy -#| msgid "Specify cache flush trap number" msgid "Specify cache flush trap number." -msgstr "Ange cache-tömningsfällnummer" +msgstr "Ange cache-tömningsfällnummer." #: config/m32r/m32r.opt:70 -#, fuzzy -#| msgid "Only issue one instruction per cycle" msgid "Only issue one instruction per cycle." -msgstr "Lägg bara ut en instruktion per cykel" +msgstr "Lägg bara ut en instruktion per cykel." #: config/m32r/m32r.opt:74 -#, fuzzy -#| msgid "Allow two instructions to be issued per cycle" msgid "Allow two instructions to be issued per cycle." -msgstr "Tillåt att två instruktioner läggs ut per cykel" +msgstr "Tillåt att två instruktioner läggs ut per cykel." #: config/m32r/m32r.opt:78 -#, fuzzy -#| msgid "Code size: small, medium or large" msgid "Code size: small, medium or large." -msgstr "Kodstorlek: small, medium, eller large" +msgstr "Kodstorlek: small, medium, eller large." #: config/m32r/m32r.opt:94 -#, fuzzy -#| msgid "Don't call any cache flush functions" msgid "Don't call any cache flush functions." -msgstr "Anropa inte några cache-tömningsfunktioner" +msgstr "Anropa inte några cache-tömningsfunktioner." #: config/m32r/m32r.opt:98 -#, fuzzy -#| msgid "Don't call any cache flush trap" msgid "Don't call any cache flush trap." -msgstr "Anropa inga cache-tömningsfällor" +msgstr "Anropa inga cache-tömningsfällor." #: config/m32r/m32r.opt:105 -#, fuzzy -#| msgid "Small data area: none, sdata, use" msgid "Small data area: none, sdata, use." -msgstr "Litet dataområde: none, sdata, use" +msgstr "Litet dataområde: none, sdata, use." #: config/s390/tpf.opt:23 -#, fuzzy -#| msgid "Enable TPF-OS tracing code" msgid "Enable TPF-OS tracing code." -msgstr "Aktivera TPF-OS-spårningskod" +msgstr "Aktivera TPF-OS-spårningskod." #: config/s390/tpf.opt:27 -#, fuzzy -#| msgid "Specify main object for TPF-OS" msgid "Specify main object for TPF-OS." -msgstr "Ange huvudobjekt för TPF-OS" +msgstr "Ange huvudobjekt för TPF-OS." #: config/s390/s390.opt:48 -#, fuzzy -#| msgid "31 bit ABI" msgid "31 bit ABI." -msgstr "31-bitars ABI" +msgstr "31-bitars ABI." #: config/s390/s390.opt:52 -#, fuzzy -#| msgid "64 bit ABI" msgid "64 bit ABI." -msgstr "64-bitars ABI" +msgstr "64-bitars ABI." #: config/s390/s390.opt:96 -#, fuzzy -#| msgid "Maintain backchain pointer" msgid "Maintain backchain pointer." -msgstr "Håll med bakåtkedjepekare" +msgstr "Håll med bakåtkedjepekare." #: config/s390/s390.opt:100 -#, fuzzy -#| msgid "Additional debug prints" msgid "Additional debug prints." -msgstr "Ytterligare felsökningsutskrifter" +msgstr "Ytterligare felsökningsutskrifter." #: config/s390/s390.opt:104 -#, fuzzy -#| msgid "ESA/390 architecture" msgid "ESA/390 architecture." -msgstr "ESA/390-arkitektur" +msgstr "ESA/390-arkitektur." #: config/s390/s390.opt:108 -#, fuzzy -#| msgid "Enable decimal floating point hardware support" msgid "Enable decimal floating point hardware support." -msgstr "Använd hårdvarustöd för decimala flyttal" +msgstr "Använd hårdvarustöd för decimala flyttal." #: config/s390/s390.opt:112 -#, fuzzy -#| msgid "Enable hardware floating point" msgid "Enable hardware floating point." -msgstr "Använd hårdvaruflyttal" +msgstr "Använd hårdvaruflyttal." #: config/s390/s390.opt:116 msgid "Takes two non-negative integer numbers separated by a comma." msgstr "Tar två icke-negativa heltal separerade av ett komma." #: config/s390/s390.opt:134 -#, fuzzy -#| msgid "Use hardware transactional execution instructions" msgid "Use hardware transactional execution instructions." -msgstr "Använd transaktionskörningsinstruktioner i hårdvara" +msgstr "Använd transaktionskörningsinstruktioner i hårdvara." #: config/s390/s390.opt:138 -#, fuzzy -#| msgid "hardware decimal floating point instructions not available on %s" msgid "Use hardware vector facility instructions and enable the vector ABI." -msgstr "hårdvaruinstruktioner för decimala flyttal är inte tillgängliga på %s" +msgstr "Använd instruktioner för vektorfunktioner i hårdvara och aktivera vektor-ABI:et." #: config/s390/s390.opt:142 -#, fuzzy -#| msgid "Use packed stack layout" msgid "Use packed stack layout." -msgstr "Använd packad stacklayout" +msgstr "Använd packad stacklayout." #: config/s390/s390.opt:146 -#, fuzzy -#| msgid "Use bras for executable < 64k" msgid "Use bras for executable < 64k." -msgstr "Använd bras för körbara program < 64k" +msgstr "Använd bras för körbara program < 64k." #: config/s390/s390.opt:150 -#, fuzzy -#| msgid "Disable hardware floating point" msgid "Disable hardware floating point." -msgstr "Använd inte hårdvaruflyttal" +msgstr "Använd inte hårdvaruflyttal." #: config/s390/s390.opt:154 -#, fuzzy -#| msgid "Set the max. number of bytes which has to be left to stack size before a trap instruction is triggered" msgid "Set the max. number of bytes which has to be left to stack size before a trap instruction is triggered." -msgstr "Ange det maximala antalet byte som måste finnas kvar till stackstorleken före en fällinstruktion utlöses" +msgstr "Ange det maximala antalet byte som måste finnas kvar till stackstorleken före en fällinstruktion utlöses." #: config/s390/s390.opt:158 msgid "Switches off the -mstack-guard= option." msgstr "Slår av flaggan -mstack-guard=." #: config/s390/s390.opt:162 -#, fuzzy -#| msgid "Emit extra code in the function prologue in order to trap if the stack size exceeds the given limit" msgid "Emit extra code in the function prologue in order to trap if the stack size exceeds the given limit." -msgstr "Mata ut extra kod i funktionsprologen för att fånga om stackstorleken överskrider den givna gränsen" +msgstr "Mata ut extra kod i funktionsprologen för att fånga om stackstorleken överskrider den givna gränsen." #: config/s390/s390.opt:166 msgid "Switches off the -mstack-size= option." msgstr "Slår av flaggan -mstack-size=." #: config/s390/s390.opt:174 -#, fuzzy -#| msgid "Generate string instructions for block moves" msgid "Use the mvcle instruction for block moves." -msgstr "Generera stränginstruktioner för blockförflyttningar" +msgstr "Använd mvcle-instruktioner för blockförflyttningar." #: config/s390/s390.opt:178 msgid "Enable the z vector language extension providing the context-sensitive" msgstr "Aktivera språkutökningen z-vektor som ger det kontextkänsliga" #: config/s390/s390.opt:183 -#, fuzzy -#| msgid "Warn if a function uses alloca or creates an array with dynamic size" msgid "Warn if a function uses alloca or creates an array with dynamic size." -msgstr "Varna om en funktion använder alloca eller skapar en vektor med dynamisk storlek" +msgstr "Varna om en funktion använder alloca eller skapar en vektor med dynamisk storlek." #: config/s390/s390.opt:187 -#, fuzzy -#| msgid "Warn if a single function's framesize exceeds the given framesize" msgid "Warn if a single function's framesize exceeds the given framesize." -msgstr "Varna om en enskild funktions ramstorlek överskrider den angivna ramstorleken" +msgstr "Varna om en enskild funktions ramstorlek överskrider den angivna ramstorleken." #: config/s390/s390.opt:191 -#, fuzzy -#| msgid "z/Architecture" msgid "z/Architecture." -msgstr "z/Arkitektur" +msgstr "z/Arkitektur." #: config/s390/s390.opt:195 msgid "Set the branch costs for conditional branch instructions. Reasonable" @@ -11624,32 +9736,24 @@ msgid "Selects the type of RL78 core being targeted (g10/g13/g14). The default msgstr "Väljer typen av RL78-kärna att ha som mål (g10/g13/g14). Standard är G14. Om satt väljer det även stödet av hårdvarumultiplikation att använda." #: config/rl78/rl78.opt:77 -#, fuzzy -#| msgid "Alias for --help=target" msgid "Alias for -mcpu=g10." -msgstr "Alias för --help=target" +msgstr "Alias för -mcpu=g10." #: config/rl78/rl78.opt:81 -#, fuzzy -#| msgid "Alias for --help=target" msgid "Alias for -mcpu=g13." -msgstr "Alias för --help=target" +msgstr "Alias för -mcpu=g13." #: config/rl78/rl78.opt:85 config/rl78/rl78.opt:89 -#, fuzzy -#| msgid "Alias for --help=target" msgid "Alias for -mcpu=g14." -msgstr "Alias för --help=target" +msgstr "Alias för -mcpu=g14." #: config/rl78/rl78.opt:93 msgid "Assume ES is zero throughout program execution, use ES: for read-only data." msgstr "Anta att ES är noll genom hela programkörningen, använd ES: för endast läsbara data." #: config/stormy16/stormy16.opt:24 -#, fuzzy -#| msgid "Provide libraries for the simulator" msgid "Provide libraries for the simulator." -msgstr "Tillhandahåll bibliotek för simulatorn" +msgstr "Tillhandahåll bibliotek för simulatorn." #: config/arm/arm-tables.opt:25 msgid "Known ARM CPUs (for use with the -mcpu= and -mtune= options):" @@ -11668,188 +9772,136 @@ msgid "TLS dialect to use:" msgstr "TLS-dialekt att använda:" #: config/arm/arm.opt:36 -#, fuzzy -#| msgid "Specify an ABI" msgid "Specify an ABI." -msgstr "Ange ett ABI" +msgstr "Ange ett ABI." #: config/arm/arm.opt:40 msgid "Known ARM ABIs (for use with the -mabi= option):" msgstr "Kända ARM ABI:er (att användas med flaggan -mabi=):" #: config/arm/arm.opt:59 -#, fuzzy -#| msgid "Generate a call to abort if a noreturn function returns" msgid "Generate a call to abort if a noreturn function returns." -msgstr "Generera ett anrop till abort om en noreturn-funktion returnerar" +msgstr "Generera ett anrop till abort om en noreturn-funktion returnerar." #: config/arm/arm.opt:66 -#, fuzzy -#| msgid "Pass FP arguments in FP registers" msgid "Pass FP arguments in FP registers." -msgstr "Skicka FP-argument i FP-register" +msgstr "Skicka FP-argument i FP-register." #: config/arm/arm.opt:70 -#, fuzzy -#| msgid "Generate APCS conformant stack frames" msgid "Generate APCS conformant stack frames." -msgstr "Generera stackramar enligt APCS" +msgstr "Generera stackramar enligt APCS." #: config/arm/arm.opt:74 -#, fuzzy -#| msgid "Generate re-entrant, PIC code" msgid "Generate re-entrant, PIC code." -msgstr "Generera återstartbar, PIC-kod" +msgstr "Generera återstartbar, PIC-kod." #: config/arm/arm.opt:90 msgid "Generate code in 32 bit ARM state." msgstr "Generera kod i 32-bitars ARM-tillstånd." #: config/arm/arm.opt:98 -#, fuzzy -#| msgid "Thumb: Assume non-static functions may be called from ARM code" msgid "Thumb: Assume non-static functions may be called from ARM code." -msgstr "Thumb: Anta att icke-statiska funktioner kan anropas från ARM-kod" +msgstr "Thumb: Anta att icke-statiska funktioner kan anropas från ARM-kod." #: config/arm/arm.opt:102 -#, fuzzy -#| msgid "Thumb: Assume function pointers may go to non-Thumb aware code" msgid "Thumb: Assume function pointers may go to non-Thumb aware code." -msgstr "Thumb: Anta att funktionspekare kan gå till icke-Thumb-medveten kod" +msgstr "Thumb: Anta att funktionspekare kan gå till icke-Thumb-medveten kod." #: config/arm/arm.opt:110 -#, fuzzy -#| msgid "Specify if floating point hardware should be used" msgid "Specify if floating point hardware should be used." -msgstr "Ange om flyttalshårdvara skall användas" +msgstr "Ange om flyttalshårdvara skall användas." #: config/arm/arm.opt:114 msgid "Known floating-point ABIs (for use with the -mfloat-abi= option):" msgstr "Kända flyttals-ABI:er (att användas med flaggan -mfloat-abi=):" #: config/arm/arm.opt:127 -#, fuzzy -#| msgid "Switch on/off MIPS16 ASE on alternating functions for compiler testing" msgid "Switch ARM/Thumb modes on alternating functions for compiler testing." -msgstr "Växla av/på MIPS16 ASE mellan alternerande funktioner för kompilatortestning" +msgstr "Växla ARM-/Thumb-lägen mellan alternerande funktioner för kompilatortestning." #: config/arm/arm.opt:131 -#, fuzzy -#| msgid "Specify the __fp16 floating-point format" msgid "Specify the __fp16 floating-point format." -msgstr "Ange flyttalsformatet __fp16" +msgstr "Ange flyttalsformatet __fp16." #: config/arm/arm.opt:135 msgid "Known __fp16 formats (for use with the -mfp16-format= option):" msgstr "Kända __fp16-format (att användas med flaggan -mfp16-format=):" #: config/arm/arm.opt:148 -#, fuzzy -#| msgid "Specify the name of the target floating point hardware/format" msgid "Specify the name of the target floating point hardware/format." -msgstr "Ange namnet på målets flyttalshårdvara/-format" +msgstr "Ange namnet på målets flyttalshårdvara/-format." #: config/arm/arm.opt:159 -#, fuzzy -#| msgid "Generate call insns as indirect calls, if necessary" msgid "Generate call insns as indirect calls, if necessary." -msgstr "Generera anropsinstruktioner som indirekta anrop, om nödvändigt" +msgstr "Generera anropsinstruktioner som indirekta anrop, om nödvändigt." #: config/arm/arm.opt:163 msgid "Assume data segments are relative to text segment." msgstr "Anta att datasegment är relativa till textsegment." #: config/arm/arm.opt:167 -#, fuzzy -#| msgid "Specify the register to be used for PIC addressing" msgid "Specify the register to be used for PIC addressing." -msgstr "Ange registret som skall användas för PIC-adressering" +msgstr "Ange registret som skall användas för PIC-adressering." #: config/arm/arm.opt:171 -#, fuzzy -#| msgid "Store function names in object code" msgid "Store function names in object code." -msgstr "Lagra funktionsnamn i objektkod" +msgstr "Lagra funktionsnamn i objektkod." #: config/arm/arm.opt:175 -#, fuzzy -#| msgid "Permit scheduling of a function's prologue sequence" msgid "Permit scheduling of a function's prologue sequence." -msgstr "Tillåt schemaläggning av en funktions prologsekvens" +msgstr "Tillåt schemaläggning av en funktions prologsekvens." #: config/arm/arm.opt:179 config/rs6000/rs6000.opt:248 -#, fuzzy -#| msgid "Do not load the PIC register in function prologues" msgid "Do not load the PIC register in function prologues." -msgstr "Ladda inte PIC-registret i funktionsprologer" +msgstr "Ladda inte PIC-registret i funktionsprologer." #: config/arm/arm.opt:186 -#, fuzzy -#| msgid "Specify the minimum bit alignment of structures" msgid "Specify the minimum bit alignment of structures." -msgstr "Ange den minsta justeringen i bitar för poster" +msgstr "Ange den minsta justeringen i bitar för poster." #: config/arm/arm.opt:190 -#, fuzzy -#| msgid "Generate code for Thumb state" msgid "Generate code for Thumb state." -msgstr "Generera kod för Thumb-tillstånd" +msgstr "Generera kod för Thumb-tillstånd." #: config/arm/arm.opt:194 -#, fuzzy -#| msgid "Support calls between Thumb and ARM instruction sets" msgid "Support calls between Thumb and ARM instruction sets." -msgstr "Stöd anrop mellan Thumb- och ARM-instruktionsuppsättningar" +msgstr "Stöd anrop mellan Thumb- och ARM-instruktionsuppsättningar." #: config/arm/arm.opt:198 -#, fuzzy -#| msgid "Specify thread local storage scheme" msgid "Specify thread local storage scheme." -msgstr "Ange metod för trådlokal lagring" +msgstr "Ange metod för trådlokal lagring." #: config/arm/arm.opt:202 -#, fuzzy -#| msgid "Specify how to access the thread pointer" msgid "Specify how to access the thread pointer." -msgstr "Ange hur trådpekaren skall nås" +msgstr "Ange hur trådpekaren skall nås." #: config/arm/arm.opt:206 msgid "Valid arguments to -mtp=:" msgstr "Giltiga argument till -mtp=:" #: config/arm/arm.opt:219 -#, fuzzy -#| msgid "Thumb: Generate (non-leaf) stack frames even if not needed" msgid "Thumb: Generate (non-leaf) stack frames even if not needed." -msgstr "Thumb: Generera (icke-löv-)stackramar även om de inte behövs" +msgstr "Thumb: Generera (icke-löv-)stackramar även om de inte behövs." #: config/arm/arm.opt:223 -#, fuzzy -#| msgid "Thumb: Generate (leaf) stack frames even if not needed" msgid "Thumb: Generate (leaf) stack frames even if not needed." -msgstr "Thumb: Generera (löv)stackramar även om de inte behövs" +msgstr "Thumb: Generera (löv)stackramar även om de inte behövs." #: config/arm/arm.opt:227 config/mn10300/mn10300.opt:42 -#, fuzzy -#| msgid "Tune code for the given processor" msgid "Tune code for the given processor." -msgstr "Trimma koden för den angivna processorn" +msgstr "Trimma koden för den angivna processorn." #: config/arm/arm.opt:231 msgid "Print CPU tuning information as comment in assembler file. This is" msgstr "Skriv ut CPU-trimningsinformation som en kommentar i assemblerfilen. Detta är" #: config/arm/arm.opt:242 -#, fuzzy -#| msgid "Use Neon quad-word (rather than double-word) registers for vectorization" msgid "Use Neon quad-word (rather than double-word) registers for vectorization." -msgstr "Använd Neons quad-ords- (snarare än dubbelords-)register för vektoriseringar" +msgstr "Använd Neons quad-ords- (snarare än dubbelords-)register för vektoriseringar." #: config/arm/arm.opt:246 -#, fuzzy -#| msgid "Use Neon double-word (rather than quad-word) registers for vectorization" msgid "Use Neon double-word (rather than quad-word) registers for vectorization." -msgstr "Använd Neons dubbelords- (snarare än quad-ords-)register för vektoriseringar" +msgstr "Använd Neons dubbelords- (snarare än quad-ords-)register för vektoriseringar." #: config/arm/arm.opt:250 msgid "Only generate absolute relocations on word sized values." @@ -11884,162 +9936,109 @@ msgid "Assume loading data from flash is slower than fetching instructions." msgstr "Anta att ladda data från flash är långsammare än att hämta instruktioner." #: config/arm/arm.opt:283 -#, fuzzy -#| msgid "Assume unified syntax for Thumb inline assembly code." msgid "Assume unified syntax for inline assembly code." -msgstr "Anta unifierad syntax för Thumb-inline assemblerkod." +msgstr "Anta unifierad syntax för inline:ad assemblerkod." -# fixme: fp = flyttal, men hur skall man skriva det. Förkortat eller FPU? #: config/sparc/sparc.opt:30 config/sparc/sparc.opt:34 #: config/visium/visium.opt:37 -#, fuzzy -#| msgid "Use hardware FP" msgid "Use hardware FP." -msgstr "Använd hårdvaru-fp" +msgstr "Använd hårdvaruflyttal." #: config/sparc/sparc.opt:38 config/visium/visium.opt:41 -#, fuzzy -#| msgid "Do not use hardware FP" msgid "Do not use hardware FP." -msgstr "Använd inte hårdvaru-fp" +msgstr "Använd inte hårdvaru-fp." #: config/sparc/sparc.opt:42 -#, fuzzy -#| msgid "Use flat register window model" msgid "Use flat register window model." -msgstr "Använd platt registerfönstermodell" +msgstr "Använd platt registerfönstermodell." #: config/sparc/sparc.opt:46 -#, fuzzy -#| msgid "Assume possible double misalignment" msgid "Assume possible double misalignment." -msgstr "Anta möjlig feljustering av double" +msgstr "Anta möjlig feljustering av double." #: config/sparc/sparc.opt:50 -#, fuzzy -#| msgid "Use ABI reserved registers" msgid "Use ABI reserved registers." -msgstr "Använd register reserverade av ABI" +msgstr "Använd register reserverade av ABI." #: config/sparc/sparc.opt:54 -#, fuzzy -#| msgid "Use hardware quad FP instructions" msgid "Use hardware quad FP instructions." -msgstr "Använd hårdvaruinstruktioner för quad fp" +msgstr "Använd hårdvaruinstruktioner för quad fp." #: config/sparc/sparc.opt:58 -#, fuzzy -#| msgid "Do not use hardware quad fp instructions" msgid "Do not use hardware quad fp instructions." -msgstr "Använd inte hårdvaruinstruktioner för quad fp" +msgstr "Använd inte hårdvaruinstruktioner för quad fp." #: config/sparc/sparc.opt:62 -#, fuzzy -#| msgid "Compile for V8+ ABI" msgid "Compile for V8+ ABI." -msgstr "Kompilera för V8+-ABI" +msgstr "Kompilera för V8+-ABI." #: config/sparc/sparc.opt:66 -#, fuzzy -#| msgid "Use UltraSPARC Visual Instruction Set version 1.0 extensions" msgid "Use UltraSPARC Visual Instruction Set version 1.0 extensions." -msgstr "Utnyttja UltraSPARC-utökningarna Visual Instruction Set version 1.0" +msgstr "Utnyttja UltraSPARC-utökningarna Visual Instruction Set version 1.0." #: config/sparc/sparc.opt:70 -#, fuzzy -#| msgid "Use UltraSPARC Visual Instruction Set version 2.0 extensions" msgid "Use UltraSPARC Visual Instruction Set version 2.0 extensions." -msgstr "Utnyttja UltraSPARC-utökningarna Visual Instruction Set version 2.0" +msgstr "Utnyttja UltraSPARC-utökningarna Visual Instruction Set version 2.0." #: config/sparc/sparc.opt:74 -#, fuzzy -#| msgid "Use UltraSPARC Visual Instruction Set version 3.0 extensions" msgid "Use UltraSPARC Visual Instruction Set version 3.0 extensions." -msgstr "Utnyttja UltraSPARC-utökningarna Visual Instruction Set version 3.0" +msgstr "Utnyttja UltraSPARC-utökningarna Visual Instruction Set version 3.0." #: config/sparc/sparc.opt:78 -#, fuzzy -#| msgid "Use UltraSPARC Compare-and-Branch extensions" msgid "Use UltraSPARC Compare-and-Branch extensions." -msgstr "Utnyttja UltraSPARC-utökningen jämför-och-grena" +msgstr "Utnyttja UltraSPARC-utökningen jämför-och-grena." #: config/sparc/sparc.opt:82 -#, fuzzy -#| msgid "Use UltraSPARC Fused Multiply-Add extensions" msgid "Use UltraSPARC Fused Multiply-Add extensions." -msgstr "Utnyttja UltraSPARC-utökningen sammansmält multiplicera-addera" +msgstr "Utnyttja UltraSPARC-utökningen sammansmält multiplicera-addera." #: config/sparc/sparc.opt:86 -#, fuzzy -#| msgid "Use UltraSPARC Population-Count instruction" msgid "Use UltraSPARC Population-Count instruction." -msgstr "Utnyttja UltraSparc:s instruktion populeringsantal" +msgstr "Utnyttja UltraSparc:s instruktion populeringsantal." #: config/sparc/sparc.opt:90 -#, fuzzy -#| msgid "Pointers are 64-bit" msgid "Pointers are 64-bit." -msgstr "Pekare är 64-bitars" +msgstr "Pekare är 64-bitars." #: config/sparc/sparc.opt:94 -#, fuzzy -#| msgid "Pointers are 32-bit" msgid "Pointers are 32-bit." -msgstr "Pekare är 32-bitars" +msgstr "Pekare är 32-bitars." #: config/sparc/sparc.opt:98 -#, fuzzy -#| msgid "Use 64-bit ABI" msgid "Use 64-bit ABI." -msgstr "Använd 64-bitars ABI" +msgstr "Använd 64-bitars ABI." #: config/sparc/sparc.opt:102 -#, fuzzy -#| msgid "Use 32-bit ABI" msgid "Use 32-bit ABI." -msgstr "Använd 32-bitars ABI" +msgstr "Använd 32-bitars ABI." #: config/sparc/sparc.opt:106 -#, fuzzy -#| msgid "Use stack bias" msgid "Use stack bias." -msgstr "Använd stackförskjutning" +msgstr "Använd stackförskjutning." #: config/sparc/sparc.opt:110 -#, fuzzy -#| msgid "Use structs on stronger alignment for double-word copies" msgid "Use structs on stronger alignment for double-word copies." -msgstr "Använd starkare justering för poster för dubbelordkopieringar" +msgstr "Använd starkare justering för poster för dubbelordkopieringar." #: config/sparc/sparc.opt:114 -#, fuzzy -#| msgid "Optimize tail call instructions in assembler and linker" msgid "Optimize tail call instructions in assembler and linker." -msgstr "Optimera svansanropsinstruktioner i assembler och länkare" +msgstr "Optimera svansanropsinstruktioner i assembler och länkare." #: config/sparc/sparc.opt:118 -#, fuzzy -#| msgid "Do not generate code that can only run in supervisor mode" msgid "Do not generate code that can only run in supervisor mode (default)." -msgstr "Generera inte kod som endast kan köra i övervakarläge" +msgstr "Generera inte kod som endast kan köra i övervakarläge (standard)." #: config/sparc/sparc.opt:122 config/visium/visium.opt:45 -#, fuzzy -#| msgid "Use features of and schedule code for given CPU" msgid "Use features of and schedule code for given CPU." -msgstr "Använd funktioner i och schemalägg kod för angiven CPU" +msgstr "Använd funktioner i och schemalägg kod för angiven CPU." #: config/sparc/sparc.opt:199 -#, fuzzy -#| msgid "Use given SPARC-V9 code model" msgid "Use given SPARC-V9 code model." -msgstr "Använd angiven SPARC-V9-kodmodell" +msgstr "Använd angiven SPARC-V9-kodmodell." #: config/sparc/sparc.opt:203 -#, fuzzy -#| msgid "Enable debug output" msgid "Enable debug output." -msgstr "Aktivera felsökningsutdata" +msgstr "Aktivera felsökningsutdata." #: config/sparc/sparc.opt:207 msgid "Enable strict 32-bit psABI struct return checking." @@ -12050,228 +10049,156 @@ msgid "Enable workaround for single erratum of AT697F processor" msgstr "Aktivera en lösning för ensamt errata för processorn AT697F" #: config/sparc/sparc.opt:216 -#, fuzzy -#| msgid "Enable workarounds for the errata of the UT699 processor" msgid "Enable workarounds for the errata of the UT699 processor." -msgstr "Aktivera en lösning för errata för processorn UT699" +msgstr "Aktivera en lösning för errata för processorn UT699." #: config/sparc/sparc.opt:245 msgid "Specify the memory model in effect for the program." msgstr "Ange minnesmodellen som skall gälla för programmet." #: config/rs6000/darwin.opt:38 config/rs6000/sysv4.opt:141 -#, fuzzy -#| msgid "Generate 64-bit code" msgid "Generate 64-bit code." -msgstr "Generera 64-bitars kod" +msgstr "Generera 64-bitars kod." #: config/rs6000/darwin.opt:42 config/rs6000/sysv4.opt:145 -#, fuzzy -#| msgid "Generate 32-bit code" msgid "Generate 32-bit code." -msgstr "Generera 32-bitars kod" +msgstr "Generera 32-bitars kod." #: config/rs6000/rs6000-tables.opt:24 msgid "Known CPUs (for use with the -mcpu= and -mtune= options):" msgstr "Kända CPU:er (att användas med flaggorna -mcpu= och -mtune=):" #: config/rs6000/476.opt:24 -#, fuzzy -#| msgid "Preserve the PowerPC 476's link stack by matching up a blr with the bcl/bl insns used for GOT accesses" msgid "Preserve the PowerPC 476's link stack by matching up a blr with the bcl/bl insns used for GOT accesses." -msgstr "Bevara PowerPC 476:ans länkstack genom att matcha en blr med bcl/bl-instruktionerna som används för GOT-åtkomster" +msgstr "Bevara PowerPC 476:ans länkstack genom att matcha en blr med bcl/bl-instruktionerna som används för GOT-åtkomster." #: config/rs6000/aix64.opt:24 -#, fuzzy -#| msgid "Compile for 64-bit pointers" msgid "Compile for 64-bit pointers." -msgstr "Kompilera för 64-bitspekare" +msgstr "Kompilera för 64-bitspekare." #: config/rs6000/aix64.opt:28 -#, fuzzy -#| msgid "Compile for 32-bit pointers" msgid "Compile for 32-bit pointers." -msgstr "Kompilera för 32-bitspekare" +msgstr "Kompilera för 32-bitspekare." #: config/rs6000/aix64.opt:32 config/rs6000/linux64.opt:28 -#, fuzzy -#| msgid "Select code model" msgid "Select code model." -msgstr "Välj kodmodell" +msgstr "Välj kodmodell." #: config/rs6000/aix64.opt:49 -#, fuzzy -#| msgid "Support message passing with the Parallel Environment" msgid "Support message passing with the Parallel Environment." -msgstr "Stöd meddelandeskickning med Parallel Environment" +msgstr "Stöd meddelandeskickning med Parallel Environment." #: config/rs6000/linux64.opt:24 -#, fuzzy -#| msgid "Call mcount for profiling before a function prologue" msgid "Call mcount for profiling before a function prologue." -msgstr "Anropa mcount för profilering före en funktionsprolog" +msgstr "Anropa mcount för profilering före en funktionsprolog." #: config/rs6000/rs6000.opt:109 -#, fuzzy -#| msgid "Use PowerPC-64 instruction set" msgid "Use PowerPC-64 instruction set." -msgstr "Använd instruktionsuppsättning för PowerPC-64" +msgstr "Använd instruktionsuppsättning för PowerPC-64." #: config/rs6000/rs6000.opt:113 -#, fuzzy -#| msgid "Use PowerPC General Purpose group optional instructions" msgid "Use PowerPC General Purpose group optional instructions." -msgstr "Använd valbara instruktioner i gruppen PowerPC General Purpose" +msgstr "Använd valbara instruktioner i gruppen PowerPC General Purpose." #: config/rs6000/rs6000.opt:117 -#, fuzzy -#| msgid "Use PowerPC Graphics group optional instructions" msgid "Use PowerPC Graphics group optional instructions." -msgstr "Använd valbara instruktioner i gruppen PowerPC Graphics" +msgstr "Använd valbara instruktioner i gruppen PowerPC Graphics." #: config/rs6000/rs6000.opt:121 -#, fuzzy -#| msgid "Use PowerPC V2.01 single field mfcr instruction" msgid "Use PowerPC V2.01 single field mfcr instruction." -msgstr "Använd PowerPC V2.01:s enkelfälts mfcr-instruktion" +msgstr "Använd PowerPC V2.01:s enkelfälts mfcr-instruktion." #: config/rs6000/rs6000.opt:125 -#, fuzzy -#| msgid "Use PowerPC V2.02 popcntb instruction" msgid "Use PowerPC V2.02 popcntb instruction." -msgstr "Använd PowerPC V2.02:s popcntb-instruktion" +msgstr "Använd PowerPC V2.02:s popcntb-instruktion." #: config/rs6000/rs6000.opt:129 -#, fuzzy -#| msgid "Use PowerPC V2.02 floating point rounding instructions" msgid "Use PowerPC V2.02 floating point rounding instructions." -msgstr "Använd PowerPC V2.02:s flyttalsavrundningsinstruktioner" +msgstr "Använd PowerPC V2.02:s flyttalsavrundningsinstruktioner." #: config/rs6000/rs6000.opt:133 -#, fuzzy -#| msgid "Use PowerPC V2.05 compare bytes instruction" msgid "Use PowerPC V2.05 compare bytes instruction." -msgstr "Använd PowerPC V2.05:s bytejämförelseinstruktion" +msgstr "Använd PowerPC V2.05:s bytejämförelseinstruktion." #: config/rs6000/rs6000.opt:137 -#, fuzzy -#| msgid "Use extended PowerPC V2.05 move floating point to/from GPR instructions" msgid "Use extended PowerPC V2.05 move floating point to/from GPR instructions." -msgstr "Använd utökad PowerPC V2.05:s instruktion för att flytta flyttal till/från GPR" +msgstr "Använd utökad PowerPC V2.05:s instruktion för att flytta flyttal till/från GPR." #: config/rs6000/rs6000.opt:141 -#, fuzzy -#| msgid "Use AltiVec instructions" msgid "Use AltiVec instructions." -msgstr "Använd AltiVec-instruktioner" +msgstr "Använd AltiVec-instruktioner." #: config/rs6000/rs6000.opt:145 -#, fuzzy -#| msgid "Generate Altivec instructions using little-endian element order" msgid "Generate Altivec instructions using little-endian element order." -msgstr "Generera Altivec-instruktioner med elementordning för omvänd byteordning" +msgstr "Generera Altivec-instruktioner med elementordning för omvänd byteordning." #: config/rs6000/rs6000.opt:149 -#, fuzzy -#| msgid "Generate Altivec instructions using big-endian element order" msgid "Generate Altivec instructions using big-endian element order." -msgstr "Generera Altivec-instruktioner med elementordning för rak byteordning" +msgstr "Generera Altivec-instruktioner med elementordning för rak byteordning." #: config/rs6000/rs6000.opt:153 -#, fuzzy -#| msgid "Use decimal floating point instructions" msgid "Use decimal floating point instructions." -msgstr "Använd decimala flyttalsinstruktioner" +msgstr "Använd decimala flyttalsinstruktioner." #: config/rs6000/rs6000.opt:157 -#, fuzzy -#| msgid "Use 4xx half-word multiply instructions" msgid "Use 4xx half-word multiply instructions." -msgstr "Använd 4xx:s halvords multiplikationsinstruktioner" +msgstr "Använd 4xx:s halvords multiplikationsinstruktioner." #: config/rs6000/rs6000.opt:161 -#, fuzzy -#| msgid "Use 4xx string-search dlmzb instruction" msgid "Use 4xx string-search dlmzb instruction." -msgstr "Använd 4xx:s strängsöknings dlmzb-instruktion" +msgstr "Använd 4xx:s strängsöknings dlmzb-instruktion." #: config/rs6000/rs6000.opt:165 -#, fuzzy -#| msgid "Generate load/store multiple instructions" msgid "Generate load/store multiple instructions." -msgstr "Generera load/store multiple-instruktioner" +msgstr "Generera ladda/lagra-multipla-instruktioner." #: config/rs6000/rs6000.opt:169 -#, fuzzy -#| msgid "Generate string instructions for block moves" msgid "Generate string instructions for block moves." -msgstr "Generera stränginstruktioner för blockförflyttningar" +msgstr "Generera stränginstruktioner för blockförflyttningar." #: config/rs6000/rs6000.opt:181 -#, fuzzy -#| msgid "Use PowerPC V2.06 popcntd instruction" msgid "Use PowerPC V2.06 popcntd instruction." -msgstr "Använd PowerPC V2.06:s popcntd-instruktion" +msgstr "Använd PowerPC V2.06:s popcntd-instruktion." #: config/rs6000/rs6000.opt:185 -#, fuzzy -#| msgid "Under -ffast-math, generate a FRIZ instruction for (double)(long long) conversions" msgid "Under -ffast-math, generate a FRIZ instruction for (double)(long long) conversions." -msgstr "Under -ffast-math, generera en FRIZ-instruktion för (double)(long long)-konverteringar." +msgstr "Under -ffast-math, generera en FRIZ-instruktion för (double)(long long)-konverteringar.." #: config/rs6000/rs6000.opt:193 -#, fuzzy -#| msgid "Use vector/scalar (VSX) instructions" msgid "Use vector/scalar (VSX) instructions." -msgstr "Använd vektor-/skalärinstruktioner (VSX)" +msgstr "Använd vektor-/skalärinstruktioner (VSX)." #: config/rs6000/rs6000.opt:240 -#, fuzzy -#| msgid "Do not generate load/store with update instructions" msgid "Do not generate load/store with update instructions." -msgstr "Generera inte load/store-instruktioner med uppdatering" +msgstr "Generera inte ladda/lagra-instruktioner med uppdatering." #: config/rs6000/rs6000.opt:244 -#, fuzzy -#| msgid "Generate load/store with update instructions" msgid "Generate load/store with update instructions." -msgstr "Generera load/store-instruktioner med uppdatering" +msgstr "Generera ladda/lagra-instruktioner med uppdatering." #: config/rs6000/rs6000.opt:252 -#, fuzzy -#| msgid "Avoid generation of indexed load/store instructions when possible" msgid "Avoid generation of indexed load/store instructions when possible." -msgstr "Undvik att generera indexerade load/store-instruktioner så långt möjligt" +msgstr "Undvik att generera indexerade ladda/lagra-instruktioner så långt möjligt." #: config/rs6000/rs6000.opt:256 -#, fuzzy -#| msgid "Mark __tls_get_addr calls with argument info" msgid "Mark __tls_get_addr calls with argument info." -msgstr "Märk __tls_get_addr-anrop med argumentinformation" +msgstr "Märk __tls_get_addr-anrop med argumentinformation." #: config/rs6000/rs6000.opt:263 -#, fuzzy -#| msgid "Schedule the start and end of the procedure" msgid "Schedule the start and end of the procedure." -msgstr "Schemalägg början och slutet av proceduren" +msgstr "Schemalägg början och slutet av proceduren." #: config/rs6000/rs6000.opt:267 -#, fuzzy -#| msgid "Return all structures in memory (AIX default)" msgid "Return all structures in memory (AIX default)." -msgstr "Returnera alla strukturer i minnet (standard för AIX)" +msgstr "Returnera alla strukturer i minnet (standard för AIX)." #: config/rs6000/rs6000.opt:271 -#, fuzzy -#| msgid "Return small structures in registers (SVR4 default)" msgid "Return small structures in registers (SVR4 default)." -msgstr "Returnera små strukturer i register (standard för SVR4)" +msgstr "Returnera små strukturer i register (standard för SVR4)." #: config/rs6000/rs6000.opt:275 -#, fuzzy -#| msgid "Conform more closely to IBM XLC semantics" msgid "Conform more closely to IBM XLC semantics." -msgstr "Följ mer noga IBM XLC:s semantik" +msgstr "Följ mer noga IBM XLC:s semantik." #: config/rs6000/rs6000.opt:279 config/rs6000/rs6000.opt:283 msgid "Generate software reciprocal divide and square root for better throughput." @@ -12282,148 +10209,100 @@ msgid "Assume that the reciprocal estimate instructions provide more accuracy." msgstr "Antag att de ömsesidiga uppskattningsinstruktionerna ger mer precision." #: config/rs6000/rs6000.opt:291 -#, fuzzy -#| msgid "Do not place floating point constants in TOC" msgid "Do not place floating point constants in TOC." -msgstr "Placera inte flyttalskonstanter i TOC" +msgstr "Placera inte flyttalskonstanter i TOC." #: config/rs6000/rs6000.opt:295 -#, fuzzy -#| msgid "Place floating point constants in TOC" msgid "Place floating point constants in TOC." -msgstr "Placera flyttalskonstanter i TOC" +msgstr "Placera flyttalskonstanter i TOC." #: config/rs6000/rs6000.opt:299 -#, fuzzy -#| msgid "Do not place symbol+offset constants in TOC" msgid "Do not place symbol+offset constants in TOC." -msgstr "Placera inte symbol+avstånd-konstanter i TOC" +msgstr "Placera inte symbol+avstånd-konstanter i TOC." #: config/rs6000/rs6000.opt:303 -#, fuzzy -#| msgid "Place symbol+offset constants in TOC" msgid "Place symbol+offset constants in TOC." -msgstr "Placera symbol+avstånd-konstanter i TOC" +msgstr "Placera symbol+avstånd-konstanter i TOC." #: config/rs6000/rs6000.opt:314 -#, fuzzy -#| msgid "Use only one TOC entry per procedure" msgid "Use only one TOC entry per procedure." -msgstr "Använd endast en TOC-post per procedur" +msgstr "Använd endast en TOC-post per procedur." #: config/rs6000/rs6000.opt:318 -#, fuzzy -#| msgid "Put everything in the regular TOC" msgid "Put everything in the regular TOC." -msgstr "Placera allting i den vanliga TOC" +msgstr "Placera allting i den vanliga TOC." #: config/rs6000/rs6000.opt:322 -#, fuzzy -#| msgid "Generate VRSAVE instructions when generating AltiVec code" msgid "Generate VRSAVE instructions when generating AltiVec code." -msgstr "Generera VRSAVE-instruktioner när AltiVec-kod genereras" +msgstr "Generera VRSAVE-instruktioner när AltiVec-kod genereras." #: config/rs6000/rs6000.opt:326 -#, fuzzy -#| msgid "Deprecated option. Use -mno-vrsave instead" msgid "Deprecated option. Use -mno-vrsave instead." -msgstr "Undanbedd flagga. Använd -mno-vrsave istället" +msgstr "Undanbedd flagga. Använd -mno-vrsave istället." #: config/rs6000/rs6000.opt:330 -#, fuzzy -#| msgid "Deprecated option. Use -mvrsave instead" msgid "Deprecated option. Use -mvrsave instead." -msgstr "Undanbedd flagga. Använd -mvrsave istället" +msgstr "Undanbedd flagga. Använd -mvrsave istället." #: config/rs6000/rs6000.opt:334 -#, fuzzy -#| msgid "Specify how many bytes should be moved inline before calling out to memcpy/memmove" msgid "Specify how many bytes should be moved inline before calling out to memcpy/memmove." -msgstr "Ange hur många byte som bör flyttas inline före anrop av memcpy/memmove" +msgstr "Ange hur många byte som bör flyttas inline före anrop av memcpy/memmove." #: config/rs6000/rs6000.opt:338 -#, fuzzy -#| msgid "Generate isel instructions" msgid "Generate isel instructions." -msgstr "Generera isel-instruktioner" +msgstr "Generera isel-instruktioner." #: config/rs6000/rs6000.opt:342 -#, fuzzy -#| msgid "Deprecated option. Use -mno-isel instead" msgid "Deprecated option. Use -mno-isel instead." -msgstr "Undanbedd flagga. Använd -mno-isel istället" +msgstr "Undanbedd flagga. Använd -mno-isel istället." #: config/rs6000/rs6000.opt:346 -#, fuzzy -#| msgid "Deprecated option. Use -misel instead" msgid "Deprecated option. Use -misel instead." -msgstr "Undanbedd flagga. Använd -misel istället" +msgstr "Undanbedd flagga. Använd -misel istället." #: config/rs6000/rs6000.opt:350 -#, fuzzy -#| msgid "Generate SPE SIMD instructions on E500" msgid "Generate SPE SIMD instructions on E500." -msgstr "Generera SPE SIMD-instruktioner för E500" +msgstr "Generera SPE SIMD-instruktioner för E500." #: config/rs6000/rs6000.opt:354 -#, fuzzy -#| msgid "Generate PPC750CL paired-single instructions" msgid "Generate PPC750CL paired-single instructions." -msgstr "Generera PPC750CL:s par-singel-instruktioner" +msgstr "Generera PPC750CL:s par-singel-instruktioner." #: config/rs6000/rs6000.opt:358 -#, fuzzy -#| msgid "Deprecated option. Use -mno-spe instead" msgid "Deprecated option. Use -mno-spe instead." -msgstr "Undanbedd flagga. Använd -mno-spe istället" +msgstr "Undanbedd flagga. Använd -mno-spe istället." #: config/rs6000/rs6000.opt:362 -#, fuzzy -#| msgid "Deprecated option. Use -mspe instead" msgid "Deprecated option. Use -mspe instead." -msgstr "Undanbedd flagga. Använd -mspe istället" +msgstr "Undanbedd flagga. Använd -mspe istället." #: config/rs6000/rs6000.opt:366 -#, fuzzy -#| msgid "-mdebug=\tEnable debug output" msgid "-mdebug=\tEnable debug output." -msgstr "-mdebug=\tAktivera felsökningsutdata" +msgstr "-mdebug=\tAktivera felsökningsutdata." #: config/rs6000/rs6000.opt:370 -#, fuzzy -#| msgid "Use the AltiVec ABI extensions" msgid "Use the AltiVec ABI extensions." -msgstr "Använd ABI-utökningarna AltiVec" +msgstr "Använd ABI-utökningarna AltiVec." #: config/rs6000/rs6000.opt:374 -#, fuzzy -#| msgid "Do not use the AltiVec ABI extensions" msgid "Do not use the AltiVec ABI extensions." -msgstr "Använd inte ABI-utökningarna AltiVec" +msgstr "Använd inte ABI-utökningarna AltiVec." #: config/rs6000/rs6000.opt:378 -#, fuzzy -#| msgid "Use the SPE ABI extensions" msgid "Use the SPE ABI extensions." -msgstr "Använd ABI-utökningarna SPE" +msgstr "Använd ABI-utökningarna SPE." #: config/rs6000/rs6000.opt:382 -#, fuzzy -#| msgid "Do not use the SPE ABI extensions" msgid "Do not use the SPE ABI extensions." -msgstr "Använd inte ABI-utökningarna SPE" +msgstr "Använd inte ABI-utökningarna SPE." #: config/rs6000/rs6000.opt:386 -#, fuzzy -#| msgid "Use the ELFv1 ABI" msgid "Use the ELFv1 ABI." -msgstr "Använd ELFv1 ABI" +msgstr "Använd ELFv1 ABI." #: config/rs6000/rs6000.opt:390 -#, fuzzy -#| msgid "Use the ELFv2 ABI" msgid "Use the ELFv2 ABI." -msgstr "Använd ELFv2 ABI" +msgstr "Använd ELFv2 ABI." #: config/rs6000/rs6000.opt:397 msgid "using darwin64 ABI" @@ -12442,114 +10321,80 @@ msgid "using IBM extended precision long double" msgstr "använder long double med IBM:s utökade precision" #: config/rs6000/rs6000.opt:410 -#, fuzzy -#| msgid "-mcpu=\tUse features of and schedule code for given CPU" msgid "-mcpu=\tUse features of and schedule code for given CPU." -msgstr "-mcpu=\tAnvänd funktioner i och schemalägg kod för angiven CPU" +msgstr "-mcpu=\tAnvänd funktioner i och schemalägg kod för angiven CPU." #: config/rs6000/rs6000.opt:414 -#, fuzzy -#| msgid "-mtune=\tSchedule code for given CPU" msgid "-mtune=\tSchedule code for given CPU." -msgstr "-mtune=\tSchemalägg kod för en given CPU" +msgstr "-mtune=\tSchemalägg kod för en given CPU." #: config/rs6000/rs6000.opt:418 -#, fuzzy -#| msgid "-mtraceback=\tSelect full, part, or no traceback table" msgid "-mtraceback=\tSelect full, part, or no traceback table." -msgstr "-mtraceback=\tVälj fullständig, partiell, eller ingen bakåtspårningstabell" +msgstr "-mtraceback=\tVälj fullständig, partiell, eller ingen bakåtspårningstabell." #: config/rs6000/rs6000.opt:434 -#, fuzzy -#| msgid "Avoid all range limits on call instructions" msgid "Avoid all range limits on call instructions." -msgstr "Undvik alla avståndsgränser vid anropsinstruktioner" +msgstr "Undvik alla avståndsgränser vid anropsinstruktioner." #: config/rs6000/rs6000.opt:438 -#, fuzzy -#| msgid "Generate Cell microcode" msgid "Generate Cell microcode." -msgstr "Generera Cell-mikrokod" +msgstr "Generera Cell-mikrokod." #: config/rs6000/rs6000.opt:442 -#, fuzzy -#| msgid "Warn when a Cell microcoded instruction is emitted" msgid "Warn when a Cell microcoded instruction is emitted." -msgstr "Varna när en Cell-mikrokodsinstruktion avges" +msgstr "Varna när en Cell-mikrokodsinstruktion avges." #: config/rs6000/rs6000.opt:446 -#, fuzzy -#| msgid "Warn about deprecated 'vector long ...' AltiVec type usage" msgid "Warn about deprecated 'vector long ...' AltiVec type usage." -msgstr "Varna för användning av AltiVec-typen ”vector long ...” som bör undvikas" +msgstr "Varna för användning av AltiVec-typen ”vector long ...” som bör undvikas." #: config/rs6000/rs6000.opt:450 -#, fuzzy -#| msgid "-mfloat-gprs=\tSelect GPR floating point method" msgid "-mfloat-gprs=\tSelect GPR floating point method." -msgstr "-mfloat-gprs=\tVälj GPR-flyttalsmetod" +msgstr "-mfloat-gprs=\tVälj GPR-flyttalsmetod." #: config/rs6000/rs6000.opt:454 msgid "Valid arguments to -mfloat-gprs=:" msgstr "Giltiga argument till -mfloat-gprs=:" #: config/rs6000/rs6000.opt:470 -#, fuzzy -#| msgid "-mlong-double-\tSpecify size of long double (64 or 128 bits)" msgid "-mlong-double-\tSpecify size of long double (64 or 128 bits)." -msgstr "-mlong-double-\tAnge storlek på long double (64 eller 128 bitar)" +msgstr "-mlong-double-\tAnge storlek på long double (64 eller 128 bitar)." #: config/rs6000/rs6000.opt:478 -#, fuzzy -#| msgid "Determine which dependences between insns are considered costly" msgid "Determine which dependences between insns are considered costly." -msgstr "Ange vilka beroenden mellan instruktioner som skall anses dyra" +msgstr "Ange vilka beroenden mellan instruktioner som skall anses dyra." #: config/rs6000/rs6000.opt:482 -#, fuzzy -#| msgid "Specify which post scheduling nop insertion scheme to apply" msgid "Specify which post scheduling nop insertion scheme to apply." -msgstr "Ange metod att tillämpa för inskjutande av nop efter schemaläggning" +msgstr "Ange metod att tillämpa för inskjutande av nop efter schemaläggning." #: config/rs6000/rs6000.opt:486 -#, fuzzy -#| msgid "Specify alignment of structure fields default/natural" msgid "Specify alignment of structure fields default/natural." -msgstr "Ange justering av postfält till default/natural" +msgstr "Ange justering av postfält till default/natural." #: config/rs6000/rs6000.opt:490 msgid "Valid arguments to -malign-:" msgstr "Giltiga argument till -malign-:" #: config/rs6000/rs6000.opt:500 -#, fuzzy -#| msgid "Specify scheduling priority for dispatch slot restricted insns" msgid "Specify scheduling priority for dispatch slot restricted insns." -msgstr "Ange schemaläggningsprioritet för begränsade instruktioner för avsändningsfack" +msgstr "Ange schemaläggningsprioritet för begränsade instruktioner för avsändningsfack." #: config/rs6000/rs6000.opt:504 -#, fuzzy -#| msgid "Single-precision floating point unit" msgid "Single-precision floating point unit." -msgstr "Enkelprecisions flyttalsenhet" +msgstr "Enkelprecisions flyttalsenhet." #: config/rs6000/rs6000.opt:508 -#, fuzzy -#| msgid "Double-precision floating point unit" msgid "Double-precision floating point unit." -msgstr "Dubbelprecisions flyttalsenhet" +msgstr "Dubbelprecisions flyttalsenhet." #: config/rs6000/rs6000.opt:512 -#, fuzzy -#| msgid "Floating point unit does not support divide & sqrt" msgid "Floating point unit does not support divide & sqrt." -msgstr "Flyttalsenheten stödjer inte division & kvadratrot" +msgstr "Flyttalsenheten stödjer inte division & kvadratrot." #: config/rs6000/rs6000.opt:516 -#, fuzzy -#| msgid "-mfpu=\tSpecify FP (sp, dp, sp-lite, dp-lite) (implies -mxilinx-fpu)" msgid "-mfpu=\tSpecify FP (sp, dp, sp-lite, dp-lite) (implies -mxilinx-fpu)." -msgstr "-mfpu=\tAnge FP (sp, dp, sp-lite, dp-lite) (implicerar -mxilinx-fpu)" +msgstr "-mfpu=\tAnge FP (sp, dp, sp-lite, dp-lite) (implicerar -mxilinx-fpu)." #: config/rs6000/rs6000.opt:538 msgid "Specify Xilinx FPU." @@ -12560,50 +10405,36 @@ msgid "Use/do not use r11 to hold the static link in calls to functions via poin msgstr "Använd/använd inte r11 för att hålla den statiska länken i anrop till funktioner via pekare." #: config/rs6000/rs6000.opt:546 -#, fuzzy -#| msgid "Control whether we save the TOC in the prologue for indirect calls or generate the save inline" msgid "Control whether we save the TOC in the prologue for indirect calls or generate the save inline." -msgstr "Bestäm huruvida vi sparar TOC:en i prologen för indirekta anrop eller genererar sparandet inline" +msgstr "Bestäm huruvida vi sparar TOC:en i prologen för indirekta anrop eller genererar sparandet inline." #: config/rs6000/rs6000.opt:550 -#, fuzzy -#| msgid "Allow 128-bit integers in VSX registers" msgid "Allow 128-bit integers in VSX registers." -msgstr "Tillåt 128-bitars heltal i VSX-register" +msgstr "Tillåt 128-bitars heltal i VSX-register." #: config/rs6000/rs6000.opt:554 -#, fuzzy -#| msgid "Fuse certain integer operations together for better performance on power8" msgid "Fuse certain integer operations together for better performance on power8." -msgstr "Smält samman vissa heltalsoperationer för bättre prestanda på power8" +msgstr "Smält samman vissa heltalsoperationer för bättre prestanda på power8." #: config/rs6000/rs6000.opt:558 -#, fuzzy -#| msgid "Allow sign extension in fusion operations" msgid "Allow sign extension in fusion operations." -msgstr "Tillåt teckenutökning i sammanslagningsoperationer" +msgstr "Tillåt teckenutökning i sammanslagningsoperationer." #: config/rs6000/rs6000.opt:562 msgid "Use/do not use vector and scalar instructions added in ISA 2.07." msgstr "Använd/använd inte vektor och skalära instruktioner som lades till i ISA 2.07." #: config/rs6000/rs6000.opt:566 -#, fuzzy -#| msgid "Use ISA 2.07 Category:Vector.AES and Category:Vector.SHA2 instructions" msgid "Use ISA 2.07 Category:Vector.AES and Category:Vector.SHA2 instructions." -msgstr "Använd ISA 2.07 instruktioner Category:Vector.AES och Category:Vector.SHA2" +msgstr "Använd ISA 2.07 instruktioner Category:Vector.AES och Category:Vector.SHA2." #: config/rs6000/rs6000.opt:570 -#, fuzzy -#| msgid "Use ISA 2.07 direct move between GPR & VSX register instructions" msgid "Use ISA 2.07 direct move between GPR & VSX register instructions." -msgstr "Använd ISA 2.07:s direkta förflyttning mellan GPR- och VSX-registerinstruktioner" +msgstr "Använd ISA 2.07:s direkta förflyttning mellan GPR- och VSX-registerinstruktioner." #: config/rs6000/rs6000.opt:574 -#, fuzzy -#| msgid "Use ISA 2.07 transactional memory (HTM) instructions" msgid "Use ISA 2.07 transactional memory (HTM) instructions." -msgstr "Använd ISA 2.07 transaktionsminnesinstruktioner (HTM)" +msgstr "Använd ISA 2.07 transaktionsminnesinstruktioner (HTM)." #: config/rs6000/rs6000.opt:578 msgid "Generate the quad word memory instructions (lq/stq)." @@ -12618,426 +10449,294 @@ msgid "Generate aggregate parameter passing code with at most 64-bit alignment." msgstr "Generera kod för att skicka aggregerade parametrar med som mes 64-bitars justering." #: config/rs6000/rs6000.opt:590 -#, fuzzy -#| msgid "Allow double variables in upper registers with -mcpu=power7 or -mvsx" msgid "Allow double variables in upper registers with -mcpu=power7 or -mvsx." -msgstr "Tillåt double-variabler i övre register med -mcpu=power7 eller -mvsx" +msgstr "Tillåt double-variabler i övre register med -mcpu=power7 eller -mvsx." #: config/rs6000/rs6000.opt:594 -#, fuzzy -#| msgid "Allow float variables in upper registers with -mcpu=power8 or -mpower8-vector" msgid "Allow float variables in upper registers with -mcpu=power8 or -mpower8-vector." -msgstr "Tillåt flyttalsvariabler i övre register med -mcpu=power8 eller mpower8-vector" +msgstr "Tillåt flyttalsvariabler i övre register med -mcpu=power8 eller mpower8-vector." #: config/rs6000/rs6000.opt:598 -#, fuzzy -#| msgid "Allow float/double variables in upper registers if cpu allows it" msgid "Allow float/double variables in upper registers if cpu allows it." -msgstr "Tillåt float/double-variabler i övre register om cpu:n tillåter det" +msgstr "Tillåt float/double-variabler i övre register om cpu:n tillåter det." #: config/rs6000/rs6000.opt:602 msgid "Analyze and remove doubleword swaps from VSX computations." msgstr "Analysera och ta bort dubbelordsbyten från VSX-beräkningar." #: config/rs6000/rs6000.opt:606 -#, fuzzy -#| msgid "Fuse certain integer operations together for better performance on power8" msgid "Fuse certain operations together for better performance on power9." -msgstr "Smält samman vissa heltalsoperationer för bättre prestanda på power8" +msgstr "Smält samman vissa operationer för bättre prestanda på power9." #: config/rs6000/rs6000.opt:610 config/rs6000/rs6000.opt:614 -#, fuzzy -#| msgid "Use/do not use vector and scalar instructions added in ISA 2.07." msgid "Use/do not use vector and scalar instructions added in ISA 3.0." -msgstr "Använd/använd inte vektor och skalära instruktioner som lades till i ISA 2.07." +msgstr "Använd/använd inte vektor- och skalära instruktioner som lades till i ISA 3.0." #: config/rs6000/rs6000.opt:618 -#, fuzzy -#| msgid "Use/do not use vector and scalar instructions added in ISA 2.07." msgid "Use/do not use the new min/max instructions defined in ISA 3.0." -msgstr "Använd/använd inte vektor och skalära instruktioner som lades till i ISA 2.07." +msgstr "Använd/använd inte de nya min-/maxinstruktionerna som definierades i ISA 3.0." #: config/rs6000/rs6000.opt:622 msgid "Fuse medium/large code model toc references with the memory instruction." msgstr "Slå samman medium/stor modellers toc-referenser med minnesinstruktionen." #: config/rs6000/rs6000.opt:626 -#, fuzzy -#| msgid "Generate isel instructions" msgid "Generate the integer modulo instructions." -msgstr "Generera isel-instruktioner" +msgstr "Generera heltalsmoduloinstruktioner." #: config/rs6000/rs6000.opt:630 msgid "Enable/disable IEEE 128-bit floating point via the __float128 keyword." msgstr "Aktivera/avaktivera IEEE 128-bitars flyttal via nyckelordet __float128." #: config/rs6000/rs6000.opt:634 -#, fuzzy -#| msgid "Use decimal floating point instructions" msgid "Enable/disable using IEEE 128-bit floating point instructions." -msgstr "Använd decimala flyttalsinstruktioner" +msgstr "Aktivera/avaktivera användning av IEEE 128-bitars flyttalsinstruktioner." #: config/rs6000/rs6000.opt:638 msgid "Enable/disable default conversions between __float128 & long double." msgstr "Aktivera/avaktivera standardkonvertering mellan __float128 & long double." #: config/rs6000/sysv4.opt:24 -#, fuzzy -#| msgid "Select ABI calling convention" msgid "Select ABI calling convention." -msgstr "Välj ABI-konvention för anrop" +msgstr "Välj ABI-konvention för anrop." #: config/rs6000/sysv4.opt:28 config/c6x/c6x.opt:42 -#, fuzzy -#| msgid "Select method for sdata handling" msgid "Select method for sdata handling." -msgstr "Välj metod för hantering av sdata" +msgstr "Välj metod för hantering av sdata." #: config/rs6000/sysv4.opt:48 config/rs6000/sysv4.opt:52 -#, fuzzy -#| msgid "Align to the base type of the bit-field" msgid "Align to the base type of the bit-field." -msgstr "Justera till bastypen av bitfältet" +msgstr "Justera till bastypen av bitfältet." #: config/rs6000/sysv4.opt:57 config/rs6000/sysv4.opt:61 -#, fuzzy -#| msgid "Produce code relocatable at runtime" msgid "Produce code relocatable at runtime." -msgstr "Producera kod som kan omlokaliseras vid körtillfället" +msgstr "Producera kod som kan omlokaliseras vid körtillfället." #: config/rs6000/sysv4.opt:65 config/rs6000/sysv4.opt:69 -#, fuzzy -#| msgid "Produce little endian code" msgid "Produce little endian code." -msgstr "Producera kod med omvänd byteordning" +msgstr "Producera kod med omvänd byteordning." #: config/rs6000/sysv4.opt:73 config/rs6000/sysv4.opt:77 -#, fuzzy -#| msgid "Produce big endian code" msgid "Produce big endian code." -msgstr "Producera kod med rak byteordning" +msgstr "Producera kod med rak byteordning." #: config/rs6000/sysv4.opt:82 config/rs6000/sysv4.opt:86 #: config/rs6000/sysv4.opt:95 config/rs6000/sysv4.opt:137 #: config/rs6000/sysv4.opt:149 -#, fuzzy -#| msgid "no description yet" msgid "no description yet." -msgstr "ingen beskrivning ännu" +msgstr "ingen beskrivning ännu." #: config/rs6000/sysv4.opt:90 -#, fuzzy -#| msgid "Assume all variable arg functions are prototyped" msgid "Assume all variable arg functions are prototyped." -msgstr "Anta att alla funktioner med variabelt antal argument har prototyp" +msgstr "Anta att alla funktioner med variabelt antal argument har prototyp." #: config/rs6000/sysv4.opt:99 -#, fuzzy -#| msgid "Use EABI" msgid "Use EABI." -msgstr "Använd EABI" +msgstr "Använd EABI." #: config/rs6000/sysv4.opt:103 -#, fuzzy -#| msgid "Allow bit-fields to cross word boundaries" msgid "Allow bit-fields to cross word boundaries." -msgstr "Tillåt att bitfält går över ordgränser" +msgstr "Tillåt att bitfält går över ordgränser." #: config/rs6000/sysv4.opt:107 -#, fuzzy -#| msgid "Use alternate register names" msgid "Use alternate register names." -msgstr "Använd alternativa registernamn" +msgstr "Använd alternativa registernamn." #: config/rs6000/sysv4.opt:113 -#, fuzzy -#| msgid "Use default method for sdata handling" msgid "Use default method for sdata handling." -msgstr "Använd standardmetod för hantering av sdata" +msgstr "Använd standardmetod för hantering av sdata." #: config/rs6000/sysv4.opt:117 -#, fuzzy -#| msgid "Link with libsim.a, libc.a and sim-crt0.o" msgid "Link with libsim.a, libc.a and sim-crt0.o." -msgstr "Länka med libsim.a, libc.a och sim-crt0.o" +msgstr "Länka med libsim.a, libc.a och sim-crt0.o." #: config/rs6000/sysv4.opt:121 -#, fuzzy -#| msgid "Link with libads.a, libc.a and crt0.o" msgid "Link with libads.a, libc.a and crt0.o." -msgstr "Länka med libads.a, libc.a och crt0.o" +msgstr "Länka med libads.a, libc.a och crt0.o." #: config/rs6000/sysv4.opt:125 -#, fuzzy -#| msgid "Link with libyk.a, libc.a and crt0.o" msgid "Link with libyk.a, libc.a and crt0.o." -msgstr "Länka med libyk.a, libc.a och crt0.o" +msgstr "Länka med libyk.a, libc.a och crt0.o." #: config/rs6000/sysv4.opt:129 -#, fuzzy -#| msgid "Link with libmvme.a, libc.a and crt0.o" msgid "Link with libmvme.a, libc.a and crt0.o." -msgstr "Länka med libmvme.a, libc.a och crt0.o" +msgstr "Länka med libmvme.a, libc.a och crt0.o." #: config/rs6000/sysv4.opt:133 -#, fuzzy -#| msgid "Set the PPC_EMB bit in the ELF flags header" msgid "Set the PPC_EMB bit in the ELF flags header." -msgstr "Sätt biten PPC_EMB i ELF:s flaggfält" +msgstr "Sätt biten PPC_EMB i ELF:s flaggfält." #: config/rs6000/sysv4.opt:153 -#, fuzzy -#| msgid "Generate code to use a non-exec PLT and GOT" msgid "Generate code to use a non-exec PLT and GOT." -msgstr "Generera kod för att använda ej-exec PLT och GOT" +msgstr "Generera kod för att använda ej-exec PLT och GOT." #: config/rs6000/sysv4.opt:157 -#, fuzzy -#| msgid "Generate code for old exec BSS PLT" msgid "Generate code for old exec BSS PLT." -msgstr "Generera kod för gammal exec BSS PLT" +msgstr "Generera kod för gammal exec BSS PLT." #: config/alpha/alpha.opt:27 -#, fuzzy -#| msgid "Use fp registers" msgid "Use fp registers." -msgstr "Använd fp-register" +msgstr "Använd fp-register." #: config/alpha/alpha.opt:35 -#, fuzzy -#| msgid "Request IEEE-conformant math library routines (OSF/1)" msgid "Request IEEE-conformant math library routines (OSF/1)." -msgstr "Begär matematikbiblioteksfunktioner som följer IEEE (OSF/1)" +msgstr "Begär matematikbiblioteksfunktioner som följer IEEE (OSF/1)." #: config/alpha/alpha.opt:39 -#, fuzzy -#| msgid "Emit IEEE-conformant code, without inexact exceptions" msgid "Emit IEEE-conformant code, without inexact exceptions." -msgstr "Avge kod som följer IEEE, utan oexakta undantag" +msgstr "Avge kod som följer IEEE, utan oexakta undantag." #: config/alpha/alpha.opt:46 -#, fuzzy -#| msgid "Do not emit complex integer constants to read-only memory" msgid "Do not emit complex integer constants to read-only memory." -msgstr "Avge inte komplexa heltalskonstanter till endast läsbart minne" +msgstr "Avge inte komplexa heltalskonstanter till endast läsbart minne." #: config/alpha/alpha.opt:50 -#, fuzzy -#| msgid "Use VAX fp" msgid "Use VAX fp." -msgstr "Använd VAX fp" +msgstr "Använd VAX fp." #: config/alpha/alpha.opt:54 -#, fuzzy -#| msgid "Do not use VAX fp" msgid "Do not use VAX fp." -msgstr "Använd inte VAX fp" +msgstr "Använd inte VAX fp." #: config/alpha/alpha.opt:58 -#, fuzzy -#| msgid "Emit code for the byte/word ISA extension" msgid "Emit code for the byte/word ISA extension." -msgstr "Avge kod för byte/ord-ISA-utökningen" +msgstr "Avge kod för byte/ord-ISA-utökningen." #: config/alpha/alpha.opt:62 -#, fuzzy -#| msgid "Emit code for the motion video ISA extension" msgid "Emit code for the motion video ISA extension." -msgstr "Avge kod för ISA-utökningen för rörlig video" +msgstr "Avge kod för ISA-utökningen för rörlig video." #: config/alpha/alpha.opt:66 -#, fuzzy -#| msgid "Emit code for the fp move and sqrt ISA extension" msgid "Emit code for the fp move and sqrt ISA extension." -msgstr "Avge kod för ISA-utökningen för fp move och sqrt" +msgstr "Avge kod för ISA-utökningen för fp move och sqrt." #: config/alpha/alpha.opt:70 -#, fuzzy -#| msgid "Emit code for the counting ISA extension" msgid "Emit code for the counting ISA extension." -msgstr "Avge kod för ISA-utökningen för räkning" +msgstr "Avge kod för ISA-utökningen för räkning." #: config/alpha/alpha.opt:74 -#, fuzzy -#| msgid "Emit code using explicit relocation directives" msgid "Emit code using explicit relocation directives." -msgstr "Avge kod som använder uttryckliga omlokaliseringsdirektiv" +msgstr "Avge kod som använder uttryckliga omlokaliseringsdirektiv." #: config/alpha/alpha.opt:78 -#, fuzzy -#| msgid "Emit 16-bit relocations to the small data areas" msgid "Emit 16-bit relocations to the small data areas." -msgstr "Avge 16-bitars omlokaliseringar till de små dataareorna" +msgstr "Avge 16-bitars omlokaliseringar till de små dataareorna." #: config/alpha/alpha.opt:82 -#, fuzzy -#| msgid "Emit 32-bit relocations to the small data areas" msgid "Emit 32-bit relocations to the small data areas." -msgstr "Avge 32-bitars omlokaliseringar till de små dataareorna" +msgstr "Avge 32-bitars omlokaliseringar till de små dataareorna." #: config/alpha/alpha.opt:86 -#, fuzzy -#| msgid "Emit direct branches to local functions" msgid "Emit direct branches to local functions." -msgstr "Mata ut direkta hopp till lokala funktioner" +msgstr "Mata ut direkta hopp till lokala funktioner." #: config/alpha/alpha.opt:90 -#, fuzzy -#| msgid "Emit indirect branches to local functions" msgid "Emit indirect branches to local functions." -msgstr "Mata ut indirekta hopp till lokala funktioner" +msgstr "Mata ut indirekta hopp till lokala funktioner." #: config/alpha/alpha.opt:94 -#, fuzzy -#| msgid "Emit rdval instead of rduniq for thread pointer" msgid "Emit rdval instead of rduniq for thread pointer." -msgstr "Avge rdval istället för rduniq för trådpekare" +msgstr "Avge rdval istället för rduniq för trådpekare." #: config/alpha/alpha.opt:106 -#, fuzzy -#| msgid "Use features of and schedule given CPU" msgid "Use features of and schedule given CPU." -msgstr "Använd funktioner i och schemalägg för angiven CPU" +msgstr "Använd funktioner i och schemalägg för angiven CPU." #: config/alpha/alpha.opt:110 -#, fuzzy -#| msgid "Schedule given CPU" msgid "Schedule given CPU." -msgstr "Schemalägg för given CPU" +msgstr "Schemalägg för given CPU." #: config/alpha/alpha.opt:114 -#, fuzzy -#| msgid "Control the generated fp rounding mode" msgid "Control the generated fp rounding mode." -msgstr "Styr det genererade fp-avrundningsläget" +msgstr "Styr det genererade fp-avrundningsläget." #: config/alpha/alpha.opt:118 -#, fuzzy -#| msgid "Control the IEEE trap mode" msgid "Control the IEEE trap mode." -msgstr "Styr IEEE-läge för fällor" +msgstr "Styr IEEE-läge för fällor." #: config/alpha/alpha.opt:122 -#, fuzzy -#| msgid "Control the precision given to fp exceptions" msgid "Control the precision given to fp exceptions." -msgstr "Styr precisionen som ges till fp-undantag" +msgstr "Styr precisionen som ges till fp-undantag." #: config/alpha/alpha.opt:126 -#, fuzzy -#| msgid "Tune expected memory latency" msgid "Tune expected memory latency." -msgstr "Trimma förväntad minneslatens" +msgstr "Trimma förväntad minneslatens." #: config/tilepro/tilepro.opt:23 msgid "Compile with 32 bit longs and pointers, which is the only supported" msgstr "Kompilera med 32-bitars long och pekare, som är det enda som stödjs" #: config/tilepro/tilepro.opt:28 config/tilegx/tilegx.opt:26 -#, fuzzy -#| msgid "-mcpu=CPU\tUse features of and schedule code for given CPU" msgid "-mcpu=CPU\tUse features of and schedule code for given CPU." -msgstr "-mcpu=CPU\tAnvänd funktioner i och schemalägg kod för angiven CPU" +msgstr "-mcpu=CPU\tAnvänd funktioner i och schemalägg kod för angiven CPU." #: config/tilepro/tilepro.opt:32 msgid "Known TILEPro CPUs (for use with the -mcpu= option):" msgstr "Kända TILEPro-CPU:er (att användas med flaggan -mcpu=):" #: config/lm32/lm32.opt:24 -#, fuzzy -#| msgid "Enable multiply instructions" msgid "Enable multiply instructions." -msgstr "Använd multiplikationsinstruktioner" +msgstr "Använd multiplikationsinstruktioner." #: config/lm32/lm32.opt:28 -#, fuzzy -#| msgid "Enable divide and modulus instructions" msgid "Enable divide and modulus instructions." -msgstr "Använd divisions- och modulusinstruktioner" +msgstr "Använd divisions- och modulusinstruktioner." #: config/lm32/lm32.opt:32 -#, fuzzy -#| msgid "Enable barrel shift instructions" msgid "Enable barrel shift instructions." -msgstr "Använd barrel-shift-instruktioner" +msgstr "Använd barrel-shift-instruktioner." #: config/lm32/lm32.opt:36 -#, fuzzy -#| msgid "Enable sign extend instructions" msgid "Enable sign extend instructions." -msgstr "Aktivera teckenutökningsinstruktioner" +msgstr "Aktivera teckenutökningsinstruktioner." #: config/lm32/lm32.opt:40 -#, fuzzy -#| msgid "Enable user-defined instructions" msgid "Enable user-defined instructions." -msgstr "Använd användardefinierade instruktioner" +msgstr "Använd användardefinierade instruktioner." #: config/nios2/elf.opt:26 -#, fuzzy -#| msgid "Link with a limited version of the C library" msgid "Link with a limited version of the C library." -msgstr "Länka med en begränsad version av C-biblioteket" +msgstr "Länka med en begränsad version av C-biblioteket." #: config/nios2/elf.opt:30 -#, fuzzy -#| msgid "Name of system library to link against" msgid "Name of system library to link against." -msgstr "Namn på systembiblioteket att länka mot" +msgstr "Namn på systembiblioteket att länka mot." #: config/nios2/elf.opt:34 -#, fuzzy -#| msgid "Name of the startfile" msgid "Name of the startfile." -msgstr "Namn på startfilen" +msgstr "Namn på startfilen." #: config/nios2/elf.opt:38 -#, fuzzy -#| msgid "Link with HAL BSP" msgid "Link with HAL BSP." -msgstr "Länka med HAL BSP" +msgstr "Länka med HAL BSP." #: config/nios2/nios2.opt:35 -#, fuzzy -#| msgid "Enable DIV, DIVU" msgid "Enable DIV, DIVU." -msgstr "Aktivera DIV, DIVU" +msgstr "Aktivera DIV, DIVU." #: config/nios2/nios2.opt:39 -#, fuzzy -#| msgid "Enable MUL instructions" msgid "Enable MUL instructions." -msgstr "Använd MUL-instruktioner" +msgstr "Använd MUL-instruktioner." #: config/nios2/nios2.opt:43 -#, fuzzy -#| msgid "Enable MULX instructions, assume fast shifter" msgid "Enable MULX instructions, assume fast shifter." -msgstr "Använd MULX-instruktioner, anta snabb skiftare" +msgstr "Använd MULX-instruktioner, anta snabb skiftare." #: config/nios2/nios2.opt:47 -#, fuzzy -#| msgid "Use table based fast divide (default at -O3)" msgid "Use table based fast divide (default at -O3)." -msgstr "Använd tabellbaserad snabb division (standard för -O3)" +msgstr "Använd tabellbaserad snabb division (standard för -O3)." #: config/nios2/nios2.opt:51 -#, fuzzy -#| msgid "All memory accesses use I/O load/store instructions" msgid "All memory accesses use I/O load/store instructions." -msgstr "Alla minnesåtkomster använder I/O ladda-/lagrainstruktioner" +msgstr "Alla minnesåtkomster använder I/O ladda-/lagrainstruktioner." #: config/nios2/nios2.opt:55 -#, fuzzy -#| msgid "Volatile memory accesses use I/O load/store instructions" msgid "Volatile memory accesses use I/O load/store instructions." -msgstr "Volatila minnesåtkomster använder I/O ladda-/lagrainstruktioner" +msgstr "Volatila minnesåtkomster använder I/O ladda-/lagrainstruktioner." #: config/nios2/nios2.opt:59 -#, fuzzy -#| msgid "Volatile memory accesses do not use I/O load/store instructions" msgid "Volatile memory accesses do not use I/O load/store instructions." -msgstr "Volatila minnesåtkomster använder inte I/O ladda-/lagrainstruktioner" +msgstr "Volatila minnesåtkomster använder inte I/O ladda-/lagrainstruktioner." #: config/nios2/nios2.opt:63 msgid "Enable/disable GP-relative addressing." @@ -13066,722 +10765,484 @@ msgid "Use little-endian byte order." msgstr "Använd omvänd byteordning." #: config/nios2/nios2.opt:102 -#, fuzzy -#| msgid "Floating point custom instruction configuration name" msgid "Floating point custom instruction configuration name." -msgstr "Namn på anpassad instruktionskonfiguration för flyttal" +msgstr "Namn på anpassad instruktionskonfiguration för flyttal." #: config/nios2/nios2.opt:106 -#, fuzzy -#| msgid "Do not use the ftruncds custom instruction" msgid "Do not use the ftruncds custom instruction." -msgstr "Använd inte den anpassade instruktionen ftruncds" +msgstr "Använd inte den anpassade instruktionen ftruncds." #: config/nios2/nios2.opt:110 -#, fuzzy -#| msgid "Integer id (N) of ftruncds custom instruction" msgid "Integer id (N) of ftruncds custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion ftruncds" +msgstr "Heltals-id (N) för anpassad instruktion ftruncds." #: config/nios2/nios2.opt:114 -#, fuzzy -#| msgid "Do not use the fextsd custom instruction" msgid "Do not use the fextsd custom instruction." -msgstr "Använd inte den anpassade instruktionen fextsd" +msgstr "Använd inte den anpassade instruktionen fextsd." #: config/nios2/nios2.opt:118 -#, fuzzy -#| msgid "Integer id (N) of fextsd custom instruction" msgid "Integer id (N) of fextsd custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fextsd" +msgstr "Heltals-id (N) för anpassad instruktion fextsd." #: config/nios2/nios2.opt:122 -#, fuzzy -#| msgid "Do not use the fixdu custom instruction" msgid "Do not use the fixdu custom instruction." -msgstr "Använd inte den anpassade instruktionen fixdu" +msgstr "Använd inte den anpassade instruktionen fixdu." #: config/nios2/nios2.opt:126 -#, fuzzy -#| msgid "Integer id (N) of fixdu custom instruction" msgid "Integer id (N) of fixdu custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fixdu" +msgstr "Heltals-id (N) för anpassad instruktion fixdu." #: config/nios2/nios2.opt:130 -#, fuzzy -#| msgid "Do not use the fixdi custom instruction" msgid "Do not use the fixdi custom instruction." -msgstr "Använd inte den anpassade instruktionen fixdi" +msgstr "Använd inte den anpassade instruktionen fixdi." #: config/nios2/nios2.opt:134 -#, fuzzy -#| msgid "Integer id (N) of fixdi custom instruction" msgid "Integer id (N) of fixdi custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fixdi" +msgstr "Heltals-id (N) för anpassad instruktion fixdi." #: config/nios2/nios2.opt:138 -#, fuzzy -#| msgid "Do not use the fixsu custom instruction" msgid "Do not use the fixsu custom instruction." -msgstr "Använd inte den anpassade instruktionen fixsu" +msgstr "Använd inte den anpassade instruktionen fixsu." #: config/nios2/nios2.opt:142 -#, fuzzy -#| msgid "Integer id (N) of fixsu custom instruction" msgid "Integer id (N) of fixsu custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fixsu" +msgstr "Heltals-id (N) för anpassad instruktion fixsu." #: config/nios2/nios2.opt:146 -#, fuzzy -#| msgid "Do not use the fixsi custom instruction" msgid "Do not use the fixsi custom instruction." -msgstr "Använd inte den anpassade instruktionen fixsi" +msgstr "Använd inte den anpassade instruktionen fixsi." #: config/nios2/nios2.opt:150 -#, fuzzy -#| msgid "Integer id (N) of fixsi custom instruction" msgid "Integer id (N) of fixsi custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fixsi" +msgstr "Heltals-id (N) för anpassad instruktion fixsi." #: config/nios2/nios2.opt:154 -#, fuzzy -#| msgid "Do not use the floatud custom instruction" msgid "Do not use the floatud custom instruction." -msgstr "Använd inte den anpassade instruktionen floatud" +msgstr "Använd inte den anpassade instruktionen floatud." #: config/nios2/nios2.opt:158 -#, fuzzy -#| msgid "Integer id (N) of floatud custom instruction" msgid "Integer id (N) of floatud custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion floatud" +msgstr "Heltals-id (N) för anpassad instruktion floatud." #: config/nios2/nios2.opt:162 -#, fuzzy -#| msgid "Do not use the floatid custom instruction" msgid "Do not use the floatid custom instruction." -msgstr "Använd inte den anpassade instruktionen floatid" +msgstr "Använd inte den anpassade instruktionen floatid." #: config/nios2/nios2.opt:166 -#, fuzzy -#| msgid "Integer id (N) of floatid custom instruction" msgid "Integer id (N) of floatid custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion floatid" +msgstr "Heltals-id (N) för anpassad instruktion floatid." #: config/nios2/nios2.opt:170 -#, fuzzy -#| msgid "Do not use the floatus custom instruction" msgid "Do not use the floatus custom instruction." -msgstr "Använd inte den anpassade instruktionen floatus" +msgstr "Använd inte den anpassade instruktionen floatus." #: config/nios2/nios2.opt:174 -#, fuzzy -#| msgid "Integer id (N) of floatus custom instruction" msgid "Integer id (N) of floatus custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion floatus" +msgstr "Heltals-id (N) för anpassad instruktion floatus." #: config/nios2/nios2.opt:178 -#, fuzzy -#| msgid "Do not use the floatis custom instruction" msgid "Do not use the floatis custom instruction." -msgstr "Använd inte den anpassade instruktionen floatis" +msgstr "Använd inte den anpassade instruktionen floatis." #: config/nios2/nios2.opt:182 -#, fuzzy -#| msgid "Integer id (N) of floatis custom instruction" msgid "Integer id (N) of floatis custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion floatis" +msgstr "Heltals-id (N) för anpassad instruktion floatis." #: config/nios2/nios2.opt:186 -#, fuzzy -#| msgid "Do not use the fcmpned custom instruction" msgid "Do not use the fcmpned custom instruction." -msgstr "Använd inte den anpassade instruktionen fcmpned" +msgstr "Använd inte den anpassade instruktionen fcmpned." #: config/nios2/nios2.opt:190 -#, fuzzy -#| msgid "Integer id (N) of fcmpned custom instruction" msgid "Integer id (N) of fcmpned custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fcmpned" +msgstr "Heltals-id (N) för anpassad instruktion fcmpned." #: config/nios2/nios2.opt:194 -#, fuzzy -#| msgid "Do not use the fcmpeqd custom instruction" msgid "Do not use the fcmpeqd custom instruction." -msgstr "Använd inte den anpassade instruktionen fcmpeqd" +msgstr "Använd inte den anpassade instruktionen fcmpeqd." #: config/nios2/nios2.opt:198 -#, fuzzy -#| msgid "Integer id (N) of fcmpeqd custom instruction" msgid "Integer id (N) of fcmpeqd custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fcmpeqd" +msgstr "Heltals-id (N) för anpassad instruktion fcmpeqd." #: config/nios2/nios2.opt:202 -#, fuzzy -#| msgid "Do not use the fcmpged custom instruction" msgid "Do not use the fcmpged custom instruction." -msgstr "Använd inte den anpassade instruktionen fcmpged" +msgstr "Använd inte den anpassade instruktionen fcmpged." #: config/nios2/nios2.opt:206 -#, fuzzy -#| msgid "Integer id (N) of fcmpged custom instruction" msgid "Integer id (N) of fcmpged custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fcmpged" +msgstr "Heltals-id (N) för anpassad instruktion fcmpged." #: config/nios2/nios2.opt:210 -#, fuzzy -#| msgid "Do not use the fcmpgtd custom instruction" msgid "Do not use the fcmpgtd custom instruction." -msgstr "Använd inte den anpassade instruktionen fcmpgtd" +msgstr "Använd inte den anpassade instruktionen fcmpgtd." #: config/nios2/nios2.opt:214 -#, fuzzy -#| msgid "Integer id (N) of fcmpgtd custom instruction" msgid "Integer id (N) of fcmpgtd custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fcmpgtd" +msgstr "Heltals-id (N) för anpassad instruktion fcmpgtd." #: config/nios2/nios2.opt:218 -#, fuzzy -#| msgid "Do not use the fcmpled custom instruction" msgid "Do not use the fcmpled custom instruction." -msgstr "Använd inte den anpassade instruktionen fcmpled" +msgstr "Använd inte den anpassade instruktionen fcmpled." #: config/nios2/nios2.opt:222 -#, fuzzy -#| msgid "Integer id (N) of fcmpled custom instruction" msgid "Integer id (N) of fcmpled custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fcmpled" +msgstr "Heltals-id (N) för anpassad instruktion fcmpled." #: config/nios2/nios2.opt:226 -#, fuzzy -#| msgid "Do not use the fcmpltd custom instruction" msgid "Do not use the fcmpltd custom instruction." -msgstr "Använd inte den anpassade instruktionen fcmpltd" +msgstr "Använd inte den anpassade instruktionen fcmpltd." #: config/nios2/nios2.opt:230 -#, fuzzy -#| msgid "Integer id (N) of fcmpltd custom instruction" msgid "Integer id (N) of fcmpltd custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fcmpltd" +msgstr "Heltals-id (N) för anpassad instruktion fcmpltd." #: config/nios2/nios2.opt:234 -#, fuzzy -#| msgid "Do not use the flogd custom instruction" msgid "Do not use the flogd custom instruction." -msgstr "Använd inte den anpassade instruktionen flogd" +msgstr "Använd inte den anpassade instruktionen flogd." #: config/nios2/nios2.opt:238 -#, fuzzy -#| msgid "Integer id (N) of flogd custom instruction" msgid "Integer id (N) of flogd custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion flogd" +msgstr "Heltals-id (N) för anpassad instruktion flogd." #: config/nios2/nios2.opt:242 -#, fuzzy -#| msgid "Do not use the fexpd custom instruction" msgid "Do not use the fexpd custom instruction." -msgstr "Använd inte den anpassade instruktionen fexpd" +msgstr "Använd inte den anpassade instruktionen fexpd." #: config/nios2/nios2.opt:246 -#, fuzzy -#| msgid "Integer id (N) of fexpd custom instruction" msgid "Integer id (N) of fexpd custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fexpd" +msgstr "Heltals-id (N) för anpassad instruktion fexpd." #: config/nios2/nios2.opt:250 -#, fuzzy -#| msgid "Do not use the fatand custom instruction" msgid "Do not use the fatand custom instruction." -msgstr "Använd inte den anpassade instruktionen fatand" +msgstr "Använd inte den anpassade instruktionen fatand." #: config/nios2/nios2.opt:254 -#, fuzzy -#| msgid "Integer id (N) of fatand custom instruction" msgid "Integer id (N) of fatand custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fatand" +msgstr "Heltals-id (N) för anpassad instruktion fatand." #: config/nios2/nios2.opt:258 -#, fuzzy -#| msgid "Do not use the ftand custom instruction" msgid "Do not use the ftand custom instruction." -msgstr "Använd inte den anpassade instruktionen ftand" +msgstr "Använd inte den anpassade instruktionen ftand." #: config/nios2/nios2.opt:262 -#, fuzzy -#| msgid "Integer id (N) of ftand custom instruction" msgid "Integer id (N) of ftand custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion ftand" +msgstr "Heltals-id (N) för anpassad instruktion ftand." #: config/nios2/nios2.opt:266 -#, fuzzy -#| msgid "Do not use the fsind custom instruction" msgid "Do not use the fsind custom instruction." -msgstr "Använd inte den anpassade instruktionen fsind" +msgstr "Använd inte den anpassade instruktionen fsind." #: config/nios2/nios2.opt:270 -#, fuzzy -#| msgid "Integer id (N) of fsind custom instruction" msgid "Integer id (N) of fsind custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fsind" +msgstr "Heltals-id (N) för anpassad instruktion fsind." #: config/nios2/nios2.opt:274 -#, fuzzy -#| msgid "Do not use the fcosd custom instruction" msgid "Do not use the fcosd custom instruction." -msgstr "Använd inte den anpassade instruktionen fcosd" +msgstr "Använd inte den anpassade instruktionen fcosd." #: config/nios2/nios2.opt:278 -#, fuzzy -#| msgid "Integer id (N) of fcosd custom instruction" msgid "Integer id (N) of fcosd custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fcosd" +msgstr "Heltals-id (N) för anpassad instruktion fcosd." #: config/nios2/nios2.opt:282 -#, fuzzy -#| msgid "Do not use the fsqrtd custom instruction" msgid "Do not use the fsqrtd custom instruction." -msgstr "Använd inte den anpassade instruktionen fsqrtd" +msgstr "Använd inte den anpassade instruktionen fsqrtd." #: config/nios2/nios2.opt:286 -#, fuzzy -#| msgid "Integer id (N) of fsqrtd custom instruction" msgid "Integer id (N) of fsqrtd custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fsqrtd" +msgstr "Heltals-id (N) för anpassad instruktion fsqrtd." #: config/nios2/nios2.opt:290 -#, fuzzy -#| msgid "Do not use the fabsd custom instruction" msgid "Do not use the fabsd custom instruction." -msgstr "Använd inte den anpassade instruktionen fabsd" +msgstr "Använd inte den anpassade instruktionen fabsd." #: config/nios2/nios2.opt:294 -#, fuzzy -#| msgid "Integer id (N) of fabsd custom instruction" msgid "Integer id (N) of fabsd custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fabsd" +msgstr "Heltals-id (N) för anpassad instruktion fabsd." #: config/nios2/nios2.opt:298 -#, fuzzy -#| msgid "Do not use the fnegd custom instruction" msgid "Do not use the fnegd custom instruction." -msgstr "Använd inte den anpassade instruktionen fnegd" +msgstr "Använd inte den anpassade instruktionen fnegd." #: config/nios2/nios2.opt:302 -#, fuzzy -#| msgid "Integer id (N) of fnegd custom instruction" msgid "Integer id (N) of fnegd custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fnegd" +msgstr "Heltals-id (N) för anpassad instruktion fnegd." #: config/nios2/nios2.opt:306 -#, fuzzy -#| msgid "Do not use the fmaxd custom instruction" msgid "Do not use the fmaxd custom instruction." -msgstr "Använd inte den anpassade instruktionen fmaxd" +msgstr "Använd inte den anpassade instruktionen fmaxd." #: config/nios2/nios2.opt:310 -#, fuzzy -#| msgid "Integer id (N) of fmaxd custom instruction" msgid "Integer id (N) of fmaxd custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fmaxd" +msgstr "Heltals-id (N) för anpassad instruktion fmaxd." #: config/nios2/nios2.opt:314 -#, fuzzy -#| msgid "Do not use the fmind custom instruction" msgid "Do not use the fmind custom instruction." -msgstr "Använd inte den anpassade instruktionen fmind" +msgstr "Använd inte den anpassade instruktionen fmind." #: config/nios2/nios2.opt:318 -#, fuzzy -#| msgid "Integer id (N) of fmind custom instruction" msgid "Integer id (N) of fmind custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fmind" +msgstr "Heltals-id (N) för anpassad instruktion fmind." #: config/nios2/nios2.opt:322 -#, fuzzy -#| msgid "Do not use the fdivd custom instruction" msgid "Do not use the fdivd custom instruction." -msgstr "Använd inte den anpassade instruktionen fdivd" +msgstr "Använd inte den anpassade instruktionen fdivd." #: config/nios2/nios2.opt:326 -#, fuzzy -#| msgid "Integer id (N) of fdivd custom instruction" msgid "Integer id (N) of fdivd custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fdivd" +msgstr "Heltals-id (N) för anpassad instruktion fdivd." #: config/nios2/nios2.opt:330 -#, fuzzy -#| msgid "Do not use the fmuld custom instruction" msgid "Do not use the fmuld custom instruction." -msgstr "Använd inte den anpassade instruktionen fmuld" +msgstr "Använd inte den anpassade instruktionen fmuld." #: config/nios2/nios2.opt:334 -#, fuzzy -#| msgid "Integer id (N) of fmuld custom instruction" msgid "Integer id (N) of fmuld custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fmuld" +msgstr "Heltals-id (N) för anpassad instruktion fmuld." #: config/nios2/nios2.opt:338 -#, fuzzy -#| msgid "Do not use the fsubd custom instruction" msgid "Do not use the fsubd custom instruction." -msgstr "Använd inte den anpassade instruktionen fsubd" +msgstr "Använd inte den anpassade instruktionen fsubd." #: config/nios2/nios2.opt:342 -#, fuzzy -#| msgid "Integer id (N) of fsubd custom instruction" msgid "Integer id (N) of fsubd custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fsubd" +msgstr "Heltals-id (N) för anpassad instruktion fsubd." #: config/nios2/nios2.opt:346 -#, fuzzy -#| msgid "Do not use the faddd custom instruction" msgid "Do not use the faddd custom instruction." -msgstr "Använd inte den anpassade instruktionen faddd" +msgstr "Använd inte den anpassade instruktionen faddd." #: config/nios2/nios2.opt:350 -#, fuzzy -#| msgid "Integer id (N) of faddd custom instruction" msgid "Integer id (N) of faddd custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion faddd" +msgstr "Heltals-id (N) för anpassad instruktion faddd." #: config/nios2/nios2.opt:354 -#, fuzzy -#| msgid "Do not use the fcmpnes custom instruction" msgid "Do not use the fcmpnes custom instruction." -msgstr "Använd inte den anpassade instruktionen fcmpnes" +msgstr "Använd inte den anpassade instruktionen fcmpnes." #: config/nios2/nios2.opt:358 -#, fuzzy -#| msgid "Integer id (N) of fcmpnes custom instruction" msgid "Integer id (N) of fcmpnes custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fcmpnes" +msgstr "Heltals-id (N) för anpassad instruktion fcmpnes." #: config/nios2/nios2.opt:362 -#, fuzzy -#| msgid "Do not use the fcmpeqs custom instruction" msgid "Do not use the fcmpeqs custom instruction." -msgstr "Använd inte den anpassade instruktionen fcmpeqs" +msgstr "Använd inte den anpassade instruktionen fcmpeqs." #: config/nios2/nios2.opt:366 -#, fuzzy -#| msgid "Integer id (N) of fcmpeqs custom instruction" msgid "Integer id (N) of fcmpeqs custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fcmpeqs" +msgstr "Heltals-id (N) för anpassad instruktion fcmpeqs." #: config/nios2/nios2.opt:370 -#, fuzzy -#| msgid "Do not use the fcmpges custom instruction" msgid "Do not use the fcmpges custom instruction." -msgstr "Använd inte den anpassade instruktionen fcmpges" +msgstr "Använd inte den anpassade instruktionen fcmpges." #: config/nios2/nios2.opt:374 -#, fuzzy -#| msgid "Integer id (N) of fcmpges custom instruction" msgid "Integer id (N) of fcmpges custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fcmpges" +msgstr "Heltals-id (N) för anpassad instruktion fcmpges." #: config/nios2/nios2.opt:378 -#, fuzzy -#| msgid "Do not use the fcmpgts custom instruction" msgid "Do not use the fcmpgts custom instruction." -msgstr "Använd inte den anpassade instruktionen fcmpgts" +msgstr "Använd inte den anpassade instruktionen fcmpgts." #: config/nios2/nios2.opt:382 -#, fuzzy -#| msgid "Integer id (N) of fcmpgts custom instruction" msgid "Integer id (N) of fcmpgts custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fcmpgts" +msgstr "Heltals-id (N) för anpassad instruktion fcmpgts." #: config/nios2/nios2.opt:386 -#, fuzzy -#| msgid "Do not use the fcmples custom instruction" msgid "Do not use the fcmples custom instruction." -msgstr "Använd inte den anpassade instruktionen fcmples" +msgstr "Använd inte den anpassade instruktionen fcmples." #: config/nios2/nios2.opt:390 -#, fuzzy -#| msgid "Integer id (N) of fcmples custom instruction" msgid "Integer id (N) of fcmples custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fcmples" +msgstr "Heltals-id (N) för anpassad instruktion fcmples." #: config/nios2/nios2.opt:394 -#, fuzzy -#| msgid "Do not use the fcmplts custom instruction" msgid "Do not use the fcmplts custom instruction." -msgstr "Använd inte den anpassade instruktionen fcmplts" +msgstr "Använd inte den anpassade instruktionen fcmplts." #: config/nios2/nios2.opt:398 -#, fuzzy -#| msgid "Integer id (N) of fcmplts custom instruction" msgid "Integer id (N) of fcmplts custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fcmplts" +msgstr "Heltals-id (N) för anpassad instruktion fcmplts." #: config/nios2/nios2.opt:402 -#, fuzzy -#| msgid "Do not use the flogs custom instruction" msgid "Do not use the flogs custom instruction." -msgstr "Använd inte den anpassade instruktionen flogs" +msgstr "Använd inte den anpassade instruktionen flogs." #: config/nios2/nios2.opt:406 -#, fuzzy -#| msgid "Integer id (N) of flogs custom instruction" msgid "Integer id (N) of flogs custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion flogs" +msgstr "Heltals-id (N) för anpassad instruktion flogs." #: config/nios2/nios2.opt:410 -#, fuzzy -#| msgid "Do not use the fexps custom instruction" msgid "Do not use the fexps custom instruction." -msgstr "Använd inte den anpassade instruktionen fexps" +msgstr "Använd inte den anpassade instruktionen fexps." #: config/nios2/nios2.opt:414 -#, fuzzy -#| msgid "Integer id (N) of fexps custom instruction" msgid "Integer id (N) of fexps custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fexps" +msgstr "Heltals-id (N) för anpassad instruktion fexps." #: config/nios2/nios2.opt:418 -#, fuzzy -#| msgid "Do not use the fatans custom instruction" msgid "Do not use the fatans custom instruction." -msgstr "Använd inte den anpassade instruktionen fatans" +msgstr "Använd inte den anpassade instruktionen fatans." #: config/nios2/nios2.opt:422 -#, fuzzy -#| msgid "Integer id (N) of fatans custom instruction" msgid "Integer id (N) of fatans custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fatans" +msgstr "Heltals-id (N) för anpassad instruktion fatans." #: config/nios2/nios2.opt:426 -#, fuzzy -#| msgid "Do not use the ftans custom instruction" msgid "Do not use the ftans custom instruction." -msgstr "Använd inte den anpassade instruktionen ftans" +msgstr "Använd inte den anpassade instruktionen ftans." #: config/nios2/nios2.opt:430 -#, fuzzy -#| msgid "Integer id (N) of ftans custom instruction" msgid "Integer id (N) of ftans custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion ftans" +msgstr "Heltals-id (N) för anpassad instruktion ftans." #: config/nios2/nios2.opt:434 -#, fuzzy -#| msgid "Do not use the fsins custom instruction" msgid "Do not use the fsins custom instruction." -msgstr "Använd inte den anpassade instruktionen fsins" +msgstr "Använd inte den anpassade instruktionen fsins." #: config/nios2/nios2.opt:438 -#, fuzzy -#| msgid "Integer id (N) of fsins custom instruction" msgid "Integer id (N) of fsins custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fsins" +msgstr "Heltals-id (N) för anpassad instruktion fsins." #: config/nios2/nios2.opt:442 -#, fuzzy -#| msgid "Do not use the fcoss custom instruction" msgid "Do not use the fcoss custom instruction." -msgstr "Använd inte den anpassade instruktionen fcoss" +msgstr "Använd inte den anpassade instruktionen fcoss." #: config/nios2/nios2.opt:446 -#, fuzzy -#| msgid "Integer id (N) of fcoss custom instruction" msgid "Integer id (N) of fcoss custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fcoss" +msgstr "Heltals-id (N) för anpassad instruktion fcoss." #: config/nios2/nios2.opt:450 -#, fuzzy -#| msgid "Do not use the fsqrts custom instruction" msgid "Do not use the fsqrts custom instruction." -msgstr "Använd inte den anpassade instruktionen fsqrts" +msgstr "Använd inte den anpassade instruktionen fsqrts." #: config/nios2/nios2.opt:454 -#, fuzzy -#| msgid "Integer id (N) of fsqrts custom instruction" msgid "Integer id (N) of fsqrts custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fsqrts" +msgstr "Heltals-id (N) för anpassad instruktion fsqrts." #: config/nios2/nios2.opt:458 -#, fuzzy -#| msgid "Do not use the fabss custom instr" msgid "Do not use the fabss custom instr." -msgstr "Använd inte den anpassade instruktionen fabss" +msgstr "Använd inte den anpassade instruktionen fabss." #: config/nios2/nios2.opt:462 -#, fuzzy -#| msgid "Integer id (N) of fabss custom instruction" msgid "Integer id (N) of fabss custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fabss" +msgstr "Heltals-id (N) för anpassad instruktion fabss." #: config/nios2/nios2.opt:466 -#, fuzzy -#| msgid "Do not use the fnegs custom instruction" msgid "Do not use the fnegs custom instruction." -msgstr "Använd inte den anpassade instruktionen fnegs" +msgstr "Använd inte den anpassade instruktionen fnegs." #: config/nios2/nios2.opt:470 -#, fuzzy -#| msgid "Integer id (N) of fnegs custom instruction" msgid "Integer id (N) of fnegs custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fnegs" +msgstr "Heltals-id (N) för anpassad instruktion fnegs." #: config/nios2/nios2.opt:474 -#, fuzzy -#| msgid "Do not use the fmaxs custom instruction" msgid "Do not use the fmaxs custom instruction." -msgstr "Använd inte den anpassade instruktionen fmaxs" +msgstr "Använd inte den anpassade instruktionen fmaxs." #: config/nios2/nios2.opt:478 -#, fuzzy -#| msgid "Integer id (N) of fmaxs custom instruction" msgid "Integer id (N) of fmaxs custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fmaxs" +msgstr "Heltals-id (N) för anpassad instruktion fmaxs." #: config/nios2/nios2.opt:482 -#, fuzzy -#| msgid "Do not use the fmins custom instruction" msgid "Do not use the fmins custom instruction." -msgstr "Använd inte den anpassade instruktionen fmins" +msgstr "Använd inte den anpassade instruktionen fmins." #: config/nios2/nios2.opt:486 -#, fuzzy -#| msgid "Integer id (N) of fmins custom instruction" msgid "Integer id (N) of fmins custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fmins" +msgstr "Heltals-id (N) för anpassad instruktion fmins." #: config/nios2/nios2.opt:490 -#, fuzzy -#| msgid "Do not use the fdivs custom instruction" msgid "Do not use the fdivs custom instruction." -msgstr "Använd inte den anpassade instruktionen fdivs" +msgstr "Använd inte den anpassade instruktionen fdivs." #: config/nios2/nios2.opt:494 -#, fuzzy -#| msgid "Integer id (N) of fdivs custom instruction" msgid "Integer id (N) of fdivs custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fdivs" +msgstr "Heltals-id (N) för anpassad instruktion fdivs." #: config/nios2/nios2.opt:498 -#, fuzzy -#| msgid "Do not use the fmuls custom instruction" msgid "Do not use the fmuls custom instruction." -msgstr "Använd inte den anpassade instruktionen fmuls" +msgstr "Använd inte den anpassade instruktionen fmuls." #: config/nios2/nios2.opt:502 -#, fuzzy -#| msgid "Integer id (N) of fmuls custom instruction" msgid "Integer id (N) of fmuls custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fmuls" +msgstr "Heltals-id (N) för anpassad instruktion fmuls." #: config/nios2/nios2.opt:506 -#, fuzzy -#| msgid "Do not use the fsubs custom instruction" msgid "Do not use the fsubs custom instruction." -msgstr "Använd inte den anpassade instruktionen fsubs" +msgstr "Använd inte den anpassade instruktionen fsubs." #: config/nios2/nios2.opt:510 -#, fuzzy -#| msgid "Integer id (N) of fsubs custom instruction" msgid "Integer id (N) of fsubs custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fsubs" +msgstr "Heltals-id (N) för anpassad instruktion fsubs." #: config/nios2/nios2.opt:514 -#, fuzzy -#| msgid "Do not use the fadds custom instruction" msgid "Do not use the fadds custom instruction." -msgstr "Använd inte den anpassade instruktionen fadds" +msgstr "Använd inte den anpassade instruktionen fadds." #: config/nios2/nios2.opt:518 -#, fuzzy -#| msgid "Integer id (N) of fadds custom instruction" msgid "Integer id (N) of fadds custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fadds" +msgstr "Heltals-id (N) för anpassad instruktion fadds." #: config/nios2/nios2.opt:522 -#, fuzzy -#| msgid "Do not use the frdy custom instruction" msgid "Do not use the frdy custom instruction." -msgstr "Använd inte den anpassade instruktionen frdy" +msgstr "Använd inte den anpassade instruktionen frdy." #: config/nios2/nios2.opt:526 -#, fuzzy -#| msgid "Integer id (N) of frdy custom instruction" msgid "Integer id (N) of frdy custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion frdy" +msgstr "Heltals-id (N) för anpassad instruktion frdy." #: config/nios2/nios2.opt:530 -#, fuzzy -#| msgid "Do not use the frdxhi custom instruction" msgid "Do not use the frdxhi custom instruction." -msgstr "Använd inte den anpassade instruktionen frdxhi" +msgstr "Använd inte den anpassade instruktionen frdxhi." #: config/nios2/nios2.opt:534 -#, fuzzy -#| msgid "Integer id (N) of frdxhi custom instruction" msgid "Integer id (N) of frdxhi custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion frdxhi" +msgstr "Heltals-id (N) för anpassad instruktion frdxhi." #: config/nios2/nios2.opt:538 -#, fuzzy -#| msgid "Do not use the frdxlo custom instruction" msgid "Do not use the frdxlo custom instruction." -msgstr "Använd inte den anpassade instruktionen frdxlo" +msgstr "Använd inte den anpassade instruktionen frdxlo." #: config/nios2/nios2.opt:542 -#, fuzzy -#| msgid "Integer id (N) of frdxlo custom instruction" msgid "Integer id (N) of frdxlo custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion frdxlo" +msgstr "Heltals-id (N) för anpassad instruktion frdxlo." #: config/nios2/nios2.opt:546 -#, fuzzy -#| msgid "Do not use the fwry custom instruction" msgid "Do not use the fwry custom instruction." -msgstr "Använd inte den anpassade instruktionen fwry" +msgstr "Använd inte den anpassade instruktionen fwry." #: config/nios2/nios2.opt:550 -#, fuzzy -#| msgid "Integer id (N) of fwry custom instruction" msgid "Integer id (N) of fwry custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fwry" +msgstr "Heltals-id (N) för anpassad instruktion fwry." #: config/nios2/nios2.opt:554 -#, fuzzy -#| msgid "Do not use the fwrx custom instruction" msgid "Do not use the fwrx custom instruction." -msgstr "Använd inte den anpassade instruktionen fwrx" +msgstr "Använd inte den anpassade instruktionen fwrx." #: config/nios2/nios2.opt:558 -#, fuzzy -#| msgid "Integer id (N) of fwrx custom instruction" msgid "Integer id (N) of fwrx custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion fwrx" +msgstr "Heltals-id (N) för anpassad instruktion fwrx." #: config/nios2/nios2.opt:562 -#, fuzzy -#| msgid "Do not use the round custom instruction" msgid "Do not use the round custom instruction." -msgstr "Använd inte den anpassade instruktionen round" +msgstr "Använd inte den anpassade instruktionen round." #: config/nios2/nios2.opt:566 -#, fuzzy -#| msgid "Integer id (N) of round custom instruction" msgid "Integer id (N) of round custom instruction." -msgstr "Heltals-id (N) för anpassad instruktion round" +msgstr "Heltals-id (N) för anpassad instruktion round." #: config/nios2/nios2.opt:574 msgid "Valid Nios II ISA levels (for -march):" msgstr "Giltiga Nios II ISA-nivåer (för -march):" #: config/nios2/nios2.opt:584 -#, fuzzy -#| msgid "Enable saturation instructions" msgid "Enable generation of R2 BMX instructions." -msgstr "Använd mättnads-instruktioner" +msgstr "Aktivera generering av R2 BMX-instruktioner." #: config/nios2/nios2.opt:588 -#, fuzzy -#| msgid "Enable saturation instructions" msgid "Enable generation of R2 CDX instructions." -msgstr "Använd mättnads-instruktioner" +msgstr "Använd generering av R2 CDX-instruktioner." #: config/rx/rx.opt:29 msgid "Store doubles in 64 bits." @@ -13860,41 +11321,28 @@ msgid "Enables or disables the use of the SMOVF, SMOVB, SMOVU, SUNTIL, SWHILE an msgstr "Aktiverar eller avaktiverar användningen av instruktionerna SMOVF, SMOVB, SMOVU, SUNTIL, SWHILE och RMPA. Normalt aktiverat." #: config/rx/rx.opt:157 -#, fuzzy -#| msgid "Always generate long calls" msgid "Always use JSR, never BSR, for calls." -msgstr "Generera alltid långa anrop" +msgstr "Använd alltid JSR, aldrig BSR, för anrop." #: config/visium/visium.opt:25 -#, fuzzy -#| msgid "Link with libc.a and libdebug.a" msgid "Link with libc.a and libdebug.a." -msgstr "Länka med libc.a och libdebug.a" +msgstr "Länka med libc.a och libdebug.a." #: config/visium/visium.opt:29 -#, fuzzy -#| msgid "Link with libc.a and libsim.a" msgid "Link with libc.a and libsim.a." -msgstr "Länka med libc.a och libsim.a" +msgstr "Länka med libc.a och libsim.a." -# fixme: fp = flyttal, men hur skall man skriva det. Förkortat eller FPU? #: config/visium/visium.opt:33 -#, fuzzy -#| msgid "Use hardware FP (default)" msgid "Use hardware FP (default)." -msgstr "Använd hårdvaru-fp (standard)" +msgstr "Använd hårdvaruflyttal (standard)." #: config/visium/visium.opt:65 -#, fuzzy -#| msgid "Generate code for the supervisor mode (default)" msgid "Generate code for the supervisor mode (default)." -msgstr "Generera kod för övervakarläget (standard)" +msgstr "Generera kod för övervakarläget (standard)." #: config/visium/visium.opt:69 -#, fuzzy -#| msgid "Generate code for the user mode" msgid "Generate code for the user mode." -msgstr "Generera kod för användarläget" +msgstr "Generera kod för användarläget." #: config/visium/visium.opt:73 msgid "Only retained for backward compatibility." @@ -13905,82 +11353,56 @@ msgid "%<-mfused-madd%> is deprecated; use %<-ffp-contract=%> instead" msgstr "%<-mfused-madd%> bör undvikas, använd %<-ffp-contract=%> istället" #: config/sol2.opt:32 -#, fuzzy -#| msgid "Clear hardware capabilities when linking" msgid "Clear hardware capabilities when linking." -msgstr "Nollställ hårdvaruförmågor vid länkning" +msgstr "Nollställ hårdvaruförmågor vid länkning." #: config/sol2.opt:36 -#, fuzzy -#| msgid "Pass -z text to linker" msgid "Pass -z text to linker." -msgstr "Skicka -z text till länkaren" +msgstr "Skicka -z text till länkaren." #: config/moxie/moxie.opt:31 -#, fuzzy -#| msgid "Enable MUL.X and UMUL.X instructions" msgid "Enable MUL.X and UMUL.X instructions." -msgstr "Använd MUL.X- och UMUL.X-instruktioner" +msgstr "Använd MUL.X- och UMUL.X-instruktioner." #: config/microblaze/microblaze.opt:40 -#, fuzzy -#| msgid "Use software emulation for floating point (default)" msgid "Use software emulation for floating point (default)." -msgstr "Använd programvaruemulering för flyttal (standard)" +msgstr "Använd programvaruemulering för flyttal (standard)." #: config/microblaze/microblaze.opt:44 -#, fuzzy -#| msgid "Use hardware floating point instructions" msgid "Use hardware floating point instructions." -msgstr "Använd flyttalsinstruktioner i hårdvara" +msgstr "Använd flyttalsinstruktioner i hårdvara." #: config/microblaze/microblaze.opt:48 -#, fuzzy -#| msgid "Use table lookup optimization for small signed integer divisions" msgid "Use table lookup optimization for small signed integer divisions." -msgstr "Aktivera tabelluppslagningsoptimeringar för divisioner med små heltal med tecken" +msgstr "Aktivera tabelluppslagningsoptimeringar för divisioner med små heltal med tecken." #: config/microblaze/microblaze.opt:52 -#, fuzzy -#| msgid "-mcpu=PROCESSOR\t\tUse features of and schedule code for given CPU" msgid "-mcpu=PROCESSOR\t\tUse features of and schedule code for given CPU." -msgstr "-mcpu=PROCESSOR\t\tAnvänd funktioner i och schemalägg kod för angiven CPU" +msgstr "-mcpu=PROCESSOR\t\tAnvänd funktioner i och schemalägg kod för angiven CPU." #: config/microblaze/microblaze.opt:56 -#, fuzzy -#| msgid "Don't optimize block moves, use memcpy" msgid "Don't optimize block moves, use memcpy." -msgstr "Optimera inte blockförflyttningar, använd memcpy" +msgstr "Optimera inte blockförflyttningar, använd memcpy." #: config/microblaze/microblaze.opt:68 -#, fuzzy -#| msgid "Use the soft multiply emulation (default)" msgid "Use the soft multiply emulation (default)." -msgstr "Använd programvaruemulering av multiplikation (standard)" +msgstr "Använd programvaruemulering av multiplikation (standard)." #: config/microblaze/microblaze.opt:72 -#, fuzzy -#| msgid "Use reorder instructions (swap and byte reversed load/store) (default)" msgid "Use reorder instructions (swap and byte reversed load/store) (default)." -msgstr "Använd ordningsändringinstruktioner (växlad och byte-omvänd lastning/lagring) (standard)" +msgstr "Använd ordningsändringinstruktioner (växlad och byte-omvänd laddning/lagring) (standard)." #: config/microblaze/microblaze.opt:76 -#, fuzzy -#| msgid "Use the software emulation for divides (default)" msgid "Use the software emulation for divides (default)." -msgstr "Använd programvaruemulering av division (standard)" +msgstr "Använd programvaruemulering av division (standard)." #: config/microblaze/microblaze.opt:80 -#, fuzzy -#| msgid "Use the hardware barrel shifter instead of emulation" msgid "Use the hardware barrel shifter instead of emulation." -msgstr "Använd tunnskiftaren i hårdvara istället för emulering" +msgstr "Använd tunnskiftaren i hårdvara istället för emulering." #: config/microblaze/microblaze.opt:84 -#, fuzzy -#| msgid "Use pattern compare instructions" msgid "Use pattern compare instructions." -msgstr "Använd mönsterjämförelseinstruktioner" +msgstr "Använd mönsterjämförelseinstruktioner." #: config/microblaze/microblaze.opt:87 #, c-format @@ -13988,16 +11410,12 @@ msgid "%qs is deprecated; use -fstack-check" msgstr "%qs bör undvikas, använd -fstack-check" #: config/microblaze/microblaze.opt:88 -#, fuzzy -#| msgid "Check for stack overflow at runtime" msgid "Check for stack overflow at runtime." -msgstr "Kontrollera stackspill vid körtillfället" +msgstr "Kontrollera stackspill vid körtillfället." #: config/microblaze/microblaze.opt:92 config/iq2000/iq2000.opt:65 -#, fuzzy -#| msgid "Use GP relative sdata/sbss sections" msgid "Use GP relative sdata/sbss sections." -msgstr "Använd GP relativt sdata/sbss-sektioner" +msgstr "Använd GP relativt sdata/sbss-sektioner." #: config/microblaze/microblaze.opt:95 #, c-format @@ -14005,364 +11423,248 @@ msgid "%qs is deprecated; use -fno-zero-initialized-in-bss" msgstr "%qs bör undvikas, använd -fno-zero-initialized-in-bss" #: config/microblaze/microblaze.opt:96 -#, fuzzy -#| msgid "Clear the BSS to zero and place zero initialized in BSS" msgid "Clear the BSS to zero and place zero initialized in BSS." -msgstr "Nollställ BSS och placera nollinitierade i BSS" +msgstr "Nollställ BSS och placera nollinitierade i BSS." #: config/microblaze/microblaze.opt:100 -#, fuzzy -#| msgid "Use multiply high instructions for high part of 32x32 multiply" msgid "Use multiply high instructions for high part of 32x32 multiply." -msgstr "Använd högmultiplikationsinstruktioner för den höga delen av 32·32-multiplikationer" +msgstr "Använd högmultiplikationsinstruktioner för den höga delen av 32·32-multiplikationer." #: config/microblaze/microblaze.opt:104 -#, fuzzy -#| msgid "Use hardware floating point conversion instructions" msgid "Use hardware floating point conversion instructions." -msgstr "Använd flyttalskonverteringsinstruktioner i hårdvara" +msgstr "Använd flyttalskonverteringsinstruktioner i hårdvara." #: config/microblaze/microblaze.opt:108 -#, fuzzy -#| msgid "Use hardware floating point square root instruction" msgid "Use hardware floating point square root instruction." -msgstr "Använd flyttalsinstruktion för kvadratrot i hårdvara" +msgstr "Använd flyttalsinstruktion för kvadratrot i hårdvara." # Den ofärdiga beskrivningen är felrapporterad: # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47105 #: config/microblaze/microblaze.opt:112 -#, fuzzy -#| msgid "Description for mxl-mode-executable" msgid "Description for mxl-mode-executable." -msgstr "Beskrivning för mxl-mode-executable" +msgstr "Beskrivning för mxl-mode-executable." # Den ofärdiga beskrivningen är felrapporterad: # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47105 #: config/microblaze/microblaze.opt:116 -#, fuzzy -#| msgid "Description for mxl-mode-xmdstub" msgid "Description for mxl-mode-xmdstub." -msgstr "Beskrivning för mxl-mode-xmdstub" +msgstr "Beskrivning för mxl-mode-xmdstub." # Den ofärdiga beskrivningen är felrapporterad: # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47105 #: config/microblaze/microblaze.opt:120 -#, fuzzy -#| msgid "Description for mxl-mode-bootstrap" msgid "Description for mxl-mode-bootstrap." -msgstr "Beskrivning för mxl-mode-bootstrap" +msgstr "Beskrivning för mxl-mode-bootstrap." # Den ofärdiga beskrivningen är felrapporterad: # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47105 #: config/microblaze/microblaze.opt:124 -#, fuzzy -#| msgid "Description for mxl-mode-novectors" msgid "Description for mxl-mode-novectors." -msgstr "Beskrivning för mxl-mode-novectors" +msgstr "Beskrivning för mxl-mode-novectors." #: config/microblaze/microblaze.opt:128 -#, fuzzy -#| msgid "Use hardware quad FP instructions" msgid "Use hardware prefetch instruction" -msgstr "Använd hårdvaruinstruktioner för quad fp" +msgstr "Använd instruktioner för förhandshämtning (prefetch) i hårdvara" #: config/vax/vax.opt:23 config/vax/vax.opt:27 -#, fuzzy -#| msgid "Target DFLOAT double precision code" msgid "Target DFLOAT double precision code." -msgstr "Sikta på DFLOAT-dubbelprecisionskod" +msgstr "Sikta på DFLOAT-dubbelprecisionskod." #: config/vax/vax.opt:31 config/vax/vax.opt:35 -#, fuzzy -#| msgid "Generate GFLOAT double precision code" msgid "Generate GFLOAT double precision code." -msgstr "Generera GFLOAT-dubbelprecisionskod" +msgstr "Generera GFLOAT-dubbelprecisionskod." #: config/vax/vax.opt:39 -#, fuzzy -#| msgid "Generate code for GNU assembler (gas)" msgid "Generate code for GNU assembler (gas)." -msgstr "Generera kod för GNU-assembler (gas)" +msgstr "Generera kod för GNU-assembler (gas)." #: config/vax/vax.opt:43 -#, fuzzy -#| msgid "Generate code for UNIX assembler" msgid "Generate code for UNIX assembler." -msgstr "Generera kod för UNIX-assembler" +msgstr "Generera kod för UNIX-assembler." #: config/vax/vax.opt:47 -#, fuzzy -#| msgid "Use VAXC structure conventions" msgid "Use VAXC structure conventions." -msgstr "Använd VAXC:s konventioner för struct" +msgstr "Använd VAXC:s konventioner för struct." #: config/vax/vax.opt:51 -#, fuzzy -#| msgid "Use new adddi3/subdi3 patterns" msgid "Use new adddi3/subdi3 patterns." -msgstr "Använd nya adddi3/subdi3-mönster" +msgstr "Använd nya adddi3/subdi3-mönster." #: config/frv/frv.opt:30 -#, fuzzy -#| msgid "Use 4 media accumulators" msgid "Use 4 media accumulators." -msgstr "Använd 4 mediaackumulatorer" +msgstr "Använd 4 mediaackumulatorer." #: config/frv/frv.opt:34 -#, fuzzy -#| msgid "Use 8 media accumulators" msgid "Use 8 media accumulators." -msgstr "Använd 8 mediaackumulatorer" +msgstr "Använd 8 mediaackumulatorer." #: config/frv/frv.opt:38 -#, fuzzy -#| msgid "Enable label alignment optimizations" msgid "Enable label alignment optimizations." -msgstr "Aktivera optimeringar av etikettjustering" +msgstr "Aktivera optimeringar av etikettjustering." #: config/frv/frv.opt:42 -#, fuzzy -#| msgid "Dynamically allocate cc registers" msgid "Dynamically allocate cc registers." -msgstr "Allokera cc-register dynamiskt" +msgstr "Allokera cc-register dynamiskt." #: config/frv/frv.opt:49 -#, fuzzy -#| msgid "Set the cost of branches" msgid "Set the cost of branches." -msgstr "Ange kostnaden för grenar" +msgstr "Ange kostnaden för grenar." #: config/frv/frv.opt:53 -#, fuzzy -#| msgid "Enable conditional execution other than moves/scc" msgid "Enable conditional execution other than moves/scc." -msgstr "Aktivera villkorlig exekvering förutom moves/scc" +msgstr "Aktivera villkorlig exekvering förutom moves/scc." #: config/frv/frv.opt:57 -#, fuzzy -#| msgid "Change the maximum length of conditionally-executed sequences" msgid "Change the maximum length of conditionally-executed sequences." -msgstr "Ändra den maximala längden på villkorligt exekverade sekvenser" +msgstr "Ändra den maximala längden på villkorligt exekverade sekvenser." #: config/frv/frv.opt:61 -#, fuzzy -#| msgid "Change the number of temporary registers that are available to conditionally-executed sequences" msgid "Change the number of temporary registers that are available to conditionally-executed sequences." -msgstr "Ändra antalet temporära register som är tillgängliga för villkorligt exekverade sekvenser" +msgstr "Ändra antalet temporära register som är tillgängliga för villkorligt exekverade sekvenser." #: config/frv/frv.opt:65 -#, fuzzy -#| msgid "Enable conditional moves" msgid "Enable conditional moves." -msgstr "Aktivera villkorliga flyttningar" +msgstr "Aktivera villkorliga flyttningar." #: config/frv/frv.opt:69 -#, fuzzy -#| msgid "Set the target CPU type" msgid "Set the target CPU type." -msgstr "Ange typen av mål-CPU" +msgstr "Ange typen av mål-CPU." #: config/frv/frv.opt:73 msgid "Known FR-V CPUs (for use with the -mcpu= option):" msgstr "Kända FR-V-CPU:er (att användas med flaggan -mcpu=):" #: config/frv/frv.opt:122 -#, fuzzy -#| msgid "Use fp double instructions" msgid "Use fp double instructions." -msgstr "Använd fp-double-instruktioner" +msgstr "Använd fp-double-instruktioner." #: config/frv/frv.opt:126 -#, fuzzy -#| msgid "Change the ABI to allow double word insns" msgid "Change the ABI to allow double word insns." -msgstr "Ändra ABI:et så det tillåter dubbelordinstruktioner" +msgstr "Ändra ABI:et så det tillåter dubbelordinstruktioner." #: config/frv/frv.opt:134 -#, fuzzy -#| msgid "Just use icc0/fcc0" msgid "Just use icc0/fcc0." -msgstr "Använd bara icc0/fcc0" +msgstr "Använd bara icc0/fcc0." #: config/frv/frv.opt:138 -#, fuzzy -#| msgid "Only use 32 FPRs" msgid "Only use 32 FPRs." -msgstr "Använd bara 32 FPR:er" +msgstr "Använd bara 32 FPR:er." #: config/frv/frv.opt:142 -#, fuzzy -#| msgid "Use 64 FPRs" msgid "Use 64 FPRs." -msgstr "Använd 64 FPR:er" +msgstr "Använd 64 FPR:er." #: config/frv/frv.opt:146 -#, fuzzy -#| msgid "Only use 32 GPRs" msgid "Only use 32 GPRs." -msgstr "Använd bara 32 GPR:er" +msgstr "Använd bara 32 GPR:er." #: config/frv/frv.opt:150 -#, fuzzy -#| msgid "Use 64 GPRs" msgid "Use 64 GPRs." -msgstr "Använd 64 GPR:er" +msgstr "Använd 64 GPR:er." #: config/frv/frv.opt:154 -#, fuzzy -#| msgid "Enable use of GPREL for read-only data in FDPIC" msgid "Enable use of GPREL for read-only data in FDPIC." -msgstr "Aktivera användning av GPREL för endast läsbara data i FDPIC" +msgstr "Aktivera användning av GPREL för endast läsbara data i FDPIC." #: config/frv/frv.opt:166 -#, fuzzy -#| msgid "Enable PIC support for building libraries" msgid "Enable PIC support for building libraries." -msgstr "Aktivera PIC-stöd för att bygga bibliotek" +msgstr "Aktivera PIC-stöd för att bygga bibliotek." #: config/frv/frv.opt:170 -#, fuzzy -#| msgid "Follow the EABI linkage requirements" msgid "Follow the EABI linkage requirements." -msgstr "Följ länkningskraven EABI" +msgstr "Följ länkningskraven EABI." #: config/frv/frv.opt:174 -#, fuzzy -#| msgid "Disallow direct calls to global functions" msgid "Disallow direct calls to global functions." -msgstr "Tillåt inte direkta anrop till globala funktioner" +msgstr "Tillåt inte direkta anrop till globala funktioner." #: config/frv/frv.opt:178 -#, fuzzy -#| msgid "Use media instructions" msgid "Use media instructions." -msgstr "Använd mediainstruktioner" +msgstr "Använd mediainstruktioner." #: config/frv/frv.opt:182 -#, fuzzy -#| msgid "Use multiply add/subtract instructions" msgid "Use multiply add/subtract instructions." -msgstr "Använd multiplicera-addera-/-subtraherainstruktioner" +msgstr "Använd multiplicera-addera-/-subtraherainstruktioner." #: config/frv/frv.opt:186 -#, fuzzy -#| msgid "Enable optimizing &&/|| in conditional execution" msgid "Enable optimizing &&/|| in conditional execution." -msgstr "Aktivera optimering av &&/|| i villkorliga uttryck" +msgstr "Aktivera optimering av &&/|| i villkorliga uttryck." #: config/frv/frv.opt:190 -#, fuzzy -#| msgid "Enable nested conditional execution optimizations" msgid "Enable nested conditional execution optimizations." -msgstr "Aktivera nästade optimeringar av villkorlig exekvering" +msgstr "Aktivera nästade optimeringar av villkorlig exekvering." #: config/frv/frv.opt:195 -#, fuzzy -#| msgid "Do not mark ABI switches in e_flags" msgid "Do not mark ABI switches in e_flags." -msgstr "Markera inte ABI-byten i e_flags" +msgstr "Markera inte ABI-byten i e_flags." #: config/frv/frv.opt:199 -#, fuzzy -#| msgid "Remove redundant membars" msgid "Remove redundant membars." -msgstr "Ta bort överflödiga medlemmar" +msgstr "Ta bort överflödiga medlemmar." #: config/frv/frv.opt:203 -#, fuzzy -#| msgid "Pack VLIW instructions" msgid "Pack VLIW instructions." -msgstr "Packa VLIW-instruktioner" +msgstr "Packa VLIW-instruktioner." #: config/frv/frv.opt:207 -#, fuzzy -#| msgid "Enable setting GPRs to the result of comparisons" msgid "Enable setting GPRs to the result of comparisons." -msgstr "Aktivera sättande av GPR:er till resultatet av jämförelser" +msgstr "Aktivera sättande av GPR:er till resultatet av jämförelser." #: config/frv/frv.opt:211 -#, fuzzy -#| msgid "Change the amount of scheduler lookahead" msgid "Change the amount of scheduler lookahead." -msgstr "Ändra hur långt schemaläggaren blickar framåt" +msgstr "Ändra hur långt schemaläggaren blickar framåt." #: config/frv/frv.opt:219 -#, fuzzy -#| msgid "Assume a large TLS segment" msgid "Assume a large TLS segment." -msgstr "Anta ett stort TLS-segment" +msgstr "Anta ett stort TLS-segment." #: config/frv/frv.opt:223 -#, fuzzy -#| msgid "Do not assume a large TLS segment" msgid "Do not assume a large TLS segment." -msgstr "Anta inte ett stort TLS-segment" +msgstr "Anta inte ett stort TLS-segment." #: config/frv/frv.opt:228 -#, fuzzy -#| msgid "Cause gas to print tomcat statistics" msgid "Cause gas to print tomcat statistics." -msgstr "Få gas att skriva tomcat-statistik" +msgstr "Få gas att skriva tomcat-statistik." #: config/frv/frv.opt:233 -#, fuzzy -#| msgid "Link with the library-pic libraries" msgid "Link with the library-pic libraries." -msgstr "Länka med biblioteken library-pic" +msgstr "Länka med biblioteken library-pic." #: config/frv/frv.opt:237 -#, fuzzy -#| msgid "Allow branches to be packed with other instructions" msgid "Allow branches to be packed with other instructions." -msgstr "Tillåt grenar att packas med andra instruktioner" +msgstr "Tillåt grenar att packas med andra instruktioner." #: config/mn10300/mn10300.opt:30 -#, fuzzy -#| msgid "Target the AM33 processor" msgid "Target the AM33 processor." -msgstr "Sikta på processorn AM33" +msgstr "Sikta på processorn AM33." #: config/mn10300/mn10300.opt:34 -#, fuzzy -#| msgid "Target the AM33/2.0 processor" msgid "Target the AM33/2.0 processor." -msgstr "Sikta på processorn AM33/2.0" +msgstr "Sikta på processorn AM33/2.0." #: config/mn10300/mn10300.opt:38 -#, fuzzy -#| msgid "Target the AM34 processor" msgid "Target the AM34 processor." -msgstr "Sikta på processorn AM34" +msgstr "Sikta på processorn AM34." #: config/mn10300/mn10300.opt:46 -#, fuzzy -#| msgid "Work around hardware multiply bug" msgid "Work around hardware multiply bug." -msgstr "Gå runt multiplikationsfel i hårdvara" +msgstr "Gå runt multiplikationsfel i hårdvara." #: config/mn10300/mn10300.opt:55 -#, fuzzy -#| msgid "Enable linker relaxations" msgid "Enable linker relaxations." -msgstr "Aktivera länkaravslappningar" +msgstr "Aktivera länkaravslappningar." #: config/mn10300/mn10300.opt:59 -#, fuzzy -#| msgid "Return pointers in both a0 and d0" msgid "Return pointers in both a0 and d0." -msgstr "Returnera pekare i både a0 och d0" +msgstr "Returnera pekare i både a0 och d0." #: config/mn10300/mn10300.opt:63 -#, fuzzy -#| msgid "Allow gcc to generate LIW instructions" msgid "Allow gcc to generate LIW instructions." -msgstr "Tillåt gcc att generera LIW-instruktioner" +msgstr "Tillåt gcc att generera LIW-instruktioner." #: config/mn10300/mn10300.opt:67 -#, fuzzy -#| msgid "Allow gcc to generate the SETLB and Lcc instructions" msgid "Allow gcc to generate the SETLB and Lcc instructions." -msgstr "Tillåt gcc att generera instruktionerna SETLB och Lcc" +msgstr "Tillåt gcc att generera instruktionerna SETLB och Lcc." #: config/nds32/nds32.opt:26 msgid "Generate code in big-endian mode." @@ -14425,172 +11727,120 @@ msgid "Guide linker to relax instructions." msgstr "Hjälp länkaren att relaxera instruktioner." #: config/iq2000/iq2000.opt:31 -#, fuzzy -#| msgid "Specify CPU for code generation purposes" msgid "Specify CPU for code generation purposes." -msgstr "Ange CPU för kodgenereringssyften" +msgstr "Ange CPU för kodgenereringssyften." #: config/iq2000/iq2000.opt:47 -#, fuzzy -#| msgid "Specify CPU for scheduling purposes" msgid "Specify CPU for scheduling purposes." -msgstr "Ange CPU för schemaläggningssyften" +msgstr "Ange CPU för schemaläggningssyften." #: config/iq2000/iq2000.opt:51 msgid "Known IQ2000 CPUs (for use with the -mcpu= option):" msgstr "Kända IQ2000 CPU:er (att användas med flaggan -mcpu=):" #: config/iq2000/iq2000.opt:61 config/mips/mips.opt:142 -#, fuzzy -#| msgid "Use ROM instead of RAM" msgid "Use ROM instead of RAM." -msgstr "Använd ROM istället för RAM" +msgstr "Använd ROM istället för RAM." #: config/iq2000/iq2000.opt:70 -#, fuzzy -#| msgid "No default crt0.o" msgid "No default crt0.o." -msgstr "Ingen standard-crt0.o" +msgstr "Ingen standard-crt0.o." #: config/iq2000/iq2000.opt:74 config/mips/mips.opt:393 -#, fuzzy -#| msgid "Put uninitialized constants in ROM (needs -membedded-data)" msgid "Put uninitialized constants in ROM (needs -membedded-data)." -msgstr "Placera oinitierade konstanter i ROM (kräver -membedded-data)" +msgstr "Placera oinitierade konstanter i ROM (kräver -membedded-data)." #: config/c6x/c6x-tables.opt:24 msgid "Known C6X ISAs (for use with the -march= option):" msgstr "Kända C6X ISA:er (att användas med flaggan -march=):" #: config/c6x/c6x.opt:46 -#, fuzzy -#| msgid "Valid arguments for the -msdata= option" msgid "Valid arguments for the -msdata= option." -msgstr "Giltiga argument till flaggan -msdata=" +msgstr "Giltiga argument till flaggan -msdata=." #: config/c6x/c6x.opt:59 -#, fuzzy -#| msgid "Compile for the DSBT shared library ABI" msgid "Compile for the DSBT shared library ABI." -msgstr "Kompilera ABI:et DSBT för delade bibliotek" +msgstr "Kompilera ABI:et DSBT för delade bibliotek." #: config/cris/linux.opt:27 -#, fuzzy -#| msgid "Together with -fpic and -fPIC, do not use GOTPLT references" msgid "Together with -fpic and -fPIC, do not use GOTPLT references." -msgstr "Tillsammans med -fpic och -fPIC, använd inte GOTPLT-referenser" +msgstr "Tillsammans med -fpic och -fPIC, använd inte GOTPLT-referenser." #: config/cris/cris.opt:45 -#, fuzzy -#| msgid "Work around bug in multiplication instruction" msgid "Work around bug in multiplication instruction." -msgstr "Gå runt fel i multiplikationsinstruktion" +msgstr "Gå runt fel i multiplikationsinstruktion." #: config/cris/cris.opt:51 -#, fuzzy -#| msgid "Compile for ETRAX 4 (CRIS v3)" msgid "Compile for ETRAX 4 (CRIS v3)." -msgstr "Kompilera för ETRAX 4 (CRIS v3)" +msgstr "Kompilera för ETRAX 4 (CRIS v3)." #: config/cris/cris.opt:56 -#, fuzzy -#| msgid "Compile for ETRAX 100 (CRIS v8)" msgid "Compile for ETRAX 100 (CRIS v8)." -msgstr "Kompilera för ETRAX 100 (CRIS v8)" +msgstr "Kompilera för ETRAX 100 (CRIS v8)." #: config/cris/cris.opt:64 -#, fuzzy -#| msgid "Emit verbose debug information in assembly code" msgid "Emit verbose debug information in assembly code." -msgstr "Mata ut utförlig felsökningsinformation i assemblerkod" +msgstr "Mata ut utförlig felsökningsinformation i assemblerkod." #: config/cris/cris.opt:71 -#, fuzzy -#| msgid "Do not use condition codes from normal instructions" msgid "Do not use condition codes from normal instructions." -msgstr "Använd inte tillståndskoder från normala instruktioner" +msgstr "Använd inte tillståndskoder från normala instruktioner." #: config/cris/cris.opt:80 -#, fuzzy -#| msgid "Do not emit addressing modes with side-effect assignment" msgid "Do not emit addressing modes with side-effect assignment." -msgstr "Mata inte ut adresseringssätt med sidoeffekttilldelning" +msgstr "Mata inte ut adresseringssätt med sidoeffekttilldelning." #: config/cris/cris.opt:89 -#, fuzzy -#| msgid "Do not tune stack alignment" msgid "Do not tune stack alignment." -msgstr "Trimma inte stackjustering" +msgstr "Trimma inte stackjustering." #: config/cris/cris.opt:98 -#, fuzzy -#| msgid "Do not tune writable data alignment" msgid "Do not tune writable data alignment." -msgstr "Trimma inte justering för skrivbar data" +msgstr "Trimma inte justering för skrivbar data." #: config/cris/cris.opt:107 -#, fuzzy -#| msgid "Do not tune code and read-only data alignment" msgid "Do not tune code and read-only data alignment." -msgstr "Trimma inte justering för kod och endast läsbar data" +msgstr "Trimma inte justering för kod och endast läsbar data." #: config/cris/cris.opt:116 -#, fuzzy -#| msgid "Align code and data to 32 bits" msgid "Align code and data to 32 bits." -msgstr "Justera kod och data till 32 bitar" +msgstr "Justera kod och data till 32 bitar." #: config/cris/cris.opt:133 -#, fuzzy -#| msgid "Don't align items in code or data" msgid "Don't align items in code or data." -msgstr "Justera inte element i kod och data" +msgstr "Justera inte element i kod och data." #: config/cris/cris.opt:142 -#, fuzzy -#| msgid "Do not emit function prologue or epilogue" msgid "Do not emit function prologue or epilogue." -msgstr "Mata inte ut funktionsprolog eller -epilog" +msgstr "Mata inte ut funktionsprolog eller -epilog." #: config/cris/cris.opt:149 -#, fuzzy -#| msgid "Use the most feature-enabling options allowed by other options" msgid "Use the most feature-enabling options allowed by other options." -msgstr "Använd de flaggor bland övriga flaggor som slår på flest funktioner" +msgstr "Använd de flaggor bland övriga flaggor som slår på flest funktioner." #: config/cris/cris.opt:158 -#, fuzzy -#| msgid "Override -mbest-lib-options" msgid "Override -mbest-lib-options." -msgstr "Åsidosätt -mbest-lib-options" +msgstr "Åsidosätt -mbest-lib-options." #: config/cris/cris.opt:165 -#, fuzzy -#| msgid "-march=ARCH\tGenerate code for the specified chip or CPU version" msgid "-march=ARCH\tGenerate code for the specified chip or CPU version." -msgstr "-march=ARK\tGenerera kod för det angivna chip:et eller CPU-versionen" +msgstr "-march=ARK\tGenerera kod för det angivna chip:et eller CPU-versionen." #: config/cris/cris.opt:169 -#, fuzzy -#| msgid "-mtune=ARCH\tTune alignment for the specified chip or CPU version" msgid "-mtune=ARCH\tTune alignment for the specified chip or CPU version." -msgstr "-mtune=ARK\tTrimma justering för det angivna chip:et eller CPU-versionen" +msgstr "-mtune=ARK\tTrimma justering för det angivna chip:et eller CPU-versionen." #: config/cris/cris.opt:173 -#, fuzzy -#| msgid "-mmax-stackframe=SIZE\tWarn when a stackframe is larger than the specified size" msgid "-mmax-stackframe=SIZE\tWarn when a stackframe is larger than the specified size." -msgstr "-mmax-stackframe=STORLEK\tVarna när en stackram är större än den angivna storleken" +msgstr "-mmax-stackframe=STORLEK\tVarna när en stackram är större än den angivna storleken." #: config/cris/cris.opt:180 msgid "Emit traps as \"break 8\", default for CRIS v3 and up. If disabled, calls to abort() are used." msgstr "Mata ut fällor som ”break 8”, standard för CRIS v3 och uppåt. Om avaktiverat används anrop till abort()." #: config/cris/cris.opt:184 -#, fuzzy -#| msgid "Emit checks causing \"break 8\" instructions to execute when applying atomic builtins on misaligned memory" msgid "Emit checks causing \"break 8\" instructions to execute when applying atomic builtins on misaligned memory." -msgstr "Mata ut kontroller som får ”break 8”-instruktioner att köra när atomära inbyggda används på feljusterat minne" +msgstr "Mata ut kontroller som får ”break 8”-instruktioner att köra när atomära inbyggda används på feljusterat minne." #: config/cris/cris.opt:188 msgid "Handle atomic builtins that may be applied to unaligned data by calling library functions. Overrides -mtrap-unaligned-atomic." @@ -14605,266 +11855,180 @@ msgid "Runtime name." msgstr "Körtidsnamn." #: config/sh/sh.opt:48 -#, fuzzy -#| msgid "Generate SH1 code" msgid "Generate SH1 code." -msgstr "Generera SH1-kod" +msgstr "Generera SH1-kod." #: config/sh/sh.opt:52 -#, fuzzy -#| msgid "Generate SH2 code" msgid "Generate SH2 code." -msgstr "Generera SH2-kod" +msgstr "Generera SH2-kod." #: config/sh/sh.opt:56 -#, fuzzy -#| msgid "Generate default double-precision SH2a-FPU code" msgid "Generate default double-precision SH2a-FPU code." -msgstr "Generera normal dubbelprecisions SH2a-FPU-kod" +msgstr "Generera normal dubbelprecisions SH2a-FPU-kod." #: config/sh/sh.opt:60 -#, fuzzy -#| msgid "Generate SH2a FPU-less code" msgid "Generate SH2a FPU-less code." -msgstr "Generera SH2a-kod utan FPU" +msgstr "Generera SH2a-kod utan FPU." #: config/sh/sh.opt:64 -#, fuzzy -#| msgid "Generate default single-precision SH2a-FPU code" msgid "Generate default single-precision SH2a-FPU code." -msgstr "Generera normal enkelprecisions SH2a-FPU-kod" +msgstr "Generera normal enkelprecisions SH2a-FPU-kod." #: config/sh/sh.opt:68 -#, fuzzy -#| msgid "Generate only single-precision SH2a-FPU code" msgid "Generate only single-precision SH2a-FPU code." -msgstr "Generera endast enkelprecisions SH2a-FPU-kod" +msgstr "Generera endast enkelprecisions SH2a-FPU-kod." #: config/sh/sh.opt:72 -#, fuzzy -#| msgid "Generate SH2e code" msgid "Generate SH2e code." -msgstr "Generera SH2e-kod" +msgstr "Generera SH2e-kod." #: config/sh/sh.opt:76 -#, fuzzy -#| msgid "Generate SH3 code" msgid "Generate SH3 code." -msgstr "Generera SH3-kod" +msgstr "Generera SH3-kod." #: config/sh/sh.opt:80 -#, fuzzy -#| msgid "Generate SH3e code" msgid "Generate SH3e code." -msgstr "Generera SH3e-kod" +msgstr "Generera SH3e-kod." #: config/sh/sh.opt:84 -#, fuzzy -#| msgid "Generate SH4 code" msgid "Generate SH4 code." -msgstr "Generera SH4-kod" +msgstr "Generera SH4-kod." #: config/sh/sh.opt:88 -#, fuzzy -#| msgid "Generate SH4-100 code" msgid "Generate SH4-100 code." -msgstr "Generera SH4-100-kod" +msgstr "Generera SH4-100-kod." #: config/sh/sh.opt:92 -#, fuzzy -#| msgid "Generate SH4-200 code" msgid "Generate SH4-200 code." -msgstr "Generera SH4-200-kod" +msgstr "Generera SH4-200-kod." #: config/sh/sh.opt:98 -#, fuzzy -#| msgid "Generate SH4-300 code" msgid "Generate SH4-300 code." -msgstr "Generera SH4-300-kod" +msgstr "Generera SH4-300-kod." #: config/sh/sh.opt:102 -#, fuzzy -#| msgid "Generate SH4 FPU-less code" msgid "Generate SH4 FPU-less code." -msgstr "Generera SH4-kod utan FPU" +msgstr "Generera SH4-kod utan FPU." #: config/sh/sh.opt:106 -#, fuzzy -#| msgid "Generate SH4-100 FPU-less code" msgid "Generate SH4-100 FPU-less code." -msgstr "Generera SH4-100-kod utan FPU" +msgstr "Generera SH4-100-kod utan FPU." #: config/sh/sh.opt:110 -#, fuzzy -#| msgid "Generate SH4-200 FPU-less code" msgid "Generate SH4-200 FPU-less code." -msgstr "Generera SH4-200-kod utan FPU" +msgstr "Generera SH4-200-kod utan FPU." #: config/sh/sh.opt:114 -#, fuzzy -#| msgid "Generate SH4-300 FPU-less code" msgid "Generate SH4-300 FPU-less code." -msgstr "Generera SH4-300-kod utan FPU" +msgstr "Generera SH4-300-kod utan FPU." #: config/sh/sh.opt:118 -#, fuzzy -#| msgid "Generate code for SH4 340 series (MMU/FPU-less)" msgid "Generate code for SH4 340 series (MMU/FPU-less)." -msgstr "Generera kod för SH4 340-serien (saknar MMU/FPU)" +msgstr "Generera kod för SH4 340-serien (saknar MMU/FPU)." #: config/sh/sh.opt:123 -#, fuzzy -#| msgid "Generate code for SH4 400 series (MMU/FPU-less)" msgid "Generate code for SH4 400 series (MMU/FPU-less)." -msgstr "Generera kod för SH4 400-serien (saknar MMU/FPU)" +msgstr "Generera kod för SH4 400-serien (saknar MMU/FPU)." #: config/sh/sh.opt:128 msgid "Generate code for SH4 500 series (FPU-less)." msgstr "Generera kod för SH4-500-serien (utan FPU)." #: config/sh/sh.opt:133 -#, fuzzy -#| msgid "Generate default single-precision SH4 code" msgid "Generate default single-precision SH4 code." -msgstr "Generera normal enkelprecisions SH4-kod" +msgstr "Generera normal enkelprecisions SH4-kod." #: config/sh/sh.opt:137 -#, fuzzy -#| msgid "Generate default single-precision SH4-100 code" msgid "Generate default single-precision SH4-100 code." -msgstr "Generera normal enkelprecisions SH4-100-kod" +msgstr "Generera normal enkelprecisions SH4-100-kod." #: config/sh/sh.opt:141 -#, fuzzy -#| msgid "Generate default single-precision SH4-200 code" msgid "Generate default single-precision SH4-200 code." -msgstr "Generera normal enkelprecisions SH4-200-kod" +msgstr "Generera normal enkelprecisions SH4-200-kod." #: config/sh/sh.opt:145 -#, fuzzy -#| msgid "Generate default single-precision SH4-300 code" msgid "Generate default single-precision SH4-300 code." -msgstr "Generera normal enkelprecisions SH4-300-kod" +msgstr "Generera normal enkelprecisions SH4-300-kod." #: config/sh/sh.opt:149 -#, fuzzy -#| msgid "Generate only single-precision SH4 code" msgid "Generate only single-precision SH4 code." -msgstr "Generera endast enkelprecisions SH4-kod" +msgstr "Generera endast enkelprecisions SH4-kod." #: config/sh/sh.opt:153 -#, fuzzy -#| msgid "Generate only single-precision SH4-100 code" msgid "Generate only single-precision SH4-100 code." -msgstr "Generera endast enkelprecisions SH4-100-kod" +msgstr "Generera endast enkelprecisions SH4-100-kod." #: config/sh/sh.opt:157 -#, fuzzy -#| msgid "Generate only single-precision SH4-200 code" msgid "Generate only single-precision SH4-200 code." -msgstr "Generera endast enkelprecisions SH4-200-kod" +msgstr "Generera endast enkelprecisions SH4-200-kod." #: config/sh/sh.opt:161 -#, fuzzy -#| msgid "Generate only single-precision SH4-300 code" msgid "Generate only single-precision SH4-300 code." -msgstr "Generera endast enkelprecisions SH4-300-kod" +msgstr "Generera endast enkelprecisions SH4-300-kod." #: config/sh/sh.opt:165 -#, fuzzy -#| msgid "Generate SH4a code" msgid "Generate SH4a code." -msgstr "Generera SH4a-kod" +msgstr "Generera SH4a-kod." #: config/sh/sh.opt:169 -#, fuzzy -#| msgid "Generate SH4a FPU-less code" msgid "Generate SH4a FPU-less code." -msgstr "Generera SH4a-kod utan FPU" +msgstr "Generera SH4a-kod utan FPU." #: config/sh/sh.opt:173 -#, fuzzy -#| msgid "Generate default single-precision SH4a code" msgid "Generate default single-precision SH4a code." -msgstr "Generera normal enkelprecisions SH4a-kod" +msgstr "Generera normal enkelprecisions SH4a-kod." #: config/sh/sh.opt:177 -#, fuzzy -#| msgid "Generate only single-precision SH4a code" msgid "Generate only single-precision SH4a code." -msgstr "Generera endast enkelprecisions SH4a-kod" +msgstr "Generera endast enkelprecisions SH4a-kod." #: config/sh/sh.opt:181 -#, fuzzy -#| msgid "Generate SH4al-dsp code" msgid "Generate SH4al-dsp code." -msgstr "Generera SH4al-dsp-kod" +msgstr "Generera SH4al-dsp-kod." #: config/sh/sh.opt:185 -#, fuzzy -#| msgid "Generate 32-bit SHmedia code" msgid "Generate 32-bit SHmedia code." -msgstr "Generera 32-bitars SHmedia-kod" +msgstr "Generera 32-bitars SHmedia-kod." #: config/sh/sh.opt:189 -#, fuzzy -#| msgid "Generate 32-bit FPU-less SHmedia code" msgid "Generate 32-bit FPU-less SHmedia code." -msgstr "Generera 32-bitars SHmedia-kod utan FPU" +msgstr "Generera 32-bitars SHmedia-kod utan FPU." #: config/sh/sh.opt:193 -#, fuzzy -#| msgid "Generate 64-bit SHmedia code" msgid "Generate 64-bit SHmedia code." -msgstr "Generera 64-bitars SHmedia-kod" +msgstr "Generera 64-bitars SHmedia-kod." #: config/sh/sh.opt:197 -#, fuzzy -#| msgid "Generate 64-bit FPU-less SHmedia code" msgid "Generate 64-bit FPU-less SHmedia code." -msgstr "Generera 64-bitars SHmedia-kod utan FPU" +msgstr "Generera 64-bitars SHmedia-kod utan FPU." #: config/sh/sh.opt:201 -#, fuzzy -#| msgid "Generate SHcompact code" msgid "Generate SHcompact code." -msgstr "Generera SHcompact-kod" +msgstr "Generera SHcompact-kod." #: config/sh/sh.opt:205 -#, fuzzy -#| msgid "Generate FPU-less SHcompact code" msgid "Generate FPU-less SHcompact code." -msgstr "Generera SHcompact-kod utan FPU" +msgstr "Generera SHcompact-kod utan FPU." #: config/sh/sh.opt:217 -#, fuzzy -#| msgid "Generate code in big endian mode" msgid "Generate code in big endian mode." -msgstr "Generera kod för rak byteordning" +msgstr "Generera kod för rak byteordning." #: config/sh/sh.opt:221 -#, fuzzy -#| msgid "Generate 32-bit offsets in switch tables" msgid "Generate 32-bit offsets in switch tables." -msgstr "Använd 32-bitars avstånd i hopptabeller" +msgstr "Använd 32-bitars avstånd i hopptabeller." #: config/sh/sh.opt:225 -#, fuzzy -#| msgid "Generate bit instructions" msgid "Generate bit instructions." -msgstr "Generera bitinstruktioner" +msgstr "Generera bitinstruktioner." #: config/sh/sh.opt:229 -#, fuzzy -#| msgid "Cost to assume for a branch insn" msgid "Cost to assume for a branch insn." -msgstr "Kostnad att anta för en greninstruktion" +msgstr "Kostnad att anta för en greninstruktion." #: config/sh/sh.opt:233 -#, fuzzy -#| msgid "Assume that zero displacement conditional branches are fast" msgid "Assume that zero displacement conditional branches are fast." -msgstr "Anta att villkorliga grenar med noll förskjutning är snabba" +msgstr "Anta att villkorliga grenar med noll förskjutning är snabba." #: config/sh/sh.opt:236 config/sh/sh.opt:240 #, c-format @@ -14872,10 +12036,8 @@ msgid "%qs is deprecated and has no effect" msgstr "%qs avrådes ifrån och har ingen effekt" #: config/sh/sh.opt:237 -#, fuzzy -#| msgid "Enable cbranchdi4 pattern" msgid "Enable cbranchdi4 pattern." -msgstr "Aktivera cbranchdi4-mönster" +msgstr "Aktivera cbranchdi4-mönster." #: config/sh/sh.opt:241 msgid "Emit cmpeqdi_t pattern even when -mcbranchdi is in effect." @@ -14886,144 +12048,100 @@ msgid "Force the usage of delay slots for conditional branches." msgstr "Framtvinga användningen av fördröjningssteg för villkorliga grenar." #: config/sh/sh.opt:249 -#, fuzzy -#| msgid "Enable SH5 cut2 workaround" msgid "Enable SH5 cut2 workaround." -msgstr "Aktivera sätt att kringgå SH5 cut2" +msgstr "Aktivera sätt att kringgå SH5 cut2." #: config/sh/sh.opt:253 -#, fuzzy -#| msgid "Align doubles at 64-bit boundaries" msgid "Align doubles at 64-bit boundaries." -msgstr "Justera double på 64-bitarsgränser" +msgstr "Justera double på 64-bitarsgränser." #: config/sh/sh.opt:257 -#, fuzzy -#| msgid "Division strategy, one of: call, call2, fp, inv, inv:minlat, inv20u, inv20l, inv:call, inv:call2, inv:fp, call-div1, call-fp, call-table" msgid "Division strategy, one of: call, call2, fp, inv, inv:minlat, inv20u, inv20l, inv:call, inv:call2, inv:fp, call-div1, call-fp, call-table." -msgstr "Divisionsstrategi, en av: call, call2, fp, inv, inv:minlat, inv20u, inv20l, inv:call, inv:call2, inv:fp, call-div1, call-fp, call-table" +msgstr "Divisionsstrategi, en av: call, call2, fp, inv, inv:minlat, inv20u, inv20l, inv:call, inv:call2, inv:fp, call-div1, call-fp, call-table." #: config/sh/sh.opt:261 -#, fuzzy -#| msgid "Specify name for 32 bit signed division function" msgid "Specify name for 32 bit signed division function." -msgstr "Ange namnet på funktion för 32-bitars division med tecken" +msgstr "Ange namnet på funktion för 32-bitars division med tecken." #: config/sh/sh.opt:265 -#, fuzzy -#| msgid "Generate LP64 code" msgid "Generate ELF FDPIC code." -msgstr "Generera LP64-kod" +msgstr "Generera ELF FDPIC-kod." #: config/sh/sh.opt:269 msgid "Enable the use of 64-bit floating point registers in fmov instructions. See -mdalign if 64-bit alignment is required." msgstr "Möjliggör användningen av 64-bitars flyttalsregister i fmov-instruktioner. Se -mdalign om 64-bitars justering krävs." #: config/sh/sh.opt:277 -#, fuzzy -#| msgid "Cost to assume for gettr insn" msgid "Cost to assume for gettr insn." -msgstr "Kostnad att anta för getattr-instruktion" +msgstr "Kostnad att anta för getattr-instruktion." #: config/sh/sh.opt:281 config/sh/sh.opt:331 -#, fuzzy -#| msgid "Follow Renesas (formerly Hitachi) / SuperH calling conventions" msgid "Follow Renesas (formerly Hitachi) / SuperH calling conventions." -msgstr "Följ Renesas (tidigare Hitachi) / SuperH-anropskonventioner" +msgstr "Följ Renesas (tidigare Hitachi) / SuperH-anropskonventioner." #: config/sh/sh.opt:285 -#, fuzzy -#| msgid "Increase the IEEE compliance for floating-point comparisons" msgid "Increase the IEEE compliance for floating-point comparisons." -msgstr "Öka efterföljden av IEEE för flyttalsjämförelser" +msgstr "Öka efterföljden av IEEE för flyttalsjämförelser." #: config/sh/sh.opt:289 -#, fuzzy -#| msgid "Enable the use of the indexed addressing mode for SHmedia32/SHcompact" msgid "Enable the use of the indexed addressing mode for SHmedia32/SHcompact." -msgstr "Aktivera användning av det indexerade adresseringsläget för SHmedia32/SHcompact" +msgstr "Aktivera användning av det indexerade adresseringsläget för SHmedia32/SHcompact." #: config/sh/sh.opt:293 -#, fuzzy -#| msgid "inline code to invalidate instruction cache entries after setting up nested function trampolines" msgid "inline code to invalidate instruction cache entries after setting up nested function trampolines." -msgstr "inline:a kod för att invalidera instruktionscacheposter efter att nästade funktionstrampoliner satts upp" +msgstr "inline:a kod för att invalidera instruktionscacheposter efter att nästade funktionstrampoliner satts upp." #: config/sh/sh.opt:297 -#, fuzzy -#| msgid "Assume symbols might be invalid" msgid "Assume symbols might be invalid." -msgstr "Anta att symboler kan vara ogiltiga" +msgstr "Anta att symboler kan vara ogiltiga." #: config/sh/sh.opt:301 config/arc/arc.opt:209 -#, fuzzy -#| msgid "Annotate assembler instructions with estimated addresses" msgid "Annotate assembler instructions with estimated addresses." -msgstr "Annotera assemblerinstruktioner med bedömda adresser" +msgstr "Annotera assemblerinstruktioner med bedömda adresser." #: config/sh/sh.opt:305 -#, fuzzy -#| msgid "Generate code in little endian mode" msgid "Generate code in little endian mode." -msgstr "Generera kod för omvänd byteordning" +msgstr "Generera kod för omvänd byteordning." #: config/sh/sh.opt:309 -#, fuzzy -#| msgid "Mark MAC register as call-clobbered" msgid "Mark MAC register as call-clobbered." -msgstr "Markera MAC-register som anropsöverskrivna" +msgstr "Markera MAC-register som anropsöverskrivna." #: config/sh/sh.opt:315 -#, fuzzy -#| msgid "Make structs a multiple of 4 bytes (warning: ABI altered)" msgid "Make structs a multiple of 4 bytes (warning: ABI altered)." -msgstr "Gör poster en multipel av 4 byte (varning: ABI:et ändras)" +msgstr "Gör poster en multipel av 4 byte (varning: ABI:et ändras)." #: config/sh/sh.opt:319 -#, fuzzy -#| msgid "Emit function-calls using global offset table when generating PIC" msgid "Emit function-calls using global offset table when generating PIC." -msgstr "Mata ut funktionsanrop som använder en global avståndstabell när PIC genereras" +msgstr "Mata ut funktionsanrop som använder en global avståndstabell när PIC genereras." #: config/sh/sh.opt:323 msgid "Assume pt* instructions won't trap" msgstr "Anta att pt*-instruktioner inte utlöser fällor" #: config/sh/sh.opt:327 -#, fuzzy -#| msgid "Shorten address references during linking" msgid "Shorten address references during linking." -msgstr "Förkorta adressreferenser vid länkning" +msgstr "Förkorta adressreferenser vid länkning." #: config/sh/sh.opt:335 -#, fuzzy -#| msgid "Deprecated. Use -matomic= instead to select the atomic model" msgid "Deprecated. Use -matomic= instead to select the atomic model." -msgstr "Undanbedes. Använd -matomic= istället för att välja den atomära modellen" +msgstr "Undanbedes. Använd -matomic= istället för att välja den atomära modellen." #: config/sh/sh.opt:339 -#, fuzzy -#| msgid "Specify the model for atomic operations" msgid "Specify the model for atomic operations." -msgstr "Ange modellen för atomiska operationer" +msgstr "Ange modellen för atomiska operationer." #: config/sh/sh.opt:343 -#, fuzzy -#| msgid "Use tas.b instruction for __atomic_test_and_set" msgid "Use tas.b instruction for __atomic_test_and_set." -msgstr "Använd instruktionen tas.b till __atomic_test_and_set" +msgstr "Använd instruktionen tas.b till __atomic_test_and_set." #: config/sh/sh.opt:347 -#, fuzzy -#| msgid "Deprecated. Use -Os instead" msgid "Deprecated. Use -Os instead." -msgstr "Undanbedes. Använd -Os istället" +msgstr "Undanbedes. Använd -Os istället." #: config/sh/sh.opt:351 -#, fuzzy -#| msgid "Cost to assume for a multiply insn" msgid "Cost to assume for a multiply insn." -msgstr "Kostnad att anta för en multiplikationsinstruktion" +msgstr "Kostnad att anta för en multiplikationsinstruktion." #: config/sh/sh.opt:355 msgid "Don't generate privileged-mode only code; implies -mno-inline-ic_invalidate if the inline code would not work in user mode." @@ -15034,448 +12152,304 @@ msgid "Pretend a branch-around-a-move is a conditional move." msgstr "Låtsas en gren-runt-en-förflyttning är en villkorlig förflyttning." #: config/sh/sh.opt:365 -#, fuzzy -#| msgid "Enable the use of the fsca instruction" msgid "Enable the use of the fsca instruction." -msgstr "Aktivera användningen av instruktionen fsca" +msgstr "Aktivera användningen av instruktionen fsca." #: config/sh/sh.opt:369 -#, fuzzy -#| msgid "Enable the use of the fsrra instruction" msgid "Enable the use of the fsrra instruction." -msgstr "Aktivera användningen av instruktionen fsrra" +msgstr "Aktivera användningen av instruktionen fsrra." #: config/sh/sh.opt:373 -#, fuzzy -#| msgid "Use LRA instead of reload (transitional)" msgid "Use LRA instead of reload (transitional)." -msgstr "Använd LRA istället för reload (tillfällig)" +msgstr "Använd LRA istället för reload (tillfällig)." #: config/fr30/fr30.opt:23 -#, fuzzy -#| msgid "Assume small address space" msgid "Assume small address space." -msgstr "Anta liten adressrymd" +msgstr "Anta liten adressrymd." #: config/mep/mep.opt:23 -#, fuzzy -#| msgid "Enable absolute difference instructions" msgid "Enable absolute difference instructions." -msgstr "Använd instruktioner för absoluta skillnad" +msgstr "Använd instruktioner för absoluta skillnad." #: config/mep/mep.opt:27 -#, fuzzy -#| msgid "Enable all optional instructions" msgid "Enable all optional instructions." -msgstr "Använd alla valbara instruktioner" +msgstr "Använd alla valbara instruktioner." #: config/mep/mep.opt:31 -#, fuzzy -#| msgid "Enable average instructions" msgid "Enable average instructions." -msgstr "Använd genomsnittsinstruktioner" +msgstr "Använd genomsnittsinstruktioner." #: config/mep/mep.opt:35 -#, fuzzy -#| msgid "Variables this size and smaller go in the based section. (default 0)" msgid "Variables this size and smaller go in the based section. (default 0)." -msgstr "Variabler av denna storlek och mindre placeras i based-sektionen. (standard 0)" +msgstr "Variabler av denna storlek och mindre placeras i based-sektionen. (standard 0)." #: config/mep/mep.opt:39 -#, fuzzy -#| msgid "Enable bit manipulation instructions" msgid "Enable bit manipulation instructions." -msgstr "Använd bithanteringsinstruktioner" +msgstr "Använd bithanteringsinstruktioner." #: config/mep/mep.opt:43 -#, fuzzy -#| msgid "Section to put all const variables in (tiny, near, far) (no default)" msgid "Section to put all const variables in (tiny, near, far) (no default)." -msgstr "Sektion att lägga alla const-variabler i (tiny, near, far) (ingen standard)" +msgstr "Sektion att lägga alla const-variabler i (tiny, near, far) (ingen standard)." #: config/mep/mep.opt:47 -#, fuzzy -#| msgid "Enable clip instructions" msgid "Enable clip instructions." -msgstr "Använd clip-instruktioner" +msgstr "Använd clip-instruktioner." #: config/mep/mep.opt:51 -#, fuzzy -#| msgid "Configuration name" msgid "Configuration name." -msgstr "Konfigurationsnamn" +msgstr "Konfigurationsnamn." #: config/mep/mep.opt:55 -#, fuzzy -#| msgid "Enable MeP Coprocessor" msgid "Enable MeP Coprocessor." -msgstr "Använd MeP-hjälpprocessor" +msgstr "Använd MeP-hjälpprocessor." #: config/mep/mep.opt:59 -#, fuzzy -#| msgid "Enable MeP Coprocessor with 32-bit registers" msgid "Enable MeP Coprocessor with 32-bit registers." -msgstr "Använd MeP-koprocessor med 32-bitars register" +msgstr "Använd MeP-koprocessor med 32-bitars register." #: config/mep/mep.opt:63 -#, fuzzy -#| msgid "Enable MeP Coprocessor with 64-bit registers" msgid "Enable MeP Coprocessor with 64-bit registers." -msgstr "Använd MeP-koprocessor med 64-bitars register" +msgstr "Använd MeP-koprocessor med 64-bitars register." #: config/mep/mep.opt:67 -#, fuzzy -#| msgid "Enable IVC2 scheduling" msgid "Enable IVC2 scheduling." -msgstr "Använd IVC2-schemaläggning" +msgstr "Använd IVC2-schemaläggning." #: config/mep/mep.opt:71 -#, fuzzy -#| msgid "Const variables default to the near section" msgid "Const variables default to the near section." -msgstr "Const-variabler till near-sektionen som standard" +msgstr "Const-variabler till near-sektionen som standard." #: config/mep/mep.opt:78 -#, fuzzy -#| msgid "Enable 32-bit divide instructions" msgid "Enable 32-bit divide instructions." -msgstr "Använd 32-bitars divisionsinstruktioner" +msgstr "Använd 32-bitars divisionsinstruktioner." #: config/mep/mep.opt:93 -#, fuzzy -#| msgid "__io vars are volatile by default" msgid "__io vars are volatile by default." -msgstr "__io-variabler är volatila som standard" +msgstr "__io-variabler är volatila som standard." #: config/mep/mep.opt:97 -#, fuzzy -#| msgid "All variables default to the far section" msgid "All variables default to the far section." -msgstr "Alla variabler läggs som standard i far-sektionen" +msgstr "Alla variabler läggs som standard i far-sektionen." #: config/mep/mep.opt:101 -#, fuzzy -#| msgid "Enable leading zero instructions" msgid "Enable leading zero instructions." -msgstr "Använd instruktioner för inledande nollor" +msgstr "Använd instruktioner för inledande nollor." #: config/mep/mep.opt:108 -#, fuzzy -#| msgid "All variables default to the near section" msgid "All variables default to the near section." -msgstr "Alla variabler till near-sektionen som standard" +msgstr "Alla variabler till near-sektionen som standard." #: config/mep/mep.opt:112 -#, fuzzy -#| msgid "Enable min/max instructions" msgid "Enable min/max instructions." -msgstr "Använd min/max-instruktioner" +msgstr "Använd min/max-instruktioner." #: config/mep/mep.opt:116 -#, fuzzy -#| msgid "Enable 32-bit multiply instructions" msgid "Enable 32-bit multiply instructions." -msgstr "Använd 32-bitars multiplikationsinstruktioner" +msgstr "Använd 32-bitars multiplikationsinstruktioner." #: config/mep/mep.opt:120 -#, fuzzy -#| msgid "Disable all optional instructions" msgid "Disable all optional instructions." -msgstr "Använd inte några valbara instruktioner" +msgstr "Använd inte några valbara instruktioner." #: config/mep/mep.opt:127 -#, fuzzy -#| msgid "Allow gcc to use the repeat/erepeat instructions" msgid "Allow gcc to use the repeat/erepeat instructions." -msgstr "Tillåt gcc att använd repeat/erepeat-instruktionerna" +msgstr "Tillåt gcc att använd repeat/erepeat-instruktionerna." #: config/mep/mep.opt:131 -#, fuzzy -#| msgid "All variables default to the tiny section" msgid "All variables default to the tiny section." -msgstr "Alla variabler till tiny-sektionen som standard" +msgstr "Alla variabler till tiny-sektionen som standard." #: config/mep/mep.opt:135 -#, fuzzy -#| msgid "Enable saturation instructions" msgid "Enable saturation instructions." -msgstr "Använd mättnads-instruktioner" +msgstr "Använd mättnads-instruktioner." #: config/mep/mep.opt:139 -#, fuzzy -#| msgid "Use sdram version of runtime" msgid "Use sdram version of runtime." -msgstr "Använd sdram-version av körtidskod" +msgstr "Använd sdram-version av körtidskod." #: config/mep/mep.opt:147 -#, fuzzy -#| msgid "Use simulator runtime without vectors" msgid "Use simulator runtime without vectors." -msgstr "Använd simulatorkörtider utan vektorer" +msgstr "Använd simulatorkörtider utan vektorer." #: config/mep/mep.opt:151 -#, fuzzy -#| msgid "All functions default to the far section" msgid "All functions default to the far section." -msgstr "Alla funktioner till far-sektion som standard" +msgstr "Alla funktioner till far-sektion som standard." #: config/mep/mep.opt:155 -#, fuzzy -#| msgid "Variables this size and smaller go in the tiny section. (default 4)" msgid "Variables this size and smaller go in the tiny section. (default 4)." -msgstr "Variabler av denna storlek och mindre läggs i tiny-sektionen. (standard 4)" +msgstr "Variabler av denna storlek och mindre läggs i tiny-sektionen. (standard 4)." #: config/mips/mips.opt:32 -#, fuzzy -#| msgid "-mabi=ABI\tGenerate code that conforms to the given ABI" msgid "-mabi=ABI\tGenerate code that conforms to the given ABI." -msgstr "-mabi=ABI\tGenerera kod som följer det angivna ABI:et" +msgstr "-mabi=ABI\tGenerera kod som följer det angivna ABI:et." #: config/mips/mips.opt:36 msgid "Known MIPS ABIs (for use with the -mabi= option):" msgstr "Kända MIPS ABI:er (att användas med flaggan -mabi=):" #: config/mips/mips.opt:55 -#, fuzzy -#| msgid "Generate code that can be used in SVR4-style dynamic objects" msgid "Generate code that can be used in SVR4-style dynamic objects." -msgstr "Generera kod som kan användas i dynamiska objekt i SVR4-stil" +msgstr "Generera kod som kan användas i dynamiska objekt i SVR4-stil." #: config/mips/mips.opt:59 -#, fuzzy -#| msgid "Use PMC-style 'mad' instructions" msgid "Use PMC-style 'mad' instructions." -msgstr "Använd ”mad”-instruktioner i PMC-stil" +msgstr "Använd ”mad”-instruktioner i PMC-stil." #: config/mips/mips.opt:63 -#, fuzzy -#| msgid "Use integer madd/msub instructions" msgid "Use integer madd/msub instructions." -msgstr "Använd heltals-madd-/msub-instruktioner" +msgstr "Använd heltals-madd-/msub-instruktioner." #: config/mips/mips.opt:67 -#, fuzzy -#| msgid "-march=ISA\tGenerate code for the given ISA" msgid "-march=ISA\tGenerate code for the given ISA." -msgstr "-march=ISA\tGenerera kod för den angivna ISA:n" +msgstr "-march=ISA\tGenerera kod för den angivna ISA:n." #: config/mips/mips.opt:71 -#, fuzzy -#| msgid "-mbranch-cost=COST\tSet the cost of branches to roughly COST instructions" msgid "-mbranch-cost=COST\tSet the cost of branches to roughly COST instructions." -msgstr "-mbranch-cost=KOSTNAD\tAnge kostnaden för grenar till ungefär KOSTNAD instruktioner" +msgstr "-mbranch-cost=KOSTNAD\tAnge kostnaden för grenar till ungefär KOSTNAD instruktioner." #: config/mips/mips.opt:75 -#, fuzzy -#| msgid "Use Branch Likely instructions, overriding the architecture default" msgid "Use Branch Likely instructions, overriding the architecture default." -msgstr "Använd Branch Likely-instruktioner, åsidosätt arkitekturens standarval" +msgstr "Använd Branch Likely-instruktioner, åsidosätt arkitekturens standarval." #: config/mips/mips.opt:79 -#, fuzzy -#| msgid "Switch on/off MIPS16 ASE on alternating functions for compiler testing" msgid "Switch on/off MIPS16 ASE on alternating functions for compiler testing." -msgstr "Växla av/på MIPS16 ASE mellan alternerande funktioner för kompilatortestning" +msgstr "Växla av/på MIPS16 ASE mellan alternerande funktioner för kompilatortestning." #: config/mips/mips.opt:83 -#, fuzzy -#| msgid "Trap on integer divide by zero" msgid "Trap on integer divide by zero." -msgstr "Fånga heltalsdivision med noll" +msgstr "Fånga heltalsdivision med noll." #: config/mips/mips.opt:87 -#, fuzzy -#| msgid "-mcode-readable=SETTING\tSpecify when instructions are allowed to access code" msgid "-mcode-readable=SETTING\tSpecify when instructions are allowed to access code." -msgstr "-code-readable=INSTÄLLNING\tAnge när instruktioner tillåts komma åt kod" +msgstr "-code-readable=INSTÄLLNING\tAnge när instruktioner tillåts komma åt kod." #: config/mips/mips.opt:91 msgid "Valid arguments to -mcode-readable=:" msgstr "Giltiga argument till -mcode-readable=:" #: config/mips/mips.opt:104 -#, fuzzy -#| msgid "Use branch-and-break sequences to check for integer divide by zero" msgid "Use branch-and-break sequences to check for integer divide by zero." -msgstr "Använd branch-and-break-sekvenser för att upptäcka heltalsdivision med noll" +msgstr "Använd branch-and-break-sekvenser för att upptäcka heltalsdivision med noll." #: config/mips/mips.opt:108 -#, fuzzy -#| msgid "Use trap instructions to check for integer divide by zero" msgid "Use trap instructions to check for integer divide by zero." -msgstr "Fånga trap-instruktioner för att upptäcka heltalsdivision med noll" +msgstr "Fånga trap-instruktioner för att upptäcka heltalsdivision med noll." #: config/mips/mips.opt:112 -#, fuzzy -#| msgid "Allow the use of MDMX instructions" msgid "Allow the use of MDMX instructions." -msgstr "Tillåt användningen av MDMX-instruktioner" +msgstr "Tillåt användningen av MDMX-instruktioner." #: config/mips/mips.opt:116 -#, fuzzy -#| msgid "Allow hardware floating-point instructions to cover both 32-bit and 64-bit operations" msgid "Allow hardware floating-point instructions to cover both 32-bit and 64-bit operations." -msgstr "Tillåt flyttalsinstruktioner i hårdvara att täcka både 32-bitars och 64-bitars operationer" +msgstr "Tillåt flyttalsinstruktioner i hårdvara att täcka både 32-bitars och 64-bitars operationer." #: config/mips/mips.opt:120 -#, fuzzy -#| msgid "Use MIPS-DSP instructions" msgid "Use MIPS-DSP instructions." -msgstr "Använd MIPS-DSP-instruktioner" +msgstr "Använd MIPS-DSP-instruktioner." #: config/mips/mips.opt:124 -#, fuzzy -#| msgid "Use MIPS-DSP REV 2 instructions" msgid "Use MIPS-DSP REV 2 instructions." -msgstr "Använd MIPS-DSP REV 2-instruktioner" +msgstr "Använd MIPS-DSP REV 2-instruktioner." #: config/mips/mips.opt:146 -#, fuzzy -#| msgid "Use Enhanced Virtual Addressing instructions" msgid "Use Enhanced Virtual Addressing instructions." -msgstr "Använd instruktioner för förbättrad virtuell adressering" +msgstr "Använd instruktioner för förbättrad virtuell adressering." #: config/mips/mips.opt:150 -#, fuzzy -#| msgid "Use NewABI-style %reloc() assembly operators" msgid "Use NewABI-style %reloc() assembly operators." -msgstr "Använd assembleroperator %reloc() i NewABI-stil" +msgstr "Använd assembleroperator %reloc() i NewABI-stil." #: config/mips/mips.opt:154 -#, fuzzy -#| msgid "Use -G for data that is not defined by the current object" msgid "Use -G for data that is not defined by the current object." -msgstr "Använd -G för data som inte är definierat av det aktuella objektet" +msgstr "Använd -G för data som inte är definierat av det aktuella objektet." #: config/mips/mips.opt:158 -#, fuzzy -#| msgid "Work around certain 24K errata" msgid "Work around certain 24K errata." -msgstr "Gå runt vissa fel i 24K" +msgstr "Gå runt vissa fel i 24K." #: config/mips/mips.opt:162 -#, fuzzy -#| msgid "Work around certain R4000 errata" msgid "Work around certain R4000 errata." -msgstr "Gå runt vissa fel i R4000" +msgstr "Gå runt vissa fel i R4000." #: config/mips/mips.opt:166 -#, fuzzy -#| msgid "Work around certain R4400 errata" msgid "Work around certain R4400 errata." -msgstr "Gå runt vissa fel i R4400" +msgstr "Gå runt vissa fel i R4400." #: config/mips/mips.opt:170 -#, fuzzy -#| msgid "Work around certain RM7000 errata" msgid "Work around certain RM7000 errata." -msgstr "Gå runt vissa fel i RM7000" +msgstr "Gå runt vissa fel i RM7000." #: config/mips/mips.opt:174 -#, fuzzy -#| msgid "Work around certain R10000 errata" msgid "Work around certain R10000 errata." -msgstr "Gå runt vissa fel i R10000" +msgstr "Gå runt vissa fel i R10000." #: config/mips/mips.opt:178 -#, fuzzy -#| msgid "Work around errata for early SB-1 revision 2 cores" msgid "Work around errata for early SB-1 revision 2 cores." -msgstr "Gå runt fel i tidiga SB-1 revision 2-kärnor" +msgstr "Gå runt fel i tidiga SB-1 revision 2-kärnor." #: config/mips/mips.opt:182 -#, fuzzy -#| msgid "Work around certain VR4120 errata" msgid "Work around certain VR4120 errata." -msgstr "Gå runt vissa fel i VR4120" +msgstr "Gå runt vissa fel i VR4120." #: config/mips/mips.opt:186 -#, fuzzy -#| msgid "Work around VR4130 mflo/mfhi errata" msgid "Work around VR4130 mflo/mfhi errata." -msgstr "Gå runt mflo/mfhi-fel i VR4130" +msgstr "Gå runt mflo/mfhi-fel i VR4130." #: config/mips/mips.opt:190 -#, fuzzy -#| msgid "Work around an early 4300 hardware bug" msgid "Work around an early 4300 hardware bug." -msgstr "Gå runt ett hårdvarufel i tidiga 4300" +msgstr "Gå runt ett hårdvarufel i tidiga 4300." #: config/mips/mips.opt:194 -#, fuzzy -#| msgid "FP exceptions are enabled" msgid "FP exceptions are enabled." -msgstr "FP-undantag är aktiverade" +msgstr "FP-undantag är aktiverade." #: config/mips/mips.opt:198 -#, fuzzy -#| msgid "Use 32-bit floating-point registers" msgid "Use 32-bit floating-point registers." -msgstr "Använd 32-bitars flyttalsregister" +msgstr "Använd 32-bitars flyttalsregister." #: config/mips/mips.opt:202 -#, fuzzy -#| msgid "Conform to the o32 FPXX ABI" msgid "Conform to the o32 FPXX ABI." -msgstr "Följ ABI:t o32 FPXX" +msgstr "Följ ABI:t o32 FPXX." #: config/mips/mips.opt:206 -#, fuzzy -#| msgid "Use 64-bit floating-point registers" msgid "Use 64-bit floating-point registers." -msgstr "Använd 64-bitars flyttalsregister" +msgstr "Använd 64-bitars flyttalsregister." #: config/mips/mips.opt:210 -#, fuzzy -#| msgid "-mflush-func=FUNC\tUse FUNC to flush the cache before calling stack trampolines" msgid "-mflush-func=FUNC\tUse FUNC to flush the cache before calling stack trampolines." -msgstr "-mflush-func=FUNK\tAnvänd FUNK för att tömma cachen föra anrop av stacktrampoliner" +msgstr "-mflush-func=FUNK\tAnvänd FUNK för att tömma cachen föra anrop av stacktrampoliner." #: config/mips/mips.opt:214 -#, fuzzy -#| msgid "-mabs=MODE\tSelect the IEEE 754 ABS/NEG instruction execution mode" msgid "-mabs=MODE\tSelect the IEEE 754 ABS/NEG instruction execution mode." -msgstr "-mabs=MODE\tVälj exekveringsläget IEEE 754 för instruktionerna ABS/NEG" +msgstr "-mabs=MODE\tVälj exekveringsläget IEEE 754 för instruktionerna ABS/NEG." #: config/mips/mips.opt:218 -#, fuzzy -#| msgid "-mnan=ENCODING\tSelect the IEEE 754 NaN data encoding" msgid "-mnan=ENCODING\tSelect the IEEE 754 NaN data encoding." -msgstr "-mnan=ENCODING\tVälj NaN-datakodningen IEEE 754" +msgstr "-mnan=ENCODING\tVälj NaN-datakodningen IEEE 754." #: config/mips/mips.opt:222 msgid "Known MIPS IEEE 754 settings (for use with the -mabs= and -mnan= options):" msgstr "Kända MIPS IEEE 754-inställningar (att användas med flaggorna -mabs= och -mnan=):" #: config/mips/mips.opt:232 -#, fuzzy -#| msgid "Use 32-bit general registers" msgid "Use 32-bit general registers." -msgstr "Använd 32-bitars allmänna register" +msgstr "Använd 32-bitars allmänna register." #: config/mips/mips.opt:236 -#, fuzzy -#| msgid "Use 64-bit general registers" msgid "Use 64-bit general registers." -msgstr "Använd 64-bitars allmänna register" +msgstr "Använd 64-bitars allmänna register." #: config/mips/mips.opt:240 -#, fuzzy -#| msgid "Use GP-relative addressing to access small data" msgid "Use GP-relative addressing to access small data." -msgstr "Använd GP-relativ adressering för att komma åt små data" +msgstr "Använd GP-relativ adressering för att komma åt små data." #: config/mips/mips.opt:244 -#, fuzzy -#| msgid "When generating -mabicalls code, allow executables to use PLTs and copy relocations" msgid "When generating -mabicalls code, allow executables to use PLTs and copy relocations." -msgstr "Vid generering av -mabicalls-kod, tillåt körbara att använda PLT:er och kopieringsomlokaliseringar" +msgstr "Vid generering av -mabicalls-kod, tillåt körbara att använda PLT:er och kopieringsomlokaliseringar." #: config/mips/mips.opt:248 -#, fuzzy -#| msgid "Allow the use of hardware floating-point ABI and instructions" msgid "Allow the use of hardware floating-point ABI and instructions." -msgstr "Tillåt användningen av flyttalsinstruktioner och -ABI i hårdvara" +msgstr "Tillåt användningen av flyttalsinstruktioner och -ABI i hårdvara." #: config/mips/mips.opt:252 msgid "Generate code that is link-compatible with MIPS16 and microMIPS code." @@ -15486,224 +12460,152 @@ msgid "An alias for minterlink-compressed provided for backward-compatibility." msgstr "Ett alias för minterlink-compressed som finns för bakåtkompatibilitet." #: config/mips/mips.opt:260 -#, fuzzy -#| msgid "-mipsN\tGenerate code for ISA level N" msgid "-mipsN\tGenerate code for ISA level N." -msgstr "-mipsN\tGenerera kod för ISA nivå N" +msgstr "-mipsN\tGenerera kod för ISA nivå N." #: config/mips/mips.opt:264 -#, fuzzy -#| msgid "Generate MIPS16 code" msgid "Generate MIPS16 code." -msgstr "Generera MIPS16-kod" +msgstr "Generera MIPS16-kod." #: config/mips/mips.opt:268 -#, fuzzy -#| msgid "Use MIPS-3D instructions" msgid "Use MIPS-3D instructions." -msgstr "Använd MIPS-3D-instruktioner" +msgstr "Använd MIPS-3D-instruktioner." #: config/mips/mips.opt:272 -#, fuzzy -#| msgid "Use ll, sc and sync instructions" msgid "Use ll, sc and sync instructions." -msgstr "Använd ll-, sc- och sync-instruktioner" +msgstr "Använd ll-, sc- och sync-instruktioner." #: config/mips/mips.opt:276 -#, fuzzy -#| msgid "Use -G for object-local data" msgid "Use -G for object-local data." -msgstr "Använd -G för objektlokala data" +msgstr "Använd -G för objektlokala data." #: config/mips/mips.opt:280 -#, fuzzy -#| msgid "Use indirect calls" msgid "Use indirect calls." -msgstr "Använd indirekta anrop" +msgstr "Använd indirekta anrop." #: config/mips/mips.opt:284 -#, fuzzy -#| msgid "Use a 32-bit long type" msgid "Use a 32-bit long type." -msgstr "Använd en 32-bitars long-typ" +msgstr "Använd en 32-bitars long-typ." #: config/mips/mips.opt:288 -#, fuzzy -#| msgid "Use a 64-bit long type" msgid "Use a 64-bit long type." -msgstr "Använd en 64-bitars long-typ" +msgstr "Använd en 64-bitars long-typ." #: config/mips/mips.opt:292 -#, fuzzy -#| msgid "Pass the address of the ra save location to _mcount in $12" msgid "Pass the address of the ra save location to _mcount in $12." -msgstr "Skicka adressen på ra-lagringsplatsen till _mcount i $12" +msgstr "Skicka adressen på ra-lagringsplatsen till _mcount i $12." #: config/mips/mips.opt:296 -#, fuzzy -#| msgid "Don't optimize block moves" msgid "Don't optimize block moves." -msgstr "Optimera inte blockförflyttningar" +msgstr "Optimera inte blockförflyttningar." #: config/mips/mips.opt:300 -#, fuzzy -#| msgid "Use microMIPS instructions" msgid "Use microMIPS instructions." -msgstr "Använd microMIPS-instruktioner" +msgstr "Använd microMIPS-instruktioner." #: config/mips/mips.opt:304 -#, fuzzy -#| msgid "Allow the use of MT instructions" msgid "Allow the use of MT instructions." -msgstr "Tillåt användning av MT-instruktioner" +msgstr "Tillåt användning av MT-instruktioner." #: config/mips/mips.opt:308 -#, fuzzy -#| msgid "Prevent the use of all floating-point operations" msgid "Prevent the use of all floating-point operations." -msgstr "Förhindra användningen av alla flyttalsoperationer" +msgstr "Förhindra användningen av alla flyttalsoperationer." #: config/mips/mips.opt:312 -#, fuzzy -#| msgid "Use MCU instructions" msgid "Use MCU instructions." -msgstr "Använd MCU-instruktioner" +msgstr "Använd MCU-instruktioner." #: config/mips/mips.opt:316 -#, fuzzy -#| msgid "Do not use a cache-flushing function before calling stack trampolines" msgid "Do not use a cache-flushing function before calling stack trampolines." -msgstr "Använd inte en cachetömmande funktion före anrop av stacktrampoliner" +msgstr "Använd inte en cachetömmande funktion före anrop av stacktrampoliner." #: config/mips/mips.opt:320 -#, fuzzy -#| msgid "Do not use MDMX instructions" msgid "Do not use MDMX instructions." -msgstr "Använd inte MDMX-instruktioner" +msgstr "Använd inte MDMX-instruktioner." #: config/mips/mips.opt:324 -#, fuzzy -#| msgid "Generate normal-mode code" msgid "Generate normal-mode code." -msgstr "Generera kod för normalläge" +msgstr "Generera kod för normalläge." #: config/mips/mips.opt:328 -#, fuzzy -#| msgid "Do not use MIPS-3D instructions" msgid "Do not use MIPS-3D instructions." -msgstr "Använd inte MIPS-3D-instruktioner" +msgstr "Använd inte MIPS-3D-instruktioner." #: config/mips/mips.opt:332 -#, fuzzy -#| msgid "Use paired-single floating-point instructions" msgid "Use paired-single floating-point instructions." -msgstr "Använd parvisa enkla flyttalsinstruktioner" +msgstr "Använd parvisa enkla flyttalsinstruktioner." #: config/mips/mips.opt:336 -#, fuzzy -#| msgid "-mr10k-cache-barrier=SETTING\tSpecify when r10k cache barriers should be inserted" msgid "-mr10k-cache-barrier=SETTING\tSpecify when r10k cache barriers should be inserted." -msgstr "-mr10k-cache-barrier=INSTÄLLNING\tAnge när r10k-cache-barriärer skall skjutas in" +msgstr "-mr10k-cache-barrier=INSTÄLLNING\tAnge när r10k-cache-barriärer skall skjutas in." #: config/mips/mips.opt:340 msgid "Valid arguments to -mr10k-cache-barrier=:" msgstr "Giltiga argument till -mr10k-cache-barrier=:" #: config/mips/mips.opt:353 -#, fuzzy -#| msgid "Try to allow the linker to turn PIC calls into direct calls" msgid "Try to allow the linker to turn PIC calls into direct calls." -msgstr "Försök att tillåta länkaren att göra om PIC-anrop till direkta anrop" +msgstr "Försök att tillåta länkaren att göra om PIC-anrop till direkta anrop." #: config/mips/mips.opt:357 -#, fuzzy -#| msgid "When generating -mabicalls code, make the code suitable for use in shared libraries" msgid "When generating -mabicalls code, make the code suitable for use in shared libraries." -msgstr "Vid generering av -mabicalls-kod, gör så att koden passar för användning i delade bibliotek" +msgstr "Vid generering av -mabicalls-kod, gör så att koden passar för användning i delade bibliotek." #: config/mips/mips.opt:361 -#, fuzzy -#| msgid "Restrict the use of hardware floating-point instructions to 32-bit operations" msgid "Restrict the use of hardware floating-point instructions to 32-bit operations." -msgstr "Begränsa användningen av flyttalsinstruktioner i hårdvara till 32-bitars operationer" +msgstr "Begränsa användningen av flyttalsinstruktioner i hårdvara till 32-bitars operationer." #: config/mips/mips.opt:365 -#, fuzzy -#| msgid "Use SmartMIPS instructions" msgid "Use SmartMIPS instructions." -msgstr "Använd SmartMIPS-instruktioner" +msgstr "Använd SmartMIPS-instruktioner." #: config/mips/mips.opt:369 -#, fuzzy -#| msgid "Prevent the use of all hardware floating-point instructions" msgid "Prevent the use of all hardware floating-point instructions." -msgstr "Förhindra användningen av alla flyttalsinstruktioner i hårdvara" +msgstr "Förhindra användningen av alla flyttalsinstruktioner i hårdvara." #: config/mips/mips.opt:373 -#, fuzzy -#| msgid "Optimize lui/addiu address loads" msgid "Optimize lui/addiu address loads." -msgstr "Optimera adressinläsningar lui/addiu" +msgstr "Optimera adressladdning lui/addiu." #: config/mips/mips.opt:377 -#, fuzzy -#| msgid "Assume all symbols have 32-bit values" msgid "Assume all symbols have 32-bit values." -msgstr "Anta att alla symboler har 32-bitsvärden" +msgstr "Anta att alla symboler har 32-bitsvärden." #: config/mips/mips.opt:381 -#, fuzzy -#| msgid "Use synci instruction to invalidate i-cache" msgid "Use synci instruction to invalidate i-cache." -msgstr "Använd synci-instruktioner för att invalidera i-cachen" +msgstr "Använd synci-instruktioner för att invalidera i-cachen." #: config/mips/mips.opt:389 -#, fuzzy -#| msgid "-mtune=PROCESSOR\tOptimize the output for PROCESSOR" msgid "-mtune=PROCESSOR\tOptimize the output for PROCESSOR." -msgstr "-mtune=PROCESSOR\tOptimera utmatningen för PROCESSOR" +msgstr "-mtune=PROCESSOR\tOptimera utmatningen för PROCESSOR." #: config/mips/mips.opt:397 -#, fuzzy -#| msgid "Use Virtualization Application Specific instructions" msgid "Use Virtualization Application Specific instructions." -msgstr "Använd instruktioner specifika för virtualiseringstillämpningar" +msgstr "Använd instruktioner specifika för virtualiseringstillämpningar." #: config/mips/mips.opt:401 -#, fuzzy -#| msgid "Use eXtended Physical Address (XPA) instructions" msgid "Use eXtended Physical Address (XPA) instructions." -msgstr "Använd instruktioner för utökad fysisk adress (XPA)" +msgstr "Använd instruktioner för utökad fysisk adress (XPA)." #: config/mips/mips.opt:405 -#, fuzzy -#| msgid "Perform VR4130-specific alignment optimizations" msgid "Perform VR4130-specific alignment optimizations." -msgstr "Utför VR4130-specifik justeringsoptimering" +msgstr "Utför VR4130-specifik justeringsoptimering." #: config/mips/mips.opt:409 -#, fuzzy -#| msgid "Lift restrictions on GOT size" msgid "Lift restrictions on GOT size." -msgstr "Lyft restriktioner på GOT-storlek" +msgstr "Lyft restriktioner på GOT-storlek." #: config/mips/mips.opt:413 -#, fuzzy -#| msgid "Enable use of odd-numbered single-precision registers" msgid "Enable use of odd-numbered single-precision registers." -msgstr "Aktivera användningen av udda enkelprecisionsregister" +msgstr "Aktivera användningen av udda enkelprecisionsregister." #: config/mips/mips.opt:417 -#, fuzzy -#| msgid "Optimize for space rather than speed" msgid "Optimize frame header." -msgstr "Optimera för storlek istället för hastighet" +msgstr "Optimera ramhuvud." #: config/mips/mips.opt:424 -#, fuzzy -#| msgid "Enable dead store elimination" msgid "Enable load/store bonding." -msgstr "Aktivera eliminering av död lagring" +msgstr "Aktivera bindning av laddning/lagring." #: config/mips/mips.opt:428 msgid "Specify the compact branch usage policy." @@ -15734,140 +12636,96 @@ msgid "Compile with 64 bit longs and pointers." msgstr "Kompilera för 64-bitars långa och pekare." #: config/tilegx/tilegx.opt:53 -#, fuzzy -#| msgid "Use given TILE-Gx code model" msgid "Use given TILE-Gx code model." -msgstr "Använd angiven TILE-Gx kodmodell" +msgstr "Använd angiven TILE-Gx kodmodell." #: config/arc/arc.opt:26 -#, fuzzy -#| msgid "Compile code for big endian mode" msgid "Compile code for big endian mode." -msgstr "Kompilera kod för rak byteordning" +msgstr "Kompilera kod för rak byteordning." #: config/arc/arc.opt:30 -#, fuzzy -#| msgid "Compile code for little endian mode. This is the default" msgid "Compile code for little endian mode. This is the default." -msgstr "Kompilera kod för omvänd byteordning. Detta är standard." +msgstr "Kompilera kod för omvänd byteordning. Detta är standard.." #: config/arc/arc.opt:34 -#, fuzzy -#| msgid "Disable ARCompact specific pass to generate conditional execution instructions" msgid "Disable ARCompact specific pass to generate conditional execution instructions." -msgstr "Avaktivera det ARCompact-specifika passet för att generera villkorliga exekveringsinstruktioner" +msgstr "Avaktivera det ARCompact-specifika passet för att generera villkorliga exekveringsinstruktioner." #: config/arc/arc.opt:38 -#, fuzzy -#| msgid "Generate ARCompact 32-bit code for ARC600 processor" msgid "Generate ARCompact 32-bit code for ARC600 processor." -msgstr "Generera ARCompact 32-bitars kod för processorn ARC600" +msgstr "Generera ARCompact 32-bitars kod för processorn ARC600." #: config/arc/arc.opt:42 -#, fuzzy -#| msgid "Same as -mA6" msgid "Same as -mA6." -msgstr "Samma som -mA6" +msgstr "Samma som -mA6." #: config/arc/arc.opt:46 -#, fuzzy -#| msgid "Generate ARCompact 32-bit code for ARC601 processor" msgid "Generate ARCompact 32-bit code for ARC601 processor." -msgstr "Generera ARCompact 32-bitars kod för processorn ARC601" +msgstr "Generera ARCompact 32-bitars kod för processorn ARC601." #: config/arc/arc.opt:50 -#, fuzzy -#| msgid "Generate ARCompact 32-bit code for ARC700 processor" msgid "Generate ARCompact 32-bit code for ARC700 processor." -msgstr "Generera ARCompact 32-bitars kod för processorn ARC700" +msgstr "Generera ARCompact 32-bitars kod för processorn ARC700." #: config/arc/arc.opt:54 -#, fuzzy -#| msgid "Same as -mA7" msgid "Same as -mA7." -msgstr "Samma som -mA7" +msgstr "Samma som -mA7." #: config/arc/arc.opt:58 msgid "-mmpy-option={0,1,2,3,4,5,6,7,8,9} Compile ARCv2 code with a multiplier design option. Option 2 is default on." msgstr "-mmpy-option={0,1,2,3,4,5,6,7,8,9} Kompilera ARCv2-kod med en multiplicerardesignflagga. Flaggan 2 är normalt på." #: config/arc/arc.opt:62 -#, fuzzy -#| msgid "Enable MUL instructions" msgid "Enable DIV-REM instructions for ARCv2." -msgstr "Använd MUL-instruktioner" +msgstr "Använd DIV-REM-instruktioner för ARCv2." #: config/arc/arc.opt:66 -#, fuzzy -#| msgid "Enable barrel shift instructions" msgid "Enable code density instructions for ARCv2." -msgstr "Använd barrel-shift-instruktioner" +msgstr "Använd koddensitetsinstruktioner för ARCv2." #: config/arc/arc.opt:70 -#, fuzzy -#| msgid "Tweak register allocation to help 16-bit instruction generation" msgid "Tweak register allocation to help 16-bit instruction generation." -msgstr "Justera registerallokeringen för att hjälpa generering av 16-bitars instruktioner" +msgstr "Justera registerallokeringen för att hjälpa generering av 16-bitars instruktioner." #: config/arc/arc.opt:80 -#, fuzzy -#| msgid "Use ordinarily cached memory accesses for volatile references" msgid "Use ordinarily cached memory accesses for volatile references." -msgstr "Använd normalt cachade minnesaccesser för volatila referenser" +msgstr "Använd normalt cachade minnesaccesser för volatila referenser." #: config/arc/arc.opt:84 -#, fuzzy -#| msgid "Enable cache bypass for volatile references" msgid "Enable cache bypass for volatile references." -msgstr "Aktivera kringgående av cachen för volatila referenser" +msgstr "Aktivera kringgående av cachen för volatila referenser." #: config/arc/arc.opt:88 -#, fuzzy -#| msgid "Generate instructions supported by barrel shifter" msgid "Generate instructions supported by barrel shifter." -msgstr "Generera instruktioner som stöds av tunnskiftaren" +msgstr "Generera instruktioner som stöds av tunnskiftaren." #: config/arc/arc.opt:92 -#, fuzzy -#| msgid "Generate norm instruction" msgid "Generate norm instruction." -msgstr "Generera norm-instruktion" +msgstr "Generera norm-instruktion." #: config/arc/arc.opt:96 -#, fuzzy -#| msgid "Generate swap instruction" msgid "Generate swap instruction." -msgstr "Generera swap-instruktion" +msgstr "Generera swap-instruktion." #: config/arc/arc.opt:100 -#, fuzzy -#| msgid "Generate mul64 and mulu64 instructions" msgid "Generate mul64 and mulu64 instructions." -msgstr "Generera mul64- och mulu64-instruktioner" +msgstr "Generera mul64- och mulu64-instruktioner." #: config/arc/arc.opt:104 -#, fuzzy -#| msgid "Do not generate mpy instructions for ARC700" msgid "Do not generate mpy instructions for ARC700." -msgstr "Generera inte mpy-instruktioner för ARC700" +msgstr "Generera inte mpy-instruktioner för ARC700." #: config/arc/arc.opt:108 -#, fuzzy -#| msgid "Generate Extended arithmetic instructions. Currently only divaw, adds, subs and sat16 are supported" msgid "Generate Extended arithmetic instructions. Currently only divaw, adds, subs and sat16 are supported." -msgstr "Generera utökade aritmetiska instruktioner. För närvarande stödjs endast divaw, adds, subs och sat16" +msgstr "Generera utökade aritmetiska instruktioner. För närvarande stödjs endast divaw, adds, subs och sat16." #: config/arc/arc.opt:112 -#, fuzzy -#| msgid "Dummy flag. This is the default unless FPX switches are provided explicitly" msgid "Dummy flag. This is the default unless FPX switches are provided explicitly." -msgstr "Attrappflagga. Detta är standard om inte FPX-flaggor uttryckligen ges" +msgstr "Attrappflagga. Detta är standard om inte FPX-flaggor uttryckligen ges." #: config/arc/arc.opt:116 -#, fuzzy -#| msgid "Generate call insns as register indirect calls" msgid "Generate call insns as register indirect calls." -msgstr "Generera anropsinstruktioner som registerindirekta anrop" +msgstr "Generera anropsinstruktioner som registerindirekta anrop." #: config/arc/arc.opt:120 msgid "Do no generate BRcc instructions in arc_reorg." @@ -15878,10 +12736,8 @@ msgid "Generate sdata references. This is the default, unless you compile for P msgstr "Generera sdata-referenser. Detta är standard, om man inte kompilerar för PIC." #: config/arc/arc.opt:128 -#, fuzzy -#| msgid "Do not generate millicode thunks (needed only with -Os)" msgid "Do not generate millicode thunks (needed only with -Os)." -msgstr "Generera inte millikodsnutt (behövs endast med -Os)" +msgstr "Generera inte millikodsnutt (behövs endast med -Os)." #: config/arc/arc.opt:132 config/arc/arc.opt:136 msgid "FPX: Generate Single Precision FPX (compact) instructions." @@ -15912,16 +12768,12 @@ msgid "Enable generation of ARC SIMD instructions via target-specific builtins." msgstr "Aktivera generering av ARC SIMD-instruktioner via målspecifika inbyggda." #: config/arc/arc.opt:168 -#, fuzzy -#| msgid "-mcpu=CPU\tCompile code for ARC variant CPU" msgid "-mcpu=CPU\tCompile code for ARC variant CPU." -msgstr "-mcpu=CPU\tKompilera kod för ARC-variant av CPU" +msgstr "-mcpu=CPU\tKompilera kod för ARC-variant av CPU." #: config/arc/arc.opt:205 -#, fuzzy -#| msgid "size optimization level: 0:none 1:opportunistic 2: regalloc 3:drop align, -Os" msgid "size optimization level: 0:none 1:opportunistic 2: regalloc 3:drop align, -Os." -msgstr "nivå på storleksoptimering: 0:ingen 1:opportunistisk 2:reg-allok 3:släpp justering, -Os" +msgstr "nivå på storleksoptimering: 0:ingen 1:opportunistisk 2:reg-allok 3:släpp justering, -Os." #: config/arc/arc.opt:213 msgid "Cost to assume for a multiply instruction, with 4 being equal to a normal insn." @@ -15944,26 +12796,20 @@ msgid "Tune for ARC700 R4.2 Cpu with XMAC block." msgstr "Trimma för cpu:n ARC700 R4.2 med standard XMAC-block." #: config/arc/arc.opt:241 -#, fuzzy -#| msgid "Enable the use of indexed loads" msgid "Enable the use of indexed loads." -msgstr "Aktivera användning av indexerade laddningar" +msgstr "Aktivera användning av indexerade laddningar." #: config/arc/arc.opt:245 msgid "Enable the use of pre/post modify with register displacement." msgstr "Aktivera användningen av pre-/postmodifieringar med registerförflyttning." #: config/arc/arc.opt:249 -#, fuzzy -#| msgid "Generate 32x16 multiply and mac instructions" msgid "Generate 32x16 multiply and mac instructions." -msgstr "Generera 32×16 multiplikations- och mac-instruktioner" +msgstr "Generera 32×16 multiplikations- och mac-instruktioner." #: config/arc/arc.opt:255 -#, fuzzy -#| msgid "Set probability threshold for unaligning branches" msgid "Set probability threshold for unaligning branches." -msgstr "Sätt sannolikhetströskeln för att inte justera grenar" +msgstr "Sätt sannolikhetströskeln för att inte justera grenar." #: config/arc/arc.opt:259 msgid "Don't use less than 25 bit addressing range for calls." @@ -15986,26 +12832,20 @@ msgid "Enable Rcw constraint handling - ccfsm condexec mostly depends on this." msgstr "Aktivera hantering av Rcw--begränsningar — ccfsm-kodexekvering beror i huvudsak på detta." #: config/arc/arc.opt:279 -#, fuzzy -#| msgid "Enable pre-reload use of cbranchsi pattern" msgid "Enable pre-reload use of cbranchsi pattern." -msgstr "Aktivera förladdningsanvändning av cbranchsi-mönster" +msgstr "Aktivera förladdningsanvändning av cbranchsi-mönster." #: config/arc/arc.opt:283 -#, fuzzy -#| msgid "Enable bbit peephole2" msgid "Enable bbit peephole2." -msgstr "Aktivera bbit peephole2" +msgstr "Aktivera bbit peephole2." #: config/arc/arc.opt:287 msgid "Use pc-relative switch case tables - this enables case table shortening." msgstr "Använd pc-relativa switch-falltabeller — detta aktiverar förkortning av falltabeller." #: config/arc/arc.opt:291 -#, fuzzy -#| msgid "Enable compact casesi pattern" msgid "Enable compact casesi pattern." -msgstr "Aktivera kompakt casesi-mönster" +msgstr "Aktivera kompakt casesi-mönster." #: config/arc/arc.opt:295 msgid "Enable 'q' instruction alternatives." @@ -16016,52 +12856,36 @@ msgid "Expand adddi3 and subdi3 at rtl generation time into add.f / adc etc." msgstr "Expandera addi3 och subdi3 vid rtl-genereringstillfället till add.f /adc etc." #: config/arc/arc.opt:306 -#, fuzzy -#| msgid "Enable variable polynomial CRC extension" msgid "Enable variable polynomial CRC extension." -msgstr "Aktivera variabel polynomiell CRC-utvidgning" +msgstr "Aktivera variabel polynomiell CRC-utvidgning." #: config/arc/arc.opt:310 -#, fuzzy -#| msgid "Enable DSP 3.1 Pack A extensions" msgid "Enable DSP 3.1 Pack A extensions." -msgstr "Aktivera utvidgningarna DSP 3.1 Pack A" +msgstr "Aktivera utvidgningarna DSP 3.1 Pack A." #: config/arc/arc.opt:314 -#, fuzzy -#| msgid "Enable dual viterbi butterfly extension" msgid "Enable dual viterbi butterfly extension." -msgstr "Aktivera dubbel viterbi fjärilsutvidgning" +msgstr "Aktivera dubbel viterbi fjärilsutvidgning." #: config/arc/arc.opt:324 -#, fuzzy -#| msgid "Enable Dual and Single Operand Instructions for Telephony" msgid "Enable Dual and Single Operand Instructions for Telephony." -msgstr "Använd dubbel- och enkeloperandinstruktioner för telefoni" +msgstr "Använd dubbel- och enkeloperandinstruktioner för telefoni." #: config/arc/arc.opt:328 -#, fuzzy -#| msgid "Enable XY Memory extension (DSP version 3)" msgid "Enable XY Memory extension (DSP version 3)." -msgstr "Aktivera XY-minnesutökningar (DSP version 3)" +msgstr "Aktivera XY-minnesutökningar (DSP version 3)." #: config/arc/arc.opt:333 -#, fuzzy -#| msgid "Enable Locked Load/Store Conditional extension" msgid "Enable Locked Load/Store Conditional extension." -msgstr "Aktivera utökningen låst ladda/lagra villkorlig" +msgstr "Aktivera utökningen låst ladda/lagra villkorlig." #: config/arc/arc.opt:337 -#, fuzzy -#| msgid "Enable swap byte ordering extension instruction" msgid "Enable swap byte ordering extension instruction." -msgstr "Aktivera utökningsinstruktionen för byte-ordningsväxling" +msgstr "Aktivera utökningsinstruktionen för byte-ordningsväxling." #: config/arc/arc.opt:341 -#, fuzzy -#| msgid "Enable 64-bit Time-Stamp Counter extension instruction" msgid "Enable 64-bit Time-Stamp Counter extension instruction." -msgstr "Aktivera utökningsingsinstruktioner för 64-bitars tidsstämpelräknare" +msgstr "Aktivera utökningsingsinstruktioner för 64-bitars tidsstämpelräknare." #: config/arc/arc.opt:345 msgid "Pass -EB option through to linker." @@ -16080,214 +12904,145 @@ msgid "Pass -marclinux_prof option through to linker." msgstr "Skicka vidare flaggan -marclinux_prof till länkaren." #: config/arc/arc.opt:365 -#, fuzzy -#| msgid "Enable lra" msgid "Enable lra." -msgstr "Aktivera lra" +msgstr "Aktivera lra." #: config/arc/arc.opt:369 -#, fuzzy -#| msgid "Don't indicate any priority with TARGET_REGISTER_PRIORITY" msgid "Don't indicate any priority with TARGET_REGISTER_PRIORITY." -msgstr "Indikera inte någon prioritet med TARGET_REGISTER_PRIORITY" +msgstr "Indikera inte någon prioritet med TARGET_REGISTER_PRIORITY." #: config/arc/arc.opt:373 -#, fuzzy -#| msgid "Indicate priority for r0..r3 / r12..r15 with TARGET_REGISTER_PRIORITY" msgid "Indicate priority for r0..r3 / r12..r15 with TARGET_REGISTER_PRIORITY." -msgstr "Indikera prioritet för r0..r3 / r12..r15 med TARGET_REGISTER_PRIORITY" +msgstr "Indikera prioritet för r0..r3 / r12..r15 med TARGET_REGISTER_PRIORITY." #: config/arc/arc.opt:377 -#, fuzzy -#| msgid "Reduce priority for r0..r3 / r12..r15 with TARGET_REGISTER_PRIORITY" msgid "Reduce priority for r0..r3 / r12..r15 with TARGET_REGISTER_PRIORITY." -msgstr "Reducera prioritet för r0..r3 / r12..r15 med TARGET_REGISTER_PRIORITY" +msgstr "Reducera prioritet för r0..r3 / r12..r15 med TARGET_REGISTER_PRIORITY." #: config/arc/arc.opt:381 -#, fuzzy -#| msgid "instrument with mcount calls as in the ucb code" msgid "instrument with mcount calls as in the ucb code." -msgstr "instrumentera med mcount-anrop som i ucb-koden" +msgstr "instrumentera med mcount-anrop som i ucb-koden." #: config/arc/arc.opt:411 -#, fuzzy -#| msgid "Enable clip instructions" msgid "Enable atomic instructions." -msgstr "Använd clip-instruktioner" +msgstr "Använd atomära instruktioner." #: config/arc/arc.opt:415 -#, fuzzy -#| msgid "Enable leading zero instructions" msgid "Enable double load/store instructions for ARC HS." -msgstr "Använd instruktioner för inledande nollor" +msgstr "Använd dubbla ladda/lagra-instruktioner för ARC HS." #: java/lang.opt:122 -#, fuzzy -#| msgid "Warn if deprecated empty statements are found" msgid "Warn if deprecated empty statements are found." -msgstr "Varna om tomma satser som bör undvikas finns" +msgstr "Varna om tomma satser som bör undvikas finns." #: java/lang.opt:126 -#, fuzzy -#| msgid "Warn if .class files are out of date" msgid "Warn if .class files are out of date." -msgstr "Varna om .class-filer är inaktuella" +msgstr "Varna om .class-filer är inaktuella." #: java/lang.opt:130 -#, fuzzy -#| msgid "Warn if modifiers are specified when not necessary" msgid "Warn if modifiers are specified when not necessary." -msgstr "Varna om modifierare anges när de inte behövs" +msgstr "Varna om modifierare anges när de inte behövs." #: java/lang.opt:150 -#, fuzzy -#| msgid "--CLASSPATH\tDeprecated; use --classpath instead" msgid "--CLASSPATH\tDeprecated; use --classpath instead." -msgstr "--CLASSPATH\tAvrådes, använd -classpath istället" +msgstr "--CLASSPATH\tAvrådes, använd -classpath istället." #: java/lang.opt:157 -#, fuzzy -#| msgid "Permit the use of the assert keyword" msgid "Permit the use of the assert keyword." -msgstr "Tillåt användning av nyckelordet assert" +msgstr "Tillåt användning av nyckelordet assert." #: java/lang.opt:179 -#, fuzzy -#| msgid "--bootclasspath=\tReplace system path" msgid "--bootclasspath=\tReplace system path." -msgstr "--bootclasspath=\tErsätt systemsökvägen" +msgstr "--bootclasspath=\tErsätt systemsökvägen." #: java/lang.opt:183 -#, fuzzy -#| msgid "Generate checks for references to NULL" msgid "Generate checks for references to NULL." -msgstr "Generera kontroller av referenser till NULL" +msgstr "Generera kontroller av referenser till NULL." #: java/lang.opt:187 -#, fuzzy -#| msgid "--classpath=\tSet class path" msgid "--classpath=\tSet class path." -msgstr "--classpath=\tAnge klassökväg" +msgstr "--classpath=\tAnge klassökväg." #: java/lang.opt:194 -#, fuzzy -#| msgid "Output a class file" msgid "Output a class file." -msgstr "Skriv en class-fil" +msgstr "Skriv en class-fil." #: java/lang.opt:198 -#, fuzzy -#| msgid "Alias for -femit-class-file" msgid "Alias for -femit-class-file." -msgstr "Alias för -femit-class-file" +msgstr "Alias för -femit-class-file." #: java/lang.opt:202 -#, fuzzy -#| msgid "--encoding=\tChoose input encoding (defaults from your locale)" msgid "--encoding=\tChoose input encoding (defaults from your locale)." -msgstr "--encoding=\tVälj inmatningskodning (din lokal används som standard)" +msgstr "--encoding=\tVälj inmatningskodning (din lokal används som standard)." #: java/lang.opt:206 -#, fuzzy -#| msgid "--extdirs=\tSet the extension directory path" msgid "--extdirs=\tSet the extension directory path." -msgstr "--extdirs=\tAnge katalogsökväg för utökningar" +msgstr "--extdirs=\tAnge katalogsökväg för utökningar." #: java/lang.opt:216 -#, fuzzy -#| msgid "Input file is a file with a list of filenames to compile" msgid "Input file is a file with a list of filenames to compile." -msgstr "Indatafil är en fil med en lista på filnamn att kompilera" +msgstr "Indatafil är en fil med en lista på filnamn att kompilera." #: java/lang.opt:223 -#, fuzzy -#| msgid "Always check for non gcj generated classes archives" msgid "Always check for non gcj generated classes archives." -msgstr "Leta alltid efter klassarkiv ej genererade av gcj" +msgstr "Leta alltid efter klassarkiv ej genererade av gcj." #: java/lang.opt:227 -#, fuzzy -#| msgid "Assume the runtime uses a hash table to map an object to its synchronization structure" msgid "Assume the runtime uses a hash table to map an object to its synchronization structure." -msgstr "Anta att en hash-tabell används vid körning för att avbilda ett objekt till dess synkroniseringsstruktur" +msgstr "Anta att en hash-tabell används vid körning för att avbilda ett objekt till dess synkroniseringsstruktur." #: java/lang.opt:231 -#, fuzzy -#| msgid "Generate instances of Class at runtime" msgid "Generate instances of Class at runtime." -msgstr "Generera instanser av Class vid körtid" +msgstr "Generera instanser av Class vid körtid." #: java/lang.opt:235 -#, fuzzy -#| msgid "Use offset tables for virtual method calls" msgid "Use offset tables for virtual method calls." -msgstr "Använd avståndstabeller för anrop av virtuella metoder" +msgstr "Använd avståndstabeller för anrop av virtuella metoder." #: java/lang.opt:242 -#, fuzzy -#| msgid "Assume native functions are implemented using JNI" msgid "Assume native functions are implemented using JNI." -msgstr "Anta att inbyggda funktioner är implementerade med JNI" +msgstr "Anta att inbyggda funktioner är implementerade med JNI." #: java/lang.opt:246 -#, fuzzy -#| msgid "Enable optimization of static class initialization code" msgid "Enable optimization of static class initialization code." -msgstr "Aktivera optimeringar av initieringskod för statiska klasser" +msgstr "Aktivera optimeringar av initieringskod för statiska klasser." #: java/lang.opt:253 -#, fuzzy -#| msgid "Reduce the amount of reflection meta-data generated" msgid "Reduce the amount of reflection meta-data generated." -msgstr "Reducera mängden reflektionsmetadata som genereras" +msgstr "Reducera mängden reflektionsmetadata som genereras." #: java/lang.opt:257 -#, fuzzy -#| msgid "Enable assignability checks for stores into object arrays" msgid "Enable assignability checks for stores into object arrays." -msgstr "Aktivera kontroll av tilldelningsbarhet för lagring i objektvektorer" +msgstr "Aktivera kontroll av tilldelningsbarhet för lagring i objektvektorer." #: java/lang.opt:261 -#, fuzzy -#| msgid "Generate code for the Boehm GC" msgid "Generate code for the Boehm GC." -msgstr "Generera kod för Boehm GC" +msgstr "Generera kod för Boehm GC." #: java/lang.opt:265 -#, fuzzy -#| msgid "Call a library routine to do integer divisions" msgid "Call a library routine to do integer divisions." -msgstr "Anropa en biblioteksrutin för att göra heltalsdivisioner" +msgstr "Anropa en biblioteksrutin för att göra heltalsdivisioner." #: java/lang.opt:269 -#, fuzzy -#| msgid "Generate code for built-in atomic operations" msgid "Generate code for built-in atomic operations." -msgstr "Generera kod för inbyggda atomiska operationer" +msgstr "Generera kod för inbyggda atomiska operationer." #: java/lang.opt:273 -#, fuzzy -#| msgid "Generated should be loaded by bootstrap loader" msgid "Generated should be loaded by bootstrap loader." -msgstr "Genererat skall läsas in av uppstartsladdaren" +msgstr "Genererat skall läsas in av uppstartsladdaren." #: java/lang.opt:277 -#, fuzzy -#| msgid "Set the source language version" msgid "Set the source language version." -msgstr "Ange källspråksversion" +msgstr "Ange källspråksversion." #: java/lang.opt:281 -#, fuzzy -#| msgid "Set the target VM version" msgid "Set the target VM version." -msgstr "Ange typen av mål-VM-version" +msgstr "Ange typen av mål-VM-version." #: lto/lang.opt:28 -#, fuzzy, c-format -#| msgid "unknown pointer size model %qs" +#, c-format msgid "unknown linker output %qs" -msgstr "okänd pekarstorlekmodell %qs" +msgstr "okänd länkarutmatning %qs" #: lto/lang.opt:47 msgid "Set linker output type (used internally during LTO optimization)" @@ -16310,176 +13065,120 @@ msgid "Whole program analysis (WPA) mode with number of parallel jobs specified. msgstr "Läget helprogramanalys (WPA) med antal parallella jobb angivna." #: lto/lang.opt:68 -#, fuzzy -#| msgid "The resolution file" msgid "The resolution file." -msgstr "Upplösningsfilen" +msgstr "Upplösningsfilen." #: common.opt:235 -#, fuzzy -#| msgid "Enable user-defined instructions" msgid "Enable coverage-guided fuzzing code instrumentation." -msgstr "Använd användardefinierade instruktioner" +msgstr "Använd täckningsguidad utsuddande kodinstrumentering." #: common.opt:302 -#, fuzzy -#| msgid "Display this information" msgid "Display this information." -msgstr "Visa den här informationen" +msgstr "Visa den här informationen." #: common.opt:306 -#, fuzzy -#| msgid "--help=\tDisplay descriptions of a specific class of options. is one or more of optimizers, target, warnings, undocumented, params" msgid "--help=\tDisplay descriptions of a specific class of options. is one or more of optimizers, target, warnings, undocumented, params." -msgstr "--help=\tVisa beskrivningar av en speciell klass av flaggor. är en eller flera av optimizers, target, warnings, undocumented, params" +msgstr "--help=\tVisa beskrivningar av en speciell klass av flaggor. är en eller flera av optimizers, target, warnings, undocumented, params." #: common.opt:424 -#, fuzzy -#| msgid "Alias for --help=target" msgid "Alias for --help=target." -msgstr "Alias för --help=target" +msgstr "Alias för --help=target." #: common.opt:449 -#, fuzzy -#| msgid "--param =\tSet parameter to value. See below for a complete list of parameters" msgid "--param =\tSet parameter to value. See below for a complete list of parameters." -msgstr "--param =\tSätt parameter till värde. Se nedan för en komplett lista på parametrar" +msgstr "--param =\tSätt parameter till värde. Se nedan för en komplett lista på parametrar." #: common.opt:477 -#, fuzzy -#| msgid "-O\tSet optimization level to " msgid "-O\tSet optimization level to ." -msgstr "-O\tSätt optimeringsnivå till " +msgstr "-O\tSätt optimeringsnivå till ." #: common.opt:481 -#, fuzzy -#| msgid "Optimize for space rather than speed" msgid "Optimize for space rather than speed." -msgstr "Optimera för storlek istället för hastighet" +msgstr "Optimera för storlek istället för hastighet." #: common.opt:485 -#, fuzzy -#| msgid "Optimize for speed disregarding exact standards compliance" msgid "Optimize for speed disregarding exact standards compliance." -msgstr "Optimera för hastighet och bortse från exakt efterlevnad av standarder" +msgstr "Optimera för hastighet och bortse från exakt efterlevnad av standarder." #: common.opt:489 -#, fuzzy -#| msgid "Optimize for debugging experience rather than speed or size" msgid "Optimize for debugging experience rather than speed or size." -msgstr "Optimera för bekväm felsökning snarare än storlek eller hastighet" +msgstr "Optimera för bekväm felsökning snarare än storlek eller hastighet." #: common.opt:529 -#, fuzzy -#| msgid "This switch is deprecated; use -Wextra instead" msgid "This switch is deprecated; use -Wextra instead." -msgstr "Denna flagga bör undvikas, använd -Wextra istället" +msgstr "Denna flagga bör undvikas, använd -Wextra istället." #: common.opt:542 -#, fuzzy -#| msgid "Warn about returning structures, unions or arrays" msgid "Warn about returning structures, unions or arrays." -msgstr "Varna för retur av poster, unioner eller vektorer" +msgstr "Varna för retur av poster, unioner eller vektorer." #: common.opt:546 -#, fuzzy -#| msgid "Warn if a loop with constant number of iterations triggers undefined behavior" msgid "Warn if a loop with constant number of iterations triggers undefined behavior." -msgstr "Varna om en slinga med konstant antal iterationer orsakar odefinierat beteende" +msgstr "Varna om en slinga med konstant antal iterationer orsakar odefinierat beteende." #: common.opt:550 common.opt:554 -#, fuzzy -#| msgid "Warn if an array is accessed out of bounds" msgid "Warn if an array is accessed out of bounds." -msgstr "Varna om en vektor används utanför gränserna" +msgstr "Varna om en vektor används utanför gränserna." #: common.opt:558 -#, fuzzy -#| msgid "Warn about inappropriate attribute usage" msgid "Warn about inappropriate attribute usage." -msgstr "Varna för felaktig användning av attribut" +msgstr "Varna för felaktig användning av attribut." #: common.opt:562 -#, fuzzy -#| msgid "Warn about pointer casts which increase alignment" msgid "Warn about pointer casts which increase alignment." -msgstr "Varna för typkonvertering av pekare som ökar justeringen" +msgstr "Varna för typkonvertering av pekare som ökar justeringen." #: common.opt:566 -#, fuzzy -#| msgid "Warn when a #warning directive is encountered" msgid "Warn when a #warning directive is encountered." -msgstr "Varna när ett #warning-direktiv påträffas" +msgstr "Varna när ett #warning-direktiv påträffas." #: common.opt:570 -#, fuzzy -#| msgid "Warn about uses of __attribute__((deprecated)) declarations" msgid "Warn about uses of __attribute__((deprecated)) declarations." -msgstr "Varna för användning av __attribute__((deprecated))-deklarationer" +msgstr "Varna för användning av __attribute__((deprecated))-deklarationer." #: common.opt:574 -#, fuzzy -#| msgid "Warn when an optimization pass is disabled" msgid "Warn when an optimization pass is disabled." -msgstr "Varna när ett optimerarpass är avaktiverat" +msgstr "Varna när ett optimerarpass är avaktiverat." #: common.opt:578 -#, fuzzy -#| msgid "Treat all warnings as errors" msgid "Treat all warnings as errors." -msgstr "Behandla alla varningar som fel." +msgstr "Behandla alla varningar som fel.." #: common.opt:582 -#, fuzzy -#| msgid "Treat specified warning as error" msgid "Treat specified warning as error." -msgstr "Behandla angivna varningar som fel" +msgstr "Behandla angivna varningar som fel." #: common.opt:586 -#, fuzzy -#| msgid "Print extra (possibly unwanted) warnings" msgid "Print extra (possibly unwanted) warnings." -msgstr "Skriv extra (möjligen oönskade) varningar" +msgstr "Skriv extra (möjligen oönskade) varningar." #: common.opt:590 -#, fuzzy -#| msgid "Exit on the first error occurred" msgid "Exit on the first error occurred." -msgstr "Avsluta vid första felet som uppstår" +msgstr "Avsluta vid första felet som uppstår." #: common.opt:594 -#, fuzzy -#| msgid "-Wframe-larger-than=\tWarn if a function's stack frame requires more than bytes" msgid "-Wframe-larger-than=\tWarn if a function's stack frame requires more than bytes." -msgstr "-Wframe-larger-than=\tVarna om en funktions stackram kräver mer en byte" +msgstr "-Wframe-larger-than=\tVarna om en funktions stackram kräver mer en byte." #: common.opt:598 -#, fuzzy -#| msgid "Warn when attempting to free a non-heap object" msgid "Warn when attempting to free a non-heap object." -msgstr "Varna vid försök att frigöra ett icke-heap-objekt" +msgstr "Varna vid försök att frigöra ett icke-heap-objekt." #: common.opt:602 -#, fuzzy -#| msgid "Warn when an inlined function cannot be inlined" msgid "Warn when a function cannot be expanded to HSAIL." -msgstr "Varna när en inline:ad funktion inte kan inline:as" +msgstr "Varna när en funktion inte kan expanderas till HSAIL." #: common.opt:606 -#, fuzzy -#| msgid "Warn when an inlined function cannot be inlined" msgid "Warn when an inlined function cannot be inlined." -msgstr "Varna när en inline:ad funktion inte kan inline:as" +msgstr "Varna när en inline:ad funktion inte kan inline:as." #: common.opt:610 msgid "Warn when an atomic memory model parameter is known to be outside the valid range." msgstr "Varna när en atomisk minnesmodellparameter med säkerhet är utanför det giltiga intervallet." #: common.opt:617 -#, fuzzy -#| msgid "-Wlarger-than=\tWarn if an object is larger than bytes" msgid "-Wlarger-than=\tWarn if an object is larger than bytes." -msgstr "-Wlarger-than=\tVarna för ett objekt är större än byte" +msgstr "-Wlarger-than=\tVarna för ett objekt är större än byte." #: common.opt:621 msgid "Warn if dereferencing a NULL pointer may lead to erroneous or undefined behavior." @@ -16490,258 +13189,176 @@ msgid "Warn if the loop cannot be optimized due to nontrivial assumptions." msgstr "Varna för slingan inte kan optimeras på grund av icketriviala antaganden." #: common.opt:632 -#, fuzzy -#| msgid "Warn about some C++ One Definition Rule violations during link time optimization" msgid "Warn about some C++ One Definition Rule violations during link time optimization." -msgstr "Varna för några brott mot C++ endefinitionsregel under optimeringar vid länktillfället" +msgstr "Varna för några brott mot C++ endefinitionsregel under optimeringar vid länktillfället." #: common.opt:636 -#, fuzzy -#| msgid "Warn about overflow in arithmetic expressions" msgid "Warn about overflow in arithmetic expressions." -msgstr "Varna för spill i aritmetiska uttryck" +msgstr "Varna för spill i aritmetiska uttryck." #: common.opt:640 msgid "During link time optimization warn about mismatched types of global declarations." msgstr "Varna under länktidsoptimeringar för typer som inte stämmer överens från globala deklarationer." #: common.opt:644 -#, fuzzy -#| msgid "Warn when the packed attribute has no effect on struct layout" msgid "Warn when the packed attribute has no effect on struct layout." -msgstr "Varna när attributet packed inte har någon effekt på postformatet" +msgstr "Varna när attributet packed inte har någon effekt på postformatet." #: common.opt:648 -#, fuzzy -#| msgid "Warn when padding is required to align structure members" msgid "Warn when padding is required to align structure members." -msgstr "Varna när utfyllnad krävs för att justera postmedlemmar" +msgstr "Varna när utfyllnad krävs för att justera postmedlemmar." #: common.opt:652 -#, fuzzy -#| msgid "Issue warnings needed for strict compliance to the standard" msgid "Issue warnings needed for strict compliance to the standard." -msgstr "Ge varningar som krävs för att strikt följa standarden" +msgstr "Ge varningar som krävs för att strikt följa standarden." #: common.opt:656 msgid "Warn about returning a pointer/reference to a local or temporary variable." msgstr "Varna för retur av en pekare/referens till en lokal eller temporär variabel." #: common.opt:660 -#, fuzzy -#| msgid "Warn when one local variable shadows another" msgid "Warn when one local variable shadows another." -msgstr "Varna när en lokal variabel skuggar en annan" +msgstr "Varna när en lokal variabel skuggar en annan." #: common.opt:664 -#, fuzzy -#| msgid "Warn when not issuing stack smashing protection for some reason" msgid "Warn when not issuing stack smashing protection for some reason." -msgstr "Varna när stacköverskrivningsskydd inte läggs ut av någon anledning" +msgstr "Varna när stacköverskrivningsskydd inte läggs ut av någon anledning." #: common.opt:668 -#, fuzzy -#| msgid "Warn if stack usage might be larger than specified amount" msgid "Warn if stack usage might be larger than specified amount." -msgstr "Varna om stackanvändningen kan vara större än den angivna mängden" +msgstr "Varna om stackanvändningen kan vara större än den angivna mängden." #: common.opt:672 common.opt:676 -#, fuzzy -#| msgid "Warn about code which might break strict aliasing rules" msgid "Warn about code which might break strict aliasing rules." -msgstr "Varna för kod som kan bryta strikta aliasregler" +msgstr "Varna för kod som kan bryta strikta aliasregler." #: common.opt:680 common.opt:684 -#, fuzzy -#| msgid "Warn about optimizations that assume that signed overflow is undefined" msgid "Warn about optimizations that assume that signed overflow is undefined." -msgstr "Varna för optimeringar som antar spill med tecken är odefinierat" +msgstr "Varna för optimeringar som antar spill med tecken är odefinierat." #: common.opt:688 -#, fuzzy -#| msgid "Warn about functions which might be candidates for __attribute__((const))" msgid "Warn about functions which might be candidates for __attribute__((const))." -msgstr "Varna för funktioner som är möjliga kandidater för __attribute__((const))" +msgstr "Varna för funktioner som är möjliga kandidater för __attribute__((const))." #: common.opt:692 -#, fuzzy -#| msgid "Warn about functions which might be candidates for __attribute__((pure))" msgid "Warn about functions which might be candidates for __attribute__((pure))." -msgstr "Varna för funktioner som är möjliga kandidater för __attribute__((pure))" +msgstr "Varna för funktioner som är möjliga kandidater för __attribute__((pure))." #: common.opt:696 -#, fuzzy -#| msgid "Warn about functions which might be candidates for __attribute__((noreturn))" msgid "Warn about functions which might be candidates for __attribute__((noreturn))." -msgstr "Varna för funktioner som är möjliga kandidater för __attribute__((noreturn))" +msgstr "Varna för funktioner som är möjliga kandidater för __attribute__((noreturn))." #: common.opt:700 -#, fuzzy -#| msgid "Warn about C++ polymorphic types where adding final keyword would improve code quality" msgid "Warn about C++ polymorphic types where adding final keyword would improve code quality." -msgstr "Varna för polymorfa C++-typer där det skulle förbättra kodkvaliteten att lägga till nyckelordet final" +msgstr "Varna för polymorfa C++-typer där det skulle förbättra kodkvaliteten att lägga till nyckelordet final." #: common.opt:704 -#, fuzzy -#| msgid "Warn about C++ virtual methods where adding final keyword would improve code quality" msgid "Warn about C++ virtual methods where adding final keyword would improve code quality." -msgstr "Varna för virtuella C++-metoder där det skulle förbättra kodkvaliteten att lägga till nyckelordet final" +msgstr "Varna för virtuella C++-metoder där det skulle förbättra kodkvaliteten att lägga till nyckelordet final." #: common.opt:708 -#, fuzzy -#| msgid "Do not suppress warnings from system headers" msgid "Do not suppress warnings from system headers." -msgstr "Undertryck inte varningar från systemhuvudfiler" +msgstr "Undertryck inte varningar från systemhuvudfiler." #: common.opt:712 -#, fuzzy -#| msgid "Warn whenever a trampoline is generated" msgid "Warn whenever a trampoline is generated." -msgstr "Varna närhelst en trampolin genereras" +msgstr "Varna närhelst en trampolin genereras." #: common.opt:716 -#, fuzzy -#| msgid "Warn if a comparison is always true or always false due to the limited range of the data type" msgid "Warn if a comparison is always true or always false due to the limited range of the data type." -msgstr "Varna om en jämförelse alltid är sann eller falsk på grund av begränsat intervall för datatypen" +msgstr "Varna om en jämförelse alltid är sann eller falsk på grund av begränsat intervall för datatypen." #: common.opt:720 -#, fuzzy -#| msgid "Warn about uninitialized automatic variables" msgid "Warn about uninitialized automatic variables." -msgstr "Varna för oinitierade automatiska variabler" +msgstr "Varna för oinitierade automatiska variabler." #: common.opt:724 -#, fuzzy -#| msgid "Warn about maybe uninitialized automatic variables" msgid "Warn about maybe uninitialized automatic variables." -msgstr "Varna för eventuellt oinitierade automatiska variabler" +msgstr "Varna för eventuellt oinitierade automatiska variabler." #: common.opt:732 -#, fuzzy -#| msgid "Enable all -Wunused- warnings" msgid "Enable all -Wunused- warnings." -msgstr "Aktivera alla -Wunused-varningar" +msgstr "Aktivera alla -Wunused-varningar." #: common.opt:736 -#, fuzzy -#| msgid "Warn when a function parameter is only set, otherwise unused" msgid "Warn when a function parameter is only set, otherwise unused." -msgstr "Varna när en funktionsparameter bara sätts, och i övrigt är oanvänd" +msgstr "Varna när en funktionsparameter bara sätts, och i övrigt är oanvänd." #: common.opt:740 -#, fuzzy -#| msgid "Warn when a variable is only set, otherwise unused" msgid "Warn when a variable is only set, otherwise unused." -msgstr "Varna när en variabel bara sätts, och i övrigt är oanvänd" +msgstr "Varna när en variabel bara sätts, och i övrigt är oanvänd." #: common.opt:744 -#, fuzzy -#| msgid "Warn when a function is unused" msgid "Warn when a function is unused." -msgstr "Varna när en funktion är oanvänd" +msgstr "Varna när en funktion är oanvänd." #: common.opt:748 -#, fuzzy -#| msgid "Warn when a label is unused" msgid "Warn when a label is unused." -msgstr "Varna när en etikett är oanvänd" +msgstr "Varna när en etikett är oanvänd." #: common.opt:752 -#, fuzzy -#| msgid "Warn when a function parameter is unused" msgid "Warn when a function parameter is unused." -msgstr "Varna när en funktionsparameter är oanvänd" +msgstr "Varna när en funktionsparameter är oanvänd." #: common.opt:756 -#, fuzzy -#| msgid "Warn when an expression value is unused" msgid "Warn when an expression value is unused." -msgstr "Varna när ett uttrycksvärde är oanvänt" +msgstr "Varna när ett uttrycksvärde är oanvänt." #: common.opt:760 -#, fuzzy -#| msgid "Warn when a variable is unused" msgid "Warn when a variable is unused." -msgstr "Varna när en variabel är oanvänd" +msgstr "Varna när en variabel är oanvänd." #: common.opt:764 -#, fuzzy -#| msgid "Warn in case profiles in -fprofile-use do not match" msgid "Warn in case profiles in -fprofile-use do not match." -msgstr "Varna om profiler i -fprofile-use inte stämmer" +msgstr "Varna om profiler i -fprofile-use inte stämmer." #: common.opt:768 -#, fuzzy -#| msgid "Warn when a vector operation is compiled outside the SIMD" msgid "Warn when a vector operation is compiled outside the SIMD." -msgstr "Varna när en vektoroperation kompileras utanför SIMD:n" +msgstr "Varna när en vektoroperation kompileras utanför SIMD:n." #: common.opt:784 -#, fuzzy -#| msgid "-aux-info \tEmit declaration information into " msgid "-aux-info \tEmit declaration information into ." -msgstr "-aux-info \tGenerera deklarationsinfo till " +msgstr "-aux-info \tGenerera deklarationsinfo till ." #: common.opt:803 -#, fuzzy -#| msgid "-d\tEnable dumps from specific passes of the compiler" msgid "-d\tEnable dumps from specific passes of the compiler." -msgstr "-d\tSlå på dumpning från specifika pass i kompilatorn" +msgstr "-d\tSlå på dumpning från specifika pass i kompilatorn." #: common.opt:807 -#, fuzzy -#| msgid "-dumpbase \tSet the file basename to be used for dumps" msgid "-dumpbase \tSet the file basename to be used for dumps." -msgstr "-dumpbase \tAnge basfilnamn att användas för dumpar" +msgstr "-dumpbase \tAnge basfilnamn att användas för dumpar." #: common.opt:811 -#, fuzzy -#| msgid "-dumpdir \tSet the directory name to be used for dumps" msgid "-dumpdir \tSet the directory name to be used for dumps." -msgstr "-dumpdir \tAnge katalognamn att användas för dumpar" +msgstr "-dumpdir \tAnge katalognamn att användas för dumpar." #: common.opt:880 -#, fuzzy -#| msgid "The version of the C++ ABI in use" msgid "The version of the C++ ABI in use." -msgstr "Versionen av C++-ABI:et som används" +msgstr "Versionen av C++-ABI:et som används." #: common.opt:884 -#, fuzzy -#| msgid "Aggressively optimize loops using language constraints" msgid "Aggressively optimize loops using language constraints." -msgstr "Optimera aggressivt slingor med användning av språkbegränsningar" +msgstr "Optimera aggressivt slingor med användning av språkbegränsningar." #: common.opt:888 -#, fuzzy -#| msgid "Align the start of functions" msgid "Align the start of functions." -msgstr "Justera starten av funktioner" +msgstr "Justera starten av funktioner." #: common.opt:895 -#, fuzzy -#| msgid "Align labels which are only reached by jumping" msgid "Align labels which are only reached by jumping." -msgstr "Justera etiketter som bara nås via hopp" +msgstr "Justera etiketter som bara nås via hopp." #: common.opt:902 -#, fuzzy -#| msgid "Align all labels" msgid "Align all labels." -msgstr "Justera alla etiketter" +msgstr "Justera alla etiketter." #: common.opt:909 -#, fuzzy -#| msgid "Align the start of loops" msgid "Align the start of loops." -msgstr "Justera starten av slingor" +msgstr "Justera starten av slingor." #: common.opt:932 -#, fuzzy -#| msgid "Select what to sanitize" msgid "Select what to sanitize." -msgstr "Välj vad som skall saneras" +msgstr "Välj vad som skall saneras." #: common.opt:936 msgid "-fasan-shadow-offset=\tUse custom shadow memory offset." @@ -16752,34 +13369,24 @@ msgid "-fsanitize-sections=\tSanitize global variables" msgstr "-fsanitize-sections=\tSanera globala variabler" #: common.opt:945 -#, fuzzy -#| msgid "After diagnosing undefined behavior attempt to continue execution" msgid "After diagnosing undefined behavior attempt to continue execution." -msgstr "Efter att diagnosticera odefinierat beteende, försök fortsätta körningen" +msgstr "Efter att diagnosticera odefinierat beteende, försök fortsätta körningen." #: common.opt:949 -#, fuzzy -#| msgid "This switch is deprecated; use -fsanitize-recover= instead" msgid "This switch is deprecated; use -fsanitize-recover= instead." -msgstr "Denna flagga bör undvikas, använd -fsanitize-recover= istället" +msgstr "Denna flagga bör undvikas, använd -fsanitize-recover= istället." #: common.opt:953 -#, fuzzy -#| msgid "Use trap instead of a library function for undefined behavior sanitization" msgid "Use trap instead of a library function for undefined behavior sanitization." -msgstr "Använd trap istället för en biblioteksfunktion för sanering av odefinierat beteende" +msgstr "Använd trap istället för en biblioteksfunktion för sanering av odefinierat beteende." #: common.opt:957 -#, fuzzy -#| msgid "Generate unwind tables that are exact at each instruction boundary" msgid "Generate unwind tables that are exact at each instruction boundary." -msgstr "Generera tabeller för upprullning som är exakta vid varje instruktionsgräns" +msgstr "Generera tabeller för upprullning som är exakta vid varje instruktionsgräns." #: common.opt:961 -#, fuzzy -#| msgid "Generate auto-inc/dec instructions" msgid "Generate auto-inc/dec instructions." -msgstr "Generera auto-inc/dec-instruktioner" +msgstr "Generera auto-inc/dec-instruktioner." #: common.opt:965 msgid "Use sample profile information for call graph node weights. The default" @@ -16790,266 +13397,184 @@ msgid "Use sample profile information for call graph node weights. The profile" msgstr "Använd samplingsprofilinformation till anropsgrafers nodvikter. Profilen" #: common.opt:979 -#, fuzzy -#| msgid "Generate code to check bounds before indexing arrays" msgid "Generate code to check bounds before indexing arrays." -msgstr "Generera kod för att kontrollera gränser före indexering i vektorer" +msgstr "Generera kod för att kontrollera gränser före indexering i vektorer." #: common.opt:983 -#, fuzzy -#| msgid "Replace add, compare, branch with branch on count register" msgid "Replace add, compare, branch with branch on count register." -msgstr "Ersätt addition, jämförelse, grena med gren vid räknarregister" +msgstr "Ersätt addition, jämförelse, grena med gren vid räknarregister." #: common.opt:987 -#, fuzzy -#| msgid "Use profiling information for branch probabilities" msgid "Use profiling information for branch probabilities." -msgstr "Använd profileringsinformation för grensannolikheter" +msgstr "Använd profileringsinformation för grensannolikheter." #: common.opt:991 -#, fuzzy -#| msgid "Perform branch target load optimization before prologue / epilogue threading" msgid "Perform branch target load optimization before prologue / epilogue threading." -msgstr "Utför optimering av grenmålsinläsning före prolog-/epilogtrådning" +msgstr "Utför optimering av grenmålsladdning före prolog-/epilogtrådning." #: common.opt:995 -#, fuzzy -#| msgid "Perform branch target load optimization after prologue / epilogue threading" msgid "Perform branch target load optimization after prologue / epilogue threading." -msgstr "Utför optimering av grenmålsinläsning efter prolog-/epilogtrådning" +msgstr "Utför optimering av grenmålsladdning efter prolog-/epilogtrådning." #: common.opt:999 -#, fuzzy -#| msgid "Restrict target load migration not to re-use registers in any basic block" msgid "Restrict target load migration not to re-use registers in any basic block." -msgstr "Begränsa migration av målinläsning till att inte återanvända register i något grundblock" +msgstr "Begränsa migration av målladdning till att inte återanvända register i något grundblock." #: common.opt:1003 -#, fuzzy -#| msgid "-fcall-saved-\tMark as being preserved across functions" msgid "-fcall-saved-\tMark as being preserved across functions." -msgstr "-fcall-saved-\tMarkera att bevaras mellan funktioner" +msgstr "-fcall-saved-\tMarkera att bevaras mellan funktioner." #: common.opt:1007 -#, fuzzy -#| msgid "-fcall-used-\tMark as being corrupted by function calls" msgid "-fcall-used-\tMark as being corrupted by function calls." -msgstr "-fcall-used-\tMarkera att förstörs av funktionsanrop" +msgstr "-fcall-used-\tMarkera att förstörs av funktionsanrop." #: common.opt:1014 -#, fuzzy -#| msgid "Save registers around function calls" msgid "Save registers around function calls." -msgstr "Spara register runt funktionsanrop" +msgstr "Spara register runt funktionsanrop." #: common.opt:1018 -#, fuzzy -#| msgid "This switch is deprecated; use -Wextra instead" msgid "This switch is deprecated; do not use." -msgstr "Denna flagga bör undvikas, använd -Wextra istället" +msgstr "Denna flagga bör undvikas, använd den inte." #: common.opt:1022 -#, fuzzy -#| msgid "Check the return value of new in C++" msgid "Check the return value of new in C++." -msgstr "Kontrollera returvärdet av new i C++" +msgstr "Kontrollera returvärdet av new i C++." #: common.opt:1026 -#, fuzzy -#| msgid "internal consistency failure" msgid "Perform internal consistency checkings." -msgstr "internt konsistensfel" +msgstr "Utför interna konsistenskontroller." #: common.opt:1030 msgid "Looks for opportunities to reduce stack adjustments and stack references." msgstr "Söker efter möjligheter att minska stackjusteringar och stackreferenser." #: common.opt:1034 -#, fuzzy -#| msgid "Do not put uninitialized globals in the common section" msgid "Do not put uninitialized globals in the common section." -msgstr "Lägg inte oinitierade globala i den gemensamma sektionen" +msgstr "Lägg inte oinitierade globala i den gemensamma sektionen." #: common.opt:1042 -#, fuzzy -#| msgid "-fcompare-debug[=]\tCompile with and without e.g. -gtoggle, and compare the final-insns dump" msgid "-fcompare-debug[=]\tCompile with and without e.g. -gtoggle, and compare the final-insns dump." -msgstr "-fcompare-debug[=]\tKompilera med och utan t.ex. -gtoggle, och jämför slutinstruktionsdumpen" +msgstr "-fcompare-debug[=]\tKompilera med och utan t.ex. -gtoggle, och jämför slutinstruktionsdumpen." #: common.opt:1046 -#, fuzzy -#| msgid "Run only the second compilation of -fcompare-debug" msgid "Run only the second compilation of -fcompare-debug." -msgstr "Kör endast den andra kompileringen av -fcompare-debug" +msgstr "Kör endast den andra kompileringen av -fcompare-debug." #: common.opt:1050 -#, fuzzy -#| msgid "Perform comparison elimination after register allocation has finished" msgid "Perform comparison elimination after register allocation has finished." -msgstr "Utför eliminering av jämförelser efter registertilldelningen har avslutats" +msgstr "Utför eliminering av jämförelser efter registertilldelningen har avslutats." #: common.opt:1054 -#, fuzzy -#| msgid "Do not perform optimizations increasing noticeably stack usage" msgid "Do not perform optimizations increasing noticeably stack usage." -msgstr "Utför inte optimeringar som märkbart ökar stackanvändningen" +msgstr "Utför inte optimeringar som märkbart ökar stackanvändningen." #: common.opt:1058 -#, fuzzy -#| msgid "Perform a register copy-propagation optimization pass" msgid "Perform a register copy-propagation optimization pass." -msgstr "Utför ett optimeringspass för kopieringspropagering av register" +msgstr "Utför ett optimeringspass för kopieringspropagering av register." #: common.opt:1062 -#, fuzzy -#| msgid "Perform cross-jumping optimization" msgid "Perform cross-jumping optimization." -msgstr "Utför optimering för korshopp" +msgstr "Utför optimering för korshopp." #: common.opt:1066 -#, fuzzy -#| msgid "When running CSE, follow jumps to their targets" msgid "When running CSE, follow jumps to their targets." -msgstr "När CSE körs, följ hopp till deras mål" +msgstr "När CSE körs, följ hopp till deras mål." #: common.opt:1074 -#, fuzzy -#| msgid "Omit range reduction step when performing complex division" msgid "Omit range reduction step when performing complex division." -msgstr "Uteslut intervallreduktionssteget när komplex division görs" +msgstr "Uteslut intervallreduktionssteget när komplex division görs." #: common.opt:1078 -#, fuzzy -#| msgid "Complex multiplication and division follow Fortran rules" msgid "Complex multiplication and division follow Fortran rules." -msgstr "Komplex multiplikation och division följer Fortranregler" +msgstr "Komplex multiplikation och division följer Fortranregler." #: common.opt:1082 -#, fuzzy -#| msgid "Place data items into their own section" msgid "Place data items into their own section." -msgstr "Placera dataobjekt i sin egen sektion" +msgstr "Placera dataobjekt i sin egen sektion." #: common.opt:1086 msgid "List all available debugging counters with their limits and counts." msgstr "Lista alla tillgängliga felsökningsräknare med deras gränser och värden." #: common.opt:1090 -#, fuzzy -#| msgid "-fdbg-cnt=:[,:,...]\tSet the debug counter limit. " msgid "-fdbg-cnt=:[,:,...]\tSet the debug counter limit." -msgstr "-fdbg-cnt=:[,:,...]\tSätt gränsen för felsökningsräknare. " +msgstr "-fdbg-cnt=:[,:,...]\tSätt gränsen för felsökningsräknare." #: common.opt:1094 -#, fuzzy -#| msgid "Map one directory name to another in debug information" msgid "Map one directory name to another in debug information." -msgstr "Översätt ett katalognamn till ett annat i felsökningsinformation" +msgstr "Översätt ett katalognamn till ett annat i felsökningsinformation." #: common.opt:1098 msgid "Output .debug_types section when using DWARF v4 debuginfo." msgstr "Mata ut en .debug_types-sektion när DWARF v4 felsökningsinformation används." #: common.opt:1104 -#, fuzzy -#| msgid "Defer popping functions args from stack until later" msgid "Defer popping functions args from stack until later." -msgstr "Senarelägg borttagandet av funktionsargument från stacken" +msgstr "Senarelägg borttagandet av funktionsargument från stacken." #: common.opt:1108 -#, fuzzy -#| msgid "Attempt to fill delay slots of branch instructions" msgid "Attempt to fill delay slots of branch instructions." -msgstr "Försök fylla fördröjningsfack av greninstruktioner" +msgstr "Försök fylla fördröjningsfack av greninstruktioner." #: common.opt:1112 -#, fuzzy -#| msgid "Delete dead instructions that may throw exceptions" msgid "Delete dead instructions that may throw exceptions." -msgstr "Ta bort döda instruktioner som kan kasta undantag" +msgstr "Ta bort döda instruktioner som kan kasta undantag." #: common.opt:1116 -#, fuzzy -#| msgid "Delete useless null pointer checks" msgid "Delete useless null pointer checks." -msgstr "Ta bort onödiga nollpekarkontroller" +msgstr "Ta bort onödiga nollpekarkontroller." #: common.opt:1120 -#, fuzzy -#| msgid "Stream extra data to support more aggressive devirtualization in LTO local transformation mode" msgid "Stream extra data to support more aggressive devirtualization in LTO local transformation mode." -msgstr "Strömma extra data för att stödja mer aggressiv avvirtualisering i lokaltransformationsläge i LTO" +msgstr "Strömma extra data för att stödja mer aggressiv avvirtualisering i lokaltransformationsläge i LTO." #: common.opt:1124 -#, fuzzy -#| msgid "Perform speculative devirtualization" msgid "Perform speculative devirtualization." -msgstr "Utför spekulativ avvirtualisering" +msgstr "Utför spekulativ avvirtualisering." #: common.opt:1128 msgid "Try to convert virtual calls to direct ones." msgstr "Försök att konvertera virtuella anrop till direkta." #: common.opt:1132 -#, fuzzy -#| msgid "-fdiagnostics-show-location=[once|every-line]\tHow often to emit source location at the beginning of line-wrapped diagnostics" msgid "-fdiagnostics-show-location=[once|every-line]\tHow often to emit source location at the beginning of line-wrapped diagnostics." -msgstr "-fdiagnostics-show-location=[once|every-line]\tAnger hur ofta källkodspositioner skall skrivas ut i början av utskrift vid radbrytning" +msgstr "-fdiagnostics-show-location=[once|every-line]\tAnger hur ofta källkodspositioner skall skrivas ut i början av utskrift vid radbrytning." #: common.opt:1149 -#, fuzzy -#| msgid "Show the source line with a caret indicating the column" msgid "Show the source line with a caret indicating the column." -msgstr "Visa källkodsrader med en cirkumflex som indikerar kolumnen" +msgstr "Visa källkodsrader med en cirkumflex som indikerar kolumnen." #: common.opt:1157 -#, fuzzy -#| msgid "-fdiagnostics-color=[never|always|auto]\tColorize diagnostics" msgid "-fdiagnostics-color=[never|always|auto]\tColorize diagnostics." -msgstr "-fdiagnostics-color=[never|always|auto]\tFärglägg felmeddelanden" +msgstr "-fdiagnostics-color=[never|always|auto]\tFärglägg felmeddelanden." #: common.opt:1177 -#, fuzzy -#| msgid "Amend appropriate diagnostic messages with the command line option that controls them" msgid "Amend appropriate diagnostic messages with the command line option that controls them." -msgstr "Lägg till lämpliga diagnostiska meddelanden till kommandoradsflaggan som styr dem" +msgstr "Lägg till lämpliga diagnostiska meddelanden till kommandoradsflaggan som styr dem." #: common.opt:1181 -#, fuzzy -#| msgid "-fdisable-[tree|rtl|ipa]-=range1+range2 disables an optimization pass" msgid "-fdisable-[tree|rtl|ipa]-=range1+range2 disables an optimization pass." -msgstr "-fdisable-[tree|rtl|ipa]-=intrvl1+intrvl2 avaktiverar ett optimeringspass" +msgstr "-fdisable-[tree|rtl|ipa]-=intrvl1+intrvl2 avaktiverar ett optimeringspass." #: common.opt:1185 -#, fuzzy -#| msgid "-fenable-[tree|rtl|ipa]-=range1+range2 enables an optimization pass" msgid "-fenable-[tree|rtl|ipa]-=range1+range2 enables an optimization pass." -msgstr "-fenable-[tree|rtl|ipa]-=intrvl1+intrvl2 aktiverar ett optimeringspass" +msgstr "-fenable-[tree|rtl|ipa]-=intrvl1+intrvl2 aktiverar ett optimeringspass." #: common.opt:1189 -#, fuzzy -#| msgid "-fdump-\tDump various compiler internals to a file" msgid "-fdump-\tDump various compiler internals to a file." -msgstr "-fdump-\tSkriv ut diverse intern kompilatorinformation till en fil" +msgstr "-fdump-\tSkriv ut diverse intern kompilatorinformation till en fil." #: common.opt:1196 -#, fuzzy -#| msgid "-fdump-final-insns=filename\tDump to filename the insns at the end of translation" msgid "-fdump-final-insns=filename\tDump to filename the insns at the end of translation." -msgstr "-fdump-final-insns=filnamn\tSkriv instruktionerna vid slutet av översättningen till filnamn" +msgstr "-fdump-final-insns=filnamn\tSkriv instruktionerna vid slutet av översättningen till filnamn." #: common.opt:1200 -#, fuzzy -#| msgid "-fdump-go-spec=filename\tWrite all declarations to file as Go code" msgid "-fdump-go-spec=filename\tWrite all declarations to file as Go code." -msgstr "-fdump-go-spec=filnamn\tSkriv alla deklarationer till fil som Go-kod" +msgstr "-fdump-go-spec=filnamn\tSkriv alla deklarationer till fil som Go-kod." #: common.opt:1204 -#, fuzzy -#| msgid "Suppress output of addresses in debugging dumps" msgid "Suppress output of addresses in debugging dumps." -msgstr "Undertryck utskrift av adresser i felsökningsutskrifter" +msgstr "Undertryck utskrift av adresser i felsökningsutskrifter." #: common.opt:1208 msgid "Collect and dump debug information into temporary file if ICE in C/C++" @@ -17060,78 +13585,56 @@ msgid "Dump detailed information on GCC's internal representation of source code msgstr "Skriv ut detaljerad information om GCC:s interna representation av källkodsplatser." #: common.opt:1217 -#, fuzzy -#| msgid "Dump optimization passes" msgid "Dump optimization passes." -msgstr "Dumpa optimeringspass" +msgstr "Dumpa optimeringspass." #: common.opt:1221 -#, fuzzy -#| msgid "Suppress output of instruction numbers, line number notes and addresses in debugging dumps" msgid "Suppress output of instruction numbers, line number notes and addresses in debugging dumps." -msgstr "Undertryck utskrift av instruktionsantal, radnummernoteringar och -adresser i felsökningsutskrifter" +msgstr "Undertryck utskrift av instruktionsantal, radnummernoteringar och -adresser i felsökningsutskrifter." #: common.opt:1225 -#, fuzzy -#| msgid "Suppress output of previous and next insn numbers in debugging dumps" msgid "Suppress output of previous and next insn numbers in debugging dumps." -msgstr "Undertryck utskrift föregående och nästa instruktionsnummer i felsökningsutskrifter" +msgstr "Undertryck utskrift föregående och nästa instruktionsnummer i felsökningsutskrifter." #: common.opt:1229 msgid "Enable CFI tables via GAS assembler directives." msgstr "Aktivera CFI-tabeller via GAS-assemblerdirektiv." #: common.opt:1233 -#, fuzzy -#| msgid "Perform early inlining" msgid "Perform early inlining." -msgstr "Utför tidig inline:ing" +msgstr "Utför tidig inline:ing." #: common.opt:1237 -#, fuzzy -#| msgid "Perform DWARF2 duplicate elimination" msgid "Perform DWARF duplicate elimination." -msgstr "Utför dubbletteliminering i DWARF2" +msgstr "Utför dubbletteliminering i DWARF." #: common.opt:1241 -#, fuzzy -#| msgid "Perform interprocedural reduction of aggregates" msgid "Perform interprocedural reduction of aggregates." -msgstr "Utför interprocedurell reduktion av aggregat" +msgstr "Utför interprocedurell reduktion av aggregat." #: common.opt:1245 -#, fuzzy -#| msgid "Perform unused symbol elimination in debug info" msgid "Perform unused symbol elimination in debug info." -msgstr "Utför eliminering av oanvända symboler i felsökningsinformation" +msgstr "Utför eliminering av oanvända symboler i felsökningsinformation." #: common.opt:1249 -#, fuzzy -#| msgid "Perform unused type elimination in debug info" msgid "Perform unused type elimination in debug info." -msgstr "Utför eliminering av oanvända typer i felsökningsinformation" +msgstr "Utför eliminering av oanvända typer i felsökningsinformation." #: common.opt:1253 msgid "Do not suppress C++ class debug information." msgstr "Undertryck inte felsökningsinformation för C++-klasser." #: common.opt:1257 -#, fuzzy -#| msgid "Enable exception handling" msgid "Enable exception handling." -msgstr "Aktivera undantagshantering" +msgstr "Aktivera undantagshantering." #: common.opt:1261 -#, fuzzy -#| msgid "Perform a number of minor, expensive optimizations" msgid "Perform a number of minor, expensive optimizations." -msgstr "Utför ett antal smärre, dyra optimeringar" +msgstr "Utför ett antal smärre, dyra optimeringar." #: common.opt:1265 -#, fuzzy -#| msgid "-fexcess-precision=[fast|standard]\tSpecify handling of excess floating-point precision" msgid "-fexcess-precision=[fast|standard]\tSpecify handling of excess floating-point precision." -msgstr "-fexecc-precision=[fast|standard]\tAnge hantering av överskjutande precision på flyttal" +msgstr "-fexecc-precision=[fast|standard]\tAnge hantering av överskjutande precision på flyttal." #: common.opt:1268 #, c-format @@ -17143,28 +13646,20 @@ msgid "Output lto objects containing both the intermediate language and binary o msgstr "Mata ut lto-objekt som innehåller både mellanspråket och binärutdata." #: common.opt:1285 -#, fuzzy -#| msgid "Assume no NaNs or infinities are generated" msgid "Assume no NaNs or infinities are generated." -msgstr "Anta att inga NaN:er eller oändligheter genereras" +msgstr "Anta att inga NaN:er eller oändligheter genereras." #: common.opt:1289 -#, fuzzy -#| msgid "-ffixed-\tMark as being unavailable to the compiler" msgid "-ffixed-\tMark as being unavailable to the compiler." -msgstr "-ffixed-\tMarkera som ej tillgängligt för kompilatorn" +msgstr "-ffixed-\tMarkera som ej tillgängligt för kompilatorn." #: common.opt:1293 -#, fuzzy -#| msgid "Don't allocate floats and doubles in extended-precision registers" msgid "Don't allocate floats and doubles in extended-precision registers." -msgstr "Allokera inte float och double i register med utökad precision" +msgstr "Allokera inte float och double i register med utökad precision." #: common.opt:1301 -#, fuzzy -#| msgid "Perform a forward propagation pass on RTL" msgid "Perform a forward propagation pass on RTL." -msgstr "Utför ett framåtpropageringspass på RTL" +msgstr "Utför ett framåtpropageringspass på RTL." #: common.opt:1305 msgid "-ffp-contract=[off|on|fast] Perform floating-point expression contraction." @@ -17176,42 +13671,30 @@ msgid "unknown floating point contraction style %qs" msgstr "okänd stil för flyttalssammandragning %qs" #: common.opt:1325 -#, fuzzy -#| msgid "Allow function addresses to be held in registers" msgid "Allow function addresses to be held in registers." -msgstr "Tillåt att funktionsadresser läggs i register" +msgstr "Tillåt att funktionsadresser läggs i register." #: common.opt:1329 -#, fuzzy -#| msgid "Place each function into its own section" msgid "Place each function into its own section." -msgstr "Placera varje funktion i sin egen sektion" +msgstr "Placera varje funktion i sin egen sektion." #: common.opt:1333 -#, fuzzy -#| msgid "Perform global common subexpression elimination" msgid "Perform global common subexpression elimination." -msgstr "Utför global eliminering av gemensamma deluttryck" +msgstr "Utför global eliminering av gemensamma deluttryck." #: common.opt:1337 -#, fuzzy -#| msgid "Perform enhanced load motion during global common subexpression elimination" msgid "Perform enhanced load motion during global common subexpression elimination." -msgstr "Utför förbättrad förflyttning av inläsning under global eliminering av gemensamma deluttryck" +msgstr "Utför förbättrad förflyttning av laddning under global eliminering av gemensamma deluttryck." #: common.opt:1341 -#, fuzzy -#| msgid "Perform store motion after global common subexpression elimination" msgid "Perform store motion after global common subexpression elimination." -msgstr "Utför förflyttning av lagring efter global eliminering av gemensamma deluttryck" +msgstr "Utför förflyttning av lagring efter global eliminering av gemensamma deluttryck." #: common.opt:1345 msgid "Perform redundant load after store elimination in global common subexpression" -msgstr "Utför eliminering av överflödig inläsning efter lagring i globala gemensamma deluttryck" +msgstr "Utför eliminering av överflödig laddning efter lagring i globala gemensamma deluttryck" #: common.opt:1350 -#, fuzzy -#| msgid "Perform global common subexpression elimination after register allocation" msgid "Perform global common subexpression elimination after register allocation has" msgstr "Utför global eliminering av gemensamma deluttryck efter registertilldelning" @@ -17220,81 +13703,57 @@ msgid "-fgnat-encodings=[all|gdb|minimal]\tSelect the balance between GNAT encod msgstr "-fgnat-encodings=[all|gdb|minimal]\tVälj balansen mellan GNAT-kodningar och standard DWARF som skrivs ut i felsökningsinformationen" #: common.opt:1372 -#, fuzzy -#| msgid "Enable in and out of Graphite representation" msgid "Enable in and out of Graphite representation." -msgstr "Aktivera in och ut från Graphite-representation" +msgstr "Aktivera in och ut från Graphite-representation." #: common.opt:1376 -#, fuzzy -#| msgid "Enable Graphite Identity transformation" msgid "Enable Graphite Identity transformation." -msgstr "Aktivera Graphite-identitetstransformation" +msgstr "Aktivera Graphite-identitetstransformation." #: common.opt:1380 msgid "Enable hoisting adjacent loads to encourage generating conditional move" -msgstr "Aktivera närliggande lyftningslast för att uppmuntra generering av villkorliga förflyttningar." +msgstr "Aktivera närliggande lyftningsladdning för att uppmuntra generering av villkorliga förflyttningar." #: common.opt:1389 -#, fuzzy -#| msgid "Mark all loops as parallel" msgid "Mark all loops as parallel." -msgstr "Markera alla slingor som parallella" +msgstr "Markera alla slingor som parallella." #: common.opt:1393 common.opt:1397 common.opt:1401 common.opt:1405 #: common.opt:2388 -#, fuzzy -#| msgid "Enable loop interchange transforms. Same as -floop-interchange" msgid "Enable loop nest transforms. Same as -floop-nest-optimize." -msgstr "Aktivera transformationen utbyte (interchange) i slingor. Samma som -floop-interchange" +msgstr "Aktivera transformationer av slingutbyten. Samma som -floop-nest-interchange." #: common.opt:1409 -#, fuzzy -#| msgid "Enable support for GNU transactional memory" msgid "Enable support for GNU transactional memory." -msgstr "Aktivera stöd för GNU:s transationsminne" +msgstr "Aktivera stöd för GNU:s transationsminne." #: common.opt:1413 -#, fuzzy -#| msgid "Use STB_GNU_UNIQUE if supported by the assembler" msgid "Use STB_GNU_UNIQUE if supported by the assembler." -msgstr "Använd STB_GNU_UNIQUE om det stödjs av assemblern" +msgstr "Använd STB_GNU_UNIQUE om det stödjs av assemblern." #: common.opt:1421 -#, fuzzy -#| msgid "Enable the ISL based loop nest optimizer" msgid "Enable the loop nest optimizer." -msgstr "Aktevera den ISL-baserade optimeraren av slingnästning" +msgstr "Aktivera optimeraren av slingnästning." #: common.opt:1425 -#, fuzzy -#| msgid "Force bitfield accesses to match their type width" msgid "Force bitfield accesses to match their type width." -msgstr "Tvinga bitfältsåtkomster att matcha sin typbredd" +msgstr "Tvinga bitfältsåtkomster att matcha sin typbredd." #: common.opt:1429 -#, fuzzy -#| msgid "Enable guessing of branch probabilities" msgid "Enable guessing of branch probabilities." -msgstr "Aktivera att grensannolikheter gissas" +msgstr "Aktivera att grensannolikheter gissas." #: common.opt:1437 -#, fuzzy -#| msgid "Process #ident directives" msgid "Process #ident directives." -msgstr "Hantera #ident-direktiv" +msgstr "Hantera #ident-direktiv." #: common.opt:1441 -#, fuzzy -#| msgid "Perform conversion of conditional jumps to branchless equivalents" msgid "Perform conversion of conditional jumps to branchless equivalents." -msgstr "Utför konvertering av villkorliga hopp till grenlösa motsvarigheter" +msgstr "Utför konvertering av villkorliga hopp till grenlösa motsvarigheter." #: common.opt:1445 -#, fuzzy -#| msgid "Perform conversion of conditional jumps to conditional execution" msgid "Perform conversion of conditional jumps to conditional execution." -msgstr "Utför konvertering av villkorliga hopp till villkorlig exekvering" +msgstr "Utför konvertering av villkorliga hopp till villkorlig exekvering." #: common.opt:1449 msgid "-fstack-reuse=[all|named_vars|none] Set stack reuse level for local variables." @@ -17306,146 +13765,100 @@ msgid "unknown Stack Reuse Level %qs" msgstr "okänd stackåteranvändningsmodell %qs" #: common.opt:1465 -#, fuzzy -#| msgid "Convert conditional jumps in innermost loops to branchless equivalents" msgid "Convert conditional jumps in innermost loops to branchless equivalents." -msgstr "Konvertera villkorliga hopp i innersta slingor till grenlösa motsvarigheter" +msgstr "Konvertera villkorliga hopp i innersta slingor till grenlösa motsvarigheter." #: common.opt:1469 -#, fuzzy -#| msgid "Also if-convert conditional jumps containing memory writes" msgid "Also if-convert conditional jumps containing memory writes." -msgstr "Även if-convert villkorliga hopp som innehåller minnesskrivningar" +msgstr "Även if-convert villkorliga hopp som innehåller minnesskrivningar." #: common.opt:1477 -#, fuzzy -#| msgid "Do not generate .size directives" msgid "Do not generate .size directives." -msgstr "Generera inte .size-direktiv" +msgstr "Generera inte .size-direktiv." #: common.opt:1481 -#, fuzzy -#| msgid "Perform indirect inlining" msgid "Perform indirect inlining." -msgstr "Utför indirekt inline:ing" +msgstr "Utför indirekt inline:ing." #: common.opt:1487 -#, fuzzy -#| msgid "Enable inlining of function declared \"inline\", disabling disables all inlining" msgid "Enable inlining of function declared \"inline\", disabling disables all inlining." -msgstr "Aktivera inline:ing av funktioner deklarerade ”inline”, avslaget avaktiveras all inline:ing" +msgstr "Aktivera inline:ing av funktioner deklarerade ”inline”, avslaget avaktiveras all inline:ing." #: common.opt:1491 -#, fuzzy -#| msgid "Integrate functions into their callers when code size is known not to grow" msgid "Integrate functions into their callers when code size is known not to grow." -msgstr "Integrera funktioner i deras anropare när det är klart att kodstorleken inte växer" +msgstr "Integrera funktioner i deras anropare när det är klart att kodstorleken inte växer." #: common.opt:1495 -#, fuzzy -#| msgid "Integrate functions not declared \"inline\" into their callers when profitable" msgid "Integrate functions not declared \"inline\" into their callers when profitable." -msgstr "Integrera funktioner deklarerade ”inline” i deras anropare när det lönar sig" +msgstr "Integrera funktioner deklarerade ”inline” i deras anropare när det lönar sig." #: common.opt:1499 -#, fuzzy -#| msgid "Integrate functions only required by their single caller" msgid "Integrate functions only required by their single caller." -msgstr "Integrera funktioner som endast behövs av deras enda anropare" +msgstr "Integrera funktioner som endast behövs av deras enda anropare." #: common.opt:1506 -#, fuzzy -#| msgid "-finline-limit=\tLimit the size of inlined functions to " msgid "-finline-limit=\tLimit the size of inlined functions to ." -msgstr "-finline-limit=\tBegränsa storlek på inline-funktioner till " +msgstr "-finline-limit=\tBegränsa storlek på inline-funktioner till ." #: common.opt:1510 msgid "Inline __atomic operations when a lock free instruction sequence is available." msgstr "Inline:a __atomic-operationer när en låsningsfri instruktionssekvens är tillgänglig." #: common.opt:1514 -#, fuzzy -#| msgid "Instrument function entry and exit with profiling calls" msgid "Instrument function entry and exit with profiling calls." -msgstr "Instrumentera funktionsingång och -utgång med profileringsanrop" +msgstr "Instrumentera funktionsingång och -utgång med profileringsanrop." #: common.opt:1518 -#, fuzzy -#| msgid "-finstrument-functions-exclude-function-list=name,... Do not instrument listed functions" msgid "-finstrument-functions-exclude-function-list=name,... Do not instrument listed functions." -msgstr "-finstrument-functions-exclude-function-list=namn,... Instrumentera inte uppräknade funktioner" +msgstr "-finstrument-functions-exclude-function-list=namn,... Instrumentera inte uppräknade funktioner." #: common.opt:1522 -#, fuzzy -#| msgid "-finstrument-functions-exclude-file-list=filename,... Do not instrument functions listed in files" msgid "-finstrument-functions-exclude-file-list=filename,... Do not instrument functions listed in files." -msgstr "-finstrument-functions-exclude-file-list=filenamn,... Instrumentera inte funktioner uppräknade i filerna" +msgstr "-finstrument-functions-exclude-file-list=filenamn,... Instrumentera inte funktioner uppräknade i filerna." #: common.opt:1526 -#, fuzzy -#| msgid "Perform interprocedural constant propagation" msgid "Perform interprocedural constant propagation." -msgstr "Utför konstantpropagering mellan procedurer" +msgstr "Utför konstantpropagering mellan procedurer." #: common.opt:1530 -#, fuzzy -#| msgid "Perform cloning to make Interprocedural constant propagation stronger" msgid "Perform cloning to make Interprocedural constant propagation stronger." -msgstr "Utför kloning för att göra konstantpropagering mellan procedurer starkare" +msgstr "Utför kloning för att göra konstantpropagering mellan procedurer starkare." #: common.opt:1534 -#, fuzzy -#| msgid "Perform alignment discovery and propagation to make Interprocedural constant propagation stronger" msgid "Perform alignment discovery and propagation to make Interprocedural constant propagation stronger." -msgstr "Utför upptäckt och propagering av justering för att göra konstantpropagering mellan procedurer starkare" +msgstr "Utför upptäckt och propagering av justering för att göra konstantpropagering mellan procedurer starkare." #: common.opt:1538 -#, fuzzy -#| msgid "Perform interprocedural profile propagation" msgid "Perform interprocedural profile propagation." -msgstr "Utför profileringspropagering mellan procedurer" +msgstr "Utför profileringspropagering mellan procedurer." #: common.opt:1542 -#, fuzzy -#| msgid "Perform interprocedural points-to analysis" msgid "Perform interprocedural points-to analysis." -msgstr "Utför pekar-på-analyser mellan procedurer" +msgstr "Utför pekar-på-analyser mellan procedurer." #: common.opt:1546 -#, fuzzy -#| msgid "Discover pure and const functions" msgid "Discover pure and const functions." -msgstr "Upptäck pure- och const-funktioner" +msgstr "Upptäck pure- och const-funktioner." #: common.opt:1550 -#, fuzzy -#| msgid "Perform Identical Code Folding for functions and read-only variables" msgid "Perform Identical Code Folding for functions and read-only variables." -msgstr "Fäll ihop identisk kod för funktioner och endast läsbara variabler" +msgstr "Fäll ihop identisk kod för funktioner och endast läsbara variabler." #: common.opt:1554 -#, fuzzy -#| msgid "Perform Identical Code Folding for functions" msgid "Perform Identical Code Folding for functions." -msgstr "Fäll ihop identisk kod för funktioner" +msgstr "Fäll ihop identisk kod för funktioner." #: common.opt:1558 -#, fuzzy -#| msgid "Perform Identical Code Folding for variables" msgid "Perform Identical Code Folding for variables." -msgstr "Utför ihopfällning av identiskt kod för variabler" +msgstr "Utför ihopfällning av identiskt kod för variabler." #: common.opt:1562 -#, fuzzy -#| msgid "Discover readonly and non addressable static variables" msgid "Discover readonly and non addressable static variables." -msgstr "Upptäck endast läsbara och icke adresserbara statiska variabler" +msgstr "Upptäck endast läsbara och icke adresserbara statiska variabler." #: common.opt:1574 -#, fuzzy -#| msgid "-fira-algorithm=[CB|priority] Set the used IRA algorithm" msgid "-fira-algorithm=[CB|priority] Set the used IRA algorithm." -msgstr "-fira-algorithm=[CB|priority] Bestäm den använda IRA-algoritmen" +msgstr "-fira-algorithm=[CB|priority] Bestäm den använda IRA-algoritmen." #: common.opt:1577 #, c-format @@ -17453,10 +13866,8 @@ msgid "unknown IRA algorithm %qs" msgstr "okänd IRA-algoritm %qs" #: common.opt:1587 -#, fuzzy -#| msgid "-fira-region=[one|all|mixed] Set regions for IRA" msgid "-fira-region=[one|all|mixed] Set regions for IRA." -msgstr "-fira-region=[one|all|mixed] Sätt regioner för IRA" +msgstr "-fira-region=[one|all|mixed] Sätt regioner för IRA." #: common.opt:1590 #, c-format @@ -17480,46 +13891,32 @@ msgid "-fira-verbose=\tControl IRA's level of diagnostic messages." msgstr "-fira-verbose=\tStyr IRA:ns nivå på diagnostikmeddelanden." #: common.opt:1625 -#, fuzzy -#| msgid "Optimize induction variables on trees" msgid "Optimize induction variables on trees." -msgstr "Optimera induktionsvariabler på träd" +msgstr "Optimera induktionsvariabler på träd." #: common.opt:1629 -#, fuzzy -#| msgid "Use jump tables for sufficiently large switch statements" msgid "Use jump tables for sufficiently large switch statements." -msgstr "Använd hopptabeller för tillräckligt stora switch-satser" +msgstr "Använd hopptabeller för tillräckligt stora switch-satser." #: common.opt:1633 -#, fuzzy -#| msgid "Generate code for functions even if they are fully inlined" msgid "Generate code for functions even if they are fully inlined." -msgstr "Generera kod för funktioner även om de är fullständigt inline:ade" +msgstr "Generera kod för funktioner även om de är fullständigt inline:ade." #: common.opt:1637 -#, fuzzy -#| msgid "Generate code for functions even if they are fully inlined" msgid "Generate code for static functions even if they are never called." -msgstr "Generera kod för funktioner även om de är fullständigt inline:ade" +msgstr "Generera kod för statiska funktioner även om de aldrig anropas." #: common.opt:1641 -#, fuzzy -#| msgid "Emit static const variables even if they are not used" msgid "Emit static const variables even if they are not used." -msgstr "Mata ut static const-variabler även om de inte används" +msgstr "Mata ut static const-variabler även om de inte används." #: common.opt:1645 -#, fuzzy -#| msgid "Give external symbols a leading underscore" msgid "Give external symbols a leading underscore." -msgstr "Ge externa symboler ett inledande understrykningstecken" +msgstr "Ge externa symboler ett inledande understrykningstecken." #: common.opt:1653 -#, fuzzy -#| msgid "Do CFG-sensitive rematerialization in LRA" msgid "Do CFG-sensitive rematerialization in LRA." -msgstr "Gör CFG-känsliga återmaterialiseringar i LRA" +msgstr "Gör CFG-känsliga återmaterialiseringar i LRA." #: common.opt:1657 msgid "Enable link-time optimization." @@ -17535,124 +13932,84 @@ msgid "unknown LTO partitioning model %qs" msgstr "okänd LTO-partitioneringsmodell %qs" #: common.opt:1683 -#, fuzzy -#| msgid "Specify the algorithm to partition symbols and vars at linktime" msgid "Specify the algorithm to partition symbols and vars at linktime." -msgstr "Ange algoritmen för att dela upp symboler och variabler vid länktillfället" +msgstr "Ange algoritmen för att dela upp symboler och variabler vid länktillfället." #: common.opt:1688 -#, fuzzy -#| msgid "-flto-compression-level=\tUse zlib compression level for IL" msgid "-flto-compression-level=\tUse zlib compression level for IL." -msgstr "-flto-compression-level=\tAnvänd zlib-komprimering på nivå för IL" +msgstr "-flto-compression-level=\tAnvänd zlib-komprimering på nivå för IL." #: common.opt:1692 -#, fuzzy -#| msgid "Merge C++ types using One Definition Rule" msgid "Merge C++ types using One Definition Rule." -msgstr "Slå samman C++-typer med endefinitionsregeln" +msgstr "Slå samman C++-typer med endefinitionsregeln." #: common.opt:1696 -#, fuzzy -#| msgid "Report various link-time optimization statistics" msgid "Report various link-time optimization statistics." -msgstr "Rapportera diverse optimeringsstatistik från länkningen" +msgstr "Rapportera diverse optimeringsstatistik från länkningen." #: common.opt:1700 -#, fuzzy -#| msgid "Report various link-time optimization statistics for WPA only" msgid "Report various link-time optimization statistics for WPA only." -msgstr "Rapportera diverse optimeringsstatistik från länkningen endast för WPA." +msgstr "Rapportera diverse optimeringsstatistik från länkningen endast för WPA.." #: common.opt:1704 -#, fuzzy -#| msgid "Set errno after built-in math functions" msgid "Set errno after built-in math functions." -msgstr "Sätt errno efter inbyggda matematikfunktioner" +msgstr "Sätt errno efter inbyggda matematikfunktioner." #: common.opt:1708 -#, fuzzy -#| msgid "-fmax-errors=\tMaximum number of errors to report" msgid "-fmax-errors=\tMaximum number of errors to report." -msgstr "-fmax-errors=\tMaximalt antal fel som skall rapporteras" +msgstr "-fmax-errors=\tMaximalt antal fel som skall rapporteras." #: common.opt:1712 -#, fuzzy -#| msgid "Report on permanent memory allocation" msgid "Report on permanent memory allocation." -msgstr "Rapportera om permanent minnesallokering" +msgstr "Rapportera om permanent minnesallokering." #: common.opt:1716 -#, fuzzy -#| msgid "Report on permanent memory allocation in WPA only" msgid "Report on permanent memory allocation in WPA only." -msgstr "Rapportera bara om permanent minnesallokering i WPA" +msgstr "Rapportera bara om permanent minnesallokering i WPA." #: common.opt:1723 -#, fuzzy -#| msgid "Attempt to merge identical constants and constant variables" msgid "Attempt to merge identical constants and constant variables." -msgstr "Försök slå samman identiska konstanter och konstanta variabler" +msgstr "Försök slå samman identiska konstanter och konstanta variabler." #: common.opt:1727 -#, fuzzy -#| msgid "Attempt to merge identical constants across compilation units" msgid "Attempt to merge identical constants across compilation units." -msgstr "Försök slå samman identiska konstanter mellan kompileringsenheter" +msgstr "Försök slå samman identiska konstanter mellan kompileringsenheter." #: common.opt:1731 -#, fuzzy -#| msgid "Attempt to merge identical debug strings across compilation units" msgid "Attempt to merge identical debug strings across compilation units." -msgstr "Försök slå samman identiska felsökningssträngar mellan kompileringsenheter" +msgstr "Försök slå samman identiska felsökningssträngar mellan kompileringsenheter." #: common.opt:1735 -#, fuzzy -#| msgid "-fmessage-length=\tLimit diagnostics to characters per line. 0 suppresses line-wrapping" msgid "-fmessage-length=\tLimit diagnostics to characters per line. 0 suppresses line-wrapping." -msgstr "-fmessage-length=\tBegränsa felmeddelandens längd till tecken per rad. 0 stänger av radbrytning" +msgstr "-fmessage-length=\tBegränsa felmeddelandens längd till tecken per rad. 0 stänger av radbrytning." #: common.opt:1739 -#, fuzzy -#| msgid "Perform SMS based modulo scheduling before the first scheduling pass" msgid "Perform SMS based modulo scheduling before the first scheduling pass." -msgstr "Utför SMS-baserad modulo-schemaläggning före det första schemaläggningspasset" +msgstr "Utför SMS-baserad modulo-schemaläggning före det första schemaläggningspasset." #: common.opt:1743 -#, fuzzy -#| msgid "Perform SMS based modulo scheduling with register moves allowed" msgid "Perform SMS based modulo scheduling with register moves allowed." -msgstr "Utför SMS-baserad modulo-schemaläggning med tillåten registerförflyttning" +msgstr "Utför SMS-baserad modulo-schemaläggning med tillåten registerförflyttning." #: common.opt:1747 -#, fuzzy -#| msgid "Move loop invariant computations out of loops" msgid "Move loop invariant computations out of loops." -msgstr "Flytta slinginvarianta beräkningar ut från slingor" +msgstr "Flytta slinginvarianta beräkningar ut från slingor." #: common.opt:1751 -#, fuzzy -#| msgid "Use the RTL dead code elimination pass" msgid "Use the RTL dead code elimination pass." -msgstr "Använd passet på RTL för eliminering av död kod" +msgstr "Använd passet på RTL för eliminering av död kod." #: common.opt:1755 -#, fuzzy -#| msgid "Use the RTL dead store elimination pass" msgid "Use the RTL dead store elimination pass." -msgstr "Använd passet på RTL för eliminering av död lagring" +msgstr "Använd passet på RTL för eliminering av död lagring." #: common.opt:1759 -#, fuzzy -#| msgid "Enable/Disable the traditional scheduling in loops that already passed modulo scheduling" msgid "Enable/Disable the traditional scheduling in loops that already passed modulo scheduling." -msgstr "Aktivera/deaktivera den traditionella schemaläggningen i slingor som redan passerat modulo-schemaläggning" +msgstr "Aktivera/deaktivera den traditionella schemaläggningen i slingor som redan passerat modulo-schemaläggning." #: common.opt:1763 -#, fuzzy -#| msgid "Support synchronous non-call exceptions" msgid "Support synchronous non-call exceptions." -msgstr "Stöd synkrona icke-anropsundantag" +msgstr "Stöd synkrona icke-anropsundantag." #: common.opt:1766 #, c-format @@ -17660,16 +14017,12 @@ msgid "options or targets missing after %qs" msgstr "flaggor eller mål saknas efter %qs" #: common.opt:1767 -#, fuzzy -#| msgid "-foffload== Specify offloading targets and options for them" msgid "-foffload== Specify offloading targets and options for them." -msgstr "-foffload== Ange mål att lasta av till och flaggor för dem" +msgstr "-foffload== Ange mål att lasta av till och flaggor för dem." #: common.opt:1771 -#, fuzzy -#| msgid "-foffload-abi=[lp64|ilp32] Set the ABI to use in an offload compiler" msgid "-foffload-abi=[lp64|ilp32] Set the ABI to use in an offload compiler." -msgstr "-foffload-abi=[lp64|ilp32] Ange ABI:et att använda i en avlastningskompilator" +msgstr "-foffload-abi=[lp64|ilp32] Ange ABI:et att använda i en avlastningskompilator." #: common.opt:1774 #, c-format @@ -17677,600 +14030,413 @@ msgid "unknown offload ABI %qs" msgstr "okänd avlastnings-ABI %qs" #: common.opt:1784 -#, fuzzy -#| msgid "When possible do not generate stack frames" msgid "When possible do not generate stack frames." -msgstr "Låt bli att generera stackramar när det är möjligt" +msgstr "Låt bli att generera stackramar när det är möjligt." #: common.opt:1788 -#, fuzzy -#| msgid "Enable all optimization info dumps on stderr" msgid "Enable all optimization info dumps on stderr." -msgstr "Aktivera alla optimeringsinformationsdumpar på standard fel" +msgstr "Aktivera alla optimeringsinformationsdumpar på standard fel." #: common.opt:1792 -#, fuzzy -#| msgid "-fopt-info[-=filename]\tDump compiler optimization details" msgid "-fopt-info[-=filename]\tDump compiler optimization details." -msgstr "-fopt-info[-=filenamn]\tSkriv ut kompilatoroptimeringsdetaljer" +msgstr "-fopt-info[-=filenamn]\tSkriv ut kompilatoroptimeringsdetaljer." #: common.opt:1800 -#, fuzzy -#| msgid "Optimize sibling and tail recursive calls" msgid "Optimize sibling and tail recursive calls." -msgstr "Optimera syskon- och svansrekursiva anrop" +msgstr "Optimera syskon- och svansrekursiva anrop." #: common.opt:1804 -#, fuzzy -#| msgid "Perform partial inlining" msgid "Perform partial inlining." -msgstr "Utför partiell inline:ing" +msgstr "Utför partiell inline:ing." #: common.opt:1808 common.opt:1812 -#, fuzzy -#| msgid "Report on memory allocation before interprocedural optimization" msgid "Report on memory allocation before interprocedural optimization." -msgstr "Rapportera minnesallokering för interprocedurella optimeringar" +msgstr "Rapportera minnesallokering för interprocedurella optimeringar." #: common.opt:1816 -#, fuzzy -#| msgid "Pack structure members together without holes" msgid "Pack structure members together without holes." -msgstr "Packa ihop postmedlemmar utan hål" +msgstr "Packa ihop postmedlemmar utan hål." #: common.opt:1820 -#, fuzzy -#| msgid "-fpack-struct=\tSet initial maximum structure member alignment" msgid "-fpack-struct=\tSet initial maximum structure member alignment." -msgstr "-fpack-struct=\tAnge initial maximal justering för postmedlemmar" +msgstr "-fpack-struct=\tAnge initial maximal justering för postmedlemmar." #: common.opt:1824 -#, fuzzy -#| msgid "Return small aggregates in memory, not registers" msgid "Return small aggregates in memory, not registers." -msgstr "Returnera små aggregat i minne, inte register" +msgstr "Returnera små aggregat i minne, inte register." #: common.opt:1828 -#, fuzzy -#| msgid "Perform loop peeling" msgid "Perform loop peeling." -msgstr "Utför slingavskalning" +msgstr "Utför slingavskalning." #: common.opt:1832 -#, fuzzy -#| msgid "Enable machine specific peephole optimizations" msgid "Enable machine specific peephole optimizations." -msgstr "Aktivera maskinspecifika nyckelhålsoptimeringar" +msgstr "Aktivera maskinspecifika nyckelhålsoptimeringar." #: common.opt:1836 -#, fuzzy -#| msgid "Enable an RTL peephole pass before sched2" msgid "Enable an RTL peephole pass before sched2." -msgstr "Aktivera ett RTL-nyckelhålspass före sched2" +msgstr "Aktivera ett RTL-nyckelhålspass före sched2." #: common.opt:1840 -#, fuzzy -#| msgid "Generate position-independent code if possible (large mode)" msgid "Generate position-independent code if possible (large mode)." -msgstr "Generera positionsoberoende kod om möjligt (stort läge)" +msgstr "Generera positionsoberoende kod om möjligt (stort läge)." #: common.opt:1844 -#, fuzzy -#| msgid "Generate position-independent code for executables if possible (large mode)" msgid "Generate position-independent code for executables if possible (large mode)." -msgstr "Generera positionsoberoende kod för körbara program om möjligt (stort läge)" +msgstr "Generera positionsoberoende kod för körbara program om möjligt (stort läge)." #: common.opt:1848 -#, fuzzy -#| msgid "Generate position-independent code if possible (small mode)" msgid "Generate position-independent code if possible (small mode)." -msgstr "Generera positionsoberoende kod om möjligt (litet läge)" +msgstr "Generera positionsoberoende kod om möjligt (litet läge)." #: common.opt:1852 -#, fuzzy -#| msgid "Generate position-independent code for executables if possible (small mode)" msgid "Generate position-independent code for executables if possible (small mode)." -msgstr "Generera positionsoberoende kod för körbara program om möjligt (litet läge)" +msgstr "Generera positionsoberoende kod för körbara program om möjligt (litet läge)." #: common.opt:1856 msgid "Use PLT for PIC calls (-fno-plt: load the address from GOT at call site)." msgstr "Använd PLT för PIC-anrop (-fno-plt: läs adressen från GOT på anropsplatsen)." #: common.opt:1860 -#, fuzzy -#| msgid "Specify a plugin to load" msgid "Specify a plugin to load." -msgstr "Ange en instickmodul att läsa in" +msgstr "Ange en instickmodul att läsa in." #: common.opt:1864 -#, fuzzy -#| msgid "-fplugin-arg--[=]\tSpecify argument = for plugin " msgid "-fplugin-arg--[=]\tSpecify argument = for plugin ." -msgstr "-fplugin-arg--[=]\tAnge argument = för insticksmodul " +msgstr "-fplugin-arg--[=]\tAnge argument = för insticksmodul ." #: common.opt:1868 msgid "Run predictive commoning optimization." msgstr "Kör optimeringar för predikativ gemensamning." #: common.opt:1872 -#, fuzzy -#| msgid "Generate prefetch instructions, if available, for arrays in loops" msgid "Generate prefetch instructions, if available, for arrays in loops." -msgstr "Generera förhandshämtningsinstruktioner (prefetch), om tillgängliga, för vektorer i slingor" +msgstr "Generera förhandshämtningsinstruktioner (prefetch), om tillgängliga, för vektorer i slingor." #: common.opt:1876 -#, fuzzy -#| msgid "Enable basic program profiling code" msgid "Enable basic program profiling code." -msgstr "Aktivera grundläggande programprofileringskod" +msgstr "Aktivera grundläggande programprofileringskod." #: common.opt:1880 -#, fuzzy -#| msgid "Insert arc-based program profiling code" msgid "Insert arc-based program profiling code." -msgstr "Lägg in bågbaserad programprofileringskod" +msgstr "Lägg in bågbaserad programprofileringskod." #: common.opt:1884 msgid "Set the top-level directory for storing the profile data." msgstr "Sätt toppnivåkatalogen för att spara profildata." #: common.opt:1889 -#, fuzzy -#| msgid "Enable correction of flow inconsistent profile data input" msgid "Enable correction of flow inconsistent profile data input." -msgstr "Aktivera korrigering av profilindata med inkonsistent flöde" +msgstr "Aktivera korrigering av profilindata med inkonsistent flöde." #: common.opt:1893 -#, fuzzy -#| msgid "Enable common options for generating profile info for profile feedback directed optimizations" msgid "Enable common options for generating profile info for profile feedback directed optimizations." -msgstr "Aktivera vanliga flaggor för att generera profileringsinformation för optimeringar styrda av återmatad profil" +msgstr "Aktivera vanliga flaggor för att generera profileringsinformation för optimeringar styrda av återmatad profil." #: common.opt:1897 -#, fuzzy -#| msgid "Enable common options for generating profile info for profile feedback directed optimizations, and set -fprofile-dir=" msgid "Enable common options for generating profile info for profile feedback directed optimizations, and set -fprofile-dir=." -msgstr "Aktivera vanliga flaggor för att generera profileringsinformation för optimeringar styrda av återmatad profil, och sätt -fprofile-dir=" +msgstr "Aktivera vanliga flaggor för att generera profileringsinformation för optimeringar styrda av återmatad profil, och sätt -fprofile-dir=." #: common.opt:1901 -#, fuzzy -#| msgid "Enable common options for performing profile feedback directed optimizations" msgid "Enable common options for performing profile feedback directed optimizations." -msgstr "Aktivera vanliga flaggor för att utföra optimeringar styrda av återmatad profil" +msgstr "Aktivera vanliga flaggor för att utföra optimeringar styrda av återmatad profil." #: common.opt:1905 -#, fuzzy -#| msgid "Enable common options for performing profile feedback directed optimizations, and set -fprofile-dir=" msgid "Enable common options for performing profile feedback directed optimizations, and set -fprofile-dir=." -msgstr "Aktivera vanliga flaggor för att utföra optimeringar styrda av återmatad profil, och sätt -fprofile-dir=" +msgstr "Aktivera vanliga flaggor för att utföra optimeringar styrda av återmatad profil, och sätt -fprofile-dir=." #: common.opt:1909 -#, fuzzy -#| msgid "Insert code to profile values of expressions" msgid "Insert code to profile values of expressions." -msgstr "Lägg in kod för att profilera värden av uttryck" +msgstr "Lägg in kod för att profilera värden av uttryck." #: common.opt:1913 -#, fuzzy -#| msgid "Report on consistency of profile" msgid "Report on consistency of profile." -msgstr "Rapportera om intern konsistens hos profilen" +msgstr "Rapportera om intern konsistens hos profilen." #: common.opt:1917 -#, fuzzy -#| msgid "Enable function reordering that improves code placement" msgid "Enable function reordering that improves code placement." -msgstr "Aktivera omflyttning av funktioner för att förbättra kodplacering" +msgstr "Aktivera omflyttning av funktioner för att förbättra kodplacering." #: common.opt:1924 -#, fuzzy -#| msgid "-frandom-seed=\tMake compile reproducible using " msgid "-frandom-seed=\tMake compile reproducible using ." -msgstr "-frandom-seed=\tGör kompileringen reproducerbar med " +msgstr "-frandom-seed=\tGör kompileringen reproducerbar med ." #: common.opt:1934 msgid "Record gcc command line switches in the object file." msgstr "Notera gcc:s kommandoradsflaggor i objektfilen." #: common.opt:1938 -#, fuzzy -#| msgid "Return small aggregates in registers" msgid "Return small aggregates in registers." -msgstr "Returnera små poster i register" +msgstr "Returnera små poster i register." #: common.opt:1946 msgid "Tell DSE that the storage for a C++ object is dead when the constructor" msgstr "Berätta för DSE att lagringen för ett C++-objekt är dött när konstrueraren" #: common.opt:1951 -#, fuzzy -#| msgid "Relief of register pressure through live range shrinkage" msgid "Relief of register pressure through live range shrinkage." -msgstr "Lättnad av registertryck genom minskning av aktivt intervall" +msgstr "Lättnad av registertryck genom minskning av aktivt intervall." #: common.opt:1955 -#, fuzzy -#| msgid "Perform a register renaming optimization pass" msgid "Perform a register renaming optimization pass." -msgstr "Utför ett optimeringspass med registernamnbyten" +msgstr "Utför ett optimeringspass med registernamnbyten." #: common.opt:1959 -#, fuzzy -#| msgid "Perform a target dependent instruction fusion optimization pass" msgid "Perform a target dependent instruction fusion optimization pass." -msgstr "Utför ett optimeringspass med målberoende instruktionssammanslagning" +msgstr "Utför ett optimeringspass med målberoende instruktionssammanslagning." #: common.opt:1963 -#, fuzzy -#| msgid "Reorder basic blocks to improve code placement" msgid "Reorder basic blocks to improve code placement." -msgstr "Flytta om grundblock för att förbättra kodplacering" +msgstr "Flytta om grundblock för att förbättra kodplacering." #: common.opt:1967 msgid "-freorder-blocks-algorithm=[simple|stc] Set the used basic block reordering algorithm." msgstr "-freorder-blocks-algorithm=[simple|stc] Sätt algoritmen att användas för ordningsändring av grundblock." #: common.opt:1970 -#, fuzzy, c-format -#| msgid "unknown IRA algorithm %qs" +#, c-format msgid "unknown basic block reordering algorithm %qs" -msgstr "okänd IRA-algoritm %qs" +msgstr "okänd algoritm for omordning av grundblock %qs" #: common.opt:1980 -#, fuzzy -#| msgid "Reorder basic blocks and partition into hot and cold sections" msgid "Reorder basic blocks and partition into hot and cold sections." -msgstr "Flytta om grundblock och partitioner till varma och kalla sektioner" +msgstr "Flytta om grundblock och partitioner till varma och kalla sektioner." #: common.opt:1984 -#, fuzzy -#| msgid "Reorder functions to improve code placement" msgid "Reorder functions to improve code placement." -msgstr "Flytta om funktioner för att förbättra kodplacering" +msgstr "Flytta om funktioner för att förbättra kodplacering." #: common.opt:1988 -#, fuzzy -#| msgid "Add a common subexpression elimination pass after loop optimizations" msgid "Add a common subexpression elimination pass after loop optimizations." -msgstr "Lägg till ett pass för eliminering av gemensamma deluttryck efter slingoptimeringar" +msgstr "Lägg till ett pass för eliminering av gemensamma deluttryck efter slingoptimeringar." #: common.opt:1996 -#, fuzzy -#| msgid "Disable optimizations that assume default FP rounding behavior" msgid "Disable optimizations that assume default FP rounding behavior." -msgstr "Avaktivera optimeringar som antar standardmässig avrundningsbeteende för FP" +msgstr "Avaktivera optimeringar som antar standardmässig avrundningsbeteende för FP." #: common.opt:2000 -#, fuzzy -#| msgid "Enable scheduling across basic blocks" msgid "Enable scheduling across basic blocks." -msgstr "Aktivera schemaläggning mellan grundblock" +msgstr "Aktivera schemaläggning mellan grundblock." #: common.opt:2004 -#, fuzzy -#| msgid "Enable register pressure sensitive insn scheduling" msgid "Enable register pressure sensitive insn scheduling." -msgstr "Aktivera registertryckskänslig instruktionsschemaläggning" +msgstr "Aktivera registertryckskänslig instruktionsschemaläggning." #: common.opt:2008 -#, fuzzy -#| msgid "Allow speculative motion of non-loads" msgid "Allow speculative motion of non-loads." -msgstr "Tillåt spekulativ förflyttning av icke-inläsningar" +msgstr "Tillåt spekulativ förflyttning av icke-laddningar." #: common.opt:2012 -#, fuzzy -#| msgid "Allow speculative motion of some loads" msgid "Allow speculative motion of some loads." -msgstr "Tillåt spekulativ förflyttning av några inläsningar" +msgstr "Tillåt spekulativ förflyttning av några laddningar." #: common.opt:2016 -#, fuzzy -#| msgid "Allow speculative motion of more loads" msgid "Allow speculative motion of more loads." -msgstr "Tillåt spekulativ förflyttning av fler inläsningar" +msgstr "Tillåt spekulativ förflyttning av fler laddningar." #: common.opt:2020 -#, fuzzy -#| msgid "-fsched-verbose=\tSet the verbosity level of the scheduler" msgid "-fsched-verbose=\tSet the verbosity level of the scheduler." -msgstr "-fsched-verbose=\tAnge hur mångordig schemaläggaren skall vara" +msgstr "-fsched-verbose=\tAnge hur mångordig schemaläggaren skall vara." #: common.opt:2024 -#, fuzzy -#| msgid "If scheduling post reload, do superblock scheduling" msgid "If scheduling post reload, do superblock scheduling." -msgstr "Om schemaläggning efter omläsning, gör superblockschemaläggning" +msgstr "Om schemaläggning efter omläsning, gör superblockschemaläggning." #: common.opt:2032 -#, fuzzy -#| msgid "Reschedule instructions before register allocation" msgid "Reschedule instructions before register allocation." -msgstr "Schemalägg om instruktioner före registertilldelning" +msgstr "Schemalägg om instruktioner före registertilldelning." #: common.opt:2036 -#, fuzzy -#| msgid "Reschedule instructions after register allocation" msgid "Reschedule instructions after register allocation." -msgstr "Schemalägg om instruktioner efter registertilldelning" +msgstr "Schemalägg om instruktioner efter registertilldelning." #: common.opt:2043 -#, fuzzy -#| msgid "Schedule instructions using selective scheduling algorithm" msgid "Schedule instructions using selective scheduling algorithm." -msgstr "Använd selektive schemaläggningsalgoritm för schemaläggning av instruktioner" +msgstr "Använd selektive schemaläggningsalgoritm för schemaläggning av instruktioner." #: common.opt:2047 -#, fuzzy -#| msgid "Run selective scheduling after reload" msgid "Run selective scheduling after reload." -msgstr "Kör selektiv schemaläggning efter omläsning" +msgstr "Kör selektiv schemaläggning efter omläsning." #: common.opt:2051 -#, fuzzy -#| msgid "Perform software pipelining of inner loops during selective scheduling" msgid "Perform software pipelining of inner loops during selective scheduling." -msgstr "Utför programvarurörläggning av inre slingor under selektiv schemaläggning" +msgstr "Utför programvarurörläggning av inre slingor under selektiv schemaläggning." #: common.opt:2055 -#, fuzzy -#| msgid "Perform software pipelining of outer loops during selective scheduling" msgid "Perform software pipelining of outer loops during selective scheduling." -msgstr "Utför programvarurörläggning av yttre slingor under selektiv schemaläggning" +msgstr "Utför programvarurörläggning av yttre slingor under selektiv schemaläggning." #: common.opt:2059 -#, fuzzy -#| msgid "Reschedule pipelined regions without pipelining" msgid "Reschedule pipelined regions without pipelining." -msgstr "Schemalägg om rörlagda regioner utan rörläggning" +msgstr "Schemalägg om rörlagda regioner utan rörläggning." #: common.opt:2063 -#, fuzzy -#| msgid "Allow interposing function (or variables) by ones with different semantics (or initializer) respectively by dynamic linker" msgid "Allow interposing function (or variables) by ones with different semantics (or initializer) respectively by dynamic linker." -msgstr "Tillåt funktioner (eller variabler) som står emellan för sådana med annan semantik (respektive initierare) i den dynamiska länkaren" +msgstr "Tillåt funktioner (eller variabler) som står emellan för sådana med annan semantik (respektive initierare) i den dynamiska länkaren." #: common.opt:2069 -#, fuzzy -#| msgid "Allow premature scheduling of queued insns" msgid "Allow premature scheduling of queued insns." -msgstr "Tillåt förtida schemaläggning av köade instruktioner" +msgstr "Tillåt förtida schemaläggning av köade instruktioner." #: common.opt:2073 -#, fuzzy -#| msgid "-fsched-stalled-insns=\tSet number of queued insns that can be prematurely scheduled" msgid "-fsched-stalled-insns=\tSet number of queued insns that can be prematurely scheduled." -msgstr "-fsched-stalled-insns=\tAnge antalet köade instruktioner som kan schemaläggas i förtid" +msgstr "-fsched-stalled-insns=\tAnge antalet köade instruktioner som kan schemaläggas i förtid." #: common.opt:2081 -#, fuzzy -#| msgid "Set dependence distance checking in premature scheduling of queued insns" msgid "Set dependence distance checking in premature scheduling of queued insns." -msgstr "Sätt beroendeavståndet som kontrolleras i förtida schemaläggning av köade instruktioner" +msgstr "Sätt beroendeavståndet som kontrolleras i förtida schemaläggning av köade instruktioner." #: common.opt:2085 -#, fuzzy -#| msgid "-fsched-stalled-insns-dep=\tSet dependence distance checking in premature scheduling of queued insns" msgid "-fsched-stalled-insns-dep=\tSet dependence distance checking in premature scheduling of queued insns." -msgstr "-fsched-stalled-insns-dep=\tSätt beroendeavståndet som kontrolleras i förtida schemaläggning av köade instruktioner" +msgstr "-fsched-stalled-insns-dep=\tSätt beroendeavståndet som kontrolleras i förtida schemaläggning av köade instruktioner." #: common.opt:2089 -#, fuzzy -#| msgid "Enable the group heuristic in the scheduler" msgid "Enable the group heuristic in the scheduler." -msgstr "Aktivera gruppheuristiken i schemaläggaren" +msgstr "Aktivera gruppheuristiken i schemaläggaren." #: common.opt:2093 -#, fuzzy -#| msgid "Enable the critical path heuristic in the scheduler" msgid "Enable the critical path heuristic in the scheduler." -msgstr "Aktivera heuristiken för kritisk väg i schemaläggaren" +msgstr "Aktivera heuristiken för kritisk väg i schemaläggaren." #: common.opt:2097 -#, fuzzy -#| msgid "Enable the speculative instruction heuristic in the scheduler" msgid "Enable the speculative instruction heuristic in the scheduler." -msgstr "Aktivera den spekulativa instruktionsheuristiken i schemaläggaren" +msgstr "Aktivera den spekulativa instruktionsheuristiken i schemaläggaren." #: common.opt:2101 -#, fuzzy -#| msgid "Enable the rank heuristic in the scheduler" msgid "Enable the rank heuristic in the scheduler." -msgstr "Aktivera ordningsheuristiken i schemaläggaren" +msgstr "Aktivera ordningsheuristiken i schemaläggaren." #: common.opt:2105 -#, fuzzy -#| msgid "Enable the last instruction heuristic in the scheduler" msgid "Enable the last instruction heuristic in the scheduler." -msgstr "Aktivera heuristiken för sista instruktion i schemaläggaren" +msgstr "Aktivera heuristiken för sista instruktion i schemaläggaren." #: common.opt:2109 -#, fuzzy -#| msgid "Enable the dependent count heuristic in the scheduler" msgid "Enable the dependent count heuristic in the scheduler." -msgstr "Aktivera heuristiken för beroende antal i schemaläggaren" +msgstr "Aktivera heuristiken för beroende antal i schemaläggaren." #: common.opt:2113 -#, fuzzy -#| msgid "Access data in the same section from shared anchor points" msgid "Access data in the same section from shared anchor points." -msgstr "Nå data i samma sektion från delade förankringspunkter" +msgstr "Nå data i samma sektion från delade förankringspunkter." #: common.opt:2125 msgid "Turn on Redundant Extensions Elimination pass." msgstr "Slå på passet för eliminering av redundanta utökningar." #: common.opt:2129 -#, fuzzy -#| msgid "Show column numbers in diagnostics, when available. Default on" msgid "Show column numbers in diagnostics, when available. Default on." -msgstr "Visa kolumnnummer i felmeddelanden, när de är tillgängliga. Normalt på" +msgstr "Visa kolumnnummer i felmeddelanden, när de är tillgängliga. Normalt på." #: common.opt:2133 msgid "Emit function prologues only before parts of the function that need it," msgstr "Mata ut funktionsprologer bara före delar av funktionen som behöver det," #: common.opt:2138 -#, fuzzy -#| msgid "Disable optimizations observable by IEEE signaling NaNs" msgid "Disable optimizations observable by IEEE signaling NaNs." -msgstr "Avaktivera optimeringar som kan observeras av IEEE signalerande NAN:ar" +msgstr "Avaktivera optimeringar som kan observeras av IEEE signalerande NAN:ar." #: common.opt:2142 -#, fuzzy -#| msgid "Disable floating point optimizations that ignore the IEEE signedness of zero" msgid "Disable floating point optimizations that ignore the IEEE signedness of zero." -msgstr "Avaktivera flyttalsoptimeringar som ignorera IEEE:s tecken på noll" +msgstr "Avaktivera flyttalsoptimeringar som ignorera IEEE:s tecken på noll." #: common.opt:2146 -#, fuzzy -#| msgid "Convert floating point constants to single precision constants" msgid "Convert floating point constants to single precision constants." -msgstr "Konvertera flyttalskonstanter till konstanter med enkel precision" +msgstr "Konvertera flyttalskonstanter till konstanter med enkel precision." #: common.opt:2150 -#, fuzzy -#| msgid "Split lifetimes of induction variables when loops are unrolled" msgid "Split lifetimes of induction variables when loops are unrolled." -msgstr "Dela livstiden på induktionsvariabler när slingor rullas ut" +msgstr "Dela livstiden på induktionsvariabler när slingor rullas ut." #: common.opt:2154 -#, fuzzy -#| msgid "Generate discontiguous stack frames" msgid "Generate discontiguous stack frames." -msgstr "Generera osammanhängande stackramar" +msgstr "Generera osammanhängande stackramar." #: common.opt:2158 -#, fuzzy -#| msgid "Split wide types into independent registers" msgid "Split wide types into independent registers." -msgstr "Dela upp breda typer i oberoende register" +msgstr "Dela upp breda typer i oberoende register." #: common.opt:2162 -#, fuzzy -#| msgid "Enable forward propagation on trees" msgid "Enable backward propagation of use properties at the SSA level." -msgstr "Aktivera framåtpropagering på träd" +msgstr "Aktivera bakåtpropagering av användningsegenskaper på SSA-nivån." #: common.opt:2166 -#, fuzzy -#| msgid "Optimize conditional patterns using SSA PHI nodes" msgid "Optimize conditional patterns using SSA PHI nodes." -msgstr "Optimera villkorliga mönster med SSA PHI-noder" +msgstr "Optimera villkorliga mönster med SSA PHI-noder." #: common.opt:2170 -#, fuzzy -#| msgid "Optimize amount of stdarg registers saved to stack at start of function" msgid "Optimize amount of stdarg registers saved to stack at start of function." -msgstr "Optimera mängden stdarg-register som sparas på stacken vid starten av en funktion" +msgstr "Optimera mängden stdarg-register som sparas på stacken vid starten av en funktion." #: common.opt:2174 -#, fuzzy -#| msgid "Apply variable expansion when loops are unrolled" msgid "Apply variable expansion when loops are unrolled." -msgstr "Tillämpa variabelexpansion när slingor rullas ut" +msgstr "Tillämpa variabelexpansion när slingor rullas ut." #: common.opt:2178 -#, fuzzy -#| msgid "-fstack-check=[no|generic|specific]\tInsert stack checking code into the program" msgid "-fstack-check=[no|generic|specific]\tInsert stack checking code into the program." -msgstr "-fstack-check=[no|generic|specific]\tLägg in stackkontrollkod i programmet" +msgstr "-fstack-check=[no|generic|specific]\tLägg in stackkontrollkod i programmet." #: common.opt:2182 -#, fuzzy -#| msgid "Insert stack checking code into the program. Same as -fstack-check=specific" msgid "Insert stack checking code into the program. Same as -fstack-check=specific." -msgstr "Lägg in stackkontrollkod i programmet. Samma som -fstack-check=specific" +msgstr "Lägg in stackkontrollkod i programmet. Samma som -fstack-check=specific." #: common.opt:2189 -#, fuzzy -#| msgid "-fstack-limit-register=\tTrap if the stack goes past " msgid "-fstack-limit-register=\tTrap if the stack goes past ." -msgstr "-fstack-limit-register=\tFånga om stacken går förbi " +msgstr "-fstack-limit-register=\tFånga om stacken går förbi ." #: common.opt:2193 -#, fuzzy -#| msgid "-fstack-limit-symbol=\tTrap if the stack goes past symbol " msgid "-fstack-limit-symbol=\tTrap if the stack goes past symbol ." -msgstr "-fstack-limit-symbol=\tFånga om stacken går förbi symbolen " +msgstr "-fstack-limit-symbol=\tFånga om stacken går förbi symbolen ." #: common.opt:2197 -#, fuzzy -#| msgid "Use propolice as a stack protection method" msgid "Use propolice as a stack protection method." -msgstr "Använd propolice som en metod att skydda stacken" +msgstr "Använd propolice som en metod att skydda stacken." #: common.opt:2201 -#, fuzzy -#| msgid "Use a stack protection method for every function" msgid "Use a stack protection method for every function." -msgstr "Använd en metod att skydda stacken för varje funktion" +msgstr "Använd en metod att skydda stacken för varje funktion." #: common.opt:2205 -#, fuzzy -#| msgid "Use a smart stack protection method for certain functions" msgid "Use a smart stack protection method for certain functions." -msgstr "Använd en smart metod att skydda stacken för vissa funktioner" +msgstr "Använd en smart metod att skydda stacken för vissa funktioner." #: common.opt:2209 -#, fuzzy -#| msgid "Use stack protection method only for functions with the stack_protect attribute" msgid "Use stack protection method only for functions with the stack_protect attribute." -msgstr "Använd en metod att skydda stacken endast för funktioner med attributet stack_protect" +msgstr "Använd en metod att skydda stacken endast för funktioner med attributet stack_protect." #: common.opt:2213 -#, fuzzy -#| msgid "Output stack usage information on a per-function basis" msgid "Output stack usage information on a per-function basis." -msgstr "Skriv ut information om stackanvändning för varje funktion" +msgstr "Skriv ut information om stackanvändning för varje funktion." #: common.opt:2225 -#, fuzzy -#| msgid "Assume strict aliasing rules apply" msgid "Assume strict aliasing rules apply." -msgstr "Anta att strikta aliasregler gäller" +msgstr "Anta att strikta aliasregler gäller." #: common.opt:2229 -#, fuzzy -#| msgid "Treat signed overflow as undefined" msgid "Treat signed overflow as undefined." -msgstr "Behandla spill med tecken som odefinierat" +msgstr "Behandla spill med tecken som odefinierat." #: common.opt:2233 -#, fuzzy -#| msgid "Implement __atomic operations via libcalls to legacy __sync functions" msgid "Implement __atomic operations via libcalls to legacy __sync functions." -msgstr "Implementera __atomic-operationer med biblioteksanrop till äldre __sync-funktioner" +msgstr "Implementera __atomic-operationer med biblioteksanrop till äldre __sync-funktioner." #: common.opt:2237 -#, fuzzy -#| msgid "Check for syntax errors, then stop" msgid "Check for syntax errors, then stop." -msgstr "Leta efter syntaxfel, stoppa sedan" +msgstr "Leta efter syntaxfel, stoppa sedan." #: common.opt:2241 -#, fuzzy -#| msgid "Create data files needed by \"gcov\"" msgid "Create data files needed by \"gcov\"." -msgstr "Skapa datafiler som behövs av ”gcov”" +msgstr "Skapa datafiler som behövs av ”gcov”." #: common.opt:2245 -#, fuzzy -#| msgid "Perform jump threading optimizations" msgid "Perform jump threading optimizations." -msgstr "Utför hopptrådningsoptimeringar" +msgstr "Utför hopptrådningsoptimeringar." #: common.opt:2249 -#, fuzzy -#| msgid "Report the time taken by each compiler pass" msgid "Report the time taken by each compiler pass." -msgstr "Rapportera tiden som går åt för varje kompilatorpass" +msgstr "Rapportera tiden som går åt för varje kompilatorpass." #: common.opt:2253 -#, fuzzy -#| msgid "-ftls-model=[global-dynamic|local-dynamic|initial-exec|local-exec]\tSet the default thread-local storage code generation model" msgid "-ftls-model=[global-dynamic|local-dynamic|initial-exec|local-exec]\tSet the default thread-local storage code generation model." -msgstr "-ftls-model=[global-dynamic|local-dynamic|initial-exec|local-exec]\tAnge normal kodgenereringsmodell för trådlokal lagring" +msgstr "-ftls-model=[global-dynamic|local-dynamic|initial-exec|local-exec]\tAnge normal kodgenereringsmodell för trådlokal lagring." #: common.opt:2256 #, c-format @@ -18278,46 +14444,32 @@ msgid "unknown TLS model %qs" msgstr "okänd TLS-modell %qs" #: common.opt:2272 -#, fuzzy -#| msgid "Reorder top level functions, variables, and asms" msgid "Reorder top level functions, variables, and asms." -msgstr "Ordna om toppnivåfunktioner, variabler och asm:ar" +msgstr "Ordna om toppnivåfunktioner, variabler och asm:ar." #: common.opt:2276 -#, fuzzy -#| msgid "Perform superblock formation via tail duplication" msgid "Perform superblock formation via tail duplication." -msgstr "Utför superblockformering via svansduplicering" +msgstr "Utför superblockformering via svansduplicering." #: common.opt:2283 -#, fuzzy -#| msgid "Assume floating-point operations can trap" msgid "Assume floating-point operations can trap." -msgstr "Anta att flyttalsoperationer kan utlösa fällor" +msgstr "Anta att flyttalsoperationer kan utlösa fällor." #: common.opt:2287 -#, fuzzy -#| msgid "Trap for signed overflow in addition, subtraction and multiplication" msgid "Trap for signed overflow in addition, subtraction and multiplication." -msgstr "Fånga teckenspill i addition, subtraktion och multiplikation" +msgstr "Fånga teckenspill i addition, subtraktion och multiplikation." #: common.opt:2291 -#, fuzzy -#| msgid "Enable SSA-CCP optimization on trees" msgid "Enable SSA-CCP optimization on trees." -msgstr "Aktivera SSA-CCP-optimering av träd" +msgstr "Aktivera SSA-CCP-optimering av träd." #: common.opt:2295 -#, fuzzy -#| msgid "Enable SSA-BIT-CCP optimization on trees" msgid "Enable SSA-BIT-CCP optimization on trees." -msgstr "Aktivera SSA-BIT-CCP-optimering av träd" +msgstr "Aktivera SSA-BIT-CCP-optimering av träd." #: common.opt:2303 -#, fuzzy -#| msgid "Enable loop header copying on trees" msgid "Enable loop header copying on trees." -msgstr "Aktivera slinghuvudkopiering av träd" +msgstr "Aktivera slinghuvudkopiering av träd." #: common.opt:2311 #, fuzzy @@ -18326,62 +14478,44 @@ msgid "Enable SSA coalescing of user variables." msgstr "Aktivera sammanläggning av alla kopierelaterade användarvariabler" #: common.opt:2319 -#, fuzzy -#| msgid "Enable copy propagation on trees" msgid "Enable copy propagation on trees." -msgstr "Aktivera kopiepropagering i träd" +msgstr "Aktivera kopiepropagering i träd." #: common.opt:2327 -#, fuzzy -#| msgid "Transform condition stores into unconditional ones" msgid "Transform condition stores into unconditional ones." -msgstr "Transformera villkorliga lagringar till ovillkorliga" +msgstr "Transformera villkorliga lagringar till ovillkorliga." #: common.opt:2331 msgid "Perform conversions of switch initializations." msgstr "Utför konvertering av switch-initieringar." #: common.opt:2335 -#, fuzzy -#| msgid "Enable SSA dead code elimination optimization on trees" msgid "Enable SSA dead code elimination optimization on trees." -msgstr "Aktivera eliminering av död kod i SSA-optimeringen i träd" +msgstr "Aktivera eliminering av död kod i SSA-optimeringen i träd." #: common.opt:2339 -#, fuzzy -#| msgid "Enable dominator optimizations" msgid "Enable dominator optimizations." -msgstr "Aktivera dominatoroptimeringar" +msgstr "Aktivera dominatoroptimeringar." #: common.opt:2343 -#, fuzzy -#| msgid "Enable tail merging on trees" msgid "Enable tail merging on trees." -msgstr "Aktivera svanssammanslagning av träd" +msgstr "Aktivera svanssammanslagning av träd." #: common.opt:2347 -#, fuzzy -#| msgid "Enable dead store elimination" msgid "Enable dead store elimination." -msgstr "Aktivera eliminering av död lagring" +msgstr "Aktivera eliminering av död lagring." #: common.opt:2351 -#, fuzzy -#| msgid "Enable forward propagation on trees" msgid "Enable forward propagation on trees." -msgstr "Aktivera framåtpropagering på träd" +msgstr "Aktivera framåtpropagering på träd." #: common.opt:2355 -#, fuzzy -#| msgid "Enable Full Redundancy Elimination (FRE) on trees" msgid "Enable Full Redundancy Elimination (FRE) on trees." -msgstr "Aktivera fullständig överflödseliminering (FRE) i träd" +msgstr "Aktivera fullständig överflödseliminering (FRE) i träd." #: common.opt:2359 -#, fuzzy -#| msgid "Enable string length optimizations on trees" msgid "Enable string length optimizations on trees." -msgstr "Aktivera stränglängdsoptimering av träd" +msgstr "Aktivera stränglängdsoptimering av träd." #: common.opt:2363 msgid "Detect paths that trigger erroneous or undefined behavior due to" @@ -18392,130 +14526,92 @@ msgid "Detect paths that trigger erroneous or undefined behavior due a null valu msgstr "Detektera vägar som orsakar felaktigt eller odefinierat beteende på grund av ett null-värde" #: common.opt:2376 -#, fuzzy -#| msgid "Enable loop distribution on trees" msgid "Enable loop distribution on trees." -msgstr "Aktivera slingdistribution i träd" +msgstr "Aktivera slingdistribution i träd." #: common.opt:2380 -#, fuzzy -#| msgid "Enable loop distribution for patterns transformed into a library call" msgid "Enable loop distribution for patterns transformed into a library call." -msgstr "Aktivera slingdistribution för mönster transformerade till biblioteksanrop" +msgstr "Aktivera slingdistribution för mönster transformerade till biblioteksanrop." #: common.opt:2384 -#, fuzzy -#| msgid "Enable loop invariant motion on trees" msgid "Enable loop invariant motion on trees." -msgstr "Aktivera förflyttning av slingoberoende delar i träd" +msgstr "Aktivera förflyttning av slingoberoende delar i träd." #: common.opt:2392 -#, fuzzy -#| msgid "Create canonical induction variables in loops" msgid "Create canonical induction variables in loops." -msgstr "Skapa kanoniska induktionsvariabler i slingor" +msgstr "Skapa kanoniska induktionsvariabler i slingor." #: common.opt:2396 -#, fuzzy -#| msgid "Enable loop optimizations on tree level" msgid "Enable loop optimizations on tree level." -msgstr "Aktivera slingoptimeringar på trädnivå" +msgstr "Aktivera slingoptimeringar på trädnivå." #: common.opt:2400 -#, fuzzy -#| msgid "Enable automatic parallelization of loops" msgid "Enable automatic parallelization of loops." -msgstr "Aktivera automatisk parallellisering av slingor" +msgstr "Aktivera automatisk parallellisering av slingor." #: common.opt:2404 msgid "Enable hoisting loads from conditional pointers." -msgstr "Aktivera lyftningslast från villkorliga pekare." +msgstr "Aktivera lyftningsladdning från villkorliga pekare." #: common.opt:2408 -#, fuzzy -#| msgid "Enable SSA-PRE optimization on trees" msgid "Enable SSA-PRE optimization on trees." -msgstr "Aktivera SSA-PRE-optimeringar i träd" +msgstr "Aktivera SSA-PRE-optimeringar i träd." #: common.opt:2412 -#, fuzzy -#| msgid "In SSA-PRE optimization on trees, enable partial-partial redundancy elimination" msgid "In SSA-PRE optimization on trees, enable partial-partial redundancy elimination." -msgstr "I SSA-PRE-optimering på träd, aktivera eliminering av partiell-partiell redundans" +msgstr "I SSA-PRE-optimering på träd, aktivera eliminering av partiell-partiell redundans." #: common.opt:2416 msgid "Perform function-local points-to analysis on trees." msgstr "Utför funktionslokala pekar-på-analyser i träd" #: common.opt:2420 -#, fuzzy -#| msgid "Enable reassociation on tree level" msgid "Enable reassociation on tree level." -msgstr "Aktivera återassociering på trädnivå" +msgstr "Aktivera återassociering på trädnivå." #: common.opt:2428 -#, fuzzy -#| msgid "Enable SSA code sinking on trees" msgid "Enable SSA code sinking on trees." -msgstr "Aktivera SSA-kodsänkning i träd" +msgstr "Aktivera SSA-kodsänkning i träd." #: common.opt:2432 -#, fuzzy -#| msgid "Perform straight-line strength reduction" msgid "Perform straight-line strength reduction." -msgstr "Utför rätlinjig styrkereduktion" +msgstr "Utför rätlinjig styrkereduktion." #: common.opt:2436 -#, fuzzy -#| msgid "Perform scalar replacement of aggregates" msgid "Perform scalar replacement of aggregates." -msgstr "Utför skalärersättning av aggregat" +msgstr "Utför skalärersättning av aggregat." #: common.opt:2440 -#, fuzzy -#| msgid "Replace temporary expressions in the SSA->normal pass" msgid "Replace temporary expressions in the SSA->normal pass." -msgstr "Ersätt tillfälliga uttryck i passet SSA->normal" +msgstr "Ersätt tillfälliga uttryck i passet SSA->normal." #: common.opt:2444 -#, fuzzy -#| msgid "Perform live range splitting during the SSA->normal pass" msgid "Perform live range splitting during the SSA->normal pass." -msgstr "Utför livstidsuppdelning under passet SSA->normal" +msgstr "Utför livstidsuppdelning under passet SSA->normal." #: common.opt:2448 -#, fuzzy -#| msgid "Perform Value Range Propagation on trees" msgid "Perform Value Range Propagation on trees." -msgstr "Utför propagering av värdeintervall i träd" +msgstr "Utför propagering av värdeintervall i träd." #: common.opt:2452 msgid "Split paths leading to loop backedges." msgstr "Dela sökvägar som leder till bakåtbågar i slingor." #: common.opt:2456 -#, fuzzy -#| msgid "Compile whole compilation unit at a time" msgid "Compile whole compilation unit at a time." -msgstr "Kompilera en hel kompileringsenhet åt gången" +msgstr "Kompilera en hel kompileringsenhet åt gången." #: common.opt:2460 -#, fuzzy -#| msgid "Perform loop unrolling when iteration count is known" msgid "Perform loop unrolling when iteration count is known." -msgstr "Utför slingutrullning när iterationsantalet är känt" +msgstr "Utför slingutrullning när iterationsantalet är känt." #: common.opt:2464 -#, fuzzy -#| msgid "Perform loop unrolling for all loops" msgid "Perform loop unrolling for all loops." -msgstr "Utför slingutrullning för alla slingor" +msgstr "Utför slingutrullning för alla slingor." #: common.opt:2471 -#, fuzzy -#| msgid "Allow loop optimizations to assume that the loops behave in normal way" msgid "Allow loop optimizations to assume that the loops behave in normal way." -msgstr "Tillåt slingoptimeringar att anta att slingorna beter sig normalt" +msgstr "Tillåt slingoptimeringar att anta att slingorna beter sig normalt." # Avhugget p.g.a. http://gcc.gnu.org/bugzilla/show_bug.cgi?id=34352 # Hela meddelandet är översatt @@ -18528,88 +14624,60 @@ msgid "Same as -fassociative-math for expressions which include division." msgstr "Samma som -fassociative-math för uttryck som inkluderar division." #: common.opt:2488 -#, fuzzy -#| msgid "Allow math optimizations that may violate IEEE or ISO standards" msgid "Allow math optimizations that may violate IEEE or ISO standards." -msgstr "Tillåt matematikoptimeringar som kan strida mot IEEE- eller ISO-standarder" +msgstr "Tillåt matematikoptimeringar som kan strida mot IEEE- eller ISO-standarder." #: common.opt:2492 -#, fuzzy -#| msgid "Perform loop unswitching" msgid "Perform loop unswitching." -msgstr "Utför slingavväxling" +msgstr "Utför slingavväxling." #: common.opt:2496 -#, fuzzy -#| msgid "Just generate unwind tables for exception handling" msgid "Just generate unwind tables for exception handling." -msgstr "Generera bara upprullningstabeller för undantagshantering" +msgstr "Generera bara upprullningstabeller för undantagshantering." #: common.opt:2500 -#, fuzzy -#| msgid "Use the bfd linker instead of the default linker" msgid "Use the bfd linker instead of the default linker." -msgstr "Använd bfd-länkaren istället för standardlänkaren" +msgstr "Använd bfd-länkaren istället för standardlänkaren." #: common.opt:2504 -#, fuzzy -#| msgid "Use the gold linker instead of the default linker" msgid "Use the gold linker instead of the default linker." -msgstr "Använd gold-länkaren istället för standardlänkaren" +msgstr "Använd gold-länkaren istället för standardlänkaren." #: common.opt:2516 -#, fuzzy -#| msgid "Perform variable tracking" msgid "Perform variable tracking." -msgstr "Utför variabelspårning" +msgstr "Utför variabelspårning." #: common.opt:2524 -#, fuzzy -#| msgid "Perform variable tracking by annotating assignments" msgid "Perform variable tracking by annotating assignments." -msgstr "Utför variabelspårning genom att annotera tilldelningar" +msgstr "Utför variabelspårning genom att annotera tilldelningar." #: common.opt:2530 -#, fuzzy -#| msgid "Toggle -fvar-tracking-assignments" msgid "Toggle -fvar-tracking-assignments." -msgstr "Växla -fvar-tracking-assignments" +msgstr "Växla -fvar-tracking-assignments." #: common.opt:2538 -#, fuzzy -#| msgid "Perform variable tracking and also tag variables that are uninitialized" msgid "Perform variable tracking and also tag variables that are uninitialized." -msgstr "Utför variabelspårning och tagga också variabler som är oinitierade" +msgstr "Utför variabelspårning och tagga också variabler som är oinitierade." #: common.opt:2542 -#, fuzzy -#| msgid "Enable vectorization on trees" msgid "Enable vectorization on trees." -msgstr "Aktivera vektorisering av träd" +msgstr "Aktivera vektorisering av träd." #: common.opt:2550 -#, fuzzy -#| msgid "Enable loop vectorization on trees" msgid "Enable loop vectorization on trees." -msgstr "Aktivera slingvektorisering i träd" +msgstr "Aktivera slingvektorisering i träd." #: common.opt:2554 -#, fuzzy -#| msgid "Enable basic block vectorization (SLP) on trees" msgid "Enable basic block vectorization (SLP) on trees." -msgstr "Aktivera grundblocksvektorisering (SLP) i träd" +msgstr "Aktivera grundblocksvektorisering (SLP) i träd." #: common.opt:2558 -#, fuzzy -#| msgid "Specifies the cost model for vectorization" msgid "Specifies the cost model for vectorization." -msgstr "Anger kostnadsmodellen för vektorisering" +msgstr "Anger kostnadsmodellen för vektorisering." #: common.opt:2562 -#, fuzzy -#| msgid "Specifies the vectorization cost model for code marked with a simd directive" msgid "Specifies the vectorization cost model for code marked with a simd directive." -msgstr "Anger kostnadsmodellen för vektorisering för kod markerad med ett simd-direktiv" +msgstr "Anger kostnadsmodellen för vektorisering för kod markerad med ett simd-direktiv." #: common.opt:2565 #, c-format @@ -18629,16 +14697,12 @@ msgid "Enable copy propagation of scalar-evolution information." msgstr "Aktivera kopiepropagering av skalärutvecklingsinformation." #: common.opt:2600 -#, fuzzy -#| msgid "Add extra commentary to assembler output" msgid "Add extra commentary to assembler output." -msgstr "Lägg till extra kommentarer till assemblerutdata" +msgstr "Lägg till extra kommentarer till assemblerutdata." #: common.opt:2604 -#, fuzzy -#| msgid "-fvisibility=[default|internal|hidden|protected]\tSet the default symbol visibility" msgid "-fvisibility=[default|internal|hidden|protected]\tSet the default symbol visibility." -msgstr "-fvisibility=[default|internal|hidden|protected]\tAnge standardvärde för symbolsynlighet" +msgstr "-fvisibility=[default|internal|hidden|protected]\tAnge standardvärde för symbolsynlighet." #: common.opt:2607 #, c-format @@ -18663,70 +14727,48 @@ msgid "Output vtable verification pointer sets information." msgstr "Mata ut information om verifieringspekaruppsättningar för vtable." #: common.opt:2647 -#, fuzzy -#| msgid "Use expression value profiles in optimizations" msgid "Use expression value profiles in optimizations." -msgstr "Använd uttrycksvärdeprofiler i optimeringar" +msgstr "Använd uttrycksvärdeprofiler i optimeringar." #: common.opt:2651 -#, fuzzy -#| msgid "Construct webs and split unrelated uses of single variable" msgid "Construct webs and split unrelated uses of single variable." -msgstr "Konstruera nät och dela orelaterade användningar av en enskild variabel" +msgstr "Konstruera nät och dela orelaterade användningar av en enskild variabel." #: common.opt:2655 -#, fuzzy -#| msgid "Enable conditional dead code elimination for builtin calls" msgid "Enable conditional dead code elimination for builtin calls." -msgstr "Aktivera villkorlig eliminering av död för inbyggda anrop" +msgstr "Aktivera villkorlig eliminering av död för inbyggda anrop." #: common.opt:2659 -#, fuzzy -#| msgid "Perform whole program optimizations" msgid "Perform whole program optimizations." -msgstr "Utför optimering av hela program" +msgstr "Utför optimering av hela program." #: common.opt:2663 -#, fuzzy -#| msgid "Assume signed arithmetic overflow wraps around" msgid "Assume signed arithmetic overflow wraps around." -msgstr "Anta att spill vid teckenaritmetik slår runt" +msgstr "Anta att spill vid teckenaritmetik slår runt." #: common.opt:2667 -#, fuzzy -#| msgid "Put zero initialized data in the bss section" msgid "Put zero initialized data in the bss section." -msgstr "Lägg nollinitierad data i bss-sektionen" +msgstr "Lägg nollinitierad data i bss-sektionen." #: common.opt:2671 -#, fuzzy -#| msgid "Generate debug information in default format" msgid "Generate debug information in default format." -msgstr "Generera felsökningsinformation i standardformat" +msgstr "Generera felsökningsinformation i standardformat." #: common.opt:2675 -#, fuzzy -#| msgid "Generate debug information in COFF format" msgid "Generate debug information in COFF format." -msgstr "Generera felsökningsinformation i COFF-format" +msgstr "Generera felsökningsinformation i COFF-format." #: common.opt:2679 -#, fuzzy -#| msgid "Generate debug information in default version of DWARF format" msgid "Generate debug information in default version of DWARF format." -msgstr "Generera felsökningsinformation i standardversion av DWARF-formatet" +msgstr "Generera felsökningsinformation i standardversion av DWARF-formatet." #: common.opt:2683 -#, fuzzy -#| msgid "Generate debug information in DWARF v2 (or later) format" msgid "Generate debug information in DWARF v2 (or later) format." -msgstr "Generera felsökningsinformation i DWARF v2-format (eller senare)" +msgstr "Generera felsökningsinformation i DWARF v2-format (eller senare)." #: common.opt:2687 -#, fuzzy -#| msgid "Generate debug information in default extended format" msgid "Generate debug information in default extended format." -msgstr "Generera felsökningsinformation i normalt utökat format" +msgstr "Generera felsökningsinformation i normalt utökat format." #: common.opt:2691 msgid "Don't generate DWARF pubnames and pubtypes sections." @@ -18749,136 +14791,92 @@ msgid "Record gcc command line switches in DWARF DW_AT_producer." msgstr "Notera gcc:s kommandoradsflaggor i DWARF DW_AT_producer." #: common.opt:2711 -#, fuzzy -#| msgid "Don't generate debug information in separate .dwo files" msgid "Don't generate debug information in separate .dwo files." -msgstr "Generera inte felsökningsinformation i separata .dwo-filer" +msgstr "Generera inte felsökningsinformation i separata .dwo-filer." #: common.opt:2715 -#, fuzzy -#| msgid "Generate debug information in separate .dwo files" msgid "Generate debug information in separate .dwo files." -msgstr "Generera felsökningsinformation i separata .dwo-filer" +msgstr "Generera felsökningsinformation i separata .dwo-filer." #: common.opt:2719 -#, fuzzy -#| msgid "Generate debug information in STABS format" msgid "Generate debug information in STABS format." -msgstr "Generera felsökningsinformation i STABS-format" +msgstr "Generera felsökningsinformation i STABS-format." #: common.opt:2723 -#, fuzzy -#| msgid "Generate debug information in extended STABS format" msgid "Generate debug information in extended STABS format." -msgstr "Generera felsökningsinformation i utökat STABS-format" +msgstr "Generera felsökningsinformation i utökat STABS-format." #: common.opt:2727 -#, fuzzy -#| msgid "Emit DWARF additions beyond selected version" msgid "Emit DWARF additions beyond selected version." -msgstr "Mata ut DWARF-tillägg utöver vald version" +msgstr "Mata ut DWARF-tillägg utöver vald version." #: common.opt:2731 -#, fuzzy -#| msgid "Don't emit DWARF additions beyond selected version" msgid "Don't emit DWARF additions beyond selected version." -msgstr "Mata inte ut DWARF-tillägg utöver vald version" +msgstr "Mata inte ut DWARF-tillägg utöver vald version." #: common.opt:2735 -#, fuzzy -#| msgid "Toggle debug information generation" msgid "Toggle debug information generation." -msgstr "Växla generering av felsökningsinformation" +msgstr "Växla generering av felsökningsinformation." #: common.opt:2739 -#, fuzzy -#| msgid "Generate debug information in VMS format" msgid "Generate debug information in VMS format." -msgstr "Generera felsökningsinformation i VMS-format" +msgstr "Generera felsökningsinformation i VMS-format." #: common.opt:2743 -#, fuzzy -#| msgid "Generate debug information in XCOFF format" msgid "Generate debug information in XCOFF format." -msgstr "Generera felsökningsinformation i XCOFF-format" +msgstr "Generera felsökningsinformation i XCOFF-format." #: common.opt:2747 -#, fuzzy -#| msgid "Generate debug information in extended XCOFF format" msgid "Generate debug information in extended XCOFF format." -msgstr "Generera felsökningsinformation i utökat XCOFF-format" +msgstr "Generera felsökningsinformation i utökat XCOFF-format." #: common.opt:2765 -#, fuzzy -#| msgid "Generate compressed debug sections" msgid "Generate compressed debug sections." -msgstr "Generera komprimerade felsökningssektioner" +msgstr "Generera komprimerade felsökningssektioner." #: common.opt:2769 -#, fuzzy -#| msgid "-gz=\tGenerate compressed debug sections in format " msgid "-gz=\tGenerate compressed debug sections in format ." -msgstr "-gz=\tGenerera komprimerade felsökningssektioner i formatet " +msgstr "-gz=\tGenerera komprimerade felsökningssektioner i formatet ." #: common.opt:2776 -#, fuzzy -#| msgid "-iplugindir=\tSet to be the default plugin directory" msgid "-iplugindir=\tSet to be the default plugin directory." -msgstr "-iplugindir=\tSätt att vara standardbibliotek för insticksmoduler" +msgstr "-iplugindir=\tSätt att vara standardbibliotek för insticksmoduler." #: common.opt:2780 -#, fuzzy -#| msgid "-imultiarch \tSet to be the multiarch include subdirectory" msgid "-imultiarch \tSet to be the multiarch include subdirectory." -msgstr "-imultiarch \tSätt att vara inkluderingsunderbiblioteket för multiarkitekturer" +msgstr "-imultiarch \tSätt att vara inkluderingsunderbiblioteket för multiarkitekturer." #: common.opt:2802 -#, fuzzy -#| msgid "-o \tPlace output into " msgid "-o \tPlace output into ." -msgstr "-o \tSkriv utdata i " +msgstr "-o \tSkriv utdata i ." #: common.opt:2806 -#, fuzzy -#| msgid "Enable function profiling" msgid "Enable function profiling." -msgstr "Aktivera funktionsprofilering" +msgstr "Aktivera funktionsprofilering." #: common.opt:2816 -#, fuzzy -#| msgid "Like -pedantic but issue them as errors" msgid "Like -pedantic but issue them as errors." -msgstr "Som -pedantic men ange dem som fel" +msgstr "Som -pedantic men ange dem som fel." #: common.opt:2856 -#, fuzzy -#| msgid "Do not display functions compiled or elapsed time" msgid "Do not display functions compiled or elapsed time." -msgstr "Visa inte kompilerade funktioner eller tiden som förbrukats" +msgstr "Visa inte kompilerade funktioner eller tiden som förbrukats." #: common.opt:2888 -#, fuzzy -#| msgid "Enable verbose output" msgid "Enable verbose output." -msgstr "Aktivera utförlig utskrift" +msgstr "Aktivera utförlig utskrift." #: common.opt:2892 -#, fuzzy -#| msgid "Display the compiler's version" msgid "Display the compiler's version." -msgstr "Visa kompilatorns version" +msgstr "Visa kompilatorns version." #: common.opt:2896 -#, fuzzy -#| msgid "Suppress warnings" msgid "Suppress warnings." -msgstr "Undertryck varningar" +msgstr "Undertryck varningar." #: common.opt:2906 -#, fuzzy -#| msgid "Create a shared library" msgid "Create a shared library." -msgstr "Skapa ett delat bibliotek" +msgstr "Skapa ett delat bibliotek." #: common.opt:2951 #, fuzzy @@ -18887,16 +14885,12 @@ msgid "Don't create a position independent executable." msgstr "Skapa ett positionsoberoende körbart program" #: common.opt:2955 -#, fuzzy -#| msgid "Create a position independent executable" msgid "Create a position independent executable." -msgstr "Skapa ett positionsoberoende körbart program" +msgstr "Skapa ett positionsoberoende körbart program." #: common.opt:2962 -#, fuzzy -#| msgid "Use caller save register across calls if possible" msgid "Use caller save register across calls if possible." -msgstr "Använd anroparens sparregister mellan anrop om möjligt" +msgstr "Använd anroparens sparregister mellan anrop om möjligt." #: go/gofrontend/expressions.cc:93 c-family/c-common.c:1524 cp/cvt.c:1174 #: cp/cvt.c:1423 @@ -19415,7 +15409,7 @@ msgstr "Det går inte arbetsmängden från %s." #: bt-load.c:1566 #, gcc-internal-format msgid "branch target register load optimization is not intended to be run twice" -msgstr "optimeringen av lastning av grenmålsregister är inte avsedd att köras två gånger" +msgstr "optimeringen av laddning av grenmålsregister är inte avsedd att köras två gånger" #: builtins.c:604 #, gcc-internal-format diff --git a/gcc/postreload.c b/gcc/postreload.c index 66f691b88d94..61c1ce8028e3 100644 --- a/gcc/postreload.c +++ b/gcc/postreload.c @@ -1057,7 +1057,6 @@ static bool reload_combine_recognize_pattern (rtx_insn *insn) { rtx set, reg, src; - unsigned int regno; set = single_set (insn); if (set == NULL_RTX) @@ -1068,7 +1067,20 @@ reload_combine_recognize_pattern (rtx_insn *insn) if (!REG_P (reg) || REG_NREGS (reg) != 1) return false; - regno = REGNO (reg); + unsigned int regno = REGNO (reg); + machine_mode mode = GET_MODE (reg); + + if (reg_state[regno].use_index < 0 + || reg_state[regno].use_index >= RELOAD_COMBINE_MAX_USES) + return false; + + for (int i = reg_state[regno].use_index; + i < RELOAD_COMBINE_MAX_USES; i++) + { + struct reg_use *use = reg_state[regno].reg_use + i; + if (GET_MODE (*use->usep) != mode) + return false; + } /* Look for (set (REGX) (CONST_INT)) (set (REGX) (PLUS (REGX) (REGY))) @@ -1090,8 +1102,6 @@ reload_combine_recognize_pattern (rtx_insn *insn) && REG_P (XEXP (src, 1)) && rtx_equal_p (XEXP (src, 0), reg) && !rtx_equal_p (XEXP (src, 1), reg) - && reg_state[regno].use_index >= 0 - && reg_state[regno].use_index < RELOAD_COMBINE_MAX_USES && last_label_ruid < reg_state[regno].use_ruid) { rtx base = XEXP (src, 1); diff --git a/gcc/reload1.c b/gcc/reload1.c index 2229fd32a4a5..c2800f8cb790 100644 --- a/gcc/reload1.c +++ b/gcc/reload1.c @@ -1258,28 +1258,6 @@ reload (rtx_insn *first, int global) } } - /* If we are doing generic stack checking, give a warning if this - function's frame size is larger than we expect. */ - if (flag_stack_check == GENERIC_STACK_CHECK) - { - HOST_WIDE_INT size = get_frame_size () + STACK_CHECK_FIXED_FRAME_SIZE; - static int verbose_warned = 0; - - for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) - if (df_regs_ever_live_p (i) && ! fixed_regs[i] && call_used_regs[i]) - size += UNITS_PER_WORD; - - if (size > STACK_CHECK_MAX_FRAME_SIZE) - { - warning (0, "frame size too large for reliable stack checking"); - if (! verbose_warned) - { - warning (0, "try reducing the number of local variables"); - verbose_warned = 1; - } - } - } - free (temp_pseudo_reg_arr); /* Indicate that we no longer have known memory locations or constants. */ @@ -7417,7 +7395,9 @@ emit_input_reload_insns (struct insn_chain *chain, struct reload *rl, /* Adjust any debug insns between temp and insn. */ while ((temp = NEXT_INSN (temp)) != insn) if (DEBUG_INSN_P (temp)) - replace_rtx (PATTERN (temp), old, reloadreg); + INSN_VAR_LOCATION_LOC (temp) + = simplify_replace_rtx (INSN_VAR_LOCATION_LOC (temp), + old, reloadreg); else gcc_assert (NOTE_P (temp)); } diff --git a/gcc/reorg.c b/gcc/reorg.c index a02141f47e75..7b28821c99f1 100644 --- a/gcc/reorg.c +++ b/gcc/reorg.c @@ -3307,7 +3307,7 @@ relax_delay_slots (rtx_insn *first) reorg_redirect_jump (delay_jump_insn, trial); target_label = trial; if (crossing) - CROSSING_JUMP_P (insn) = 1; + CROSSING_JUMP_P (delay_jump_insn) = 1; } /* If the first insn at TARGET_LABEL is redundant with a previous diff --git a/gcc/rtl.h b/gcc/rtl.h index c91d60d3c908..7f0bfa443a02 100644 --- a/gcc/rtl.h +++ b/gcc/rtl.h @@ -3011,7 +3011,7 @@ extern bool can_nonlocal_goto (const rtx_insn *); extern void copy_reg_eh_region_note_forward (rtx, rtx_insn *, rtx); extern void copy_reg_eh_region_note_backward (rtx, rtx_insn *, rtx); extern int inequality_comparisons_p (const_rtx); -extern rtx replace_rtx (rtx, rtx, rtx); +extern rtx replace_rtx (rtx, rtx, rtx, bool = false); extern void replace_label (rtx *, rtx, rtx, bool); extern void replace_label_in_insn (rtx_insn *, rtx, rtx, bool); extern bool rtx_referenced_p (const_rtx, const_rtx); diff --git a/gcc/rtlanal.c b/gcc/rtlanal.c index 642611fa91ab..b4dff86c0e9a 100644 --- a/gcc/rtlanal.c +++ b/gcc/rtlanal.c @@ -2946,10 +2946,13 @@ inequality_comparisons_p (const_rtx x) not enter into CONST_DOUBLE for the replace. Note that copying is not done so X must not be shared unless all copies - are to be modified. */ + are to be modified. + + ALL_REGS is true if we want to replace all REGs equal to FROM, not just + those pointer-equal ones. */ rtx -replace_rtx (rtx x, rtx from, rtx to) +replace_rtx (rtx x, rtx from, rtx to, bool all_regs) { int i, j; const char *fmt; @@ -2961,9 +2964,17 @@ replace_rtx (rtx x, rtx from, rtx to) if (x == 0) return 0; - if (GET_CODE (x) == SUBREG) + if (all_regs + && REG_P (x) + && REG_P (from) + && REGNO (x) == REGNO (from)) + { + gcc_assert (GET_MODE (x) == GET_MODE (from)); + return to; + } + else if (GET_CODE (x) == SUBREG) { - rtx new_rtx = replace_rtx (SUBREG_REG (x), from, to); + rtx new_rtx = replace_rtx (SUBREG_REG (x), from, to, all_regs); if (CONST_INT_P (new_rtx)) { @@ -2979,7 +2990,7 @@ replace_rtx (rtx x, rtx from, rtx to) } else if (GET_CODE (x) == ZERO_EXTEND) { - rtx new_rtx = replace_rtx (XEXP (x, 0), from, to); + rtx new_rtx = replace_rtx (XEXP (x, 0), from, to, all_regs); if (CONST_INT_P (new_rtx)) { @@ -2997,10 +3008,11 @@ replace_rtx (rtx x, rtx from, rtx to) for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--) { if (fmt[i] == 'e') - XEXP (x, i) = replace_rtx (XEXP (x, i), from, to); + XEXP (x, i) = replace_rtx (XEXP (x, i), from, to, all_regs); else if (fmt[i] == 'E') for (j = XVECLEN (x, i) - 1; j >= 0; j--) - XVECEXP (x, i, j) = replace_rtx (XVECEXP (x, i, j), from, to); + XVECEXP (x, i, j) = replace_rtx (XVECEXP (x, i, j), + from, to, all_regs); } return x; @@ -3358,7 +3370,7 @@ commutative_operand_precedence (rtx op) if (code == CONST_INT) return -8; if (code == CONST_WIDE_INT) - return -8; + return -7; if (code == CONST_DOUBLE) return -7; if (code == CONST_FIXED) diff --git a/gcc/sched-deps.c b/gcc/sched-deps.c index 4961dfb3d7e9..8f3a124a8fad 100644 --- a/gcc/sched-deps.c +++ b/gcc/sched-deps.c @@ -2860,6 +2860,17 @@ sched_macro_fuse_insns (rtx_insn *insn) } +/* Get the implicit reg pending clobbers for INSN and save them in TEMP. */ +void +get_implicit_reg_pending_clobbers (HARD_REG_SET *temp, rtx_insn *insn) +{ + extract_insn (insn); + preprocess_constraints (insn); + alternative_mask preferred = get_preferred_alternatives (insn); + ira_implicitly_set_insn_hard_regs (temp, preferred); + AND_COMPL_HARD_REG_SET (*temp, ira_no_alloc_regs); +} + /* Analyze an INSN with pattern X to find all dependencies. */ static void sched_analyze_insn (struct deps_desc *deps, rtx x, rtx_insn *insn) @@ -2872,12 +2883,7 @@ sched_analyze_insn (struct deps_desc *deps, rtx x, rtx_insn *insn) if (! reload_completed) { HARD_REG_SET temp; - - extract_insn (insn); - preprocess_constraints (insn); - alternative_mask prefrred = get_preferred_alternatives (insn); - ira_implicitly_set_insn_hard_regs (&temp, prefrred); - AND_COMPL_HARD_REG_SET (temp, ira_no_alloc_regs); + get_implicit_reg_pending_clobbers (&temp, insn); IOR_HARD_REG_SET (implicit_reg_pending_clobbers, temp); } @@ -3489,7 +3495,8 @@ sched_analyze_insn (struct deps_desc *deps, rtx x, rtx_insn *insn) { if (deps->last_args_size) add_dependence (insn, deps->last_args_size, REG_DEP_OUTPUT); - deps->last_args_size = insn; + if (!deps->readonly) + deps->last_args_size = insn; } } diff --git a/gcc/sched-int.h b/gcc/sched-int.h index 2a457033306f..de5d32692663 100644 --- a/gcc/sched-int.h +++ b/gcc/sched-int.h @@ -1351,6 +1351,7 @@ extern void finish_deps_global (void); extern void deps_analyze_insn (struct deps_desc *, rtx_insn *); extern void remove_from_deps (struct deps_desc *, rtx_insn *); extern void init_insn_reg_pressure_info (rtx_insn *); +extern void get_implicit_reg_pending_clobbers (HARD_REG_SET *, rtx_insn *); extern dw_t get_dep_weak (ds_t, ds_t); extern ds_t set_dep_weak (ds_t, ds_t, dw_t); diff --git a/gcc/sel-sched-ir.c b/gcc/sel-sched-ir.c index d6c86b86bf2e..83f813aa5714 100644 --- a/gcc/sel-sched-ir.c +++ b/gcc/sel-sched-ir.c @@ -1871,12 +1871,16 @@ merge_expr (expr_t to, expr_t from, insn_t split_point) /* Make sure that speculative pattern is propagated into exprs that have non-speculative one. This will provide us with consistent speculative bits and speculative patterns inside expr. */ - if ((EXPR_SPEC_DONE_DS (from) != 0 - && EXPR_SPEC_DONE_DS (to) == 0) - /* Do likewise for volatile insns, so that we always retain - the may_trap_p bit on the resulting expression. */ - || (VINSN_MAY_TRAP_P (EXPR_VINSN (from)) - && !VINSN_MAY_TRAP_P (EXPR_VINSN (to)))) + if (EXPR_SPEC_DONE_DS (to) == 0 + && (EXPR_SPEC_DONE_DS (from) != 0 + /* Do likewise for volatile insns, so that we always retain + the may_trap_p bit on the resulting expression. However, + avoid propagating the trapping bit into the instructions + already speculated. This would result in replacing the + speculative pattern with the non-speculative one and breaking + the speculation support. */ + || (!VINSN_MAY_TRAP_P (EXPR_VINSN (to)) + && VINSN_MAY_TRAP_P (EXPR_VINSN (from))))) change_vinsn_in_expr (to, EXPR_VINSN (from)); merge_expr_data (to, from, split_point); @@ -2650,6 +2654,23 @@ maybe_downgrade_id_to_use (idata_t id, insn_t insn) IDATA_TYPE (id) = USE; } +/* Setup implicit register clobbers calculated by sched-deps for INSN + before reload and save them in ID. */ +static void +setup_id_implicit_regs (idata_t id, insn_t insn) +{ + if (reload_completed) + return; + + HARD_REG_SET temp; + unsigned regno; + hard_reg_set_iterator hrsi; + + get_implicit_reg_pending_clobbers (&temp, insn); + EXECUTE_IF_SET_IN_HARD_REG_SET (temp, 0, regno, hrsi) + SET_REGNO_REG_SET (IDATA_REG_SETS (id), regno); +} + /* Setup register sets describing INSN in ID. */ static void setup_id_reg_sets (idata_t id, insn_t insn) @@ -2704,6 +2725,9 @@ setup_id_reg_sets (idata_t id, insn_t insn) } } + /* Also get implicit reg clobbers from sched-deps. */ + setup_id_implicit_regs (id, insn); + return_regset_to_pool (tmp); } @@ -2735,20 +2759,18 @@ deps_init_id (idata_t id, insn_t insn, bool force_unique_p) deps_init_id_data.force_use_p = false; init_deps (dc, false); - memcpy (&deps_init_id_sched_deps_info, &const_deps_init_id_sched_deps_info, sizeof (deps_init_id_sched_deps_info)); - if (spec_info != NULL) deps_init_id_sched_deps_info.generate_spec_deps = 1; - sched_deps_info = &deps_init_id_sched_deps_info; deps_analyze_insn (dc, insn); + /* Implicit reg clobbers received from sched-deps separately. */ + setup_id_implicit_regs (id, insn); free_deps (dc); - deps_init_id_data.id = NULL; } @@ -4084,11 +4106,14 @@ get_seqno_by_preds (rtx_insn *insn) insn_t *preds; int n, i, seqno; - while (tmp != head) + /* Loop backwards from INSN to HEAD including both. */ + while (1) { - tmp = PREV_INSN (tmp); if (INSN_P (tmp)) - return INSN_SEQNO (tmp); + return INSN_SEQNO (tmp); + if (tmp == head) + break; + tmp = PREV_INSN (tmp); } cfg_preds (bb, &preds, &n); diff --git a/gcc/sel-sched.c b/gcc/sel-sched.c index bd32ab5c154b..b795aea0ac24 100644 --- a/gcc/sel-sched.c +++ b/gcc/sel-sched.c @@ -1457,31 +1457,44 @@ choose_best_pseudo_reg (regset used_regs, gcc_assert (mode == GET_MODE (dest)); orig_regno = REGNO (dest); - if (!REGNO_REG_SET_P (used_regs, orig_regno)) - { - if (orig_regno < FIRST_PSEUDO_REGISTER) - { - gcc_assert (df_regs_ever_live_p (orig_regno)); + /* Check that nothing in used_regs intersects with orig_regno. When + we have a hard reg here, still loop over hard_regno_nregs. */ + if (HARD_REGISTER_NUM_P (orig_regno)) + { + int j, n; + for (j = 0, n = hard_regno_nregs[orig_regno][mode]; j < n; j++) + if (REGNO_REG_SET_P (used_regs, orig_regno + j)) + break; + if (j < n) + continue; + } + else + { + if (REGNO_REG_SET_P (used_regs, orig_regno)) + continue; + } + if (HARD_REGISTER_NUM_P (orig_regno)) + { + gcc_assert (df_regs_ever_live_p (orig_regno)); - /* For hard registers, we have to check hardware imposed - limitations (frame/stack registers, calls crossed). */ - if (!TEST_HARD_REG_BIT (reg_rename_p->unavailable_hard_regs, - orig_regno)) - { - /* Don't let register cross a call if it doesn't already - cross one. This condition is written in accordance with - that in sched-deps.c sched_analyze_reg(). */ - if (!reg_rename_p->crosses_call - || REG_N_CALLS_CROSSED (orig_regno) > 0) - return gen_rtx_REG (mode, orig_regno); - } + /* For hard registers, we have to check hardware imposed + limitations (frame/stack registers, calls crossed). */ + if (!TEST_HARD_REG_BIT (reg_rename_p->unavailable_hard_regs, + orig_regno)) + { + /* Don't let register cross a call if it doesn't already + cross one. This condition is written in accordance with + that in sched-deps.c sched_analyze_reg(). */ + if (!reg_rename_p->crosses_call + || REG_N_CALLS_CROSSED (orig_regno) > 0) + return gen_rtx_REG (mode, orig_regno); + } - bad_hard_regs = true; - } - else - return dest; - } - } + bad_hard_regs = true; + } + else + return dest; + } *is_orig_reg_p_ptr = false; @@ -4249,8 +4262,9 @@ invoke_aftermath_hooks (fence_t fence, rtx_insn *best_insn, int issue_more) issue_more); memcpy (FENCE_STATE (fence), curr_state, dfa_state_size); } - else if (GET_CODE (PATTERN (best_insn)) != USE - && GET_CODE (PATTERN (best_insn)) != CLOBBER) + else if (!DEBUG_INSN_P (best_insn) + && GET_CODE (PATTERN (best_insn)) != USE + && GET_CODE (PATTERN (best_insn)) != CLOBBER) issue_more--; return issue_more; diff --git a/gcc/simplify-rtx.c b/gcc/simplify-rtx.c index 450fa8b03204..e1a0319c26f1 100644 --- a/gcc/simplify-rtx.c +++ b/gcc/simplify-rtx.c @@ -4421,9 +4421,26 @@ simplify_plus_minus (enum rtx_code code, machine_mode mode, rtx op0, n_ops = i; } - /* If nothing changed, fail. */ + /* If nothing changed, check that rematerialization of rtl instructions + is still required. */ if (!canonicalized) - return NULL_RTX; + { + /* Perform rematerialization if only all operands are registers and + all operations are PLUS. */ + /* ??? Also disallow (non-global, non-frame) fixed registers to work + around rs6000 and how it uses the CA register. See PR67145. */ + for (i = 0; i < n_ops; i++) + if (ops[i].neg + || !REG_P (ops[i].op) + || (REGNO (ops[i].op) < FIRST_PSEUDO_REGISTER + && fixed_regs[REGNO (ops[i].op)] + && !global_regs[REGNO (ops[i].op)] + && ops[i].op != frame_pointer_rtx + && ops[i].op != arg_pointer_rtx + && ops[i].op != stack_pointer_rtx)) + return NULL_RTX; + goto gen_result; + } /* Create (minus -C X) instead of (neg (const (plus X C))). */ if (n_ops == 2 @@ -4465,6 +4482,7 @@ simplify_plus_minus (enum rtx_code code, machine_mode mode, rtx op0, } /* Now make the result by performing the requested operations. */ + gen_result: result = ops[0].op; for (i = 1; i < n_ops; i++) result = gen_rtx_fmt_ee (ops[i].neg ? MINUS : PLUS, diff --git a/gcc/system.h b/gcc/system.h index 445073c5cae7..cb545410a158 100644 --- a/gcc/system.h +++ b/gcc/system.h @@ -1014,6 +1014,10 @@ extern void fancy_abort (const char *, int, const char *) ATTRIBUTE_NORETURN; #undef rindex #pragma GCC poison bcopy bzero bcmp rindex +/* Poison ENABLE_CHECKING macro that should be replaced with + 'if (flag_checking)', or with CHECKING_P macro. */ +#pragma GCC poison ENABLE_CHECKING + #endif /* GCC >= 3.0 */ /* This macro allows casting away const-ness to pass -Wcast-qual diff --git a/gcc/target.def b/gcc/target.def index 5c8e4e16cc10..20f2b32da1e9 100644 --- a/gcc/target.def +++ b/gcc/target.def @@ -4884,9 +4884,9 @@ DEFHOOK DEFHOOK (lra_p, "A target hook which returns true if we use LRA instead of reload pass.\ - It means that LRA was ported to the target.\ \ - The default version of this target hook returns always false.", + The default version of this target hook returns always false, but new\ + ports should use LRA.", bool, (void), default_lra_p) diff --git a/gcc/targhooks.c b/gcc/targhooks.c index 74af91a6b1dd..a34227705d2b 100644 --- a/gcc/targhooks.c +++ b/gcc/targhooks.c @@ -1031,7 +1031,10 @@ tree default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED, HOST_WIDE_INT default_vector_alignment (const_tree type) { - return tree_to_shwi (TYPE_SIZE (type)); + HOST_WIDE_INT align = tree_to_shwi (TYPE_SIZE (type)); + if (align > MAX_OFILE_ALIGNMENT) + align = MAX_OFILE_ALIGNMENT; + return align; } bool diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 3a56e66ac889..44f023f24274 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,10 +1,1254 @@ +2016-03-27 Eric Botcazou + + * gnat.dg/specs/double_record_extension3.ads: New test. + +2016-03-25 Richard Henderson + + PR target/70120 + * gcc.target/aarch64/pr70120-1.c: New. + * gcc.target/aarch64/pr70120-2.c: New. + * gcc.target/aarch64/pr70120-3.c: New. + +2016-03-25 Patrick Palka + + PR c++/62212 + * g++.dg/template/mangle2.C: The dg-do directive should be + "compile" not "assemble". + +2016-03-25 Bernd Schmidt + + PR lto/69650 + * gcc.dg/pr69650.c: New test. + +2016-03-25 David Edelsohn + + * g++.dg/ext/pr70290.C: Prune non-standard ABI. + +2016-03-25 Alan Modra + + * gcc.dg/dfp/pr70052.c: New test. + +2016-03-24 Richard Henderson + + PR middle-end/69845 + * gcc.dg/tree-ssa/pr69845-1.c: New test. + * gcc.dg/tree-ssa/pr69845-2.c: New test. + +2016-03-24 Tom de Vries + + * gfortran.dg/goacc/host_data-tree.f95: Add missing initialization. + +2016-03-24 Tom de Vries + + * c-c++-common/goacc/uninit-use-device-clause.c: New test. + * gfortran.dg/goacc/uninit-use-device-clause.f95: New test. + +2016-03-24 Tom de Vries + + * c-c++-common/goacc/uninit-dim-clause.c: New test. + * gfortran.dg/goacc/uninit-dim-clause.f95: New test. + +2016-03-24 Patrick Palka + + PR c++/62212 + * g++.dg/template/mangle2.C: New test. + +2016-03-24 Richard Biener + + PR tree-optimization/70396 + * gcc.dg/torture/pr70396.c: New testcase. + +2016-03-24 Richard Biener + + PR middle-end/70370 + * gcc.dg/torture/pr70370.c: New testcase. + +2016-03-24 Tom de Vries + + * gfortran.dg/goacc/data-tree.f95: Add missing initialization. + * gfortran.dg/goacc/kernels-tree.f95: Same. + * gfortran.dg/goacc/parallel-tree.f95: Same. + +2016-03-24 Tom de Vries + + * c-c++-common/goacc/uninit-if-clause.c: New test. + * gfortran.dg/goacc/uninit-if-clause.f95: New test. + +2016-03-24 Jakub Jelinek + + PR target/70290 + * g++.dg/ext/pr70290.C: Add -Wno-psabi -w to dg-options. Formatting. + +2016-03-24 Richard Biener + + PR tree-optimization/70372 + * gcc.dg/tree-ssa/pr70372.c: New testcase. + +2016-03-23 Patrick Palka + + PR c++/70347 + * g++.dg/cpp1y/nsdmi-union1.C: New test. + +2016-03-23 Patrick Palka + + PR c++/70332 + * g++.dg/cpp1y/nsdmi-aggr5.C: New test. + +2016-03-23 Jakub Jelinek + + PR c++/70001 + * g++.dg/cpp0x/constexpr-70001-4.C: New test. + * g++.dg/cpp1y/pr70001.C: New test. + + PR c++/70323 + * g++.dg/cpp0x/constexpr-70323.C: New test. + +2016-03-23 Alexandre Oliva + Jason Merrill + Jakub Jelinek + + PR c++/69315 + * g++.dg/cpp0x/constexpr-69315.C: New test. + * g++.dg/cpp0x/variadic122.C: Change one dg-warning into dg-bogus. + +2016-03-23 Marek Polacek + + PR c++/69884 + * g++.dg/warn/Wignored-attributes-1.C: New test. + * g++.dg/warn/Wignored-attributes-2.C: New test. + +2016-03-23 Tom de Vries + + * c-c++-common/goacc/kernels-default.c (foo): Add missing + initialization. + * gfortran.dg/goacc/private-3.f95 (test): Same. + * gfortran.dg/goacc/routine-5.f90 (gang, worker, vector, seq): Add + missing use param. + +2016-03-23 Kyrylo Tkachov + + * lib/target-supports.exp: Remove v7ve entry from loop + creating effective target checks. + (check_effective_target_arm_arch_v7ve_ok): New procedure. + (add_options_for_arm_arch_v7ve): Likewise. + +2016-03-23 Jakub Jelinek + + PR tree-optimization/70354 + * gcc.dg/vect/pr70354-1.c: New test. + * gcc.dg/vect/pr70354-2.c: New test. + * gcc.target/i386/avx2-pr70354-1.c: New test. + * gcc.target/i386/avx2-pr70354-2.c: New test. + +2016-03-22 Jeff Law + + PR target/70232 + * gcc.dg/tree-ssa/pr70232.c: New test. + +2016-03-22 Ilya Enkovich + + PR target/70302 + * gcc.target/i386/pr70302.c: New test. + +2016-03-22 Richard Biener + + PR middle-end/70251 + * g++.dg/torture/pr70251.C: New testcase. + +2016-03-22 David Malcolm + + PR c/69993 + * c-c++-common/Wmisleading-indentation-3.c: New test, based on + Wmisleading-indentation.c. + * c-c++-common/Wmisleading-indentation.c: Update thoughout to + reflect change to diagnostic text and order of messages. + * gcc.dg/plugin/location-overflow-test-2.c: Likewise. + +2016-03-22 David Edelsohn + + * g++.dg/ext/java-3.C: Don't compile on AIX. + +2016-03-22 Richard Biener + + PR middle-end/70333 + * gcc.dg/torture/pr70333.c: New testcase. + +2016-03-22 Ilya Enkovich + + * g++.dg/ext/pr70290.C: New test. + +2016-03-22 Kirill Yukhin + + PR target/70325 + * gcc.target/i386/pr70325.c: New test. + +2016-03-22 Jakub Jelinek + + PR target/70329 + * gcc.target/i386/avx512bw-pr70329-1.c: New test. + * gcc.target/i386/avx512bw-pr70329-2.c: New test. + + PR target/70300 + * gcc.target/i386/pr70300.c: New test. + + PR c++/70295 + * c-c++-common/nonnull-1.c (func): Remove parens around cp4 != 0. + (func2): New function for cond with parens, xfail warning for c++. + * g++.dg/warn/Wnonnull-compare-8.C: New test. + +2016-03-22 Patrick Palka + + PR c++/70096 + * g++.dg/template/ptrmem30.C: New test. + +2016-03-22 Patrick Palka + + PR c++/70204 + * g++.dg/cpp0x/constexpr-70204a.C: New test. + * g++.dg/cpp0x/constexpr-70204b.C: New test. + +2016-03-21 Jakub Jelinek + + PR middle-end/70326 + * gcc.dg/pr70326.c: New test. + +2016-03-21 Marc Glisse + Jakub Jelinek + + PR tree-optimization/70317 + * gcc.dg/pr70317.c: New test. + +2016-03-21 Uros Bizjak + + PR target/70327 + * gcc.target/i386/pr70327.c: New test. + +2016-03-21 Martin Liska + + PR ipa/70306 + * gcc.dg/ipa/pr70306.c: New test. + +2016-03-21 Andre Vieira + + * gcc.target/arm/attr-align1.c: Skip if M-profile. + * gcc.target/arm/attr-align3.c: Likewise. + * gcc.target/arm/attr_arm.c: Likewise. + * gcc.target/arm/flip-thumb.c: Likewise. + +2016-03-21 Jakub Jelinek + + PR target/70296 + * gcc.target/powerpc/altivec-36.c: New test. + +2016-03-21 Richard Biener + + PR tree-optimization/70310 + * gcc.dg/torture/pr70310.c: New testcase. + +2016-03-21 Kirill Yukhin + + PR target/70293 + * gcc.target/i386/pr70293.c: New test. + +2016-03-21 Richard Biener + + PR tree-optimization/70288 + * gcc.dg/torture/pr70288-1.c: New testcase. + * gcc.dg/torture/pr70288-2.c: Likewise. + +2016-03-21 Andrey Belevantsev + + PR rtl-optimization/69307 + * gcc.target/arm/pr69307.c: New test. + +2016-03-21 Andrey Belevantsev + + PR rtl-optimization/69102 + * gcc.c-torture/compile/pr69102.c: New test. + +2016-03-18 Jeff Law + + PR rtl-optimization/70263 + * gcc.c-torture/compile/pr70263-1.c: New test. + * gcc.target/i386/pr70263-2.c: New test. + +2016-03-18 Bernd Schmidt + + PR rtl-optimization/70278 + * gcc.dg/torture/pr70278.c: New test. + * gcc.target/arm/pr70278.c: New test. + +2016-03-18 David Malcolm + + PR c/70281 + * gcc.dg/plugin/diagnostic-test-expressions-1.c + (test_builtin_types_compatible_p): New test function. + * gcc.dg/pr70281.c: New test case. + +2016-03-18 Christophe Lyon + + PR target/70113 + * gcc.target/aarch64/pr63304_1.c: Add -mno-fix-cortex-a53-843419. + +2016-03-18 Ilya Enkovich + + PR tree-optimization/70252 + * gcc.dg/pr70252.c: New test. + +2016-03-18 Tom de Vries + + * gcc.dg/pr70161-2.c: New test. + * gcc.dg/pr70161.c: New test. + +2016-03-18 Tom de Vries + + PR ipa/70269 + * gcc.dg/pr70269.c: New test. + +2016-03-18 Jakub Jelinek + + PR c++/70267 + * g++.dg/ext/java-3.C: New test. + +2016-03-18 Patrick Palka + + PR c++/70205 + * g++.dg/lookup/pr70205.C: New test. + +2016-03-18 Patrick Palka + + PR c++/70218 + * g++.dg/cpp0x/lambda/lambda-70218.C: New test. + +2016-03-17 Marek Polacek + + PR c/69407 + * gcc.dg/atomic-op-6.c: New test. + +2016-03-17 David Malcolm + + PR c/70264 + * c-c++-common/pr70264.c: New test case. + +2016-03-17 Jakub Jelinek + + PR c++/70144 + * c-c++-common/pr70144-1.c: New test. + * c-c++-common/pr70144-2.c: New test. + + PR c++/70272 + * g++.dg/opt/flifetime-dse5.C (main): Remove extra semicolon. + * g++.dg/opt/flifetime-dse6.C: New test. + * g++.dg/tree-ssa/ehcleanup-1.C: Adjust unreachable count. + +2016-03-17 H.J. Lu + + PR driver/70192 + * gcc.dg/pic-1.c: New test. + * gcc.dg/pic-2.c: Likewise. + * gcc.dg/pic-3.c: Likewise. + * gcc.dg/pic-4.c: Likewise. + * gcc.dg/pie-1.c: Likewise. + * gcc.dg/pie-2.c: Likewise. + * gcc.dg/pie-3.c: Likewise. + * gcc.dg/pie-4.c: Likewise. + * gcc.dg/pie-5.c: Likewise. + * gcc.dg/pie-6.c: Likewise. + +2016-03-17 Tom de Vries + + * gfortran.dg/goacc/kernels-alias-3.f95: New test. + * gfortran.dg/goacc/kernels-alias-4.f95: New test. + +2016-03-17 Richard Biener + + PR debug/70271 + * g++.dg/debug/pr70271.C: New testcase. + +2016-03-17 Ilya Enkovich + + * gcc.target/i386/pr70251.c: New test. + +2016-03-17 Marek Polacek + + PR c++/70194 + * g++.dg/warn/constexpr-70194.C: New test. + +2016-03-16 Richard Henderson + + PR middle-end/70240 + * gcc.c-torture/compile/pr70240.c: New. + +2016-03-16 Senthil Kumar Selvaraj + + * gcc.c-torture/compile/20151204.c: Skip for avr. + +2016-03-16 Jakub Jelinek + + PR target/70245 + * g++.dg/opt/pr70245.C: New test. + * g++.dg/opt/pr70245.h: New file. + * g++.dg/opt/pr70245-aux.cc: New file. + +2016-03-16 Martin Sebor + + * g++.dg/cpp1y/constexpr-instantiate.C: Correct DejaGnu directives. + +2016-03-16 Richard Henderson + + PR middle-end/70199 + * gcc.c-torture/compile/pr70199.c: New. + +2016-03-16 H.J. Lu + + * gcc.dg/uninit-19.c: Run dos2unix. + +2016-03-16 Marek Polacek + + PR c/70093 + * gcc.dg/nested-func-10.c: New test. + * gcc.dg/nested-func-9.c: New test. + +2016-03-16 Jakub Jelinek + + PR tree-optimization/68714 + * gcc.dg/tree-ssa/pr68714.c: Add -w -Wno-psabi to dg-options. + +2016-03-16 Tom de Vries + + PR tree-optimization/68715 + * gcc.dg/graphite/pr68715-2.c: New test. + * gcc.dg/graphite/pr68715.c: New test. + * gfortran.dg/graphite/pr68715.f90: New test. + +2016-03-16 Tom de Vries + + PR tree-optimization/68809 + * gcc.dg/graphite/pr68809-2.c: New test. + * gcc.dg/graphite/pr68809.c: New test. + +2016-03-16 Jakub Jelinek + + PR c++/70147 + * g++.dg/ubsan/pr70147-2.C (C::C): Initialize A base with invalid + method call to i () as argument. Adjust expected output. + + PR c++/70147 + * g++.dg/ubsan/pr70147-1.C: New test. + * g++.dg/ubsan/pr70147-2.C: New test. + +2016-03-15 Martin Sebor + + PR c++/58281 + * g++.dg/cpp1y/constexpr-instantiate.C: Add new test. + +2016-03-15 John David Anglin + + * gcc.c-torture/execute/pr68532.c: Add -fno-common option on + hppa*-*-hpux*. + + * gcc.dg/ifcvt-4.c: Add hppa*64*-*-* to skip list. + + PR libfortran/69799 + * gfortran.dg/coarray_allocate_5.f08: Add "-latomic" option if + libatomic_available. + +2016-03-15 Marek Polacek + + PR c++/70209 + * g++.dg/ext/attribute-may-alias-4.C: New test. + +2016-03-15 Alexander Monakov + + * g++.dg/pr63384.C: Add -w to dg-options. Remove '-toggle' in + -fvar-tracking-assignments-toggle flag. + +2016-03-15 Pat Haugen + + * gcc.dg/ifcvt-4.c: Add -misel for powerpc*. + +2016-03-15 Jakub Jelinek + + PR rtl-optimization/70222 + * gcc.c-torture/execute/pr70222-1.c: New test. + * gcc.c-torture/execute/pr70222-2.c: New test. + +2016-03-15 Richard Henderson + + * gcc.dg/tree-ssa/pr68714.c: Test during reassoc1 pass. + +2016-03-15 Andrey Belevantsev + + PR rtl-optimization/69032 + * gcc.dg/pr69032.c: New test. + +2016-03-15 Andrey Belevantsev + + PR rtl-optimization/63384 + * g++.dg/pr63384.C: New test. + +2016-03-15 Andrey Belevantsev + + PR target/64411 + * gcc.target/i386/pr64411.C: New test. + +2016-03-15 Tom de Vries + + * gfortran.dg/goacc/kernels-alias-2.f95: New test. + * gfortran.dg/goacc/kernels-alias.f95: New test. + +2016-03-14 Martin Sebor + + PR c++/53792 + * g++.dg/cpp0x/constexpr-inline.C: New test. + * g++.dg/cpp0x/constexpr-inline-1.C: Same. + +2016-03-14 David Edelsohn + + * gcc.dg/torture/pr70083.c: Prune non-standard ABI. + +2016-03-14 Jakub Jelinek + + PR middle-end/70219 + * gcc.dg/pr70219.c: New test. + +2016-03-14 Bernd Schmidt + + PR target/70083 + * gcc.dg/torture/pr70083.c: New test. + * gcc.target/i386/pr70083.c: New test. + +2016-03-14 Richard Biener + + PR tree-optimization/56365 + * gcc.dg/tree-ssa/phi-opt-14.c: New testcase. + +2016-03-14 Segher Boessenkool + + PR target/70098 + * lib/target-supports.exp (check_effective_target_powerpc64_no_dm): + New function. + * g++.dg/pr70098.C: New testcase. + + +2016-03-14 Tom de Vries + + PR tree-optimization/70045 + * gcc.dg/graphite/pr70045.c: New test. + +2016-03-13 Jerry DeLisle + + PR fortran/69043 + * gfortran.dg/include_9.f90: New test. + +2016-03-13 Dominique d'Humieres + + PR fortran/45076 + gfortran.dg/prof/prof.exp: New script. + gfortran.dg/prof/dynamic_dispatch_6.f03: New test. + +2016-03-12 Andrey Belevantsev + + PR rtl-optimization/69307 + * gcc.dg/pr69307.c: New test. + +2016-03-12 Vladimir Makarov + + PR target/69614 + * gcc.target/arm/pr69614.c: New. + +2016-03-12 Paul Thomas + + PR fortran/70031 + * gfortran.dg/submodule_14.f08: New test + + PR fortran/69524 + * gfortran.dg/submodule_15.f08: New test + +2016-03-12 Patrick Palka + + PR c++/70106 + * g++.dg/cpp1y/paren3.C: New test. + +2016-03-11 Michael Meissner + + PR target/70131 + * gcc.target/powerpc/ppc-round2.c: New test. + +2016-03-11 Bernd Schmidt + + PR target/70123 + * gcc.dg/torture/pr70123.c: New test. + +2016-03-11 Jeff Law + + PR tree-optimization/70190 + * gcc.c-torture/compile/pr70190.c: New test. + +2016-03-11 David Malcolm + + PR c/68187 + * c-c++-common/Wmisleading-indentation.c (test43_a): New test + case. + (test43_b): Likewise. + (test43_c): Likewise. + (test43_d): Likewise. + (test43_e): Likewise. + (test43_f): Likewise. + (test43_g): Likewise. + (test44_a): Likewise. + (test44_b): Likewise. + (test44_c): Likewise. + (test44_d): Likewise. + (test44_e): Likewise. + +2016-03-11 David Malcolm + + PR c/70085 + * c-c++-common/Wmisleading-indentation.c (pr70085): New test case. + +2016-03-11 Kyrylo Tkachov + + * gcc.target/aarch64/vect-reduc-or_1.c: Add -fno-vect-cost-model to + dg-options. + +2016-03-11 Kyrylo Tkachov + + PR target/70002 + PR target/69245 + * gcc.target/aarch64/pr69245_2.c: New test. + +2016-03-11 Jakub Jelinek + + PR tree-optimization/70177 + * gcc.dg/pr70177.c: New test. + +2016-03-11 Alan Lawrence + + * gfortran.dg/unconstrained_commons.f: Widen regexp to match j_. + +2016-03-11 Alan Lawrence + + * gcc.dg/tree-ssa/sra-20.c: New. + +2016-03-11 Jakub Jelinek + + PR rtl-optimization/70174 + * gcc.dg/pr70174.c: New test. + + PR tree-optimization/70169 + * gcc.dg/pr70169.c: New test. + +2016-03-11 Ilya Enkovich + + PR target/70160 + * gcc.target/i386/pr70160.c: New test. + +2016-03-11 Andreas Krebbel + + * gcc.target/s390/dfp-1.c: New test. + +2016-03-10 Nick Clifton + + PR target/70044 + * gcc.target/aarch64/pr70044.c: New test. + +2016-03-10 Patrick Palka + Jakub Jelinek + + PR c++/70001 + * g++.dg/cpp0x/constexpr-70001-1.C: New test. + * g++.dg/cpp0x/constexpr-70001-2.C: New test. + * g++.dg/cpp0x/constexpr-70001-3.C: New test. + +2016-03-10 Jan Hubicka + + PR lto/69589 + * g++.dg/lto/pr69589_0.C: New testcase + * g++.dg/lto/pr69589_1.C: New testcase + +2016-03-10 Marek Polacek + + PR c++/70153 + * g++.dg/delayedfold/unary-plus1.C: New test. + +2016-03-10 Andre Vieira + + * gcc.target/arm/pr45701-1.c: Escape brackets. + * gcc.target/arm/pr45701-2.c: Likewise. + +2016-03-10 Alan Lawrence + + * gfortran.dg/unconstrained_commons.f: New. + +2016-03-10 Alan Modra + + * gcc.dg/pr69195.c: New. + * gcc.dg/pr69238.c: New. + +2016-03-10 Tom de Vries + + PR testsuite/68915 + * gcc.dg/vect/pr46032.c: Xfail scan if alignment requirements not met. + +2016-03-10 Richard Biener + + PR tree-optimization/70128 + * gcc.dg/tree-ssa/alias-34.c: New testcase. + * gcc.dg/tree-ssa/alias-35.c: Likewise. + +2016-03-09 Jakub Jelinek + + PR tree-optimization/70152 + * gcc.dg/pr70152.c: New test. + + PR target/70086 + * gcc.target/i386/pr70086-1.c: New test. + * gcc.target/i386/pr70086-2.c: New test. + * gcc.target/i386/pr70086-3.c: New test. + + PR tree-optimization/70127 + * gcc.c-torture/execute/pr70127.c: New test. + +2016-03-09 Cesar Philippidis + + * c-c++-common/goacc/combined-directives-2.c: New test. + +2016-03-09 David Malcolm + + PR c/68473 + PR c++/70105 + * g++.dg/diagnostic/pr70105.C: New test. + * gcc.dg/plugin/diagnostic-test-expressions-1.c (foo): New decl. + (test_multiple_ordinary_maps): New test function. + +2016-03-09 David Malcolm + + PR c/68473 + PR c++/70105 + * gcc.dg/plugin/diagnostic_plugin_show_trees.c (show_tree): + Drop range information from call to inform_at_rich_loc. + * gcc.dg/plugin/diagnostic_plugin_test_show_locus.c (add_range): + New. + (test_show_locus): Replace calls to rich_location::add_range with + calls to add_range. Rewrite the tests that used the now-defunct + rich_location ctor taking a source_range. Simplify other tests + by replacing calls to COMBINE_LOCATION_DATA with calls to + make_location. + +2016-03-09 Richard Biener + Jakub Jelinek + + PR tree-optimization/70138 + * gcc.dg/vect/pr70138-1.c: New testcase. + * gcc.dg/vect/pr70138-2.c: Likewise. + +2016-03-09 Jakub Jelinek + + PR target/70049 + * gcc.target/i386/pr70049.c: New test. + +2016-03-09 Richard Biener + + PR c/70143 + * gcc.dg/Wstrict-aliasing-bogus-upcast.c: New testcase. + * gcc.dg/Wstrict-aliasing-struct-with-char-member.c: Likewise. + * gcc.dg/Wstrict-aliasing-struct-member.c: Remove again. + +2016-03-09 Rainer Orth + + * gcc.dg/vect/bb-slp-34.c: Really don't xfail on aarch64-*-*, + arm-*-*. + +2016-03-09 Jakub Jelinek + + PR middle-end/67278 + * gcc.dg/simd-7.c: Add -w -Wno-psabi to dg-options. + + PR target/67278 + * gcc.dg/simd-8.c: Add -w -Wno-psabi to dg-options. + + PR middle-end/70050 + * gcc.dg/pr70050.c: Add -w to dg-options. Fix up PR number + in testcase comment. + +2016-03-09 Tom de Vries + + * gfortran.dg/goacc/kernels-loop-2.f95: New test. + * gfortran.dg/goacc/kernels-loop-data-2.f95: New test. + * gfortran.dg/goacc/kernels-loop-data-enter-exit-2.f95: New test. + * gfortran.dg/goacc/kernels-loop-data-enter-exit.f95: New test. + * gfortran.dg/goacc/kernels-loop-data-update.f95: New test. + * gfortran.dg/goacc/kernels-loop-data.f95: New test. + * gfortran.dg/goacc/kernels-loop-n.f95: New test. + * gfortran.dg/goacc/kernels-loop.f95: New test. + +2016-03-08 Martin Sebor + + PR c++/62096 + * g++.dg/warn/overflow-warn-7.C: New test. + +2016-03-08 Jason Merrill + + * lib/g++-dg.exp (g++-dg-runtest): Handle "concepts" in std list. + * lib/target-supports.exp (check_effective_target_concepts): New. + +2016-03-08 Jakub Jelinek + + PR c++/70135 + * g++.dg/cpp1y/constexpr-loop4.C: New test. + * g++.dg/ubsan/pr70135.C: New test. + + PR target/70110 + * gcc.dg/pr70110.c: New test. + +2016-03-07 Martin Jambor + + * c-c++-common/gomp/clauses-1.c: Remove dg-options. + * c-c++-common/gomp/if-1.c: Likewise. + * c-c++-common/gomp/pr61486-2.c: Likewise. + * c-c++-common/gomp/target-teams-1.c: Moved dg-options except -fopenmp + to dg-additional-options. + * g++.dg/gomp/gomp.exp: Pass -Wno-hsa to all tests. + * g++/gomp/target-teams-1.c: Likewise. + * gcc.dg/gomp/gomp.exp: Likewise. + * gcc.dg/gomp/pr68128-2.c: Moved dg-options except -fopenmp to + dg-additional-options. + * gfortran.dg/gomp/gomp.exp: Likewise. + * gfortran.dg/gomp/target1.f90: Remove dg-options. + * gfortran.dg/gomp/target2.f90: Moved dg-options except -fopenmp to + dg-additional-options. + * gfortran.dg/gomp/target3.f90: Remove dg-options. + +2016-03-07 Martin Jambor + + * lib/target-supports.exp (check_effective_target_offload_hsa): New. + * c-c++-common/gomp/gridify-1.c: New test. + * gfortran.dg/gomp/gridify-1.f90: Likewise. + +2016-03-07 Andre Vieira + + * gcc.target/arm/pr45701-1.c: Change assembler scan to not + trigger for cortex-r8, when scanning for register r8. + * gcc.target/arm/pr45701-2.c: Likewise. + +2016-02-26 Richard Biener + Jeff Law + + PR tree-optimization/69740 + * gcc.c-torture/compile/pr69740-1.c: New test. + * gcc.c-torture/compile/pr69740-2.c: New test. + +2016-03-07 Bill Schmidt + + * lib/target-supports.exp + (check_effective_target_whole_vector_shift): Enable for PPC64. + +2016-03-07 Richard Biener + + PR tree-optimization/70115 + * gcc.dg/torture/pr70115.c: New testcase. + +2016-03-07 Nathan Sidwell + + PR middle-end/69916 + * c-c-++-common/goacc/pr69916.c: New. + +2016-03-07 Richard Henderson + + * gcc.c-torture/compile/pr70061.c: New test. + +2016-03-07 Richard Biener + + PR testsuite/70109 + * gcc.dg/vect/O3-pr36098.c: New testcase. + +2016-03-07 Christophe Lyon + + * gcc.target/arm/pragma_cpp_fma.c: Reset default FPU. + +2016-03-07 Eric Botcazou + + * gnat.dg/renaming9.ad[sb]: New testcase. + +2016-03-05 Jakub Jelinek + + PR c++/70084 + * g++.dg/expr/stdarg3.C: New test. + +2016-03-04 Jeff Law + + PR tree-optimization/69196 + * gcc.dg/tree-ssa/pr69196-1.c: Limit this to sparc*-*-* and + x86_64-*-*. + +2016-03-04 Bernd Schmidt + + PR c/69973 + * gcc.dg/pr69973.c: New test. + + PR rtl-optimization/69941 + * gcc.dg/torture/pr69941.c: New test. + + PR c/69824 + * gcc.dg/pr69824.c: New test. + +2016-03-05 Tom de Vries + + * c-c++-common/goacc/nesting-fail-1.c (f_acc_routine): New function. + * c-c++-common/goacc-gomp/nesting-fail-1.c (f_acc_routine): New + function. + +2016-03-05 Patrick Palka + + PR c++/66786 + * g++.dg/cpp1y/var-templ48.C: New test. + * g++.dg/cpp1y/var-templ49.C: New test. + +2016-03-04 Eric Botcazou + + * g++.dg/Wno-frame-address.C: Skip on IA-64. + +2016-03-04 Jakub Jelinek + + PR c++/70035 + * g++.dg/ubsan/pr70035.C: New test. + + PR target/70062 + * gcc.target/i386/pr70062.c: New test. + +2016-03-04 H.J. Lu + + * g++.dg/template/typename21.C: Remove c++98_only. + +2016-03-04 H.J. Lu + + * g++.dg/template/typename21.C: Replace c++98 with c++98_only. + +2016-03-04 David Malcolm + + PR c/68187 + * c-c++-common/Wmisleading-indentation.c (fn_42_a): New test + function. + (fn_42_b): Likewise. + (fn_42_c): Likewise. + +2016-03-04 David Malcolm + + PR c/68187 + * c-c++-common/Wmisleading-indentation.c (fn_40_a): New test + function. + (fn_40_b): Likewise. + (fn_41_a): Likewise. + (fn_41_b): Likewise. + +2016-03-04 Jakub Jelinek + + PR target/70059 + * gcc.target/i386/avx512f-pr70059.c: New test. + * gcc.target/i386/avx512dq-pr70059.c: New test. + +2016-03-04 Bernd Schmidt + + PR rtl-optimization/57676 + * gcc.dg/torture/pr57676.c: New test. + +2016-03-04 Ilya Enkovich + + * gcc.dg/pr70026.c: New test. + +2016-03-04 Marek Polacek + + PR c/69798 + * gcc.dg/cilk-plus/pr69798-1.c: New test. + * gcc.dg/cilk-plus/pr69798-2.c: New test. + +2016-03-04 Kyrylo Tkachov + + PR target/70004 + * gcc.target/aarch64/scalar_shift_1.c: (test_corners_sisd_di): + Delete. + (test_corners_sisd_si): Likewise. + (main): Remove checks of the above. + * gcc.target/aarch64/shift_wide_invalid_1.c: New test. + +2016-03-04 Eric Botcazou + + * gcc.dg/Wno-frame-address.c: Skip on IA-64. + +2016-03-04 Christophe Lyon + + * gcc.dg/torture/pr69951.c: Accept argc==0. + +2016-03-04 Richard Biener + + PR c++/70054 + * g++.dg/warn/Wstrict-aliasing-bogus-union-2.C: New testcase. + * gcc.dg/Wstrict-aliasing-struct-member.c: New testcase. + +2016-03-04 Dominik Vogt + + PR testsuite/69766 + * go.test/go-test.exp: S/390: Set GOARCH to the current target when + testing multiarch. + +2016-03-04 Jakub Jelinek + + PR debug/69947 + * gcc.dg/guality/pr69947.c: New test. + +2016-03-03 Jakub Jelinek + + PR ada/70017 + * gcc.dg/pr70017.c (foo): Store 0 to first element of each array. + +2016-03-03 Kyrylo Tkachov + + PR rtl-optimization/69904 + * gcc.target/arm/pr69904.c: New test. + +2016-03-03 Jakub Jelinek + + PR target/70021 + * gcc.dg/vect/pr70021.c: New test. + * gcc.target/i386/pr70021.c: New test. + +2016-03-03 Marek Polacek + + PR middle-end/70050 + * gcc.dg/pr70050.c: New test. + +2016-03-03 James Greenhalgh + + * gcc.dg/vect/bb-slp-34.c: Don't XFAIL for ARM/AArch64. + +2016-03-03 Ilya Enkovich + + PR tree-optimization/70043 + * gfortran.dg/vect/pr70043.f90: New test. + +2016-03-03 Eric Botcazou + + * gnat.dg/specs/task1.ads: New test. + +2016-03-03 Rainer Orth + + * lib/gcc-gdb-test.exp (gdb-test): Make log message match command. + Invoke gdb with -batch. + * lib/gcc-simulate-thread.exp (simulate-thread): Likewise. + +2016-03-03 Richard Biener + + PR tree-optimization/55936 + * gcc.dg/tree-ssa/vrp06.c: Remove XFAIL. + +2016-03-02 Jeff Law + + PR rtl-optimization/69942 + * gcc.dg/ifcvt-5.c: Use "word_mode" rather than "int" to limit the + effects of argument promotions. + + PR tree-optimization/69987 + * gfortran.dg/pr69987.f90: Use "-w" to avoid failures when the + target does not support -fprefetch-loop-arrays. + +2016-03-02 Uros Bizjak + + * gcc.target/i386/bmi2-bzhi-2.c: Change to runtime test. + +2016-03-02 Bin Cheng + + PR rtl-optimization/69052 + * gcc.target/i386/pr69052.c: New test. + +2016-03-02 Alan Modra + + * gcc.dg/pr69990.c: New. + +2016-03-02 Jakub Jelinek + + PR c/68062 + * c-c++-common/vector-compare-4.c: Add -Wno-psabi to dg-options. + + PR middle-end/70022 + * gcc.dg/pr70022.c: Add -w -Wno-psabi to dg-options. + + PR target/70028 + * gcc.target/i386/pr70028.c: New test. + +2016-03-02 Maxim Kuvyrkov + + * c-c++-common/asan/swapcontext-test-1.c, + * c-c++-common/tsan/thread_leak.c, + * g++.dg/tsan/aligned_vs_unaligned_race.C, + * g++.dg/tsan/benign_race.C, + * g++.dg/tsan/fd_close_norace.C, + * g++.dg/tsan/fd_close_norace2.C: Print markers to stderr to avoid + races with sanitizer output + +2016-03-02 Richard Biener + Uros Bizjak + + PR target/67278 + * gcc.dg/simd-8.c: New testcase. + +2016-03-02 Richard Biener + + PR middle-end/67278 + * gcc.dg/simd-7.c: New testcase. + +2016-03-02 Eric Botcazou + + * gcc.target/i386/pr70007.c: Tweak. + +2016-03-02 Dominik Vogt + + * gfortran.dg/bessel_6.f90: Reduce accuracy for S/390. + +2016-03-02 Marek Polacek + + PR c/67854 + * gcc.dg/pr67854.c: New test. + +2016-03-02 Jakub Jelinek + + PR middle-end/70025 + * gcc.dg/torture/pr70025.c: New test. + +2016-03-02 Venkataramanan Kumar + + PR tree-optimization/68621 + * gcc.dg/tree-ssa/ifc-8.c: Adjust test. + +2016-03-01 Eric Botcazou + + * gcc.target/i386/pr70007.c: New test. + +2016-03-01 Jeff Law + + PR tree-optimization/69196 + * gcc.dg/tree-ssa/pr69196-1.c: New test. + + PR tree-optimization/69196 + * gcc.dg/tree-ssa/vrp46.c: Twiddle threading params to keep it from + duplicating code and spoiling the expected output. + +2016-03-01 Michael Meissner + + PR target/70033 + * gcc.target/powerpc/p9-lxvx-stxvx-1.c: Make sure compiler + supports power9 before doing tests. + * gcc.target/powerpc/p9-lxvx-stxvx-2.c: Likewise. + * gcc.target/powerpc/p9-lxvx-stxvx-3.c: Likewise. + * gcc.target/powerpc/p9-permute.c: Likewise. + +2016-03-01 Uros Bizjak + + PR target/70027 + * gcc.target/i386/pr70027.c: New test. + +2016-03-01 Eric Botcazou + + * gcc.dg/pr70017.c: New test. + +2016-03-01 Jakub Jelinek + + PR c/69796 + PR c/69974 + * gcc.dg/pr69796.c: New test. + * gcc.dg/pr69974.c: New test. + +2016-03-01 Eric Botcazou + + * gnat.dg/stack_usage3.adb: Robustify and enable for all targets. + +2016-02-29 Jeff Law + + PR tree-optimization/69987 + * gfortran.dg/pr69987.f90: New test. + + PR tree-optimization/69989 + * gcc.c-torture/compile/pr69989-2.c: New test. + +2016-03-01 Marek Polacek + + PR c++/69795 + * g++.dg/parse/invalid1.C: New test. + +2016-03-01 Richard Biener + + PR middle-end/70022 + * gcc.dg/pr70022.c: New testcase. + +2016-03-01 Ilya Enkovich + + PR tree-optimization/69956 + * gcc.dg/pr69956.c: New test. + +2016-02-29 Bill Schmidt + + PR target/70011 + * gcc.dg/vect/costmodel/ppc/costmodel-fast-math-vect-pr299925.c: + XFAIL when hardware supports efficient unaligned storage access. + +2016-03-01 Patrick Palka + + PR c++/69961 + * g++.dg/template/pr69961a.C: New test. + * g++.dg/template/pr69961b.C: New test. + +2016-02-29 David Malcolm + + PR preprocessor/69985 + * gcc.dg/cpp/pr69985.c: New test case. + +2016-02-29 Jeff Law + + PR tree-optimization/70005 + * gcc.c-torture/execute/pr70005.c New test. + + PR tree-optimization/69999 + * gcc.c-torture/compile/pr69999.c: New test. + +2016-02-29 Yuri Rumyantsev + + PR tree-optimization/69652 + * gcc.dg/torture/pr69652.c: Delete test. + * gcc.dg/vect/pr69652.c: New test. + +2016-02-19 Richard Biener + + PR tree-optimization/69980 + * gfortran.dg/vect/pr69980.f90: New testcase. + +2016-02-29 Eric Botcazou + + * gcc.target/sparc/20160229-1.c: New test. + +2016-02-29 Eric Botcazou + + * gnat.dg/stack_usage3.adb: New test. + * gnat.dg/stack_usage3_pkg.ads: New helper. + +2016-02-29 Eric Botcazou + + * gnat.dg/renaming8.adb: New test. + * gnat.dg/renaming8_pkg1.ads: New helper. + * gnat.dg/renaming8_pkg2.ad[sb]: Likewise. + * gnat.dg/renaming8_pkg3.ad[sb]: Likewise. + +2016-02-29 Richard Biener + + PR tree-optimization/69720 + * gcc.dg/vect/vect-outer-pr69720.c: New testcase. + 2016-02-28 Thomas Koenig PR fortran/68147 PR fortran/47674 * gfortran.dg/realloc_on_assign_26.f90: New test case. -2016-02-28 Harald Anlauf +2016-02-28 Harald Anlauf Jerry DeLisle PR fortran/56007 @@ -323,7 +1567,6 @@ PR c/69900 * gcc.dg/pr69900.c: New test. ->>>>>>> .r233653 2016-02-23 Martin Jambor PR tree-optimization/69666 @@ -2226,7 +3469,7 @@ PR tree-optimization/69170 * gcc.dg/torture/pr69170.c: New testcase. -2016-01-17 John David Anglin +2016-01-17 John David Anglin * gcc.dg/torture/builtin-integral-1.c: Require c99_runtime. @@ -2359,11 +3602,11 @@ * gcc.target/i386/pr65105-5.c: New test. -2016-01-15 Jan Hubicka +2016-01-15 Jan Hubicka * gcc.c-torture/execute/alias-4.c: New testcase. -2016-01-15 Jan Hubicka +2016-01-15 Jan Hubicka PR ipa/68148 * g++.dg/ipa/devirt-49.C: New testcase. diff --git a/gcc/testsuite/ChangeLog-2015 b/gcc/testsuite/ChangeLog-2015 index f48907ae4293..17609b92d9ef 100644 --- a/gcc/testsuite/ChangeLog-2015 +++ b/gcc/testsuite/ChangeLog-2015 @@ -514,7 +514,7 @@ * g++.dg/lookup/pr21802.C: New test. * g++.dg/lookup/two-stage4.C: Remove XFAIL. -2015-12-14 Jerry DeLisle +2015-12-14 Jerry DeLisle * gfortran.dg/quad_2.f90: Update test. @@ -785,7 +785,7 @@ * gcc.c-torture/execute/alias-2.c: New testcase. 2015-12-09 Tobias Burnus - Alessandro Fanfarillo + Alessandro Fanfarillo * gfortran.dg/coarray_40.f90: New. @@ -1347,7 +1347,7 @@ * lib/g++-dg.exp (g++-dg-runtest): Use it. 2015-12-02 Tobias Burnus - Alessandro Fanfarillo + Alessandro Fanfarillo * gfortran.dg/coarray/event_1.f90: New. * gfortran.dg/coarray/event_2.f90: New. @@ -2083,7 +2083,7 @@ PR c++/68087 * g++.dg/cpp0x/constexpr-array13.C: New. -2015-11-25 Ilmir Usmanov +2015-11-25 Ilmir Usmanov Cesar Philippidis PR fortran/63858 @@ -2596,7 +2596,7 @@ PR c++/68308 * g++.dg/init/new46.C: New test. -2015-11-17 Dominique d'Humieres +2015-11-17 Dominique d'Humieres PR fortran/65751 * gfortran.dg/unlimited_polymorphic_2.f03: Update test. @@ -2786,12 +2786,12 @@ * g++.dg/vect/simd-bool-comparison-1.cc: New test. * g++.dg/vect/simd-bool-comparison-2.cc: New test. -2015-11-13 Dominique d'Humieres +2015-11-13 Dominique d'Humieres PR fortran/47266 * gfortran.dg/module_private_2.f90: New test. -2015-11-13 Dominique d'Humieres +2015-11-13 Dominique d'Humieres PR fortran/47266 * gfortran.dg/warn_unused_function_2.f90: New test. @@ -7096,7 +7096,7 @@ * g++.dg/lto/pr68057_0.C: Fix testcase. -2015-11-08 Joost VandeVondele +2015-11-08 Joost VandeVondele * gfortran.dg/PR67518.f90: move from here... * gfortran.dg/graphite/PR67518.f90: to here. @@ -7179,7 +7179,7 @@ * gcc.target/arm/mincmp.c: New test. -2015-11-06 Dominique d'Humieres +2015-11-06 Dominique d'Humieres PR fortran/54224 * gfortran.dg/warn_unused_function_2.f90: Add two new @@ -7440,7 +7440,7 @@ PR c++-common/67882 * c-c++-common/builtin-offsetof-2.c: New test. -2015-11-03 Dominique d'Humieres +2015-11-03 Dominique d'Humieres PR fortran/67982 * gfortran.dg/warn_unused_function_3.f90: New test. @@ -7495,7 +7495,7 @@ * g++.dg/ext/mvc1.C: Require ifunc. -2015-11-02 Alexandre Oliva +2015-11-02 Alexandre Oliva PR tree-optimization/68083 * gcc.dg/torture/pr68083.c: New. From Zhendong Su. @@ -7704,7 +7704,7 @@ * c-c++-common/goacc/loop-shape.c: New test. -2015-10-27 Nathan Sidwell +2015-10-27 Nathan Sidwell Cesar Philippidis * g++.dg/gomp/pr33372-1.C: Adjust diagnostic. @@ -7953,7 +7953,7 @@ * gcc.dg/torture/pr67736.c: New test. * gcc.dg/combine-subregs.c: New test. -2015-10-23 Alan Hayward +2015-10-23 Alan Hayward PR tree-optimization/65947 * lib/target-supports.exp @@ -8306,7 +8306,7 @@ * g++.dg/cpp1z/fold-ice1.C: New. 2015-10-16 Michael Collison - Andrew Pinski + Andrew Pinski * gcc.dg/tree-ssa/minmax-loopend.c: New test. @@ -8521,7 +8521,7 @@ * gcc.dg/ipa/ipa-sra-10.c: New test. * gcc.dg/torture/pr67794.c: Likewise. -2015-10-09 Alexandre Oliva +2015-10-09 Alexandre Oliva PR rtl-optimization/67828 * gcc.dg/torture/pr67828.c: New. @@ -8594,7 +8594,7 @@ * c-c++-common/Wtautological-compare-4.c: New test. 2015-10-05 Michael Meissner - Peter Bergner + Peter Bergner PR target/67808 * gcc.target/powerpc/pr67808.c: New test. @@ -9032,7 +9032,7 @@ * g++.dg/debug/dwarf2/pr44641.C: Revert line number change. Remove skip on AIX. XFAIL individual line tests. -2015-09-27 Alexandre Oliva +2015-09-27 Alexandre Oliva PR rtl-optimization/64164 PR tree-optimization/67312 @@ -9146,7 +9146,7 @@ PR libgcc/67624 * gcc.target/arm/fp16-inf.c: New test. -2015-09-24 Kirill Yukhin +2015-09-24 Kirill Yukhin * gcc.target/i386/avx512vbmi-check.h (main): Fix register name while checking for AVX-512VBMI presence. @@ -9206,12 +9206,12 @@ PR tree-optimization/67671 * g++.dg/pr67671.C: New test. -2015-09-22 Alexander Fomin +2015-09-22 Alexander Fomin PR target/67480 * gcc.target/i386/pr67480.c: New test. -2015-09-22 Kirill Yukhin +2015-09-22 Kirill Yukhin * gcc.target/i386/funcspec-5.c: Test avx512vl, avx512bw, avx512dq, avx512cd, avx512er, avx512pf and skylake-avx512. @@ -9903,7 +9903,7 @@ 2015-09-04 Andrey Turetskiy Petr Murzin - Kirill Yukhin + Kirill Yukhin * gcc.target/i386/avx512f-scatter-1.c: New. * gcc.target/i386/avx512f-scatter-2.c: Ditto. @@ -9977,7 +9977,7 @@ * lib/tsan-dg.exp: Likewise. * lib/ubsan-dg.exp: Likewise. -2015-09-01 Kenneth Zadeck +2015-09-01 Kenneth Zadeck * gcc.c-torture/execute/ieee/20000320-1.c Fixed misplaced test case. @@ -10034,7 +10034,7 @@ * gcc.dg/vect/no-scevccp-outer-11.c: Don't xfail scan-tree-dump-times. -2015-09-01 Kyrylo Tkachov +2015-09-01 Kyrylo Tkachov * gcc.dg/ifcvt-1.c: New test. * gcc.dg/ifcvt-2.c: Likewise. @@ -10257,7 +10257,7 @@ PR target/67211 * g++.dg/pr67211.C: New test. -2015-08-24 Louis Krupp +2015-08-24 Louis Krupp PR fortran/62536 PR fortran/66175 @@ -11069,7 +11069,7 @@ * jit.dg/test-error-gcc_jit_timer_pop-mismatch.c: New test case. * jit.dg/test-error-gcc_jit_timer_pop-too-many.c: New test case. -2015-08-03 Alexander Basov +2015-08-03 Alexander Basov PR middle-end/64744 PR middle-end/48470 @@ -12424,7 +12424,7 @@ * gcc.dg/vect/pr48052.c: Use dg-require-effective-target vect_int_mult. 2015-07-05 Chung-Lin Tang - Sandra Loosemore + Sandra Loosemore * gcc.target/nios2/gprel-offset.c: New test. @@ -14580,7 +14580,7 @@ * lib/target-supports.exp (check_effective_target_pie): Add *-*-freebsd* to the family of pie capable targets. -2015-05-18 Alex Velenko +2015-05-18 Alex Velenko * gcc.target/arm/bics_1.c : New testcase. * gcc.target/arm/bics_2.c : New testcase. @@ -14765,7 +14765,7 @@ * c-c++-common/Wmisleading-indentation-2.c: New testcase. * c-c++-common/Wmisleading-indentation-2.md: New file. -2015-05-12 Sandra Loosemore +2015-05-12 Sandra Loosemore * gcc.target/nios2/nios2-trap-insn.c: Expect "trap" instead of "break". @@ -15332,7 +15332,7 @@ PR tree-optimization/65851 * g++.dg/torture/pr65851.C: New testcase. -2015-04-27 Jeff Law +2015-04-27 Jeff Law PR tree-optimization/65217 * gcc.target/i386/pr65217.c: Remove XFAIL. @@ -15419,7 +15419,7 @@ * c-c++-common/pr61534-1.c: New test. 2015-04-24 Thomas Preud'homme - Steven Bosscher + Steven Bosscher PR rtl-optimization/34503 * gcc.target/arm/pr64616.c: New file. @@ -15583,7 +15583,7 @@ PR rtl-optimization/64818 * gcc.target/arm/pr64818.c: New test. -2015-04-21 Jan Hubicka +2015-04-21 Jan Hubicka PR ipa/65076 * g++.dg/tree-ssa/pr61034.C: Update template. @@ -15591,7 +15591,7 @@ * gcc.dg/Warray-bounds-11.c: Likewise. * gcc.dg/Warray-bounds.c: Likewise. -2015-04-21 Jerry DeLisle +2015-04-21 Jerry DeLisle PR libgfortran/65234 * gfortran.dg/fmt_unlimited.f90: New test. @@ -15608,7 +15608,7 @@ * gcc.target/i386/avx512vbmi-vpermi2b-2.c: Likewise. * gcc.target/i386/avx512vbmi-vpermt2b-2.c: Likewise. -2015-04-21 Jerry DeLisle +2015-04-21 Jerry DeLisle PR libgfortran/56743 * gfortran.dg/namelist_87.f90: New test. @@ -16241,7 +16241,7 @@ PR libgfortran/65563 * gfortran.dg/open_errors_2.f90: New test. -2015-03-28 Jerry DeLisle +2015-03-28 Jerry DeLisle PR libgfortran/65596 * gfortran.dg/namelist_86.f90: New test. @@ -16670,7 +16670,7 @@ PR c++/65340 * g++.dg/cpp1y/pr65340.C: New. -2015-03-17 Jerry DeLisle +2015-03-17 Jerry DeLisle PR fortran/64432 * gfortran.dg/system_clock_3.f08: Adjust test. @@ -16681,7 +16681,7 @@ * gfortran.dg/proc_ptr_comp_44.f90: New test. * gfortran.dg/proc_ptr_comp_45.f90: New test. -2015-03-16 Jerry DeLisle +2015-03-16 Jerry DeLisle PR fortran/64432 * gfortran.dg/system_clock_3.f08: New test. @@ -17450,7 +17450,7 @@ PR ipa/65236 * g++.dg/ipa/ipa-icf-6.C: New testcase. -2015-02-27 Pat Haugen +2015-02-27 Pat Haugen * gcc.dg/vect/pr59354.c: Move vector producing code to separate function. @@ -19523,7 +19523,7 @@ * gcc.dg/tree-ssa/pr61743-1.c: Add -fno-tree-vectorize. * gcc.dg/tree-ssa/pr61743-2.c: Likewise. -2015-01-16 Zhenqiang Chen +2015-01-16 Zhenqiang Chen * gcc.dg/pr64015.c: New test. @@ -19761,7 +19761,7 @@ * gcc.dg/tree-ssa/pr61743-1.c: New testcase. * gcc.dg/tree-ssa/pr61743-2.c: Likewise. -2015-01-15 Renlin Li +2015-01-15 Renlin Li * gcc.target/aarch64/volatileloadpair-1.c: Correct dg-options. * gcc.target/aarch64/volatileloadpair-2.c: Likewise. @@ -19833,7 +19833,7 @@ PR middle-end/64365 * gcc.dg/torture/pr64365.c: New testcase. -2015-01-14 Marcos Diaz +2015-01-14 Marcos Diaz * gcc.dg/stackprotectexplicit1.c: New test. * g++.dg/stackprotectexplicit2.c: New test. @@ -19942,7 +19942,7 @@ * gcc.dg/vect/pr64493.c: New testcase. * gcc.dg/vect/pr64495.c: Likewise. -2015-01-13 Martin Uecker +2015-01-13 Martin Uecker * gcc.dg/Warray-bounds-11.c: New test-case. @@ -20417,7 +20417,7 @@ * gcc.dg/tree-ssa/loop-1.c: Likewise. * gcc.dg/weak/typeof-2.c: Likewise. -2015-01-05 Radovan Obradovic +2015-01-05 Radovan Obradovic PR rtl-optimization/64287 * gcc.dg/aru-2.c: New test. diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-3.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-3.c new file mode 100644 index 000000000000..277a3885e219 --- /dev/null +++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-3.c @@ -0,0 +1,82 @@ +/* Verify -Wmisleading-indentation with source-printing. + This is a subset of Wmisleading-indentation.c. */ + +/* { dg-options "-Wmisleading-indentation -fdiagnostics-show-caret" } */ +/* { dg-do compile } */ + +extern int foo (int); +extern int bar (int, int); +extern int flagA; +extern int flagB; +extern int flagC; +extern int flagD; + +void +fn_5 (double *a, double *b, double *sum, double *prod) +{ + int i = 0; + for (i = 0; i < 10; i++) /* { dg-warning "3: this 'for' clause does not guard..." } */ + sum[i] = a[i] * b[i]; + prod[i] = a[i] * b[i]; /* { dg-message "5: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'for'" } */ +/* { dg-begin-multiline-output "" } + for (i = 0; i < 10; i++) + ^~~ + { dg-end-multiline-output "" } */ +/* { dg-begin-multiline-output "" } + prod[i] = a[i] * b[i]; + ^~~~ + { dg-end-multiline-output "" } */ +} + +/* Based on CVE-2014-1266 aka "goto fail" */ +int fn_6 (int a, int b, int c) +{ + int err; + + /* ... */ + if ((err = foo (a)) != 0) + goto fail; + if ((err = foo (b)) != 0) /* { dg-message "2: this 'if' clause does not guard..." } */ + goto fail; + goto fail; /* { dg-message "3: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'if'" } */ + if ((err = foo (c)) != 0) + goto fail; + /* ... */ + +/* { dg-begin-multiline-output "" } + if ((err = foo (b)) != 0) + ^~ + { dg-end-multiline-output "" } */ +/* { dg-begin-multiline-output "" } + goto fail; + ^~~~ + { dg-end-multiline-output "" } */ + +fail: + return err; +} + +#define FOR_EACH(VAR, START, STOP) \ + for ((VAR) = (START); (VAR) < (STOP); (VAR++)) /* { dg-warning "3: this 'for' clause does not guard..." } */ + +void fn_14 (void) +{ + int i; + FOR_EACH (i, 0, 10) /* { dg-message "in expansion of macro .FOR_EACH." } */ + foo (i); + bar (i, i); /* { dg-message "5: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'for'" } */ + +/* { dg-begin-multiline-output "" } + for ((VAR) = (START); (VAR) < (STOP); (VAR++)) + ^ + { dg-end-multiline-output "" } */ +/* { dg-begin-multiline-output "" } + FOR_EACH (i, 0, 10) + ^~~~~~~~ + { dg-end-multiline-output "" } */ +/* { dg-begin-multiline-output "" } + bar (i, i); + ^~~ + { dg-end-multiline-output "" } */ +} +#undef FOR_EACH diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation.c index 25db8fe8412f..dcc66e7f6fc8 100644 --- a/gcc/testsuite/c-c++-common/Wmisleading-indentation.c +++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation.c @@ -12,17 +12,17 @@ int fn_1 (int flag) { int x = 4, y = 5; - if (flag) /* { dg-message "3: ...this 'if' clause, but it is not" } */ + if (flag) /* { dg-warning "3: this 'if' clause does not guard..." } */ x = 3; - y = 2; /* { dg-warning "statement is indented as if it were guarded by..." } */ + y = 2; /* { dg-message "5: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'if'" } */ return x * y; } int fn_2 (int flag, int x, int y) { - if (flag) /* { dg-message "3: ...this 'if' clause, but it is not" } */ - x++; y++; /* { dg-warning "statement is indented as if it were guarded by..." } */ + if (flag) /* { dg-warning "3: this 'if' clause does not guard..." } */ + x++; y++; /* { dg-message "10: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'if'" } */ return x * y; } @@ -33,9 +33,9 @@ fn_3 (int flag) int x = 4, y = 5; if (flag) x = 3; - else /* { dg-message "3: ...this 'else' clause, but it is not" } */ + else /* { dg-warning "3: this 'else' clause does not guard..." } */ x = 2; - y = 2; /* { dg-warning "statement is indented as if it were guarded by..." } */ + y = 2; /* { dg-message "5: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'else'" } */ return x * y; } @@ -43,18 +43,18 @@ void fn_4 (double *a, double *b, double *c) { int i = 0; - while (i < 10) /* { dg-message "3: ...this 'while' clause, but it is not" } */ + while (i < 10) /* { dg-warning "3: this 'while' clause does not guard..." } */ a[i] = b[i] * c[i]; - i++; /* { dg-warning "statement is indented as if it were guarded by..." } */ + i++; /* { dg-message "5: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'while'" } */ } void fn_5 (double *a, double *b, double *sum, double *prod) { int i = 0; - for (i = 0; i < 10; i++) /* { dg-output "3: ...this 'for' clause, but it is not" } */ + for (i = 0; i < 10; i++) /* { dg-warning "3: this 'for' clause does not guard..." } */ sum[i] = a[i] * b[i]; - prod[i] = a[i] * b[i]; /* { dg-warning "statement is indented as if it were guarded by..." } */ + prod[i] = a[i] * b[i]; /* { dg-message "5: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'for'" } */ } /* Based on CVE-2014-1266 aka "goto fail" */ @@ -65,9 +65,9 @@ int fn_6 (int a, int b, int c) /* ... */ if ((err = foo (a)) != 0) goto fail; - if ((err = foo (b)) != 0) /* { dg-message "2: ...this 'if' clause, but it is not" } */ + if ((err = foo (b)) != 0) /* { dg-message "2: this 'if' clause does not guard..." } */ goto fail; - goto fail; /* { dg-warning "statement is indented as if it were guarded by..." } */ + goto fail; /* { dg-message "3: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'if'" } */ if ((err = foo (c)) != 0) goto fail; /* ... */ @@ -80,8 +80,8 @@ int fn_7 (int p, int q, int r, int s, int t) { if (bar (p, q)) { - if (p) /* { dg-message "7: ...this 'if' clause, but it is not" } */ - q++; r++; /* { dg-warning "statement is indented as if it were guarded by..." } */ + if (p) /* { dg-message "7: this 'if' clause does not guard..." } */ + q++; r++; /* { dg-message "14: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'if'" } */ t++; } return p + q + r + s + t; @@ -95,20 +95,20 @@ int fn_8 (int a, int b, int c) void fn_9 (int flag) { - if (flag) /* { dg-message "3: ...this 'if' clause, but it is not" } */ + if (flag) /* { dg-warning "3: this 'if' clause does not guard..." } */ foo (0); - foo (1); /* { dg-warning "statement is indented as if it were guarded by..." } */ + foo (1); /* { dg-message "5: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'if'" } */ } void fn_10 (int flag) { - if (flag) /* { dg-message "3: ...this 'if' clause, but it is not" } */ + if (flag) /* { dg-warning "3: this 'if' clause does not guard..." } */ if (flag / 2) { foo (0); foo (1); } - foo (2); /* { dg-warning "statement is indented as if it were guarded by..." } */ + foo (2); /* { dg-message "5: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'if'" } */ foo (3); } @@ -116,48 +116,48 @@ void fn_11 (void) { if (flagA) if (flagB) - if (flagC) /* { dg-message "7: ...this 'if' clause, but it is not" } */ + if (flagC) /* { dg-message "7: this 'if' clause does not guard..." } */ foo (0); - bar (1, 2); /* { dg-warning "statement is indented as if it were guarded by..." } */ + bar (1, 2); /* { dg-message "9: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'if'" } */ } void fn_12 (void) { if (flagA) - if (flagB) /* { dg-message "5: ...this 'if' clause, but it is not" } */ + if (flagB) /* { dg-message "5: this 'if' clause does not guard..." } */ if (flagC) foo (0); - bar (1, 2); /* { dg-warning "statement is indented as if it were guarded by..." } */ + bar (1, 2); /* { dg-message "7: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'if'" } */ } void fn_13 (void) { - if (flagA) /* { dg-message "3: ...this 'if' clause, but it is not" } */ + if (flagA) /* { dg-warning "3: this 'if' clause does not guard..." } */ if (flagB) if (flagC) foo (0); - bar (1, 2); /* { dg-warning "statement is indented as if it were guarded by..." } */ + bar (1, 2); /* { dg-message "5: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'if'" } */ } #define FOR_EACH(VAR, START, STOP) \ - for ((VAR) = (START); (VAR) < (STOP); (VAR++)) /* { dg-message "3: ...this 'for' clause, but it is not" } */ + for ((VAR) = (START); (VAR) < (STOP); (VAR++)) /* { dg-warning "3: this 'for' clause does not guard..." } */ void fn_14 (void) { int i; - FOR_EACH (i, 0, 10) /* { dg-message "3: in expansion of macro" } */ + FOR_EACH (i, 0, 10) /* { dg-message "in expansion of macro .FOR_EACH." } */ foo (i); - bar (i, i); /* { dg-warning "statement is indented as if it were guarded by..." } */ + bar (i, i); /* { dg-message "5: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'for'" } */ } #undef FOR_EACH -#define FOR_EACH(VAR, START, STOP) for ((VAR) = (START); (VAR) < (STOP); (VAR++)) /* { dg-message "36: ...this 'for' clause, but it is not" } */ +#define FOR_EACH(VAR, START, STOP) for ((VAR) = (START); (VAR) < (STOP); (VAR++)) /* { dg-message "36: this 'for' clause does not guard..." } */ void fn_15 (void) { int i; - FOR_EACH (i, 0, 10) /* { dg-message "3: in expansion of macro" } */ + FOR_EACH (i, 0, 10) /* { dg-message "in expansion of macro .FOR_EACH." } */ foo (i); - bar (i, i); /* { dg-warning "statement is indented as if it were guarded by..." } */ + bar (i, i); /* { dg-message "5: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'for'" } */ } #undef FOR_EACH @@ -166,9 +166,9 @@ void fn_16_spaces (void) int i; for (i = 0; i < 10; i++) while (flagA) - if (flagB) /* { dg-message "7: ...this 'if' clause, but it is not" } */ + if (flagB) /* { dg-message "7: this 'if' clause does not guard..." } */ foo (0); - foo (1); /* { dg-warning "statement is indented as if it were guarded by..." } */ + foo (1); /* { dg-message "9: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'if'" } */ } void fn_16_tabs (void) @@ -176,49 +176,49 @@ void fn_16_tabs (void) int i; for (i = 0; i < 10; i++) while (flagA) - if (flagB) /* { dg-message "7: ...this 'if' clause, but it is not" } */ + if (flagB) /* { dg-message "7: this 'if' clause does not guard..." } */ foo (0); - foo (1);/* { dg-warning "statement is indented as if it were guarded by..." } */ + foo (1);/* { dg-message "2: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'if'" } */ } void fn_17_spaces (void) { int i; - for (i = 0; i < 10; i++) /* { dg-message "3: ...this 'for' clause, but it is not" } */ + for (i = 0; i < 10; i++) /* { dg-warning "3: this 'for' clause does not guard..." } */ while (flagA) if (flagB) foo (0); - foo (1);/* { dg-warning "statement is indented as if it were guarded by..." } */ + foo (1);/* { dg-message "5: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'for'" } */ } void fn_17_tabs (void) { int i; - for (i = 0; i < 10; i++) /* { dg-message "3: ...this 'for' clause, but it is not" } */ + for (i = 0; i < 10; i++) /* { dg-warning "3: this 'for' clause does not guard..." } */ while (flagA) if (flagB) foo (0); - foo (1);/* { dg-warning "statement is indented as if it were guarded by..." } */ + foo (1);/* { dg-message "5: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'for'" } */ } void fn_18_spaces (void) { int i; for (i = 0; i < 10; i++) - while (flagA) /* { dg-message "5: ...this 'while' clause, but it is not" } */ + while (flagA) /* { dg-message "5: this 'while' clause does not guard..." } */ if (flagB) foo (0); - foo (1);/* { dg-warning "statement is indented as if it were guarded by..." } */ + foo (1);/* { dg-message "7: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'while'" } */ } void fn_18_tabs (void) { int i; for (i = 0; i < 10; i++) - while (flagA) /* { dg-message "5: ...this 'while' clause, but it is not" } */ + while (flagA) /* { dg-message "5: this 'while' clause does not guard..." } */ if (flagB) foo (0); - foo (1);/* { dg-warning "statement is indented as if it were guarded by..." } */ + foo (1);/* { dg-message "7: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'while'" } */ } /* This shouldn't lead to a warning. */ @@ -701,108 +701,108 @@ fn_37 (void) int i; #define EMPTY -#define FOR_EACH(VAR, START, STOP) for (VAR = START; VAR < STOP; VAR++) +#define FOR_EACH(VAR, START, STOP) for (VAR = START; VAR < STOP; VAR++) /* { dg-warning "this 'for' clause" } */ - while (flagA); /* { dg-message "3: ...this 'while' clause" } */ - foo (0); /* { dg-warning "statement is indented as if" } */ + while (flagA); /* { dg-warning "3: this 'while' clause" } */ + foo (0); /* { dg-message "5: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'while'" } */ if (flagA) ; - else if (flagB); /* { dg-message "8: ...this 'if' clause" } */ - foo (0); /* { dg-warning "statement is indented as if" } */ - while (flagA) /* { dg-message "3: ...this 'while' clause" } */ + else if (flagB); /* { dg-warning "8: this 'if' clause" } */ + foo (0); /* { dg-message "5: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'if'" } */ + while (flagA) /* { dg-warning "3: this 'while' clause" } */ /* blah */; - foo (0); /* { dg-warning "statement is indented as if" } */ + foo (0); /* { dg-message "5: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'while'" } */ if (flagA) ; - else if (flagB) /* { dg-message "8: ...this 'if' clause" } */ + else if (flagB) /* { dg-warning "8: this 'if' clause" } */ foo (1); - foo (2); /* { dg-warning "statement is indented as if" } */ + foo (2); /* { dg-message "5: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'if'" } */ if (flagA) foo (1); - else if (flagB) /* { dg-message "8: ...this 'if' clause" } */ + else if (flagB) /* { dg-warning "8: this 'if' clause" } */ foo (2); - foo (3); /* { dg-warning "statement is indented as if" } */ + foo (3); /* { dg-message "5: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'if'" } */ - if (flagB) /* { dg-message "3: ...this 'if' clause" } */ + if (flagB) /* { dg-warning "3: this 'if' clause" } */ /* blah */; - { /* { dg-warning "statement is indented as if" } */ + { /* { dg-message "5: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'if'" } */ foo (0); } - if (flagB) /* { dg-message "3: ...this 'if' clause" } */ + if (flagB) /* { dg-warning "3: this 'if' clause" } */ /* blah */; - { /* { dg-warning "statement is indented as if" } */ + { /* { dg-message "4: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'if'" } */ foo (0); } if (flagB) ; - else; foo (0); /* { dg-warning "statement is indented as if" } */ + else; foo (0); /* { dg-warning "3: this 'else' clause" } */ - if (flagC); foo (2); /* { dg-warning "statement is indented as if" } */ + if (flagC); foo (2); /* { dg-warning "3: this 'if' clause" } */ - if (flagA) - ; /* blah */ { /* { dg-warning "statement is indented as if" } */ + if (flagA) /* { dg-warning "3: this 'if' clause" } */ + ; /* blah */ { /* { dg-message "18: ...this statement" } */ foo (1); } - if (flagB) ; /* { dg-message "3: ...this 'if' clause" } */ - return; /* { dg-warning "statement is indented as if" } */ + if (flagB) ; /* { dg-warning "3: this 'if' clause" } */ + return; /* { dg-message "5: ...this statement" } */ - if (flagB) EMPTY; /* { dg-message "3: ...this 'if' clause" } */ - foo (1); /* { dg-warning "statement is indented as if" } */ + if (flagB) EMPTY; /* { dg-warning "3: this 'if' clause" } */ + foo (1); /* { dg-message "5: ...this statement" } */ - for (i = 0; i < 10; i++); /* { dg-message "3: ...this 'for' clause" } */ - foo (2); /* { dg-warning "statement is indented as if" } */ + for (i = 0; i < 10; i++); /* { dg-warning "3: this 'for' clause" } */ + foo (2); /* { dg-message "5: ...this statement" } */ - FOR_EACH (i, 0, 10); - foo (2); /* { dg-warning "statement is indented as if" } */ + FOR_EACH (i, 0, 10); /* { dg-message "3: in expansion of macro .FOR_EACH." } */ + foo (2); /* { dg-message "5: ...this statement" } */ - FOR_EACH (i, 0, 10); - { /* { dg-warning "statement is indented as if" } */ + FOR_EACH (i, 0, 10); /* { dg-message "3: in expansion of macro .FOR_EACH." } */ + { /* { dg-message "5: ...this statement" } */ foo (3); } - FOR_EACH (i, 0, 10); - { /* { dg-warning "statement is indented as if" } */ + FOR_EACH (i, 0, 10); /* { dg-message "3: in expansion of macro .FOR_EACH." } */ + { /* { dg-message "3: ...this statement" } */ foo (3); } - while (i++); { /* { dg-warning "statement is indented as if" } */ + while (i++); { /* { dg-warning "3: this 'while' clause" } */ foo (3); } - if (i++); { /* { dg-warning "statement is indented as if" } */ + if (i++); { /* { dg-warning "3: this 'if' clause" } */ foo (3); } if (flagA) { foo (1); - } else /* { dg-message "5: ...this 'else' clause" } */ + } else /* { dg-warning "5: this 'else' clause" } */ if (flagB) foo (2); - foo (3); /* { dg-warning "statement is indented as if" } */ + foo (3); /* { dg-message "5: ...this statement" } */ if (flagA) foo (1); - else if (flagB); /* { dg-message "8: ...this 'if' clause" } */ - foo (2); /* { dg-warning "statement is indented as if" } */ + else if (flagB); /* { dg-warning "8: this 'if' clause" } */ + foo (2); /* { dg-message "5: ...this statement" } */ - for (i = 0; /* { dg-message "3: ...this 'for' clause" } */ + for (i = 0; /* { dg-warning "3: this 'for' clause" } */ i < 10; i++); - foo (i); /* { dg-warning "statement is indented as if" } */ + foo (i); /* { dg-message "5: ...this statement" } */ if (flagA) { foo (1); } - else if (flagB); /* { dg-message "8: ...this 'if' clause" } */ - { /* { dg-warning "statement is indented as if" } */ + else if (flagB); /* { dg-warning "8: this 'if' clause" } */ + { /* { dg-message "3: ...this statement" } */ foo (2); } @@ -903,3 +903,338 @@ void pr69122 (void) emit foo (1); } #undef emit + +/* In the following, the 'if' within the 'for' statement is not indented, + but arguably should be. + The for loop: + "for (cnt = 0; cnt < thousands_len; ++cnt)" + does not guard this conditional: + "cnt < thousands_len;". + and the poor indentation is not misleading. Verify that we do + not erroneously emit a warning about this. + Based on an example seen in glibc (PR c/68187). */ + +void +fn_40_a (const char *end, const char *thousands, int thousands_len) +{ + int cnt; + + while (flagA) + if (flagA + && ({ for (cnt = 0; cnt < thousands_len; ++cnt) + if (thousands[cnt] != end[cnt]) + break; + cnt < thousands_len; }) + && flagB) + break; +} + +/* As above, but with the indentation within the "for" loop fixed. + We should not emit a warning for this, either. */ + +void +fn_40_b (const char *end, const char *thousands, int thousands_len) +{ + int cnt; + + while (flagA) + if (flagA + && ({ for (cnt = 0; cnt < thousands_len; ++cnt) + if (thousands[cnt] != end[cnt]) + break; + cnt < thousands_len; }) + && flagB) + break; +} + +/* We should not warn for the following + (based on libstdc++-v3/src/c++11/random.cc:random_device::_M_init). */ + +void +fn_41_a (void) +{ + if (flagA) + { + } + else if (flagB) + fail: + foo (0); + + foo (1); + if (!flagC) + goto fail; +} + +/* Tweaked version of the above (with the label indented), which we should + also not warn for. */ + +void +fn_41_b (void) +{ + if (flagA) + { + } + else if (flagB) + fail: + foo (0); + + foo (1); + if (!flagC) + goto fail; +} + +/* In the following, the + "if (i > 0)" + is poorly indented, and ought to be on the same column as + "engine_ref_debug(e, 0, -1)" + However, it is not misleadingly indented, due to the presence + of that macro. Verify that we do not emit a warning about it + not being guarded by the "else" clause above. + + Based on an example seen in OpenSSL 1.0.1, which was filed as + PR c/68187 in comment #1, though it's arguably a separate bug to + the one in comment #0. */ + +int +fn_42_a (int locked) +{ +#define engine_ref_debug(X, Y, Z) + + int i; + + if (locked) + i = foo (0); + else + i = foo (1); + engine_ref_debug(e, 0, -1) + if (i > 0) + return 1; + return 0; +#undef engine_ref_debug +} + +/* As above, but the empty macro is at the same indentation level. + This *is* misleading; verify that we do emit a warning about it. */ + +int +fn_42_b (int locked) +{ +#define engine_ref_debug(X, Y, Z) + + int i; + + if (locked) + i = foo (0); + else /* { dg-warning "this .else. clause" } */ + i = foo (1); + engine_ref_debug(e, 0, -1) + if (i > 0) /* { dg-message "...this statement" } */ + return 1; + return 0; +#undef engine_ref_debug +} + +/* As above, but where the body is a semicolon "hidden" by a preceding + comment, where the semicolon is not in the same column as the successor + "if" statement, but the empty macro expansion is at the same indentation + level as the guard. + This is poor indentation, but not misleading; verify that we don't emit a + warning about it. */ + +int +fn_42_c (int locked, int i) +{ +#define engine_ref_debug(X, Y, Z) + + if (locked) + /* blah */; + engine_ref_debug(e, 0, -1) + if (i > 0) + return 1; + return 0; +#undef engine_ref_debug +} + +/* We shouldn't complain about the following function. */ +#define ENABLE_FEATURE +int pr70085 (int x, int y) +{ + if (x > y) + return x - y; + + #ifdef ENABLE_FEATURE + if (x == y) + return 0; + #endif + + return -1; +} +#undef ENABLE_FEATURE + +/* Additional test coverage for PR c/68187, with various locations for a + pair of aligned statements ("foo (2);" and "foo (3);") that may or may + not be misleadingly indented. */ + +/* Before the "}". + + The two statements aren't visually "within" the above line, so we + shouldn't warn. */ + +void +test43_a (void) +{ + if (flagA) { + foo (1); + } else if (flagB) + foo (2); + foo (3); +} + +/* Aligned with the "}". + + Again, the two statements aren't visually "within" the above line, so we + shouldn't warn. */ + +void +test43_b (void) +{ + if (flagA) { + foo (1); + } else if (flagB) + foo (2); + foo (3); +} + +/* Indented between the "}" and the "else". + + The two statements are indented "within" the line above, so appear that + they would be guarded together. We should warn about this. */ + +void +test43_c (void) +{ + if (flagA) { + foo (1); + } else if (flagB) /* { dg-message "...this .if. clause" } */ + foo (2); + foo (3); /* { dg-message "...this statement" } */ +} + +/* Aligned with the "else". Likewise, we should warn. */ + +void +test43_d (void) +{ + if (flagA) { + foo (1); + } else if (flagB) /* { dg-message "...this .if. clause" } */ + foo (2); + foo (3); /* { dg-message "...this statement" } */ +} + +/* Indented between the "else" and the "if". Likewise, we should warn. */ + +void +test43_e (void) +{ + if (flagA) { + foo (1); + } else if (flagB) /* { dg-message "...this .if. clause" } */ + foo (2); + foo (3); /* { dg-message "...this statement" } */ +} + +/* Aligned with the "if". Likewise, we should warn. */ + +void +test43_f (void) +{ + if (flagA) { + foo (1); + } else if (flagB) /* { dg-warning "this .else. clause" } */ + foo (2); + foo (3); /* { dg-message "...this statement" } */ +} + +/* Indented more than the "if". Likewise, we should warn. */ + +void +test43_g (void) +{ + if (flagA) { + foo (1); + } else if (flagB) /* { dg-message "...this .if. clause" } */ + foo (2); + foo (3); /* { dg-message "...this statement" } */ +} + +/* Again, but without the 2nd "if". */ + +/* Before the "}". + + As before, the two statements aren't visually "within" the above line, + so we shouldn't warn. */ + +void +test44_a (void) +{ + if (flagA) { + foo (1); + } else + foo (2); + foo (3); +} + +/* Aligned with the "}". + + As before, the two statements aren't visually "within" the above line, + so we shouldn't warn. */ + +void +test44_b (void) +{ + if (flagA) { + foo (1); + } else + foo (2); + foo (3); +} + +/* Indented between the "}" and the "else". + + The two statements are indented "within" the line above, so appear that + they would be guarded together. We should warn about this. */ + +void +test44_c (void) +{ + if (flagA) { + foo (1); + } else /* { dg-warning "this .else. clause" } */ + foo (2); + foo (3); /* { dg-message "...this statement" } */ +} + +/* Aligned with the "else". Likewise, we should warn. */ + +void +test44_d (void) +{ + if (flagA) { + foo (1); + } else /* { dg-warning "this .else. clause" } */ + foo (2); + foo (3); /* { dg-message "...this statement" } */ +} + +/* Indented more than the "else". Likewise, we should warn. */ + +void +test44_e (void) +{ + if (flagA) { + foo (1); + } else /* { dg-warning "this .else. clause" } */ + foo (2); + foo (3); /* { dg-message "...this statement" } */ +} diff --git a/gcc/testsuite/c-c++-common/asan/swapcontext-test-1.c b/gcc/testsuite/c-c++-common/asan/swapcontext-test-1.c index 23d3db0655b8..555f2d9bb409 100644 --- a/gcc/testsuite/c-c++-common/asan/swapcontext-test-1.c +++ b/gcc/testsuite/c-c++-common/asan/swapcontext-test-1.c @@ -52,9 +52,9 @@ volatile int zero = 0; int main(int argc, char **argv) { int ret = 0; ret += Run(zero, 0); - printf("Test1 passed\n"); + fprintf(stderr, "Test1 passed\n"); ret += Run(zero, 1); - printf("Test2 passed\n"); + fprintf(stderr, "Test2 passed\n"); return ret; } diff --git a/gcc/testsuite/c-c++-common/goacc-gomp/nesting-fail-1.c b/gcc/testsuite/c-c++-common/goacc-gomp/nesting-fail-1.c index 1a4472107c67..5e3f183998a3 100644 --- a/gcc/testsuite/c-c++-common/goacc-gomp/nesting-fail-1.c +++ b/gcc/testsuite/c-c++-common/goacc-gomp/nesting-fail-1.c @@ -439,3 +439,11 @@ f_acc_loop (void) #pragma omp target update to(i) /* { dg-error "non-OpenACC construct inside of OpenACC region" } */ } } + +#pragma acc routine +void +f_acc_routine (void) +{ +#pragma omp target /* { dg-error "non-OpenACC construct inside of OpenACC routine" } */ + ; +} diff --git a/gcc/testsuite/c-c++-common/goacc/combined-directives-2.c b/gcc/testsuite/c-c++-common/goacc/combined-directives-2.c new file mode 100644 index 000000000000..c51e2f9c75b8 --- /dev/null +++ b/gcc/testsuite/c-c++-common/goacc/combined-directives-2.c @@ -0,0 +1,14 @@ +/* Ensure that bogus clauses aren't propagated in combined loop + constructs. */ + +int +main () +{ + int a, i; + +#pragma acc parallel loop vector copy(a[0:100]) reduction(+:a) /* { dg-error "'a' does not have pointer or array type" } */ + for (i = 0; i < 100; i++) + a++; + + return a; +} diff --git a/gcc/testsuite/c-c++-common/goacc/kernels-default.c b/gcc/testsuite/c-c++-common/goacc/kernels-default.c index 58cd5e10a5b3..cb031c11a34b 100644 --- a/gcc/testsuite/c-c++-common/goacc/kernels-default.c +++ b/gcc/testsuite/c-c++-common/goacc/kernels-default.c @@ -4,7 +4,7 @@ void foo (void) { - unsigned int i; + unsigned int i = 0; #pragma acc kernels { i++; diff --git a/gcc/testsuite/c-c++-common/goacc/nesting-fail-1.c b/gcc/testsuite/c-c++-common/goacc/nesting-fail-1.c index 7a36074ae384..506a1aeaa6a9 100644 --- a/gcc/testsuite/c-c++-common/goacc/nesting-fail-1.c +++ b/gcc/testsuite/c-c++-common/goacc/nesting-fail-1.c @@ -37,3 +37,11 @@ f_acc_kernels (void) #pragma acc exit data delete(i) /* { dg-error ".enter/exit data. construct inside of .kernels. region" } */ } } + +#pragma acc routine +void +f_acc_routine (void) +{ +#pragma acc parallel /* { dg-error "OpenACC region inside of OpenACC routine, nested parallelism not supported yet" } */ + ; +} diff --git a/gcc/testsuite/c-c++-common/goacc/pr69916.c b/gcc/testsuite/c-c++-common/goacc/pr69916.c new file mode 100644 index 000000000000..e037af34a632 --- /dev/null +++ b/gcc/testsuite/c-c++-common/goacc/pr69916.c @@ -0,0 +1,20 @@ +/* { dg-additional-options "-O2" } */ + +/* PR 69916, an loop determined to be empty sometime after omp-lower + and before oacc-device-lower can evaporate leading to no GOACC_LOOP + internal functions existing. */ + +int +main (void) +{ + +#pragma acc parallel + { + int j = 0; +#pragma acc loop private (j) + for (int i = 0; i < 10; i++) + j++; + } + + return 0; +} diff --git a/gcc/testsuite/c-c++-common/goacc/uninit-dim-clause.c b/gcc/testsuite/c-c++-common/goacc/uninit-dim-clause.c new file mode 100644 index 000000000000..0a006e370e40 --- /dev/null +++ b/gcc/testsuite/c-c++-common/goacc/uninit-dim-clause.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-additional-options "-Wuninitialized" } */ + +#include + +int +main (void) +{ + int i, j, k; + + #pragma acc parallel num_gangs(i) /* { dg-warning "is used uninitialized in this function" } */ + ; + + #pragma acc parallel num_workers(j) /* { dg-warning "is used uninitialized in this function" } */ + ; + + #pragma acc parallel vector_length(k) /* { dg-warning "is used uninitialized in this function" } */ + ; +} diff --git a/gcc/testsuite/c-c++-common/goacc/uninit-if-clause.c b/gcc/testsuite/c-c++-common/goacc/uninit-if-clause.c new file mode 100644 index 000000000000..55caa4c2c7fc --- /dev/null +++ b/gcc/testsuite/c-c++-common/goacc/uninit-if-clause.c @@ -0,0 +1,38 @@ +/* { dg-do compile } */ +/* { dg-additional-options "-Wuninitialized" } */ +/* { dg-excess-errors "PR70392" { xfail c++ } } */ + +#include + +int +main (void) +{ + int l, l2, l3, l4; + bool b, b2, b3, b4; + int i, i2; + + #pragma acc parallel if(l) /* { dg-warning "is used uninitialized in this function" } */ + ; + + #pragma acc parallel if(b) /* { dg-warning "is used uninitialized in this function" "" { xfail c++ } } */ + ; + + #pragma acc kernels if(l2) /* { dg-warning "is used uninitialized in this function" } */ + ; + + #pragma acc kernels if(b2) /* { dg-warning "is used uninitialized in this function" "" { xfail c++ } } */ + ; + + #pragma acc data if(l3) /* { dg-warning "is used uninitialized in this function" } */ + ; + + #pragma acc data if(b3) /* { dg-warning "is used uninitialized in this function" "" { xfail c++ } } */ + ; + + #pragma acc update if(l4) self(i) /* { dg-warning "is used uninitialized in this function" } */ + ; + + #pragma acc update if(b4) self(i2) /* { dg-warning "is used uninitialized in this function" "" { xfail c++ } } */ + ; + +} diff --git a/gcc/testsuite/c-c++-common/goacc/uninit-use-device-clause.c b/gcc/testsuite/c-c++-common/goacc/uninit-use-device-clause.c new file mode 100644 index 000000000000..c5d327caf808 --- /dev/null +++ b/gcc/testsuite/c-c++-common/goacc/uninit-use-device-clause.c @@ -0,0 +1,14 @@ +/* Test fails due to PR70388. */ +/* { dg-do compile } */ +/* { dg-excess-errors "PR70388" { xfail *-*-* } } */ +/* { dg-additional-options "-Wuninitialized" } */ + +void +foo (void) +{ + int i; + +#pragma acc host_data use_device(i) /* { dg-warning "is used uninitialized in this function" "" { xfail *-*-* } } */ + { + } +} diff --git a/gcc/testsuite/c-c++-common/gomp/clauses-1.c b/gcc/testsuite/c-c++-common/gomp/clauses-1.c index 2d1c352a3f29..91aed3960f6c 100644 --- a/gcc/testsuite/c-c++-common/gomp/clauses-1.c +++ b/gcc/testsuite/c-c++-common/gomp/clauses-1.c @@ -1,5 +1,4 @@ /* { dg-do compile } */ -/* { dg-options "-fopenmp" } */ /* { dg-additional-options "-std=c99" { target c } } */ int t; diff --git a/gcc/testsuite/c-c++-common/gomp/gridify-1.c b/gcc/testsuite/c-c++-common/gomp/gridify-1.c new file mode 100644 index 000000000000..ba7a86665b59 --- /dev/null +++ b/gcc/testsuite/c-c++-common/gomp/gridify-1.c @@ -0,0 +1,54 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target offload_hsa } */ +/* { dg-options "-fopenmp -fdump-tree-omplower-details" } */ + +void +foo1 (int n, int *a, int workgroup_size) +{ + int i; +#pragma omp target +#pragma omp teams thread_limit(workgroup_size) +#pragma omp distribute parallel for shared(a) firstprivate(n) private(i) + for (i = 0; i < n; i++) + a[i]++; +} + +void +foo2 (int j, int n, int *a) +{ + int i; +#pragma omp target teams +#pragma omp distribute parallel for shared(a) firstprivate(n) private(i) firstprivate(j) + for (i = j + 1; i < n; i++) + a[i] = i; +} + +void +foo3 (int j, int n, int *a) +{ + int i; +#pragma omp target teams +#pragma omp distribute parallel for shared(a) firstprivate(n) private(i) firstprivate(j) + for (i = j + 1; i < n; i += 3) + a[i] = i; +} + +void +foo4 (int j, int n, int *a) +{ +#pragma omp parallel + { + #pragma omp single + { + int i; +#pragma omp target +#pragma omp teams +#pragma omp distribute parallel for shared(a) firstprivate(n) private(i) firstprivate(j) + for (i = j + 1; i < n; i += 3) + a[i] = i; + } + } +} + + +/* { dg-final { scan-tree-dump-times "Target construct will be turned into a gridified GPGPU kernel" 4 "omplower" } } */ diff --git a/gcc/testsuite/c-c++-common/gomp/if-1.c b/gcc/testsuite/c-c++-common/gomp/if-1.c index 4ba708c50c3a..3a9b53870c6e 100644 --- a/gcc/testsuite/c-c++-common/gomp/if-1.c +++ b/gcc/testsuite/c-c++-common/gomp/if-1.c @@ -1,5 +1,4 @@ /* { dg-do compile } */ -/* { dg-options "-fopenmp" } */ void foo (int a, int b, int *p, int *q) diff --git a/gcc/testsuite/c-c++-common/gomp/pr61486-2.c b/gcc/testsuite/c-c++-common/gomp/pr61486-2.c index db97143e913e..4a680235fa1e 100644 --- a/gcc/testsuite/c-c++-common/gomp/pr61486-2.c +++ b/gcc/testsuite/c-c++-common/gomp/pr61486-2.c @@ -1,6 +1,5 @@ /* PR middle-end/61486 */ /* { dg-do compile } */ -/* { dg-options "-fopenmp" } */ /* { dg-require-effective-target alloca } */ #pragma omp declare target diff --git a/gcc/testsuite/c-c++-common/gomp/target-teams-1.c b/gcc/testsuite/c-c++-common/gomp/target-teams-1.c index 0a707c2e49ab..51b8d488562a 100644 --- a/gcc/testsuite/c-c++-common/gomp/target-teams-1.c +++ b/gcc/testsuite/c-c++-common/gomp/target-teams-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-fopenmp -fdump-tree-gimple" } */ +/* { dg-additional-options "-fdump-tree-gimple" } */ int v = 6; void bar (int); diff --git a/gcc/testsuite/c-c++-common/nonnull-1.c b/gcc/testsuite/c-c++-common/nonnull-1.c index fb2814c44981..2446d6fbcfa6 100644 --- a/gcc/testsuite/c-c++-common/nonnull-1.c +++ b/gcc/testsuite/c-c++-common/nonnull-1.c @@ -24,5 +24,11 @@ func (char *cp1, char *cp2, char *cp3, char *cp4) if (NULL != cp3) /* { dg-warning "nonnull argument" "cp3 compared to NULL" } */ return 3; - return (cp4 != 0) ? 0 : 1; /* { dg-warning "nonnull argument" "cp4 compared to NULL" } */ + return cp4 != 0 ? 0 : 1; /* { dg-warning "nonnull argument" "cp4 compared to NULL" } */ +} + +__attribute__((nonnull (1))) int +func2 (char *cp) +{ + return (cp != NULL) ? 1 : 0; /* { dg-warning "nonnull argument" "cp compared to NULL" { xfail c++ } } */ } diff --git a/gcc/testsuite/c-c++-common/pr70144-1.c b/gcc/testsuite/c-c++-common/pr70144-1.c new file mode 100644 index 000000000000..01c7b78b1792 --- /dev/null +++ b/gcc/testsuite/c-c++-common/pr70144-1.c @@ -0,0 +1,9 @@ +/* PR c++/70144 */ +/* { dg-do compile } */ + +void +foo () +{ + __builtin_constant_p (__builtin_constant_p) ?: ({ unsigned t = 0; t; }); /* { dg-error "must be directly called" } */ + __builtin_classify_type (__builtin_expect); /* { dg-error "must be directly called" } */ +} diff --git a/gcc/testsuite/c-c++-common/pr70144-2.c b/gcc/testsuite/c-c++-common/pr70144-2.c new file mode 100644 index 000000000000..0973b792e95a --- /dev/null +++ b/gcc/testsuite/c-c++-common/pr70144-2.c @@ -0,0 +1,12 @@ +/* PR c++/70144 */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +int +main () +{ + if (__builtin_constant_p (__builtin_memset) != 0 + || __builtin_classify_type (__builtin_memset) != 5) + __builtin_abort (); + return 0; +} diff --git a/gcc/testsuite/c-c++-common/pr70264.c b/gcc/testsuite/c-c++-common/pr70264.c new file mode 100644 index 000000000000..815aad175e53 --- /dev/null +++ b/gcc/testsuite/c-c++-common/pr70264.c @@ -0,0 +1,13 @@ +/* { dg-options "-fdiagnostics-show-caret" } */ + +#define X __LINE__ /* { dg-error "expected" } */ +X + +/* { dg-begin-multiline-output "" } + #define X __LINE__ + ^ + { dg-end-multiline-output "" } */ +/* { dg-begin-multiline-output "" } + X + ^ + { dg-end-multiline-output "" } */ diff --git a/gcc/testsuite/c-c++-common/tsan/thread_leak.c b/gcc/testsuite/c-c++-common/tsan/thread_leak.c index 02deaba5846b..4ddda4aecba2 100644 --- a/gcc/testsuite/c-c++-common/tsan/thread_leak.c +++ b/gcc/testsuite/c-c++-common/tsan/thread_leak.c @@ -9,7 +9,7 @@ int main() { pthread_t t; pthread_create(&t, 0, Thread, 0); pthread_join(t, 0); - printf("PASS\n"); + fprintf(stderr, "PASS\n"); return 0; } diff --git a/gcc/testsuite/c-c++-common/vector-compare-4.c b/gcc/testsuite/c-c++-common/vector-compare-4.c index b05deccfab53..e7d37eb84592 100644 --- a/gcc/testsuite/c-c++-common/vector-compare-4.c +++ b/gcc/testsuite/c-c++-common/vector-compare-4.c @@ -1,6 +1,6 @@ /* PR c/68062 */ /* { dg-do compile } */ -/* { dg-options "-Wsign-compare" } */ +/* { dg-options "-Wsign-compare -Wno-psabi" } */ /* Ignore warning on some powerpc configurations. */ /* { dg-prune-output "non-standard ABI extension" } */ diff --git a/gcc/testsuite/g++.dg/Wno-frame-address.C b/gcc/testsuite/g++.dg/Wno-frame-address.C index a0e9c3684e3c..a2df034fac7c 100644 --- a/gcc/testsuite/g++.dg/Wno-frame-address.C +++ b/gcc/testsuite/g++.dg/Wno-frame-address.C @@ -1,5 +1,5 @@ // { dg-do compile } -// { dg-skip-if "Cannot access arbitrary stack frames." { arm*-*-* hppa*-*-* } } +// { dg-skip-if "Cannot access arbitrary stack frames." { arm*-*-* hppa*-*-* ia64-*-* } } // { dg-options "-Werror" } // { dg-additional-options "-mbackchain" { target s390*-*-* } } diff --git a/gcc/testsuite/g++.dg/concepts/alias1.C b/gcc/testsuite/g++.dg/concepts/alias1.C index 03b3ceae9281..fdd54bd2af15 100644 --- a/gcc/testsuite/g++.dg/concepts/alias1.C +++ b/gcc/testsuite/g++.dg/concepts/alias1.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/alias2.C b/gcc/testsuite/g++.dg/concepts/alias2.C index d81188ed4354..7879d4419617 100644 --- a/gcc/testsuite/g++.dg/concepts/alias2.C +++ b/gcc/testsuite/g++.dg/concepts/alias2.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/alias3.C b/gcc/testsuite/g++.dg/concepts/alias3.C index e6ab66976a16..a8f0f67e04f9 100644 --- a/gcc/testsuite/g++.dg/concepts/alias3.C +++ b/gcc/testsuite/g++.dg/concepts/alias3.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/alias4.C b/gcc/testsuite/g++.dg/concepts/alias4.C index 4227a44c042b..8ffa0a10e3f0 100644 --- a/gcc/testsuite/g++.dg/concepts/alias4.C +++ b/gcc/testsuite/g++.dg/concepts/alias4.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/auto1.C b/gcc/testsuite/g++.dg/concepts/auto1.C index 6068e4cc4862..be9237d69fa5 100644 --- a/gcc/testsuite/g++.dg/concepts/auto1.C +++ b/gcc/testsuite/g++.dg/concepts/auto1.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template class A { }; diff --git a/gcc/testsuite/g++.dg/concepts/auto3.C b/gcc/testsuite/g++.dg/concepts/auto3.C index 1cface77d555..e1a4d7342aa4 100644 --- a/gcc/testsuite/g++.dg/concepts/auto3.C +++ b/gcc/testsuite/g++.dg/concepts/auto3.C @@ -1,4 +1,4 @@ -// { dg-options -std=c++1z } +// { dg-options "-std=c++1z -fconcepts" } template class tuple {}; diff --git a/gcc/testsuite/g++.dg/concepts/class.C b/gcc/testsuite/g++.dg/concepts/class.C index ea74a54da6c1..061105756cb0 100644 --- a/gcc/testsuite/g++.dg/concepts/class.C +++ b/gcc/testsuite/g++.dg/concepts/class.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool Class() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/class1.C b/gcc/testsuite/g++.dg/concepts/class1.C index b213cb58b7e3..a2c4f5d1aed8 100644 --- a/gcc/testsuite/g++.dg/concepts/class1.C +++ b/gcc/testsuite/g++.dg/concepts/class1.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/class2.C b/gcc/testsuite/g++.dg/concepts/class2.C index 2c3ea4483abc..4b8706d8001b 100644 --- a/gcc/testsuite/g++.dg/concepts/class2.C +++ b/gcc/testsuite/g++.dg/concepts/class2.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/class3.C b/gcc/testsuite/g++.dg/concepts/class3.C index e3a1d2a949b6..c25c801f1f63 100644 --- a/gcc/testsuite/g++.dg/concepts/class3.C +++ b/gcc/testsuite/g++.dg/concepts/class3.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/class4.C b/gcc/testsuite/g++.dg/concepts/class4.C index 7ba825085523..af6db2509dbf 100644 --- a/gcc/testsuite/g++.dg/concepts/class4.C +++ b/gcc/testsuite/g++.dg/concepts/class4.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool Class() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/class5.C b/gcc/testsuite/g++.dg/concepts/class5.C index 903bf2499558..218ec9f5a9f0 100644 --- a/gcc/testsuite/g++.dg/concepts/class5.C +++ b/gcc/testsuite/g++.dg/concepts/class5.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool One() { return sizeof(T) >= 4; } diff --git a/gcc/testsuite/g++.dg/concepts/class6.C b/gcc/testsuite/g++.dg/concepts/class6.C index fe6b42d5557e..4a3a3d70a85c 100644 --- a/gcc/testsuite/g++.dg/concepts/class6.C +++ b/gcc/testsuite/g++.dg/concepts/class6.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool One() { return sizeof(T) >= 4; } diff --git a/gcc/testsuite/g++.dg/concepts/constrained-parm.C b/gcc/testsuite/g++.dg/concepts/constrained-parm.C index fd21c43a037b..2650caeb9c42 100644 --- a/gcc/testsuite/g++.dg/concepts/constrained-parm.C +++ b/gcc/testsuite/g++.dg/concepts/constrained-parm.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/decl-diagnose.C b/gcc/testsuite/g++.dg/concepts/decl-diagnose.C index 67b56f962d0f..9829ba1ba697 100644 --- a/gcc/testsuite/g++.dg/concepts/decl-diagnose.C +++ b/gcc/testsuite/g++.dg/concepts/decl-diagnose.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } typedef concept int CINT; // { dg-error "'concept' cannot appear in a typedef declaration" } diff --git a/gcc/testsuite/g++.dg/concepts/deduction-constraint1.C b/gcc/testsuite/g++.dg/concepts/deduction-constraint1.C index 6ff3be94ba98..dfb0c6e94367 100644 --- a/gcc/testsuite/g++.dg/concepts/deduction-constraint1.C +++ b/gcc/testsuite/g++.dg/concepts/deduction-constraint1.C @@ -1,5 +1,5 @@ // PR c++/67007 -// { dg-options -std=c++1z } +// { dg-options "-std=c++1z -fconcepts" } template concept bool A = diff --git a/gcc/testsuite/g++.dg/concepts/diagnostic1.C b/gcc/testsuite/g++.dg/concepts/diagnostic1.C index 7c360cc3943b..aa98ffa752a4 100644 --- a/gcc/testsuite/g++.dg/concepts/diagnostic1.C +++ b/gcc/testsuite/g++.dg/concepts/diagnostic1.C @@ -1,5 +1,5 @@ // PR c++/67159 -// { dg-options -std=c++1z } +// { dg-options "-std=c++1z -fconcepts" } template concept bool R = requires (T& t) { diff --git a/gcc/testsuite/g++.dg/concepts/disjunction1.C b/gcc/testsuite/g++.dg/concepts/disjunction1.C index f67fa0beacb0..24472cc296de 100644 --- a/gcc/testsuite/g++.dg/concepts/disjunction1.C +++ b/gcc/testsuite/g++.dg/concepts/disjunction1.C @@ -1,5 +1,5 @@ // PR c++/66962 -// { dg-options -std=c++1z } +// { dg-options "-std=c++1z -fconcepts" } template struct remove_cv; template struct is_reference; diff --git a/gcc/testsuite/g++.dg/concepts/dr1430.C b/gcc/testsuite/g++.dg/concepts/dr1430.C index 7f857fe4ecc0..3a7ba0363b1a 100644 --- a/gcc/testsuite/g++.dg/concepts/dr1430.C +++ b/gcc/testsuite/g++.dg/concepts/dr1430.C @@ -1,5 +1,5 @@ // PR c++/66092 -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } #include diff --git a/gcc/testsuite/g++.dg/concepts/equiv.C b/gcc/testsuite/g++.dg/concepts/equiv.C index c2ac7410f010..11e232fe2d5e 100644 --- a/gcc/testsuite/g++.dg/concepts/equiv.C +++ b/gcc/testsuite/g++.dg/concepts/equiv.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } // Check equivalence of short- and longhand declarations. diff --git a/gcc/testsuite/g++.dg/concepts/equiv2.C b/gcc/testsuite/g++.dg/concepts/equiv2.C index 675fe2105f19..24d419b2ed3e 100644 --- a/gcc/testsuite/g++.dg/concepts/equiv2.C +++ b/gcc/testsuite/g++.dg/concepts/equiv2.C @@ -1,5 +1,5 @@ // { dg-do run } -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } // template diff --git a/gcc/testsuite/g++.dg/concepts/explicit-inst1.C b/gcc/testsuite/g++.dg/concepts/explicit-inst1.C index 3079ca50f647..89eeb156b574 100644 --- a/gcc/testsuite/g++.dg/concepts/explicit-inst1.C +++ b/gcc/testsuite/g++.dg/concepts/explicit-inst1.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/explicit-inst2.C b/gcc/testsuite/g++.dg/concepts/explicit-inst2.C index 5e75f4ff6313..0319756bfc5c 100644 --- a/gcc/testsuite/g++.dg/concepts/explicit-inst2.C +++ b/gcc/testsuite/g++.dg/concepts/explicit-inst2.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/explicit-inst3.C b/gcc/testsuite/g++.dg/concepts/explicit-inst3.C index a471657a750e..177fc6c1368c 100644 --- a/gcc/testsuite/g++.dg/concepts/explicit-inst3.C +++ b/gcc/testsuite/g++.dg/concepts/explicit-inst3.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/explicit-inst4.C b/gcc/testsuite/g++.dg/concepts/explicit-inst4.C index b075c1009e8e..cf0d8988bd30 100644 --- a/gcc/testsuite/g++.dg/concepts/explicit-inst4.C +++ b/gcc/testsuite/g++.dg/concepts/explicit-inst4.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/explicit-spec1.C b/gcc/testsuite/g++.dg/concepts/explicit-spec1.C index 6316410b950b..c6f559cd1af7 100644 --- a/gcc/testsuite/g++.dg/concepts/explicit-spec1.C +++ b/gcc/testsuite/g++.dg/concepts/explicit-spec1.C @@ -1,5 +1,5 @@ // { dg-do run } -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } #include diff --git a/gcc/testsuite/g++.dg/concepts/explicit-spec2.C b/gcc/testsuite/g++.dg/concepts/explicit-spec2.C index 4f196243717b..8fa7e8aef166 100644 --- a/gcc/testsuite/g++.dg/concepts/explicit-spec2.C +++ b/gcc/testsuite/g++.dg/concepts/explicit-spec2.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/explicit-spec3.C b/gcc/testsuite/g++.dg/concepts/explicit-spec3.C index 29546b3b37c4..6294cef5845e 100644 --- a/gcc/testsuite/g++.dg/concepts/explicit-spec3.C +++ b/gcc/testsuite/g++.dg/concepts/explicit-spec3.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/explicit-spec4.C b/gcc/testsuite/g++.dg/concepts/explicit-spec4.C index e9aacd51bbba..16698cbb366a 100644 --- a/gcc/testsuite/g++.dg/concepts/explicit-spec4.C +++ b/gcc/testsuite/g++.dg/concepts/explicit-spec4.C @@ -1,5 +1,5 @@ // { dg-do run } -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } #include diff --git a/gcc/testsuite/g++.dg/concepts/explicit-spec5.C b/gcc/testsuite/g++.dg/concepts/explicit-spec5.C index 8047278aa77e..e889c2192bfd 100644 --- a/gcc/testsuite/g++.dg/concepts/explicit-spec5.C +++ b/gcc/testsuite/g++.dg/concepts/explicit-spec5.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } #include diff --git a/gcc/testsuite/g++.dg/concepts/explicit-spec6.C b/gcc/testsuite/g++.dg/concepts/explicit-spec6.C index 3eba9ff7bfd0..0bf7640df27c 100644 --- a/gcc/testsuite/g++.dg/concepts/explicit-spec6.C +++ b/gcc/testsuite/g++.dg/concepts/explicit-spec6.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template struct A { diff --git a/gcc/testsuite/g++.dg/concepts/expression.C b/gcc/testsuite/g++.dg/concepts/expression.C index 5ae04e43a12e..de68ef89ee6f 100644 --- a/gcc/testsuite/g++.dg/concepts/expression.C +++ b/gcc/testsuite/g++.dg/concepts/expression.C @@ -1,5 +1,5 @@ // { dg-do run } -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } #include #include diff --git a/gcc/testsuite/g++.dg/concepts/expression2.C b/gcc/testsuite/g++.dg/concepts/expression2.C index 40c2034764a9..ebdadc231f38 100644 --- a/gcc/testsuite/g++.dg/concepts/expression2.C +++ b/gcc/testsuite/g++.dg/concepts/expression2.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C1() diff --git a/gcc/testsuite/g++.dg/concepts/expression3.C b/gcc/testsuite/g++.dg/concepts/expression3.C index eb8406f13b01..77b414e5cfc3 100644 --- a/gcc/testsuite/g++.dg/concepts/expression3.C +++ b/gcc/testsuite/g++.dg/concepts/expression3.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() diff --git a/gcc/testsuite/g++.dg/concepts/feature-macro.C b/gcc/testsuite/g++.dg/concepts/feature-macro.C index 7bc787559ec8..d8ea36981474 100644 --- a/gcc/testsuite/g++.dg/concepts/feature-macro.C +++ b/gcc/testsuite/g++.dg/concepts/feature-macro.C @@ -1,4 +1,4 @@ -// { dg-options -std=c++1z } +// { dg-options "-std=c++1z -fconcepts" } #ifndef __cpp_concepts #error __cpp_concepts not defined diff --git a/gcc/testsuite/g++.dg/concepts/fn-concept1.C b/gcc/testsuite/g++.dg/concepts/fn-concept1.C index 385dcbc13cf1..4a8437f010b3 100644 --- a/gcc/testsuite/g++.dg/concepts/fn-concept1.C +++ b/gcc/testsuite/g++.dg/concepts/fn-concept1.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool Tuple() { // { dg-error "multiple statements" } diff --git a/gcc/testsuite/g++.dg/concepts/fn-concept2.C b/gcc/testsuite/g++.dg/concepts/fn-concept2.C index 092c91c5b84c..86ba936d842b 100644 --- a/gcc/testsuite/g++.dg/concepts/fn-concept2.C +++ b/gcc/testsuite/g++.dg/concepts/fn-concept2.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept auto C1() { return 0; } // { dg-error "deduced return type" } diff --git a/gcc/testsuite/g++.dg/concepts/fn1.C b/gcc/testsuite/g++.dg/concepts/fn1.C index b2bdaf918852..c4f9f555e0a9 100644 --- a/gcc/testsuite/g++.dg/concepts/fn1.C +++ b/gcc/testsuite/g++.dg/concepts/fn1.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/fn10.C b/gcc/testsuite/g++.dg/concepts/fn10.C index f4cd4c5ce346..859c1d5eb218 100644 --- a/gcc/testsuite/g++.dg/concepts/fn10.C +++ b/gcc/testsuite/g++.dg/concepts/fn10.C @@ -1,5 +1,5 @@ // { dg-do compile } -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } // Test that constraint satisfaction checks work even when // processing template declarations. diff --git a/gcc/testsuite/g++.dg/concepts/fn2.C b/gcc/testsuite/g++.dg/concepts/fn2.C index 0aee852ce38f..51a3fb5fd8e0 100644 --- a/gcc/testsuite/g++.dg/concepts/fn2.C +++ b/gcc/testsuite/g++.dg/concepts/fn2.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/fn3.C b/gcc/testsuite/g++.dg/concepts/fn3.C index 06402e02c3bb..ef704f7e135d 100644 --- a/gcc/testsuite/g++.dg/concepts/fn3.C +++ b/gcc/testsuite/g++.dg/concepts/fn3.C @@ -1,5 +1,5 @@ // { dg-do run } -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } #include diff --git a/gcc/testsuite/g++.dg/concepts/fn4.C b/gcc/testsuite/g++.dg/concepts/fn4.C index 5ced6a7f390d..9fa5790fd5e9 100644 --- a/gcc/testsuite/g++.dg/concepts/fn4.C +++ b/gcc/testsuite/g++.dg/concepts/fn4.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/fn5.C b/gcc/testsuite/g++.dg/concepts/fn5.C index b3c3f70a8789..dd9a19e9f195 100644 --- a/gcc/testsuite/g++.dg/concepts/fn5.C +++ b/gcc/testsuite/g++.dg/concepts/fn5.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } // Check shorthand notation. diff --git a/gcc/testsuite/g++.dg/concepts/fn6.C b/gcc/testsuite/g++.dg/concepts/fn6.C index 73ef19a20a77..f6f165e09995 100644 --- a/gcc/testsuite/g++.dg/concepts/fn6.C +++ b/gcc/testsuite/g++.dg/concepts/fn6.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } // Redefinition errors. diff --git a/gcc/testsuite/g++.dg/concepts/fn7.C b/gcc/testsuite/g++.dg/concepts/fn7.C index 2abd34a1e780..dd16a9ae65b5 100644 --- a/gcc/testsuite/g++.dg/concepts/fn7.C +++ b/gcc/testsuite/g++.dg/concepts/fn7.C @@ -1,5 +1,5 @@ // { dg-do link } -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } // FIXME: What is this actually testing? diff --git a/gcc/testsuite/g++.dg/concepts/fn8.C b/gcc/testsuite/g++.dg/concepts/fn8.C index 71141f6ff557..e7481be2f05c 100644 --- a/gcc/testsuite/g++.dg/concepts/fn8.C +++ b/gcc/testsuite/g++.dg/concepts/fn8.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool Class() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/fn9.C b/gcc/testsuite/g++.dg/concepts/fn9.C index b7ac4e10a8da..c135bd7010a6 100644 --- a/gcc/testsuite/g++.dg/concepts/fn9.C +++ b/gcc/testsuite/g++.dg/concepts/fn9.C @@ -1,5 +1,5 @@ // { dg-do run } -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } #include diff --git a/gcc/testsuite/g++.dg/concepts/friend1.C b/gcc/testsuite/g++.dg/concepts/friend1.C index 286e7697c739..5c418cbf76cf 100644 --- a/gcc/testsuite/g++.dg/concepts/friend1.C +++ b/gcc/testsuite/g++.dg/concepts/friend1.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool Eq() { return requires(T t) { t == t; }; } diff --git a/gcc/testsuite/g++.dg/concepts/friend2.C b/gcc/testsuite/g++.dg/concepts/friend2.C index 38b230c4ff7a..6268801a260c 100644 --- a/gcc/testsuite/g++.dg/concepts/friend2.C +++ b/gcc/testsuite/g++.dg/concepts/friend2.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool Eq() { return requires(T t) { t == t; }; } diff --git a/gcc/testsuite/g++.dg/concepts/generic-fn-err.C b/gcc/testsuite/g++.dg/concepts/generic-fn-err.C index 1e975108257b..03a47d5c9597 100644 --- a/gcc/testsuite/g++.dg/concepts/generic-fn-err.C +++ b/gcc/testsuite/g++.dg/concepts/generic-fn-err.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/generic-fn.C b/gcc/testsuite/g++.dg/concepts/generic-fn.C index 778356db1803..d74ea21b6eff 100644 --- a/gcc/testsuite/g++.dg/concepts/generic-fn.C +++ b/gcc/testsuite/g++.dg/concepts/generic-fn.C @@ -1,5 +1,5 @@ // { dg-do run } -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } #include #include diff --git a/gcc/testsuite/g++.dg/concepts/iconv1.C b/gcc/testsuite/g++.dg/concepts/iconv1.C index c4dd38fe5b45..28f3566d4178 100644 --- a/gcc/testsuite/g++.dg/concepts/iconv1.C +++ b/gcc/testsuite/g++.dg/concepts/iconv1.C @@ -1,5 +1,5 @@ // PR c++/67240 -// { dg-options -std=c++1z } +// { dg-options "-std=c++1z -fconcepts" } int foo(int x) { diff --git a/gcc/testsuite/g++.dg/concepts/inherit-ctor1.C b/gcc/testsuite/g++.dg/concepts/inherit-ctor1.C index 29433ade7b4f..6f5115c6c85f 100644 --- a/gcc/testsuite/g++.dg/concepts/inherit-ctor1.C +++ b/gcc/testsuite/g++.dg/concepts/inherit-ctor1.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/inherit-ctor2.C b/gcc/testsuite/g++.dg/concepts/inherit-ctor2.C index 4f39203db4c3..435745a1fa9e 100644 --- a/gcc/testsuite/g++.dg/concepts/inherit-ctor2.C +++ b/gcc/testsuite/g++.dg/concepts/inherit-ctor2.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/inherit-ctor3.C b/gcc/testsuite/g++.dg/concepts/inherit-ctor3.C index 3d0ddf210d12..07499bb40f9d 100644 --- a/gcc/testsuite/g++.dg/concepts/inherit-ctor3.C +++ b/gcc/testsuite/g++.dg/concepts/inherit-ctor3.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/inherit-ctor4.C b/gcc/testsuite/g++.dg/concepts/inherit-ctor4.C index cd9565f660f0..4c53205466dd 100644 --- a/gcc/testsuite/g++.dg/concepts/inherit-ctor4.C +++ b/gcc/testsuite/g++.dg/concepts/inherit-ctor4.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() { return __is_class(T); } diff --git a/gcc/testsuite/g++.dg/concepts/intro1.C b/gcc/testsuite/g++.dg/concepts/intro1.C index 1b5f5d14b7e5..5f036c4b6454 100644 --- a/gcc/testsuite/g++.dg/concepts/intro1.C +++ b/gcc/testsuite/g++.dg/concepts/intro1.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C = __is_class(T); diff --git a/gcc/testsuite/g++.dg/concepts/intro2.C b/gcc/testsuite/g++.dg/concepts/intro2.C index 91a1cacf9c0e..1db1d7a493fb 100644 --- a/gcc/testsuite/g++.dg/concepts/intro2.C +++ b/gcc/testsuite/g++.dg/concepts/intro2.C @@ -1,5 +1,5 @@ // { dg-do run } -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } #include diff --git a/gcc/testsuite/g++.dg/concepts/intro3.C b/gcc/testsuite/g++.dg/concepts/intro3.C index 5dd95c698e12..3cb3ecbb8b4b 100644 --- a/gcc/testsuite/g++.dg/concepts/intro3.C +++ b/gcc/testsuite/g++.dg/concepts/intro3.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C1 = true; diff --git a/gcc/testsuite/g++.dg/concepts/intro4.C b/gcc/testsuite/g++.dg/concepts/intro4.C index 6d8aec3ff616..182129165556 100644 --- a/gcc/testsuite/g++.dg/concepts/intro4.C +++ b/gcc/testsuite/g++.dg/concepts/intro4.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C1 = true; diff --git a/gcc/testsuite/g++.dg/concepts/intro5.C b/gcc/testsuite/g++.dg/concepts/intro5.C index 64771cd6e251..31924f930a70 100644 --- a/gcc/testsuite/g++.dg/concepts/intro5.C +++ b/gcc/testsuite/g++.dg/concepts/intro5.C @@ -1,4 +1,4 @@ -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template concept bool C() diff --git a/gcc/testsuite/g++.dg/concepts/intro6.C b/gcc/testsuite/g++.dg/concepts/intro6.C index 4e168ef3c7dc..f8ed6669f14f 100644 --- a/gcc/testsuite/g++.dg/concepts/intro6.C +++ b/gcc/testsuite/g++.dg/concepts/intro6.C @@ -1,5 +1,5 @@ // PR c++/67003 -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } namespace X { template diff --git a/gcc/testsuite/g++.dg/concepts/intro7.C b/gcc/testsuite/g++.dg/concepts/intro7.C index d92eafcfbd57..914c5fd61100 100644 --- a/gcc/testsuite/g++.dg/concepts/intro7.C +++ b/gcc/testsuite/g++.dg/concepts/intro7.C @@ -1,5 +1,5 @@ // PR c++/66985 -// { dg-options "-std=c++1z" } +// { dg-options "-std=c++1z -fconcepts" } template