gcc 12.2.0 - en to de translation catalogue (15077 entries)

en: 
    For bug reporting instructions, please see:
de: 
    Zum Einsenden von Fehlerberichten (auf Englisch) lesen Sie bitte die
    folgenden Hinweise; Fehler in der deutschen Übersetzung sind an
    translation-team-de@lists.sourceforge.net zu melden:

en: 
    For bug reporting instructions, please see:
    %s.
de: 
    Zum Einsenden von Fehlerberichten (auf Englisch) lesen Sie bitte die Hinweise in:
    %s.
    Fehler in der deutschen Übersetzung sind an translation-team-de@lists.sourceforge.net zu melden.

en: 
    Go ahead? (y or n)
de: 
    Fortfahren? (y oder n)

en: 
    Linker options
    ==============
de: 
    Linkeroptionen
    ==============

en: 
    Obsolete options:
de: 
    Veraltete Optionen:

en: 
    Options starting with -g, -f, -m, -O, -W, or --param are automatically
     passed on to the various sub-processes invoked by %s.  In order to pass
     other options on to these processes the -W<letter> options must be used.
de: 
    Optionen, die mit -g, -f, -m, -O, -W, oder --param beginnen, werden automatisch
     an die verschiedenen Subprozesse, die von %s aufgerufen werden, übergeben.
     Um weitere Optionen an diese Prozesse zu übergeben, müssen die Optionen
     -W<Buchstabe> verwendet werden.

en: 
    ldd output with constructors/destructors.
de: 
    Ausgabe von ldd mit Konstruktoren/Destruktoren.

en: 
    write_c_file - output name is %s, prefix is %s
de: 
    write_c_file: Ausgabename ist %s, Präfix ist %s

en:                            Display specific types of command line options.
de:                            Spezifische Typen der Kommandozeilenoptionen anzeigen.

en:                  from
de:                  von

en:         included from
de:         eingebunden von

en:     -F, --fullname                      Print full filename
de:     -F, --fullname                      Vollständigen Dateinamen ausgeben

en:     -f, --function                      Print function level info
de:     -f, --function                      Daten über Funktionsebene ausgeben

en:     -h, --hotonly                       Only print info for hot objects/functions
de:     -h, --hotonly                       Daten nur für heiße Objekte/Funktionen ausgeben

en:     -n, --normalize <int64_t>           Normalize the profile
de:     -n, --normalize <int64_t>           Profil normalisieren

en:     -o, --object                        Print object level info
de:     -o, --object                        Daten über Objektebene ausgeben

en:     -o, --output <dir>                  Output directory
de:     -o, --output <Verzeichnis>          Ausgabeverzeichnis

en:     -s, --scale <float or simple-frac>  Scale the profile counters
de:     -s, --scale <Gleitkomma oder einfacher Bruch>  Profilzähler skalieren

en:     -t <float>, --hot_threshold <float> Set the threshold for hotness
de:     -t <Gleitkomma>, --hot_threshold <Gleitkomma>  Schwellwert für Heißheit festlegen

en:     -v, --verbose                       Verbose mode
de:     -v, --verbose                       Ausführlicher Modus

en:     -w, --weight <w1,w2>                Set weights (float point values)
de:     -w, --weight <Gewicht1,Gewicht2>    Gewichtung festlegen (Gleitkommazahlen)

en:     Included at %s:%d:
de:     Eingefügt bei %s:%d:

en:     inlined from %qs
de:     eingefügt von %qs

en:     inlined from %qs at %r%s:%d%R
de:     eingefügt von %qs bei %r%s:%d%R

en:     inlined from %qs at %r%s:%d:%d%R
de:     eingefügt von %qs bei %r%s:%d:%d%R

en:    by earlier handler for %<%T%>
de:    von früherem Behandler für %<%T%>

en:    in pointer to member conversion
de:    in Umwandlung in Zeiger auf Element

en:    in pointer to member function conversion
de:    in Umwandlung in Zeiger auf Elementfunktion

en:   %q+T does not have %<constexpr%> destructor
de:   %q+T hat keinen %<constexpr%>-Destruktor

en:   %q+T has a non-trivial destructor
de:   %q+T hat einen nicht-trivialen Destruktor

en:   %q+T is not an aggregate, does not have a trivial default constructor, and has no %<constexpr%> constructor that is not a copy or move constructor
de:   %q+T ist kein Aggregat, hat keinen trivialen Standardkonstruktor und hat keinen %<constexpr%>-Konstruktor, der kein Kopier- oder Bewegungskonstruktor ist

en:   %qE is not equivalent to %qE
de:  %qE entspricht nicht %qE

en:   %qT does not have a virtual destructor
de:   %qT keinen virtuellen Destruktor hat

en:   %qT does not have unique object representations
de:   %qT keine eindeutige Objektrepräsentationen hat

en:   %qT is a closure type, which is only literal in C++17 and later
de:   %qT is a Closure-Typ und ist erst ab C++17 literal

en:   %qT is an ambiguous base class of %qT
de:  %qT ist mehrdeutige Basisklasse von %qT

en:   %qT is not %<nothrow%> assignable from %qT
de:   %qT nicht per %<nothrow%>-Kopie von %qT zuweisbar ist

en:   %qT is not %<nothrow%> constructible from %qE
de:   %qT nicht per %<nothrow%> von %qE konstruiert werden kann

en:   %qT is not %<nothrow%> copy assignable
de:   %qT nicht per %<nothrow%>-Kopie zuweisbar ist

en:   %qT is not %<nothrow%> copy constructible
de:   %qT nicht per %<nothrow%> mit dem Standardkonstruktor kopiert werden kann

en:   %qT is not %<nothrow%> default constructible
de:   %qT nicht per %<nothrow%> mit dem Standardkonstruktor erzeugt werden kann

en:   %qT is not a POD type
de:   %qT kein POD-Typ ist

en:   %qT is not a base of %qT
de:   %qT keine Basis von %qT ist

en:   %qT is not a class
de:   %qT keine Klasse ist

en:   %qT is not a final class
de:   %qT keine finale Klasse ist

en:   %qT is not a literal type
de:   %qT kein literaler Typ ist

en:   %qT is not a polymorphic type
de:   %qT kein polymorpher Typ ist

en:   %qT is not a trivial type
de:   %qT kein trivialer Typ ist

en:   %qT is not a union
de:   %qT kein Vereinigungstyp ist

en:   %qT is not an abstract class
de:   %qT keine abstrakte Klasse ist

en:   %qT is not an aggregate
de:   %qT kein Aggregat ist

en:   %qT is not an empty class
de:   %qT keine leere Klasse ist

en:   %qT is not an enum
de:   %qT keine Aufzählung ist

en:   %qT is not an standard layout type
de:   %qT kein Typ mit Standardlayout ist

en:   %qT is not assignable from %qT
de:  %qT nicht vom Typ %qT zugewiesen werden kann

en:   %qT is not constructible from %qE
de:  %qT nicht von %qE konstruiert werden kann

en:   %qT is not default constructible
de:   %qT nicht mit dem Standardkonstruktor erzeugt werden kann

en:   %qT is not derived from %qT
de:  %qT ist nicht vom Typ %qT abgeleitet

en:   %qT is not layout compatible with %qT
de:   das Layout von %qT nicht zu %qT kompatibel ist

en:   %qT is not pointer-interconvertible base of %qT
de:   %qT keine Zeiger-konvertierbare Basis von %qT ist

en:   %qT is not the same as %qT
de:   %qT nicht derselbe Typ wie %qT ist

en:   %qT is not trivially assignable from %qT
de:   %qT nicht per trivialer Kopie von %qT zugewiesen werden kann

en:   %qT is not trivially constructible from %qE
de:   %qT nicht trivial von %qE konstruiert werden kann

en:   %qT is not trivially copy assignable
de:   %qT nicht per trivialer Kopie zugewiesen werden kann

en:   %qT is not trivially copy constructible
de:   %qT nicht per trivialer Kopie erzeugt werden kann

en:   %qT is not trivially copyable
de:   %qT nicht trivial kopierbar

en:   %qT is not trivially default constructible
de:   %qT nicht trivial mit dem Standardkonstruktor erzeugt werden kann

en:   %qT is not trivially destructible
de:   %qT nicht trivial zerstört werden kann

en:   (Use '-v --help' to display command line options of sub-processes).
de:   (Verwenden Sie »-v --help« zum Anzeigen der Kommandozeilenoptionen von Subprozessen).

en:   -###                     Like -v but options quoted and commands not executed.
de:   -###                     Wie -v, aber mit zitierten Optionen und ohne Ausführung
                               der Befehlen.

en:   --help                   Display this information.
de:   --help                   Diese Informationen anzeigen.

en:   --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].
de:   --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...]

en:   --sysroot=<directory>    Use <directory> as the root directory for headers
                               and libraries.
de:   --sysroot=<Verzeichnis>  <Verzeichnis> als Wurzelverzeichnis für Header und
                               Bibliotheken verwenden.

en:   --target-help            Display target specific command line options (including assembler and linker options).
de:   --target-help            Zielspezifische Kommandozeilenoptionen (inklusive Assembler- und Linkeroptionen) anzeigen.

en:   --version                Display compiler version information.
de:   --version                Compilerversionsinformation anzeigen.

en:   -B <directory>           Add <directory> to the compiler's search paths.
de:   -B <Verzeichnis>         <Verzeichnis> zum Suchpfad des Compilers hinzufügen.

en:   -D, --debug			    Display debugging dumps
de:   -D, --debug			    Fehlersuche-Details anzeigen

en:   -E                       Preprocess only; do not compile, assemble or link.
de:   -E                       Nur den Präprozessor ausführen, nicht Compiler, Assembler oder
                               Linker.

en:   -H, --human-readable            Output human readable numbers
de:   -H, --human-readable            Menschenlesbare Zahlen ausgeben

en:   -S                       Compile only; do not assemble or link.
de:   -S                       Nur kompilieren, nicht assemblieren oder linken.

en:   -Wa,<options>            Pass comma-separated <options> on to the assembler.
de:   -Wa,<Optionen>           Die durch Kommata getrennten <Optionen> an den Assembler übergeben.

en:   -Wl,<options>            Pass comma-separated <options> on to the linker.
de:   -Wl,<Optionen>           Die durch Kommata getrennten <Optionen> an den Linker übergeben.

en:   -Wp,<options>            Pass comma-separated <options> on to the preprocessor.
de:   -Wp,<Optionen>           Die durch Kommata getrennten <Optionen> an den Präprozessor übergeben.

en:   -Xassembler <arg>        Pass <arg> on to the assembler.
de:   -Xassembler <Arg>        <Arg> an den Assembler übergeben.

en:   -Xlinker <arg>           Pass <arg> on to the linker.
de:   -Xlinker <Arg>           <Arg> an den Linker übergeben.

en:   -Xpreprocessor <arg>     Pass <arg> on to the preprocessor.
de:   -Xpreprocessor <Arg>     <Arg> an den Präprozessor übergeben.

en:   -a, --all-blocks                Show information for every basic block
de:   -a, --all-blocks                Informationen für jeden Basisblock zeigen

en:   -b, --branch-probabilities      Include branch probabilities in output
de:   -b, --branch-probabilities      Zweigwahrscheinlichkeiten in Ausgabe aufnehmen

en:   -c                       Compile and assemble, but do not link.
de:   -c                       Nur kompilieren und assemblieren, aber nicht binden.

en:   -c, --branch-counts             Output counts of branches taken
                                        rather than percentages
de:   -c, --branch-counts             Anzahl der Zweigdurchläufe statt
                                        Prozentzahlen ausgeben

en:   -d, --display-progress          Display progress information
de:   -d, --display-progress          Fortschrittsinformationen anzeigen

en:   -dumpmachine             Display the compiler's target processor.
de:   -dumpmachine             Zielprozessor des Compilers anzeigen.

en:   -dumpspecs               Display all of the built in spec strings.
de:   -dumpspecs               Alle eingebauten Spezifikationszeichenketten anzeigen.

en:   -dumpversion             Display the version of the compiler.
de:   -dumpversion             Die Compilerversion anzeigen.

en:   -f, --function-summaries        Output summaries for each function
de:   -f, --function-summaries        Ausgabezusammenfassungen für jede Funktion

en:   -foffload=<targets>      Specify offloading targets.
de:   -foffload=<Ziele>        Offloading-Ziele angeben.

en:   -h, --help                            Print this help, then exit
de:   -h, --help                            Diese Hilfe anzeigen, danach beenden

en:   -h, --help                      Print this help, then exit
de:   -h, --help                      Diese Hilfe anzeigen

en:   -i, --json-format               Replaced with -j, --json-format
de:   -i, --json-format               Ersetzt durch -j, --json-format

en:   -j, --human-readable            Replaced with -H, --human-readable
de:   -j, --human-readable            Ersetzt durch -H, --human-readable

en:   -j, --json-format               Output JSON intermediate format
                                        into .gcov.json.gz file
de:   -j, --json-format               Zwischenergebnisse im JSON-Format in
                                      .gcov.json.gz-Datei ausgeben

en:   -k, --use-colors                Emit colored output
de:   -k, --use-colors                Bunte Ausgabe erzeugen

en:   -l, --long-file-names           Use long output file names for included
                                        source files
de:   -l, --long-file-names           In eingefügten Quelldateien lange Dateinamen
                                        für Ausgabedateien verwenden

en:   -m, --demangled-names           Output demangled function names
de:   -m, --demangled-names           Entmangelte Funktionsnamen ausgeben

en:   -n, --no-output                 Do not create an output file
de:   -n, --no-output                 Keine Ausgabedatei erzeugen

en:   -no-canonical-prefixes   Do not canonicalize paths when building relative
                               prefixes to other gcc components.
de:   -no-canonical-prefixes   Pfade beim Erzeugen relativer Präfixe zu anderen
                               GCC-Komponenten nicht kanonisieren.

en:   -o <file>                Place the output into <file>.
de:   -o <Datei>               Ausgabe in <Datei> schreiben.

en:   -o, --object-directory DIR|FILE Search for object files in DIR or called FILE
de:   -o, --object-directory DIR|FILE In DIR oder aufgerufener Datei FILE nach
                                      Objektdateien suchen

en:   -p, --preserve-paths            Preserve all pathname components
de:   -p, --preserve-paths            Alle Pfadnamenskomponenten bewahren

en:   -pass-exit-codes         Exit with highest error code from a phase.
de:   -pass-exit-codes         Mit höchstem Rückgabe-Code einer Phase beenden.

en:   -pie                     Create a dynamically linked position independent
                               executable.
de:   -pie                     Eine ausführbare Datei mit positionsunabhängigem
                               Code erzeugen.

en:   -pipe                    Use pipes rather than intermediate files.
de:   -pipe                    Pipes statt temporärer Dateien verwenden.

en:   -print-file-name=<lib>   Display the full path to library <lib>.
de:   -print-file-name=<Bib>   Vollen Pfad zur Bibliothek <Bib> anzeigen.

en:   -print-libgcc-file-name  Display the name of the compiler's companion library.
de:   -print-libgcc-file-name  Name der Begleitbibliothek des Compilers anzeigen.

en:   -print-multi-directory   Display the root directory for versions of libgcc.
de:   -print-multi-directory   Wurzelverzeichnis für Versionen von libgcc anzeigen.

en:   -print-multi-lib         Display the mapping between command line options and
                               multiple library search directories.
de:   -print-multi-lib         Entspechungen zwischen Kommandozeilenoptionen und
                               mehreren Suchverzeichnissen für Bibliotheken ausgeben.

en:   -print-multi-os-directory Display the relative path to OS libraries.
de:   -print-multi-os-directory Relativen Pfad zu Betriebssystembibliotheken anzeigen.

en:   -print-multiarch         Display the target's normalized GNU triplet, used as
                               a component in the library path.
de:   -print-multiarch         Normalisiertes GNU-Tripel für das Ziel anzeigen,
                               welches als Komponente im Bibliothekspfad verwendet wird.

en:   -print-prog-name=<prog>  Display the full path to compiler component <prog>.
de:   -print-prog-name=<Prog>  Vollen Pfad zur Compilerkomponente <Prog> anzeigen.

en:   -print-search-dirs       Display the directories in the compiler's search path.
de:   -print-search-dirs       Verzeichnisse im Suchpfad des Compilers anzeigen.

en:   -print-sysroot           Display the target libraries directory.
de:   -print-sysroot           Verzeichnis der Bibliotheken für die Zielarchitektur ausgeben.

en:   -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.
de:   -print-sysroot-headers-suffix Den für die Headersuche verwendeten Sysroot-Anhang ausgeben.

en:   -q, --use-hotness-colors        Emit perf-like colored output for hot lines
de:   -q, --use-hotness-colors        perf-artige bunte Ausgabe für heiße Zeilen

en:   -r, --relative-only             Only show data for relative sources
de:   -r, --relative-only             Nur Daten für relative Quellen zeigen

en:   -s, --source-prefix DIR         Source prefix to elide
de:   -s, --source-prefix VERZ        wegzulassender Quellen-Präfix

en:   -save-temps              Do not delete intermediate files.
de:   -save-temps              Temporäre Dateien nicht löschen.

en:   -save-temps=<arg>        Do not delete intermediate files.
de:   -save-temps=<Arg>        Temporäre Dateien nicht löschen.

en:   -shared                  Create a shared library.
de:   -shared                  Eine dynamiache Bibliothek erzeugen.

en:   -specs=<file>            Override built-in specs with the contents of <file>.
de:   -specs=<Datei>           Eingebaute Spezifikationen mit dem Inhalt von <Datei>
                               überschreiben.

en:   -std=<standard>          Assume that the input sources are for <standard>.
de:   -std=<Standard>          Annehmen, dass die Eingabequellen für <Standard> sind.

en:   -t, --stdout                    Output to stdout instead of a file
de:   -t, --stdout                    Ausgabe nach stdout anstelle einer Datei

en:   -time                    Time the execution of each subprocess.
de:   -time                    Zeit für die Ausführung jedes Subprozesses festhalten.

en:   -u, --unconditional-branches    Show unconditional branch counts too
de:   -u, --unconditional-branches    Auch unbedingte Zweigzähler zeigen

en:   -v                       Display the programs invoked by the compiler.
de:   -v                       Die vom Compiler aufgerufenen Programme ausgeben.

en:   -v, --version                         Print version number, then exit
de:   -v, --version                         Versionsnummer anzeigen, danach beenden

en:   -v, --version                   Print version number, then exit
de:   -v, --version                   Versionsnummer anzeigen

en:   -w, --verbose                   Print verbose informations
de:   -w, --verbose                   Ausführliche Informationen ausgeben

en:   -x <language>            Specify the language of the following input files.
                               Permissible languages include: c c++ assembler none
                               'none' means revert to the default behavior of
                               guessing the language based on the file's extension.
de:   -x <Sprache>             Sprache der folgenden Eingabedateien angeben
                               Zulässige Sprachen sind: c c++ assembler none
                               »none« bedeutet den Rückfall auf das Standardverhalten,
                               die Sprache aufgrund der Dateiendung zu erraten.

en:   -x, --hash-filenames            Hash long pathnames
de:   -x, --hash-filenames            lange Dateinamen hashen

en:   Known valid arguments for %s option:
de:   Bekannte gültige Argumente für Option »%s«:

en:   a constructor taking a single argument of its own class type is invalid
de:  Ein Konstruktor, der ein einzelnes Argument seines eigenen Klassentyps hat, ist ungültig

en:   a qualified-id is required
de:   eine qualifizierte ID ist erforderlich

en:   after user-defined conversion:
de:   nach benutzerdefinierter Umwandlung:

en:   ambiguous template argument for non-type template parameter is treated as function type
de:   mehrdeutiges Templateargument für Nichttyp-Templateparameter wird wie ein Funktionstyp behandelt

en:   an inherited constructor is not a candidate for initialization from an expression of the same or derived type
de:   ein geerbter Konstruktor ist kein Kandidat für Initialisierung aus einem Ausdruck desselben oder eines abgeleiteten Typs

en:   and each type can be converted to the other
de:   und jeder Typ kann zu jedem anderen konvertiert werden

en:   as it is a non-system directory that duplicates a system directory
de:   da es ein Nicht-Systemverzeichnis ist, das ein Systemverzeichnis dupliziert

en:   base %qT
de:   Basis %qT

en:   base class %qT of %q+T is non-literal
de:   Basisklasse %qT von %q+T ist kein Literal

en:   because conversion sequence for the argument is better
de:   denn die Umwandlungsfolge für das Argument ist besser

en:   because the following virtual functions are pure within %qT:
de:   denn die folgenden virtuellen Funktionen sind rein innerhalb %qT:

en:   but %d required
de:   aber %d benötigt

en:   but does not declare %<%T(const %T&)%>
de:   aber deklariert %<%T(const %T&)%> nicht

en:   but does not declare %<operator=(const %T&)%>
de:   aber deklariert %<operator=(const %T&)%> nicht

en:   by %qD
de:   von %qD

en:   candidate conversions include %qD and %qD
de:   in Frage kommende Umwandlungen beziehen %qD und %qD ein

en:   candidate expects %d argument, %d provided |   candidate expects %d arguments, %d provided
de[0]:   Kandidat erwartet %d Argument, %d angegeben
de[1]:   Kandidat erwartet %d Argumente, %d angegeben

en:   candidate expects at least %d argument, %d provided |   candidate expects at least %d arguments, %d provided
de[0]:   Kandidat erwartet mindestens %d Argument, %d angegeben
de[1]:   Kandidat erwartet mindestens %d Argumente, %d angegeben

en:   cannot convert %qE (type %qT) to type %qT
de:  %qE (Typ %qT) kann nicht in den Typ %qT umgewandelt werden

en:   cannot deduce a template for %qT from non-template type %qT
de:   für %qT kann kein Template aus Nicht-Templatetyp %qT hergeleitet werden

en:   conversion from return type %qT of template conversion function specialization to %qT is not an exact match
de:  Umwandlung von Rückgabetyp %qT der Spezialisierung der Template-Umwandlungsfunktion in %qT passt nicht exakt

en:   conversion of argument %d would be ill-formed:
de:   Umwandlung von Argument %d wäre unzulässig:

en:   couldn%'t deduce template parameter %qD
de:   Template-Parameter %qD konnte nicht hergeleitet werden

en:   crosses initialization of %q#D
de:   überschneidet Initialisierung von %q#D

en:   declared here
de:   hier deklariert

en:   deduced conflicting types for parameter %qT (%qT and %qT)
de:  hergeleitete Typen für Parameter %qT stehen in Konflikt (%qT und %qT)

en:   deduced conflicting values for non-type parameter %qE (%qE and %qE)
de:  hergeleitete Werte für Nicht-Typ-Parameter %qE stehen in Konflikt (%qE und %qE)

en:   enters %<catch%> block
de:   betritt %<catch%>-Block

en:   enters %<consteval if%> statement
de:   betritt %<consteval if%>-Anweisung

en:   enters %<constexpr if%> statement
de:   betritt %<constexpr if%>-Anweisung

en:   enters %<try%> block
de:   betritt %<try%>-Block

en:   enters OpenMP structured block
de:   tritt in OpenMP-strukturierten Block ein

en:   enters scope of %q#D which has non-trivial destructor
de:   Eintritt in Gültigkeitsbereich von %q#D mit nicht-trivialem Destruktor

en:   enters scope of %q#D, which has non-trivial destructor
de:   Eintritt in Gültigkeitsbereich von %q#D mit nicht-trivialem Destruktor

en:   enters synchronized or atomic statement
de:   synchronisierte oder atomare Anweisung wird betreten

en:   exits OpenMP structured block
de:   beendet OpenMP-strukturierten Block

en:   expected %qD but got %qD
de:   %qD erwartet, %qD erhalten

en:   expected a class template, got %qE
de:   Klassentemplate erwartet, %qE erhalten

en:   expected a class template, got %qT
de:   Klassentemplate erwartet, %qT erhalten

en:   expected a constant of type %qT, got %qT
de:   Konstante des Typs %qT erwartet, %qT erhalten

en:   expected a template of type %qD, got %qT
de:   ein Template des Typs %qD erwartet, %qT erhalten

en:   expected a type, got %qE
de:   einen Typ erwartet, %qE erhalten

en:   expected a type, got %qT
de:   einen Typ erwartet, %qT erhalten

en:   for conversion from %qH to %qI
de:   für Umwandlung von %qH in %qI

en:   from definition of %q#D
de:   aus Definition von %q#D

en:   from here
de:   von hier

en:   in call to %qD
de:   in Aufruf von %qD

en:   in evaluation of %<%Q(%#T, %#T)%>
de:   in Auswertung von %<%Q(%#T, %#T)%>

en:   in thrown expression
de:   in geworfenem Ausdruck

en:   inconsistent parameter pack deduction with %qT and %qT
de:  unpassende Herleitung von Parameterpack mit %qT und %qT

en:   inherited here
de:   hier geerbt

en:   initializing argument %P of %qD
de:   Argument %P von %qD wird initialisiert

en:   member function type %qT is not a valid template argument
de:  Typ %qT von Elementfunktion ist kein gültiges Templateargument

en:   merge [options] <dir1> <dir2>         Merge coverage file contents
de:   merge [Optionen] <Ordner1> <Ordner2>  Abdeckungsdateien zusammenführen

en:   mismatched types %qT and %qT
de:  unpassende Typen %qT und %qT

en:   no known conversion for argument %d from %qH to %qI
de:   keine bekannte Umwandlung für Argument %d von %qH nach %qI

en:   no known conversion for implicit %<this%> parameter from %qH to %qI
de:   keine bekannte Umwandlung für impliziten %<this%>-Parameter von %qH nach %qI

en:   no known conversion from %qH to %qI
de:   keine bekannte Umwandlung von %qH nach %qI

en:   non-static data member %qD has non-literal type
de:   nicht-statisches Datenelement %qD hat nicht-literalen Typ

en:   non-static data member %qD has volatile type
de:   nicht-statisches Datenelement %qD hat nicht-literalen Typ

en:   or %<operator=(const %T&)%>
de:   oder %<operator=(const %T&)%>

en:   or a %<transaction_may_cancel_outer%> function
de:   oder einer %<transaction_may_cancel_outer%>-Funktion

en:   overlap [options] <dir1> <dir2>       Compute the overlap of two profiles
de:   overlap [Optionen] <Verz1> <Verz2>    Überlappung zwischen zwei Profilen berechnen

en:   passing %qT as %<this%> argument discards qualifiers
de:   die Übergabe von %qT als %<this%>-Argument streicht Qualifizierer

en:   profiling support are only provided in archive format
de:   Profiling-Unterstützung nur im Archivformat unterstützt werden

en:   return type %qT of explicit conversion function cannot be converted to %qT with a qualification conversion
de:  Rückgabetyp %qT der expliziten Umwandlungsfunktion kann nicht mit Qualifizierungsänderung in %qT umgewandelt werden

en:   rewrite [options] <dir>               Rewrite coverage file contents
de:   rewrite [Optionen] <Verzeichnis>      Inhalt der Abdeckungsdatei umschreiben

en:   since %q+#D declared in base class
de:   denn %q+#D ist in Basisklasse deklariert

en:   skips initialization of %q#D
de:   überspringt Initialisierung von %q#D

en:   substitution of deduced template arguments resulted in errors seen above
de:  Ersetzung der ermittelten Templateargumente führte zu obigen Fehlern

en:   template argument %qE does not match %qE
de:  Template-Argument %qE passt nicht zu %qE

en:   template argument %qE does not match pointer-to-member constant %qE
de:  Templateargumente %qE passt nicht zum konstanten Zeiger auf Element %qE

en:   template argument deduction/substitution failed:
de:   Herleitung/Ersetzung von Templateargument gescheitert:

en:   template parameter %qD is not a parameter pack, but argument %qD is
de:  Templateparameter %qD ist kein Parameterpack wie Argument %qD

en:   template parameters of a template template argument are inconsistent with other deduced template arguments
de:  Templateparameter eines Template-Templatearguments sind mit anderen hergeleiteten Templateargumenten unverträglich

en:   trying to instantiate %qD
de:   Versuch, %qD zu instanziieren

en:   types %qT and %qT have incompatible cv-qualifiers
de:  Typen %qT und %qT haben unverträgliche CV-Qualifizierer

en:   variable-sized array type %qT is not a valid template argument
de:  Arraytyp %qT mit veränderlicher Größe ist kein gültiges Templateargument

en:   when initialized here
de:   während es hier initialisiert wurde

en:   when instantiating default argument for call to %qD
de:   bei Instanziierung des Standardarguments für Aufruf von %qD

en:  (operand type is %qT)
de:  (Operandentyp ist %qT)

en:  (operand types are %qT and %qT)
de:  (Operandentypen sind %qT und %qT)

en:  (operand types are %qT, %qT, and %qT)
de:  (Operandentypen sind %qT, %qT und %qT)

en:  All options with the desired characteristics have already been displayed
de:  Alle Optionen mit den gewünschten Eigenschaften wurden bereits angezeigt

en:  No options with the desired characteristics were found
de:  Keine Optionen mit den gewünschten Eigenschaften gefunden

en:  None found.  Use --help=%s to show *all* the options supported by the %s front-end.
de:  Nichts gefunden. Bitte verwenden Sie »--help=%s«, um *alle* vom Frontend %s unterstützten Optionen anzuzeigen

en:  [see %<-fno-allow-invalid-boz%>]
de:  [siehe %<-fno-allow-invalid-boz%>]

en:  because all of its copy and move constructors are deleted
de:  da alle seine Kopier- und Verschiebekonstruktoren gelöscht sind

en:  candidate 1: %q#F
de:  Kandidat 1: %q#F

en:  candidate 2: %q#F
de:  Kandidat 2: %q#F

en:  conflicting code gen style switches are used
de:  in Konflikt stehende Codeerzeugungsschalter verwendet

en:  declared here
de:  hier deklariert

en:  the expression has a constant value but is not a C++ constant-expression
de:  der Ausdruck hat einen konstanten Wert, ist aber kein konstanter Ausdruck im Sinne von C++

en: !$ACC LOOP %s loops don't form rectangular iteration space at %L
de: »%s !$ACC LOOP«-Schleifen bei %L formen keinen rechteckigen Wiederholungsraum

en: !$ACC LOOP cannot be a DO CONCURRENT loop at %L
de: !$ACC LOOP kann bei %L keine DO-CONCURRENT-Schleife sein

en: !$ACC LOOP cannot be a DO WHILE or DO without loop control at %L
de: !$ACC LOOP darf ohne Schleifensteuerung bei %L kein DO WHILE oder DO sein

en: !$ACC LOOP iteration variable must be of type integer at %L
de: !$ACC-LOOP-Iterationsvariable bei %L muss vom Typ integer sein

en: !$ACC ROUTINE already applied at %C
de: »!$ACC ROUTINE« wurde bereits bei %C angewendet

en: !$ACC ROUTINE with GANG, WORKER, or VECTOR clause is not permitted in PURE procedure at %C
de: !$ACC ROUTINE mit GANG, WORKER oder VECTOR-Klausel ist in PURE-Prozedur bei %C nicht erlaubt

en: !$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line
de: !$ACC bei %C beginnt eine kommentierte Zeile, da es weder von Leerzeichen gefolgt wird noch eine Fortsetzungszeile ist

en: !$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L
de: !$OMP ATOMIC CAPTURE-Erfassungsanweisung liest bei %L von anderer Variable als die Update-Anweisung schreibt

en: !$OMP ATOMIC READ at %L incompatible with RELEASE clause
de: !$OMP ATOMIC READ bei %L ist inkompatibel zur RELEASE-Klausel

en: !$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L
de: Anweisung !$OMP ATOMIC READ muss bei %L von skalarer Variable intrinsischen Typs lesen

en: !$OMP ATOMIC UPDATE at %L with FAIL clause requiries either the COMPARE clause or using the intrinsic MIN/MAX procedure
de: !$OMP ATOMIC UPDATE bei %L mit FAIL-Klausel erfordert entweder die COMPARE-Klausel oder die Verwendung der intrinsischen MIN/MAX-Prozedur

en: !$OMP ATOMIC WRITE at %L incompatible with ACQUIRE clause
de: !$OMP ATOMIC WRITE bei %L ist inkompatibel zur ACQUIRE-Klausel

en: !$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L
de: Eingebaute Zuweisung !$OMP ATOMIC IAND, IOR oder IEOR muss bei %L zwei Argumente haben

en: !$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L
de: Eingebaute Zuweisung !$OMP ATOMIC muss bei %L MIN, MAX, IAND, IOR oder IEOR sein

en: !$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L
de: Zuweisung !$OMP ATOMIC muss bei %L »var = var op expr« oder »var = expr op var« sein

en: !$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L
de: !$OMP ATOMIC Zuweisung muss auf der rechten Seite bei %L Operator oder Intrinsic haben

en: !$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L
de: Zuweisungsoperator »!$OMP ATOMIC« muss bei %L ein binäres +, *, -, /, .AND., .OR., .EQV. oder .NEQV. sein

en: !$OMP ATOMIC at %L with %s clause is incompatible with READ or WRITE
de: !$OMP ATOMIC bei %L mit %s-Klausel ist inkompatibel zu READ oder WRITE

en: !$OMP ATOMIC at %L with %s clause requires %s clause
de: !$OMP ATOMIC bei %L mit %s-Klausel erfordert %s-Klausel

en: !$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L
de: Erfassungsanweisung !$OMP ATOMIC bei %L muss eine skalare Variable intrinsischen Typs setzen

en: !$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L
de: Erfassungsanweisung !$OMP ATOMIC bei %L erfordert eine skalare Variable intrinsischen Typs

en: !$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L
de: Von den intrinsischen Argumenten für %<!$OMP ATOMIC%> bei %2$L darf höchstens eins auf %1$qs verweisen

en: !$OMP ATOMIC intrinsic arguments must be scalar at %L
de: !$OMP ATOMIC intrinsische Argumente müssen bei %L skalar sein

en: !$OMP ATOMIC statement must assign an expression of intrinsic type at %L
de: Anweisung !$OMP ATOMIC muss einen skalaren Ausdruck intrinsischen Typs bei %L zuweisen

en: !$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L
de: Anweisung !$OMP ATOMIC muss eine skalare Variable intrinsischen Typs bei %L setzen

en: !$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L
de: !$OMP ATOMIC »var op expr« bei %L ist nicht mathematisch äquivalent zu »var = var op (expr)«

en: !$OMP ATOMIC with ALLOCATABLE variable at %L
de: !$OMP ATOMIC mit ALLOCATABLE-Variable bei %L

en: !$OMP DECLARE REDUCTION %s not found at %L
de: !$OMP DECLARE REDUCTION %s nicht gefunden bei %L

en: !$OMP DECLARE REDUCTION %s not found for type %s at %L
de: !$OMP DECLARE REDUCTION »%s« für Typ %s bei %L nicht gefunden

en: !$OMP DECLARE SIMD should refer to containing procedure %qs at %L
de: !$OMP DECLARE SIMD bei %2$L sollte auf die enthaltende Prozedur %1$qs verweisen

en: !$OMP DECLARE TARGET variable %qs at %L isn't SAVEd
de: »!$OMP DECLARE TARGET«-Variable %qs bei %L ist nicht gespeichert (SAVE)

en: !$OMP REQUIRES at %C must appear in the specification part of a program unit
de: !$OMP REQUIRES bei %C muss im Spezifikationsteil einer Programmeinheit vorkommen

en: !$OMP REQUIRES clause %<atomic_default_mem_order(%s)%> specified at %L overrides a previous %<atomic_default_mem_order(%s)%> (which might be through using a module)
de: %<!$OMP REQUIRES%>-Klausel %<atomic_default_mem_order(%s)%>, die bei %L angegeben ist, übersteuert ein vorangehendes %<atomic_default_mem_order(%s)%> (das möglicherweise von einer Modulverwendung stammt)

en: !$OMP REQUIRES clause %<atomic_default_mem_order(%s)%> specified via module %qs use at %L but same clause is not specified for the program unit
de: %<!$OMP REQUIRES%>-Klausel %<atomic_default_mem_order(%s)%> wird von der Modulverwendung %qs bei %L angegeben, aber diese Klausel ist in der Programmeinheit nicht ebenfalls angegeben

en: !$OMP REQUIRES clause %<atomic_default_mem_order(%s)%> specified via module %qs use at %L overrides a previous %<atomic_default_mem_order(%s)%> (which might be through using a module)
de: %<!$OMP REQUIRES%>-Klausel %<atomic_default_mem_order(%s)%>, die von der Modulverwendung %qs bei %L angegeben ist, übersteuert ein vorangehendes %<atomic_default_mem_order(%s)%> (das möglicherweise von einer Modulverwendung stammt)

en: !$OMP REQUIRES clause %qs specified at %L comes after using a device construct/routine
de: %<!$OMP REQUIRES%>-Klausel %qs, die bei %L angegeben ist, kommt nach der Verwendung eines Geräte-Konstrukts bzw. einer Geräte-Routine

en: !$OMP REQUIRES clause %qs specified via module %qs use at %L but same clause is not specified for the program unit
de: %<!$OMP REQUIRES%>-Klausel %qs ist von der Modulverwendung %qs bei %L angegeben, aber diese Klausel ist in der Programmeinheit nicht ebenfalls angegeben

en: !$OMP REQUIRES clause %qs specified via module %qs use at %L comes after using a device construct/routine
de: %<!$OMP REQUIRES%>-Klausel %qs, die von der Modulverwendung %qs bei %L angegeben ist, kommt nach der Verwendung eines Geräte-Konstrukts bzw. einer Geräte-Routine

en: !$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line
de: !$OMP bei %C beginnt eine kommentierte Zeile, da es weder von Leerzeichen gefolgt wird noch eine Fortsetzungszeile ist

en: "::" was expected after module nature at %C but was not found
de: "::" nach Modul-Eigenschaft bei %C erwartet, aber nicht gefunden

en: "USE :: module" at %C
de: "USE :: module" bei %C

en: #include "..." search starts here:
de: Suche für »#include "..."« beginnt hier:

en: #include <...> search starts here:
de: Suche für »#include <...>« beginnt hier:

en: $ descriptor at %L
de: $-Deskriptor bei %L

en: $ should be the last specifier in format at %L
de: $ sollte das letzte Spezifikationssymbol in Format bei %L sein

en: $OMP ERROR encountered at %L
de: $OMP ERROR aufgetreten bei %L

en: $OMP ERROR encountered at %L: %s
de: $OMP ERROR aufgetreten bei %L: %s

en: %#qT declared here
de: %#qT wird hier deklariert

en: %#qT defined here
de: %#qT hier definiert

en: %%:%<canon_for_mlib%> takes 1 or more pairs of parameters
de: %%:%<canon_for_mlib%> verlangt 1 oder mehr Paare von Parametern

en: %%:%<target_mode_check%> takes an even number of parameters
de: %%:%<target_mode_check%> verlangt eine gerade Anzahl an Parametern

en: %%LOC() as an rvalue at %C
de: %%LOC() als rvalue bei %C

en: %%d, %%e, %%f, %%g operand modifiers are for memory references or constant values only
de: Die Operandenmodifizierer %%d, %%e, %%f und %%g sind ausschließlich für Speicherreferenzen oder konstante Werte

en: %+qD causes a section type conflict
de: %+qD löst einen Abschnittstypkonflikt aus

en: %+qD causes a section type conflict with %qD
de: %+qD löst einen Abschnittstypkonflikt mit %qD aus

en: %+qD declared %qE after being used
de: %+qD als %qE deklariert, nachdem es verwendet wurde

en: %+qD declared %qs after being used
de: %+qD wurde als %qs deklariert, nachdem es verwendet wurde

en: %+qD without %<retain%> attribute and %qD with %<retain%> attribute are placed in a section with the same name
de: %+qD ohne %<retain%>-Attribut und %qD mit %<retain%>-Attribut liegen in einem Abschnitt mit demselben Namen

en: %<!%> not valid in GIMPLE
de: Interner Fehler: %<!%> not valid in GIMPLE

en: %<#pragma %s%> may only be used in compound statements
de: %<#pragma %s%> darf nur in Verbundanweisungen verwendet werden

en: %<#pragma GCC aarch64%> requires a string parameter
de: %<#pragma GCC aarch64%> erfordert eine Zeichenkette als Parameter

en: %<#pragma GCC arm%> requires a string parameter
de: %<#pragma GCC arm%> erfordert eine Zeichenkette als Parameter

en: %<#pragma GCC ivdep%> must be inside a function
de: %<#pragma GCC ivdep%> muss innerhalb einer Funktion sein

en: %<#pragma GCC memregs%> must precede any function declarations
de: %<#pragma GCC memregs%> muss vor allen Funktionsdeklarationen stehen

en: %<#pragma GCC memregs%> takes a number [0-16]
de: %<#pragma GCC memregs%> erfordert eine Zahl von 0 bis 16

en: %<#pragma GCC optimize (string [,string]...)%> does not have a final %<)%>
de: %<#pragma GCC optimize (Zeichenkette [,Zeichenkette]...)%> hat kein abschließendes %<)%>

en: %<#pragma GCC optimize%> is not a string or number
de: %<#pragma GCC optimize%> ist keine Zeichenkette oder Zahl

en: %<#pragma GCC optimize%> is not allowed inside functions
de: %<#pragma GCC optimize%> ist nur außerhalb von Funktionen erlaubt

en: %<#pragma GCC optimize%> string is badly formed
de: %<#pragma GCC optimize%> Zeichenkette hat falsches Format

en: %<#pragma GCC option%> is not a string
de: %<#pragma GCC option%> ist keine Zeichenkette

en: %<#pragma GCC option%> is not allowed inside functions
de: %<#pragma GCC option%> ist nur außerhalb von Funktionen erlaubt

en: %<#pragma GCC pch_preprocess%> must be first
de: %<#pragma GCC pch_preprocess%> muss zuerst kommen

en: %<#pragma GCC pop_options%> without a corresponding %<#pragma GCC push_options%>
de: %<#pragma GCC pop_options%> ohne zugehöriges %<#pragma GCC push_options%>

en: %<#pragma GCC target (string [,string]...)%> does not have a final %<)%>
de: %<#pragma GCC target (Zeichenkette [,Zeichenkette]...)%> hat kein abschließendes %<)%>

en: %<#pragma GCC target%> is not supported for this machine
de: %<#pragma GCC target%> wird für diese Maschine nicht unterstützt

en: %<#pragma GCC target%> string is badly formed
de: %<#pragma GCC target%> Zeichenkette hat falsches Format

en: %<#pragma GCC unroll%> must be inside a function
de: %<#pragma GCC unroll%> muss innerhalb einer Funktion sein

en: %<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u
de: %<#pragma GCC unroll%> erfordert einen Zuweisungsausdruck, der zu einer nichtnegativen Ganzzahlkonstante kleiner als %u evaluiert

en: %<#pragma GCC visibility push()%> must specify %<default%>, %<internal%>, %<hidden%> or %<protected%>
de: %<#pragma GCC visibility push()%> muss %<default%>, %<internal%>, %<hidden%> oder %<protected%> angeben

en: %<#pragma GCC visibility%> must be followed by %<push%> or %<pop%>
de: %<#pragma GCC visibility%> muss von %<push%> oder %<pop%> gefolgt werden

en: %<#pragma STDC FLOAT_CONST_DECIMAL64%> is not supported for C++
de: %<#pragma STDC FLOAT_CONST_DECIMAL64%> wird für C++ nicht unterstützt

en: %<#pragma STDC FLOAT_CONST_DECIMAL64%> is not supported on this target
de: %<#pragma STDC FLOAT_CONST_DECIMAL64%> wird auf diesem Ziel nicht unterstützt

en: %<#pragma acc %s data%> has no data movement clause
de: %<#pragma acc %s data%> hat keine Datenverschiebeklausel

en: %<#pragma acc routine%> must be applied before definition
de: %<#pragma acc routine%> muss vor Definition angewendet werden

en: %<#pragma acc routine%> must be applied before use
de: %<#pragma acc routine%> muss vor Verwendung angewendet werden

en: %<#pragma acc routine%> must be at file scope
de: %<#pragma acc routine%> darf nur im Datei-Gültigkeitsbereich auftreten

en: %<#pragma acc routine%> names a set of overloads
de: %<#pragma acc routine%> benennt eine Menge von Überladungen

en: %<#pragma acc routine%> not immediately followed by a single function declaration or definition
de: %<#pragma acc routine%> muss direkt vor einer Deklaration oder Definition einer einzelnen Funktion auftreten

en: %<#pragma acc routine%> not immediately followed by function declaration or definition
de: %<#pragma acc routine%> muss direkt vor einer Funktionsdeklaration oder -definition auftreten

en: %<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause
de: %<#pragma acc update%> muss mindestens eine %<device%>- oder %<host%>- or %<self%>-Klausel enthalten

en: %<#pragma align%> must appear before the declaration of %qD, ignoring
de: %<#pragma align%> muss vor der Deklaration von %qD auftreten; wird ignoriert

en: %<#pragma implementation%> for %qs appears after file is included
de: %<#pragma implementation%> für %qs erscheint, nachdem Datei eingebunden wurde

en: %<#pragma omp allocate%> not yet supported
de: %<#pragma omp allocate%> wird nicht mehr unterstützt

en: %<#pragma omp atomic capture%> uses two different expressions for memory
de: %<#pragma omp atomic capture%> verwendet zwei unterschiedliche Ausdrücke für Speicher

en: %<#pragma omp atomic capture%> uses two different variables for memory
de: %<#pragma omp atomic capture%> verwendet zwei unterschiedliche Variablen für Speicher

en: %<#pragma omp atomic compare capture%> with non-integral comparison result
de: Ergebnis von %<#pragma omp atomic compare capture%> ist keine Ganzzahl

en: %<#pragma omp atomic read%> incompatible with %<release%> clause
de: %<#pragma omp atomic read%> ist unverträglich mit der Klausel %<release%>

en: %<#pragma omp atomic update%> uses two different expressions for memory
de: %<#pragma omp atomic update%> verwendet zwei unterschiedliche Ausdrücke für Speicher

en: %<#pragma omp atomic update%> uses two different variables for memory
de: %<#pragma omp atomic update%> verwendet zwei unterschiedliche Variablen für Speicher

en: %<#pragma omp atomic write%> incompatible with %<acquire%> clause
de: %<#pragma omp atomic write%> ist unverträglich mit der Klausel %<acquire%>

en: %<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses
de: %<#pragma omp cancel%> muss eine der Klauseln %<parallel%>, %<for%>, %<sections%> oder %<taskgroup%> angeben

en: %<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses
de: %<#pragma omp cancellation point%> muss eine der Klauseln %<parallel%>, %<for%>, %<sections%> oder %<taskgroup%> angeben

en: %<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used
de: %<#pragma omp critical%> mit %<hint%>-Klausel erfordert einen Namen, außer wenn %<omp_sync_hint_none%> verwendet wird

en: %<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>
de: %<#pragma omp declare %s%> gefolgt von %<#pragma omp declare %s%>

en: %<#pragma omp declare %s%> must be followed by function declaration or definition
de: %<#pragma omp declare %s%> muss vor der Deklaration oder Definition einer Funktion auftreten

en: %<#pragma omp declare %s%> must be followed by function declaration or definition or another %<#pragma omp declare %s%>
de: %<#pragma omp declare %s%> muss von einer Funktionsdeklaration oder -definition oder einem weiteren %<#pragma omp declare %s%> gefolgt werden

en: %<#pragma omp declare %s%> not immediately followed by a function declaration or definition
de: hinter %<#pragma omp declare %s%> muss direkt eine Funktionsdeklaration oder -definition stehen

en: %<#pragma omp declare %s%> not immediately followed by a single function declaration or definition
de: hinter %<#pragma omp declare %s%> muss direkt eine einzelne Funktionsdeklaration oder -definition stehen

en: %<#pragma omp declare %s%> not immediately followed by function declaration or definition
de: %<#pragma omp declare %s%> muss direkt von einer Funktionsdeklaration oder -definition gefolgt sein

en: %<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>
de: %<#pragma omp declare reduction%>-Kombinierer verweist auf Variable %qD, die weder %<omp_out%> noch %<omp_in%> ist

en: %<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>
de: %<#pragma omp declare reduction%>-Initialisierung verweist auf Variable %qD, die weder %<omp_priv%> noch %<omp_orig%> ist

en: %<#pragma omp declare reduction%> not at file or block scope
de: %<#pragma omp declare reduction%> darf nur im Datei- oder Block-Gültigkeitsbereich auftreten

en: %<#pragma omp declare target%> without corresponding %<#pragma omp end declare target%>
de: %<#pragma omp declare target%> ohne zugehöriges %<#pragma omp end declare target%>

en: %<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%>
de: %<#pragma omp end declare target%> ohne zugehöriges %<#pragma omp declare target%>

en: %<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements
de: %<#pragma omp error%> mit %<at(execution)%>-Klausel darf nur in Verbundanweisungen verwendet werden

en: %<#pragma omp ordered%> with %<depend%> clause may only be used in compound statements
de: %<#pragma omp ordered%> mit %<depend%>-Klausel darf nur in Verbundanweisungen verwendet werden

en: %<#pragma omp requires%> may only be used at file or namespace scope
de: %<#pragma omp requires%> darf nur im Gültigkeitsbereich einer Datei oder eines Namensraums verwendet werden

en: %<#pragma omp requires%> may only be used at file scope
de: %<#pragma omp requires%> darf nur im Gültigkeitsbereich einer Datei verwendet werden

en: %<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause
de: %<#pragma omp scan%> darf nur in einem Schleifenkonstrukt mit %<inscan%>-%<reduction%>-Klausel verwendet werden

en: %<#pragma omp section%> may only be used in %<#pragma omp sections%> construct
de: %<#pragma omp section%> darf nur in %<#pragma omp sections%>-Konstrukt verwendet werden

en: %<#pragma omp simd%> used with class iteration variable %qE
de: %<#pragma omp simd%> zusammen mit Iterationsvariable %qE verwendet

en: %<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause
de: %<#pragma omp target data%> muss mindestens eine %<map%>-, %<use_device_ptr%>- oder %<use_device_addr%>-Klausel enthalten

en: %<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause
de: %<#pragma omp target data%> mit Zuordnungstyp außer %<to%>, %<from%>, %<tofrom%> oder %<alloc%> an %<map%>-Klausel

en: %<#pragma omp target enter data%> must contain at least one %<map%> clause
de: %<#pragma omp target enter data%> muss mindestens eine %<map%>-Klausel enthalten

en: %<#pragma omp target enter data%> with map-type other than %<to%> or %<alloc%> on %<map%> clause
de: %<#pragma omp target enter data%> mit Zuordnungstyp außer %<to%> oder %<alloc%> an %<map%>-Klausel

en: %<#pragma omp target exit data%> must contain at least one %<map%> clause
de: %<#pragma omp target exit data%> muss mindestens eine %<map%>-Klausel enthalten

en: %<#pragma omp target exit data%> with map-type other than %<from%>, %<release%> or %<delete%> on %<map%> clause
de: %<#pragma omp target exit data%> mit Zuordnungstyp außer %<from%>, %<release%> oder %<delete%> an %<map%>-Klausel

en: %<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses
de: %<#pragma omp target update%> muss mindestens eine %<from%>- oder %<to%>-Klausel enthalten

en: %<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause
de: %<#pragma omp target%> mit Zuordnungstyp außer %<to%>, %<from%>, %<tofrom%> oder %<alloc%> an %<map%>-Klausel

en: %<#pragma omp target%> with modifier other than %<always%> or %<close%> on %<map%> clause
de: %<#pragma omp target%> mit Modifizierer außer %<always%> oder %<close%> an %<map%>-Klausel

en: %<#pragma pack (pop)%> encountered without matching %<#pragma pack (push)%>
de: %<#pragma pack (pop)%> gefunden ohne passendes %<#pragma pack (push)%>

en: %<#pragma pack%> has no effect with %<-fpack-struct%> - ignored
de: %<#pragma pack%> hat mit %<-fpack-struct%> keinen Effekt – wird ignoriert

en: %<#pragma pack(pop, %E)%> encountered without matching %<#pragma pack(push, %E)%>
de: %<#pragma pack(pop, %E)%> gefunden ohne passendes %<#pragma pack(push, %E)%>

en: %<#pragma redefine_extname%> ignored due to conflict with %<asm%> declaration
de: %<#pragma redefine_extname%> wird aufgrund von Konflikt mit %<asm%>-Deklaration ignoriert

en: %<#pragma redefine_extname%> ignored due to conflict with previous %<#pragma redefine_extname%>
de: %<#pragma redefine_extname%> wird aufgrund des Konflikts mit vorherigem %<#pragma redefine_extname%> ignoriert

en: %<#pragma redefine_extname%> ignored due to conflict with previous rename
de: %<#pragma redefine_extname%> wird aufgrund des Konflikts mit vorheriger Umbenennung ignoriert

en: %<#pragma scalar_storage_order%> is not supported for C++
de: %<#pragma scalar_storage_order%> wird in C++ nicht unterstützt

en: %<#pragma vtable%> no longer supported
de: %<#pragma vtable%> wird nicht mehr unterstützt

en: %<#pragma weak%> declaration of %q+D not allowed, ignored
de: %<#pragma weak%>-Deklaration von %q+D nicht erlaubt; wird ignoriert

en: %<#pragma%> GHS endXXX does not match previous startXXX
de: %<#pragma GHS endXXX%> passt nicht zum vorherigen %<startXXX%>

en: %<#pragma%> GHS endXXX found without previous startXXX
de: %<#pragma GHS endXXX%> ohne vorheriges %<startXXX%> gefunden

en: %<#pragma%> is not allowed here
de: %<#pragma%> ist hier nicht erlaubt

en: %<$%>operand number used after format without operand number
de: %<$%>-Operandennummer nach Format ohne Operandennummer angegeben

en: %<%%%> constraint used with last operand
de: %<%%%>-Bedingung mit letztem Operanden verwendet

en: %<%%%c%> yields only last 2 digits of year
de: %<%%%c%> liefert nur die letzten 2 Ziffern des Jahres

en: %<%%%c%> yields only last 2 digits of year in some locales
de: %<%%%c%> liefert in manchen Locales nur die letzten 2 Ziffern des Jahres

en: %<%.*s%> directive argument is not a nul-terminated string
de: Argument der Direktive %<%.*s%> ist keine nul-terminierte Zeichenkette

en: %<%.*s%> directive argument is null
de: Argument %<%.*s%> für Direktive ist null

en: %<%.*s%> directive output between %wu and %wu bytes causes result to exceed %<INT_MAX%>
de: Ausgabe der %<%.*s%>-Direktive zwischen %wu und %wu Bytes macht das Ergebnis größer als %<INT_MAX%>

en: %<%.*s%> directive output between %wu and %wu bytes exceeds %<INT_MAX%>
de: Ausgabe der Direktive %<%.*s%> zwischen %wu und %wu Bytes übersteigt %<INT_MAX%>

en: %<%.*s%> directive output between %wu and %wu bytes exceeds minimum required size of 4095
de: Ausgabe der %<%.*s%>-Direktive zwischen %wu und %wu Bytes überschreitet die minimal erforderliche Größe von 4095

en: %<%.*s%> directive output between %wu and %wu bytes may cause result to exceed %<INT_MAX%>
de: Ausgabe der %<%.*s%>-Direktive zwischen %wu und %wu Bytes könnte das Ergebnis größer als %<INT_MAX%> machen

en: %<%.*s%> directive output between %wu and %wu bytes may exceed minimum required size of 4095
de: Ausgabe der %<%.*s%>-Direktive zwischen %wu und %wu Bytes könnte die minimal erforderliche Größe von 4095 überschreiten

en: %<%.*s%> directive output may be truncated writing %wu byte into a region of size %wu | %<%.*s%> directive output may be truncated writing %wu bytes into a region of size %wu
de[0]: Ausgabe der %<%.*s%>-Direktive könnte abgeschnitten sein, beim Schreiben von %wu Byte in eine Region der Größe %wu
de[1]: Ausgabe der %<%.*s%>-Direktive könnte abgeschnitten sein, beim Schreiben von %wu Bytes in eine Region der Größe %wu

en: %<%.*s%> directive output may be truncated writing %wu byte into a region of size between %wu and %wu | %<%.*s%> directive output may be truncated writing %wu bytes into a region of size between %wu and %wu
de[0]: Ausgabe der %<%.*s%>-Direktive könnte abgeschnitten sein, beim Schreiben von %wu Byte in eine Region der Größe zwischen %wu und %wu
de[1]: Ausgabe der %<%.*s%>-Direktive könnte abgeschnitten sein, beim Schreiben von %wu Bytes in eine Region der Größe zwischen %wu und %wu

en: %<%.*s%> directive output may be truncated writing %wu or more bytes into a region of size %wu
de: Ausgabe der %<%.*s%>-Direktive könnte abgeschnitten sein, beim Schreiben von %wu oder mehr Bytes in eine Region der Größe %wu

en: %<%.*s%> directive output may be truncated writing %wu or more bytes into a region of size between %wu and %wu
de: Ausgabe der %<%.*s%>-Direktive könnte abgeschnitten sein, beim Schreiben von %wu oder mehr Bytes in eine Region der Größe zwischen %wu und %wu

en: %<%.*s%> directive output may be truncated writing between %wu and %wu bytes into a region of size %wu
de: Ausgabe der %<%.*s%>-Direktive könnte abgeschnitten sein, beim Schreiben von %wu bis %wu Bytes in eine Region der Größe %wu

en: %<%.*s%> directive output may be truncated writing between %wu and %wu bytes into a region of size between %wu and %wu
de: Ausgabe der %<%.*s%>-Direktive könnte abgeschnitten sein, beim Schreiben zwischen %wu und %wu Bytes in eine Region der Größe zwischen %wu und %wu

en: %<%.*s%> directive output may be truncated writing likely %wu or more bytes into a region of size %wu
de: Ausgabe der %<%.*s%>-Direktive könnte abgeschnitten sein, beim Schreiben von wahrscheinlich %wu oder mehr Bytes in eine Region der Größe %wu

en: %<%.*s%> directive output may be truncated writing likely %wu or more bytes into a region of size between %wu and %wu
de: Ausgabe der %<%.*s%>-Direktive könnte abgeschnitten sein, beim Schreiben von wahrscheinlich %wu oder mehr Bytes in eine Region der Größe zwischen %wu und %wu

en: %<%.*s%> directive output may be truncated writing up to %wu bytes into a region of size %wu
de: Ausgabe der %<%.*s%>-Direktive könnte abgeschnitten sein, beim Schreiben von bis zu %wu Bytes in eine Region der Größe %wu

en: %<%.*s%> directive output may be truncated writing up to %wu bytes into a region of size between %wu and %wu
de: Ausgabe der %<%.*s%>-Direktive könnte abgeschnitten sein, beim Schreiben von bis zu %wu Bytes in eine Region der Größe zwischen %wu und %wu

en: %<%.*s%> directive output of %wu bytes causes result to exceed %<INT_MAX%>
de: Ausgabe der %<%.*s%>-Direktive von %wu Bytes macht das Ergebnis größer als %<INT_MAX%>

en: %<%.*s%> directive output of %wu bytes exceeds %<INT_MAX%>
de: Ausgabe der Direktive %<%.*s%> übersteigt mit %wu Bytes %<INT_MAX%>

en: %<%.*s%> directive output of %wu bytes exceeds minimum required size of 4095
de: Ausgabe der %<%.*s%>-Direktive von %wu Bytes überschreitet die minimal erforderliche Größe von 4095

en: %<%.*s%> directive output truncated writing %wu byte into a region of size %wu | %<%.*s%> directive output truncated writing %wu bytes into a region of size %wu
de[0]: Ausgabe der %<%.*s%>-Direktive abgeschnitten, beim Schreiben von %wu Byte in eine Region der Größe %wu
de[1]: Ausgabe der %<%.*s%>-Direktive abgeschnitten, beim Schreiben von %wu Bytes in eine Region der Größe %wu

en: %<%.*s%> directive output truncated writing %wu byte into a region of size between %wu and %wu | %<%.*s%> directive output truncated writing %wu bytes into a region of size between %wu and %wu
de[0]: Ausgabe der %<%.*s%>-Direktive abgeschnitten, beim Schreiben von %wu Byte in eine Region der Größe zwischen %wu und %wu
de[1]: Ausgabe der %<%.*s%>-Direktive abgeschnitten, beim Schreiben von %wu Bytes in eine Region der Größe zwischen %wu und %wu

en: %<%.*s%> directive output truncated writing %wu or more bytes into a region of size %wu
de: Ausgabe der %<%.*s%>-Direktive abgeschnitten, beim Schreiben von %wu oder mehr Bytes in eine Region der Größe %wu

en: %<%.*s%> directive output truncated writing %wu or more bytes into a region of size between %wu and %wu
de: Ausgabe der %<%.*s%>-Direktive abgeschnitten, beim Schreiben von %wu oder mehr Bytes in eine Region der Größe zwischen %wu und %wu

en: %<%.*s%> directive output truncated writing between %wu and %wu bytes into a region of size %wu
de: Ausgabe der %<%.*s%>-Direktive abgeschnitten, beim Schreiben von %wu bis %wu Bytes in eine Region der Größe %wu

en: %<%.*s%> directive output truncated writing between %wu and %wu bytes into a region of size between %wu and %wu
de: Ausgabe der %<%.*s%>-Direktive abgeschnitten, beim Schreiben von %wu bis %wu Bytes in eine Region der Größe zwischen %wu und %wu

en: %<%.*s%> directive output truncated writing likely %wu or more bytes into a region of size %wu
de: Ausgabe der %<%.*s%>-Direktive abgeschnitten, beim Schreiben von wahrscheinlich %wu oder mehr Bytes in eine Region der Größe %wu

en: %<%.*s%> directive output truncated writing likely %wu or more bytes into a region of size between %wu and %wu
de: Ausgabe der %<%.*s%>-Direktive abgeschnitten, beim Schreiben von wahrscheinlich %wu oder mehr Bytes in eine Region der Größe zwischen %wu und %wu

en: %<%.*s%> directive output truncated writing up to %wu bytes into a region of size %wu
de: Ausgabe der %<%.*s%>-Direktive abgeschnitten, beim Schreiben von bis zu %wu Bytes in eine Region der Größe %wu

en: %<%.*s%> directive output truncated writing up to %wu bytes into a region of size between %wu and %wu
de: Ausgabe der %<%.*s%>-Direktive abgeschnitten, beim Schreiben von bis zu %wu Bytes in eine Region der Größe zwischen %wu und %wu

en: %<%.*s%> directive precision out of range
de: Genauigkeit der %<%.*s%>-Direktive außerhalb des zulässigen Bereichs

en: %<%.*s%> directive width out of range
de: Breite für %<%.*s%>-Direktive außerhalb des zulässigen Bereichs

en: %<%.*s%> directive writing %wu byte into a region of size %wu | %<%.*s%> directive writing %wu bytes into a region of size %wu
de[0]: %<%.*s%>-Direktive schreibt %wu Byte in eine Region der Größe %wu
de[1]: %<%.*s%>-Direktive schreibt %wu Bytes in eine Region der Größe %wu

en: %<%.*s%> directive writing %wu byte into a region of size between %wu and %wu | %<%.*s%> directive writing %wu bytes into a region of size between %wu and %wu
de[0]: %<%.*s%>-Direktive schreibt %wu Byte in eine Region der Größe zwischen %wu und %wu
de[1]: %<%.*s%>-Direktive schreibt %wu Bytes in eine Region der Größe zwischen %wu und %wu

en: %<%.*s%> directive writing %wu or more bytes into a region of size %wu
de: %<%.*s%>-Direktive schreibt %wu oder mehr Bytes in eine Region der Größe %wu

en: %<%.*s%> directive writing %wu or more bytes into a region of size between %wu and %wu
de: %<%.*s%>-Direktive schreibt %wu oder mehr Bytes in eine Region der Größe zwischen %wu und %wu

en: %<%.*s%> directive writing between %wu and %wu bytes into a region of size %wu
de: %<%.*s%>-Direktive schreibt zwischen %wu und %wu Bytes in eine Region der Größe %wu

en: %<%.*s%> directive writing between %wu and %wu bytes into a region of size between %wu and %wu
de: %<%.*s%>-Direktive schreibt zwischen %wu und %wu Bytes in eine Region der Größe zwischen %wu und %wu

en: %<%.*s%> directive writing likely %wu or more bytes into a region of size %wu
de: %<%.*s%>-Direktive schreibt wahrscheinlich %wu oder mehr Bytes in eine Region der Größe %wu

en: %<%.*s%> directive writing likely %wu or more bytes into a region of size between %wu and %wu
de: %<%.*s%>-Direktive schreibt wahrscheinlich %wu oder mehr Bytes in eine Region der Größe zwischen %wu und %wu

en: %<%.*s%> directive writing up to %wu bytes into a region of size %wu
de: %<%.*s%>-Direktive schreibt bis zu %wu Bytes in eine Region der Größe %wu

en: %<%.*s%> directive writing up to %wu bytes into a region of size between %wu and %wu
de: %<%.*s%>-Direktive schreibt bis zu %wu Bytes in eine Region der Größe zwischen %wu und %wu

en: %<%D::%D%> is not a class member
de: %<%D::%D%> ist kein Klassenelement

en: %<%D::%D%> is not a member of %qT
de: %<%D::%D%> ist kein Element von %qT

en: %<%E (%E)%> attribute ignored on functions declared %qs
de: Attribut %<%E (%E)%> wird ignoriert, da es sich auf eine Funktion bezieht, die als %qs deklariert ist

en: %<%E (%E)%> attribute ignored with deallocation functions declared %qs
de: Attribut %<%E (%E)%> wird ignoriert, da es sich auf eine Deallokationsfunction bezieht, die als %qs deklariert ist

en: %<%E::%E%> has not been declared
de: %<%E::%E%> wurde nicht deklariert

en: %<%E::%E%> is not a class or namespace
de: %<%E::%E%> ist keine Klasse oder Namensbereich

en: %<%E::%E%> is not a class, namespace, or enumeration
de: %<%E::%E%> ist keine Klasse, Namensbereich oder Aufzählung

en: %<%E::%E%> is not a type
de: %<%E::%E%> ist kein Typ

en: %<%E::%E%> scoped attribute directive ignored
de: Attribut-Direktive im Bereich %<%E::%E%> ignoriert

en: %<%T%s%D%> names destructor
de: %<%T%s%D%> benennt Destruktor

en: %<%T::%D%> names constructor in %qT
de: %<%T::%D%> benennt Konstruktor in %qT

en: %<%T::%D%> names the constructor, not the type
de: %<%T::%D%> benennt Konstruktor, nicht den Typ

en: %<%T::%E%> has not been declared
de: %<%T::%E%> wurde nicht deklariert

en: %<%T::%E%> is not a type
de: %<%T::%E%> ist kein Typ

en: %<%T::%E%> names the constructor, not the type
de: %<%T::%E%> benennt den Konstruktor, nicht den Typ

en: %<%c%> is not a valid character in an identifier
de: %<%c%> ist kein gültiges Zeichen in einem Bezeichner

en: %<%c%> is not a valid first character for an identifier
de: %<%c%> ist kein gültiges Anfangszeichen für einen Bezeichner

en: %<%c%E%> not found in protocol(s)
de: %<%c%E%> nicht in Protokoll(en) gefunden

en: %<%s %E%> declared inside parameter list will not be visible outside of this definition or declaration
de: das innerhalb der Parameterliste deklarierte %<%s %E%> ist außerhalb dieser Definition oder Deklaration nicht sichtbar

en: %<%s %s%> construct not closely nested inside of %qs
de: %<%s %s%>-Konstrukt innerhalb von %qs nicht eng geschachtelt

en: %<%s + %s%> at %L must be less than or equal to BIT_SIZE(%qs)
de: %<%s + %s%> bei %L muss kleiner oder gleich BIT_SIZE(%qs) sein

en: %<%s taskgroup%> construct not closely nested inside of %<taskgroup%> region
de: %<%s taskgroup%>-Konstrukt nicht eng geschachtelt innerhalb von %<taskgroup%>-Region

en: %<%s=%s%> and %<%s-%s%> are incompatible
de: %<%s=%s%> und %<%s-%s%> sind unverträglich

en: %<&%> constraint used with no register class
de: %<&%>-Bedingung ohne Registerklasse verwendet

en: %<&%> not allowed by itself in line %d
de: in Zeile %d ist %<&%> für sich alleine nicht erlaubt

en: %<&%> should come before %<...%>
de: %<&%> sollte vor %<...%> kommen

en: %<&&%> not valid in GIMPLE
de: Interner Fehler: %<&&%> not valid in GIMPLE

en: %<)%> expected at %C
de: %<)%> bei %C erwartet

en: %<*%> in boolean context, suggest %<&&%> instead
de: %<*%> in booleschem Kontext, stattdessen ist %<&&%> empfohlen

en: %<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>
de: %<*this%>-Capture ist nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar

en: %<-%s%> conflicts with the other architecture options, which specify a %s processor
de: %<-%s%> steht in Konflikt mit den anderen Architekturoptionen, die einen %s-Prozessor angeben

en: %<--help%> argument %q.*s is ambiguous, please be more specific
de: Argument %q.*s für %<--help%> ist mehrdeutig, bitte präzisieren

en: %<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>
de: %<--param constructive-interference-size=%d%> ist größer als %<--param l1-cache-line-size=%d%>

en: %<--param constructive-interference-size=%d%> is less than %d
de: %<--param constructive-interference-size=%d%> ist kleiner als %d

en: %<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>
de: %<--param destructive-interference-size=%d%> ist kleiner als %<--param l1-cache-line-size=%d%>

en: %<--param destructive-interference-size=%d%> is less than %d
de: %<--param destructive-interference-size=%d%> ist kleiner als %d

en: %<-I-%> specified twice
de: %<-I-%> doppelt angegeben

en: %<-MG%> may only be used with %<-M%> or %<-MM%>
de: %<-MG%> darf nur mit %<-M%> oder %<-MM%> verwendet werden

en: %<-W%serror=%s%>: no option %<-%s%>
de: %<-W%serror=%s%>: Keine Option %<-%s%>

en: %<-W%serror=%s%>: no option %<-%s%>; did you mean %<-%s%>?
de: %<-W%serror=%s%>: unbekannte Option %<-%s%>; meinten Sie %<-%s%>?

en: %<-Wabi%> warns about differences from the most up-to-date ABI, which is also used by default
de: %<-Wabi%> warnt vor Abweichungen von der aktuellsten ABI, die ebenfalls standardmäßig verwendet wird

en: %<-Wabi%> won%'t warn about anything
de: %<-Wabi%> wird vor nichts warnen

en: %<-Wabi=1%> is not supported, using =2
de: %<-Wabi=1%> wird nicht unterstützt; stattdessen wird »=2« verwendet

en: %<-Werror=%> argument %qs is not valid for %s
de: Argument %qs für %<-Werror=%> ist für %s nicht gültig

en: %<-Werror=%s%>: %<-%s%> is not an option that controls warnings
de: %<-Werror=%s%>: %<-%s%> ist keine Option, die Warnungen steuert

en: %<-Wformat-contains-nul%> ignored without %<-Wformat%>
de: %<-Wformat-contains-nul%> wird ohne %<-Wformat%> ignoriert

en: %<-Wformat-extra-args%> ignored without %<-Wformat%>
de: %<-Wformat-extra-args%> wird ohne %<-Wformat%> ignoriert

en: %<-Wformat-nonliteral%> ignored without %<-Wformat%>
de: %<-Wformat-nonliteral%> wird ohne %<-Wformat%> ignoriert

en: %<-Wformat-security%> ignored without %<-Wformat%>
de: %<-Wformat-security%> wird ohne %<-Wformat%> ignoriert

en: %<-Wformat-y2k%> ignored without %<-Wformat%>
de: %<-Wformat-y2k%> wird ohne %<-Wformat%> ignoriert

en: %<-Wformat-zero-length%> ignored without %<-Wformat%>
de: %<-Wformat-zero-length%> wird ohne %<-Wformat%> ignoriert

en: %<-Wmisleading-indentation%> is disabled from this point onwards, since column-tracking was disabled due to the size of the code/headers
de: %<-Wmisleading-indentation%> ist von diesem Punkt an ausgeschaltet, da die Spalten-Verfolgung aufgrund der Größe des Codes/Headers ausgeschaltet wurde

en: %<-f%s%> and %<%s=%s%> are incompatible
de: %<-f%s%> und %<%s=%s%> sind unverträglich

en: %<-f%s%> is not supported with CONST16 instructions
de: %<-f%s%> wird mit CONST16-Befehlen nicht unterstützt

en: %<-f%s%> not supported: ignored
de: %<-f%s%> nicht unterstützt: wird ignoriert

en: %<-f%sleading-underscore%> not supported on this target machine
de: %<-f%sleading-underscore%> wird auf dieser Zielmaschine nicht unterstützt

en: %<-fPIC%> and %<-fpic%> are not supported on this target
de: %<-fPIC%> und %<-fpic%> werden für dieses Ziel nicht unterstützt

en: %<-fPIC%> is not supported
de: %<-fPIC%> wird nicht unterstützt

en: %<-fPIC%>/%<-fpic%> not supported for this target
de: %<-fPIC%>/%<-fpic%> werden für dieses Ziel nicht unterstützt

en: %<-fPIE%> is not supported
de: %<-fPIE%> wird nicht unterstützt

en: %<-fabi-compat-version=1%> is not supported, using =2
de: %<-fabi-compat-version=1%> wird nicht unterstützt; stattdessen wird »=2« verwendet

en: %<-fabi-version=1%> is no longer supported
de: %<-fabi-version=1%> wird nicht mehr unterstützt

en: %<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT
de: %<-fabi-version=12%> (GCC 8.1) ändert versehentlich die Aufrufkonvention für %qT

en: %<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1
de: %<-fabi-version=13%> (GCC 8.2) korrigiert die Aufrufkonvention für %qT, die in 8.1 versehentlich geändert wurde

en: %<-falign-%s%> is not between 0 and %d
de: %<-falign-%s%> ist nicht zwischen 0 und %d

en: %<-falign-labels=%d%> is not supported
de: %<-falign-labels=%d%> wird nicht unterstützt

en: %<-falign-loops=%d%> is not supported
de: %<-falign-loops=%d%> wird nicht unterstützt

en: %<-faligned-new=%d%> is not a power of two
de: %<-faligned-new=%d%> ist keine Zweierpotenz

en: %<-fasan-shadow-offset%> should only be used with %<-fsanitize=kernel-address%>
de: %<-fasan-shadow-offset%> sollte nur zusammen mit %<-fsanitize=kernel-address%> verwendet werden

en: %<-fassociative-math%> disabled; other options take precedence
de: %<-fassociative-math%> abgeschaltet; andere Optionen haben Vorrang

en: %<-fcall-saved-REG%> is not supported for out registers
de: %<-fcall-saved-REG%> wird für Ausgaberegister nicht unterstützt

en: %<-fcf-protection%> is not compatible with this target
de: %<-fcf-protection%> ist nicht mit diesem Ziel kompatibel

en: %<-fcf-protection=branch%> is not supported for this target
de: %<-fcf-protection=branch%> wird für dieses Ziel nicht unterstützt

en: %<-fcf-protection=full%> is not supported for this target
de: %<-fcf-protection=full%> wird für dieses Ziel nicht unterstützt

en: %<-fcf-protection=return%> is not supported for this target
de: %<-fcf-protection=return%> wird für dieses Ziel nicht unterstützt

en: %<-fconvert=r16_ieee%> or %<-fconvert=r16_ibm%> not supported on this architecture
de: %<-fconvert=r16_ieee%> oder %<-fconvert=r16_ibm%> werden auf dieser Architektur nicht unterstützt

en: %<-fd-lines-as-code%> has no effect in free form
de: %<-fd-lines-as-code%> hat in Freiform keine Auswirkung

en: %<-fd-lines-as-comments%> has no effect in free form
de: %<-fd-lines-as-comments%> hat in Freiform keine Auswirkung

en: %<-fdata-sections%> not supported for this target
de: %<-fdata-sections%> wird für dieses Ziel nicht unterstützt

en: %<-fdbg-cnt=%s:%d-%d%> has smaller upper limit than the lower
de: %<-fdbg-cnt=%s:%d:%d%> hat kleinere obere als untere Grenze

en: %<-fdirectives-only%> is incompatible with %<-Wunused-macros%>
de: %<-fdirectives-only%> ist mit %<-Wunused-macros%> unverträglich

en: %<-fdirectives-only%> is incompatible with %<-traditional%>
de: %<-fdirectives-only%> ist mit %<-traditional%> unverträglich

en: %<-femit-struct-debug-detailed=dir:...%> must allow at least as much as %<-femit-struct-debug-detailed=ind:...%>
de: %<-femit-struct-debug-detailed=dir:...%> muss zumindest so viel wie %<-femit-struct-debug-detailed=ind:...%> erlauben

en: %<-fexcess-precision=16%> for Ada
de: %<-fexcess-precision=16%> für Ada

en: %<-fexcess-precision=16%> for Fortran
de: %<-fexcess-precision=16%> für Fortran

en: %<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>
de: %<-fexcess-precision=16%> ist nicht mit %<-mfpmath=387%> kompatibel

en: %<-fexcess-precision=16%> is not supported on this target
de: %<-fexcess-precision=16%> wird auf diesem Ziel nicht unterstützt

en: %<-fexcess-precision=standard%> for Ada
de: %<-fexcess-precision=standard%> für Ada

en: %<-fexcess-precision=standard%> for C++
de: %<-fexcess-precision=standard%> für C++

en: %<-fexcess-precision=standard%> for Fortran
de: %<-fexcess-precision=standard%> für Fortran

en: %<-ffunction-sections%> not supported for this target
de: %<-ffunction-sections%> wird für dieses Ziel nicht unterstützt

en: %<-fhandle-exceptions%> has been renamed %<-fexceptions%> (and is now on by default)
de: %<-fhandle-exceptions%> wurde in %<-fexceptions%> umbenannt (und ist nun voreingestellt)

en: %<-fipa-modref%> is incompatible with %qs
de: %<-fipa-modref%> ist unverträglich mit %qs

en: %<-flinker-output=rel%> and %<-fltrans%> are mutually exclusive
de: %<-flinker-output=rel%> und %<-fltrans%> schließen sich gegenseitig aus

en: %<-fmodule-only%> used for non-interface
de: %<-fmodule-only%> wird für Nicht-Schnittstelle verwendet

en: %<-fmoduleinfo%> is not supported on this target
de: %<-fmoduleinfo%> wird von diesem Ziel nicht unterstützt

en: %<-fno-fat-lto-objects%> are supported only with linker plugin
de: %<-fno-fat-lto-objects%> werden nur mit Linker-Plugin unterstützt

en: %<-fno-gnu89-inline%> is only supported in GNU99 or C99 mode
de: %<-fno-gnu89-inline%> wird nur im Modus GNU99 oder C99 unterstützt

en: %<-fobjc-abi-version%> %d is not supported for 32 bit targets with %<-fnext-runtime%>
de: %<-fobjc-abi-version%> %d wird für 32-Bit-Ziele mit %<-fnext-runtime%> nicht unterstützt

en: %<-fobjc-abi-version%> 2 must be used for 64 bit targets with %<-fnext-runtime%>
de: %<-fobjc-abi-version%> 2 muss für 64-Bit-Ziele mit %<-fnext-runtime%> verwendet werden

en: %<-fobjc-exceptions%> is required to enable Objective-C exception syntax
de: %<-fobjc-exceptions%> verwenden, um Syntax für Objective-C-Ausnahmen einzuschalten

en: %<-fobjc-gc%> is ignored for %<-fgnu-runtime%>
de: %<-fobjc-gc%> wird für %<-fgnu-runtime%> ignoriert

en: %<-fobjc-sjlj-exceptions%> is ignored for %<-fgnu-runtime%>
de: %<-fobjc-sjlj-exceptions%> wird für %<-fgnu-runtime%> ignoriert

en: %<-fobjc-sjlj-exceptions%> is ignored for %<-fnext-runtime%> when %<-fobjc-abi-version%> greater than 1
de: %<-fobjc-sjlj-exceptions%> wird für %<-fnext-runtime%> ignoriert, wenn %<-fobjc-abi-version%> größer als 1 ist

en: %<-fobjc-sjlj-exceptions%> is the only supported exceptions system for %<-fnext-runtime%> with %<-fobjc-abi-version%> argument less than 2
de: %<-fobjc-sjlj-exceptions%> ist das einzige unterstützte Ausnahmesystem für %<-fnext-runtime%> mit %<-fobjc-abi-version%>-Argument kleiner 2

en: %<-foffload-abi%> option can be specified only for offload compiler
de: Option %<-foffload-abi%> kann nur für Offload-Compiler angegeben werden

en: %<-fonly=%> argument is different from first input file name
de: das Argument %<-fonly=%> unterscheidet sich vom Namen der ersten Eingabedatei

en: %<-fopenacc-dim%> operand is malformed at %qs
de: Operand für %<-fopenacc-dim%> bei %qs ist falsch

en: %<-fpic%> and %<-fPIC%> not supported without %<-mdsbt%> on this target
de: %<-fpic%> und %<-fPIC%> werden ohne %<-mdsbt%> für dieses Ziel nicht unterstützt

en: %<-fpic%> and %<-mapcs-reent%> are incompatible
de: %<-fpic%> und %<-mapcs-reent%> sind inkompatibel

en: %<-fpic%> is not supported
de: %<-fpic%> wird nicht unterstützt

en: %<-fpie%> is not supported
de: %<-fpie%> wird nicht unterstützt

en: %<-fprefetch-loop-arrays%> is not supported with %<-Os%>
de: %<-fprefetch-loop-arrays%> wird nicht mit %<-Os%> unterstützt

en: %<-fprefetch-loop-arrays%> not supported for this target
de: %<-fprefetch-loop-arrays%> wird für dieses Ziel nicht unterstützt

en: %<-fprefetch-loop-arrays%> not supported for this target (try %<-march%> switches)
de: %<-fprefetch-loop-arrays%> wird für dieses Ziel nicht unterstützt (ggf. die %<-march%>-Schalter versuchen)

en: %<-frecord-gcc-switches%> is not supported by the current target
de: %<-frecord-gcc-switches%> wird für das aktuelle Ziel nicht unterstützt

en: %<-freorder-blocks-and-partition%> does not support unwind info on this architecture
de: %<-freorder-blocks-and-partition%> unterstützt auf dieser Architektur nicht Unwind-Info

en: %<-freorder-blocks-and-partition%> does not work on this architecture
de: %<-freorder-blocks-and-partition%> funktioniert auf dieser Architektur nicht

en: %<-freorder-blocks-and-partition%> does not work with exceptions on this architecture
de: %<-freorder-blocks-and-partition%> funktioniert auf dieser Architektur nicht mit Ausnahmen

en: %<-freorder-blocks-and-partition%> not supported on this architecture
de: %<-freorder-blocks-and-partition%> wird auf dieser Architektur nicht unterstützt

en: %<-fsanitize-address-use-after-scope%> requires %<-fstack-reuse=none%> option
de: %<-fsanitize-address-use-after-scope%> erfordert %<-fstack-reuse=none%>

en: %<-fsanitize-recover=%s%> is not supported
de: %<-fsanitize-recover=%s%> wird nicht unterstützt

en: %<-fsanitize=%s%> is incompatible with %<-fsanitize=%s%>
de: %<-fsanitize=%s%> ist mit %<-fsanitize=%s%> unverträglich

en: %<-fsanitize=address%> and %<-fsanitize=kernel-address%> are not supported for this target
de: %<-fsanitize=address%> und %<-fsanitize=kernel-address%> werden für dieses Ziel nicht unterstützt

en: %<-fsanitize=address%> not supported for this target
de: %<-fsanitize=address%> wird für dieses Ziel nicht unterstützt

en: %<-fsanitize=all%> option is not valid
de: %<-fsanitize=all%> ist ungültig

en: %<-fsanitize=kernel-address%> with stack protection is not supported without %<-fasan-shadow-offset=%> for this target
de: %<-fsanitize=kernel-address%> mit Stapelschutz wird auf diesem Ziel nur in Kombination mit %<-fasan-shadow-offset=%> unterstützt

en: %<-fsanitize=pointer-compare%> must be combined with %<-fsanitize=address%> or %<-fsanitize=kernel-address%>
de: %<-fsanitize=pointer-compare%> muss mit %<-fsanitize=address%> oder %<-fsanitize=kernel-address%> kombiniert werden

en: %<-fsanitize=pointer-subtract%> must be combined with %<-fsanitize=address%> or %<-fsanitize=kernel-address%>
de: %<-fsanitize=pointer-subtract%> muss mit %<-fsanitize=address%> oder %<-fsanitize=kernel-address%> kombiniert werden

en: %<-fsanitize=shadow-call-stack%> not supported in current platform
de: %<-fsanitize=shadow-call-stack%> wird für dieses Ziel nicht unterstützt

en: %<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>
de: %<-fsanitize=shadow-call-stack%> erfordert %<-ffixed-x18%>

en: %<-fsanitize=shadow-call-stack%> requires %<-fno-exceptions%>
de: %<-fsanitize=shadow-call-stack%> erfordert %<-fno-exceptions%>

en: %<-fsplit-stack%> currently only supported on GNU/Linux
de: %<-fsplit-stack%> wird derzeit nur auf GNU/Linux unterstützt

en: %<-fsplit-stack%> currently only supported on PowerPC64 GNU/Linux with glibc-2.18 or later
de: %<-fsplit-stack%> wird derzeit nur auf PowerPC64 GNU/Linux mit glibc-2.18 oder neuer unterstützt

en: %<-fsplit-stack%> does not support 2 register parameters for a nested function
de: %<-fsplit-stack%> unterstützt nicht 2 Registerparameter für eine geschachtelte Funktion

en: %<-fsplit-stack%> does not support 3 register parameters
de: %<-fsplit-stack%> unterstützt nicht 3 Registerparameter

en: %<-fsplit-stack%> does not support fastcall with nested function
de: %<-fsplit-stack%> unterstützt nicht fastcall mit geschachtelter Funktion

en: %<-fsplit-stack%> is not supported by this compiler configuration
de: %<-fsplit-stack%> wird von dieser Compilerkonfiguration nicht unterstützt

en: %<-fsplit-stack%> requires assembler support for CFI directives
de: %<-fsplit-stack%> erfordert Assemblerunterstützung für CFI-Direktiven

en: %<-fstack-check=%> and %<-fstack-clash_protection%> are mutually exclusive; disabling %<-fstack-check=%>
de: %<-fstack-check=%> und %<-fstack-clash_protection%> schließen einander aus. %<-fstack-check=%> wird deaktiviert

en: %<-fstack-check=specific%> for Thumb-1
de: %<-fstack-check=specific%> für Thumb-1

en: %<-fstack-check=specific%> not implemented for MIPS16
de: %<-fstack-check=specific%> nicht für MIPS16 implementiert

en: %<-fstack-clash-protection%> is not supported on targets where the stack grows from lower to higher addresses
de: %<-fstack-clash-protection%> wird auf Architekturen, deren Stapel von klein nach groß wächst, nicht unterstützt

en: %<-fstack-limit-%> options are ignored with %<-mfdpic%>; use %<-mstack-check-l1%>
de: Optionen %<-fstack-limit-%> werden durch %<-mfdpic%> ignoriert; stattdessen %<-mstack-check-l1%> verwenden

en: %<-fstack-limit-%> options are not supported on this cpu
de: die Optionen %<-fstack-limit-%> werden auf dieser CPU nicht unterstützt

en: %<-fstack-protector%> not supported for this target
de: %<-fstack-protector%> wird für dieses Ziel nicht unterstützt

en: %<-fuse-cxa-atexit%> is not supported for msp430-elf
de: %<-fuse-cxa-atexit%> wird für msp430-elf nicht unterstützt

en: %<-fuse-linker-plugin%>, but %s not found
de: %<-fuse-linker-plugin%>, aber %s nicht gefunden

en: %<-fwpa%> and %<-fltrans%> are mutually exclusive
de: %<-fwpa%> und %<-fltrans%> schließen sich gegenseitig aus

en: %<-g%> is only supported when using GAS on this processor
de: %<-g%> wird nur bei der Verwendung von GAS auf diesem Prozessor unterstützt

en: %<-g%> option disabled
de: Option %<-g%> ausgeschaltet

en: %<-g%> with %<-mno-apcs-frame%> may not give sensible debugging
de: %<-g%> mit %<-mno-apcs-frame%> könnte vernünftiges Debugging verhindern

en: %<-gdwarf%s%> is ambiguous; use %<-gdwarf-%s%> for DWARF version or %<-gdwarf%> %<-g%s%> for debug level
de: %<-gdwarf=%s%> ist mehrdeutig; verwenden Sie %<-gdwarf-%s%> für die DWARF-Version und %<-gdwarf -g%s%> für die Debugstufe

en: %<-gdwarf-6%> is output as version 5 with incompatibilities
de: %<-gdwarf-6%> wird als Version 5 ausgegeben, mit Inkompatibilitäten

en: %<-ginline-points%> is forced disabled without %<-gstatement-frontiers%>
de: %<-ginline-points%> wird zwangsweise ausgeschaltet, da %<-gstatement-frontiers%> nicht angegeben ist

en: %<-ginternal-reset-location-views%> is forced disabled without %<-gvariable-location-views%>
de: %<-ginternal-reset-location-views%> wird zwangsweise ausgeschaltet, da %<-gvariable-location-views%> nicht angegeben ist

en: %<-gnat%> misspelled as %<-gant%>
de: %<-gnat%> falsch buchstabiert als %<-gant%>

en: %<-gsplit-dwarf%> is not supported on this platform, ignored
de: %<-gsplit-dwarf%> wird für dieses Ziel nicht unterstützt, wird ignoriert

en: %<-gsplit-dwarf%> is not supported with LTO, disabling
de: %<-gsplit-dwarf%> wird nicht zusammen mit LTO unterstützt, wird daher ausgeschaltet

en: %<-iplugindir%> option not passed from the gcc driver
de: Option %<-iplugindir%> nicht vom GCC-Treiber übergeben

en: %<-m%s%> not supported in this configuration
de: %<-m%s%> wird in dieser Konfiguration nicht unterstützt

en: %<-m%s%> overrides %<-m%s=%s%>, adjusting ABI to %qs
de: %<-m%s%> setzt %<-m%s=%s%> außer Kraft, die ABI wird auf %qs angepasst

en: %<-m32%> conflicts with %<-arch ppc64%> (%<-m32%> ignored)
de: %<-m32%> widerspricht %<-arch ppc64%> (%<-m32%> wird ignoriert)

en: %<-m32%> conflicts with %<-arch x86_64%> (%<-m32%> ignored)
de: %<-m32%> widerspricht %<-arch x86_64%> (%<-m32%> wird ignoriert)

en: %<-m64%> requires a PowerPC64 cpu
de: %<-m64%> benötigt eine PowerPC64-CPU

en: %<-m96bit-long-double%> is not compatible with this target
de: %<-m96bit-long-double%> ist nicht mit diesem Ziel kompatibel

en: %<-mabi=%s%> not supported with %<-fsanitize=address%>
de: %<-mabi=%s%> wird nicht zusammen mit %<-fsanitize=address%> unterstützt

en: %<-mabi=%s%> not supported with %<-fsanitize=kernel-address%>
de: %<-mabi=%s%> wird nicht zusammen mit %<-fsanitize=kernel-address%> unterstützt

en: %<-mabi=%s%> not supported with %<-fsanitize=thread%>
de: %<-mabi=%s%> wird nicht zusammen mit %<-fsanitize=thread%> unterstützt

en: %<-mabi=2fp+%> option only support when FPU available, must be enable %<-mext-fpu-sp%> or %<-mext-fpu-dp%>
de: die Option %<-mabi=2fp+%> wird nur unterstützt, wenn eine FPU verfügbar ist, das kann durch die Optionen %<-mext-fpu-sp%> oder %<-mext-fpu-dp%> eingeschaltet werden

en: %<-mabi=ms%> not supported with X32 ABI
de: %<-mabi=ms%> wird in der X32-ABI nicht unterstützt

en: %<-maix64%> required: 64-bit computation with 32-bit addressing not yet supported
de: %<-maix64%> benötigt: 64-Bit-Berechnung mit 32-Bit-Adressierung noch nicht unterstützt

en: %<-maix64%> requires PowerPC64 architecture remain enabled
de: %<-maix64%> setzt eingeschaltete PowerPC64-Architektur voraus

en: %<-malign-functions%> is obsolete, use %<-falign-functions%>
de: %<-malign-functions%> ist veraltet, Ersatz: %<-falign-functions%>

en: %<-malign-functions=%d%> is not between 0 and %d
de: %<-malign-functions=%d%> liegt nicht zwischen 0 und %d

en: %<-malign-jumps%> is obsolete, use %<-falign-jumps%>
de: %<-malign-jumps%> ist veraltet, Ersatz: %<-falign-jumps%>

en: %<-malign-jumps=%d%> is not between 0 and %d
de: %<-malign-jumps=%d%> liegt nicht zwischen 0 und %d

en: %<-malign-loops%> is obsolete, use %<-falign-loops%>
de: %<-malign-loops%> ist veraltet, Ersatz: %<-falign-loops%>

en: %<-malign-loops=%d%> is not between 0 and %d
de: %<-malign-loops=%d%> liegt nicht zwischen 0 und %d

en: %<-mapcs-stack-check%> incompatible with %<-mno-apcs-frame%>
de: %<-mapcs-stack-check%> verträgt sich nicht mit %<-mno-apcs-frame%>

en: %<-march=%s%> is not compatible with the selected ABI
de: %<-march=%s%> ist mit dem ausgewählten ABI unverträglich

en: %<-march=%s%> requires %<-mfp32%>
de: %<-march=%s%> erfordert %<-mfp32%>

en: %<-march=%s%>: %s must separate with %<_%>
de: %<-march=%s%>: %s müssen durch %<_%> getrennt sein

en: %<-march=%s%>: ISA string is not in canonical order. %<%c%>
de: %<-march=%s%>: ISA-Zeichenkette ist nicht in kanonischer Reihenfolge. %<%c%>

en: %<-march=%s%>: ISA string must begin with rv32 or rv64
de: %<-march=%s%>: ISA-Zeichenkette muss mit %<rv32%> oder %<rv64%> anfangen

en: %<-march=%s%>: expect number after %<%dp%>
de: %<-march=%s%>: nach %<%dp%> muss eine Zahl stehen

en: %<-march=%s%>: extension %qs appear more than one time
de: %<-march=%s%>: Erweiterung %qs kommt mehr als einmal vor

en: %<-march=%s%>: first ISA subset must be %<e%>, %<i%> or %<g%>
de: %<-march=%s%>: erste ISA-Teilmenge muss %<e%>, %<i%> oder %<g%> sein

en: %<-march=%s%>: for %<%s%dp%dp?%>, version number with more than 2 level is not supported
de: %<-march=%s%>: für %<%s%dp%dp?%> wird Versionsnummer mit mehr als 2 Stufen nicht unterstützt

en: %<-march=%s%>: name of %s must be more than 1 letter
de: %<-march=%s%>: Name von %s muss mehr als 1 Buchstabe sein

en: %<-march=%s%>: rv%de is not a valid base ISA
de: %<-march=%s%>: rv%de ist keine gültige Basis-ISA

en: %<-march=%s%>: unexpected ISA string at end: %qs
de: %<-march=%s%>: unerwartete ISA-Zeichenkette am Ende: %qs

en: %<-march=%s%>: unsupported ISA subset %<%c%>
de: %<-march=%s%>: nicht unterstützte ISA-Teilmenge %<%c%>

en: %<-masm=intel%> not supported in this configuration
de: %<-masm=intel%> wird in dieser Konfiguration nicht unterstützt

en: %<-max-stackframe=%d%> is not usable, not between 0 and %d
de: %<-max-stackframe=%d%> ist nicht verwendbar, nicht zwischen 0 und %d

en: %<-mbackchain%> %<-mpacked-stack%> %<-mhard-float%> are not supported in combination
de: die Kombination aus %<-mbackchain%>, %<-mpacked-stack%> und %<-mhard-float%> wird nicht unterstützt

en: %<-mbranch-cost=%d%> is not between 0 and 5
de: %<-mbranch-cost=%d%> liegt nicht zwischen 0 und 5

en: %<-mcall-aixdesc%> incompatible with %<-mabi=elfv2%>
de: %<-mcall-aixdesc%> ist unverträglich mit %<-mabi=elfv2%>

en: %<-mcall-ms2sysv-xlogues%> is not compatible with %s
de: %<-mcall-ms2sysv-xlogues%> ist nicht kompatibel mit %<%s%>

en: %<-mcall-ms2sysv-xlogues%> isn%'t currently supported with SEH
de: %<-mcall-ms2sysv-xlogues%> wird derzeit nicht zusammen mit SEH unterstützt

en: %<-mcmodel%> incompatible with other toc options
de: %<-mcmodel%> unverträglich mit anderen TOC-Optionen

en: %<-mcmodel=%> is not supported in 32-bit mode
de: %<-mcmodel=%> wird im 32-Bit-Modus nicht unterstützt

en: %<-mcode-region=either%> requires the large memory model (%<-mlarge%>)
de: %<-mcode-region=either%> erfordert das große Speichermodell (%<-mlarge%>)

en: %<-mcode-region=upper%> requires the large memory model (%<-mlarge%>)
de: %<-mcode-region=upper%> erfordert das große Speichermodell (%<-mlarge%>)

en: %<-mcorea%> and %<-mcoreb%> cannot be used together
de: %<-mcorea%> und %<-mcoreb%> können nicht zusammen verwendet werden

en: %<-mcorea%> should be used with %<-mmulticore%>
de: %<-mcorea%> sollte mit %<-mmulticore%> verwendet werden

en: %<-mcoreb%> should be used with %<-mmulticore%>
de: %<-mcoreb%> sollte mit %<-mmulticore%> verwendet werden

en: %<-mcpu=%> is deprecated; use %<-mtune=%> or %<-march=%> instead
de: %<-mcpu=%> ist veraltet. Verwenden Sie stattdessen %<-mtune=%> oder %<-march=%>

en: %<-mcpu=%s%> conflicts with %<-march=%s%>
de: %<-mcpu=%s%> steht in Konflikt mit %<-march=%s%>

en: %<-mcpu=%s%> has invalid silicon revision
de: %<-mcpu=%s%> hat ungültige Silizium-Revision

en: %<-mcpu=%s%> is not valid
de: %<-mcpu=%s%> ist nicht gültig

en: %<-mcpu=%s%>: unknown CPU
de: %<-mcpu=%s%>: unbekannte CPU

en: %<-mdata-region=either%> requires the large memory model (%<-mlarge%>)
de: %<-mdata-region=either%> erfordert das große Speichermodell (%<-mlarge%>)

en: %<-mdata-region=upper%> requires the large memory model (%<-mlarge%>)
de: %<-mdata-region=upper%> erfordert das große Speichermodell (%<-mlarge%>)

en: %<-mdiv%> requires %<-march%> to subsume the %<M%> extension
de: %<-mdiv%> erfordert %<-march%>, um die %<M%>-Erweiterung zu ermitteln

en: %<-mdouble-float%> ignored without %<-mhard-float%>
de: %<-mdouble-float%> wird ohne %<-mhard-float%> ignoriert

en: %<-mdynamic-no-pic%> overrides %<-fpic%>, %<-fPIC%>, %<-fpie%> or %<-fPIE%>
de: %<-mdynamic-no-pic%> übersteuert %<-fpic%>, %<-fPIC%>, %<-fpie%> oder %<-fPIE%>

en: %<-mes0%> can only be used with C
de: %<-mes0%> kann nur zusammen mit C verwendet werden

en: %<-mexr%> is used without %<-ms%>
de: %<-mexr%> wird ohne %<-ms%> verwendet

en: %<-mexr%> is used without %<-ms%> or %<-msx%>
de: %<-mexr%> wird ohne %<-ms%> oder %<-msx%> verwendet

en: %<-mfdivdu%> ignored without %<-mhard-float%>
de: %<-mfdivdu%> wird ohne %<-mhard-float%> ignoriert

en: %<-mfdpic%> is not supported, please use a bfin-linux-uclibc target
de: %<-mfdpic%> wird nicht unterstützt, bitte das Ziel »bfin-linux-uclibc« verwenden

en: %<-mfentry%> is supported only for 64-bit CPUs
de: %<-mfentry%> wird nur auf 64-Bit-CPUs unterstützt

en: %<-mfentry%> isn%'t supported for 32-bit in combination with %<-fpic%>
de: %<-mfentry%> wird für 32 Bit in Kombination mit %<-fpic%> nicht unterstützt

en: %<-mfloat-abi=hard%> and VFP
de: %<-mfloat-abi=hard%> und VFP

en: %<-mfloat-abi=hard%>: selected architecture lacks an FPU
de: %<-mfloat-abi=hard%>: ausgewählte Architektur hat keine FPU

en: %<-mfpxx%> can only be used with the o32 ABI
de: %<-mfpxx%> kann nur mit dem o32-ABI verwendet werden

en: %<-mfpxx%> requires %<-mlra%>
de: %<-mfpxx%> erfordert %<-mlra%>

en: %<-mfunction-return%> and %<-fcf-protection%> are not compatible
de: %<-mfunction-return%> und %<-fcf-protection%> sind nicht kompatibel

en: %<-mfunction-return=%s%> and %<-mcmodel=large%> are not compatible
de: %<-mfunction-return=%s%> und %<-mcmodel=large%> sind nicht kompatibel

en: %<-mfused-madd%> is deprecated; use %<-ffp-contract=%> instead
de: %<-mfused-madd%> ist veraltet; stattdessen %<-ffp-contract=%> verwenden

en: %<-mgp32%> and %<-mfp64%> can only be combined if the target supports the mfhc1 and mthc1 instructions
de: %<-mgp32%> und %<-mfp64%> können nur kombiniert werden, wenn das Ziel die Befehle mfhc1 und mthc1 unterstützt

en: %<-mgp32%> and %<-mfp64%> can only be combined when using the o32 ABI
de: %<-mgp32%> und %<-mfp64%> können nur kombiniert werden, wenn o32-ABI verwendet wird

en: %<-mgp32%> used with a 64-bit ABI
de: %<-mgp32%> mit einem 64-Bit-ABI verwendet

en: %<-mgp64%> used with a 32-bit ABI
de: %<-mgp64%> mit einem 32-Bit-ABI verwendet

en: %<-mgp64%> used with a 32-bit processor
de: %<-mgp64%> mit einem 32-Bit-Prozessor verwendet

en: %<-mgpopt%> not supported with PIC
de: %<-mgpopt%> wird nicht zusammen mit PIC unterstützt

en: %<-mgprel-sec=%> argument is not a valid regular expression
de: Argument für %<-mgprel-sec=%> ist kein gültiger regulärer Ausdruck

en: %<-mgprel-sec=%> not supported with PIC
de: %<-mgprel-sec=%> wird nicht zusammen mit PIC unterstützt

en: %<-mhard-dfp%> cannot be used in conjunction with %<-msoft-float%>
de: %<-mhard-dfp%> kann nicht in Verbindung mit %<-msoft-float%> verwendet werden

en: %<-mhard-float%> is not supported by the selected CPU
de: %<-mhard-float%> wird von der ausgewählten CPU nicht unterstützt

en: %<-mincoming-stack-boundary=%d%> is not between %d and 12
de: %<-mincoming-stack-boundary=%d%> liegt nicht zwischen %d und 12

en: %<-mindirect-branch%> and %<-fcf-protection%> are not compatible
de: %<-mindirect-branch%> und %<-fcf-protection%> sind nicht kompatibel

en: %<-mindirect-branch=%s%> and %<-mcmodel=large%> are not compatible
de: %<-mindirect-branch=%s%> und %<-mcmodel=large%> sind nicht kompatibel

en: %<-mintel-syntax%> and %<-mno-intel-syntax%> are deprecated; use %<-masm=intel%> and %<-masm=att%> instead
de: %<-mintel-syntax%> und %<-mno-intel-syntax%> sind veraltet; stattdessen %<-masm=intel%> und %<-masm=att%> verwenden

en: %<-mips3d%> requires %<-mpaired-single%>
de: %<-mips3d%> erfordert %<-mpaired-single%>

en: %<-misr-secure=%d%> argument not in between 0 and 3
de: Argument für %<-misr-secure=%d%> liegt nicht zwischen 0 und 3

en: %<-misr-vector-size=%d%> argument must be 4 or 16
de: für die Option %<-misr-vector-size=%d%> sind nur die Werte 4 oder 16 gültig

en: %<-mlarge%> requires a 430X-compatible %<-mmcu=%>
de: %<-mlarge%> erfordert ein 430X-kompatibles %<-mmcu=%>

en: %<-mlong-double-64%> not allowed with %<-m64%>
de: %<-mlong-double-64%> ist mit %<-m64%> nicht erlaubt

en: %<-mloongson-ext2%> must be used with %<-mloongson-ext%>
de: %<-mloongson-ext2%> muss zusammen mit %<-mloongson-ext%> verwendet werden

en: %<-mloongson-mmi%> must be used with %<-mhard-float%>
de: %<-mloongson-mmi%> muss zusammen mit %<-mhard-float%> verwendet werden

en: %<-mmsa%> must be used with %<-mfp64%> and %<-mhard-float%>
de: %<-mmsa%> muss zusammen mit %<-mfp64%> und %<-mhard-float%> verwendet werden

en: %<-mmul=g13%> cannot be used with %<-mcpu=g10%>
de: %<-mmul=g13%> kann nicht zusammen mit %<-mcpu=g10%> verwendet werden

en: %<-mmul=g13%> cannot be used with %<-mcpu=g14%>
de: %<-mmul=g13%> kann nicht zusammen mit %<-mcpu=g14%> verwendet werden

en: %<-mmul=g14%> cannot be used with %<-mcpu=g10%>
de: %<-mmul=g14%> kann nicht zusammen mit %<-mcpu=g10%> verwendet werden

en: %<-mmul=g14%> cannot be used with %<-mcpu=g13%>
de: %<-mmul=g14%> kann nicht zusammen mit %<-mcpu=g13%> verwendet werden

en: %<-mmulticore%> can only be used with BF561
de: %<-mmulticore%> kann nur mit BF561 verwendet werden

en: %<-mn%> is not supported for linux targets
de: %<-mn%> wird für Linux-Ziele nicht unterstützt

en: %<-mno-%s%> turns off %<-m%s%>
de: %<-mno-%s%> schaltet %<-m%s%> aus

en: %<-mno-allow-string-insns%> forbids the generation of the RMPA instruction
de: %<-mno-allow-string-insns%> verbietet das Erzeugen des RMPA-Befehls

en: %<-mno-altivec%> disables vsx
de: %<-mno-altivec%> schaltet vsx aus

en: %<-mno-dpfp-lrsr%> supported only with %<-mdpfp%>
de: %<-mno-dpfp-lrsr%> wird nur mit %<-mdpfp%> unterstützt

en: %<-mno-exr%> is valid only with %<-ms%> or %<-msx%> - option ignored
de: %<-mno-exr%> ist nur mit %<-ms%> oder %<-msx%> gültig, die Option wird ignoriert

en: %<-mno-fentry%> isn%'t compatible with SEH
de: %<-mno-fentry%> ist nicht mit SEH verträglich

en: %<-mno-gpopt%> needs %<-mexplicit-relocs%>
de: %<-mno-gpopt%> erfordert %<-mexplicit-relocs%>

en: %<-mno-mpy%> supported only for ARC700 or ARCv2
de: %<-mno-mpy%> wird nur für ARC700 oder ARCv2 unterstützt

en: %<-mno-pic-data-is-text-relative%> cannot be used without %<-fpic%>/%<-fPIC%>
de: %<-mno-pic-data-is-text-relative%> kann nur zusammen mit %<-fpic%>/%<-fPIC%> verwendet werden

en: %<-mnop-mcount%> is not compatible with this target
de: %<-mnop-mcount%> ist nicht mit diesem Ziel kompatibel

en: %<-mnop-mcount%> is not implemented for %<-fPIC%>
de: %<-mnop-mcount%> ist für %<-fPIC%> nicht implementiert

en: %<-mpcrel%> %<-fPIC%> is not currently supported on selected cpu
de: %<-mpcrel -fPIC%> wird derzeit nicht für die ausgewählte CPU unterstützt

en: %<-mpic-register=%> is useless without %<-fpic%>
de: %<-mpic-register=%> ist ohne %<-fpic%> nutzlos

en: %<-mpic-symbol-stubs%> is not required for 64-bit code (ignored)
de: %<-mpic-symbol-stubs%> ist für 64-Bit-Code nicht erforderlich (ignoriert)

en: %<-mpreferred-stack-boundary%> is not supported for this target
de: %<-mpreferred-stack-boundary%> wird für dieses Ziel nicht unterstützt

en: %<-mpreferred-stack-boundary=%d%> is not between %d and %d
de: %<-mpreferred-stack-boundary=%d%> liegt nicht zwischen %d und %d

en: %<-mpreferred-stack-boundary=%d%> must be between %d and %d
de: %<-mpreferred-stack-boundary=%d%> muss zwischen %d und %d liegen

en: %<-mquad-memory%> is not available in little endian mode
de: %<-mquad-memory%> ist im Little-Endian-Modus nicht verfügbar

en: %<-mquad-memory%> requires 64-bit mode
de: %<-mquad-memory%> benötigt 64-Bit-Modus

en: %<-mquad-memory-atomic%> requires 64-bit mode
de: %<-mquad-memory-atomic%> benötigt 64-Bit-Modus

en: %<-mr0rel-sec=%> argument is not a valid regular expression
de: Argument für %<-mr0rel-sec=%> ist kein gültiger regulärer Ausdruck

en: %<-mr0rel-sec=%> not supported with PIC
de: %<-mr0rel-sec=%> wird nicht zusammen mit PIC unterstützt

en: %<-mregparm%> is ignored for Intel MCU psABI
de: %<-mregparm%> wird für Intel-MCU-psABI ignoriert

en: %<-mregparm%> is ignored in 64-bit mode
de: %<-mregparm%> wird im 64-Bit-Modus ignoriert

en: %<-mregparm=%d%> is not between 0 and %d
de: %<-mregparm=%d%> liegt nicht zwischen 0 und %d

en: %<-mrelax%> is only supported for RTP PIC
de: %<-mrelax%> wird nur für RTP PIC unterstützt

en: %<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]
de: %<-mriscv-attribute%> RISC-V-ELF-Attribut erfordert GNU as 2.32 [%<-mriscv-attribute%>]

en: %<-mrtd%> is ignored in 64bit mode
de: %<-mrtd%> wird im 64-Bit-Modus ignoriert

en: %<-ms2600%> is used without %<-ms%>
de: %<-ms2600%> wird ohne %<-ms%> verwendet

en: %<-mshared-library-id=%> specified without %<-mid-shared-library%>
de: %<-mshared-library-id=%> ohne %<-mid-shared-library%> angegeben

en: %<-mshared-library-id=%s%> is not between 0 and %d
de: %<-mshared-library-id=%s%> liegt nicht zwischen 0 und %d

en: %<-msmart%> is incompatible with %<-mhigh-registers%>
de: %<-msmart%> ist mit %<-mhigh-registers%> unverträglich

en: %<-mspfp_fast%> not available on ARC600 or ARC601
de: %<-mspfp_fast%> ist auf ARC600 und ARC601 nicht verfügbar

en: %<-msse5%> was removed
de: %<-msse5%> wurde entfernt

en: %<-msseregparm%> used without SSE enabled
de: %<-msseregparm%> verwendet, ohne dass SSE eingeschaltet ist

en: %<-mstack-guard%> implies use of %<-mstack-size%>
de: %<-mstack-guard%> bringt %<-mstack-size%> mit sich

en: %<-mstack-protector-guard=tls%> needs a hardware TLS register
de: %<-mstack-protector-guard=tls%> erfordert ein Hardware-TLS-Register

en: %<-mstringop-strategy=rep_8byte%> not supported for 32-bit code
de: %<-mstringop-strategy=rep_8byte%> wird für 32-Bit-Code nicht unterstützt

en: %<-mtpf-trace-hook-epilogue-check%> requires integer in range 0-4095
de: %<-mtpf-trace-hook-epilogue-check%> erfordert eine Ganzzahl im Bereich von 0 bis 4095

en: %<-mtpf-trace-hook-epilogue-target%> requires integer in range 0-4095
de: %<-mtpf-trace-hook-epilogue-target%> erfordert eine Ganzzahl im Bereich von 0 bis 4095

en: %<-mtpf-trace-hook-prologue-check%> requires integer in range 0-4095
de: %<-mtpf-trace-hook-prologue-check%> erfordert eine Ganzzahl im Bereich von 0 bis 4095

en: %<-mtpf-trace-hook-prologue-target%> requires integer in range 0-4095
de: %<-mtpf-trace-hook-prologue-target%> erfordert eine Ganzzahl im Bereich von 0 bis 4095

en: %<-mtune=%> expects mn10300, am33, am33-2, or am34
de: %<-mtune=%> erwartet mn10300, am33, am33-2 oder am34

en: %<-mtune=x86-64%> is deprecated; use %<-mtune=k8%> or %<-mtune=generic%> instead as appropriate
de: %<-mtune=x86-64%> ist veraltet; stattdessen entsprechend %<-mtune=k8%> oder %<-mtune=generic%> verwenden

en: %<-muintr%> not supported for 32-bit code
de: %<-muintr%> wird für 32-Bit-Code nicht unterstützt

en: %<-mvrsave=no%> is deprecated; use %<-mno-vrsave%> instead
de: %<-mvrsave=no%> ist veraltet. Verwenden Sie stattdessen %<-mno-vrsave%>

en: %<-mvrsave=yes%> is deprecated; use %<-mvrsave%> instead
de: %<-mvrsave=yes%> ist veraltet. Verwenden Sie stattdessen %<-mvrsave%>

en: %<-mvsx%> and %<-mno-altivec%> are incompatible
de: %<-mvsx%> und %<-mno-altivec%> sind unverträglich

en: %<-mvsx%> needs indexed addressing
de: %<-mvsx%> benötigt indizierte Adressierung

en: %<-mvsx%> requires hardware floating point
de: %<-mvsx%> benötigt Hardware-Gleitkommabefehle

en: %<-mxl-multiply-high%> can be used only with %<-mcpu=v6.00.a%> or greater
de: %<-mxl-multiply-high%> kann nur mit %<-mcpu=v6.00.a%> oder höher verwendet werden

en: %<-mxl-multiply-high%> requires %<-mno-xl-soft-mul%>
de: %<-mxl-multiply-high%> erfordert %<-mno-xl-soft-mul%>

en: %<-mxl-reorder%> can be used only with %<-mcpu=v8.30.a%> or greater
de: %<-mxl-reorder%> kann nur mit %<-mcpu=v8.30.a%> oder höher verwendet werden

en: %<-mxl-reorder%> requires %<-mxl-pattern-compare%> for %<-mcpu=v8.30.a%>
de: %<-mxl-reorder%> erfordert %<-mxl-pattern-compare%> für %<-mcpu=v8.30.a%>

en: %<-pipe%> ignored because %<-save-temps%> specified
de: %<-pipe%> ignoriert, da %<-save-temps%> angegeben wurde

en: %<-pipe%> not supported
de: %<-pipe%> wird nicht unterstützt

en: %<-static-libgfortran%> is not supported in this configuration
de: %<-static-libgfortran%> wird in dieser Konfiguration nicht unterstützt

en: %<-x %s%> after last input file has no effect
de: %<-x %s%> hinter letzter Eingabedatei hat keine Auswirkung

en: %<.%s%> designator used multiple times in the same initializer list
de: %<.%s%>-Name wird mehrfach in derselben Initialisierungsliste verwendet

en: %<...%> handler must be the last handler for its try block
de: %<...%>-Behandler muss der letzte Behandler für seinen »try«-Block sein

en: %<...%> not allowed in designated initializer list
de: %<...%> ist in benannten Initialisierungen nicht erlaubt

en: %<::%> needed in PROCEDURE binding with explicit target at %C
de: %<::%> in PROCEDURE-Bindung mit explizitem Ziel bei %C erforderlich

en: %<::%D%> has not been declared
de: %<::%D%> wurde nicht deklariert

en: %<::%D%> has not been declared; did you mean %qs?
de: %<::%D%> wurde nicht deklariert; meinten Sie %qs?

en: %<::%E%> has not been declared
de: %<::%E%> wurde nicht deklariert

en: %<::%E%> is not a class or namespace
de: %<::%E%> ist keine Klasse oder Namensbereich

en: %<::%E%> is not a class, namespace, or enumeration
de: %<::%E%> ist keine Klasse, Namensbereich oder Aufzählung

en: %<::%E%> is not a type
de: %<::%E%> ist kein Typ

en: %<::main%> must return %<int%>
de: %<::main%> muss %<int%> zurückgeben

en: %<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>
de: %<<:%> ist eine andere Schreibweise für %<[%>. Leerraum zwischen %<<%> und %<::%> einfügen

en: %<<::%> cannot begin a template-argument list
de: %<<::%> kann keine Templateargumentliste einleiten

en: %<<<%> in boolean context, did you mean %<<%>?
de: %<<<%> in booleschem Kontext, meinten Sie %<<%>?

en: %<=%>options missing after %<-foffload-options=%>target
de: %<=%>Optionen fehlen nach %<-foffload-options=%>Ziel

en: %<=> target%> is invalid for DEFERRED binding at %C
de: %<=> target%> ist ungültig für DEFERRED-Bindung bei %C

en: %<>>%> operator is treated as two right angle brackets in C++11
de: Operator %<>>%> wird in C++11 wie zwei spitze schließende Klammern behandelt

en: %<>>%> should be %<> >%> within a nested template argument list
de: %<>>%> sollte innerhalb einer geschachtelten Templateargumentliste %<> >%> sein

en: %<?:%> using integer constants in boolean context
de: %<?:%> mit Ganzzahlkonstanten in booleschem Kontext

en: %<?:%> using integer constants in boolean context, the expression will always evaluate to %<true%>
de: %<?:%> mit Ganzzahlkonstanten in booleschem Zusammenhang; der Ausdruck evaluiert immer zu %<true%>

en: %<@catch%> parameter cannot be protocol-qualified
de: %<@catch%>-Parameter kann nicht Protokoll-qualifiziert sein

en: %<@catch%> parameter is not a known Objective-C class type
de: %<@catch%>-Parameter ist kein bekannter Objective-C-Klassentyp

en: %<@dynamic%> is not available in Objective-C 1.0
de: in Objective-C 1.0 gibt es kein %<@dynamic%>

en: %<@dynamic%> not in @implementation context
de: %<@dynamic%> nicht in @implementation-Kontext

en: %<@dynamic%> requires the @interface of the class to be available
de: %<@dynamic%> erfordert Verfügbarkeit des @interface der Klasse

en: %<@encode%> must specify a type as an argument
de: %<@encode%> muss als Argument einen Typen angeben

en: %<@end%> missing in implementation context
de: %<@end%> fehlt in Implementationskontext

en: %<@end%> must appear in an @implementation context
de: %<@end%> muss in einem @implementation-Kontext auftreten

en: %<@interface%> of class %qE not found
de: %<@interface%> der Klasse %qE nicht gefunden

en: %<@optional%> is allowed in @protocol context only
de: %<@optional%> ist nur im @protocol-Kontext erlaubt

en: %<@optional%> is not available in Objective-C 1.0
de: %<@optional%> ist in Objective-C 1.0 nicht verfügbar

en: %<@package%> is not available in Objective-C 1.0
de: %<@package%> ist in Objective-C 1.0 nicht verfügbar

en: %<@package%> presently has the same effect as %<@public%>
de: %<@package%> hat derzeit den gleichen Effekt wie %<@public%>

en: %<@property%> is not available in Objective-C 1.0
de: %<@property%> ist in Objective-C 1.0 nicht verfügbar

en: %<@required%> is allowed in @protocol context only
de: %<@required%> ist nur im @protocol-Kontext erlaubt

en: %<@required%> is not available in Objective-C 1.0
de: %<@required%> ist in Objective-C 1.0 nicht verfügbar

en: %<@synchronized%> argument is not an object
de: %<@synchronized%>-Argument ist kein Objekt

en: %<@synthesize%> cannot be used in categories
de: %<@synthesize%> kann nicht in Kategorien verwendet werden

en: %<@synthesize%> is not available in Objective-C 1.0
de: in Objective-C 1.0 gibt es kein %<@synthesize%>

en: %<@synthesize%> not in @implementation context
de: %<@synthesize%> nicht in @implementation-Kontext

en: %<@synthesize%> requires the @interface of the class to be available
de: %<@synthesize%> erfordert Verfügbarkeit des @interface der Klasse

en: %<@throw%> (rethrow) used outside of a %<@catch%> block
de: %<@throw%> (rethrow) außerhalb von %<@catch%>-Block verwendet

en: %<@throw%> argument is not an object
de: %<@throw%>-Argument ist kein Objekt

en: %<@try%> without %<@catch%> or %<@finally%>
de: %<@try%> ohne %<@catch%> oder %<@finally%>

en: %<CPU_TYPE%> and %<MPY_TYPE%> column headings are missing from %<devices.csv%>
de: Spaltenüberschriften %<CPU_TYPE%> und %<MPY_TYPE%> fehlen in %<devices.csv%>

en: %<CPU_TYPE%> column heading is missing from %<devices.csv%>
de: Spaltenüberschrift %<CPU_TYPE%> fehlt in %<devices.csv%>

en: %<CTABLE_ENTRY%> base address is not a multiple of 256
de: %<CTABLE_ENTRY%>-Basisadresse muss ein Vielfaches von 256 sein

en: %<CTABLE_ENTRY%> index %
de: N/A

en: %<DEFFERED_INIT%> calls should have same constant size for the first argument and LHS
de: %<DEFFERED_INIT%>-Aufrufe sollten die gleiche konstante Größe für das erste Argument und LHS haben

en: %<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause
de: %<DETACH%>-Klausel bei %L darf nicht zusammen mit %<MERGEABLE%>-Klausel verwendet werden

en: %<G0%> in format at %L
de: %<G0%> in Format bei %L

en: %<GCC ivdep%> directive not at the start of a loop at %C
de: Die Direktive %<GCC unroll%> bei %C darf nur direkt vor einem Schleifenbeginn stehen

en: %<GCC novector%> directive not at the start of a loop at %C
de: Die Direktive %<GCC unroll%> bei %C darf nur direkt vor einem Schleifenbeginn stehen

en: %<GCC unroll%> directive not at the start of a loop at %C
de: Die Direktive %<GCC unroll%> bei %C darf nur direkt vor einem Schleifenbeginn stehen

en: %<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C
de: Direktive %<GCC unroll%> bei %2$C verlangt eine konstante Anzahl (maximal %1$u)

en: %<GCC vector%> directive not at the start of a loop at %C
de: Die Direktive %<GCC unroll%> bei %C darf nur direkt vor einem Schleifenbeginn stehen

en: %<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model
de: %<HLE_ACQUIRE%> wird mit %<ACQUIRE%> oder stärkerem Speichermodell nicht verwendet

en: %<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model
de: %<HLE_RELEASE%> wird mit %<RELEASE%> oder stärkerem Speichermodell nicht verwendet

en: %<LEXER_DEBUGGING_ENABLED_P%> is not set to true
de: %<LEXER_DEBUGGING_ENABLED_P%> ist nicht auf true gesetzt

en: %<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0
de: Argument %<MOLD%> des intrinsischen %<TRANSFER%> bei %L ist ein Array und darf nicht die Speichergröße 0 haben, da das %<SOURCE%>-Argument größer als 0 ist

en: %<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s
de: Argument %<MOLD%> des intrinsischen %<TRANSFER%> bei %L darf nicht %s sein

en: %<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s
de: Argument %<MOLD%> des intrinsischen %<TRANSFER%> bei %L darf kein %s sein

en: %<MPY_TYPE%> column heading is missing from %<devices.csv%>
de: Spaltenüberschrift %<MPY_TYPE%> fehlt in %<devices.csv%>

en: %<PRINT_OPERAND%> null pointer
de: %<PRINT_OPERAND%> Null-Zeiger

en: %<PRINT_OPERAND%>: Unknown punctuation %<%c%>
de: %<PRINT_OPERAND%>: Unbekanntes Satzzeichen %<%c%>

en: %<PRINT_OPERAND_ADDRESS%>, null pointer
de: %<PRINT_OPERAND_ADDRESS%>, Null-Zeiger

en: %<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s
de: Argument %<SOURCE%> des intrinsischen %<TRANSFER%> bei %L darf kein %s sein

en: %<TREE_PURPOSE%> is non-NULL in %<TYPE_ARG_TYPES%> list
de: Interner Compilerfehler: %<TREE_PURPOSE%> is non-NULL in %<TYPE_ARG_TYPES%> list

en: %<TYPE_ARRAY_MAX_SIZE%> not %<INTEGER_CST%>
de: Interner Compilerfehler: %<TYPE_ARRAY_MAX_SIZE%> not %<INTEGER_CST%>

en: %<TYPE_BINFO%> is not %<TREE_BINFO%>
de: Interner Compilerfehler: %<TYPE_BINFO%> is not %<TREE_BINFO%>

en: %<TYPE_BINFO%> type is not %<TYPE_MAIN_VARIANT%>
de: Interner Compilerfehler: %<TYPE_BINFO%> type is not %<TYPE_MAIN_VARIANT%>

en: %<TYPE_CACHED_VALUES%> is not %<TREE_VEC%>
de: Interner Compilerfehler: %<TYPE_CACHED_VALUES%> is not %<TREE_VEC%>

en: %<TYPE_CACHED_VALUES_P%> is %i while %<TYPE_CACHED_VALUES%> is %p
de: Interner Compilerfehler: %<TYPE_CACHED_VALUES_P%> is %i while %<TYPE_CACHED_VALUES%> is %p

en: %<TYPE_CACHED_VALUES_P%> is set while it should not be
de: Interner Compilerfehler: %<TYPE_CACHED_VALUES_P%> is set while it should not be

en: %<TYPE_CANONICAL%> has different %<TYPE_CANONICAL%>
de: Interner Compilerfehler: %<TYPE_CANONICAL%> has different %<TYPE_CANONICAL%>

en: %<TYPE_CANONICAL%> is not compatible
de: Interner Compilerfehler: %<TYPE_CANONICAL%> is not compatible

en: %<TYPE_CANONICAL%> of main variant is not main variant
de: Interner Compilerfehler: %<TYPE_CANONICAL%> of main variant is not main variant

en: %<TYPE_FIELDS%> defined in incomplete type
de: Interner Compilerfehler: %<TYPE_FIELDS%> defined in incomplete type

en: %<TYPE_LANG_SLOT_1 (binfo)%> field is non-NULL
de: Interner Compilerfehler: %<TYPE_LANG_SLOT_1 (binfo)%> field is non-NULL

en: %<TYPE_MAIN_VARIANT%> has different %<TYPE_MAIN_VARIANT%>
de: Interner Compilerfehler: %<TYPE_MAIN_VARIANT%> has different %<TYPE_MAIN_VARIANT%>

en: %<TYPE_MAX_VALUE_RAW%> non-NULL
de: Interner Compilerfehler: %<TYPE_MAX_VALUE_RAW%> non-NULL

en: %<TYPE_METHOD_BASETYPE%> is not main variant
de: Interner Compilerfehler: %<TYPE_METHOD_BASETYPE%> is not main variant

en: %<TYPE_METHOD_BASETYPE%> is not record nor union
de: Interner Compilerfehler: %<TYPE_METHOD_BASETYPE%> is not record nor union

en: %<TYPE_MODE%> of %<TYPE_CANONICAL%> is not compatible
de: Interner Compilerfehler: %<TYPE_MODE%> of %<TYPE_CANONICAL%> is not compatible

en: %<TYPE_NEXT_PTR_TO%> is not %<POINTER_TYPE%>
de: Interner Compilerfehler: %<TYPE_NEXT_PTR_TO%> is not %<POINTER_TYPE%>

en: %<TYPE_NEXT_REF_TO%> is not %<REFERENCE_TYPE%>
de: Interner Compilerfehler: %<TYPE_NEXT_REF_TO%> is not %<REFERENCE_TYPE%>

en: %<TYPE_OFFSET_BASETYPE%> is not record nor union
de: Interner Compilerfehler: %<TYPE_OFFSET_BASETYPE%> is not record nor union

en: %<TYPE_VALUES_RAW%> field is non-NULL
de: Interner Compilerfehler: %<TYPE_VALUES_RAW%> field is non-NULL

en: %<TYPE_VFIELD%> is not %<FIELD_DECL%> nor %<TREE_LIST%>
de: Interner Compilerfehler: %<TYPE_VFIELD%> is not %<FIELD_DECL%> nor %<TREE_LIST%>

en: %<V%> modifier on non-integer register
de: %<V%>-Modifikator an nicht-ganzzahligem Register

en: %<[%E] =%> used in a GNU-style designated initializer for class %qT
de: %<[%E] =%> in benannter Initialisierung im GNU-Stil für Klasse %qT verwendet

en: %<[*]%> not allowed in other than function prototype scope
de: %<[*]%> außerhalb des Bereichs des Funktionsprototypen nicht erlaubt

en: %<[*]%> not in a declaration
de: %<[*]%> nicht in einer Deklaration

en: %<[[omp::directive(%s)]]%> must be the only specified attribute on a statement
de: %<[[omp::directive(%s)]]%> muss das einzige angegebene Attribut in einer Anweisung sein

en: %<[super ...]%> must appear in a method context
de: %<[super …]%> darf nur in einem Methodenkontext auftreten

en: %<_Alignas%> specifiers cannot reduce alignment of %qE
de: %<_Alignas%>-Spezifizierer können nicht die Ausrichtung von %qE reduzieren

en: %<_Alignas%> specifiers cannot reduce alignment of compound literal
de: %<_Alignas%>-Spezifizierer können nicht die Ausrichtung eines zusammengesetzten Feldes reduzieren

en: %<_Alignas%> specifiers cannot reduce alignment of unnamed field
de: %<_Alignas%>-Spezifizierer können nicht die Ausrichtung eines unbenannten Feldes reduzieren

en: %<_Atomic%> %qD in %<aligned%> clause
de: %<_Atomic%> %qD in %<aligned%>-Klausel

en: %<_Atomic%> %qD in %<firstprivate%> clause on %<target%> construct
de: %<_Atomic%> %qD in %<firstprivate%>-Klausel am %<target%>-Konstrukt

en: %<_Atomic%> %qD in %<linear%> clause
de: %<_Atomic%> %qD in %<linear%>-Klausel

en: %<_Atomic%> %qD in %qs clause
de: %<_Atomic%>-Deklaration %qD in %qs-Klausel

en: %<_Atomic%> %qD in implicit %<firstprivate%> clause on %<target%> construct
de: %<_Atomic%> %qD in impliziter %<firstprivate%>-Klausel am %<target%>-Konstrukt

en: %<_Atomic%> %qD in implicit %<map%> clause
de: %<_Atomic%> %qD in implizier %<map%>-Klausel

en: %<_Atomic%> %qE in %<reduction%> clause
de: %<_Atomic%> %qE in %<reduction%>-Klausel

en: %<_Atomic%> %qE in %qs clause
de: %<_Atomic%>-Ausdruck %qE in %qs-Klausel

en: %<_Atomic%> applied to a qualified type
de: %<_Atomic%> auf einen qualifizierten Typen angewandt

en: %<_Atomic%> expression in %<#pragma omp atomic%>
de: %<_Atomic%>-Ausdruck in %<#pragma omp atomic%>

en: %<_Atomic%> iteration variable %qE
de: %<_Atomic%>-Iterationsvariable %qE

en: %<_Atomic%> qualified type in %<#pragma omp declare reduction%>
de: %<_Atomic%>-qualifizierter Typ in %<#pragma omp declare reduction%>

en: %<_Atomic%>-qualified array type
de: %<_Atomic%>-qualifizierter Arraytyp

en: %<_Atomic%>-qualified function type
de: %<_Atomic%>-qualifizierter Funktionstyp

en: %<_Atomic%>-qualified parameter type %qT of %q+D
de: %<_Atomic%>-qualifizierter Parametertyp %qT von %q+D

en: %<_Atomic%>-qualified return type of %qD
de: %<_Atomic%>-qualifizierter Rückgabetyp von %qD

en: %<_Float%d%s%> is not supported on this target
de: %<_Float%d%s%> wird für dieses Ziel nicht unterstützt

en: %<_Generic%> association has function type
de: %<_Generic%>-Zuordnung hat Funktionstyp

en: %<_Generic%> association has incomplete type
de: %<_Generic%>-Zuordnung hat unvollständigen Typ

en: %<_Generic%> association has variable length type
de: %<_Generic%>-Verbindung hat variable Typlänge

en: %<_Generic%> selector matches multiple associations
de: %<_Generic%>-Selektor passt zu mehreren Zuordnungen

en: %<_Generic%> selector of type %qT is not compatible with any association
de: %<_Generic%>-Selektor vom Typ %qT ist mit keiner der Zuordnungen kompatibel

en: %<_Generic%> specifies two compatible types
de: %<_Generic%> gibt zwei kompatible Typen an

en: %<_Noreturn%> in empty declaration
de: %<_Noreturn%> in leerer Deklaration

en: %<_Sat%> is used without %<_Fract%> or %<_Accum%>
de: %<_Sat%> ohne %<_Fract%> oder %<_Accum%> verwendet

en: %<__BELOW100__%> attribute not allowed with auto storage class
de: Attribut %<__BELOW100__%> nicht mit Speicherklasse »auto« erlaubt

en: %<__BELOW100__%> attribute only applies to variables
de: Attribut %<__BELOW100__%> bezieht sich nur auf Variablen

en: %<__GIMPLE%> only valid with %<-fgimple%>
de: %<__GIMPLE%> ist nur mit %<-fgimple%> gültig

en: %<__RTL%> function cannot be compiled with %<-flto%>
de: Funktion %<__RTL%> kann nicht mit %<-flto%> kompiliert werden

en: %<__alignof%> applied to a bit-field
de: %<__alignof%> auf Bitfeld angewandt

en: %<__auto_type%> followed by %<[[]]%> attributes
de: %<__auto_type%> gefolgt von %<[[]]%>-Attributen

en: %<__auto_type%> in empty declaration
de: %<__auto_type%> in leerer Deklaration

en: %<__auto_type%> may only be used with a single declarator
de: %<__auto_type%> kann nur mit einem einzelnen Deklarator verwendet werden

en: %<__auto_type%> requires a plain identifier as declarator
de: %<__auto_type%> erfordert einen einfachen Bezeichner als Deklarator

en: %<__auto_type%> requires an initialized data declaration
de: %<__auto_type%> benötigt eine initialisierte Datendeklaration

en: %<__auto_type%> used with a bit-field initializer
de: %<__auto_type%> wird mit einem Bitfeld-Initialisierer verwendet

en: %<__builtin_arc_aligned%> with non-constant alignment
de: %<__builtin_arc_aligned%> mit nichtkonstanter Ausrichtung

en: %<__builtin_bit_cast%> destination type %qT is an array type
de: Zieltyp %qT von %<__builtin_bit_cast%> ist ein Arraytyp

en: %<__builtin_bit_cast%> destination type %qT is not trivially copyable
de: Zieltyp %qT von %<__builtin_bit_cast%> ist nicht trivial kopierbar

en: %<__builtin_bit_cast%> source size %qE not equal to destination type size %qE
de: in %<__builtin_bit_cast%> ist die Quellgröße %qE ungleich der Zieltypgröße %qE

en: %<__builtin_bit_cast%> source type %qT is not trivially copyable
de: Quelltyp %qT von %<__builtin_bit_cast%> ist nicht trivial kopierbar

en: %<__builtin_complex%> operand not of real binary floating-point type
de: Operand von %<__builtin_complex%> nicht realer binärer Gleitkommatyp

en: %<__builtin_complex%> operands of different types
de: Operanden von %<__builtin_complex%> unterschiedlichen Typs

en: %<__builtin_convertvector%> first argument must be an integer or floating vector
de: Das erste Argument von %<__builtin_convertvector%> muss Ganzzahl- oder Gleitkommavektor sein

en: %<__builtin_convertvector%> number of elements of the first argument vector and the second argument vector type should be the same
de: Anzahl der Elemente des ersten Argumentvektors und des Typs des zweiten Argumentvektors für %<__builtin_convertvector%> sollten gleich sein

en: %<__builtin_convertvector%> second argument must be an integer or floating vector type
de: Das zweite Argument von %<__builtin_convertvector%> muss Ganzzahl- oder Gleitkommavektortyp sein

en: %<__builtin_eh_return%> not supported on this target
de: %<__builtin_eh_return%> für dieses Ziel nicht unterstützt

en: %<__builtin_has_attribute%> with dependent argument not supported yet
de: %<__builtin_has_attribute%> mit abhängigem Argument wird noch nicht unterstützt

en: %<__builtin_is_corresponding_member%> argument is not pointer to member
de: Argument von %<__builtin_is_corresponding_member%> muss ein Zeiger auf Member sein

en: %<__builtin_is_corresponding_member%> needs two arguments
de: %<__builtin_is_corresponding_member%> benötigt zwei Argumente

en: %<__builtin_is_corresponding_member%> not well defined for anonymous unions
de: %<__builtin_is_corresponding_member%> nicht wohldefiniert für anonyme Vereinigungen

en: %<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member
de: Argument von %<__builtin_is_pointer_interconvertible_with_class%> muss ein Zeiger auf Member sein

en: %<__builtin_is_pointer_interconvertible_with_class%> needs a single argument
de: %<__builtin_is_pointer_interconvertible_with_class%> benötigt ein einziges Argument

en: %<__builtin_longjmp%> second argument must be 1
de: Zweites Argument für %<__builtin_longjmp%> muss 1 sein

en: %<__builtin_next_arg%> called without an argument
de: %<__builtin_next_arg%> ohne Argument gerufen

en: %<__builtin_rx_%s%> takes %<C%>, %<Z%>, %<S%>, %<O%>, %<I%>, or %<U%>
de: %<__builtin_rx_%s%> benötigt %<C%>, %<Z%>, %<S%>, %<O%>, %<I%> oder %<U%>

en: %<__builtin_saveregs%> not supported by this subtarget
de: %<__builtin_saveregs%> wird für dieses Teilziel nicht unterstützt

en: %<__builtin_saveregs%> not supported by this target
de: %<__builtin_saveregs%> wird von diesem Ziel nicht unterstützt

en: %<__builtin_set_thread_pointer%> is not supported on this target
de: %<__builtin_set_thread_pointer%> wird für dieses Ziel nicht unterstützt

en: %<__builtin_shuffle%> argument vector(s) inner type must have the same size as inner type of the mask
de: Innere Typen des/der Argumentvektors/en und Maske von %<__builtin_shuffle%> müssen gleiche Größe haben

en: %<__builtin_shuffle%> argument vectors must be of the same type
de: Vektorargumente von %<__builtin_shuffle%> müssen gleichen Typ haben

en: %<__builtin_shuffle%> arguments must be vectors
de: Argumente für %<__builtin_shuffle%> müssen Vektoren sein

en: %<__builtin_shuffle%> last argument must be an integer vector
de: Das letzte Argument von %<__builtin_shuffle%> muss Ganzzahlvektor sein

en: %<__builtin_shuffle%> number of elements of the argument vector(s) and the mask vector should be the same
de: Anzahl der Elemente des/der Argumentvektors/en und des Maskenvektors für %<__builtin_shuffle%> sollten gleich sein

en: %<__builtin_shufflevector%> argument vectors must have the same element type
de: Vektorargumente von %<__builtin_shufflevector%> müssen den gleichen Typ haben

en: %<__builtin_shufflevector%> arguments must be constant size vectors
de: Argumente für %<__builtin_shufflevector%> müssen Vektoren konstanter Größe sein

en: %<__builtin_shufflevector%> arguments must be vectors
de: Argumente für %<__builtin_shufflevector%> müssen Vektoren sein

en: %<__builtin_shufflevector%> must specify a result with a power of two number of elements
de: %<__builtin_shufflevector%> muss ein Ergebnis mit einer Zweierpotenz von Elementen angeben

en: %<__builtin_thread_pointer%> is not supported on this target
de: %<__builtin_thread_pointer%> wird für dieses Ziel nicht unterstützt

en: %<__builtin_unreachable%> or %<__builtin_trap%> call with arguments
de: Aufruf von %<__builtin_unreachable%> oder %<__builtin_trap%> mit Argumenten

en: %<__delay_cycles%> is limited to 32-bit loop counts
de: %<__delay_cycles%> ist auf 32-Bit-Schleifendurchläufe beschränkt

en: %<__delay_cycles%> only takes constant arguments
de: %<__delay_cycles%> nimmt nur konstante Argumente entgegen

en: %<__delay_cycles%> only takes non-negative cycle counts
de: %<__delay_cycles%> nimmt nur nicht-negative Zykluszahlen entgegen

en: %<__fp16%> and no ldrh
de: %<__fp16%> ohne %<ldrh%>

en: %<__gcc_host_wide_int__%> is not defined as %<long%> or %<long long%>
de: %<__gcc_host_wide_int__%> ist nicht als %<long%> oder %<long long%> definiert

en: %<__gcc_host_wide_int__%> is not defined as a type
de: %<__gcc_host_wide_int__%> ist nicht als Typ definiert

en: %<__int%d%> is not supported by this target
de: %<__int%d%> wird von diesem Ziel nicht unterstützt

en: %<__int%d%> is not supported on this target
de: %<__int%d%> wird für dieses Ziel nicht unterstützt

en: %<__label__%> declarations are only allowed in function scopes
de: %<__label__%>-Deklarationen sind nur im Funktionsgültigkeitsbereich erlaubt

en: %<__label__%> not at the beginning of a block
de: %<__label__%> nicht am Anfang eines Blocks

en: %<__restrict%> can only be specified for objects and functions
de: %<__restrict%> kann nur für Objekte und Funktionen angegeben werden

en: %<__thread%> before %<extern%>
de: %<__thread%> vor %<extern%>

en: %<__thread%> before %<static%>
de: %<__thread%> vor %<static%>

en: %<__thread%> before %qD
de: %<__thread%> vor %qD

en: %<__thread%> can only be specified for objects and functions
de: %<__thread%> kann nur für Objekte und Funktionen angegeben werden

en: %<__transaction_atomic%> without transactional memory support enabled
de: %<__transaction_atomic%> ohne eingeschaltete Unterstützung für transaktionsgebundenen Speicher

en: %<__transaction_cancel%> not within %<__transaction_atomic%>
de: %<__transaction_cancel%> nicht innerhalb von %<__transaction_atomic%>

en: %<__transaction_cancel%> within a %<__transaction_relaxed%>
de: %<__transaction_cancel%> innerhalb eines %<__transaction_relaxed%>

en: %<__transaction_cancel%> without transactional memory support enabled
de: %<__transaction_cancel%> ohne eingeschaltete Unterstützung für transaktionsbasierten Speicher

en: %<__transaction_relaxed%> without transactional memory support enabled
de: %<__transaction_relaxed%> ohne eingeschaltete Unterstützung für transaktionsgebundenen Speicher

en: %<a%d%> argument of %qs intrinsic at %L must be %s(%d)
de: Argument %<a%d%> des intrinsischen %qs bei %L muss %s(%d) sein

en: %<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER
de: Argument %<a1%> des intrinsischen %qs bei %L muss INTEGER, REAL oder CHARACTER sein

en: %<acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause at %L
de: %<acc update%> bei %L muss mindestens eine %<device%>- oder %<host%>- oder %<self%>-Klausel enthalten

en: %<alias%> attribute ignored because function is defined
de: Attribut %<alias%> ignoriert, da Funktion bereits definiert ist

en: %<alignas%> argument has non-integral type %qT
de: Argument für %<alignas%> hat nicht-ganzzahligen Typen %qT

en: %<aligned%> clause alignment expression must be integral
de: Ausdruck für Ausrichtung der %<aligned%>-Klausel muss ganzzahlig sein

en: %<aligned%> clause alignment expression must be positive constant integer expression
de: Ausdruck für %<aligned%>-Klausel erfordert positiven konstanten Ganzzahlausdruck

en: %<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression
de: in der %<allocate%>-Klausel muss das Argument des %<align%>-Modifizierers eine positive konstante Zweierpotenz eines ganzzahligen Ausdrucks sein

en: %<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>
de: Allokationsausdruck in %<allocate%>-Klausel ist vom Typ %qT statt des erwarteten %<omp_allocator_handle_t%>

en: %<allocator%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>
de: Allokationsausdruck in %<allocator%>-Klausel ist vom Typ %qT statt des erwarteten %<omp_allocator_handle_t%>

en: %<always_inline%> function might not be inlinable
de: %<always_inline%> Funktion ist möglicherweise nicht inlinefähig

en: %<amdgpu_hsa_kernel%> attribute requires string constant arguments
de: Attribut %<amdgpu_hsa_kernel%> erfordert Zeichenkettenkonstanten als Argumente

en: %<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause
de: %<ancestor%>-Gerätemodifikator, dem keine %<requires%>-Direktive mit %<reverse_offload%>-Klausel vorausgeht

en: %<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause at %C
de: %<ancestor%>-Gerätemodifizierer bei %C, dem keine %<requires%>-Direktive mit %<reverse_offload%>-Klausel vorausgeht

en: %<ancestor%> not yet supported
de: %<ancestor%> wird noch nicht unterstützt

en: %<and%> of mutually exclusive equal-tests is always 0
de: %<und%> bei sich gegenseitig ausschließenden Gleichheits-Tests ist immer 0

en: %<asm goto%> with complex typed outputs
de: %<asm goto%> mit komplexen typisierten Ausgaben

en: %<asm%> clobber conflict with input operand
de: %<asm%>-Konflikt mit Eingabeoperand

en: %<asm%> clobber conflict with output operand
de: %<asm%>-Konflikt mit Ausgabeoperand

en: %<asm%> declaration ignored due to conflict with previous rename
de: %<asm%>-Deklaration wird wegen Konflikt mit vorheriger Umbenennung ignoriert

en: %<asm%> flags not supported in thumb1 mode
de: %<asm%>-Schalter werden im Thumb1-Modus nicht unterstützt

en: %<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>
de: %<asm%> innerhalb einer %<constexpr%>-Funktion ist erst ab %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: %<asm%> not allowed in %<transaction_safe%> function
de: %<asm%> in %<transaction_safe%>-Funktion ist nicht erlaubt

en: %<asm%> not allowed in atomic transaction
de: in atomarer Transaktion ist kein %<asm%> erlaubt

en: %<asm%> operand %d probably does not match constraints
de: %<asm%>-Operand %d passt wahrscheinlich nicht zu den Bedingungen

en: %<asm%> operand constraint incompatible with operand size
de: %<asm%>-Operandenbedingung inkompatibel mit Operandengröße

en: %<asm%> operand has impossible constraints
de: %<asm%>-Operand hat unmögliche Nebenbedingungen

en: %<asm%> operand requires impossible reload
de: %<asm%>-Operand erfordert unmögliches Neuladen

en: %<asm%> qualifier %qT ignored outside of function body
de: %<asm%>-Qualifizierer %qT wird ignoriert, da außerhalb des Funktionsrumpfes

en: %<asm%> qualifier outside of function body
de: %<asm%>-Qualifizierer außerhalb des Funktionsrumpfes

en: %<asm%> specifier for variable %qE conflicts with %<asm%> clobber list
de: %<asm%>-Spezifizierer für Variable %qE steht in Konflikt mit %<asm%>-Bestrafungs-Liste

en: %<asm%> specifiers are not permitted on non-static data members
de: %<asm%>-Symbole sind an nicht statischen Datenelementen nicht erlaubt

en: %<assign%> can be unsafe for Objective-C objects; please state explicitly if you need it
de: %<assign%> kann für Objective-C-Objekte unsicher sein; bitte explizit angeben, falls nötig

en: %<assign%> property %qs is using bit-field instance variable %qs
de: %<assign%>-Eigenschaft %qs verwendet Bitfeld-Instanzvariable %qs

en: %<async%> expression must be integral
de: %<async%>-Ausdruck muss ganzzahlig sein

en: %<atexit%> failed
de: %<atexit%> fehlgeschlagen

en: %<atomic%> property %qs is using bit-field instance variable %qs
de: %<atomic%>-Eigenschaft %qs verwendet Bitfeld-Instanzvariable %qs

en: %<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause
de: %<atomic_default_mem_order%>-Klausel wird lexikalisch nach dem ersten %<atomic%>-Konstrukt ohne Speicherreihenfolge-Klausel verwendet

en: %<auto%> can only be specified for variables or function declarations
de: %<auto%> kann nur für Variablen oder Funktionsdeklarationen angegeben werden

en: %<auto%> changes meaning in C++11; please remove it
de: Bedeutung von %<auto%> ändert in C++11 die Bedeutung; Bitte entfernen

en: %<auto%> conflicts with other OpenACC loop specifiers
de: %<auto%> steht in Konflikt mit anderen OpenACC-Schleifenspezifizierern

en: %<auto%> in file-scope empty declaration
de: %<auto%> in leerer Deklaration im Datei-Gültigkeitsbereich

en: %<auto%> not allowed in alias declaration
de: %<auto%> ist in Aliasdeklaration nicht erlaubt

en: %<auto%> parameter not permitted in this context
de: %<auto%>-Parameter darf in diesem Kontext nicht verwendet werden

en: %<auto(x)%> cannot be constrained
de: %<auto(x)%> kann nicht eingeschränkt werden

en: %<auto(x)%> only available with %<-std=c++2b%> or %<-std=gnu++2b%>
de: %<auto{x}%> ist erst mit %<-std=c++2b%> oder %<-std=gnu++2b%> verfügbar

en: %<auto{x}%> cannot be constrained
de: %<auto{x}%> kann nicht eingeschränkt werden

en: %<auto{x}%> only available with %<-std=c++2b%> or %<-std=gnu++2b%>
de: %<auto{x}%> ist erst mit %<-std=c++2b%> oder %<-std=gnu++2b%> verfügbar

en: %<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle
de: %<await_suspend%> muss %<void%>, %<bool%> oder ein Koroutine-Handle zurückgeben

en: %<bank_switch%> has no effect on non-interrupt functions
de: %<bank_switch%> hat auf Nicht-Interrupt-Funktionen keine Auswirkung

en: %<bind%> clause not specified on a %<loop%> construct not nested inside another OpenMP construct
de: %<bind%>-Klausel nicht auf einem %<loop%>-Konstrukt, das nicht in einem anderen OpenMP-Konstrukt geschachtelt ist

en: %<bind(parallel)%> on a %<loop%> construct nested inside %<simd%> construct
de: %<bind(parallel)%> an einem %<loop%>-Konstrukt, das in einem %<simd%>-Konstrukt geschachtelt ist

en: %<bind(teams)%> on a %<loop%> region not strictly nested inside of a %<teams%> region
de: %<bind(teams)%> an einer %<loop%>-Region, die nicht streng innerhalb einer %<teams%>-Region geschachtelt ist

en: %<builtin_return_address%> contains only 2 bytes of address
de: %<builtin_return_address%> enthält nur 2 Adressbytes

en: %<cancel for%> inside %<nowait%> for construct
de: %<cancel for%> innerhalb von %<nowait%>-for-Konstrukt

en: %<cancel for%> inside %<ordered%> for construct
de: %<cancel for%> innerhalb von %<ordered%>-for-Konstrukt

en: %<cancel sections%> inside %<nowait%> sections construct
de: %<cancel sections%> innerhalb %<nowait%>-Abschnittskonstrukt

en: %<catch%> is not supported
de: %<catch%> wird nicht unterstützt

en: %<concept%> only available with %<-std=c++20%> or %<-fconcepts%>
de: %<concept%> ist erst ab %<-std=c++20%> oder mit %<-fconcepts%> verfügbar

en: %<const%> %qs cannot be declared %<mutable%>
de: %qs ist %<const%> und darf daher nicht als %<mutable%> deklariert sein

en: %<const%> and %<volatile%> function specifiers on %qD invalid in field declaration
de: Funktionsspezifizierer %<const%> und %<volatile%> an %qD ungültig in Felddeklaration

en: %<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration
de: Funktionsspezifizierer %<const%> und %<volatile%> an %qD ungültig in Parameterdeklaration

en: %<const%> and %<volatile%> function specifiers on %qD invalid in type declaration
de: Funktionsspezifizierer %<const%> und %<volatile%> an %qD ungültig in Typdeklaration

en: %<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration
de: Funktionsspezifizierer %<const%> und %<volatile%> an %qD ungültig in Variablendeklaration

en: %<const%> can only be specified for objects and functions
de: %<const%> kann nur für Objekte und Funktionen angegeben werden

en: %<const%> qualified %<depobj%> expression
de: %<const%>-qualifizierter %<depobj%>-Ausdruck

en: %<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses
de: %<const%>-qualifiziertes %qE darf nur in %<shared%>- oder %<firstprivate%>-Klauseln vorkommen

en: %<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses
de: %<const%>-qualifiziertes %qE ohne %<mutable%>-Element darf nur in %<shared%>- oder %<firstprivate%>-Klauseln vorkommen

en: %<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>
de: %<const%>-, %<volatile%>- oder %<__restrict%>-qualifizierter Typ %qT in %<#pragma omp declare reduction%>

en: %<consteval%> function %q+D overriding non-%<consteval%> function
de: %<consteval%>-Funktion %q+D übersteuert nicht-%<consteval%>-Funktion

en: %<constexpr%> call flows off the end of the function
de: Kontrollfluss für %<constexpr%>-Aufruf fällt hinten aus der Funktion

en: %<constexpr%> constructor does not have empty body
de: %<constexpr%>-Konstruktor hat keinen leeren Körper

en: %<constexpr%> constructor for union %qT must initialize exactly one non-static data member
de: %<constexpr%>-Konstruktor für Union %qT muss genau ein nicht-statisches Datenelement initialisieren

en: %<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>
de: %<constexpr%>-Destruktoren sind erst ab %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: %<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)
de: Auswertungstiefe von %<constexpr%> überschreitet Höchstwert %d (%<-fconstexpr-depth=%> verwenden, um dies zu erhöhen)

en: %<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)
de: Anzahl der Evaluierungsoperationen in %<constexpr%> überschreitet Höchstwert %wd (%<-fconstexpr-ops-limit=%> verwenden, um diesen zu erhöhen)

en: %<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>
de: %<constexpr%>-Lambda ist nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar

en: %<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)
de: Anzahl der Schleifendurchläufe in %<constexpr%> überschreitet Höchstwert %d (%<-fconstexpr-loop-limit=%> verwenden, um diesen zu erhöhen)

en: %<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type
de: %<constexpr%> erforderlich für Initialisierung innerhalb der Klasse des statischen Datenelements %q#D mit nicht eingebautem Typ

en: %<constexpr%> static data member %qD must have an initializer
de: statisches Datenelement %qD (%<constexpr%>) muss Initialisierung haben

en: %<constexpr%> variable %qD has variably-modified type %qT
de: %<constexpr%>-Variable %qD hat variabel modifizierten Typ %qT

en: %<constinit%> can only be applied to a variable with static or thread storage duration
de: Attribut %<constinit%> kann nur für Variablen verwendet werden, die »static« oder threadlokel sind

en: %<constinit%> on function return type is not allowed
de: %<constinit%> ist am Rückgabetyp einer Funktion nicht erlaubt

en: %<constinit%> variable %qD does not have a constant initializer
de: %<constinit%>-Variable %qD muss eine konstante Initialisierung haben

en: %<critical%> region may not be nested inside a %<critical%> region with the same name
de: %<critical%>-Region darf innerhalb einer gleichnamigen %<critical%>-Region nicht eng geschachtelt sein

en: %<custom-%s=%> argument should be a non-negative integer
de: Argument von %<custom-%s=%> muss eine nicht-negative Ganzzahl sein

en: %<custom-%s=%> is not recognized as FPU instruction
de: %<custom-%s=%> ist nicht als ein FPU-Befehl bekannt

en: %<custom-%s=%> requires argument
de: %<custom-%s=%> erfordert Argument

en: %<custom-fpu-cfg%> option does not support %<no-%>
de: Option %<custom-fpu-cfg%> unterstützt kein %<no-%>

en: %<custom-fpu-cfg%> option requires configuration argument
de: Option %<custom-fpu-cfg%> erfordert Konfigurationsargument

en: %<decl-specifier%> in declaration of deduction guide
de: %<decl-specifier%> in Deklaration von Ableitungshinweis

en: %<declare %s%> directive not immediately followed by function declaration or definition
de: %<declare %s%> muss direkt von einer Funktionsdeklaration oder -definition gefolgt sein

en: %<declare target%> in attribute syntax terminated with %<end declare target%> in pragma syntax
de: %<declare target%> beginnt in der Attributsyntax, wird aber mit %<end declare target%> in der Pragma-Syntax abgeschlossen

en: %<declare target%> in pragma syntax terminated with %<end declare target%> in attribute syntax
de: %<declare target%> beginnt in der Pragma-Syntax, wird aber mit %<end declare target%> in der Attributsyntax abgeschlossen

en: %<declare variant%> on constructor %qD
de: %<declare variant%> für Konstruktor %qD

en: %<declare variant%> on defaulted %qD
de: %<declare variant%> an %qD mit Vorgabewert

en: %<declare variant%> on deleted %qD
de: %<declare variant%> an gelöschter %qD

en: %<declare variant%> on destructor %qD
de: %<declare variant%> für Destruktor %qD

en: %<declare variant%> on virtual %qD
de: %<declare variant%> an virtueller %qD

en: %<decltype%> cannot resolve address of overloaded function
de: %<decltype%> kann die Adresse der überladenen Funktion nicht auflösen

en: %<decltype%> evaluates to %qT, which is not a class or enumeration type
de: %<decltype%> wird zu %qT ausgewertet, und das ist weder eine Klasse noch ein Aufzählungstyp

en: %<decltype(auto)%> cannot be cv-qualified
de: %<decltype(auto)%> darf nicht CV-qualifiziert sein

en: %<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>
de: die Typangabe %<decltype(auto)%> ist erst mit %<-std=c++14%> oder %<-std=gnu++14%> verfügbar

en: %<default%> label not within a switch statement
de: %<default%>-Marke nicht innerhalb einer switch-Anweisung

en: %<default%> target was not set
de: %<default%>-Ziel wurde nicht gesetzt

en: %<delete[]%> is not a constant expression
de: %<delete[]%> ist kein Konstantenausdruck

en: %<depend%> clause with %<depobj%> dependence type on array section
de: %<depend%>-Klausel mit %<depobj%>-Abhängigkeitstyp auf Arrayabschnitt

en: %<depend%> clause with %<sink%> modifier refers to iteration never in the iteration space
de: %<depend%>-Klausel mit %<sink%>-Modifizierer verweist auf Iteration, die niemals im Iterationsraum ist

en: %<depend%> clause with %<sink%> modifier waiting for lexically later iteration
de: %<depend%>-Klausel mit %<sink%>-Modifizierer wartet auf lexikalisch spätere Iteration

en: %<depend%> clause with %<source%> modifier specified together with %<depend%> clauses with %<sink%> modifier on the same construct
de: %<depend%>-Klausel mit %<source%>-Modifizierer zusammen mit %<depend%>-Klauseln mit %<sink%>-Modifizierer an demselben Konstrukt

en: %<depend(%s)%> is only allowed in %<omp ordered%>
de: %<depend(%s)%> ist nur in %<omp ordered%> erlaubt

en: %<depobj%> dependence type specified in %<depend%> clause on %<depobj%> construct
de: %<depobj%>-Abhängigkeitstyp in %<depend%>-Klausel von %<depobj%> angegeben

en: %<depobj%> expression is not lvalue expression
de: Ausdruck %<depobj%> ist kein lvalue-Ausdruck

en: %<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>
de: Ereignishandle in %<detach%>-Klausel ist vom Typ %qT statt des erwarteten %<omp_event_handle_t%>

en: %<detach%> clause must not be used together with %<mergeable%> clause
de: %<detach%>-Klausel darf nicht zusammen mit %<mergeable%>-Klausel verwendet werden

en: %<device%> clause with %<ancestor%> is only allowed on %<target%> construct
de: %<device%>-Klausel mit %<ancestor%> ist nur an einem %<target%>-Konstrukt erlaubt

en: %<device%> id must be integral
de: %<device%>-ID muss ganzzahlig sein

en: %<dim%> argument of %qs intrinsic at %L is not a valid codimension index
de: Argument %<dim%> des intrinsischen %qs bei %L ist kein gültiger Codimensionsindex

en: %<dim%> argument of %qs intrinsic at %L is not a valid dimension index
de: Argument %<dim%> des intrinsischen %qs bei %L ist kein gültiger Dimensionsindex

en: %<dim%> argument of %s intrinsic at %L is not a valid dimension index
de: Argument %<dim%> des intrinsischen »%s« bei %L ist kein gültiger Dimensionsindex

en: %<dist_schedule%> chunk size expression must be integral
de: Ausdruck für %<dist_schedule%>-Chunkgröße muss ganzzahlig sein

en: %<distribute%> region must be strictly nested inside %<teams%> construct
de: %<distribute%>-Region muss innerhalb eines %<teams%>-Konstrukts streng geschachtelt sein

en: %<dynamic_cast%> not permitted with %<-fno-rtti%>
de: %<dynamic_cast%> ist nicht mit %<-fno-rtti%> erlaubt

en: %<dynamic_cast<%#T>(%#D)%> can never succeed
de: %<dynamic_cast<%#T>(%#D)%> kann nie erfolgreich sein

en: %<else%> without a previous %<if%>
de: %<else%> ohne vorheriges %<if%>

en: %<enum %E%> declared in %<for%> loop initial declaration
de: %<enum %E%> in Anfangsdeklaration einer %<for%>-Schleife deklariert

en: %<explicit%> can only be specified for constructors
de: %<explicit%> kann nur für Konstruktoren angegeben werden

en: %<explicit%> in friend declaration
de: %<explicit%> in »friend«-Deklaration

en: %<explicit%> outside class declaration
de: %<explicit%> außerhalb einer Klassendeklaration

en: %<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>
de: %<explicit(bool)%> ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: %<export%> not part of following module-directive
de: %<export%> ist kein Teil der folgenden module-directive

en: %<extern "C"%> linkage started here
de: %<extern "C"%>-Bindung beginnt hier

en: %<externally_visible%> attribute have effect only on public objects
de: Attribut %<externally_visible%> wirkt sich nur auf öffentliche Objekte aus

en: %<fallthrough%> attribute at top level
de: %<fallthrough%>-Attribut auf höchster Ebene

en: %<fallthrough%> attribute not followed by %<;%>
de: %<fallthrough%>-Attribut ohne darauffolgendes %<;%>

en: %<fallthrough%> attribute specified with a parameter
de: %<fallthrough%>-Attribut mit einem Parameter angegeben

en: %<fast_interrupt%> attribute directive ignored
de: Direktive des Attributes %<fast_interrupt%> ignoriert

en: %<filter%> expression must be integral
de: %<filter%>-Ausdruck muss ganzzahlig sein

en: %<flatten%> attribute is ignored on aliases
de: Attribut %<flatten%> wird an Aliasen ignoriert

en: %<flush%> list specified together with memory order clause
de: %<flush%>-Liste wurde zusammen mit Speicherreihenfolge-Klausel angegeben

en: %<for%> loop initial declarations are only allowed in C99 or C11 mode
de: Anfangsdeklarationen in %<for%>-Schleifen sind nur im C99- oder C11-Modus erlaubt

en: %<friend%> can only be specified inside a class
de: %<friend%> kann nur innerhalb einer Klasse angegeben werden

en: %<friend%> used outside of class
de: %<friend%> außerhalb einer Klasse verwendet

en: %<function_profiler%> support
de: Unterstützung für %<function_profiler%>

en: %<function_profiler%> support for MMIX
de: %<function_profiler%>-Unterstützung für MMIX

en: %<gang%> loop in %<gang-single%> region
de: %<gang%>-Schleife in %<gang-single%>-Region

en: %<gang%> num expression must be integral
de: Ausdruck für %<gang%>-Nummer muss ganzzahlig sein

en: %<gang%> num value must be positive
de: Wert von %<gang%> muss positiv sein

en: %<gang%> static expression must be integral
de: statischer %<gang%>-Ausdruck muss ganzzahlig sein

en: %<gang%> static value must be positive
de: statischer %<gang%>-Ausdruck muss positiv sein

en: %<generic%> CPU can be used only for %<-mtune=%> switch
de: %<generic%>-CPU kann nur für %<-mtune=%>-Schalter verwendet werden

en: %<generic%> CPU can be used only for %<target("tune=")%> attribute
de: %<generic%>-CPU kann nur für %<target("tune=")%>-Schalter verwendet werden

en: %<getter%> attribute of property %qD conflicts with previous declaration
de: %<getter%>-Attribut der Eigenschaft %qD in Konflikt mit vorheriger Deklaration

en: %<gnu_inline%> attribute present on %q+D
de: Attribut %<gnu_inline%> vorhanden bei %q+D

en: %<goto%> in %<constexpr%> function only available with %<-std=c++2b%> or %<-std=gnu++2b%>
de: %<goto%> innerhalb einer %<constexpr%>-Funktion ist erst mit %<-std=c++2b%> oder %<-std=gnu++2b%> verfügbar

en: %<goto%> is not a constant expression
de: %<goto%> ist kein Konstantenausdruck

en: %<gp_offset%> (%ld) or %<end_offset%> (%ld) is less than zero
de: %<gp_offset%> (%ld) oder %<end_offset%> (%ld) ist kleiner als null

en: %<grainsize%> expression must be integral
de: Ausdruck für %<grainsize%> muss ganzzahlig sein

en: %<grainsize%> value must be positive
de: Wert von %<grainsize%> muss positiv sein

en: %<h%> applied to non-register operand
de: %<h%> auf nicht-Register-Operand angewandt

en: %<hard-float%> MIPS16 code for ABIs other than o32 and o64
de: %<hard-float%> MIPS16-Code für andere ABIs als o32 und o64

en: %<hint%> expression must be constant integer expression
de: %<hint%>-Ausdruck muss ganzzahlig und konstant sein

en: %<hint%> expression must be integral
de: %<hint%>-Ausdruck muss ganzzahlig sein

en: %<if consteval%> only available with %<-std=c++2b%> or %<-std=gnu++2b%>
de: %<if consteval%> ist erst mit %<-std=c++2b%> oder %<-std=gnu++2b%> verfügbar

en: %<if consteval%> requires compound statement
de: %<if consteval%> erfordert zusammengesetzte Anweisung

en: %<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>
de: %<if constexpr%> ist nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar

en: %<ifunc%> resolver for %qD must return %qT
de: %<ifunc%>-Auflöser für %qD muss %qT zurückgeben

en: %<ifunc%> resolver for %qD should return %qT
de: %<ifunc%>-Auflöser für %qD sollte %qT zurückgeben

en: %<inbranch%> clause is incompatible with %<notinbranch%>
de: %<inbranch%>-Klausel ist inkompatibel mit %<notinbranch%>

en: %<indirect_call%> attribute cannot apply for static function
de: Attribut %<indirect_call%> bezieht sich nicht auf %<static%>-Funktionen

en: %<inline%> can only be specified for functions
de: %<inline%> kann nur für Funktionen angegeben werden

en: %<inline%> in empty declaration
de: %<inline%> in leerer Deklaration

en: %<inline%> is not allowed in declaration of friend template specialization %qD
de: %<inline%> ist nicht in Deklaration der friend-Template-Spezialisierung %qD erlaubt

en: %<inline%> specified for friend class declaration
de: %<inline%> für friend-Klassen-Deklaration angegeben

en: %<inline%> specifier invalid for function %qs declared out of global scope
de: %<inline%> ungültig für außerhalb des globalen Gültigkeitsbereiches deklarierte Funktion %qs

en: %<inline%> specifier invalid for variable %qD declared at block scope
de: %<inline%>-Spezifizierer ungültig für Variable %qD mit Gültigkeitsbereich Block

en: %<inscan%> %<reduction%> clause on %qs construct
de: %<inscan%>-%<reduction%>-Klausel am %qs-Konstrukt

en: %<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>
de: %<inscan%>-%<reduction%>-Klausel bei Konstruktion außer %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>

en: %<inscan%> %<reduction%> clause used together with %<linear%> clause for a variable other than loop iterator
de: %<inscan%>-%<reduction%>-Klausel wird zusammen mit %<linear%>-Klausel an einer Variable verwendet, die kein Schleifeniterator ist

en: %<inscan%> %<reduction%> clause with array section
de: %<inscan%>-%<reduction%>-Klausel mit Arrayabschnitt

en: %<inscan%> REDUCTION clause on construct other than DO, SIMD, DO SIMD, PARALLEL DO, PARALLEL DO SIMD at %L
de: %<inscan%>-REDUCTION-Klausel an einem anderen Konstrukt als DO, SIMD, DO SIMD, PARALLEL DO, PARALLEL DO SIMD bei %L

en: %<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct
de: die Klausel %<inscan%> darf nicht zusammen mit nicht-%<inscan%>-%<reduction%> am selben Konstrukt vorkommen

en: %<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct at %L
de: %<inscan%> und nicht-%<inscan%>-%<reduction%>-Klauseln am selben Konstrukt bei %L

en: %<intel%> CPU can be used only for %<-mtune=%> switch
de: die CPU %<intel%> kann nur für den Schalter %<-mtune=%> verwendet werden

en: %<intel%> CPU can be used only for %<target("tune=")%> attribute
de: die CPU %<intel%> kann nur für das Attribut %<target("tune=")%> verwendet werden

en: %<interrupt_thread%> is available only on fido
de: %<interrupt_thread%> ist nur auf Fido verfügbar

en: %<iterator%> modifier incompatible with %qs
de: Modifizierer %<iterator%> ist unverträglich mit %qs

en: %<iterator%> modifier may not be specified on %<depobj%> construct
de: %<iterator%>-Modifizierer darf nicht bei einem %<depobj%>-Konstrukt angegeben sein

en: %<l1-cache-size%> parameter is not a power of two %d
de: %<l1-cache-size%>-Parameter ist keine Zweierpotenz (%d)

en: %<lastprivate%> clause on a %<loop%> construct refers to a variable %qD which is not the loop iterator
de: %<lastprivate%>-Klausel an einem %<loop%>-Konstrukt bezieht sich auf eine Variable %qD, die nicht der Schleifeniterator ist

en: %<linear%> clause for variable other than loop iterator specified on construct combined with %<distribute%>
de: %<linear%>-Klausel für Variable, die keine Schleifeniterationsvariable ist, wurde für ein mit %<distribute%> kombiniertes Konstrukt angegeben

en: %<linear%> clause may not be specified together with %<ordered%> clause with a parameter
de: %<linear%>-Klausel darf nicht zusammen mit %<ordered%>-Klausel mit einem Parameter angegeben werden

en: %<linear%> clause step %qE is neither constant nor a parameter
de: Schrittweite %qE der %<linear%>-Klausel muss konstant oder ein Parameter sein

en: %<linear%> clause step expression must be integral
de: Schrittweite der %<linear%>-Klausel muss ganzzahlig sein

en: %<linear%> clause step is a parameter %qD not specified in %<uniform%> clause
de: %<linear%>-Klauselschritt ist ein Parameter %qD, der nicht in der %<uniform%>-Klausel angegeben ist

en: %<location_t%> is not defined as a type
de: %<location_t%> ist nicht als ein Typ definiert

en: %<locus%> is not defined as a type
de: %<locus%> ist nicht als ein Typ definiert

en: %<long long long%> is too long for GCC
de: %<long long long%> ist für GCC zu lang

en: %<long%> and %<short%> specified together
de: %<long%> und %<short%> gleichzeitig angegeben

en: %<long%> switch expression not converted to %<int%> in ISO C
de: %<long%> switch-Ausdruck nicht nach %<int%> konvertiert in ISO C

en: %<lp_array%> does not match %<region_tree%>
de: %<lp_array%> passt nicht zum %<region_tree%>

en: %<lp_array%> is corrupted for lp %i
de: %<lp_array%> ist für lp %i beschädigt

en: %<main%> declared %<_Noreturn%>
de: %<main%> als %<_Noreturn%> deklariert

en: %<memset%> used with constant zero length parameter; this could be due to transposed parameters
de: %<memset%> mit konstanter Länge 0 verwendet; das könnte heißen, dass die Parameter vertauscht sind

en: %<memset%> used with length equal to number of elements without multiplication by element size
de: im Aufruf von %<memset%> ist die Länge gleich der Anzahl der Elemente angegeben, ohne sie mit der Elementgröße zu multiplizieren

en: %<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit
de: Attribut %<ms_hook_prologue%> ist mit %<-mfentry%> für 32 Bit nicht verträglich

en: %<ms_hook_prologue%> attribute is not compatible with nested function
de: Attribut %<ms_hook_prologue%> ist mit geschachtelter Funktion nicht verträglich

en: %<msp430_select_hwmult_lib%> needs one or more arguments
de: %<msp430_select_hwmult_lib%> erfordert mindestens ein Argument

en: %<msp430_set_driver_var%> expects 2 arguments
de: %<msp430_set_driver_var%> erwartet 2 Argumente

en: %<mutexinoutset%> kind in %<depend%> clause on a %<taskwait%> construct
de: %<mutexinoutset%>-Art in %<depend%>-Klausel bei einem %<taskwait%>-Konstrukt

en: %<namespace %E%> is ambiguous
de: %<namespace %E%> ist mehrdeutig

en: %<namespace%> definition is not allowed here
de: %<namespace%>-Definition ist hier nicht erlaubt

en: %<new%> of %<initializer_list%> does not extend the lifetime of the underlying array
de: %<new%> einer %<initializer_list%> führt nicht zu einer längeren Lebenszeit des zugrundeliegenden Arrays

en: %<new%> of type %qT with extended alignment %d
de: %<new%> für Typ %qT mit erweiterter Ausrichtung %d

en: %<no-custom-%s%> does not accept arguments
de: %<no-custom-%s%> akzeptiert keine Argumente

en: %<nogroup%> clause must not be used together with %<reduction%> clause
de: %<nogroup%>-Klausel darf nicht zusammen mit %<reduction%>-Klausel verwendet werden

en: %<nonatomic%> attribute of property %qD conflicts with previous declaration
de: Attribut %<nonatomic%> der Eigenschaft %qD in Konflikt mit vorheriger Deklaration

en: %<nonmonotonic%> schedule modifier specified together with %<ordered%> clause
de: %<nonmonotonic%>-Planungsmodifizierer zusammen mit %<ordered%>-Klausel angegeben

en: %<nonnull%> argument %qD compared to NULL
de: %<nonnull%>-Argument %qD wird mit NULL verglichen

en: %<noreturn%> function does return
de: %<noreturn%>-Funktion kehrt zurück

en: %<nowait%> clause must not be used together with %<copyprivate%>
de: %<nowait%>-Klausel darf nicht zusammen mit %<copyprivate%> verwendet werden

en: %<num_tasks%> value must be positive
de: Wert von %<num_tasks%> muss positiv sein

en: %<num_teams%> lower bound %qE bigger than upper bound %qE
de: untere Grenze %qE von %<num_teams%> ist größer als obere Grenze %qE

en: %<num_teams%> value must be positive
de: Wert von %<num_teams%> muss positiv sein

en: %<num_threads%> value must be positive
de: Wert von %<num_threads%> muss positiv sein

en: %<object.TypeInfo%> cannot be used with %<-fno-rtti%>
de: %<object.TypeInfo%> kann nicht mit %<-fno-rtti%> verwendet werden

en: %<object.TypeInfo%> could not be found, but is implicitly used
de: %<object.TypeInfo%> konnte nicht gefunden werden, wird aber implizit verwendet

en: %<offsetof%> within non-standard-layout type %qT is conditionally-supported
de: %<offsetof%> innerhalb von Typ %qT (der kein Standardlayout hat) ist bedingt unterstützt

en: %<omp::%E%> attribute requires argument
de: Attribut %<omp::%E%> erfordert Argument

en: %<omp::%E%> not allowed to be specified in this context
de: %<omp::%E%> darf in diesem Kontext nicht angegeben werden

en: %<operator delete%> must return type %qT
de: %<operator delete%> muss Typ %qT zurückgeben

en: %<operator delete%> takes type %qT as first parameter
de: %<operator delete%> nimmt Typ %qT als ersten Parameter

en: %<operator delete[]%> cannot be a destroying delete
de: %<operator delete[]%> kann kein zerstörendes %<delete%> sein

en: %<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)
de: %<operator new%> darf nicht NULL zurückgeben, außer er ist mit %<throw%> deklariert (oder %<-fcheck-new%> ist eingeschaltet)

en: %<operator new%> must return type %qT
de: %<operator new%> muss Typ %qT zurückgeben

en: %<operator new%> takes type %<size_t%> (%qT) as first parameter
de: %<operator new%> nimmt Typ %<size_t%> (%qT) als ersten Parameter

en: %<operator=%> should return a reference to %<*this%>
de: %<operator=%> sollte eine Referenz auf %<*this%> zurückgeben

en: %<or%> of unmatched not-equal tests is always 1
de: %<oder%> bei nicht passenden Ungleichheits-Tests ist immer 1

en: %<order%> clause must not be used together with %<ordered%>
de: %<order%>-Klausel darf nicht zusammen mit %<ordered%> verwendet werden

en: %<ordered simd threads%> must be closely nested inside of %<%s simd%> region
de: %<ordered simd threads%> muss innerhalb einer %<%s simd%>-Region eng geschachtelt sein

en: %<ordered%> %<simd%> must be closely nested inside %<simd%> region
de: %<ordered%> %<simd%> muss innerhalb einer %<simd%>-Region eng geschachtelt sein

en: %<ordered%> clause parameter is less than %<collapse%>
de: %<ordered%>-Klauselparameter ist weniger als %<collapse%>

en: %<ordered%> clause with parameter may not be specified on %qs construct
de: %<ordered%>-Klausel mit Parameter darf nicht beim %qs-Konstruk angegeben werden

en: %<ordered%> clause with parameter on range-based %<for%> loop
de: %<ordered%>-Klausel mit Parameter in %<for%>-Schleife über einen Bereich

en: %<ordered%> construct with %<depend%> clause must be closely nested inside a loop with %<ordered%> clause with a parameter
de: %<ordered%>-Konstrukt mit %<depend%>-Klausel muss innerhalb einer Schleife mit %<ordered%>-Klausel und Parameter eng geschachtelt sein

en: %<ordered%> construct with %<depend%> clause must be closely nested inside an %<ordered%> loop
de: %<ordered%>-Konstrukt mit %<depend%>-Klausel muss innerhalb einer %<ordered%>-Schleife eng geschachtelt sein

en: %<ordered%> region may not be closely nested inside of %<critical%>, %<ordered%>, explicit %<task%> or %<taskloop%> region
de: %<ordered%>-Region darf innerhalb einer Region, die %<critical%>, %<ordered%>, expliziten %<task%> oder %<taskloop%> ist, nicht eng geschachtelt sein

en: %<ordered%> region must be closely nested inside a loop region with an %<ordered%> clause
de: %<ordered%>-Region muss eng geschachtelt sein, wenn sie innerhalb einer Schleifenregion mit %<ordered%>-Klausel auftritt

en: %<ordered%> region without %<depend%> clause may not be closely nested inside a loop region with an %<ordered%> clause with a parameter
de: %<ordered%>-Region ohne %<depend%>-Klausel darf innerhalb einer Schleifenregion mit %<ordered%>-Klausel und Parameter nicht eng geschachtelt sein

en: %<pch_preprocess%> pragma should only be used with %<-fpreprocessed%>
de: das Pragma %<pch_preprocess%> sollte nur mit %<-fpreprocessed%> verwendet werden

en: %<pragma omp error%> encountered
de: %<#pragma omp error%> gefunden

en: %<pragma omp error%> encountered: %s
de: %<#pragma omp error%> gefunden: %s

en: %<pragma omp requires%> requires at least one clause
de: %<pragma omp requires%> erfordert mindestens eine Klausel

en: %<priority%> expression must be integral
de: Ausdruck für %<priority%> muss ganzzahlig sein

en: %<priority%> value must be non-negative
de: Wert von %<priority%> muss positiv sein

en: %<readonly%> attribute conflicts with %<setter%> attribute
de: Attribut %<readonly%> steht mit Attribut %<setter%> in Konflikt

en: %<readonly%> attribute of property %qD conflicts with previous declaration
de: Attribut %<readonly%> der Eigenschaft %qD in Konflikt mit vorheriger Deklaration

en: %<region_array%> does not match %<region_tree%>
de: %<region_array%> passt nicht zum %<region_tree%>

en: %<region_array%> is corrupted for region %i
de: %<region_array%> ist für Region %i beschädigt

en: %<register%> in file-scope empty declaration
de: %<register%> in leerer Deklaration im Datei-Gültigkeitsbereich

en: %<register%> storage class specifier used
de: %<register%>-Speicherklassenangabe verwendet

en: %<reinterpret_cast%> from integer to pointer
de: %<reinterpret_cast%> von Ganzzahl zu Zeiger

en: %<reinterpret_cast%> from type %qT to type %qT casts away qualifiers
de: %<reinterpret_cast%> von Typ %qT in Typ %qT entfernt Qualifizierer

en: %<reinterpret_cast%> is not a constant expression
de: Ein %<reinterpret_cast%> ist kein konstanter Ausdruck

en: %<reinterpret_cast<%T>(%E)%> is not a constant expression
de: %<reinterpret_cast<%T>(%E)%> ist kein Konstantenausdruck

en: %<requires%> only available with %<-std=c++20%> or %<-fconcepts%>
de: %<requires%> ist erst ab %<-std=c++20%> oder mit %<-fconcepts%> verfügbar

en: %<return%> with a value, in function returning void
de: %<return%> mit Wert in void zurückgebender Funktion

en: %<return%> with no value, in function returning non-void
de: %<return%> ohne Wert in nicht-void zurückgebender Funktion

en: %<return_void%> declared here
de: %<return_void%> wurde hier deklariert

en: %<safelen%> clause expression must be positive constant integer expression
de: Ausdruck der %<safelen%>-Klausel erfordert positiven konstanten Ganzzahlausdruck

en: %<scalar_storage_order%> is not supported because endianness is not uniform
de: %<scalar_storage_order%> wird nicht unterstützt, da die Bytereihenfolge nicht einheitlich ist

en: %<scope%> region may not be closely nested inside of work-sharing, %<loop%>, explicit %<task%>, %<taskloop%>, %<critical%>, %<ordered%>, %<master%>, or %<masked%> region
de: %<scope%>-Region darf nicht innerhalb einer Region eng geschachtelt sein, die arbeitsteilend, %<loop%>, explizit %<task%>, %<taskloop%>, %<critical%>, %<ordered%>, %<master%> oder %<masked%> ist

en: %<seq%> overrides other OpenACC loop specifiers
de: %<seq%> übersteuert andere OpenACC-Schleifenspezifizierer

en: %<setter%> attribute of property %qD conflicts with previous declaration
de: %<setter%>-Attribut der Eigenschaft %qD in Konflikt mit vorheriger Deklaration

en: %<setter%> specified here
de: %<setter%> ist hier angegeben

en: %<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements
de: Argument »shape« des intrinsischen »reshape« bei %L hat mehr als %d Elemente

en: %<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size
de: Argument %<shape%> des intrinsischen %<reshape%> bei %L muss ein Feld konstanter Größe sein

en: %<signed%> and %<unsigned%> specified together
de: %<signed%> und %<unsigned%> gleichzeitig angegeben

en: %<simdlen%> clause expression must be positive constant integer expression
de: Ausdruck der %<simdlen%>-Klausel erfordert positiven konstanten Ganzzahlausdruck

en: %<simdlen%> clause value is bigger than %<safelen%> clause value
de: %<simdlen%>-Klauselwert ist größer als %<safelen%>-Klauselwert

en: %<sizeof%> applied to a bit-field
de: %<sizeof%> auf ein Bitfeld angewandt

en: %<sizeof%> on array function parameter %qE will return size of %qT
de: %<sizeof%> auf Array-Funktionsparameter %qE gibt die Größe von %qT zurück

en: %<sizeof...%> argument must be surrounded by parentheses
de: Argument von %<sizeof...%> muss mit Klammern umschlossen werden

en: %<soft-float%> and long-double-128 are incompatible
de: %<soft-float%> und long-double-128 sind unverträglich

en: %<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array
de: Argument %<source%> des intrinsischen %<shape%> bei %L darf kein Feld impliziter Größe sein

en: %<stack_offset%> must be a multiple of 4
de: %<stack_offset%> muss ein Vielfaches von 4 sein

en: %<stack_offset%> must be at least 4
de: %<stack_offset%> muss mindestens 4 sein

en: %<static%> %qs cannot be declared %<mutable%>
de: %qs ist %<static%> und darf daher nicht als %<mutable%> deklariert sein

en: %<static%> may not be used when defining (as opposed to declaring) a static data member
de: %<static%> darf nicht bei der Definition (im Gegensatz zu Deklaration) eines statischen Datenelementes verwendet werden

en: %<static%> specifier invalid for function %qs declared out of global scope
de: %<static%> ist für außerhalb des globalen Gültigkeitsbereiches deklarierte Funktion %qs ungültig

en: %<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>
de: %<static_assert%> ohne Text ist erst ab %<-std=c++17%> oder %<-std=gnu++17%> verfügbar

en: %<static_cast%> from type %qT to type %qT casts away qualifiers
de: %<static_cast%> von Typ %qT in Typ %qT entfernt Qualifizierer

en: %<std::%s%> is defined in header %qs; did you forget to %<#include %s%>?
de: %<std::%s%> ist im Header %qs definiert; haben Sie vergessen, %<#include %s%> zu schreiben?

en: %<std::%s%> is only available from %s onwards
de: %<std::%s%> ist erst ab %s verfügbar

en: %<std::is_constant_evaluated%> always evaluates to false in a non-%<constexpr%> function
de: %<std::is_constant_evaluated%> wertet in einer nicht-%<constexpr%>-Funktion immer zu false aus

en: %<std::is_constant_evaluated%> always evaluates to true in %<if constexpr%>
de: %<std::is_constant_evaluated%> wertet innerhalb von %<if constexpr%> immer zu true aus

en: %<std::is_constant_evaluated%> always evaluates to true in a %<consteval%> function
de: %<std::is_constant_evaluated%> wertet innerhalb einer %<consteval%>-Funktion immer zu true aus

en: %<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>
de: %<std::source_location::__impl%> enthält nicht nur nicht-statische Datenelemente %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> und %<_M_column%>

en: %<std::tuple_element<%u, %T>::type%> is %<void%>
de: %<std::tuple_element<%u, %T>::type%> ist %<void%>

en: %<std::tuple_size<%T>::value%> is not an integral constant expression
de: %<std::tuple_size<%T>::value%> ist kein konstanter Ganzzahlausdruck

en: %<strong%> using directive no longer supported
de: die Direktive %<strong%>-%<using%> wird nicht mehr unterstützt

en: %<struct %E%> declared in %<for%> loop initial declaration
de: %<struct %E%> in Anfangsdeklaration einer %<for%>-Schleife deklariert

en: %<symver%> attribute argument %qs must contain one or two %<@%>
de: Argument %qs für Attribut %<symver%> muss ein oder zwei %<@%> enthalten

en: %<symver%> attribute argument not a string constant
de: Argument des Attributs %<symver%> ist keine Zeichenkettenkonstante

en: %<symver%> attribute is only applicable to symbols
de: Attribut %<symver%> bezieht sich nur auf Symbole

en: %<symver%> attribute only applies to functions and variables
de: Attribut %<symver%> gilt nur für Funktionen und Variablen

en: %<sysctl%> for %<kern.osversion%> failed: %m
de: Fehler bei %<sysctl%> für %<kern.osversion%>: %m

en: %<target%> construct with nested %<teams%> construct contains directives outside of the %<teams%> construct
de: %<target%>-Konstrukt mit geschachteltem %<teams%>-Konstrukt enthält Direktiven außerhalb des %<teams%>-Konstrukts

en: %<target("rtd")%> is ignored in 64bit mode
de: %<target("rtd")%> wird im 64-Bit-Modus ignoriert

en: %<target("sseregparm")%> used without SSE enabled
de: %<target("sseregparm")%> verwendet, ohne dass SSE eingeschaltet ist

en: %<target("tune=x86-64")%> is deprecated; use %<target("tune=k8")%> or %<target("tune=generic")%> instead as appropriate
de: %<target("tune=x86-64")%> ist veraltet; stattdessen entsprechend %<target("tune=k8")%> oder %<target("tune=generic")%> verwenden

en: %<target_clones%> attribute needs GLIBC (2.23 and newer) that exports hardware capability bits
de: das Attribut %<target_clones%> erfordert GLIBC (2.23 oder neuer), die Hardware-Fähigkeits-Bits exportiert

en: %<task%> reduction modifier on a construct with a %<nowait%> clause
de: %<task%>-Reduktionsmodifizierer bei einem Konstrukt mit %<nowait%>-Klausel

en: %<teams%> construct must be closely nested inside of %<target%> construct or not nested in any OpenMP construct
de: %<teams%>-Konstrukt muss innerhalb eines %<target%>-Konstrukts eng geschachtelt sein, oder in überhaupt keinem OpenMP-Konstrukt geschachtelt sein

en: %<template%> keyword not permitted in destructor name
de: das Schlüsselwort %<template%> ist im Destruktornamen nicht erlaubt

en: %<template%> must follow a nested-name-specifier
de: %<template%> muss auf einen nested-name-specifier folgen

en: %<this%> allowed in OpenMP only in %<declare simd%> clauses
de: %<this%> ist in OpenMP nur innerhalb von %<declare simd%>-Klauseln erlaubt

en: %<this%> cannot be captured by reference
de: %<this%> kann nicht per Referenz eingefangen werden

en: %<this%> is unavailable for static member functions
de: %<this%> ist für statische Elementfunktionen nicht verfügbar

en: %<this%> may not be used in this context
de: %<this%> darf in diesem Kontext nicht verwendet werden

en: %<this%> not allowed in %<allocate%> clause
de: %<this%> ist in %<allocate%>-Klausel nicht erlaubt

en: %<this%> was not captured for this lambda function
de: %<this%> wurde für diese Lambda-Funktion nicht aufgefangen

en: %<thread_limit%> expression must be integral
de: %<thread_limit%>-Ausdruck muss ganzzahlig sein

en: %<thread_limit%> value must be positive
de: Wert von %<thread_limit%> muss positiv sein

en: %<threadprivate%> %qD is not file, namespace or block scope variable
de: %<threadprivate%> %qD ist weder Datei-, Namens- noch Blockbereichsvariable

en: %<threadprivate%> %qE directive not in %qT definition
de: %<threadprivate%> Direktive %qE nicht in Definition von %qT

en: %<threadprivate%> %qE has incomplete type
de: %<threadprivate%> %qE hat unvollständigen Typen

en: %<throw%> will always call %<terminate%>
de: %<throw%> wird immer %<terminate%> aufrufen

en: %<tile%> argument needs integral type
de: Argument für %<tile%> erfordert ganzzahligen Typ

en: %<tile%> argument needs positive integral constant
de: %<tile%>-Argument muss eine positive, ganzzahlige Konstante sein

en: %<transaction_may_cancel_outer%> function call not within outer transaction or %<transaction_may_cancel_outer%>
de: Funktionsaufruf von %<transaction_may_cancel_outer%> nicht innerhalb von äußerer Transaktion oder %<transaction_may_cancel_outer%>

en: %<transaction_safe_dynamic%> may only be specified for a virtual function
de: %<transaction_safe_dynamic%> kann nur für virtuelle Funktionen angegeben werden

en: %<tree%> is not defined as a pointer type
de: %<tree%> ist nicht als ein Zeigertyp definiert

en: %<tree%> is not defined as a type
de: %<tree%> ist nicht als ein Typ definiert

en: %<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>
de: %<try%> innerhalb einer %<constexpr%>-Funktion ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: %<typedef%> was ignored in this declaration
de: %<typedef%> wurde in dieser Deklaration ignoriert

en: %<typeid%> is not a constant expression because %qE is of polymorphic type
de: %<typeid%> ist kein konstanter Ausdruck, da %qE polymorphen Typ hat

en: %<typeid%> of qualified function type %qT
de: %<typeid%> des qualifizierten Funktionstyps %qT

en: %<typeid%> operator cannot appear in a constant-expression
de: %<typeid%>-Operator kann nicht in einem Konstanten-Ausdruck auftreten

en: %<typename %T::%D%> names %q#T, which is not a class template
de: %<typename %T::%D%> benennt %q#T, was kein Klassentemplate ist

en: %<typename %T::%D%> names %q#T, which is not a type
de: %<typename %T::%D%> benennt %q#T, was kein Typ ist

en: %<typeof%> applied to a bit-field
de: %<typeof%> auf ein Bitfeld angewandt

en: %<union %E%> declared in %<for%> loop initial declaration
de: %<union %E%> in Anfangsdeklaration einer %<for%>-Schleife deklariert

en: %<using enum%> of %qT before its enum-specifier
de: %<using enum%> von %qT vor seinem enum-specifier

en: %<using enum%> of dependent type %qT
de: %<using enum%> des abhängigen Typen %qT

en: %<using enum%> of incomplete type %qT
de: %<using enum%> an unvollständigem Typ %qT

en: %<using enum%> of non-enumeration type %q#T
de: %<using enum%> an Nicht-Aufzählungstyp %q#T

en: %<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>
de: %<using enum%> ist nur mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: %<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>
de: %<using%> mit Gültigkeitsbereich in enum-Typ %q#T ist erst ab %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: %<va_start%> used in function with fixed arguments
de: %<va_start%> in Funktion mit fester Parameteranzahl verwendet

en: %<vec_lvsl%> is deprecated for little endian; use assignment for unaligned loads and stores
de: %<vec_lvsl%> ist für Little-Endian veraltet; verwenden Sie Zuweisungen für unausgerichtete Speicherzugriffe

en: %<vec_lvsr%> is deprecated for little endian; use assignment for unaligned loads and stores
de: %<vec_lvsr%> ist für Little-Endian veraltet; verwenden Sie Zuweisungen für unausgerichtete Speicherzugriffe

en: %<vector%> length expression must be integral
de: Ausdruck für %<vector%>-Länge muss ganzzahlig sein

en: %<vector%> length value must be positive
de: Wert der %<vector%>-Länge muss positiv sein

en: %<virtual%> can only be specified for functions
de: %<virtual%> kann nur für Funktionen angegeben werden

en: %<virtual%> outside class declaration
de: %<virtual%> außerhalb einer Klassendeklaration

en: %<virtual%> specified more than once in base-specifier
de: %<virtual%> mehr als einmal in Basisspezifikation angegeben

en: %<void%> as only parameter may not be qualified
de: %<void%> kann nicht als einzelner Parameter qualifiziert werden

en: %<void%> must be the only parameter
de: %<void%> muss der einzige Parameter sein

en: %<volatile%> can only be specified for objects and functions
de: %<volatile%> kann nur für Objekte und Funktionen angegeben werden

en: %<volatile%>-qualified parameter is deprecated
de: %<volatile%>-qualifizierter Parameter ist veraltet

en: %<volatile%>-qualified return type is deprecated
de: %<volatile%>-qualifizierter Rückgabetyp ist veraltet

en: %<volatile%>-qualified structured binding is deprecated
de: %<volatile%>-qualifizierte strukturierte Bindung ist veraltet

en: %<wait%> expression must be integral
de: %<wait%>-Ausdruck muss ganzzahlig sein

en: %<warn_if_not_aligned%> may not be specified for %q+D
de: Für %q+D darf %<warn_if_not_aligned%> nicht angegeben werden

en: %<weak%> clause requires atomic equality comparison
de: %<weak%>-Klausel erfordert atomaren Gleichheitsvergleich

en: %<weakref%> attribute ignored because function is defined
de: Attribut %<weakref%> ignoriert, da Funktion bereits definiert ist

en: %<weakref%> attribute ignored because variable is initialized
de: Attribut %<weakref%> ignoriert, da Variable bereits initialisiert ist

en: %<weakref%> attribute should be accompanied with an %<alias%> attribute
de: Attribut %<weakref%> sollte von Attribut %<alias%> begleitet werden

en: %<weakref%> cannot be versioned
de: %<weakref%> kann nicht versioniert werden

en: %<worker%> num expression must be integral
de: Ausdruck für %<worker%>-Nummer muss ganzzahlig sein

en: %<worker%> num value must be positive
de: Wert der %<worker%>-Nummer muss positiv sein

en: %<||%> not valid in GIMPLE
de: Interner Fehler: %<||%> not valid in GIMPLE

en: %<~%> on a boolean expression
de: %<~%> auf booleschem Ausdruck

en: %<~%> on an expression of type %<bool%>
de: %<~%> auf einem Ausdruck vom Typ %<bool%>

en: %<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>
de: %<~auto%> ist nur mit %<-std=c++14%> oder %<-std=gnu++14%> verfügbar

en: %d bytes of gang-private data-share memory exhausted (increase with %<-mgang-private-size=%d%>, for example)
de: %d Bytes des gang-privaten Speichers für Datenaustausch erschöpft (kann zum Beispiel mit %<-mgang-private-size=%d%> erhöht werden)

en: %d constructor found
     | %d constructors found
de[0]: Einen Konstruktor gefunden
de[1]: %d Konstruktoren gefunden

en: %d destructor found
     | %d destructors found
de[0]: Einen Destruktor gefunden
de[1]: %d Destruktoren gefunden

en: %d exits recorded for loop %d (having %d exits)
de: Interner Fehler: %d exits recorded for loop %d (having %d exits)

en: %d frame table found
     | %d frame tables found
de[0]: Eine Rahmentabelle gefunden
de[1]: %d Rahmentabellen gefunden

en: %i-bit mode not compiled in
de: %i-Bit-Modus nicht einkompiliert

en: %llu bytes
de: %llu Bytes

en: %q#D cannot be overloaded with %q#D
de: %q#D kann nicht mit %q#D überladen werden

en: %q#D conflicts with a previous declaration
de: %q#D steht mit vorheriger Deklaration in Konflikt

en: %q#D conflicts with version inherited from %qT
de: %q#D steht in Konflikt mit von %qT geerbter Version

en: %q#D declared here
de: %q#D hier deklariert

en: %q#D does not have external linkage
de: %q#D hat keine externe Bindung

en: %q#D does not refer to the unqualified type, so it is not used for linkage
de: %q#D verweist nicht auf den unqualifizierten Typen und wird daher nicht zum Binden verwendet

en: %q#D explicitly defaulted here
de: %q#D wurde hat hier ausdrücklichen Standardwert bekommen

en: %q#D has incomplete type
de: %q#D hat unvollständigen Typ

en: %q#D hides constructor for %q#D
de: %q#D verdeckt Konstruktor für %q#D

en: %q#D inherits from multiple base subobjects
de: %q#D erbt von mehreren Basis-Teilobjekten

en: %q#D invalid; an anonymous union can only have non-static data members
de: %q#D ungültig; eine anonyme Union kann nur nicht-statische Datenelemente haben

en: %q#D invalid; an anonymous union may only have public non-static data members
de: %q#D ungültig; eine anonyme Union kann nur nicht-statische Datenelemente haben

en: %q#D is a static data member; it can only be initialized at its definition
de: %q#D« ist ein statisches Datenelement; es kann nur bei seiner Definition initialisiert werden

en: %q#D is implicitly declared as deleted because %qT declares a move constructor or move assignment operator
de: %q#D ist implizit als gelöscht deklariert, da %qT einen Bewegungskonstruktor oder Bewegungs-Zuweisungsoperator deklariert

en: %q#D is implicitly deleted because the default definition would be ill-formed:
de: %q#D wird implizit gelöscht, da die Standarddefinition ungültig wäre:

en: %q#D is inaccessible within this context
de: %q#D ist in diesem Zusammenhang unzugänglich

en: %q#D is not a function template
de: %q#D ist kein Funktionstemplate

en: %q#D is not a non-static data member of %qT
de: %q#D ist kein Nicht-static-Datenelement von %qT

en: %q#D is not a valid template argument for type %qT because a reference variable does not have a constant address
de: %q#D ist kein gültiges Templateargument für Typ %qT, weil eine Referenzvariable keine konstante Adresse hat

en: %q#D is not const
de: %q#D ist nicht konstant

en: %q#D is private within this context
de: %q#D ist in diesem Zusammenhang »private«

en: %q#D is protected within this context
de: %q#D ist in diesem Zusammenhang »protected«

en: %q#D is public, but requires an existing %q#T object
de: %q#D ist %<public%>, benötigt jedoch ein existierendes Objekt vom Typ %q#T

en: %q#D is volatile
de: %q#D ist volatile

en: %q#D not declared in class
de: %q#D nicht in Klasse deklariert

en: %q#D previously declared here
de: %q#D wurde bereits hier deklariert

en: %q#D previously defined here
de: %q#D wurde bereits hier definiert

en: %q#D redeclared as different kind of entity
de: %q#D als andere Symbolart redeklariert

en: %q#D references internal linkage entity %q#D
de: %q#D verweist auf eine Einheit %q#D mit interner Verlinkung

en: %q#D should be initialized
de: %q#D sollte initialisiert werden

en: %q#D, declared using local type %qT, is used but never defined
de: %q#D (durch lokalen Typen %qT deklariert) wird verwendet, aber nirgends definiert

en: %q#D, declared using unnamed type, is used but never defined
de: %q#D (durch einen unbenannten Typen deklariert) wird verwendet, aber nirgends definiert

en: %q#F is implicitly deleted because its exception-specification does not match the implicit exception-specification %qX
de: %q#F wird implizit gelöscht, da ihre Ausnahme-Spezifikation nicht zur impliziten Ausnahme-Spezifikation %qX passt

en: %q#T has no member named %qE
de: %q#T hat kein Element namens %qE

en: %q#T has no member named %qE; did you mean %q#D? (accessible via %q#D)
de: %q#T hat kein Element namens %qE; meinten Sie %q#D? (zugreifbar über %q#D)

en: %q#T has no member named %qE; did you mean %q#D? (not accessible from this context)
de: %q#T hat kein Element namens %qE; meinten Sie %q#D? (aus diesem Kontext nicht zugreifbar)

en: %q#T has no member named %qE; did you mean %qE?
de: %q#T hat kein Element namens %qE; meinten Sie %qE?

en: %q#T has no user-provided default constructor
de: %q#T hat keinen benutzerdefinierten Default-Konstruktor

en: %q#T has pointer data members
de: %q#T hat Zeigertypen als Elemente

en: %q#T has virtual base classes
de: %q#T hat virtuelle Basisklassen

en: %q#T has virtual functions and accessible non-virtual destructor
de: %q#T hat virtuelle Funktionen und erreichbaren nicht-virtuellen Destruktor

en: %q#T is not a class
de: %q#T ist keine Klasse

en: %q#T is not a class or namespace
de: %q#T ist weder Klasse noch Namensbereich

en: %q#T is not a template
de: %q#T ist kein Template

en: %q#T is not a valid type for a template non-type parameter
de: %q#T ist kein gültiger Typ für einen Nicht-Typ-Parameter eines Templates

en: %q#T only defines a private destructor and has no friends
de: %q#T definiert nur einen privaten Destruktor und hat keine »friends«

en: %q#T only defines private constructors and has no friends
de: %q#T definiert nur private Konstruktoren und hat keine »friends«

en: %q#T used where a %qT was expected
de: %q#T verwendet, wo %qT erwartet wurde

en: %q#T used where a floating-point value was expected
de: %q#T verwendet, wo ein Gleitkommawert erwartet wurde

en: %q#T was previously declared here
de: %q#T wurde vorher hier deklariert

en: %q+#D cannot be declared
de: %q+#D kann nicht deklariert werden

en: %q+#D is not a static data member of %q#T
de: %q+#D ist kein static-Datenelement von %q#T

en: %q+#D marked %<final%>, but is not virtual
de: %q+#D als %<final%> markiert, ist aber nicht »virtual«

en: %q+#D marked %<override%>, but does not override
de: %q+#D als %<override%> markiert, überschreibt aber nicht

en: %q+D alias between function and variable is not supported
de: Alias %q+D zwischen Funktion und Variable wird nicht unterstützt

en: %q+D aliased to external symbol %qE
de: %q+D als Alias für externes Symbol %qE

en: %q+D aliased to undefined symbol %qE
de: %q+D als Alias für undefiniertes Symbol %qE

en: %q+D already declared with dllexport attribute: dllimport ignored
de: %q+D bereits mit Attribut »dllimport« deklariert: »dllimport« ignoriert

en: %q+D declared as a friend
de: %q+D als »friend« deklariert

en: %q+D declared as variadic function
de: %q+D als variadische Funktion deklariert

en: %q+D declared weak after being used
de: %q+D als schwach deklariert, nachdem es verwendet wurde

en: %q+D declared with an exception specification
de: %q+D mit einer Ausnahmespezifikation deklariert

en: %q+D defined as variadic function without prototype
de: %q+D ist als variadische Funktion ohne Prototyp definiert

en: %q+D defined both normally and as %qE attribute
de: %q+D sowohl normal als auch als Attribut %qE definiert

en: %q+D has incompatible attributes %qs and %qs
de: %q+D hat unverträgliche Attribute %qs und %qs

en: %q+D in declare target directive does not have mappable type
de: %q+D in »declare target«-Direktive hat keinen zuordenbaren Typ

en: %q+D is static but declared in inline function %qD which is not static
de: %q+D ist statisch, aber in Inline-Funktion %qD deklariert, was nicht statisch ist

en: %q+D is usually a function
de: %q+D ist üblicherweise eine Funktion

en: %q+D offset %E in %qT isn%'t aligned to %u
de: %q+D mit Offset %E in %qT ist nicht an %u ausgerichtet

en: %q+D offset %E in %qT may not be aligned to %u
de: %q+D mit Offset %E in %qT ist möglicherweise nicht an %u ausgerichtet

en: %q+D redeclared as different kind of symbol
de: %q+D als andere Symbolart redeklariert

en: %q+D redeclared inline with %<gnu_inline%> attribute
de: %q+D mit Attribut %<gnu_inline%> »inline« redeklariert

en: %q+D redeclared inline without %<gnu_inline%> attribute
de: %q+D ohne Attribut %<gnu_inline%> »inline« redeklariert

en: %q+D redeclared without dllimport attribute after being referenced with dll linkage
de: %q+D ohne Attribut »dllimport« redeklariert, nachdem es mit dll-Bindung referenziert wurde

en: %q+D redeclared without dllimport attribute: previous dllimport ignored
de: %qD ohne Attribut »dllimport« redeklariert: vorheriges »dllimport« ignoriert

en: %q+D static data member inside of declare target directive
de: statisches Datenelement %q+D innerhalb von »declare target«-Direktive

en: %q+D takes only zero or two arguments
de: %q+D benötigt entweder null oder zwei Argumente

en: %q+E is not a constant expression
de: %q+E ist kein Konstantenausdruck

en: %q+F declared %<static%> but never defined
de: %q+F als %<static%> deklariert, aber nirgendwo definiert

en: %q+F used but never defined
de: %q+F verwendet, aber nirgendwo definiert

en: %q+T is not literal because:
de: %q+T ist kein Literal, denn:

en: %qD accessing %E byte in a region of size %E
de: %qD greift auf %E Byte in einer Region der Größe %E zu

en: %qD accessing %E bytes in a region of size %E
de: %qD greift auf %E Bytes in einer Region der Größe %E zu

en: %qD accessing %E or more bytes in a region of size %E
de: %qD greift auf %E oder mehr Bytes in einer Region der Größe %E zu

en: %qD accessing %wu byte at offsets %s and %s may overlap %wu byte at offset %s | %qD accessing %wu bytes at offsets %s and %s may overlap %wu byte at offset %s
de[0]: %qD Zugriff auf %wu Byte an den Offsets %s und %s überdeckt möglicherweise %wu Byte an Offset %s
de[1]: %qD Zugriff auf %wu Byte an den Offsets %s und %s überdeckt möglicherweise %wu Bytes an Offset %s

en: %qD accessing %wu byte at offsets %s and %s may overlap up to %wu bytes at offset %s | %qD accessing %wu bytes at offsets %s and %s may overlap up to %wu bytes at offset %s
de[0]: %qD Zugriff auf %wu Byte an den Offsets %s und %s überdeckt möglicherweise bis zu %wu Bytes an Offset %s
de[1]: %qD Zugriff auf %wu Bytes an den Offsets %s und %s überdeckt möglicherweise bis zu %wu Bytes an Offset %s

en: %qD accessing %wu byte at offsets %s and %s overlaps %wu byte at offset %s
de: %qD Zugriff auf %wu Byte an den Offsets %s und %s überdeckt sich mit %wu Byte an Offset %s

en: %qD accessing %wu byte at offsets %s and %s overlaps %wu bytes at offset %s
de: %qD Zugriff auf %wu Byte an den Offsets %s und %s überdeckt sich mit %wu Bytes an Offset %s

en: %qD accessing %wu byte at offsets %s and %s overlaps %wu or more bytes at offset %s | %qD accessing %wu bytes at offsets %s and %s overlaps %wu or more bytes at offset %s
de[0]: %qD Zugriff auf %wu Byte an den Offsets %s und %s überdeckt sich mit %wu oder mehr Bytes an Offset %s
de[1]: %qD Zugriff auf %wu Bytes an den Offsets %s und %s überdeckt sich mit %wu oder mehr Bytes an Offset %s

en: %qD accessing %wu byte at offsets %s and %s overlaps between %wu and %wu bytes at offset %s | %qD accessing %wu bytes at offsets %s and %s overlaps between %wu and %wu bytes at offset %s
de[0]: %qD Zugriff auf %wu Byte an den Offsets %s und %s überdeckt sich mit %wu bis %wu Bytes an Offset %s
de[1]: %qD Zugriff auf %wu Bytes an den Offsets %s und %s überdeckt sich mit %wu bis %wu Bytes an Offset %s

en: %qD accessing %wu byte may overlap %wu byte | %qD accessing %wu bytes may overlap %wu byte
de[0]: %qD Zugriff auf %wu Byte überdeckt möglicherweise %wu Byte
de[1]: %qD Zugriff auf %wu Byte überdeckt möglicherweise %wu Bytes

en: %qD accessing %wu byte may overlap up to %wu bytes | %qD accessing %wu bytes may overlap up to %wu bytes
de[0]: %qD Zugriff auf %wu Byte überdeckt möglicherweise bis zu %wu Bytes
de[1]: %qD Zugriff auf %wu Bytes überdeckt möglicherweise bis zu %wu Bytes

en: %qD accessing %wu bytes at offsets %s and %s overlaps %wu byte at offset %s
de: %qD Zugriff auf %wu Bytes an den Offsets %s und %s überdeckt sich mit %wu Byte an Offset %s

en: %qD accessing %wu bytes at offsets %s and %s overlaps %wu bytes at offset %s
de: %qD Zugriff auf %wu Bytes an den Offsets %s und %s überdeckt sich mit %wu Bytes an Offset %s

en: %qD accessing %wu or more bytes at offsets %s and %s may overlap %wu byte at offset %s | %qD accessing %wu or more bytes at offsets %s and %s may overlap up to %wu bytes at offset %s
de[0]: %qD Zugriff auf %wu oder mehr Bytes an Offsets %s und %s überdeckt möglicherweise %wu Byte an Offset %s
de[1]: %qD Zugriff auf %wu oder mehr Bytes an Offsets %s und %s überdeckt möglicherweise %wu Bytes an Offset %s

en: %qD accessing %wu or more bytes at offsets %s and %s overlaps %wu byte at offset %s | %qD accessing %wu or more bytes at offsets %s and %s overlaps %wu bytes at offset %s
de[0]: %qD Zugriff auf %wu oder mehr Bytes an den Offsets %s und %s überdeckt %wu Byte an Offset %s
de[1]: %qD Zugriff auf %wu oder mehr Bytes an den Offsets %s und %s überdeckt %wu Bytes an Offset %s

en: %qD accessing %wu or more bytes at offsets %s and %s overlaps %wu or more bytes at offset %s
de: %qD Zugriff auf %wu oder mehr Bytes an den Offsets %s und %s überdeckt %wu oder mehr Bytes an Offset %s

en: %qD accessing %wu or more bytes at offsets %s and %s overlaps between %wu and %wu bytes at offset %s
de: %qD Zugriff auf %wu oder mehr Bytes an den Offsets %s und %s überdeckt %wu bis %wu Bytes an Offset %s

en: %qD accessing between %E and %E bytes in a region of size %E
de: %qD greift auf zwischen %E und %E Bytes in einer Region der Größe %E zu

en: %qD accessing between %wu and %wu bytes at offsets %s and %s may overlap %wu byte at offset %s | %qD accessing between %wu and %wu bytes at offsets %s and %s may overlap up to %wu bytes at offset %s
de[0]: %qD Zugriff auf %wu bis %wu Bytes an Offsets %s und %s überdeckt möglicherweise %wu Byte an Offset %s
de[1]: %qD Zugriff auf %wu bis %wu Bytes an Offsets %s und %s überdeckt möglicherweise %wu Bytes an Offset %s

en: %qD accessing between %wu and %wu bytes at offsets %s and %s overlaps %wu byte at offset %s | %qD accessing between %wu and %wu bytes at offsets %s and %s overlaps %wu bytes at offset %s
de[0]: %qD Zugriff auf %wu bis %wu Bytes an den Offsets %s und %s überdeckt %wu Byte an Offset %s
de[1]: %qD Zugriff auf %wu bis %wu Bytes an den Offsets %s und %s überdeckt %wu Bytes an Offset %s

en: %qD accessing between %wu and %wu bytes at offsets %s and %s overlaps %wu or more bytes at offset %s
de: %qD Zugriff auf %wu bis %wu Bytes an den Offsets %s und %s überdeckt %wu oder mehr Bytes an Offset %s

en: %qD accessing between %wu and %wu bytes at offsets %s and %s overlaps between %wu and %wu bytes at offset %s
de: %qD Zugriff auf %wu bis %wu Bytes an den Offsets %s und %s überdeckt %wu bis %wu Bytes an Offset %s

en: %qD accessing between %wu and %wu bytes may overlap %wu byte | %qD accessing between %wu and %wu bytes may overlap up to %wu bytes
de[0]: %qD Zugriff auf %wu bis %wu Bytes überdeckt möglicherweise %wu Byte
de[1]: %qD Zugriff auf %wu bis %wu Bytes überdeckt möglicherweise %wu Bytes

en: %qD alias between functions of incompatible types %qT and %qT
de: %qD Alias zwischen unverträglichen Funktionstypen %qT und %qT

en: %qD appears both in data and map clauses
de: %qD tritt in Daten- und Zuordnungsklauseln mehrfach auf

en: %qD appears more than once in %<aligned%> clauses
de: %qD tritt in %<aligned%>-Klausel mehrfach auf

en: %qD appears more than once in %<allocate%> clauses
de: %qD kommt in %<allocate%>-Klausel mehrfach vor

en: %qD appears more than once in %<nontemporal%> clauses
de: %qD tritt in %<nontemporal%>-Klauseln mehrfach auf

en: %qD appears more than once in data clauses
de: %qD tritt in Datenklausel mehrfach auf

en: %qD appears more than once in data-sharing clauses
de: %qD kommt mehr als einmal in Datenfreigabeklauseln vor

en: %qD appears more than once in map clauses
de: %qD tritt in Zuordnungsklauseln mehrfach auf

en: %qD appears more than once in motion clauses
de: %qD tritt in Bewegungsklausel mehrfach auf

en: %qD appears more than once in reduction clauses
de: %qD tritt in Reduktionsklauseln mehrfach auf

en: %qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype
de: der Typ von %qD Argument %d wird zu %qT befördert, der Aufruf der eingebauten Funktion, die ohne Prototyp deklariert wurde, erwartet jedoch %qT

en: %qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype
de: der Typ von %qD Argument %d ist %qT, der Aufruf der eingebauten Funktion, die ohne Prototyp deklariert wurde, erwartet jedoch %qT

en: %qD argument %i declared attribute %<nonstring%>
de: %qD Argument %i ist als Attribut %<nonstring%> deklariert

en: %qD argument %i declared attribute %<nonstring%> is smaller than the specified bound %wu
de: %qD Argument %i (als Attribut %<nonstring%> deklariert) ist kleiner als die angegebene Grenze %wu

en: %qD argument %i declared attribute %<nonstring%> is smaller than the specified bound [%E, %E]
de: %qD Argument %i (als Attribut %<nonstring%> deklariert) ist kleiner als die angegebene Grenze [%E, %E]

en: %qD argument %i declared attribute %<nonstring%> may be smaller than the specified bound [%E, %E]
de: %qD Argument %i (als Attribut %<nonstring%> deklariert) ist möglicherweise kleiner als die angegebene Grenze [%E, %E]

en: %qD argument missing terminating nul
de: Argument für %qD hat kein abschließendes nul-Zeichen

en: %qD attribute directive ignored
de: Attribut-Anweisung %qD wird ignoriert

en: %qD attribute is meaningless since members of the anonymous namespace get local symbols
de: Attribut %qD ist bedeutungslos, da die Elemente des anonymen Namensraums lokale Symbole erhalten

en: %qD attribute requires a single NTBS argument
de: Attribut %qD erfordert ein einzelnes NTBS-Argument

en: %qD called in a constant expression
de: %qD in konstantem Ausdruck aufgerufen

en: %qD called in a constant expression before its definition is complete
de: %qD in konstantem Ausdruck aufgerufen, bevor die Definition vollständig war

en: %qD called on a pointer passed to mismatched reallocation function %qD
de: %qD wird mit Zeiger aufgerufen, der aus der unpassenden Allozierungsfunktion %qD stammt

en: %qD called on a pointer to an unallocated object %qE
de: %qD wird mit Zeiger auf nicht alloziertes Objekt %qE aufgerufen

en: %qD called on pointer %qE passed to mismatched allocation function %qD
de: %qD wird mit Zeiger %qE aufgerufen, der aus der unpassenden Allozierungsfunktion %qD stammt

en: %qD called on pointer %qE with nonzero offset%s
de: %qD wird mit Zeiger %qE mit Offset%s ungleich 0 aufgerufen

en: %qD called on pointer returned from a mismatched allocation function
de: %qD wird mit Zeiger aufgerufen, der aus einer unpassenden Allozierungsfunktion stammt

en: %qD called on pointer to an unallocated object
de: %qD wird mit nicht alloziertem Zeiger aufgerufen

en: %qD called on unallocated object %qD
de: %qD wird auf nicht alloziertem Objekt %qD aufgerufen

en: %qD can be marked override
de: %qD kann als »override« markiert werden

en: %qD cannot appear in a constant-expression
de: %qD kann nicht in Konstanten-Ausdruck auftreten

en: %qD cannot be %qs
de: %qD kann nicht %qs sein

en: %qD cannot be declared %<virtual%>, since it is always static
de: %qD kann nicht als %<virtual%> deklariert werden, da es immer statisch ist

en: %qD cannot be defaulted
de: %qD kann nicht vorgegeben werden

en: %qD cannot be used as a function
de: %qD kann nicht als Funktion verwendet werden

en: %qD cannot have default arguments
de: %qD kann keine Standardargumente haben

en: %qD changed semantics in GCC 4.4
de: %qD hat neue Semantik in GCC 4.4

en: %qD clearing an object of non-trivial type %#qT%s
de: %qD Säubern eines Objekts von nichttrivialem Typ %#qT%s

en: %qD clearing an object of type %#qT containing a pointer-to-member%s
de: %qD Säubern eines Objekts des Typs %#qT, das einen Zeiger auf Datenelement enthält%s

en: %qD clearing an object of type %#qT with no trivial copy-assignment%s
de: %qD Säubern eines Objekts des Typs %#qT ohne triviale Kopierzuweisung%s

en: %qD conflicts with used function
de: %qD steht mit verwendeter Funktion in Konflikt

en: %qD copying an object of non-trivial type %#qT from an array of %#qT
de: %qD Kopieren eines Objekts mit nichttrivialem Typ %#qT aus einem Array von %#qT

en: %qD copying an object of type %#qT with %qs member %qD from an array of %#qT; use assignment or copy-initialization instead
de: %qD Kopieren eines Objekts des Typs %#qT mit Element %qs %qD aus einem Array von %#qT; verwenden Sie eine Zuweisung oder Kopierinitialisierung stattdessen

en: %qD declared %<transaction_safe_dynamic%>
de: %qD als %<transaction_safe_dynamic%> deklariert

en: %qD declared as a %<virtual%> field
de: %qD als ein %<virtual%> Feld deklariert

en: %qD declared as a %<virtual%> parameter
de: %qD als ein %<virtual%> Parameter deklariert

en: %qD declared as a %<virtual%> type
de: %qD als ein %<virtual%> Typ deklariert

en: %qD declared as a %<virtual%> variable
de: %qD als eine %<virtual%> Variable deklariert

en: %qD declared as a non-parameter
de: %qD als Nicht-Parameter deklariert

en: %qD declared as an %<inline%> field
de: %qD als ein %<inline%> Feld deklariert

en: %qD declared as an %<inline%> parameter
de: %qD als ein %<inline%> Parameter deklariert

en: %qD declared as an %<inline%> type
de: %qD als ein %<inline%> Typ deklariert

en: %qD declared as array of template placeholder type %qT
de: %qD ist als Array vom Template-Platzhaltertyp %qT deklariert

en: %qD declared as reference but not initialized
de: %qD als Referenz deklariert, aber nicht initialisiert

en: %qD declared here
de: %qD ist hier deklariert

en: %qD declared here as %q#D
de: %qD wurde hier als %q#D deklariert

en: %qD declared here, later in the translation unit
de: %qD hier deklariert, später in der Übersetzungseinheit

en: %qD declared weak after being used
de: %qD als schwach deklariert, nachdem es verwendet wurde

en: %qD defined %<static%> in %<constexpr%> context
de: %qD in %<constexpr%>-Kontext als %<static%> definiert

en: %qD defined %<static%> in %qs function only available with %<-std=c++2b%> or %<-std=gnu++2b%>
de: %qD kann in einer %qs-Funktion erst ab %<-std=c++2b%> oder %<-std=gnu++2b%> als %<static%> definiert werden

en: %qD defined %<thread_local%> in %<constexpr%> context
de: %qD in %<constexpr%>-Kontext als %<thread_local%> definiert

en: %qD defined %<thread_local%> in %qs function only available with %<-std=c++2b%> or %<-std=gnu++2b%>
de: %qD kann in einer %qs-Funktion erst ab %<-std=c++2b%> oder %<-std=gnu++2b%> als %<thread_local%> definiert werden

en: %qD defined but not used
de: %qD definiert, aber nicht verwendet

en: %qD defined here
de: %qD hier definiert

en: %qD destination unchanged after copying no bytes
de: %qD Ziel unverändert, nachdem keine Bytes kopiert wurden

en: %qD destination unchanged after copying no bytes from a string of length %E
de: %qD Ziel unverändert, nachdem keine Bytes aus einem String der Länge %E kopiert wurden

en: %qD does not have %<const char *%> type
de: %qD hat nicht den Typ %<const char *%>

en: %qD does not have a mappable type in %qs clause
de: %qD in %qs-Klausel hat keinen zuordenbaren Typ

en: %qD does not have integral or enumeration type
de: %qD hat keinen Ganzzahl- oder Aufzählungstyp

en: %qD does not have integral type
de: %qD hat keinen Ganzzahltyp

en: %qD does not name an enumeration in %qT
de: %qD benennt keinen Aufzählungstyp in %qT

en: %qD does not refer to a function
de: %qD bezeichnet keine Funktion

en: %qD does not refer to a namespace scope function
de: %qD bezeichnet keine Funktion innerhalb eines Namensraum

en: %qD expecting %E byte in a region of size %E | %qD expecting %E bytes in a region of size %E
de[0]: %qD erwartet %E Byte in einer Region der Größe %E
de[1]: %qD erwartet %E Bytes in einer Region der Größe %E

en: %qD expecting %E or more bytes in a region of size %E
de: %qD erwartet %E oder mehr Bytes in einer Region der Größe %E

en: %qD expecting between %E and %E bytes in a region of size %E
de: %qD erwartet zwischen %E und %E Bytes in einer Region der Größe %E

en: %qD forming offset %s is out of bounds
de: %qD Bildung des Offsets %s außerhalb der Grenzen

en: %qD forming offset %s is out of the bounds [0, %wu]
de: %qD Bildung des Offsets %s außerhalb der Grenzen [0, %wu]

en: %qD forming offset %s is out of the bounds [0, %wu] of object %qD with type %qT
de: %qD Bildung des Offsets %s außerhalb der Grenzen [0, %wu] von Objekt %qD mit Typ %qT

en: %qD forming offset %s is out of the bounds of object %qD with type %qT
de: %qD Bildung des Offsets %s außerhalb der Grenzen von Objekt %qD mit Typ %qT

en: %qD has a non-structural type
de: %qD ist kein nicht-struktureller Typ

en: %qD has a previous declaration here
de: %qD hat eine vorherige Deklaration hier

en: %qD has already been defined
de: %qD wurde bereits definiert

en: %qD has an incomplete type %qT
de: %qD hat unvollständigen Typ %qT

en: %qD has incomplete type
de: %qD hat unvollständigen Typ

en: %qD has invalid argument list
de: %qD hat ungültige Argumentliste

en: %qD has not been declared in %qD
de: %qD wurde nicht innerhalb von %qD deklariert

en: %qD has not been declared within %qD
de: %qD wurde nicht innerhalb von %qD deklariert

en: %qD has the same name as the class in which it is declared
de: %qD hat den gleichen Namen wie die Klasse, in der es deklariert wurde

en: %qD in %<reduction%> clause is a zero size array
de: %qD in %<reduction%>-Klausel ist ein Array der Länge 0

en: %qD inherits the %E ABI tag that %qT (used in its return type) has
de: %qD erbt das %E-ABI-Tag, das %qT (im Rückgabetyp verwendet) hat

en: %qD inherits the %E ABI tag that %qT (used in its type) has
de: %qD erbt das %E-ABI-Tag, das %qT (im Typ verwendet) hat

en: %qD invalid in %q#T because of local member %q#D with same name
de: %qD ist ungültig in %q#T wegen lokalem Element %q#D mit gleichem Namen

en: %qD invalid in %q#T because of local method %q#D with same name
de: %qD ist in %q#T ungültig wegen lokaler Methode %q#D mit gleichem Namen

en: %qD invalid in condition
de: %qD ungültig in Bedingung

en: %qD invalid in lambda
de: %qD ungültig in Lambda

en: %qD is a function, not a type
de: %qD ist eine Funktion, kein Typ

en: %qD is a namespace
de: %qD ist ein Namensbereich

en: %qD is a usual (non-placement) deallocation function
de: %qD ist eine gewöhnliche (nicht-Platzierungs) Deallokationsfunktion

en: %qD is a usual (non-placement) deallocation function in C++14 (or with %<-fsized-deallocation%>)
de: %qD ist eine übliche (nicht-placement) Deallokationsfunktion in C++14 (oder mit %<-fsized-deallocation%>)

en: %qD is already a friend of %qT
de: %qD ist bereits ein »friend« von %qT

en: %qD is already a friend of class %qT
de: %qD ist bereits ein »friend« der Klasse %qT

en: %qD is already defined in %qT
de: %qD ist bereits in %qT definiert

en: %qD is already defined in class %qT
de: %qD ist bereits in Klasse %qT definiert

en: %qD is already defined in the class %qT
de: %qD ist bereits in der Klasse %qT definiert

en: %qD is an enumeration template
de: %qD ist ein Aufzählungstemplate

en: %qD is both a direct base and an indirect virtual base
de: %qD ist sowohl eine direkte Basis als auch eine indirekte virtuelle Basis

en: %qD is declared in header %qs
de: %qD wird in Header %qs deklariert

en: %qD is defined with tls model %s
de: %qD ist mit TLS-Modell %s definiert

en: %qD is deprecated
de: %qD ist veraltet

en: %qD is deprecated: %s
de: %qD ist veraltet: %s

en: %qD is initialized with itself
de: %qD wird mit sich selbst initialisiert

en: %qD is instantiated for an empty pack
de: %qD wird für ein leeres Pack instanziiert

en: %qD is mutable
de: %qD ist veränderlich

en: %qD is normally a non-static function
de: %qD ist normalerweise eine nicht-statische Funktion

en: %qD is not a class or namespace
de: %qD ist keine Klasse oder Namensbereich

en: %qD is not a class type
de: %qD ist kein Klassentyp

en: %qD is not a direct member of %qT
de: %qD ist kein direktes Element von %qT

en: %qD is not a function argument
de: %qD ist kein Funktionsargument

en: %qD is not a function template
de: %qD ist kein Funktionstemplate

en: %qD is not a member of %qD
de: %qD ist kein Element von %qD

en: %qD is not a member of %qD; did you mean %qs?
de: %qD ist kein Element von %qD; meinten Sie %qs?

en: %qD is not a member of %qT
de: %qD ist kein Element von %qT

en: %qD is not a member of %qT; did you mean %qs?
de: %qD ist kein Element von %qT; meinten Sie %qs?

en: %qD is not a member template function
de: %qD ist keine Elementtemplatefunktion

en: %qD is not a namespace-name
de: %qD ist kein Namensbereichs-Name

en: %qD is not a namespace-name; did you mean %qs?
de: %qD bezeichnet Namensraum-Namen; meinten Sie %qs?

en: %qD is not a pointer variable
de: %qD ist keine Zeigervariable

en: %qD is not a static data member
de: %qD ist kein %<static%>-Datenelement

en: %qD is not a static data member of a class template
de: %qD ist kein statisches Datenelement eines Klassentemplates

en: %qD is not a template
de: %qD ist kein Template

en: %qD is not a template function
de: %qD ist keine Templatefunktion

en: %qD is not a type
de: %qD ist kein Typ

en: %qD is not a valid template argument because %qD is a variable, not the address of a variable
de: %qD ist kein gültiges Templateargument, weil %qD eine Variable und nicht die Adresse einer Variable ist

en: %qD is not a variable
de: %qD ist keine Variable

en: %qD is not a variable in %<aligned%> clause
de: %qD ist in %<aligned%>-Klausel keine Variable

en: %qD is not a variable in %<allocate%> clause
de: %qD ist in %<allocate%>-Klausel keine Variable

en: %qD is not a variable in %<nontemporal%> clause
de: %qD ist in %<nontemporal%>-Klausel keine Variable

en: %qD is not a variable in %qs clause
de: %qD in %qs-Klausel muss eine Variable sein

en: %qD is not a variable in clause %<firstprivate%>
de: %qD ist in Klausel %<firstprivate%> keine Variable

en: %qD is not a variable in clause %<lastprivate%>
de: %qD ist in Klausel %<lastprivate%> keine Variable

en: %qD is not a variable in clause %qs
de: %qD ist in Klausel %qs keine Variable

en: %qD is not a variable template
de: %qD ist kein variadisches Template

en: %qD is not an argument in %<uniform%> clause
de: %qD in %<uniform%>-Klausel ist kein Argument

en: %qD is not captured
de: %qD ist nicht eingefangen

en: %qD is not compatible with %qD
de: %qD ist mit %qD unverträglich

en: %qD is not defined outside of function scope
de: %qD ist außerhalb des Funktionsgültigkeitsbereiches nicht definiert

en: %qD is not lvalue expression nor array section in %qs clause
de: %qD ist in %qs-Klausel weder lvalue-Ausdruck noch Arrayabschnitt

en: %qD is not public
de: %qD ist nicht %<public%>

en: %qD is not usable as a %<constexpr%> function because:
de: %qD ist nicht als %<constexpr%>-Funktion verwendbar, denn:

en: %qD is static but used in inline function %qD which is not static
de: %qD ist statisch, wird jedoch in Inline-Funktion %qD verwendet, was nicht statisch ist

en: %qD is threadprivate variable in %qs clause
de: %qD in %qs-Klausel ist eine threadprivate Variable

en: %qD is too small to hold all values of %q#T
de: %qD ist zu klein, um alle Werte von %q#T aufzunehmen

en: %qD is unavailable
de: %qD ist nicht verfügbar

en: %qD is unavailable: %s
de: %qD ist nicht verfügbar: %s

en: %qD is used uninitialized
de: %qD ist nicht initialisiert, wird aber benutzt

en: %qD may access %E byte in a region of size %E
de: %qD greift möglicherweise auf %E Byte in einer Region der Größe %E zu

en: %qD may access %E bytes in a region of size %E
de: %qD greift möglicherweise auf %E Bytes in einer Region der Größe %E zu

en: %qD may access %E or more bytes in a region of size %E
de: %qD greift möglicherweise auf %E oder mehr Bytes in einer Region der Größe %E zu

en: %qD may access between %E and %E bytes in a region of size %E
de: %qD greift möglicherweise auf zwischen %E und %E Bytes in einer Region der Größe %E zu

en: %qD may be used uninitialized
de: %qD könnte uninitialisiert verwendet werden

en: %qD may not be declared as static
de: %qD darf nicht als »static« deklariert werden

en: %qD may not be declared within a namespace
de: %qD darf nicht innerhalb eines Namensbereiches definiert werden

en: %qD may read %E byte from a region of size %E
de: %qD liest möglicherweise %E Byte aus einer Region der Größe %E

en: %qD may read %E bytes from a region of size %E
de: %qD liest möglicherweise %E Bytes aus einer Region der Größe %E

en: %qD may read %E or more bytes from a region of size %E
de: %qD liest möglicherweise %E oder mehr Bytes aus einer Region der Größe %E

en: %qD may read between %E and %E bytes from a region of size %E
de: %qD liest möglicherweise zwischen %E und %E Bytes aus einer Region der Größe %E

en: %qD may write %E byte into a region of size %E
de: %qD schreibt möglicherweise %E Byte in eine Region der Größe %E

en: %qD may write %E bytes into a region of size %E
de: %qD schreibt möglicherweise %E Bytes in eine Region der Größe %E

en: %qD may write %E or more bytes into a region of size %E
de: %qD schreibt möglicherweise %E oder mehr Bytes in eine Region der Größe %E

en: %qD may write between %E and %E bytes into a region of size %E
de: %qD schreibt möglicherweise zwischen %E und %E Bytes in eine Region der Größe %E

en: %qD moving an object of non-trivial type %#qT and size %E into a region of size %E
de: %qD Verschieben eines Objekts des nichttrivialen Typs %#qT und Größe %E in eine Region der Größe %E

en: %qD moving an object of non-trivially copyable type %#qT; use %<new%> and %<delete%> instead
de: %qD Verschieben eines Objekts des nichttrivial kopierbaren Typs %#qT; verwenden Sie stattdessen %<new%> oder %<delete%>

en: %qD moving an object of type %#qT with deleted copy constructor; use %<new%> and %<delete%> instead
de: %qD Verschieben eines Objekts des Typs %#qT mit gelöschtem Kopierkonstruktor; verwenden Sie stattdessen %<new%> und %<delete%>

en: %qD moving an object of type %#qT with deleted destructor
de: %qD Verschieben eines Objekts des Typs %#qT mit gelöschtem Destruktor

en: %qD must be a global variable in %<#pragma acc declare link%>
de: In %<#pragma acc declare link%> muss %qD eine globale Variable sein

en: %qD must be a non-member function
de: %qD muss eine Nicht-Elementfunktion sein

en: %qD must be a non-static member function
de: %qD muss eine nichtstatische Elementfunktion sein

en: %qD must be a variable declared in the same scope as %<#pragma acc declare%>
de: %qD muss eine Variable sein, die im selben Gültigkeitsbereich wie %<#pragma acc declare%> deklariert ist

en: %qD must be either a non-static member function or a non-member function
de: %qD muss entweder eine nichtstatische Elementfunktion oder eine Nicht-Element-Funktion sein

en: %qD must have an argument of class or enumerated type
de: %qD muss ein Argument von einem Klassen- oder Aufzählungstyp haben

en: %qD must have either one or two arguments
de: %qD muss entweder ein oder zwei Argumente nehmen

en: %qD must have either zero or one argument
de: %qD muss entweder null oder ein Argument nehmen

en: %qD must have exactly one argument
de: %qD muss genau ein Argument nehmen

en: %qD must have exactly two arguments
de: %qD muss genau zwei Argumente nehmen

en: %qD must have no arguments
de: %qD darf keine Argumente nehmen

en: %qD must not have variable number of arguments
de: »%qD« darf keine variable Argumentanzahl haben

en: %qD not defined
de: %qD nicht definiert

en: %qD of a string of length %wu and an array of size %wu evaluates to nonzero
de: %qD einer Zeichenkette der Länge %wu und eines Arrays der Größe %wu wird zu ungleich Null ausgewertet

en: %qD of a string of length %wu or more and an array of size %wu evaluates to nonzero
de: %qD einer Zeichenkette der Länge %wu oder mehr und einem Array der Größe %wu wird zu ungleich Null ausgewertet

en: %qD of a string of length %wu, an array of size %wu and bound of %wu evaluates to nonzero
de: %qD einer Zeichenkette der Länge %wu, einem Array der Größe %wu und der Grenze von %wu wird zu ungleich Null ausgewertet

en: %qD of strings of length %wu and %wu and bound of %wu evaluates to nonzero
de: %qD von Zeichenketten der Länge %wu und %wu und der Grenze von %wu wird zu ungleich Null ausgewertet

en: %qD offset %s from the object at %qE is out of the bounds of %qT
de: %qD Offset %s des Objekts an %qE ist außerhalb der Grenzen von %qT

en: %qD offset %s from the object at %qE is out of the bounds of referenced subobject %qD with type %qT at offset %wi
de: %qD Offset %s des Objekts an %qE ist außerhalb der Grenzen des referenzierten Teilobjekts %qD mit Typ %qT an Offset %wi

en: %qD offset %s is out of bounds
de: %qD Offset %s ist außerhalb der Grenzen

en: %qD offset %s is out of the bounds [0, %wu]
de: %qD Offset %s ist außerhalb der Grenzen [0, %wu]

en: %qD offset %s is out of the bounds [0, %wu] of object %qD with type %qT
de: %qD Offset %s is außerhalb der Grenzen [0, %wu] von Objekt %qD mit Typ %qT

en: %qD offset %s is out of the bounds of object %qD with type %qT
de: %qD Offset %s ist außerhalb der Grenzen von Objekt %qD mit Typ %qT

en: %qD output may be truncated copying %E byte from a string of length %wu | %qD output may be truncated copying %E bytes from a string of length %wu
de[0]: Ausgabe von %qD möglicherweise abgeschnitten, beim Kopieren von %E Byte aus einer Zeichenkette der Länge %wu
de[1]: Ausgabe von %qD möglicherweise abgeschnitten, beim Kopieren von %E Bytes aus einer Zeichenkette der Länge %wu

en: %qD output may be truncated copying between %wu and %wu bytes from a string of length %wu
de: %qD Ausgabe möglicherweise abgeschnitten, beim Kopieren von %wu bis %wu Byte aus einer Zeichenkette der Länge %wu

en: %qD output truncated before terminating nul copying %E byte from a string of the same length | %qD output truncated before terminating nul copying %E bytes from a string of the same length
de[0]: %qD Ausgabe abgeschnitten vor dem abschließenden NUL, beim Kopieren von %E Byte aus einem String derselben Länge
de[1]: %qD Ausgabe abgeschnitten vor dem abschließenden NUL, beim Kopieren von %E Bytes aus einem String derselben Länge

en: %qD output truncated before terminating nul copying as many bytes from a string as its length
de: %qD Ausgabe abgeschnitten vor dem beendenden NUL, beim Kopieren von so vielen Bytes aus einer Zeichenkette, wie die Ausgabezeichenkette lang ist

en: %qD output truncated copying %E byte from a string of length %wu | %qD output truncated copying %E bytes from a string of length %wu
de[0]: Ausgabe von %qD abgeschnitten, beim Kopieren von %E Byte aus einer Zeichenkette der Länge %wu
de[1]: Ausgabe von %qD abgeschnitten, beim Kopieren von %E Bytes aus einer Zeichenkette der Länge %wu

en: %qD output truncated copying between %wu and %wu bytes from a string of length %wu
de: %qD Ausgabe abgeschnitten, beim Kopieren von %wu bis %wu Bytes aus einer Zeichenkette der Länge %wu

en: %qD pointer overflow between offset %s and size %s
de: %qD Zeigerüberlauf zwischen Offset %s und Größe %s

en: %qD pointer overflow between offset %s and size %s accessing array %qD with type %qT
de: %qD Zeigerüberlauf zwischen Offset %s und Größe %s beim Zugriff auf Array %qD mit Typ %qT

en: %qD reading %E byte from a region of size %E
de: %qD liest %E Byte aus einer Region der Größe %E

en: %qD reading %E bytes from a region of size %E
de: %qD liest %E Bytes aus einer Region der Größe %E

en: %qD reading %E or more bytes from a region of size %E
de: %qD liest %E oder mehr Bytes aus einer Region der Größe %E

en: %qD reading between %E and %E bytes from a region of size %E
de: %qD liest zwischen %E und %E Bytes aus einer Region der Größe %E

en: %qD redeclared with different access
de: %qD mit anderem Zugriff redeklariert

en: %qD redeclared with different visibility
de: %qD mit anderer Sichtbarkeit redeklariert

en: %qD referenced in target region does not have a mappable type
de: Zielregion verweist auf %qD, aber der Ausdruck hat keinen zuordenbaren Typ

en: %qD renamed after being referenced in assembly
de: %qD nach Referenzierung in Assemblierung umbenannt

en: %qD should be initialized
de: %qD sollte initialisiert werden

en: %qD should be initialized in the member initialization list
de: %qD sollte in Elementinitialisierungsliste initialisiert werden

en: %qD should have been declared inside %qD
de: %qD sollte innerhalb von %qD deklariert werden

en: %qD should return by value
de: %qD sollte Wert zurückgeben

en: %qD source argument is the same as destination
de: Quellargument für %qD ist dasselbe wie für das Ziel

en: %qD specified both in declare target %<link%> and %<to%> clauses
de: %qD ist sowohl in %<link%>- als auch %<to%>-Klauseln des Deklarationsziels angegeben

en: %qD specified both in declare target %<link%> and implicitly in %<to%> clauses
de: %qD ist sowohl in %<declare target link%>- als auch implizit in %<to%>-Klauseln angegeben

en: %qD specified bound %E equals destination size
de: angegebene Grenze %2$E von %1$qD ist genau die Größe des Ziels

en: %qD specified bound %E equals source length
de: %qD angegebene Grenze %E ist genau die Größe der Quelle

en: %qD specified bound %E exceeds destination size %E
de: durch %qD angegebene Grenze %E überschreitet die Größe %E des Zielobjekts

en: %qD specified bound %E exceeds maximum object size %E
de: durch %qD angegebene Grenze %E überschreitet die maximale Objektgröße %E

en: %qD specified bound %E exceeds source size %E
de: durch %qD angegebene Grenze %E überschreitet die Größe %E des Quellobjekts

en: %qD specified bound %E may exceed destination size %E
de: durch %qD angegebene Grenze %E überschreitet möglicherweise die Größe %E des Zielobjekts

en: %qD specified bound %E may exceed maximum object size %E
de: durch %qD angegebene Grenze %E überschreitet möglicherweise die maximale Objektgröße %E

en: %qD specified bound %E may exceed source size %E
de: durch %qD angegebene Grenze %E überschreitet möglicherweise die Größe %E des Quellobjekts

en: %qD specified bound %s exceeds maximum object size %E
de: durch %qD angegebene Grenze %s überschreitet die maximale Objektgröße %E

en: %qD specified bound %s exceeds the size %E of unterminated array
de: durch %qD angegebene Grenze %s überschreitet die Größe %E des nicht abgeschlossenen Arrays

en: %qD specified bound %s exceeds the size of at most %E of unterminated array
de: durch %qD angegebene Grenze %s überschreitet die Maximalgröße %E des nicht abgeschlossenen Arrays

en: %qD specified bound %s may exceed the size of at most %E of unterminated array
de: durch %qD angegebene Grenze %s überschreitet möglicherweise die Maximalgröße %E des nicht abgeschlossenen Arrays

en: %qD specified bound %wu exceeds maximum object size %wu
de: durch %qD angegebene Grenze %wu überschreitet maximale Objektgröße %wu

en: %qD specified bound [%E, %E] exceeds destination size %E
de: durch %qD angegebene Grenze [%E, %E] überschreitet die Größe %E des Zielobjekts

en: %qD specified bound [%E, %E] exceeds maximum object size %E
de: durch %qD angegebene Grenze [%E, %E] überschreitet die maximale Objektgröße %E

en: %qD specified bound [%E, %E] exceeds source size %E
de: durch %qD angegebene Grenze [%E, %E] überschreitet die Größe %E des Quellobjekts

en: %qD specified bound [%E, %E] may exceed destination size %E
de: durch %qD angegebene Grenze [%E, %E] überschreitet möglicherweise die Größe %E des Zielobjekts

en: %qD specified bound [%E, %E] may exceed maximum object size %E
de: durch %qD angegebene Grenze [%E, %E] überschreitet möglicherweise die maximale Objektgröße %E

en: %qD specified bound [%E, %E] may exceed source size %E
de: durch %qD angegebene Grenze [%E, %E] überschreitet möglicherweise die Größe %E des Quellobjekts

en: %qD specified bound between %wu and %wu exceeds maximum object size %wu
de: durch %qD angegebene Grenze zwischen %wu und %wu überschreitet maximale Objektgröße %wu

en: %qD specified bound depends on the length of the source argument
de: %qD angegebene Grenze hängt von der Länge des Quellarguments ab

en: %qD specified in %<allocate%> clause but not in an explicit privatization clause
de: %qD ist in %<allocate%>-Klausel angegeben, aber nicht in einer expliziten Privatisierungs-Klausel

en: %qD specified in %<inscan%> %<reduction%> clause but not in %<scan%> directive clause
de: %qD ist in %<inscan%>-%<reduction%>-Klausel angegeben, aber nicht in %<scan%>-Direktivenklausel

en: %qD specified in %qs clause but not in %<inscan%> %<reduction%> clause on the containing construct
de: %qD wurde in %qs-Klausel angegeben, aber nicht in %<inscan%>-%<reduction%>-Klausel am enthaltenden Konstrukt

en: %qD specified size %E exceeds maximum object size %E
de: durch %qD angegebene Größe %E überschreitet die maximale Objektgröße %E

en: %qD specified size %E may exceed maximum object size %E
de: durch %qD angegebene Größe %E überschreitet möglicherweise die maximale Objektgröße %E

en: %qD specified size between %E and %E exceeds maximum object size %E
de: durch %qD angegebene Größe zwischen %E und %E überschreitet die maximale Objektgröße %E

en: %qD specified size between %E and %E may exceed maximum object size %E
de: durch %qD angegebene Größe zwischen %E und %E überschreitet möglicherweise die maximale Objektgröße %E

en: %qD specifies less restrictive attribute than its target %qD: %s | %qD specifies less restrictive attributes than its target %qD: %s
de[0]: %qD legt weniger eingeschränktes Attribut als sein Ziel %qD fest: %s
de[1]: %qD legt weniger eingeschränkte Attribute als sein Ziel %qD fest: %s

en: %qD specifies more restrictive attribute than its target %qD: %s | %qD specifies more restrictive attributes than its target %qD: %s
de[0]: %qD legt eingeschränkteres Attribut als sein Ziel %qD fest: %s
de[1]: %qD legt eingeschränktere Attribute als sein Ziel %qD fest: %s

en: %qD target declared here
de: Ziel %qD wurde hier deklariert

en: %qD used as a variant with incompatible %<construct%> selector sets
de: %qD als Variante mit inkompatiblen %<construct%>-Selektormengen verwendet

en: %qD used before its definition
de: %qD vor seiner Definition verwendet

en: %qD used in its own initializer
de: %qD in seiner eigenen Initialisierung verwendet

en: %qD used without template arguments
de: %qD wird ohne Template-Argumente verwendet

en: %qD violates the C++ One Definition Rule
de: %qD verletzt die One-Definition-Rule von C++

en: %qD was declared %<extern%> and later %<static%>
de: %qD wurde %<extern%> deklariert und später %<static%>

en: %qD was declared %qs which implies default visibility
de: %qD wurde als %qs deklariert, was Standardsichtbarkeit mit sich bringt

en: %qD was declared here
de: %qD wurde hier deklariert

en: %qD was hidden
de: %qD war versteckt

en: %qD was not declared %<constexpr%>
de: %qD wurde nicht als %<constexpr%> definiert

en: %qD was not declared in this scope
de: %qD wurde in diesem Gültigkeitsbereich nicht definiert

en: %qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation
de: %qD wurde in diesem Gültigkeitsbereich nicht deklariert, und bei argumentabhängiger Suche am Ort der Instanziierung wurden keine Deklarationen gefunden

en: %qD was not declared in this scope; did you mean %qs?
de: %qD wurde in diesem Gültigkeitsbereich nicht deklariert; meinten Sie %qs?

en: %qD was not initialized with a constant expression
de: %qD wurde nicht mit konstantem Ausdruck initialisiert

en: %qD was previously declared here
de: %qD wurde vorher hier deklariert

en: %qD was used with no declaration before its definition
de: %qD wurde vor seiner Definition ohne Deklaration verwendet

en: %qD was used with no prototype before its definition
de: %qD wurde vor seiner Definition ohne Prototyp verwendet

en: %qD will be initialized after
de: %qD wird initialisiert nach

en: %qD writing %E byte into a region of size %E overflows the destination
de: %qD schreibt %E Byte in eine Region der Größe %E und bringt dadurch das Zielobjekt zum Überlaufen

en: %qD writing %E bytes into a region of size %E overflows the destination
de: %qD schreibt %E Bytes in eine Region der Größe %E und bringt dadurch das Zielobjekt zum Überlaufen

en: %qD writing %E or more bytes into a region of size %E overflows the destination
de: %qD schreibt %E oder mehr Bytes in eine Region der Größe %E und bringt dadurch das Zielobjekt zum Überlaufen

en: %qD writing %wu byte into a region of size %wu | %qD writing %wu bytes into a region of size %wu
de[0]: %qD schreibt %wu Byte in eine Region der Größe %wu
de[1]: %qD schreibt %wu Bytes in eine Region der Größe %wu

en: %qD writing %wu byte into a region of size between %wu and %wu | %qD writing %wu bytes into a region of size between %wu and %wu
de[0]: %qD schreibt %wu Byte in eine Region der Größe zwischen %wu und %wu
de[1]: %qD schreibt %wu Bytes in eine Region der Größe zwischen %wu und %wu

en: %qD writing between %E and %E bytes into a region of size %E overflows the destination
de: %qD schreibt zwischen %E und %E Bytes in eine Region der Größe %E und bringt dadurch das Zielobjekt zum Überlaufen

en: %qD writing between %wu and %wu bytes into a region of size %wu
de: %qD schreibt zwischen %wu und %wu Bytes in eine Region der Größe %wu

en: %qD writing between %wu and %wu bytes into a region of size between %wu and %wu
de: %qD schreibt zwischen %wu und %wu Bytes in eine Region der Größe zwischen %wu und %wu

en: %qD writing one too many bytes into a region of a size that depends on %<strlen%>
de: %qD schreibt ein Byte zu viel in eine Region, deren Größe von %<strlen%> abhängt

en: %qD writing to an object of a non-trivial type %#qT leaves %wu byte unchanged
de: %qD Schreiben in ein Objekt eines nichttrivialen Typen %#qT lässt %wu Byte unverändert

en: %qD writing to an object of a non-trivial type %#qT leaves %wu bytes unchanged
de: %qD Schreiben in ein Objekt eines nichttrivialen Typen %#qT lässt %wu Bytes unverändert

en: %qD writing to an object of non-trivial type %#qT%s
de: %qD Schreiben in ein Objekt des nichttrivialen Typs %#qT%s

en: %qD writing to an object of non-trivially copyable type %#qT%s
de: %qD Schreiben in ein Objekt des nichttrivial kopierbaren Typs %#qT%s

en: %qD writing to an object of type %#qT containing a pointer to data member%s
de: %qD Schreibzugriff auf ein Objekt des Typs %#qT, das einen Zeiger auf Datenelement enthält%s

en: %qD writing to an object of type %#qT with %qs member %qD
de: %qD Schreibzugriff auf ein Objekt des Typs %#qT mit Element %qs %qD

en: %qD writing to an object of type %#qT with no trivial copy-assignment
de: %qD Schreibzugriff auf ein Objekt des Typs %#qT ohne triviale Kopierzuweisung

en: %qD writing to an object of type %#qT with no trivial copy-assignment%s
de: %qD Schreibzugriff auf ein Objekt des Typs %#qT ohne triviale Kopierzuweisung%s

en: %qD writing to an object with a deleted copy constructor
de: %qD Schreibzugriff auf ein Objekt mit einem gelöschten Kopierkonstruktor

en: %qD: visibility attribute ignored because it conflicts with previous declaration
de: %qD: Sichtbarkeitsattribut ignoriert, da es in Konflikt mit vorheriger Deklaration steht

en: %qE 2.95 vtable-compatibility attribute applies only to C++ classes
de: %qE 2.95 vtable-Kompatibilitätsattribut trifft nur für C++-Klassen zu

en: %qE 2.95 vtable-compatibility attribute applies only when compiling a kext
de: %qE 2.95 vtable-Kompatibilitätsattribut trifft nur zu, wenn ein »kext« kompiliert wird

en: %qE appears more than once in %<aligned%> clauses
de: %qE tritt in %<aligned%>-Klausel mehrfach auf

en: %qE appears more than once in %<allocate%> clauses
de: %qE kommt mehr als einmal in %<allocate%>-Klauseln vor

en: %qE appears more than once in %<nontemporal%> clauses
de: %qE tritt in %<nontemporal%>-Klausel mehrfach auf

en: %qE appears more than once in data clauses
de: %qE tritt in dieser Datenklausel mehrfach auf

en: %qE appears more than once in map clauses
de: %qE tritt in Mapklauseln mehrfach auf

en: %qE appears more than once on the same %<declare target%> directive
de: %qE tritt in derselben %<declare target%>-Direktive mehrfach auf

en: %qE argument %Z may overlap destination object %qE | %qE arguments %Z may overlap destination object %qE
de[0]: %qE Argument %Z überlappt möglicherweise das Zielobjekt %qE
de[1]: %qE Argumente %Z überlappen möglicherweise das Zielobjekt %qE

en: %qE argument %Z overlaps destination object %qE | %qE arguments %Z overlap destination object %qE
de[0]: %qE Argument %Z überlappt das Zielobjekt %qE
de[1]: %qE Argumente %Z überlappen das Zielobjekt %qE

en: %qE argument is not a function
de: Argument %qE ist keine Funktion

en: %qE argument must be one of %qs, %qs, %qs, or %qs
de: Argument %qE muss eins von %qs, %qs, %qs oder %qs sein

en: %qE argument not a string
de: Argument %qE ist keine Zeichenkette

en: %qE argument not an identifier
de: Argument %qE ist kein Bezeichner

en: %qE arguments %Z and maybe %Z overlap destination object %qE
de: Im Aufruf von %qE überlappen sich die Argumente %Z und vielleicht %Z mit dem Zielobjekt %qE

en: %qE attribute address out of range
de: Adresse von Attribut %qE außerhalb des gültigen Bereichs

en: %qE attribute allows only an integer constant argument
de: Attribut %qE erlaubt nur eine Ganzzahlkonstante als Argument

en: %qE attribute applied to %qD with void return type
de: Attribut %qE auf %qD mit Rückgabetyp »void« angewendet

en: %qE attribute applied to %qT after its definition
de: Attribut %qE auf %qT nach seiner Definition angewendet

en: %qE attribute applied to extern "C" declaration %qD
de: Attribut %qE wird auf »extern "C"«-Deklaration %qD angewendet

en: %qE attribute applied to non-class, non-enum type %qT
de: Attribut %qE auf Nicht-Klassen-, Nicht-Enum-Typ %qT angewendet

en: %qE attribute applied to non-function, non-variable %qD
de: %qE-Attribut wird auf %qD angewendet, das weder Funktion noch Variable ist

en: %qE attribute applies only to functions
de: Attribut %qE kann nur auf Funktionen angewandt werden

en: %qE attribute applies only to initialized variables with external linkage
de: Attribut %qE bezieht sich nur auf initialisierte Variablen mit externer Bindung

en: %qE attribute argument %E is not a power of 2
de: Attributargument %qE mit Wert %E ist keine Zweierpotenz

en: %qE attribute argument %E is not an integer constant
de: Attribut %qE mit Argument %E ist keine Ganzzahlkonstante

en: %qE attribute argument %E is not in the range [0, %wu]
de: Argument %2$E von Attribut %1$qE liegt nicht im Bereich [0, %3$wu]

en: %qE attribute argument %E is not positive
de: Attribut %qE Argument %E ist nicht positiv

en: %qE attribute argument %i has type %qT
de: Attributargument %qE an Position %i hat Typ %qT

en: %qE attribute argument %i is invalid
de: Attributargument %qE an Position %i ist ungültig

en: %qE attribute argument %i value %qE does not refer to a function parameter
de: Attributargument %qE an Position %i hat den Wert %qE, der nicht auf einen Funktionsparameter verweist

en: %qE attribute argument %i value %qE does not refer to a variable argument list
de: Attributargument %qE an Position %i hat den Wert %qE, der nicht auf eine variable Argumentliste verweist

en: %qE attribute argument %i value %qE exceeds the number of function parameters %u
de: Attributargument %qE an Position %i hat den Wert %qE, der die Anzahl der Funktionsparameter %u übersteigt

en: %qE attribute argument %i value %qE is not an integer constant
de: Attributargument %qE an Position %i hat den Wert %qE, der keine Ganzzahlkonstante ist

en: %qE attribute argument %i value %qE refers to a variadic function parameter of unknown type
de: Attributargument %qE an Position %i hat den Wert %qE, der auf einen variadischen Funktionsparameter unbekannten Typs verweist

en: %qE attribute argument %i value %qE refers to parameter type %qT
de: Attributargument %qE an Position %i hat den Wert %qE, der auf den Parametertyp %qT verweist

en: %qE attribute argument %qE exceeds %u
de: Attribut %qE hat Argument %qE, das %u übersteigt

en: %qE attribute argument %qE is not an integer constant
de: Attributargument %qE mit Wert %qE ist keine Ganzzahlkonstante

en: %qE attribute argument %qE is not an integer constant between 0 and 3
de: Attribut %qE Argument %qE muss eine ganzzahlige Konstante zwischen 0 und 3 sein

en: %qE attribute argument %qE is not recognised
de: Attribut %qE Argument %qE ist unbekannt

en: %qE attribute argument 1 does not name a function
de: Attribut %qE Argument 1 benennt keine Funktion

en: %qE attribute argument 1 is ambiguous
de: Attribut %qE Argument 1 ist mehrdeutig

en: %qE attribute argument 1 must take a pointer type as its first argument
de: Attribut %qE Argument 1 muss einen Zeigertyp als erstes Argument haben

en: %qE attribute argument 1 must take a pointer type as its first argument; have %qT
de: Attribut %qE Argument 1 muss einen Zeigertyp als erstes Argument haben, hat jedoch %qT

en: %qE attribute argument cannot be a constant arithmetic expression
de: Attributargument %qE kann kein konstanter arithmetischer Ausdruck sein

en: %qE attribute argument cannot be a string
de: Attributargument %qE kann keine Zeichenkette sein

en: %qE attribute argument has type %qT
de: Attributargument %qE hat Typ %qT

en: %qE attribute argument is invalid
de: Attributargument %qE ist ungültig

en: %qE attribute argument must be a string constant
de: Argument des Attributs %qE muss eine Zeichenkettenkonstante sein

en: %qE attribute argument not a string constant
de: Argument des Attributs %qE ist keine Zeichenkettenkonstante

en: %qE attribute argument not an integer constant
de: Attributargument %qE ist keine Ganzzahlkonstante

en: %qE attribute argument should be between 0 to 255
de: Argument des Attributs %qE sollte zwischen 0 und 255 sein

en: %qE attribute argument should be between 18 to 255
de: Argument des Attributs %qE sollte zwischen 18 und 255 sein

en: %qE attribute argument value %qE does not refer to a function parameter
de: Attributargument %qE hat den Wert %qE, der nicht auf einen Funktionsparameter verweist

en: %qE attribute argument value %qE does not refer to a variable argument list
de: Attributargument %qE hat den Wert %qE, der nicht auf eine variable Argumentliste verweist

en: %qE attribute argument value %qE exceeds %wu
de: Attributargument %qE mit Wert %qE übersteigt %wu

en: %qE attribute argument value %qE exceeds the number of function parameters %u
de: Attributargument %qE hat den Wert %qE, der die Anzahl der Funktionsparameter %u übersteigt

en: %qE attribute argument value %qE is negative
de: Attributargument %qE mit Wert %qE ist negativ

en: %qE attribute argument value %qE is not an integer constant
de: Attributargument %qE hat den Wert %qE, der keine Ganzzahlkonstante ist

en: %qE attribute argument value %qE refers to a variadic function parameter of unknown type
de: Attributargument %qE hat den Wert %qE, der auf einen variadischen Funktionsparameter unbekannten Typs verweist

en: %qE attribute argument value %qE refers to parameter type %qT
de: Attributargument %qE hat den Wert %qE, der auf den Parametertyp %qT verweist

en: %qE attribute can only be applied to functions or to class or enumeration types
de: Attribut %qE kann nur auf Funktionen oder auf Klasse- oder Aufzählungstypen angewendet werden

en: %qE attribute can only be applied to functions or to structure, union or enumeration types
de: Attribut %qE kann nur auf Funktionen oder auf struct-, union- oder enum-Typen angewendet werden

en: %qE attribute can only be applied to non-static data members
de: Attribut %qE kann nur auf nicht-statische Datenelemente angewendet werden

en: %qE attribute cannot be applied to a bit-field
de: Attribut %qE kann nicht auf Bitfeld angewendet werden

en: %qE attribute cannot be specified for local variables
de: Attribut %qE kann nicht für lokale Variablen angegeben werden

en: %qE attribute conflicts with %qE attribute
de: Attribut %qE steht mit Attribut %qE in Konflikt

en: %qE attribute directive ignored
de: Attribut-Direktive %qE ignoriert

en: %qE attribute does not apply to functions
de: Attribut %qE ist nicht auf Funktionen anwendbar

en: %qE attribute does not apply to types
de: Attribut %qE kann nicht auf Typen angewandt werden

en: %qE attribute does not take any arguments
de: Attribut %qE akzeptiert keine Argumente

en: %qE attribute doesn%'t apply to functions
de: Attribut %qE bezieht sich nicht auf Funktionen

en: %qE attribute duplicated
de: doppeltes Attribut %qE

en: %qE attribute follows %qE
de: Attribut %qE folgt auf %qE

en: %qE attribute has no effect
de: Attribut %qE hat keinen Effekt

en: %qE attribute has no effect on functions with static linkage
de: Attribut %qE wirkt sich nicht auf Funktionen mit »static«-Bindung aus

en: %qE attribute has no effect on unit local functions
de: Attribut %qE wirkt sich nicht auf einheits-lokale Funktionen aus

en: %qE attribute have effect only on public objects
de: Attribut %qE wirkt sich nur auf öffentliche Objekte aus

en: %qE attribute ignored
de: Attribut %qE wird ignoriert

en: %qE attribute ignored because %qD does not have thread storage duration
de: Attribut %qE ignoriert, da %qD nicht Thread-Speicherdauer hat

en: %qE attribute ignored because %qD is not a local variable
de: Attribut %qE ignoriert, da %qD keine lokale Variable ist

en: %qE attribute ignored because %qD is not a variable
de: Attribut %qE ignoriert, da %qD keine Variable ist

en: %qE attribute ignored because %qT is already defined
de: Attribut %qE ignoriert, da %qT bereits definiert ist

en: %qE attribute ignored due to conflict with %qs attribute
de: Attribut %qE steht mit Attribut %qs in Konflikt; wird ignoriert

en: %qE attribute ignored due to conflict with attribute %qs
de: Attribut %qE steht mit Attribut %qs in Konflikt; wird ignoriert

en: %qE attribute ignored for %qE
de: Attribut %qE ignoriert für %qE

en: %qE attribute ignored for field of type %qT
de: Attribut %qE ignoriert für Feld vom Typ %qT

en: %qE attribute ignored for type %qT
de: Attribut %qE für Typ %qT ignoriert

en: %qE attribute ignored on a declaration of a different kind than referenced symbol
de: Attributargument %qE deklariert das referenzierte Symbol mit einer anderen Art; wird ignoriert

en: %qE attribute ignored on a function returning %qT
de: Attribut %qE an einer Funktion mit Rückgabetyp %qT wird ignoriert

en: %qE attribute ignored on a redeclaration of the referenced symbol
de: Attributargument %qE deklariert das referenzierte Symbol neu; wird ignoriert

en: %qE attribute ignored on functions returning %qT; valid only for pointer return types
de: Attribut %qE wird an Funktionen mit Rückgabetyp %qT ignoriert; es gilt nur für Zeiger-Rückgabetypen

en: %qE attribute ignored on non-class types
de: Attribut %qE ignoriert für Nicht-Klassen-Typen

en: %qE attribute ignored on objects of type %qT
de: Attribut %qE wird für Objekte vom Typ %qT ignoriert

en: %qE attribute ignored on types
de: Attribut %qE für Typen ignoriert

en: %qE attribute ignored without %<-mcmse%> option
de: Attribut %qE ignoriert, da die Option %<-mcmse%> nicht angegeben ist

en: %qE attribute ignored without %<-mistack%>
de: Attribut %qE ignoriert, da die Option %<-mistack%> nicht angegeben ist

en: %qE attribute ignored.  Large memory model (%<-mlarge%>) is required.
de: Attribut %qE ignoriert, da es nur für ein großes Speichermodell (%<-mlarge%>) sinnvoll ist.

en: %qE attribute ignored. Use %<-fcf-protection%> option to enable it
de: Attribut %qE ignoriert, da die Option %<-fcf-protection%> nicht angegeben ist

en: %qE attribute ignored; field must be a function pointer
de: Attribut %qE wird ignoriert, da das Feld ein Funktionszeiger sein muss

en: %qE attribute ignored; valid only for functions
de: Attribut %qE wird ignoriert, da es nur für Funktionen gilt

en: %qE attribute ignored; valid only for functions and function pointer fields
de: Attribut %qE wird ignoriert, da es nur für Funktionen und Funktionszeigerfelder gilt

en: %qE attribute is for pointer types only
de: Attribut %qE kann nur auf Zeigertypen angewendet werden

en: %qE attribute is not supported because endianness is not uniform
de: Attribut %qE wird nicht unterstützt, da die Bytereihenfolge nicht einheitlich ist

en: %qE attribute is not supported for R8C target
de: Attribut %qE wird für Ziel R8C nicht unterstützt

en: %qE attribute is not supported on this platform
de: Attribut %qE wird auf dieser Plattform nicht unterstützt

en: %qE attribute is only applicable on functions
de: Attribut %qE bezieht sich nur auf Funktionen

en: %qE attribute is only valid for Objective-C objects
de: Attribut %qE ist nur für Objective-C-Objekte gültig

en: %qE attribute is only valid on %<struct%> type
de: Attribut %qE kann nur auf %<struct%>-Typen angewandt werden

en: %qE attribute is specific to ELF targets
de: Attribut %qE wird für ELF-Ziele unterstützt

en: %qE attribute is supported only for SH2A
de: Attribut %qE wird nur auf SH2A unterstützt

en: %qE attribute is used for non-class method
de: Attribut %qE wird für Nicht-Klassen-Methode verwendet

en: %qE attribute may be put on a typedef only; attribute is ignored
de: Attribut %qE kann nur an einem typedef stehen; wird ignoriert

en: %qE attribute must appear before %qs attribute
de: Attribut %qE muss vor Attribut %qs auftreten

en: %qE attribute must apply to a declaration
de: Attribut %qE muss sich auf eine Deklaration beziehen

en: %qE attribute not allowed with auto storage class
de: Attribut %qE nicht mit Speicherklasse »auto« erlaubt

en: %qE attribute not available to functions that return value on the stack
de: Attribut %qE ist nicht auf Funktionen anwendbar, die Argumente auf dem Stack zurückgeben

en: %qE attribute not available to functions with arguments passed on the stack
de: Attribut %qE ist nicht auf Funktionen anwendbar, die Argumente auf dem Stack übergeben

en: %qE attribute not available to functions with variable number of arguments
de: Attribut %qE ist nicht auf Funktionen anwendbar, die variable Anzahl von Argumenten haben

en: %qE attribute on a function not returning a pointer
de: Attribut %qE an einer Funktion, die keinen Zeiger zurückgibt

en: %qE attribute on function returning %<void%>
de: Attribut %qE an einer Funktion mit Rückgabetyp %<void%>

en: %qE attribute on non-volatile variable
de: Attribut %qE an nicht-»volatile«-Variable

en: %qE attribute only affects top level objects
de: Attribut %qE bezieht sich nur auf Toplevel-Objekte

en: %qE attribute only applies to SH2A
de: Attribut %qE gilt nur für SH2A

en: %qE attribute only applies to base type of a function pointer
de: Attribut %qE kann nur auf Basistypen von Funktionszeiger angewandt werden

en: %qE attribute only applies to function types
de: Attribut %qE kann nur auf Funktionstypen angewandt werden

en: %qE attribute only applies to functions
de: Attribut %qE bezieht sich nur auf Funktionen

en: %qE attribute only applies to interrupt functions
de: Attribut %qE bezieht sich nur auf Interruptfunktionen

en: %qE attribute only applies to structure, union and class types
de: Attribut %qE ist nur bei Struktur-, Vereinigungs- und Klassentypen anwendbar

en: %qE attribute only applies to types
de: Attribut %qE kann nur auf Typen angewandt werden

en: %qE attribute only applies to variables
de: Attribut %qE bezieht sich nur auf Variablen

en: %qE attribute only applies to variables in static storage
de: Attribut %qE kann nur für »static«-Variablen verwendet werden

en: %qE attribute only applies to variadic functions
de: Attribut %qE gilt nur für variadische Funktionen

en: %qE attribute only available for 32-bit
de: Attribut %qE nur für 32 Bit verfügbar

en: %qE attribute only supported for reduced Tiny cores
de: Attribut %qE wird nur für reduzierte Tiny-Kerne unterstützt

en: %qE attribute only supported on boolean types
de: Attribut %qE wird nur für Boolean-Typen unterstützt

en: %qE attribute only supported on non-mask vector types
de: Attribut %qE wird nur für Vektortypen unterstützt, die nicht maskiert sind

en: %qE attribute only valid for ARC EM architecture
de: Attribut %qE ist nur für die ARC-EM-Architektur gültig

en: %qE attribute only valid for ARCv2 architecture
de: Attribut %qE ist nur für die Architektur ARCv2 gültig

en: %qE attribute requires a string argument
de: Attribut %qE erfordert eine Zeichenkettenkonstante als Argument

en: %qE attribute requires a string constant argument
de: Attribut %qE erfordert eine Zeichenkettenkonstante als Argument

en: %qE attribute requires a void return type
de: Attribut %qE erfordert den Rückgabetyp »void«

en: %qE attribute requires an integer argument
de: Attribut %qE benötigt eine Ganzzahl als Argument

en: %qE attribute requires an integer constant argument
de: Attribut %qE benötigt eine Ganzzahlkonstante als Argument

en: %qE attribute requires prototypes with named arguments
de: Attribut %qE benötigt Prototypen mit benannten Argumenten

en: %qE attribute takes no arguments
de: Attribut %qE erwartet keine Argumente

en: %qE attribute with unsupported boolean precision
de: Attribut %qE mit nicht unterstützter Boolean-Genauigkeit

en: %qE attribute without arguments on a non-prototype
de: Attribut %qE ohne Argumente für einen Nicht-Prototyp

en: %qE cannot be applied to non-pointer type %qT
de: Attribut %qE kann nur auf Zeigertypen angewendet werden, nicht auf %qT

en: %qE cannot be introduced with an ellipsis %<...%>
de: %qE kann nicht mit Auslassungspunkten %<...%> eingeleitet werden

en: %qE cannot be used as a function
de: %qE kann nicht als Funktion verwendet werden

en: %qE cannot be used as a member pointer, since it is of type %qT
de: %qE kann nicht als Elementzeiger verwendet werden, da es vom Typ %qT ist

en: %qE cannot have both %qs and %qs attributes
de: %qE kann nicht gleichzeitig die Attribute %qs und %qs haben

en: %qE declared %<threadprivate%> after first use
de: %qE nach erster Verwendung als %<threadprivate%> deklariert

en: %qE declared as function returning a function
de: %qE als Funktion, die eine Funktion zurückgibt, deklariert

en: %qE declared as function returning an array
de: %qE als Funktion, die ein Array zurückgibt, deklariert

en: %qE declared here
de: %qE ist hier deklariert

en: %qE defined as wrong kind of tag
de: %qE als falsche Symbolart definiert

en: %qE does not constrain a type
de: %qE schränkt keinen Typ ein

en: %qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type
de: %qE hat nicht den Typ %<omp_depend_t%>, in der %<depend%>-Klausel mit %<depobj%>-Abhängigkeitstyp

en: %qE does not have a mappable type in %qs clause
de: %qE in %qs-Klausel hat keinen zuordenbaren Typ

en: %qE does not have pointer or array type
de: %qE hat weder Zeiger- noch Arraytyp

en: %qE does not name a type
de: %qE bezeichnet keinen Typ

en: %qE does not name a type; did you mean %qs?
de: %qE bezeichnet keinen Typ; meinten Sie %qs?

en: %qE does not satisfy return-type-requirement
de: %qE erfüllt »return-type-requirement« nicht

en: %qE does not satisfy return-type-requirement, because
de: %qE erfüllt »return-type-requirement« nicht, da

en: %qE does not support 32-bit sign-extended offsets
de: %qE unterstützt keine 32-Bit-Offsets mit Vorzeichenerweiterung

en: %qE does not support 32-bit vector type %qT
de: %qE unterstützt den 32-Bit-Vektortyp %qT nicht

en: %qE does not support sign-extended offsets
de: %qE unterstützt keine vorzeichenerweiterten Offsets

en: %qE evaluates to false
de: %qE wird zu »false« ausgewertet

en: %qE fails to be a typedef or built in type
de: %qE ist kein typedef oder eingebauter Typ

en: %qE has both %<extern%> and initializer
de: %qE hat sowohl %<extern%> als auch Initialisierung

en: %qE has const type for %<reduction%>
de: %qE hat konstanten Typ für %<reduction%>

en: %qE has invalid type for %<reduction(%s)%>
de: %qE hat ungültigen Typ für %<reduction(%s)%>

en: %qE has no form that takes %qT arguments
de: %qE hat keine Form, die %qT Argumente annimmt

en: %qE has not been declared
de: %qE wurde nicht deklariert

en: %qE implies default visibility, but %qD has already been declared with a different visibility
de: %qE bringt Standardsichtbarkeit mit sich, aber %qD wurde bereits mit anderer Sichtbarkeit deklariert

en: %qE in %<aligned%> clause is neither a pointer nor an array
de: %qE in %<aligned%>-Klausel ist weder Zeiger noch Array

en: %qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array
de: %qE in %<aligned%>-Klausel ist weder Zeiger noch Array noch Referenz auf Zeiger oder Array

en: %qE in %<reduction%> clause is a zero size array
de: %qE in %<reduction%>-Klausel ist ein Array der Länge 0

en: %qE in %q#T does not name a template type
de: %qE in %q#T benennt keinen Templatetypen

en: %qE in %q#T does not name a type
de: %qE in %q#T benennt keinen Typen

en: %qE in namespace %qE does not name a template type
de: %qE in Namensraum %qE bezeichnet keinen Templatetyp

en: %qE in namespace %qE does not name a template type; did you mean %qs?
de: %qE in Namensraum %qE bezeichnet keinen Templatetyp; meinten Sie %qs?

en: %qE in namespace %qE does not name a type
de: %qE in Namensbereich %qE bezeichnet keinen Typ

en: %qE in namespace %qE does not name a type; did you mean %qs?
de: %qE in Namensraum %qE bezeichnet keinen Typ; meinten Sie %qs?

en: %qE incompatible attribute ignored
de: %qE-inkompatibles Attribut wird ignoriert

en: %qE initialized and declared %<extern%>
de: %qE initialisiert und als %<extern%> deklariert

en: %qE is a member of a union
de: %qE ist ein Element eines Union-Typs

en: %qE is a pointer; did you mean to use %<->%>?
de: %qE ist ein Zeiger; meinten Sie %<->%>?

en: %qE is an unrecognized format function type
de: %qE ist ein nicht erkannter Formatfunktionstyp

en: %qE is deprecated
de: %qE ist veraltet

en: %qE is deprecated: %s
de: %qE ist veraltet: %s

en: %qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT
de: %qE ist mit %<throw()%> oder %<noexcept%> markiert, aber %qT liefert kein brauchbares %<get_return_object_on_allocation_failure%>

en: %qE is neither a variable nor a function name in clause %qs
de: %qE in %qs-Klausel ist weder Variablen- noch Funktionsname

en: %qE is neither function nor member function; cannot be declared friend
de: %qE ist weder eine Funktion noch Elementfunktion; kann nicht als »friend« deklariert werden

en: %qE is not %<noexcept%>
de: %qE ist nicht %<noexcept%>

en: %qE is not a class or namespace
de: %qE ist keine Klasse oder Namensbereich

en: %qE is not a class template
de: %qE ist kein Klassentemplate

en: %qE is not a class, namespace, or enumeration
de: %qE ist keine Klasse, Namensbereich oder Aufzählung

en: %qE is not a constant expression
de: %qE ist kein Konstantenausdruck

en: %qE is not a constant expression because allocated storage has not been deallocated
de: %qE ist kein konstanter Ausdruck, da der angeforderte Speicher nicht vollständig freigegeben wurde

en: %qE is not a constant expression because it refers to a result of %<operator new%>
de: %qE ist kein konstanter Ausdruck, da er auf das Ergebnis von %<operator new%> verweist

en: %qE is not a constant expression because it refers to an incompletely initialized variable
de: %qE ist kein Konstantenausdruck, da er auf eine unvollständig initialisierte Variable verweist

en: %qE is not a constant expression because it refers to mutable subobjects of %qT
de: %qE ist kein Konstantenausdruck, da er auf veränderliche Teilobjekte von %qT verweist

en: %qE is not a template
de: %qE ist kein Template

en: %qE is not a type
de: %qE ist kein Typ

en: %qE is not a valid %<asm%> qualifier
de: %qE ist kein gültiger %<asm%>-Qualifizierer

en: %qE is not a valid template argument for %qT because it is not the address of a variable
de: %qE ist kein gültiges Templateargument für %qT, da es keine Adresse einer Variable ist

en: %qE is not a valid template argument for type %qT
de: %qE ist kein gültiges Templateargument für Typ %qT

en: %qE is not a valid template argument for type %qT because %qD does not have external linkage
de: %qE ist kein gültiges Templateargument für Typ %qT, weil %qD keine externe Bindung hat

en: %qE is not a valid template argument for type %qT because %qD has no linkage
de: %qE ist kein gültiges Templateargument für Typ %qT, weil %qD keine Bindung hat

en: %qE is not a valid template argument for type %qT because it is a pointer
de: %qE ist kein gültiges Templateargument für Typ %qT, weil es ein Zeiger ist

en: %qE is not a valid template argument for type %qT because it is not an lvalue
de: %qE ist kein gültiges Templateargument für Typ %qT, weil es kein L-Wert ist

en: %qE is not a valid template argument for type %qT because it is of type %qT
de: %qE ist kein gültiges Templateargument für Typ %qT, weil es vom Typ %qT ist

en: %qE is not a valid template argument for type %qT because of conflicts in cv-qualification
de: %qE ist kein gültiges Templateargument für Typ %qT, da es in CV-Qualifikation in Konflikt steht

en: %qE is not a valid template argument for type %qT because string literals can never be used in this context
de: %qE ist kein gültiges Templateargument für Typ %qT, da Zeichenkettensymbole in diesem Zusammenhang nicht verwendet werden können

en: %qE is not a valid template argument of type %qT because %qD has no linkage
de: %qE ist kein gültiges Templateargument für Typ %qT, weil %qD keine Bindung hat

en: %qE is not a valid template argument of type %qT because %qE is not a variable
de: %qE ist kein gültiges Templateargument für Typ %qT, weil %qE keine Variable ist

en: %qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage
de: %qE ist in C++98 kein gültiges Templateargument des Typs %qT, weil %qD keine externe Bindung hat

en: %qE is not a variable in %<aligned%> clause
de: %qE ist %<aligned%>-Klausel keine Variable

en: %qE is not a variable in %<allocate%> clause
de: %qE in %<allocate%>-Klausel ist keine Variable

en: %qE is not a variable in %<nontemporal%> clause
de: %qE ist in %<nontemporal%>-Klausel keine Variable

en: %qE is not a variable in %qs clause
de: %qE in %qs-Klausel muss eine Variable sein

en: %qE is not a variable in clause %<firstprivate%>
de: %qE ist in Klausel %<firstprivate%> keine Variable

en: %qE is not a variable in clause %<lastprivate%>
de: %qE ist in Klausel %<lastprivate%> keine Variable

en: %qE is not a variable in clause %qs
de: %qE ist in Klausel %qs keine Variable

en: %qE is not an Objective-C class name or alias
de: %qE ist kein Klassenname oder Alias in Objective-C

en: %qE is not an argument in %<uniform%> clause
de: %qE in %<uniform%>-Klausel ist kein Argument

en: %qE is not at beginning of declaration
de: %qE ist nicht am Anfang einer Deklaration

en: %qE is not initialized
de: %qE ist nicht initialisiert

en: %qE is not lvalue expression nor array section in %qs clause
de: %qE ist weder ein lvalue-Ausdruck noch ein Arrayabschnitt in %qs-Klausel

en: %qE is not of type %qT
de: %qE ist nicht vom Typ %qT

en: %qE is not recognized as a module control-line
de: unbekannte Modul-Steuerzeile %qE

en: %qE is not the entire pattern of the pack expansion
de: %qE ist nicht das vollständige Muster einer Packexpansion

en: %qE is only allowed in Objective-C dialects
de: %qE ist nur in Objective-C-Dialekten erlaubt

en: %qE is only applicable to Objective-C class interfaces, attribute ignored
de: %qE ist nur auf Objective-C-Klassen-Interfaces anwendbar; wird ignoriert

en: %qE is predetermined %qs for %qs
de: %qE ist vorbestimmt %qs für %qs

en: %qE is provided by %qT but %<std::nothrow%> cannot be found
de: %qE wird von %qT bereitgestellt, aber %<std::nothrow%> wurde nicht gefunden

en: %qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>
de: %qE wird von %qT bereitgestellt, aber %qE ist nicht mit %<throw()%> oder %<noexcept%> gekennzeichnet

en: %qE is provided by %qT but is not usable with the function signature %qD
de: %qE wird von %qT bereitgestellt, ist aber nicht mit der Funktionssignatur %qD verwendbar

en: %qE is unavailable
de: %qE ist nicht verfügbar

en: %qE is unavailable: %s
de: %qE ist nicht verfügbar: %s

en: %qE is used uninitialized
de: %qE ist nicht initialisiert

en: %qE may be used uninitialized
de: %qE könnte uninitialisiert verwendet werden

en: %qE may not respond to %<%c%E%>
de: %qE antwortet möglicherweise nicht auf %<%c%E%>

en: %qE may only occur after a module interface declaration
de: %qE darf erst nach einer Modul-Interface-Deklaration vorkommen

en: %qE may only occur once in an export declaration
de: %qE darf nur einmal pro Export-Deklaration vorkommen

en: %qE may write a terminating nul past the end of the destination
de: %qE könnte ein abschließendes NUL hinter das Ende des Ziels schreiben

en: %qE missing template arguments
de: fehlende Templateargumente für %qE

en: %qE must be %<threadprivate%> for %<copyin%>
de: %qE muss für %<copyin%> %<threadprivate%> sein

en: %qE needs isa option %s
de: %qE erfordert ISA-Option %s

en: %qE needs unknown isa option
de: %qE erfordert unbekannte ISA-Option

en: %qE not specified in enclosing %<target%>
de: %qE in umgebendem %<target%> nicht angegeben

en: %qE not specified in enclosing %qs
de: %qE in umgebendem %qs nicht angegeben

en: %qE not specified in enclosing OpenACC %qs construct
de: %qE in umgebendem OpenACC-%qs-Konstrukt nicht angegeben

en: %qE output %wu byte | %qE output %wu bytes
de[0]: %qE hat %wu Byte ausgegeben
de[1]: %qE hat %wu Bytes ausgegeben

en: %qE output %wu byte into a destination of size %wu | %qE output %wu bytes into a destination of size %wu
de[0]: %qE hat %wu Byte in ein Ziel der Größe %wu ausgegeben
de[1]: %qE hat %wu Byte in ein Ziel der Größe %wu ausgegeben

en: %qE output %wu or more bytes
de: %qE hat %wu oder mehr Bytes ausgegeben

en: %qE output %wu or more bytes (assuming %wu)
de: %qE hat %wu oder mehr Bytes (angenommen %wu) ausgegeben

en: %qE output %wu or more bytes (assuming %wu) into a destination of size %wu
de: %qE hat %wu oder mehr Bytes (angenommen %wu) in das Ziel der Größe %wu ausgegeben

en: %qE output %wu or more bytes into a destination of size %wu
de: %qE hat %wu oder mehr Bytes in das Ziel der Größe %wu ausgegeben

en: %qE output between %wu and %wu bytes
de: %qE hat zwischen %wu und %wu Bytes ausgegeben

en: %qE output between %wu and %wu bytes into a destination of size %wu
de: %qE hat zwischen %wu und %wu Bytes in das Ziel der Größe %wu ausgegeben

en: %qE output may be truncated before the last format character
de: %qE-Ausgabe könnte vor dem letzten Formatzeichen abgeschnitten sein

en: %qE output truncated before the last format character
de: %qE-Ausgabe ist vor dem letzten Formatzeichen abgeschnitten

en: %qE redeclared as different kind of symbol
de: %qE als andere Symbolart redeklariert

en: %qE redeclared with conflicting %qs attributes
de: %qE mit in Konflikt stehenden Attributen %qs redeklariert

en: %qE requires %<-fgnu-tm%>
de: %qE benötigt %<-fgnu-tm%>

en: %qE requires a %<declare%> directive for use in a %<routine%> function
de: %qE erfordert eine %<declare%>-Direktive, um in einer %<routine%>-Funktion verwendet zu werden

en: %qE requires a vector base and a scalar index
de: %qE erfordert eine Vektorbasis und einen skalaren Index

en: %qE requires an argument
de: Attribut %qE benötigt ein Argument

en: %qE requires the SVE ISA extension
de: %qE benötigt die SVE-ISA-Erweiterung

en: %qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>
de: %qE sollte einen anderen Typ haben als %<omp_depend_t%>, in der %<depend%>-Klausel mit von %<depobj%> verschiedenem Abhängigkeitstyp

en: %qE specified here
de: %qE ist hier angegeben

en: %qE undeclared (first use in this function)
de: %qE nicht deklariert (erste Verwendung in dieser Funktion)

en: %qE undeclared (first use in this function); did you mean %qs?
de: %qE nicht deklariert (erstmalige Verwendung in dieser Funktion); meinten Sie %qs?

en: %qE undeclared here (not in a function)
de: %qE ist hier nicht deklariert (nicht in einer Funktion)

en: %qE undeclared here (not in a function); did you mean %qs?
de: %qE ist hier (außerhalb einer Funktion) nicht deklariert; meinten Sie %qs?

en: %qE used with %<auto%>
de: %qE mit %<auto%> verwendet

en: %qE used with %<register%>
de: %qE mit %<register%> verwendet

en: %qE used with %<typedef%>
de: %qE mit %<typedef%> verwendet

en: %qE with %<link%> clause used in %<routine%> function
de: %qE mit %<link%>-Klausel wird in %<routine%>-Funktion verwendet

en: %qE writing a terminating nul past the end of the destination
de: %qE schreibt ein abschließendes NUL hinter das Ende des Ziels

en: %qF declared %<static%> but never defined
de: %qF als %<static%> deklariert, aber nirgendwo definiert

en: %qF requires %<-mvx%>
de: %qF erfordert %<-mvx%>

en: %qF requires z14 or higher
de: %qF erfordert z14 oder höher

en: %qF requires z15 or higher
de: %qF erfordert z15 oder höher

en: %qT and %qT are in disjoint named address spaces
de: %qT und %qT sind in disjunkt benannten Adressräumen

en: %qT as type rather than plain %<decltype(auto)%>
de: %qT als Typ statt als einfaches %<decltype(auto)%>

en: %qT declared here
de: %qT hier deklariert

en: %qT declared with a mismatched class-key %qs
de: %qT mit nicht zusammenpassendem Klassenschlüssel %qs deklariert

en: %qT declared with greater visibility than its base %qT
de: %qT mit bedeutenderer Sichtbarkeit als seine Basis %qT deklariert

en: %qT declared with greater visibility than the type of its field %qD
de: %qT mit bedeutenderer Sichtbarkeit als der Typ seines Feldes %qD deklariert

en: %qT defined as %qs here
de: %qT wurde hier als %qs definiert

en: %qT defined with direct virtual base
de: %qT ist mit direkter virtueller Basisklasse definiert

en: %qT defined with multiple direct bases
de: %qT ist mit mehreren direkten Basisklassen definiert

en: %qT does not have the %E ABI tag that %qT (used in the type of %qD) has
de: %qT hat nicht das ABI-Tag %E, das %qT (im Typ von %qD verwendet) hat

en: %qT does not have the %E ABI tag that base %qT has
de: %qT hat nicht das ABI-Tag %E, das die Basis %qT hat

en: %qT does not match original declaration
de: %qT stimmt nicht mit der ursprünglichen Deklaration überein

en: %qT first declared as %qs here
de: %qT wurde erstmals hier als %qs deklariert

en: %qT has a base %qT whose type depends on the type %qT which has no linkage
de: %qT hat Basis %qT, dessen Typ von Typ %qT abhängt, der wiederum keine Bindung hat

en: %qT has a base %qT whose type has no linkage
de: %qT hat Basis %qT, dessen Typ keine Bindung hat

en: %qT has a base %qT whose type uses the anonymous namespace
de: %qT hat Basis %qT, dessen Typ den anonymen Namensbereich verwendet

en: %qT has a field %qD whose type depends on the type %qT which has no linkage
de: %qT hat ein Feld %qD, dessen Typ vom Typ %qT abhängt, der wiederum keine Bindung hat

en: %qT has a field %qD whose type has no linkage
de: %qT hat ein Feld %qD, dessen Typ keine Bindung hat

en: %qT has a field %qD whose type uses the anonymous namespace
de: %qT hat ein Feld %qD, dessen Typ den anonymen Namensbereich verwendet

en: %qT has a previous declaration here
de: %qT hat hier eine vorherige Deklaration

en: %qT has no member named %qE
de: %qT hat kein Element namens %qE

en: %qT has no member named %qE; did you mean %qE?
de: %qT hat kein Element namens %qE; meinten Sie %qE?

en: %qT has no non-static data member named %qD
de: %qT hat kein nicht-statisches Datenelement namens %qD

en: %qT is a variably modified type
de: %qT ist ein variabel modifizierter Typ

en: %qT is already a friend of %qT
de: %qT ist bereits ein »friend« von %qT

en: %qT is an ambiguous base class of dynamic type %qT of its operand
de: %qT ist eine mehrdeutige Basisklasse des dynamischen Typen %qT seines Operanden

en: %qT is an ambiguous base of %qT
de: %qT ist mehrdeutige Basis von %qT

en: %qT is an inaccessible base of %qT
de: %qT ist eine nicht erreichbare Basis von %qT

en: %qT is not a base of %qT
de: %qT ist keine Basis von %qT

en: %qT is not a class or namespace
de: %qT ist keine Klasse oder Namensbereich

en: %qT is not a class type
de: %qT ist kein Klassentyp

en: %qT is not a class, namespace, or enumeration
de: %qT ist weder eine Klasse, noch ein Namensbereich oder eine Aufzählung

en: %qT is not a class, struct, or union type
de: %qT ist kein Klassen-, Struktur- oder Union-Typ

en: %qT is not a direct base of %qT
de: %qT ist keine direkte Basis von %qT

en: %qT is not a member class template of %qT
de: %qT ist kein Elementklassentemplate von %qT

en: %qT is not a member of %qT
de: %qT ist kein Element von %qT

en: %qT is not a nested class of %qT
de: %qT ist keine geschachtelte Klasse von %qT

en: %qT is not a pointer-to-object type
de: %qT ist kein Zeiger auf Objekt

en: %qT is not a template
de: %qT ist kein Template

en: %qT is not a template type
de: %qT ist kein Template-Typ

en: %qT is not a valid type for a template non-type parameter because it is not structural
de: %qT ist kein gültiger Typ für einen Nichttyp-Templateparameter, da er nicht strukturell ist

en: %qT is not an %<asm%> qualifier
de: %qT ist kein %<asm%>-Qualifizierer

en: %qT is not an accessible base of %qT
de: %qT ist keine erreichbare Basis von %qT

en: %qT is not an enumeration type
de: %qT ist kein Aufzählungstyp

en: %qT is promoted to %qT when passed through %<...%>
de: %qT auf %qT erweitert beim Durchlaufen von %<...%>

en: %qT is/uses unnamed type
de: %qT ist/verwendet anonymen Typen

en: %qT may not intend to support class template argument deduction
de: %qT beabsichtigt möglicherweise nicht, Argumentherleitung für Klassentemplates zu unterstützen

en: %qT not permitted in template argument
de: %qT ist in einem Templateargument nicht erlaubt

en: %qT referred to as %qs
de: %qT als %qs verwendet

en: %qT referred to as enum
de: %qT als enum verwendet

en: %qT resolves to %qT, which is not a class type
de: %qT wird in %qT aufgelöst, aber das ist kein Klassentyp

en: %qT resolves to %qT, which is not an enumeration type
de: %qT wird in %qT aufgelöst, was kein Aufzählungstyp ist

en: %qT%d%qE%d | passing single vector %qT to argument %d of %qE, which expects a tuple of %d vectors
de[0]: %qT%d%qE%d
de[1]: der einzelne Vektor %qT wird an Argument %d von %qE übergeben, das erwartet jedoch ein Tupel von %d Vektoren

en: %qV qualifiers cannot be applied to %qT
de: %qV-Qualifizierer können nicht auf %qT angewendet werden

en: %qc conversion used unquoted
de: %qc-Umwandlung wird unescapet verwendet

en: %qc conversion used within a quoted sequence
de: Umwandlung %qc wird innerhalb einer q-Folge benutzt

en: %qc directive redundant after prior occurence of the same
de: Die Direktive %qc ist redundant, da sie bereits vorgekommen ist

en: %qs LHS in assignment statement
de: %qs auf der linken Seite einer Zuweisung

en: %qs LHS in clobber statement
de: %s auf der linken Seite einer Clobber-Anweisung

en: %qs RHS in assignment statement
de: %qs auf der rechten Seite Zuweisung

en: %qs accessing uninitialized byte at offset %d
de: %qs greift auf das uninitialisierte Byte an Offset %d zu

en: %qs already defined as specific binding for the generic %qs at %C
de: %qs bereits als spezifische Bindung für das generische %qs bei %C definiert

en: %qs and %<%s-%s%> are incompatible
de: %qs und %<%s-%s%> sind unverträglich

en: %qs and %<%s=%s%> are incompatible
de: %qs und %<%s=%s%> sind unverträglich

en: %qs and %qs are incompatible
de: %qs und %qs sind unverträglich

en: %qs and %qs arguments of %qs intrinsic at %L must have identical shape.
de: Argumente %qs und %qs des intrinsischen %qs bei %L müssen gleiche Form haben.

en: %qs and %qs arguments of %qs intrinsic at %L must have the same type
de: Argumente %qs und %qs des intrinsischen %qs bei %L müssen denselben Typ haben

en: %qs and %qs attributes are not compatible
de: Attribute %qs und %qs sind nicht verträglich

en: %qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L
de: %qs und %qs können nicht gemischte FUNCTION/SUBROUTINE für GENERIC %qs bei %L sein

en: %qs and %qs for GENERIC %qs at %L are ambiguous
de: %qs und %qs für GENERIC %qs bei %L sind mehrdeutig

en: %qs appears more than once in %<allocate%> clauses at %L
de: %qs kommt mehr als einmal in %<allocate%>-Klauseln bei %L vor

en: %qs appears to be a misspelled %qs handler, missing %<__vector%> prefix
de: %qs scheint ein falsch geschriebener %qs-Handler zu sein, das Präfix %<__vector%> fehlt

en: %qs applied to non-SVE type %qT
de: %qs angewendet auf Nicht-SVE-Typ %qT

en: %qs applied to non-vector type %qT
de: %qs angewendet auf den Nicht-Vektor-Typ %qT

en: %qs applied to type %qT, which already has a size
de: %qs angewendet auf den Typ %qT, der bereits eine Größe hat

en: %qs argument has invalid operand number (argument %lu)
de: Argument %qs hat ungültige Operandennummer (Argument %lu)

en: %qs argument missing terminating nul
de: Argument für %qs hat kein abschließendes nul-Zeichen

en: %qs argument of %qs intrinsic at %L cannot be INTENT(IN)
de: Argument %qs des intrinsischen %qs bei %L kann nicht INTENT(IN) sein

en: %qs argument of %qs intrinsic at %L cannot be of type %s
de: Argument %qs des intrinsischen %qs bei %L kann nicht Typ %s haben

en: %qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)
de: Argument %qs des intrinsischen %qs bei %L hat ungültige Permutation der Dimensionen (Dimension %qd doppelt)

en: %qs argument of %qs intrinsic at %L has invalid shape in dimension %d (%ld/%ld)
de: Argument %qs des intrinsischen %qs bei %L hat ungültige Form in Dimension %d (%ld/%ld)

en: %qs argument of %qs intrinsic at %L has negative element (%d)
de: Argument %qs des intrinsischen %qs bei %L hat negatives Element (%d)

en: %qs argument of %qs intrinsic at %L has out-of-range dimension (%d)
de: Argument %qs des intrinsischen %qs bei %L hat Dimension außerhalb des Wertebereiches (%d)

en: %qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)
de: Argument %qs des intrinsischen %qs bei %L hat falsche Anzahl der Elemente (%d/%d)

en: %qs argument of %qs intrinsic at %L is empty
de: Argument %qs des intrinsischen %qs bei %L ist leer

en: %qs argument of %qs intrinsic at %L is not a valid dimension index
de: Argument %qs des intrinsischen %qs bei %L ist kein gültiger Dimensionsindex

en: %qs argument of %qs intrinsic at %L must be %s
de: Argument %qs des intrinsischen %qs bei %L muss %s sein

en: %qs argument of %qs intrinsic at %L must be ALLOCATABLE
de: Argument %qs des intrinsischen %qs bei %L muss ALLOCATABLE sein

en: %qs argument of %qs intrinsic at %L must be INTEGER
de: Argument %qs des intrinsischen %qs bei %L muss ein INTEGER sein

en: %qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE
de: Argument %qs für intrinsisches %qs bei %L muss INTEGER oder PROCEDURE sein

en: %qs argument of %qs intrinsic at %L must be INTEGER or REAL
de: Argument %qs des intrinsischen %qs bei %L muss INTEGER oder REAL sein

en: %qs argument of %qs intrinsic at %L must be INTEGER or REAL or CHARACTER
de: Argument %qs des intrinsischen %qs bei %L muss INTEGER, REAL oder CHARACTER sein

en: %qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant
de: Argument %qs der intrinsischen Funktion %qs bei %L muss INTEGER, LOGICAL oder ein BOZ-Literal sein

en: %qs argument of %qs intrinsic at %L must be REAL or COMPLEX
de: Argument %qs des intrinsischen %qs bei %L muss REAL oder COMPLEX sein

en: %qs argument of %qs intrinsic at %L must be a POINTER
de: Argument %qs des intrinsischen %qs bei %L muss ein POINTER sein

en: %qs argument of %qs intrinsic at %L must be a POINTER or a TARGET
de: Argument %qs des intrinsischen %qs bei %L muss ein POINTER oder ein TARGET sein

en: %qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer
de: Argument %qs des intrinsischen %qs bei %L muss POINTER, ALLOCATABLE oder Prozedurzeiger sein

en: %qs argument of %qs intrinsic at %L must be a constant
de: Argument %qs des intrinsischen %qs bei %L muss eine Konstante sein

en: %qs argument of %qs intrinsic at %L must be a data entity
de: Argument %qs des intrinsischen %qs bei %L muss eine Datenentität sein

en: %qs argument of %qs intrinsic at %L must be a logical array
de: Argument %qs des intrinsischen %qs bei %L muss ein logisches Feld sein

en: %qs argument of %qs intrinsic at %L must be a pointer or target VARIABLE or FUNCTION
de: Argument %qs des intrinsischen %qs bei %L muss ein Zeiger oder Ziel VARIABLE oder FUNCTION sein

en: %qs argument of %qs intrinsic at %L must be a scalar
de: Argument %qs des intrinsischen %qs bei %L muss ein Skalar sein

en: %qs argument of %qs intrinsic at %L must be a variable
de: Argument %qs des intrinsischen %qs bei %L muss eine Variable sein

en: %qs argument of %qs intrinsic at %L must be an array
de: Argument %qs des intrinsischen %qs bei %L muss ein Feld sein

en: %qs argument of %qs intrinsic at %L must be an interoperable data entity: %s
de: Argument %qs des intrinsischen %qs bei %L muss austauschbare Datenentität sein: %s

en: %qs argument of %qs intrinsic at %L must be default real
de: Argument %qs des intrinsischen %qs bei %L muss ein Standard-Real sein

en: %qs argument of %qs intrinsic at %L must be double precision
de: Argument %qs des intrinsischen %qs bei %L muss doppelte Genauigkeit haben

en: %qs argument of %qs intrinsic at %L must be less than rank %d
de: Argument %qs für intrinsisches %qs bei %L muss geringer als Rang %d sein

en: %qs argument of %qs intrinsic at %L must be numeric or LOGICAL
de: Argument %qs des intrinsischen %qs bei %L muss numerisch oder LOGICAL sein

en: %qs argument of %qs intrinsic at %L must be of a dummy variable
de: Argument %qs des intrinsischen %qs bei %L muss eine Scheinvariable sein

en: %qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)
de: Argument %qs des intrinsischen %qs bei %L darf von der Art nicht breiter als der Standard (%d) sein

en: %qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable
de: Argument %qs des intrinsischen %qs bei %L muss eine OPTIONALe Scheinvariable sein

en: %qs argument of %qs intrinsic at %L must be of an extensible type
de: Argument %qs des intrinsischen %qs bei %L muss erweiterbaren Typ haben

en: %qs argument of %qs intrinsic at %L must be of intrinsic type
de: Argument %qs des intrinsischen %qs bei %L muss ein intrinsischer Typ sein

en: %qs argument of %qs intrinsic at %L must be of kind %d
de: Argument %qs des intrinsischen %qs bei %L muss von der Art %d sein

en: %qs argument of %qs intrinsic at %L must be of rank %d
de: Argument %qs des intrinsischen %qs bei %L muss vom Rang %d sein

en: %qs argument of %qs intrinsic at %L must be of rank 1 or 2
de: Argument %qs des intrinsischen %qs bei %L muss vom Rang 1 oder 2 sein

en: %qs argument of %qs intrinsic at %L must be positive
de: Argument %qs des intrinsischen %qs bei %L muss positiv sein

en: %qs argument of %qs intrinsic at %L must be the same kind as %qs
de: Argument %qs des intrinsischen %qs bei %L muss von der selben Art wie %qs sein

en: %qs argument of %qs intrinsic at %L must be the same type and kind as %qs
de: Argument %qs des intrinsischen %qs bei %L muss vom gleichen Typ und gleicher Art wie %qs sein

en: %qs argument of %qs intrinsic at %L must have a numeric type
de: Argument %qs des intrinsischen %qs bei %L muss ein numerischer Typ sein

en: %qs argument of %qs intrinsic at %L must have a type of either REAL or INTEGER
de: %qs-Argument des intrinsischen %qs bei %L muss vom Typ REAL oder INTEGER sein

en: %qs argument of %qs intrinsic at %L must have length at least 1
de: Argument %qs des intrinsischen %qs bei %L muss mindestens die Länge 1 haben

en: %qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar
de: Argument %qs des intrinsischen %qs bei %L muss den selben Rang wie %qs haben oder skalar sein

en: %qs argument of %qs intrinsic at %L must not be OPTIONAL
de: Argument %qs des intrinsischen %qs bei %L darf nicht OPTIONAL sein

en: %qs argument of %qs intrinsic at %L must not be a subobject of %qs
de: Argument %qs des intrinsischen %qs bei %L darf kein Unterobjekt von %qs sein

en: %qs argument of %qs intrinsic at %L must not be present if %<x%> is COMPLEX
de: Argument %qs des intrinsischen %qs bei %L darf nicht vorhanden sein, wenn %<x%> COMPLEX ist

en: %qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)
de: Argument %qs des intrinsischen %qs bei %L muss mindestens so viele Elemente haben wie es .TRUE.-Werte %qs (%ld/%d) gibt

en: %qs argument of %qs intrinsic at %L not yet supported
de: Argument %qs des intrinsischen %qs bei %L ist noch nicht unterstützt

en: %qs argument of %qs intrinsic at %L shall be of type integer, real or character
de: Argument %qs des intrinsischen %qs bei %L muss vom Typ integer, read oder character sein

en: %qs argument of %qs intrinsic at %L shall have the same type as %qs at %L
de: Argument %qs des intrinsischen %qs bei %L muss vom gleichen Typ und gleicher Art wie %qs bei %L sein

en: %qs argument of %qs intrinsic at %L shall not be TYPE(*)
de: Argument %qs des intrinsischen %qs bei %L darf nicht TYPE(*) sein

en: %qs argument of %qs intrinsic at %L shall not be a procedure
de: Argument %qs des intrinsischen %qs bei %L darf keine Prozedur sein

en: %qs argument of %qs intrinsic at %L shall not be an assumed-size array
de: Argument %qs des intrinsischen %qs bei %L darf kein Feld impliziter Größe sein

en: %qs argument of %qs intrinsic at %L shall not be coindexed
de: Argument %qs des intrinsischen %qs bei %L darf keinen Koindex haben

en: %qs argument of %qs intrinsic at %L shall specify a valid integer kind
de: Argument %qs des intrinsischen %qs bei %L muss eine gültige Ganzzahlart sein

en: %qs argument of intrinsic %qs at %L of must have rank %d or be a scalar
de: Argument %qs des intrinsischen %qs bei %L muss Rang %d haben oder ein Skalar sein

en: %qs argument references non-pointer operand (argument %lu, operand %lu)
de: Argument %qs referenziert Nicht-Zeiger-Operanden (Argument %lu, Operand %lu)

en: %qs argument with out-of-range operand number (argument %lu, operand %lu)
de: Argument %qs mit Operandennummer außerhalb des Wertebereiches (Argument %lu, Operand %lu)

en: %qs at %C is a DEC extension, enable with %<-fdec-structure%>
de: %qs bei %C ist eine DEC-Erweiterung, muss mit %<-fdec-structure%> eingeschaltet werden

en: %qs at %C is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs
de: %qs bei %C ist eine Redefinition der Deklaration in der entsprechenden Schnittstelle für MODUL PROCEDURE %qs

en: %qs at %C is already defined as FINAL procedure
de: %qs bei %C ist bereits als FINAL-Prozedur definiert

en: %qs at %C is not a member of the %qs structure
de: %qs bei %C ist kein Element der Struktur %qs

en: %qs at %C is not a member of the %qs structure; did you mean %qs?
de: %qs bei %C ist kein Element der Struktur %qs; meinen Sie %qs?

en: %qs at %C is not a variable
de: %qs bei %C ist keine Variable

en: %qs at %C is not an inquiry reference to an intrinsic type component
de: %qs bei %C ist keine Ermittlungsreferenz auf eine intrinsische Typkomponente

en: %qs at %C is not an inquiry reference to an intrinsic type component %qs
de: %qs bei %C ist keine Ermittlungsreferenz auf eine intrinsische Typkomponente %qs

en: %qs at %C is the name of a recursive function and so refers to the result variable. Use an explicit RESULT variable for direct recursion (12.5.2.1)
de: %qs bei %C ist der Name einer rekursiven Funktion und verweist damit auf die Ergebnisvariable. Für direkte Rekursion, eine explizite RESULT-Variable verwenden (12.5.2.1)

en: %qs at %L already is initialized at %L
de: %qs bei %L wurde bereits bei %L initialisiert

en: %qs at %L associated to expression cannot be used in a variable definition context (%s)
de: %qs ist bei %L mit Ausdruck verbunden und kann nicht in Variablen-Definitionskontext (%s) verwendet werden

en: %qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)
de: %qs ist bei %L mit vektorindiziertem Ziel verbunden und kann nicht in Variablen-Definitionskontext (%s) verwendet werden

en: %qs at %L cannot appear in COMMON [F2008:C5100]
de: %qs bei %L kann nicht in COMMON auftreten [F2008:C5100]

en: %qs at %L cannot have the VALUE attribute because it is not a dummy argument
de: %qs bei %L kann nicht das VALUE-Attribut haben, da es kein Scheinargument ist

en: %qs at %L has a type, which is not consistent with the CALL at %L
de: %qs bei %L hat einen Typen, der nicht zum CALL bei %L passt

en: %qs at %L has attributes specified outside its INTERFACE body
de: %qs bei %L hat außerhalb seines INTERFACE-Körpers spezifizierte Attribute

en: %qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array
de: %qs bei %L hat Attribut CONTIGUOUS, aber ist kein Feldzeiger oder Feld vermuteter Größe oder Rang

en: %qs at %L is ambiguous
de: %qs bei %L ist mehrdeutig

en: %qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)
de: %qs bei %L ist ein Feld und OPTIONAL; wenn es fehlt, kann es nicht das effektive Argument einer ELEMENTAL-Prozedur sein, es sei denn, es gibt ein nicht-optionales Argument mit demselben Rang (Fortran 2018, 15.5.2.12)

en: %qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name
de: %qs bei %L ist Host-verbunden bei %L in eine enthaltene Prozedur mit einer gleichnamigen internen Prozedur

en: %qs at %L is not a VALUE
de: %qs bei %L ist kein VALUE

en: %qs at %L is not a function
de: %qs bei %L ist keine Funktion

en: %qs at %L is not a module procedure
de: %qs bei %L ist keine Modulprozedur

en: %qs at %L is of the ABSTRACT type %qs
de: %qs bei %L ist vom ABSTRACT-Typ %qs

en: %qs at %L must be less than BIT_SIZE(%qs)
de: %qs bei %L muss kleiner als BIT_SIZE(%qs) sein

en: %qs at %L must be less than or equal to BIT_SIZE(%qs)
de: %qs bei %L muss kleiner oder gleich BIT_SIZE(%qs) sein

en: %qs at %L must be less than or equal to the BIT_SIZE of INTEGER(KIND=%d)
de: %qs bei %L muss kleiner oder gleich der BIT_SIZE von INTEGER(KIND=%d) sein

en: %qs at %L must be nonnegative
de: %qs bei %L darf nicht negativ sein

en: %qs at %L must have constant character length in this context
de: %qs bei %L muss in diesem Zusammenhang konstante Zeichenlänge haben

en: %qs at %L must have the same number of formal arguments as the overridden procedure
de: %qs bei %L muss die gleiche Anzahl formaler Argumente wie die überschriebene Prozedur haben

en: %qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding
de: %qs bei %L darf nicht DEFERRED sein, da es eine Nicht-DEFERRED-Bindung überschreibt

en: %qs at %L overrides a FUNCTION and must also be a FUNCTION
de: %qs bei %L überschreibt eine FUNCTION und muss auch eine FUNCTION sein

en: %qs at %L overrides a NOPASS binding and must also be NOPASS
de: %qs bei %L überschreibt eine NOPASS-Bindung und muss ebenfalls NOPASS sein

en: %qs at %L overrides a PUBLIC procedure and must not be PRIVATE
de: %qs bei %L überschreibt eine PUBLIC-Prozedur und darf nicht PRIVATE sein

en: %qs at %L overrides a PURE procedure and must also be PURE
de: %qs bei %L überschreibt eine PURE-Prozedur und muss auch PURE sein

en: %qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE
de: %qs bei %L überschreibt eine SUBROUTINE und muss auch eine SUBROUTINE sein

en: %qs at %L overrides a binding with PASS and must also be PASS
de: %qs bei %L überschreibt eine Bindung mit PASS und muss ebenfalls PASS sein

en: %qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either
de: %qs bei %L überschreibt eine Nicht-ELEMENTAL-Prozedur und darf ebenfalls nicht ELEMENTAL sein

en: %qs at %L overrides a procedure binding declared NON_OVERRIDABLE
de: %qs bei %L überschreibt eine Prozedurbindung, die als NON_OVERRIDABLE deklariert ist

en: %qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL
de: %qs bei %L überschreibt eine ELEMENTAL-Prozedur und muss auch ELEMENTAL sein

en: %qs at %L shall be an INTENT(OUT) variable
de: %qs bei %L muss eine %<INTENT(OUT)%>-Variable sein

en: %qs at %L should be a FUNCTION
de: %qs bei %L sollte eine FUNCTION sein

en: %qs at %L should be a SUBROUTINE
de: %qs bei %L sollte eine SUBROUTINE sein

en: %qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)
de: %qs bei %L sollte ein Skalar vom Typ integer(kind=omp_event_handle_kind) sein

en: %qs attribute cannot be applied to a function that does not take variable arguments
de: Attribut %qs ist nur auf Funktionen anwendbar, die eine variable Anzahl von Argumenten haben

en: %qs attribute directive ignored
de: Attribut-Direktive %qs ignoriert

en: %qs attribute ignored
de: Attribut %qs wird ignoriert

en: %qs attribute not supported for %qE in %<__builtin_has_attribute%>
de: Attribut %qs wird für %qE in %<__builtin_has_attribute%> nicht unterstützt

en: %qs attribute not supported for %qT in %<__builtin_has_attribute%>
de: Attribut %qs wird für %qT in %<__builtin_has_attribute%> nicht unterstützt

en: %qs attribute not supported in %<__builtin_has_attribute%>
de: Attribut %qs wird in %<__builtin_has_attribute%> nicht unterstützt

en: %qs attribute only applies to functions
de: Attribut %qs gilt nur für Funktionen

en: %qs attribute only applies to variadic functions
de: Attribut %qs gilt nur für variadische Funktionen

en: %qs attribute requires prototypes with named arguments
de: Attribut %qs benötigt Prototypen mit benannten Argumenten

en: %qs attribute without arguments on a non-prototype
de: Attribut %qs ohne Argumente für einen Nicht-Prototyp

en: %qs cannot appear in a constant-expression
de: %qs kann nicht in einem Konstanten-Ausdruck auftreten

en: %qs cannot appear in a typedef declaration
de: %qs kann nicht in einer typedef-Deklaration auftreten

en: %qs cannot be constant evaluated because the argument cannot be encoded
de: %qs kann nicht als konstanter Ausdruck ausgewertet werden, da das Argument nicht codiert werden kann

en: %qs cannot be constant evaluated because the argument cannot be interpreted
de: %qs kann nicht als konstanter Ausdruck ausgewertet werden, da das Argument nicht interpretiert werden kann

en: %qs cannot be constant evaluated because the type is too large
de: %qs kann nicht als konstanter Ausdruck ausgewertet werden, da der Typ zu groß ist

en: %qs cannot be constant evaluated on the target
de: %qs kann auf diesem Ziel nicht als konstanter Ausdruck ausgewertet werden

en: %qs cannot be extended at %C because it is BIND(C)
de: %qs kann bei %C nicht erweitert werden, da es BIND(C) ist

en: %qs cannot be extended at %C because it is a SEQUENCE type
de: %qs kann bei %C nicht erweitert werden, da es ein SEQUENCE-Typ ist

en: %qs cannot be initialized with%<-ftrivial-auto-var_init%>
de: %qs kann nicht mit %<-ftrivial-auto-var_init%> initialisiert werden

en: %qs cannot be used for type declarations
de: %qs kann nicht für Typdeklarationen verwendet werden

en: %qs cannot be used in a %<constexpr%> function
de: %qs kann nicht in einer %<constexpr%>-Funktion verwendet werden

en: %qs cannot be used in a constructor
de: %qs kann nicht in einem Konstruktor verwendet werden

en: %qs cannot be used in a destructor
de: %qs kann nicht in einem Destruktor verwendet werden

en: %qs cannot be used in a function with a deduced return type
de: %qs kann nicht in einer Funktion mit einem abgeleiteten Rückgabetyp verwendet werden

en: %qs cannot be used in a varargs function
de: %qs kann nicht in einer varargs-Funktion verwendet werden

en: %qs cannot be used in the %<main%> function
de: %qs kann nicht in der Funktion %<main%> verwendet werden

en: %qs cannot be used outside a function
de: %qs kann nicht außerhalb einer Funktion verwendet werden

en: %qs clause at %L specified more than once
de: %qs-Klausel bei %L ist mehrfach angegeben

en: %qs clause is incompatible with %<read%> or %<write%> clauses
de: Klausel %qs ist unverträglich mit den Klauseln %<read%> oder %<write%>

en: %qs clause may not appear on non-rectangular %qs
de: %qs-Klausel darf nur bei rechteckigen %qs vorkommen

en: %qs clause on %<requires%> directive not supported yet
de: die %qs-Klausel wird in der %<requires%>-Direktive noch nicht unterstützt

en: %qs clause requires %qs clause
de: %qs-Klausel erfordert %qs-Klausel

en: %qs clause specified together with %<inscan%> %<reduction%> clause
de: %qs-Klausel darf nicht zusammen mit %<inscan%>-%<reduction%>-Klausel verwendet werden

en: %qs clause used lexically after first target construct or offloading API
de: %qs-Klausel wird lexikalisch nach dem ersten Zielkonstrukt oder nach der ersten Auslagerungs-API verwendet

en: %qs combined with %<auto%> qualifier for %qE
de: %qs mit Qualifizierer %<auto%> für %qE kombiniert

en: %qs combined with %<register%> qualifier for %qE
de: %qs mit Qualifizierer %<register%> für %qE kombiniert

en: %qs conflicts with %<-arch i386%> (%qs ignored)
de: %qs widerspricht %<-arch i386%> (%qs wird ignoriert)

en: %qs conflicts with %<-arch ppc%> (%qs ignored)
de: %qs widerspricht %<-arch ppc%> (%qs wird ignoriert)

en: %qs construct inside of %qs region
de: %qs-Konstrukt innerhalb einer %qs-Region

en: %qs declared INTRINSIC at %L does not exist
de: INTRINSIC deklariertes %qs bei %L existiert nicht

en: %qs declared as function returning a function
de: %qs als Funktion, die eine Funktion zurückgibt, deklariert

en: %qs declared as function returning an array
de: %qs als Funktion, die ein Feld zurückgibt, deklariert

en: %qs declared at %L is also the name of an intrinsic.  It can only be called via an explicit interface or if declared EXTERNAL.
de: Bei %2$L deklariertes %1$qs ist auch der Name einer intrinsischen Funktion. Sie kann nur über eine explizite Schnittstelle oder als EXTERNAL deklariert aufgerufen werden.

en: %qs declared at %L may shadow the intrinsic of the same name.  In order to call the intrinsic, explicit INTRINSIC declarations may be required.
de: Bei %2$L deklariertes %1$qs überdeckt intrinsische Funktion mit gleichem Namen. Um die aufzurufen, sind explizite INTRINSIC-Deklarationen erforderlich.

en: %qs declared in a non-class scope
de: %qs in einem Nicht-Klassen-Gültigkeitsbereich definiert

en: %qs defined in a non-class scope
de: %qs nicht in Klassen-Gültigkeitsbereich definiert

en: %qs does not support MIPS16 code
de: %qs unterstützt keinen MIPS16-Code

en: %qs does not support feature %qs
de: %qs unterstützt %qs nicht

en: %qs does not work on a cross compiler
de: %qs funktioniert nicht auf einem Cross-Compiler

en: %qs entity cannot have an initializer at %C
de: Entität %qs bei %C kann keine Initialisierung haben

en: %qs entity cannot have attributes at %C
de: Entität %qs bei %C kann keine Argumente haben

en: %qs expects 1 argument but %d given
de: %qs erfordert 1 Argument, aber %d wurden angegeben

en: %qs expects 2 arguments but %d given
de: %qs erwartet 2 Argumente, aber %d wurden angegeben

en: %qs expects a constant argument
de: %qs erwartet ein konstantes Argument

en: %qs expects a fixed-point value as argument
de: %qs erwartet einen Festkommawert als Argument

en: %qs expects a fixed-point value as first argument
de: %qs erwartet einen Festkommawert als erstes Argument

en: %qs expects an integer value as second argument
de: %qs erwartet einen Ganzzahlwert als zweites Argument

en: %qs expression must be integral
de: %qs-Ausdruck muss ganzzahlig sein

en: %qs expression of %<volatile%>-qualified type is deprecated
de: %qs-Ausdruck von %<volatile%>-qualifiziertem Typ ist veraltet

en: %qs failed
de: %qs fehlgeschlagen

en: %qs feature modifier is incompatible with the use of floating-point types
de: Feature-Modifizierer %qs verträgt sich nicht mit der Verwendung von Gleitkommatypen

en: %qs feature modifier is incompatible with the use of vector types
de: Feature-Modifizierer %qs verträgt sich nicht mit der Verwendung von Vektortypen

en: %qs function cannot have arguments
de: Funktion %qs kann keine Argumente haben

en: %qs function cannot have different interrupt type
de: %qs-Funktion kann keine andere Interrupt-Art haben

en: %qs function cannot return a value
de: Funktion %qs kann keinen Wert zurückgeben

en: %qs function uses %<auto%> type specifier without trailing return type
de: Funktion %qs verwendet Typspezifikation %<auto%> ohne folgenden Rückgabetypen

en: %qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>
de: Funktion %qs mit nachgestelltem Rückgabetyp hat %<decltype(auto)%> als Typ statt einfachem %<auto%>

en: %qs function with trailing return type has %qT as its type rather than plain %<auto%>
de: Funktion %qs mit folgendem Rückgabetypen hat %qT als seinen Typ statt einfaches %<auto%>

en: %qs function with trailing return type not declared with %<auto%> type specifier
de: Funktion %qs mit folgendem Rückgabetypen nicht mit Typspezifikation %<auto%> deklariert

en: %qs has both %<extern%> and initializer
de: %qs hat sowohl %<extern%> als auch Initialisierung

en: %qs has overflowed
de: %qs übergelaufen

en: %qs in %s clause at %L is a zero size array section
de: %qs in der %s-Klausel bei %L ist ein Array-Abschnitt der Größe Null

en: %qs in %s clause at %L is not a proper array section
de: %qs in %s-Klausel bei %L ist kein korrekter Feldabschnitt

en: %qs in ALIGNED clause at %L requires a scalar positive constant integer alignment expression
de: %qs in ALIGNED-Klausel bei %L erfordert einen skalaren, positiven, konstanten Ganzzahlausdruck für die Ausrichtung

en: %qs in ALIGNED clause must be POINTER, ALLOCATABLE, Cray pointer or C_PTR at %L
de: %qs in ALIGNED-Klausel bei %L muss POINTER, ALLOCATABLE, Cray-Zeiger oder C_PTR sein

en: %qs in EXTENDS expression at %C is not a derived type
de: %qs in EXTENDS-Ausdruck bei %C ist kein abgeleiteter Typ

en: %qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause
de: %qs in LINEAR-Klausel bei %L benötigt einen konstanten, ganzzahligen linear-step-Ausdruck oder ein Dummy-Argument, das in der UNIFORM-Klausel angegeben ist

en: %qs in LINEAR clause at %L requires a scalar integer linear-step expression
de: %qs in LINEAR-Klausel bei %L benötigt einen skalaren, ganzzahligen linear-step-Ausdruck

en: %qs in gimple IL
de: %qs in GIMPLE-IL

en: %qs in the pointer assignment at %L cannot be an l-value since it is a procedure
de: %qs in Zeigerzuweisung bei %L kann kein L-Wert sein, da es eine Prozedur ist

en: %qs in variable definition context (%s) at %L is not a variable
de: %qs in Variablen-Definitionskontext (%s) bei %L ist keine Variable

en: %qs incompatible with explicitly disabled options
de: %qs inkompatibel mit explizit ausgeschalteten Optionen

en: %qs initialized and declared %<extern%>
de: %qs initialisiert und als %<extern%> deklariert

en: %qs into non-mode-precision operand
de: %qs in non-mode-precision Operanden

en: %qs intrinsic subprogram at %L has been removed.  Use INT intrinsic subprogram.
de: Das intrinsische Unterprogramm %qs bei %L wurde entfernt. Verwenden Sie das intrinsische Unterprogramm INT.

en: %qs intrinsic with CHARACTER argument at %L
de: intrinsisches %qs mit CHARACTER-Argument bei %L

en: %qs intrinsic with KIND argument at %L
de: intrinsisches %qs mit KIND-Argument bei %L

en: %qs intrinsic with RADIX argument at %L
de: intrinsisches %qs mit RADIX-Argument bei %L

en: %qs is a nested function and cannot be accessed from %qs
de: %qs ist eine geschachtelte Funktion, Zugriff von %qs aus ist nicht möglich

en: %qs is a reserved identifier in AVR-LibC.  Consider %<#include <avr/interrupt.h>%> before using the %qs macro
de: %qs ist in der AVR-LibC ein reservierter Bezeichner. Erwägen Sie %<#include <avr/interrupt.h>%> vor der Benutzung des Makros %qs

en: %qs is already IMPORTed from host scoping unit at %C
de: %qs bereits aus Host-Sichtbarkeitseinheit bei %C IMPORTiert

en: %qs is an invalid argument to %<-mcpu=%>
de: %qs ist ein ungültiges Argument für %<-mcpu=%>

en: %qs is an opaque type, and you cannot set it to other values
de: %qs ist ein undurchsichtiger Typ, und Sie können ihn nicht auf andere Werte setzen

en: %qs is an unknown %<-save-temps%> option
de: %qs ist eine unbekannte Option für %<-save-temps%>

en: %qs is corrupted
de: %qs ist beschädigt

en: %qs is defined in header %qs; did you forget to %<#include %s%>?
de: %qs ist im Header %qs definiert; haben Sie vergessen, %<#include %s%> zu schreiben?

en: %qs is deprecated
de: %qs ist veraltet

en: %qs is deprecated and not recommended in any circumstances
de: %qs ist veraltet und wird unter keinen Umständen empfohlen

en: %qs is deprecated; use -fno-zero-initialized-in-bss
de: %qs ist veraltet; stattdessen -fno-zero-initialized-in-bss verwenden

en: %qs is deprecated; use -fstack-check
de: %qs ist veraltet; stattdessen -fstack-check verwenden

en: %qs is incompatible with %qs
de: %qs ist mit %qs unverträglich

en: %qs is incompatible with the use of floating-point types
de: %qs verträgt sich nicht mit der Verwendung von Gleitkommatypen

en: %qs is incompatible with the use of vector types
de: %qs verträgt sich nicht mit der Verwendung von Vektortypen

en: %qs is mutually exclusive with %qs and cannot be specified together
de: %qs und %qs schließen sich gegenseitig aus und können nicht zusammen angegeben werden

en: %qs is narrower than values of its type
de: %qs ist schmaler als die Werte seines Typs

en: %qs is neither a defined operator nor a structure component in dotted string at %C
de: in der gepunkteten Zeichenkette bei %2$C ist %1$qs weder ein definierter Operator noch eine Strukturkomponente

en: %qs is not a constant expression because %qT contains a pointer to member type
de: %qs ist kein konstanter Ausdruck, da %qT einen Zeiger-auf-Element-Typen enthält

en: %qs is not a constant expression because %qT contains a pointer type
de: %qs ist kein konstanter Ausdruck, da %qT einen Zeigertyp enthält

en: %qs is not a constant expression because %qT contains a reference type
de: %qs ist kein konstanter Ausdruck, da %qT einen Referenztypen enthält

en: %qs is not a constant expression because %qT contains a union type
de: %qs ist kein konstanter Ausdruck, da %qT einen union-Typen enthält

en: %qs is not a constant expression because %qT contains a volatile subobject
de: %qs ist kein konstanter Ausdruck, da %qT ein %<volatile%>-Teilobjekt enthält

en: %qs is not a constant expression because %qT is a pointer to member type
de: %qs ist kein konstanter Ausdruck, da %qT ein Zeiger-auf-Element-Typ ist

en: %qs is not a constant expression because %qT is a pointer type
de: %qs ist kein konstanter Ausdruck, da %qT ein Zeigertyp ist

en: %qs is not a constant expression because %qT is a reference type
de: %qs ist kein konstanter Ausdruck, da %qT ein Referenztyp ist

en: %qs is not a constant expression because %qT is a union type
de: %qs ist kein konstanter Ausdruck, da %qT ein union-Typ ist

en: %qs is not a constant expression because %qT is volatile
de: %qs ist kein konstanter Ausdruck, da %qT %<volatile%> ist

en: %qs is not a directory
de: %qs ist kein Verzeichnis

en: %qs is not a field, but a %qs
de: %qs ist kein Feld, sondern ein %qs

en: %qs is not a gcov data file
de: %qs ist keine gcov-Datei

en: %qs is not a valid base register in %<-mstack-protector-guard-reg=%>
de: %qs ist kein gültiges Basisregister in %<-mstack-protector-guard-reg=%>

en: %qs is not a valid base register in %qs
de: %qs ist in %qs kein gültiges Basisregister

en: %qs is not a valid number in %<-mstack-protector-guard-offset=%>
de: %qs ist keine gültige Zahl in %<-mstack-protector-guard-offset=%>

en: %qs is not a valid number in %qs
de: %qs ist in %qs keine gültige Zahl

en: %qs is not a valid offset in %<-mstack-protector-guard-offset=%>
de: %qs ist kein gültiger Offset in %<-mstack-protector-guard-offset=%>

en: %qs is not a valid offset in %qs
de: %qs ist in %qs kein gültiger Offset

en: %qs is not a valid option to the preprocessor
de: %qs ist keine gültige Präprozessoroption

en: %qs is not an associative array
de: %qs ist kein assoziatives Array

en: %qs is not an expression
de: %qs ist kein Ausdruck

en: %qs is not an option that controls warnings
de: %qs ist keine Option, die Warnungen steuert

en: %qs is not defined as a type
de: %qs ist nicht als ein Typ definiert

en: %qs is not supported by arch %s
de: %qs wird von der Architektur %<%s%> nicht unterstützt

en: %qs is not supported for 64-bit Darwin; it is incompatible with the installed C and C++ libraries
de: %qs wird für 64-Bit-Darwin nicht unterstützt; es ist mit den installierten C- und C++-Bibliotheken unverträglich

en: %qs is not supported for this target
de: %qs wird auf diesem Ziel nicht unterstützt

en: %qs is not supported in 32-bit mode
de: %qs wird im 32-Bit-Modus nicht unterstützt

en: %qs is not supported in this compiler configuration
de: %qs wird von dieser Compiler-Konfiguration nicht unterstützt

en: %qs is not supported in this configuration
de: %qs wird in dieser Konfiguration nicht unterstützt

en: %qs is not supported on little endian systems
de: %qs wird auf »little endian«-Systemen nicht unterstützt

en: %qs is not supported on this target
de: %qs wird auf diesem Ziel nicht unterstützt

en: %qs is not supported with %qs
de: %qs wird mit %qs nicht unterstützt

en: %qs is not valid for %<-mmacosx-version-min%>
de: ungültiger Wert %qs für %<-mmacosx-version-min%>

en: %qs is not valid for %qs
de: %qs ist für %qs ungültig

en: %qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L
de: %qs hat PRIVATE-Typ und kann kein Scheinargument von %qs bei %L sein, das PUBLIC ist

en: %qs is used uninitialized
de: %qs ist nicht initialisiert, wird aber benutzt

en: %qs is version %q.*s, expected version %q.*s
de: %qs hat Version %q.*s, Version %q.*s erwartet

en: %qs length expression must be integral
de: Ausdruck für %qs-Länge muss ganzzahlig sein

en: %qs length expression must be positive constant integer expression
de: Ausdruck für %qs-Länge muss ganzzahlig, positiv und konstant sein

en: %qs matching variant is deprecated
de: %qs-Matchingvariante ist veraltet

en: %qs matching variant requires z14 or higher
de: passende %qs-Variante erfordert z14 oder höher

en: %qs matching variant requires z15 or higher
de: passende %qs-Variante erfordert z15 oder höher

en: %qs may be used uninitialized
de: %qs könnte uninitialisiert verwendet werden

en: %qs must be a module procedure or an external procedure with an explicit interface at %L
de: %qs bei %L muss eine Modulprozedur oder eine externe Prozedur mit expliziter Schnittstelle sein

en: %qs must be by itself for %<-mharden-sls=%>
de: %qs muss für sich allein stehen, für %<-mharden-sls=%>

en: %qs must be of same type and kind as %qs at %L in %qs
de: %qs muss vom gleichen Typ und gleicher Art wie %qs bei %L in %qs sein

en: %qs must be the first clause of %qs
de: %qs muss die erste Klausel von %qs sein

en: %qs must be used with %qs
de: %qs muss mit %qs verwendet werden

en: %qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated
de: %qs darf nicht bei %L in einer Feldspezifikation in der gleichen ALLOCATE-Anweisung auftreten, wo es selbst alloziert wird

en: %qs needs a valid base register
de: %qs erfordert ein gültiges Basisregister

en: %qs not allowed outside STRUCTURE at %C
de: %qs ist außerhalb der STRUCTURE bei %C nicht erlaubt

en: %qs not at element boundary
de: %qs nicht an Elementgrenze

en: %qs not supported by your assembler
de: %qs wird vom Assembler nicht unterstützt

en: %qs not supported on this target
de: %qs wird auf diesem Ziel nicht unterstützt

en: %qs not supported with %<-msoft-float%>
de: %qs wird in Kombination mit %<-msoft-float%> nicht unterstützt

en: %qs not yet supported
de: %qs wird noch nicht unterstützt

en: %qs of %qs is PRIVATE at %L
de: %qs von %qs bei %L ist PRIVATE

en: %qs of module %qs, imported at %C, is also the name of the current program unit
de: Bei %3$C importiertes %1$qs von Modul %2$qs ist auch der Name der aktuellen Programmeinheit

en: %qs of non-mode-precision operand
de: Operand von %qs ohne Modus-Genauigkeit

en: %qs only supported in OpenACC code
de: %qs wird nur in OpenACC-Code unterstützt

en: %qs parameter inquiry for %qs in variable definition context (%s) at %L
de: Parameterabfrage %qs für %qs in Variablen-Definitionskontext (%s) bei %L

en: %qs pointer is null
de: Zeiger %qs ist null

en: %qs profile count data file not found
de: Datei für Profilingzählerdaten %qs wurde nicht gefunden

en: %qs property cannot be set
de: Eigenschaft %qs kann nicht gesetzt werden

en: %qs region may not be closely nested inside of work-sharing, %<loop%>, explicit %<task%> or %<taskloop%> region
de: %qs-Region darf nicht innerhalb einer Region eng geschachtelt sein, die arbeitsteilend, %<loop%>, explizit %<task%> oder %<taskloop%> ist

en: %qs requires %<__ibm128%> type support
de: %qs erfordert Unterstützung des Typs %<__ibm128%>

en: %qs requires %<long double%> to be IBM 128-bit format
de: %qs erfordert, dass %<long double%> das IBM-128-Bit-Format ist

en: %qs requires %qs
de: %qs erfordert %qs

en: %qs requires %qs or %qs
de: %qs erfordert %qs oder %qs

en: %qs requires PowerPC64 architecture, enabling
de: %qs erfordert PowerPC64-Architektur, wird eingeschaltet

en: %qs requires VSX support
de: %qs erfordert VSX-Unterstützung

en: %qs requires a target that provides the %qs instruction
de: %qs erfordert ein Ziel, das den %qs-Befehl unterstützt

en: %qs requires an integer constant expression
de: %qs erfordert einen konstanten Ganzzahlausdruck

en: %qs requires branch-likely instructions
de: %qs erfordert sprungwahrscheinliche Befehle

en: %qs requires full ISA 2.06 support
de: %qs erfordert vollständige Unterstützung von ISA 2.06

en: %qs requires full ISA 3.0 support
de: %qs erfordert vollständige Unterstützung von ISA 3.0

en: %qs requires quad-precision floating-point arithmetic
de: %qs erfordert Gleitkomma-Arithmetik mit Vierfachpräzision

en: %qs requires the %qs and %qs options
de: %qs erfordert die Optionen %qs und %qs

en: %qs requires the %qs option
de: %qs erfordert die Option %qs

en: %qs requires the %qs option and either the %qs or %qs option
de: %qs erfordert die Option %qs, zusätzlich entweder %qs oder %qs

en: %qs requires the ELFv2 ABI
de: %qs erfordert das ELFv2-ABI

en: %qs should be from a scalar to a like vector
de: %qs sollte von einem Skalar auf einen gleichartigen Vektor abbilden

en: %qs specified bound %s exceeds maximum object size %E
de: durch %qs angegebene Grenze %s überschreitet die maximale Objektgröße %E

en: %qs specified bound %s exceeds the size %E of unterminated array
de: durch %qs angegebene Grenze %s überschreitet die Größe %E des nicht abgeschlossenen Arrays

en: %qs specified bound %s exceeds the size of at most %E of unterminated array
de: durch %qs angegebene Grenze %s überschreitet die Maximalgröße %E des nicht abgeschlossenen Arrays

en: %qs specified bound %s may exceed the size of at most %E of unterminated array
de: durch %qs angegebene Grenze %s überschreitet möglicherweise die Maximalgröße %E des nicht abgeschlossenen Arrays

en: %qs specified for auto variable %qE
de: %qs für »auto«-Variable %qE angegeben

en: %qs specified for parameter %qE
de: %qs für Parameter %qE angegeben

en: %qs specified for structure field
de: %qs für Strukturfeld angegeben

en: %qs specified for structure field %qE
de: %qs für Strukturfeld %qE angegeben

en: %qs specified for unnamed parameter
de: %qs für unbenannten Parameter angegeben

en: %qs specified in 'allocate' clause at %L but not in an explicit privatization clause
de: %qs ist in %<allocate%>-Klausel bei %L angegeben, aber nicht in einer expliziten Privatisierungs-Klausel

en: %qs specified multiple times in the same option
de: %qs ist in derselben Option mehrfach angegeben

en: %qs specified with %<decltype%>
de: %qs mit %<decltype%> angegeben

en: %qs specified with %<typeof%>
de: %qs mit %<typeof%> angegeben

en: %qs specified with %qT
de: %qs mit %qT angegeben

en: %qs specifies a conflicting level of parallelism
de: %qs gibt eine widersprüchliche Stufe der Parallelität an

en: %qs string ill-formed
de: Zeichenkette %qs ist falsch geformt

en: %qs symbol %q+D must have static linkage
de: %qs-Symbol %q+D muss statische Bindung haben

en: %qs symbol %q+D ultimately targets itself
de: %qs-Symbol %q+D zielt letztendlich auf sich selbst ab

en: %qs tag used in naming %q#T
de: Markierung %qs bei Benennung von %q#T verwendet

en: %qs unsupported for this ABI
de: %qs wird in dieser ABI nicht unterstützt

en: %qs used with %qE
de: %qs mit %qE verwendet

en: %qs uses dynamic stack allocation
de: %qs verwendet dynamische Stapelanforderung

en: %qs uses register r29
de: %qs verwendet Register r29

en: %qs value must be positive
de: Wert %qs muss positiv sein

en: %qs variable is neither a pointer nor an array
de: Variable %qs ist weder Zeiger noch Array

en: %qs variable is neither a pointer nor reference to pointer
de: Variable %qs ist weder Zeiger noch Referenz auf Zeiger

en: %qs variable is neither a pointer, nor an array nor reference to pointer or array
de: Variable %qs ist weder Zeiger noch Array noch Referenz auf Zeiger oder Array

en: %qs variable is not a pointer
de: Variable %qs muss ein Zeiger sein

en: %qs was declared here
de: %qs wurde hier deklariert

en: %qs with an always-false condition
de: %qs mit immer falscher Bedingung

en: %qs: [%u] bad %<next_regno%> for empty chain (%u)
de: %s: [%u] Falsches %<next_regno%> für leere Kette (%u)

en: %qs: [%u] bad %<oldest_regno%> (%u)
de: %s: [%u] Falsches %<oldest_regno%> (%u)

en: %qs: [%u] non-empty register in chain (%s %u %i)
de: %s: [%u] Nicht leeres Register in Kette (%s %u %i)

en: %qs: loop in %<next_regno%> chain (%u)
de: %s: Zyklus in %<next_regno%>-Kette (%u)

en: %r%s:%d:%R   [ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
de: %r%s:%d:%R   [ %d Instanziierungskontexte werden übersprungen, »-ftemplate-backtrace-limit=0« zum Ausschalten verwenden ]

en: %r%s:%d:%R   in %<constexpr%> expansion of %qs
de: %r%s:%d:%R   in %<constexpr%>-Ersetzung von %qs

en: %r%s:%d:%d:%R   [ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
de: %r%s:%d:%d:%R   [ %d Instanziierungskontexte werden übersprungen, »-ftemplate-backtrace-limit=0« zum Ausschalten verwenden ]

en: %r%s:%d:%d:%R   in %<constexpr%> expansion of %qs
de: %r%s:%d:%d:%R   in %<constexpr%>-Ersetzung von %qs

en: %s  Same as %s.
de: %s ist identisch mit %s.

en: %s !$ACC LOOP loops not perfectly nested at %L
de: »%s !$ACC LOOP«-Schleifen bei %L nicht perfekt geschachtelt

en: %s %<%s%.*s%> expects a matching %<%T%s%> argument
de: %s %<%s%.*s%> erwartet ein passendes Argument %<%T%s%>

en: %s %<%s%.*s%> expects a matching %<%s%s%> argument
de: %s %<%s%.*s%> erwartet ein passendes Argument %<%s%s%>

en: %s %<%s%.*s%> expects argument of type %<%T%s%>, but argument %d has type %qT
de: %s %<%s%.*s%> erwartet Argumenttyp %<%T%s%>, aber Argument %d hat Typ %qT

en: %s %<%s%.*s%> expects argument of type %<%s%s%>, but argument %d has type %qT
de: %s %<%s%.*s%> erwartet Argumenttyp %<%s%s%>, aber Argument %d hat Typ %qT

en: %s %qE does not fully implement the %qE protocol
de: »%s %E« implementiert das Protokoll %qE nicht vollständig

en: %s %qs construct inside of %s %qs region
de: %s-%qs-Konstrukt innerhalb einer %s-%qs-Region

en: %s %qs is an invalid argument to builtin %qs
de: %s %qs ist ein ungültiges Argument für eingebaute Funktion %qs

en: %s %wd out of range %wd - %wd
de: »%s« %wd ist außerhalb des gültigen Bereichs von %wd bis %wd

en: %s '%s'
de: %s: »%s«

en: %s - %u-bit integer numbers unsupported (mode %qs)
de: %s – %u-Bit-Ganzzahlen werden nicht unterstützt (Modus %qs)

en: %s - %u-bit-precision complex floating-point numbers unsupported (mode %qs)
de: %s – Komplexe Gleitkommazahlen mit %u Bit Genauigkeit werden nicht unterstützt (Modus %qs)

en: %s - %u-bit-precision decimal floating-point numbers unsupported (mode %qs)
de: %s – Dezimale Gleitkommazahlen mit %u Bit Genauigkeit werden nicht unterstützt (Modus %qs)

en: %s - %u-bit-precision floating-point numbers unsupported (mode %qs)
de: %s – Gleitkommazahlen mit %u Bit Genauigkeit werden nicht unterstützt (Modus %qs)

en: %s - unsupported mode %qs
de: nicht unterstützter Modus %2$qs für %1$qs

en: %s argument to IMAGE_INDEX must be a rank one array at %L
de: Argument »%s« für IMAGE_INDEX muss Feld mit Rang 1 bei %L sein

en: %s at %C is a DEC extension, enable with %<-fdec%>
de: %s bei %C ist eine DEC-Erweiterung, muss mit %<-fdec%> eingeschaltet werden

en: %s at %C is a DEC extension, enable with %<-fdec-static%>
de: %s bei %C ist eine DEC-Erweiterung, muss mit %<-fdec-static%> eingeschaltet werden

en: %s at %C is a DEC extension, enable with %<-fdec-structure%>
de: %s bei %C ist eine DEC-Erweiterung, muss mit %<-fdec-structure%> eingeschaltet werden

en: %s at %L
de: %s bei %L

en: %s at %L is a DEC extension, enable with %<-fdec-static%>
de: %s bei %L ist eine DEC-Erweiterung, muss mit %<-fdec-static%> eingeschaltet werden

en: %s at %L must be INTEGER
de: %s bei %L muss INTEGER sein

en: %s at %L must be a scalar
de: %s bei %L muss skalar sein

en: %s at %L must be integer
de: %s bei %L muss ganzzahlig sein

en: %s attribute applied to %s %s at %L
de: Attribut %s auf %s %s bei %L angewendet

en: %s attribute at %L is not allowed outside of the specification part of a module
de: Attribut %s bei %L ist außerhalb des Spezifikationsabschnitts eines Moduls nicht erlaubt

en: %s attribute conflicts with %s attribute at %L
de: Attribut %s steht mit Attribut %s bei %L in Konflikt

en: %s attribute conflicts with %s attribute in %qs at %L
de: Attribut %s steht mit Attribut %s in %qs bei %L in Konflikt

en: %s attribute not allowed in BLOCK DATA program unit at %L
de: Attribut %s ungültig in BLOCK DATA - Programmeinheit bei %L

en: %s attribute of %qs conflicts with %s attribute at %L
de: Attribut %s von %qs steht mit Attribut %s bei %L in Konflikt

en: %s between %L and %L
de: %s zwischen %L und %L

en: %s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs
de: %s zwischen der MODULE-PROCEDURE-Deklaration in Modul %qs und der Deklaration bei %L in (SUB)MODULE %qs

en: %s cannot be a DO CONCURRENT loop at %L
de: %s kann bei %L keine DO-CONCURRENT-Schleife sein

en: %s cannot be a DO WHILE or DO without loop control at %L
de: %s kann weder DO WHILE noch DO sein, ohne Schleifensteuerung bei %L

en: %s cannot be used in %<asm%> here
de: »%s« kann nicht hier in %<asm%> verwendet werden

en: %s clause at %L requires a scalar INTEGER expression
de: Klausel %s bei %L erfordert einen skalaren INTEGER-Ausdruck

en: %s clause variable %qs at %L is neither a POINTER nor an array
de: %s-Klausel-Variable %qs bei %L ist weder Zeiger- noch Feldtyp

en: %s collapsed loops don't form rectangular iteration space at %L
de: Zusammengefallene »%s«-Schleifen formen bei %L keinen rechteckigen Wiederholungsraum

en: %s contains too many lines
de: %s enthält zu viele Zeilen

en: %s does not support %%n$ operand number formats
de: %s unterstützt %%n$-Operandennummerformate nicht

en: %s does not support %s
de: %s unterstützt %s nicht

en: %s does not support %s with the %<%%%c%> %s format
de: %s unterstützt %s mit dem Format %<%%%c%> %s nicht

en: %s does not support block_ends_with_call_p
de: Interner Fehler: %s does not support block_ends_with_call_p

en: %s does not support block_ends_with_condjump_p
de: Interner Fehler: %s does not support block_ends_with_condjump_p

en: %s does not support can_duplicate_block_p
de: Interner Fehler: %s does not support can_duplicate_block_p

en: %s does not support can_merge_blocks_p
de: Interner Fehler: %s does not support can_merge_blocks_p

en: %s does not support can_remove_branch_p
de: Interner Fehler: %s does not support can_remove_branch_p

en: %s does not support create_basic_block
de: Interner Fehler: %s does not support create_basic_block

en: %s does not support delete_basic_block
de: Interner Fehler: %s does not support delete_basic_block

en: %s does not support dump_bb_for_graph
de: Interner Fehler: %s does not support dump_bb_for_graph

en: %s does not support duplicate_block
de: Interner Fehler: %s does not support duplicate_block

en: %s does not support flow_call_edges_add
de: Interner Fehler: %s does not support flow_call_edges_add

en: %s does not support force_nonfallthru
de: Interner Fehler: %s does not support force_nonfallthru

en: %s does not support make_forwarder_block
de: Interner Fehler: %s does not support make_forwarder_block

en: %s does not support merge_blocks
de: Interner Fehler: %s does not support merge_blocks

en: %s does not support move_block_after
de: Interner Fehler: %s does not support move_block_after

en: %s does not support predict_edge
de: Interner Fehler: %s does not support predict_edge

en: %s does not support predicted_by_p
de: Interner Fehler: %s does not support predicted_by_p

en: %s does not support redirect_edge_and_branch
de: Interner Fehler: %s does not support redirect_edge_and_branch

en: %s does not support redirect_edge_and_branch_force
de: Interner Fehler: %s does not support redirect_edge_and_branch_force

en: %s does not support split_block
de: Interner Fehler: %s does not support split_block

en: %s does not support split_edge
de: Interner Fehler: %s does not support split_edge

en: %s does not support the %<%%%c%> %s format
de: %s unterstützt das Format %<%%%c%> für %s nicht

en: %s does not support the %<%%%s%c%> %s format
de: %s unterstützt das Format %<%%%s%c%> für %s nicht

en: %s does not support the %qs %s length modifier
de: %s unterstützt den Längenmodifizierer %qs für %s nicht

en: %s does not take any feature options
de: %s akzeptiert keine Featureoptionen

en: %s expects a compile time integer constant
de: %s erwartet eine Ganzzahlkonstante zur Kompilierzeit

en: %s expects a compile time long integer constant as first argument
de: %s erwartet eine Long-Ganzzahlkonstante als erstes Argument zur Kompilierzeit

en: %s expression list treated as compound expression
de: Ausdrucksliste für »%s« wird als zusammengesetzten Ausdruck behandelt

en: %s from %s called in %s
de: %s aus %s wird in %s aufgerufen

en: %s from %s referenced in %s
de: %s aus %s wird in %s referenziert

en: %s ignored with %s and %<%%%c%> %s format
de: %s ignoriert mit %s und Format %<%%%c%> für %s

en: %s ignored with %s in %s format
de: %s ignoriert mit %s im Format für %s

en: %s incompatible with %<-mword-relocations%>
de: »%s« verträgt sich nicht mit %<-mword-relocations%>

en: %s instructions aren%'t allowed in a function with the %<no_caller_saved_registers%> attribute
de: %s-Befehle sind in Funktionen mit %<no_caller_saved_registers%>-Attribut nicht erlaubt

en: %s instructions aren%'t allowed in an exception service routine
de: %s-Befehle sind in Exception-Serviceroutine nicht erlaubt

en: %s instructions aren%'t allowed in an interrupt service routine
de: %s-Befehle sind in Interrupt-Serviceroutine nicht erlaubt

en: %s is not supported by this configuration
de: %s wird von dieser Konfiguration nicht unterstützt

en: %s iteration variable must be of type integer at %L
de: %s-Iterationsvariable bei %L muss vom Typ integer sein

en: %s iteration variable must not be THREADPRIVATE at %L
de: %s-Iterationsvariable bei %L darf nicht THREADPRIVATE sein

en: %s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L
de: %s-Iterationsvariable bei %L an anderer Klausel als PRIVATE, LASTPRIVATE oder ALLOCATE gefunden

en: %s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L
de: %s-Iterationsvariable bei %L an anderer Klausel als PRIVATE, LASTPRIVATE, ALLOCATE oder LINEAR gefunden

en: %s must contain at least one MAP clause at %L
de: %s bei %L muss mindestens eine MAP-Klausel enthalten

en: %s namespace %qD conflicts with reachable definition
de: %s-Namensraum %qD widerspricht der Erreichbarkeits-Definition

en: %s not supported for variable length aggregates
de: %s wird für Aggregattypen mit variabler Länge nicht unterstützt

en: %s not supported on this target
de: %s wird auf diesem Ziel nicht unterstützt

en: %s only supports non-pic code on M-profile targets
de: %s unterstützt nicht-PIC-Code nur auf M-Profil-Zielen

en: %s only supports non-pic code on M-profile targets with the MOVT instruction
de: %s unterstützt nicht-PIC-Code nur auf M-Profil-Zielen mit dem MOVT-Befehl

en: %s out of range: Range is %i to %i, value is %i
de: %s außerhalb des Wertebereiches: Bereich ist %i bis %i, Wert ist %i

en: %s procedure at %L is already declared as %s procedure
de: Prozedur %s bei %L ist bereits als Prozedur %s deklariert

en: %s procedure at %L is already declared as %s procedure. 
    F2008: A pointer function assignment is ambiguous if it is the first executable statement after the specification block. Please add any other kind of executable statement before it. FIXME
de: %s-Prozedur bei %L ist bereits als %s-Prozedur deklariert.
    F2008: Eine Zuweisung an eine Zeigerfunktion ist mehrdeutig, wenn dies die erste Anweisung nach dem Spezifikationsblock ist. Bitte fügen Sie davor irgend eine andere ausführbare Anweisung ein. FIXME (steht so im englischen Original.)

en: %s returned %d exit status
de: %s gab Ende-Status %d zurück

en: %s signal terminated program %s
de: Signal %s hat Programm %s beendet

en: %s specifier at %L not allowed in OPEN statement for unformatted I/O
de: %s-Angabe bei %L ist in OPEN-Anweisung nicht erlaubt für unformatierte Ein-/Ausgabe

en: %s specifier in %s statement at %L has invalid value %qs
de: Spezifizierer %s in Anweisung %s bei %L hat ungültigen Wert %qs

en: %s specifier in %s statement at %L has value %qs
de: Spezifizierer %s in Anweisung %s bei %L hat Wert %qs

en: %s statement at %C cannot follow %s statement at %L
de: Anweisung %s bei %C kann nicht auf Anweisung %s bei %L folgen

en: %s statement at %C cannot terminate a non-block DO loop
de: Anweisung %s bei %C kann keine DO-Schleife ohne Block beenden

en: %s statement at %C follows another accessibility specification
de: Anweisung %s bei %C folgt einer anderen Zugriffsspezifikation

en: %s statement at %C in PURE procedure
de: Anweisung %s bei %C in PURE-Prozedur

en: %s statement at %C is not applicable to construct %qs
de: Anweisung %s bei %C nicht auf Konstrukt %qs anwendbar

en: %s statement at %C is not within a construct
de: Anweisung %s bei %C ist nicht innerhalb eines Konstrukts

en: %s statement at %C is not within construct %qs
de: Anweisung %s bei %C nicht innerhalb des Konstrukts %qs

en: %s statement at %C leaves CRITICAL construct
de: Anweisung %s bei %C hinterlässt CRITICAL-Konstrukt

en: %s statement at %C leaves DO CONCURRENT construct
de: Anweisung %s bei %C hinterlässt DO CONCURRENT-Konstrukt

en: %s statement at %C leaving OpenACC structured block
de: Anweisung %s bei %C verlässt OpenACC-strukturierten Block

en: %s statement at %C leaving OpenMP structured block
de: Anweisung %s bei %C verlässt OpenMP-strukturierten Block

en: %s statement expected at %L
de: %s-Anweisung bei %L erwartet

en: %s statement is not allowed inside of BLOCK DATA at %C
de: %s-Anweisung ist innerhalb von BLOCK DATA bei %C nicht erlaubt

en: %s statement is not allowed inside of BLOCK at %C
de: %s-Anweisung ist innerhalb eines BLOCKs bei %C nicht erlaubt

en: %s statement must appear in a MODULE
de: Anweisung %s muss in einem MODULE auftreten

en: %s statement not allowed in PURE procedure at %C
de: %s-Anweisung in PURE-Prozedur bei %C nicht erlaubt

en: %s tag
de: %s-Symbol

en: %s tag at %L must be a character string of default kind
de: Markierung %s bei %L muss Standard-Zeichenkette sein

en: %s tag at %L must be of type %s
de: Markierung %s bei %L muss vom Typ %s sein

en: %s tag at %L must be scalar
de: Markierung %s bei %L muss ein Skalar sein

en: %s tag with INQUIRE
de: %s-Symbol mit INQUIRE

en: %s terminated with signal %d [%s]%s
de: %s mit Signal %d [%s]%s beendet

en: %s used with %<%%%c%> %s format
de: %s verwendet mit Format %<%%%c%> %s

en: %s used within a quoted sequence
de: %s wird innerhalb von %%<…%%> verwendet

en: %s variable %qE is private in outer context
de: »%s«-Variable %qE ist im äußeren Kontext »private«

en: %s%#qD (deleted)
de: %s%#qD (gelöscht)

en: %s%#qD (near match)
de: %s%#qD (in der Nähe der Übereinstimmung)

en: %s%#qD (reversed)
de: %s%#qD (umgekehrt)

en: %s%#qD (rewritten)
de: %s%#qD (umgeschrieben)

en: %s%<%D(%T)%> (built-in)
de: %s%<%D(%T)%> (eingebaut)

en: %s%<%D(%T, %T)%> (built-in)
de: %s%<%D(%T, %T)%> (eingebaut)

en: %s%<%D(%T, %T, %T)%> (built-in)
de: %s%<%D(%T, %T, %T)%> (eingebaut)

en: %s%qT (conversion)
de: %s%qT (Umwandlung)

en: %s%qs%s is invalid
de: %s%qs%s ist ungültig

en: %s%qs%s is not allowed
de: %s%qs%s ist nicht erlaubt

en: %s%s%s %sversion %s (%s)
    %s	compiled by GNU C version %s,
de: %s%s%s %sVersion %s (%s)
    %s	kompiliert von GNU-C-Version %s,

en: %s%s%s %sversion %s (%s) compiled by CC,
de: %s%s%s %sVersion %s (%s) kompiliert von CC,

en: %s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
de: %s%sGGC-Heuristik: --param ggc-min-expand=%d --param ggc-min-heapsize=%d

en: %s%swarning: %s header version %s differs from library version %s.
de: %s%sWarnung: %s-Header-Version %s unterscheidet sich von Bibliotheksversion %s.

en: %s-%s is an empty range
de: %s-%s ist ein leerer Bereich

en: %s: %<-fcompare-debug%> failure
de: %s: %<-fcompare-debug%> ist fehlgeschlagen

en: %s: %<-fcompare-debug%> failure (length)
de: %s: %<-fcompare-debug%> ist fehlgeschlagen (Länge)

en: %s: %d basic blocks and %d edges/basic block
de: %s: %d Basis-Blöcke und %d Kanten/Basis-Blöcke

en: %s: %d basic blocks and %d registers; increase %<--param max-gcse-memory%> above %wu
de: %s: %d Basisblöcke und %d Register; erhöhen Sie %<--param max-gcse-memory%> auf mehr als %wu

en: %s: %s compiler not installed on this system
de: %s: %s-Compiler ist auf diesem System nicht installiert

en: %s: In instantiation of %q#D:
de: %s: In Instanziierung von %q#D:

en: %s: In substitution of %qS:
de: %s: In Ersetzung von %qS:

en: %s: PCH file was invalid
de: %s: PCH-Datei war ungültig

en: %s: all warnings being treated as errors
de: %s: Alle Warnungen werden als Fehler behandelt

en: %s: attempt to rename spec %qs to already defined spec %qs
de: %s: Versuch, Spezifikation %qs in bereits definierte Spezifikation %qs umzubenennen

en: %s: cannot open as COFF file
de: %s kann nicht als COFF-Datei geöffnet werden

en: %s: could not determine length of compare-debug file %s
de: %s: Größe der Vergleichs-Prüfdatei %s konnte nicht ermittelt werden

en: %s: could not open compare-debug file %s
de: %s: Vergleichs-Prüfdatei %s konnte nicht geöffnet werden

en: %s: couldn%'t open PCH file: %m
de: %s: PCH-Datei konnte nicht geöffnet werden: %m

en: %s: linker input file not found: %m
de: %s: Linker-Eingabedatei nicht gefunden: %m

en: %s: linker input file unused because linking not done
de: %s: Eingabedatei des Linkers unbenutzt, da das Linken nicht durchgeführt wird

en: %s: not a COFF file
de: %s: keine COFF-Datei

en: %s: some warnings being treated as errors
de: %s: Einige Warnungen werden als Fehler behandelt

en: %s:%d: confused by earlier errors, bailing out
de: %s:%d: durch frühere Fehler verwirrt, Abbruch

en: %s:'%s' has arcs from exit block
de: %s: »%s« hat Bögen vom Eintrittsblock

en: %s:'%s' has arcs to entry block
de: %s: »%s« hat Bögen zum Eintrittsblock

en: %s:'%s' lacks entry and/or exit blocks
de: %s: Eintrag und/oder Exit-Blöcke fehlen in »%s«

en: %s:already seen blocks for '%s'
de: %s: bereits gesehene Blöcke für »%s«

en: %s:cannot open data file, assuming not executed
de: %s: kann nicht geöffnet werden, wird als nicht ausgeführt vermutet

en: %s:cannot open notes file
de: %s:Hinweis-Datei kann nicht geöffnet werden

en: %s:corrupted
de: %s: beschädigt

en: %s:graph is unsolvable for '%s'
de: %s: Graph ist für »%s« unlösbar

en: %s:no functions found
de: %s: keine Funktionen gefunden

en: %s:no lines for '%s'
de: %s: keine Zeilen für »%s«

en: %s:not a gcov data file
de: %s: keine gcov-Datei

en: %s:not a gcov notes file
de: %s:keine gcov-Hinweis-Datei

en: %s:overflowed
de: %s: übergelaufen

en: %s:profile mismatch for '%s'
de: %s: Profil passt nicht für »%s«

en: %s:source file is newer than notes file '%s'
de: %s:Quelldatei ist neuer als Hinweis-Datei »%s«

en: %s:stamp mismatch with notes file
de: %s: Marke passt nicht zur Hinweis-Datei

en: %s:version '%.4s', prefer '%.4s'
de: %s: Version »%.4s«, aber »%.4s« wird bevorzugt

en: %s:version '%.4s', prefer version '%.4s'
de: %s: Version »%.4s«, aber Version »%.4s« wird bevorzugt

en: %u name provided for structured binding | %u names provided for structured binding
de[0]: %u Name für strukturelle Bindung angegeben
de[1]: %u Namen für strukturelle Bindung angegeben

en: '
de: «

en: ' ' flag
de: » «-Kennzeichen

en: '!' flag
de: »!«-Kennzeichen

en: '#' flag
de: »#«-Kennzeichen

en: '%%%c' is not a valid operand prefix
de: »%%%c« ist kein gültiger Operandenpräfix

en: '%%&' used without any local dynamic TLS references
de: »%%&« ohne lokale dynamische TLS-Referenzen verwendet

en: '%%l' operand isn't a label
de: »%%l«-Operand ist keine Marke

en: '%s' file is already processed
de: Die Datei »%s« wird bereits verarbeitet

en: '%s' must have %d operands (excluding match_dups)
de: »%s« muss %d Operanden haben (außer match_dups)

en: '%s' must have at least %d operands (excluding match_dups)
de: »%s« muss mindestens %d Operanden haben (außer match_dups)

en: '%s' must have no more than %d operands (excluding match_dups)
de: »%s« darf höchstens %d Operanden haben (außer match_dups)

en: ''' flag
de: »'«-Kennzeichen

en: '(' flag
de: »(«-Kennzeichen

en: '+' flag
de: »+«-Kennzeichen

en: '-' flag
de: »-«-Kennzeichen

en: '0' flag
de: »0«-Kennzeichen

en: 'B' operand has multiple bits set
de: »B«-Operand hat mehrere gesetzte Bits

en: 'B' operand is not constant
de: »B«-Operand ist nicht konstant

en: 'E' modifier
de: »E«-Modifizierer

en: 'I' flag
de: »I«-Kennzeichen

en: 'O' modifier
de: »O«-Modifizierer

en: '^' flag
de: »^«-Kennzeichen

en: '_' flag
de: »_«-Kennzeichen

en: 'a' flag
de: »a«-Kennzeichen

en: 'm' flag
de: »m«-Kennzeichen

en: 'o' operand is not constant
de: »o«-Operand ist nicht konstant

en: 'q' flag
de: »q«-Kennzeichen

en: (Obsolete after 10.3.9) Set MH_NOPREFIXBINDING, in an executable.
de: (Obsolet nach 10.3.9)	MH_NOPREFIXBINDING festlegen, in einer ausführbaren Datei.

en: (Obsolete after 10.4)	Set MH_NOMULTIDEFS in an umbrella framework.
de: (Obsolet nach 10.4)	MH_NOMULTIDEFS festlegen, in einem übergeordneten Framework.

en: (Obsolete after 10.4) -multiply_defined <treatment>	Provided a mechanism for warning about symbols defined in multiple dylibs.
de: (Obsolet nach 10.4) -multiply_defined <Behandlung>	Bot einen Mechanismus zur Warnung vor Symbolen, die in mehreren Dylibs definiert sind.

en: (Obsolete after 10.4) -multiply_defined_unused <treatment>	Provided a mechanism for warning about symbols defined in the current executable also being defined in linked dylibs.
de: (Obsolet nach 10.4) -multiply_defined_unused <Behandlung>	Bot einen Mechanismus zur Warnung vor Symbolen, die in der aktuellen ausführbaren Datei definiert sind, die auch in verknüpften Dylibs definiert sind.

en: (Obsolete after 10.4) Multi modules are ignored at runtime since macOS 10.4.
de: (Obsolet nach 10.4) Multi-Module werden seit macOS 10.4 zur Laufzeit ignoriert.

en: (Obsolete and unhandled by ld64, ignored)	ld should produce an executable (only handled by ld_classic).
de: (Veraltet und unberücksichtigt von ld64)	Ob ld eine ausführbare Datei erzeugen soll (nur von ld_classic umgesetzt).

en: (Obsolete)	This is the default.
de: (Obsolet)	Dies ist der Vorgabewert.

en: (Obsolete) -sectobjectsymbols <segname> <sectname>	Setting a local symbol at the start of a section is no longer supported.
de: (Obsolet) -sectobjectsymbols <Segmentname> <Abschnittsname>	Das Festlegen eines lokalen Symbols am Anfang eines Abschnitts wird nicht mehr unterstützt.

en: (Obsolete) -sectorder <segname> <sectname> <orderfile>	Replaced by a more general option "-order_file".
de: (Obsolet) -sectorder <Segmentname> <Abschnittsname> <Reihenfolgedatei>	Wurde ersetzt durch die allgemeinere Option »-order_file«.

en: (Obsolete) Allowed linking to proceed with "-flat_namespace" when a linked bundle contained a symbol also exported from the main executable.
de: (Obsolet) Erlaubte das Verlinken mit »-flat_namespace« fortzusetzen, wenn ein verlinktes Bundle ein Symbol enthält, das ebenfalls aus der Hauptausführungsdatei exportiert wurde.

en: (Obsolete) Current linkers never dead-strip these items, so the option is not needed.
de: (Obsolet) Aktuelle Linker entfernen diese Elemente nie, daher wird diese Option nicht benötigt.

en: (Obsolete) LD_PREBIND is no longer supported.
de: (Obsolet) LD_PREBIND wird nicht mehr unterstützt.

en: (Obsolete) Object files with LINKEDIT sections are no longer supported.
de: (Veraltet) Objektdateien mit LINKEDIT-Abschnitten werden nicht mehr unterstützt.

en: (Obsolete) This is the default.
de: (Obsolet) Dies ist der Vorgabewert.

en: (Obsolete, ignored)	Old support similar to "-whyload".
de: (Veraltet, ignoriert)	Alte Unterstützung, ähnlich wie »whyload«.

en: (Obsolete, ld_classic only) -sectcreate <segname> <sectname> <file>	Allowed creation of a section from a file.
de: (Obsolet, nur ld_classic) -sectcreate <Segmentname> <Abschnittsname> <Datei>	Hat erlaubt, einen Abschnitt aus einer Datei zu erstellen.

en: (Obsolete, ld_classic only) -seg_addr_table_filename <path>.
de: (Obsolet, nur ld_classic) -seg_addr_table_filename <Pfad>.

en: (a pointer to member can only be formed with %<&%E%>)
de: (ein Zeiger auf ein Element kann nur mit %<»&%E%> erzeugt werden)

en: (an out of class initialization is required)
de: (eine Initialisierung außerhalb der Klasse ist erforderlich)

en: (anonymous namespace)
de: (anonymer Namensraum)

en: (anonymous)
de: (anonym)

en: (if this is not what you intended, make sure the function template has already been declared and add %<<>%> after the function name here)
de: (wenn das nicht beabsichtigt war, stellen Sie sicher, dass das Funktions-Template bereits deklariert wurde, fügen Sie %<<>%> hier hinter dem Funktionsnamen ein)

en: (if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)
de: (bei Verwendung von %<-fpermissive%>, %<-std=c++11%> oder %<-std=gnu++11%> wird G++ den Code akzeptieren)

en: (if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)
de: (mit %<-fpermissive%> wird G++ den Code akzeptieren, aber die Verwendung eines nicht deklarierten Namens ist veraltet)

en: (messages without a matching method signature will be assumed to return %<id%> and accept %<...%> as arguments)
de: (bei Nachrichten ohne eine übereinstimmende Methodensignatur wird angenommen, dass sie %<id%> zurückgeben und %<...%> als Argumente akzeptieren)

en: (near initialization for %qs)
de: (nahe der Initialisierung für %qs)

en: (no argument)
de: (kein Argument)

en: (perhaps %<typename %T::%E%> was intended)
de: (vielleicht war %<typename %T::%E%> beabsichtigt)

en: (perhaps a semicolon is missing after the definition of %qT)
de: (vielleicht fehlt ein Semikolon hinter der Definition von %qT)

en: (so you should pass %qT not %qT to %<va_arg%>)
de: (Es sollte also %qT statt %qT an %<va_arg%> übergeben werden)

en: (static destructors for %s)
de: (statische Destruktoren für %s)

en: (static initializers for %s)
de: (statische Initialisierungen für %s)

en: (the message is displayed only once per source file)
de: (die Meldung wird pro Quelldatei nur einmal angezeigt)

en: ({anonymous})
de: ({anonym})

en: *** WARNING *** there are active plugins, do not report this as a bug unless you can reproduce it without enabling any plugins.
de: *** WARNUNG *** es gibt aktive Plugins – bitte Fehler nur dann melden, wenn diese auch ohne alle Plugins reproduziert werden können.

en: --help=<class>	Display descriptions of a specific class of options.  <class> is one or more of optimizers, target, warnings, undocumented, params.
de: --help=<Klasse>	Beschreibungen für eine bestimmte Klasse von Optionen anzeigen. <Klasse> ist ein oder mehrere Elemente aus optimizers, target, warnings, undocumented, param.

en: --param inline-unit-growth limit reached
de: --param inline-unit-growth: Limit erreicht

en: --param large-function-growth limit reached
de: --param large-function-growth: Limit erreicht

en: --param large-stack-frame-growth limit reached
de: --param large-stack-frame-growth: Limit erreicht

en: --param max-inline-insns-auto limit reached
de: --param max-inline-insns-auto: Limit erreicht

en: --param max-inline-insns-single limit reached
de: --param max-inline-insns-single: Limit erreicht

en: --param=evrp-mode=[legacy|ranger|legacy-first|ranger-first] Specifies the mode Early VRP should operate in.
de: --param=evrp-mode=[legacy|ranger|legacy-first|ranger-first] Gibt an, in welchem Modus Early-VRP arbeiten soll.

en: --param=openacc-kernels=[decompose|parloops]	Specify mode of OpenACC 'kernels' constructs handling.
de: --param=openacc-kernels=[decompose|parloops]	Modus, in dem OpenACC-»kernels«-Konstrukte verarbeitet werden.

en: --param=openacc-privatization=[quiet|noisy]	Specify mode of OpenACC privatization diagnostics.
de: --param=openacc-privatization=[quiet|noisy]	Modus von OpenACC-Privatisierungsmeldungen festlegen.

en: --param=parloops-schedule=[static|dynamic|guided|auto|runtime]	Schedule type of omp schedule for loops parallelized by parloops.
de: --param=parloops-schedule=[static|dynamic|guided|auto|runtime]	Art des OMP-Zeitplans für Schleifen, die durch parloops parallelisiert werden.

en: --param=ranger-debug=[none|trace|gori|cache|tracegori|all] Specifies the output mode for debugging ranger.
de: --param=ranger-debug=[none|trace|gori|cache|tracegori|all]	Ausgabemodus für das Ranger-Debuggen festlegen.

en: --param=threader-debug=[none|all] Enables verbose dumping of the threader solver.
de: --param=threader-debug=[none|all]	Aktiviert das ausführliche Dumping des Threader-Lösers.

en: --param=vrp1-mode=[vrp|ranger] Specifies the mode VRP1 should operate in.
de: --param=vrp1-mode=[vrp|ranger]	Angeben, in welchem Modus VRP1 arbeiten soll.

en: --param=vrp2-mode=[vrp|ranger] Specifies the mode VRP2 should operate in.
de: --param=vrp2-mode=[vrp|ranger]	Gibt an, in welchem Modus VRP2 arbeiten soll.

en: -A<question>=<answer>	Assert the <answer> to <question>.  Putting '-' before <question> disables the <answer> to <question>.
de: -A<Frage>=<Antwort>	Die <Antwort> auf eine <Frage> annehmen. Angabe von »-« vor <Frage> schaltet die <Antwort> auf <Frage> aus.

en: -D<macro>[=<val>]	Define a <macro> with <val> as its value.  If just <macro> is given, <val> is taken to be 1.
de: -D<Makro>[=<Wert>]	Ein <Makro> mit <Wert> definieren. Wenn nur <Makro> angegeben wird, wird <Wert> auf 1 gesetzt.

en: -E or -x required when input is from standard input
de: »-E« oder »-x« benötigt, wenn die Eingabe von der Standardeingabe kommt

en: -F <dir>	Add <dir> to the end of the main framework include path.
de: -F <Verz>	<Verz> an das Ende des Haupt-Einfügepfades des Frameworks anfügen.

en: -G<number>	Put global and static data smaller than <number> bytes into a special section (on some targets).
de: -G<Anzahl>	Globale und statische Daten kleiner als <Anzahl> Bytes in einen gesonderten Abschnitt legen (bei manchen Zielarchitekturen).

en: -Hd <dir>	Write D interface files to directory <dir>.
de: -Hd <Verz>	D-Schnittstellen-Dateien in Verzeichnis <Verz> schreiben.

en: -Hf <file>	Write D interface to <file>.
de: -Hf <Datei>	D-Interface in <Datei> schreiben.

en: -I <dir>	Add <dir> to the end of the main include path.
de: -I <Verz>	<Verz> an das Ende des Haupteinfügepfades anfügen.

en: -J<directory>	Put MODULE files in 'directory'.
de: -J<Verzeichnis>	MODULE-Dateien in »Verzeichnis« ablegen.

en: -MF <file>	Write dependency output to the given file.
de: -MF <Datei>	Abhängigkeiten in angegebene Datei schreiben.

en: -MQ <target>	Add a target that may require quoting.
de: -MQ <Ziel>	Ziel hinzufügen, das möglicherweise Anführungszeichen benötigt.

en: -MT <target>	Add a target that does not require quoting.
de: -MT <Ziel>	Ziel hinzufügen, das keine Anführungszeichen benötigt.

en: -O<number>	Set optimization level to <number>.
de: -O<Zahl>	Optimierungsstufe auf <Zahl> setzen.

en: -U<macro>	Undefine <macro>.
de: -U<Makro>	<Makro>-Definition aufheben.

en: -Waligned-new=[none|global|all]	Warn even if 'new' uses a class member allocation function.
de: -Waligned-new=[none|global|all]	Selbst dann warnen, wenn »new« Klassenelementfunktionen zur Speicherreservierung verwendet.

en: -Walloc-size-larger-than=<bytes>	Warn for calls to allocation functions that attempt to allocate objects larger than the specified number of bytes.
de: -Walloc-size-larger-than=<Bytes>	Bei Aufrufen von Allozierungsfunktionen warnen, mit denen Objekte erzeugt werden, die größer als »Bytes« sind.

en: -Walloca-larger-than=<number>	Warn on unbounded uses of alloca, and on bounded uses of alloca whose bound can be larger than <number> bytes.
de: -Walloca-larger-than=<Anzahl>	Bei Aufrufen von alloca warnen, deren Größe unbeschränkt ist oder deren Größe zwar beschränkt ist, aber mehr als <Anzahl> Bytes betragen kann.

en: -Wbidi-chars=[none|unpaired|any|ucn] Warn about UTF-8 bidirectional control characters.
de: -Wbidi-chars=[none|unpaired|any|ucn] Vor UTF-8 bidirektionalen Steuerzeichen warnen.

en: -Wframe-larger-than=<byte-size>	Warn if a function's stack frame requires in excess of <byte-size>.
de: -Wframe-larger-than=<Größe>	Warnen, wenn der Stapelrahmen einer Funktion mehr als <Größe> Bytes benötigt.

en: -Wlarger-than=<byte-size>	Warn if an object's size exceeds <byte-size>.
de: -Wlarger-than=<Anzahl>	Warnen, wenn ein Objekt größer als <Anzahl> Bytes ist.

en: -Wnormalized=[none|id|nfc|nfkc]	Warn about non-normalized Unicode strings.
de: -Wnormalized=[none|id|nfc|nfkc]	Bei nicht-normalisierten Unicode-Zeichenketten warnen.

en: -Wstack-usage=<byte-size>	Warn if stack usage might exceed <byte-size>.
de: -Wstack-usage=<Größe in Bytes>	Warnen, wenn Stapelverwendung den angegebenen Betrag überschreiten könnte.

en: -Wvla-larger-than=<number>	Warn on unbounded uses of variable-length arrays, and on bounded uses of variable-length arrays whose bound can be larger than <number> bytes.
de: -Wvla-larger-than=<Anzahl>	Bei unbeschränkten Verwendungen von Arrays variabler Länge warnen, und bei Verwendung von Arrays variabler Länge, wenn die Länge <Anzahl> überschreiten kann.

en: -Xbind-now and -Xbind-lazy are incompatible
de: »-Xbind-now« und »-Xbind-lazy« sind unverträglich

en: -Xf <file>	Write JSON output to the given <file>.
de: -Xf <Datei>	JSON-Ausgabe in die angegebene <Datei> schreiben.

en: -allowable_client <name>	The output dylib is private to the client <name>.
de: -allowable_client <Name>	Die ausgegebene dylib ist nur vom Client <Name> verwendbar.

en: -arch <name>	Generate output for architecture <name>.
de: -arch <Name>	Ausgabedatei für die Architektur <Name> erzeugen.

en: -aux-info <file>	Emit declaration information into <file>.
de: -aux-info <Datei>	Deklarationsinformationen in <Datei> ausgeben.

en: -bundle not allowed with -dynamiclib
de: »-bundle« ist nicht mit »-dynamiclib« erlaubt

en: -bundle_loader <executable>	Treat <executable> (that will be loading this bundle) as if it was one of the dynamic libraries the bundle is linked against for symbol resolution.
de: -bundle_loader <Ausführbar>	Die ausführbare Datei <Ausführbar> (die dieses Bundle laden wird) so behandeln, als sei sie eine der dynamischen Bibliotheken, gegen die das Bundle für Symbolauflösung gebunden ist.

en: -bundle_loader not allowed with -dynamiclib
de: »-bundle_loader« ist nicht mit »-dynamiclib« erlaubt

en: -c or -S required for Ada
de: Für Ada wird »-c« oder »-S« benötigt

en: -c required for gnat2scil
de: Für gnat2scil wird -c benötigt

en: -c required for gnat2why
de: Für gnat2why wird »-c« benötigt

en: -client_name <name>	Enable the executable being built to link against a private dylib (using allowable_client).
de: -client_name <Name>	Erlauben, dass die erzeugte ausführbare Datei gegen die private Dylib gebunden werden darf (mit allowable_client).

en: -client_name not allowed with -dynamiclib
de: »-client_name« ist nicht mit »-dynamiclib« erlaubt

en: -compatibility_version <number>	Set the version for the client interface.  Client programs must record a value less than or equal to <number>, or the binding will fail at runtime.
de: -compatibility_version <Nummer>	Minimale Version für das Client-Interface festlegen. Clients müssen diese <Nummer> oder eine größere angeben, oder das Binden wird zur Laufzeit fehlschlagen.

en: -compatibility_version only allowed with -dynamiclib
de: »-compatibility_version« ist nur mit »-dynamiclib« erlaubt

en: -current_version <number>	Set the current version for the library to <number>.
de: -current_version <Nummer>	Aktuelle Version für die Bibliothek auf <Nummer> festlegen.

en: -current_version only allowed with -dynamiclib
de: »-current_version« ist nur mit »-dynamiclib« erlaubt

en: -d<letters>	Enable dumps from specific passes of the compiler.
de: -d<Buchstaben>	Ausgaben von bestimmten Durchläufen des Compilers einschalten.

en: -dumpbase <file>	Set the file basename to be used for dumps.
de: -dumpbase <Datei>	Den Basis-Dateinamen für Ausgaben setzen.

en: -dumpbase-ext .<ext>    Drop a trailing .<ext> from the dump basename to name auxiliary output files.
de: -dumpbase-ext .<Erw>    Die Dateinamenserweiterung .<Erw> weglassen, beim Benennen der hilfsweisen Ausgabedateien.

en: -dumpdir <dir>	Set the directory name to be used for dumps.
de: -dumpdir <Verzeichnis>	Den Basis-Verzeichnisnamen für Ausgaben setzen.

en: -dylib_file install_name:file_name	This allows linking of a dylib with "install_name" but to be found in a different install position "file_name"
de: -dylib_file Installationsname:Dateiname	Dies ermöglicht die Verknüpfung einer Dylib mit »Installationsname«, die aber in einer anderen Installationsposition »Dateiname« zu finden ist

en: -dylinker_install_name <path>	Only used for building dyld.
de: -dylinker_install_name <Pfad>	Wird nur verwendet, um dyld zu bauen.

en: -exported_symbols_list <filename>	Export global symbols in <filename> in linked output file; any symbols not mentioned will be treated as "hidden".
de: -exported_symbols_list <Dateiname>	Globale Symbole in <Dateiname> werden aus der gelinkten Ausgabedatei exportiert, alle nicht erwähnten Symbole werden als versteckt behandelt.

en: -f%s ignored (not supported for DJGPP)
de: -f%s ignoriert (nicht für DJGPP unterstützt)

en: -fada-spec-parent=unit	Dump Ada specs as child units of given parent.
de: -fada-spec-parent=Einheit	Ada-Spezifikationen als Kind-Einheiten der angegebenen Elterneinheit ausgeben.

en: -faligned-new=<N>	Use C++17 over-aligned type allocation for alignments greater than N.
de: -faligned-new=<N>	Überausgerichtete Typallozierung aus C++17 für Typen mit Ausrichtung größer N verwenden.

en: -fasan-shadow-offset=<number>	Use custom shadow memory offset.
de: -fasan-shadow-offset=<Zahl>	Spezifischen Offset für Schattenspeicher verwenden.

en: -fblas-matmul-limit=<n>	Size of the smallest matrix for which matmul will use BLAS.
de: -fblas-matmul-limit=<n>	Größe der kleinsten Matrix, für die matmul BLAS verwendet.

en: -fbounds-check=[on|safeonly|off]	Turn array bounds checks on, in @safe code only, or off.
de: -fbounds-check=[on|safeonly|off]	Array-Grenzprüfungen einschalten, nur in @safe-Code, oder ausschalten.

en: -fcall-saved-<register>	Mark <register> as being preserved across functions.
de: -fcall-saved-<Register>	<Register> als über Funktionsgrenzen hinweg reserviert markieren.

en: -fcall-used-<register>	Mark <register> as being corrupted by function calls.
de: -fcall-used-<Register>	<Register> als durch Funktionsaufrufe beschädigt markieren.

en: -fcf-protection=[full|branch|return|none|check]	Instrument functions with checks to verify jump/call/return control-flow transfer instructions have valid targets.
de: -fcf-protection=[full|branch|return|none|check]	Funktionen mit zusätzlichen Prüfungen versehen, dass die Sprungziele von jump/call/return gültig sind.

en: -fcheck=[...]	Specify which runtime checks are to be performed.
de: -fcheck=[...]	Durchgeführte Laufzeitprüfungen.

en: -fcheckaction=[throw,halt,context]	Behavior on contract failure.
de: -fcheckaction=[throw,halt,context]	Verhalten bei Nichterfüllung eines Vertrags.

en: -fcoarray=<none|single|lib>	Specify which coarray parallelization should be used.
de: -fcoarray=<none|single|lib>	Angeben, welche Koarray-Parallelisierung verwendet wird.

en: -fcompare-debug[=<opts>]	Compile with and without e.g. -gtoggle, and compare the final-insns dump.
de: -fcompare-debug[=<Optionen>]	Mit und ohne z.B. -gtoggle kompilieren, und den Dump der »final-insns« vergleichen.

en: -fconst-string-class=<name>	Use class <name> for constant strings.
de: -fconst-string-class=<Name>	Klasse <Name> für konstante Zeichenketten verwenden.

en: -fconstexpr-cache-depth=<number>	Specify maximum constexpr recursion cache depth.
de: -fconstexpr-cache-depth=<Zahl>	Größte Rekursionstiefe des Caches für konstante Ausdrücke festlegen.

en: -fconstexpr-depth=<number>	Specify maximum constexpr recursion depth.
de: -fconstexpr-depth=<Zahl>	Größte Rekursionstiefe für konstante Ausdrücke angeben.

en: -fconstexpr-loop-limit=<number>	Specify maximum constexpr loop iteration count.
de: -fconstexpr-loop-limit=<Anzahl>	Höchstzahl der Schleifeniterationen für »constexpr« angeben.

en: -fconstexpr-ops-limit=<number>	Specify maximum number of constexpr operations during a single constexpr evaluation.
de: -fconstexpr-ops-limit=<Anzahl>	Höchstzahl der constexpr-Operationen pro einzelner »constexpr« angeben.

en: -fconvert=<big-endian|little-endian|native|swap|r16_ieee|r16_ibm>	The endianness used for unformatted files.
de: -fconvert=<big-endian|little-endian|native|swap|r16_ieee|r16_ibm>	Die Endianess, die für unformatierte Dateien verwendet wird.

en: -fdbg-cnt=<counter>[:<lower_limit1>-]<upper_limit1>[:<lower_limit2>-<upper_limit2>:...][,<counter>:...]	Set the debug counter limit.
de: -fdbg-cnt=<Zähler>[:<Untere Grenze 1>-]<Obere Grenze 1>[:<Untere Grenze 2>-<Obere Grenze 2>:...][,<Zähler>:...]	Obergrenze für Debug-Zähler festlegen.

en: -fdebug-prefix-map=<old>=<new>	Map one directory name to another in debug information.
de: -fdebug-prefix-map=<alt>=<neu>	In Fehlersuchinfo einen Verzeichnisnamen auf einen anderen abbilden.

en: -fdebug=<level|ident>	Compile in debug code, code <= <level>, or code identified by <ident>.
de: -fdebug=<Stufe|Ident>	Debugging-Code der Stufe <= <Stufe> eincompilieren, oder durch <Ident> gekennzeichneten Code.

en: -fdiagnostics-color=[never|always|auto]	Colorize diagnostics.
de: -fdiagnostics-color=[never|always|auto]	Diagnosemeldungen einfärben.

en: -fdiagnostics-column-origin=<number>	Set the number of the first column.  The default is 1-based as per GNU style, but some utilities may expect 0-based, for example.
de: -fdiagnostics-column-origin=<Nummer>	Legt die Nummer der ersten Spalte fest. Die Vorgabe ist gemäß GNU-Stil 1-basiert, aber einige Dienstprogramme erwarten 0-basierte Spaltennummern.

en: -fdiagnostics-column-unit=[display|byte]	Select whether column numbers are output as display columns (default) or raw bytes.
de: -fdiagnostics-column-unit=[display|byte]	Festlegen, ob Spaltennummern als Anzeigespalten (Standard) ausgegeben werden oder in rohen Bytes gemessen werden.

en: -fdiagnostics-escape-format=[unicode|bytes]	Select how to escape non-printable-ASCII bytes in the source for diagnostics that suggest it.
de: -fdiagnostics-escape-format=[unicode|bytes]	Festlegen, wie Zeichen außerhalb des druckbaren ASCII-Bereichs in der Quelle für Diagnosen, die dies vorschlagen, ausgegeben werden sollen.

en: -fdiagnostics-format=[text|json]	Select output format.
de: -fdiagnostics-format=[text|json]	Ausgabeformat auswählen.

en: -fdiagnostics-show-location=[once|every-line]	How often to emit source location at the beginning of line-wrapped diagnostics.
de: -fdiagnostics-show-location=[once|every-line]	Wie oft die Quelltext-Position am Zeilenanfang ausgegeben wird, wenn die Diagnose über mehrere Zeilen geht.

en: -fdiagnostics-urls=[never|always|auto]	Embed URLs in diagnostics.
de: -fdiagnostics-urls=[never|always|auto]	URLs in Diagnosemeldungen einbetten.

en: -fdisable-[tree|rtl|ipa]-<pass>=range1+range2	Disable an optimization pass.
de: -fdisable-[tree|rtl|ipa]-<Durchgang>=range1+range2	Einen Optimierungsdurchgang ausschalten.

en: -fdoc-dir=<dir>	Write documentation file to directory <dir>.
de: -fdoc-dir=<Verz>	Dokumentationsdatei in Verzeichnis <Verz> schreiben.

en: -fdoc-file=<file>	Write documentation to <file>.
de: -fdoc-file=<Datei>	Dokumentation in <Datei> schreiben.

en: -fdoc-inc=<file>	Include a Ddoc macro <file>.
de: -fdoc-inc=<Datei>	Eine Ddoc-Makro-Datei <Datei> inkludieren.

en: -fdump-<type>	Dump various compiler internals to a file.
de: -fdump-<type>	Verschiedene compilerinterne Informationen in eine Datei abziehen.

en: -fdump-cxx-spec=<filename>	Write all declarations as C++ code to <filename>.
de: -fdump-cxx-spec=<Dateiname>	Alle Deklarationen als C++-Code nach <Dateiname> schreiben.

en: -fdump-final-insns=filename	Dump to filename the insns at the end of translation.
de: -fdump-final-insns=<Datei>	Die Befehle am Ende der Übersetzung in Datei abziehen.

en: -fdump-go-spec=filename	Write all declarations to file as Go code.
de: -fdump-go-spec=<Datei>	Alle Deklarationen als Go-Code in <Datei> schreiben.

en: -femit-struct-debug-baseonly	Aggressive reduced debug info for structs.
de: -femit-struct-debug-baseonly	Aggressiv reduzierte Debuginfo für Strukturen.

en: -femit-struct-debug-detailed=<spec-list>	Detailed reduced debug info for structs.
de: -femit-struct-debug-detailed=<spec-list>Ausführliche reduzierte Debuginfo für Strukturen.

en: -femit-struct-debug-reduced	Conservative reduced debug info for structs.
de: -femit-struct-debug-reduced	Konservativ reduzierte Debuginfo für Strukturen.

en: -fenable-[tree|rtl|ipa]-<pass>=range1+range2	Enable an optimization pass.
de: -fenable-[tree|rtl|ipa]-<Durchgang>=range1+range2	Einen Optimierungsdurchgang einschalten.

en: -fexcess-precision=[fast|standard|16]	Specify handling of excess floating-point precision.
de: -fexcess-precision=[fast|standard|16]	Behandlung überschüssiger Gleitkommagenauigkeit bestimmen.

en: -fexec-charset=<cset>	Convert all strings and character constants to character set <cset>.
de: -fexec-charset=<Zeichensatz>	Alle Zeichenketten und Zeichenkonstanten in <Zeichensatz> umwandeln.

en: -fextern-std=<standard>	Set C++ name mangling compatibility with <standard>.
de: -fextern-std=<Standard>	C++-Namensumwandlung kompatibel zu <Standard> machen.

en: -ffile-prefix-map=<old>=<new>	Map one directory name to another in compilation result.
de: -ffile-prefix-map=<alt>=<neu>	In Übersetzungsergebnis einen Verzeichnisnamen auf einen anderen abbilden.

en: -ffixed-<register>	Mark <register> as being unavailable to the compiler.
de: -ffixed-<Register>	<Register> als für den Compiler nicht verfügbar markieren.

en: -ffixed-line-length-<n>	Use n as character line width in fixed mode.
de: -ffixed-line-length-<n>	Im festen Modus n als Zeilenlänge verwenden.

en: -ffp-contract=[off|on|fast]	Perform floating-point expression contraction.
de: -ffp-contract=[off|on|fast]	Schrumpfung von Gleitkommaausdrücken durchführen.

en: -ffpe-summary=[...]	Print summary of floating point exceptions.
de: -ffpe-summary=[…]	Zusammenfassung für Gleitkommaausnahmen ausgeben.

en: -ffpe-trap=[...]	Stop on following floating point exceptions.
de: -ffpe-trap=[…]	Bei folgenden Gleitkommaausnahmen anhalten.

en: -ffree-line-length-<n>	Use n as character line width in free mode.
de: -ffixed-line-length-<n>	Im freien Modus n als Zeilenlänge verwenden.

en: -fgnat-encodings=[all|gdb|minimal]	Select the balance between GNAT encodings and standard DWARF emitted in the debug information.
de: -fgnat-encodings=[all|gdb|minimal]	Gleichgewicht zwischen GNAT-Encodings und Standard-DWARF auswählen, die in den Debuginformationen landen.

en: -fgo-c-header=<file>	Write Go struct definitions to file as C code.
de: -fgo-c-header=<Datei>	Go-struct-Definitionen als C-Code in <Datei> schreiben.

en: -fgo-debug-escape-hash=<string>	Hash value to debug escape analysis.
de: -fgo-debug-escape-hash=<Zeichenkette>	Hashwert zum Debuggen der Escape-Analyse.

en: -fgo-dump-<type>	Dump Go frontend internal information.
de: -fgo-dump-<Typ>	Interne Information des Go-Frontends in Datei ausgeben.

en: -fgo-embedcfg=<file>	List embedded files via go:embed.
de: -fgo-embedcfg=<Datei>	Eingebettete Dateien über go:embed auflisten.

en: -fgo-optimize-<type>	Turn on optimization passes in the frontend.
de: -fgo-optimize-<type>	Optimierungsdurchläufe im Frontend einschalten.

en: -fgo-pkgpath=<string>	Set Go package path.
de: -fgo-pkgpath=<Zeichenkette>	Go-Paketpfad festlegen.

en: -fgo-prefix=<string>	Set package-specific prefix for exported Go names.
de: -fgo-prefix=<Zeichenkette>	Paketspezifisches Präfix für exportierte Go-Namen festlegen.

en: -fgo-relative-import-path=<path>	Treat a relative import as relative to path.
de: -fgo-relative-import-path=<Pfad>	Relativen Import als relativ zum Pfad behandeln.

en: -finit-character=<n>	Initialize local character variables to ASCII value n.
de: -finit-character=<n>	Lokale Zeichenvariablen auf ASCII-Wert n initialisieren.

en: -finit-integer=<n>	Initialize local integer variables to n.
de: -finit-integer=<n>	Lokale Ganzzahlvariablen auf n initialisieren.

en: -finit-logical=<true|false>	Initialize local logical variables.
de: -finit-logical=<true|false>	Lokale logische Variablen initialisieren.

en: -finit-real=<zero|snan|nan|inf|-inf>	Initialize local real variables.
de: -finit-real=<zero|nan|inf|-inf>	Lokale Real-Variablen initialisieren.

en: -finline-arg-packing	Perform argument packing inline.
de: -finline-arg-packing	Argumentpacken inline durchführen.

en: -finline-limit=<number>	Limit the size of inlined functions to <number>.
de: -finline-limit=<Zahl>	Größe von »inline«-Funktionen auf <Zahl> beschränken.

en: -finline-matmul-limit=<n>	Specify the size of the largest matrix for which matmul will be inlined.
de: -finline-matmul-limit=<n>	Größe der größten Matrix, für die matmul geinlinet wird.

en: -finput-charset=<cset>	Specify the default character set for source files.
de: -finput-charset=<Zeichensatz>	Standard-Zeichensatz für Quelldateien angeben.

en: -finstrument-functions-exclude-file-list=filename,...	Do not instrument functions listed in files.
de: -finstrument-functions-exclude-file-list=filename,…	In den Dateien aufgezählte Funktionen nicht instrumentieren.

en: -finstrument-functions-exclude-function-list=name,...	Do not instrument listed functions.
de: -finstrument-functions-exclude-function-list=name,…	Aufgezählte Funktionen nicht instrumentieren.

en: -fira-algorithm=[CB|priority]	Set the used IRA algorithm.
de: -fira-algorithm=[CB|priority]	Verwendeten IRA-Algorithmus festlegen.

en: -fira-region=[one|all|mixed]	Set regions for IRA.
de: -fira-region=[one|all|mixed]	Regionen für IRA festlegen.

en: -fira-verbose=<number>	Control IRA's level of diagnostic messages.
de: -fira-verbose=<Zahl<	Stufe der IRA Diagnosemeldungen steuern.

en: -flive-patching=[inline-only-static|inline-clone]	Control IPA optimizations to provide a safe compilation for live-patching.  At the same time, provides multiple-level control on the enabled IPA optimizations.
de: -flive-patching=[inline-only-static|inline-clone]	Funktionsübergreifende Optimierung steuern, um für Live-Patching geeigneten Code zu erzeugen. Bietet gleichzeitig mehrstufige Kontrolle bezüglich der ausgewählten funktionsübergreifenden Optimierungen.

en: -flto-compression-level=<number>	Use zlib/zstd compression level <number> for IL.
de: -flto-compression-level=<Stufe>	zlib/zstd-Kompressionsstufe <Stufe> für IL verwenden.

en: -fmacro-prefix-map=<old>=<new>	Map one directory name to another in __FILE__, __BASE_FILE__, and __builtin_FILE().
de: -fmacro-prefix-map=<alt>=<neu>	Einen Verzeichnisnamen auf einen anderen umschreiben in __FILE__, __BASE_FILE__ und __builtin_FILE().

en: -fmax-array-constructor=<n>	Maximum number of objects in an array constructor.
de: -fmax-array-constructor=<n>	Höchstzahl der Objekte in einem Feldkonstruktor.

en: -fmax-errors=<number>	Maximum number of errors to report.
de: -fmax-errors=<Anzahl>	Höchstzahl der zu meldenden Fehler.

en: -fmax-identifier-length=<n>	Maximum identifier length.
de: -fmax-identifier-length=<n>	Größte Bezeichnerlänge.

en: -fmax-stack-var-size=<n>	Size in bytes of the largest array that will be put on the stack.
de: -fmax-stack-var-size=<n>	Größe des größten Feldes, das auf dem Stapel abgelegt wird, in Bytes.

en: -fmax-subrecord-length=<n>	Maximum length for subrecords.
de: -fmax-subrecord-length=<n>	Größte Länge für Teildatensätze.

en: -fmessage-length=<number>	Limit diagnostics to <number> characters per line.  0 suppresses line-wrapping.
de: -fmessage-length=<Anzahl>	Diagnosemeldungen auf <Anzahl> Zeichen pro Zeile beschränken. 0 unterdrückt Zeilenumbruch.

en: -fmodule-file=<package.module>=<filespec>	use <filespec> as source file for <package.module>.
de: -fmodule-file=<package.module>=<Dateiang>	Dateiangabe <Dateiang> als Quelldatei für <package.module> verwenden.

en: -fno-threadsafe-statics	Do not generate thread-safe code for initializing local statics.
de: -fno-threadsafe-statics	Keinen threadsicheren Code für Initialisierung lokaler statischer Objekte erzeugen.

en: -foffload-abi=[lp64|ilp32]	Set the ABI to use in an offload compiler.
de: -foffload-abi=[lp64|ilp32]	Festlegen, welche ABI in einem Offload-Compiler verwendet wird.

en: -foffload-options=<targets>=<options>	Specify options for the offloading targets.
de: -foffload-options=<Ziele>=<Optionen>	Offloading-Ziele und deren Optionen angeben.

en: -fopt-info[-<type>=filename]	Dump compiler optimization details.
de: -fopt-info[-<Typ>=Dateiname]	Optimierungsdetails des Compilers ausgeben.

en: -force_flat_namespace not allowed with -dynamiclib
de: »-force_flat_namespace« ist nicht mit »-dynamiclib« erlaubt

en: -fpack-struct=<number>	Set initial maximum structure member alignment.
de: -fpack-struct=<Zahl>	Anfängliche größte Ausrichtung für Strukturelemente festlegen.

en: -fpermitted-flt-eval-methods=[c11|ts-18661]	Specify which values of FLT_EVAL_METHOD are permitted.
de: -fpermitted-flt-eval-methods=[c11|ts-18661]	Angeben, welche Werte von FLT_EVAL_METHOD erlaubt sind.

en: -fplugin-arg-<name>-<key>[=<value>]	Specify argument <key>=<value> for plugin <name>.
de: -fplugin-arg-<Name>-<Schlüssel>[=<Wert>]	Argument <Schlüssel>=<Wert> für Plugin <Name> angeben.

en: -fprofile-prefix-map=<old>=<new>	Map one directory name to another in GCOV coverage result.
de: -fprofile-prefix-map=<alt>=<neu>	In der Ausgabe von GCOV einen Verzeichnisnamen auf einen anderen abbilden.

en: -fprofile-reproducible=[serial|parallel-runs|multithreaded]	Control level of reproducibility of profile gathered by -fprofile-generate.
de: -fprofile-reproducible=[serial|parallel-runs|multithreaded]	Stufe für die Reproduzierbarkeit des mit »-fprofile-generate« generierten Profils festlegen.

en: -fprofile-update=[single|atomic|prefer-atomic]	Set the profile update method.
de: -fprofile-update=[single|atomic|prefer-atomic]	Methode für Profilupdates festlegen.

en: -framework <name>	The linker should search for the framework <name> in the framework search path.
de: -framework <Name>	Das Framework <Name> im Pfad für Frameworks suchen.

en: -frandom-seed=<string>	Make compile reproducible using <string>.
de: -frandom-seed=<Zeichenkette>	Übersetzung mit <Zeichenkette> reproduzierbar machen.

en: -freorder-blocks-algorithm=[simple|stc]	Set the used basic block reordering algorithm.
de: -freorder-blocks-algorithm=[simple|stc]	Algorithmus zum Umordnen der Basisblöcke festlegen.

en: -fsanitize-sections=<sec1,sec2,...>	Sanitize global variables in user-defined sections.
de: -fsanitize-sections=<sec1,sec2,...>	Globale Variablen in benutzerdefinierten Abschnitten bereinigen.

en: -fsanitize=address is not supported in this configuration
de: -fsanitize=address wird in dieser Konfiguration nicht unterstützt

en: -fsave-mixins=<filename>	Expand and save mixins to file specified by <filename>.
de: -fsave-mixins=<Dateiname>	Mixins expandieren und in <Dateiname> speichern.

en: -fsched-stalled-insns-dep=<number>	Set dependence distance checking in premature scheduling of queued insns.
de: -fsched-stalled-insns-dep=<Zahl>	Abhängigkeitsentfernung für Prüfung in nicht ausgereifter Planung von eingereihten Befehlen festlegen.

en: -fsched-stalled-insns=<number>	Set number of queued insns that can be prematurely scheduled.
de: -fsched-stalled-insns=<Anzahl>	Anzahl der eingereihten Befehle festlegen, die unausgereift geplant werden können.

en: -fsched-verbose=<number>	Set the verbosity level of the scheduler.
de: -fsched-verbose=<Stufe>	Stufe der Wortfülle des Planers angeben.

en: -fsimd-cost-model=[unlimited|dynamic|cheap|very-cheap]	Specifies the vectorization cost model for code marked with a simd directive.
de: -fsimd-cost-model=[unlimited|dynamic|cheap|very-cheap]	Vektorisierungs-Kostenmodell angeben, das für mit einer SIMD-Direktive markierten Code verwendet wird.

en: -fsso-struct=[big-endian|little-endian|native]	Set the default scalar storage order.
de: -fsso-struct=[big-endian|little-endian|native]	Standardspeicherreihenfolge für Skalare festlegen.

en: -fstack-check=[no|generic|specific]	Insert stack checking code into the program.
de: -fstack-check=[no|generic|specific]	Code zur Stapelprüfung in das Programm einfügen.

en: -fstack-limit-register=<register>	Trap if the stack goes past <register>.
de: -fstack-limit-register=<Register>	Wenn der Stapel über <Register> hinausgeht, abfangen (»trap«).

en: -fstack-limit-symbol=<name>	Trap if the stack goes past symbol <name>.
de: -fstack-limit-symbol=<Name>	Wenn der Stapel über das Symbol <Name> hinausgeht, abfangen (»trap«).

en: -fstack-reuse=[all|named_vars|none]	Set stack reuse level for local variables.
de: -fstack-reuse=[all|named_vars|none]	Stufe der Stapel-Wiederverwendung für lokale Variablen festlegen.

en: -ftabstop=<number>      Distance between tab stops for column reporting.
de: -ftabstop=<Zahl>        Abstand zwischen Tabstopps für Spaltenmeldungen.

en: -ftemplate-depth=<number>	Specify maximum template instantiation depth.
de: -ftemplate-depth=<Zahl>	Größte Template-Instanziierungstiefe angeben.

en: -ftls-model=[global-dynamic|local-dynamic|initial-exec|local-exec]	Set the default thread-local storage code generation model.
de: -ftls-model=[global-dynamic|local-dynamic|initial-exec|local-exec]	Das standardmäßige Codeerzeugungsmodell für Thread-lokalen Speicher angeben.

en: -ftrack-macro-expansion=<0|1|2>	Track locations of tokens coming from macro expansion and display them in error messages.
de: -ftrack-macro-expansion=<0|1|2>	Orte der aus der Makroersetzung entstehenden Token verfolgen und sie in Fehlermeldungen anzeigen.

en: -ftree-parallelize-loops=<number>	Enable automatic parallelization of loops.
de: -ftree-parallelize-loops=<Anzahl>	Automatische Parallelisierung von Schleifen einschalten.

en: -ftrivial-auto-var-init=[uninitialized|pattern|zero]	Add initializations to automatic variables.
de: -ftrivial-auto-var-init=[uninitialized|pattern|zero]	Automatische Variablen initialisieren.

en: -fuse-linker-plugin is not supported in this configuration
de: -fuse-linker-plugin wird in dieser Konfiguration nicht unterstützt

en: -fvect-cost-model=[unlimited|dynamic|cheap|very-cheap]	Specifies the cost model for vectorization.
de: -fvect-cost-model=[unlimited|dynamic|cheap|very-cheap]	Kostenmodell für Vektorisierung angeben.

en: -fversion=<level|ident>	Compile in version code >= <level> or identified by <ident>.
de: -fversion=<Stufe|Ident>	Versionscode >= <Stufe> oder durch <Ident> gekennzeichneten Code mitcompilieren.

en: -fvisibility=[default|internal|hidden|protected]	Set the default symbol visibility.
de: -fvisibility=[default|internal|hidden|protected]	Standard-Symbolsichtbarkeit festlegen.

en: -fvisibility=[private|protected|public|package]	Set the default symbol visibility.
de: -fvisibility=[private|protected|public|package]	Standard-Symbolsichtbarkeit festlegen.

en: -fvtable-verify=preinit is not supported in this configuration
de: -fvtable-verify=preinit wird in dieser Konfiguration nicht unterstützt

en: -fvtable-verify=std is not supported in this configuration
de: -fvtable-verify=std wird in dieser Konfiguration nicht unterstützt

en: -fwide-exec-charset=<cset>	Convert all wide strings and character constants to character set <cset>.
de: -fwide-exec-charset=<Zeichensatz>	Alle Wide-Zeichenketten und -konstanten in Zeichensatz <Zeichensatz> umwandeln.

en: -gnat<options>	Specify options to GNAT.
de: -gnat<Optionen>	Optionen für GNAT angeben.

en: -gz is not supported in this configuration
de: -gz wird in dieser Konfiguration nicht unterstützt

en: -gz=<format>	Generate compressed debug sections in format <format>.
de: -gz=<Format>	Komprimierte Debugabschnitte im Format <Format> erzeugen.

en: -gz=zlib is not supported in this configuration
de: -gz=zlib wird in dieser Konfiguration nicht unterstützt

en: -idirafter <dir>	Add <dir> to the end of the system include path.
de: -idirafter <Verzeichnis>	<Verzeichnis> an das Ende des System-Einfügepfades anfügen.

en: -iframework <dir>	Add <dir> to the end of the system framework include path.
de: -iframework <Verz>	<Verz> an das Ende des Einfügepfades des System-Frameworks anfügen.

en: -imacros <file>	Accept definition of macros in <file>.
de: -imacros <Datei>	Definition von Makros in <Datei> akzeptieren.

en: -image_base <address>	Specify <address> as the base address for a dylib or bundle.
de: -image_base <Adresse>	Basisadresse für eine Dylib oder ein Bundle festlegen.

en: -imultiarch <dir>	Set <dir> to be the multiarch include subdirectory.
de: -imultiarch <Verzeichnis>	<Verzeichnis> als Multiarch-include-Verzeichnis festlegen.

en: -imultilib <dir>	Set <dir> to be the multilib include subdirectory.
de: -imultilib <Verzeichnis>	<Verzeichnis> als Multilib-include-Verzeichnis setzen.

en: -include <file>	Include the contents of <file> before other files.
de: -include <Datei>	Inhalt von <Datei> vor anderen Dateien einfügen.

en: -init <symbol_name>	The symbol <symbol_name> will be used as the first initialiser for a dylib.
de: -init <Symbolname>	Das Symbol <Symbolname> wird als erster Initialisierer für eine Dylib verwendet.

en: -install_name <name>	Set the install name for a dylib.
de: -install_name <Name>	Legt den Installationsnamen für eine Dylib fest.

en: -install_name only allowed with -dynamiclib
de: »-install_name« ist nur mit »-dynamiclib« erlaubt

en: -iplugindir=<dir>	Set <dir> to be the default plugin directory.
de: -iplugindir=<Verz>	<Verz> als Standard-Plugin-Verzeichnis festlegen.

en: -iprefix <path>	Specify <path> as a prefix for next two options.
de: -iprefix <Pfad>	<Pfad> als ein Präfix für die nächsten zwei Optionen angeben.

en: -iquote <dir>	Add <dir> to the end of the quote include path.
de: -iquote <Verzeichnis>	<Verzeichnis> am Ende des Einfügepfades für »#include "…"« anfügen.

en: -isysroot <dir>	Set <dir> to be the system root directory.
de: -isysroot <Verzeichnis>	<Verzeichnis> als System-Wurzelverzeichnis setzen.

en: -isystem <dir>	Add <dir> to the start of the system include path.
de: -isystem <Verzeichnis>	<Verzeichnis> an den Anfang des System-Einfügepfades anfügen.

en: -iwithprefix <dir>	Add <dir> to the end of the system include path.
de: -iwithprefix <Verzeichnis>	<Verzeichnis> an das Ende des System-Einfügepfades anfügen.

en: -iwithprefixbefore <dir>	Add <dir> to the end of the main include path.
de: -iwithprefixbefore <Verz>	<Verz> an das Ende des Haupt-Einfügepfades anfügen.

en: -keep_private_externs not allowed with -dynamiclib
de: »-keep_private_externs« ist mit »-dynamiclib« nicht erlaubt

en: -mabi=ABI	Generate code that conforms to the given ABI.
de: -mabi=ABI	Code erzeugen, der zum angegebenen ABI passt.

en: -mabi=BASEABI	Generate code that conforms to the given BASEABI.
de: -mabi=<Basis-ABI>	Code erzeugen, der zur angegebenen Basis-ABI passt.

en: -mabs=MODE	Select the IEEE 754 ABS/NEG instruction execution mode.
de: -mabs=MODUS	Den Modus für IEEE-754-ABS/NEG-Befehle auswählen.

en: -march=	Generate code for given RISC-V ISA (e.g. RV64IM).  ISA strings must be lower-case.
de: -march=	Code für die angegebene RISC-V-ISA (z.B. RV64IM) erzeugen. ISA-Zeichenketten müssen in Kleinbuchstaben angegeben werden.

en: -march=ARCH	Generate code for the specified chip or CPU version.
de: -march=ARCH	Code für die angegebene Chip- oder CPU-Version erzeugen.

en: -march=ISA	Generate code for the given ISA.
de: -march=ISA	Code für das gegebene ISA erzeugen.

en: -march=PROCESSOR	Generate code for the given PROCESSOR ISA.
de: -march=<Prozessor>	Code für die angegebene <Prozessor>-ISA erzeugen.

en: -mas100-syntax is incompatible with -gdwarf
de: »-mas100-syntax« ist unverträglich mit »-gdwarf«

en: -mbig-endian and -mlittle-endian may not be used together
de: »-mbig-endian« und »-mlittle-endian« dürfen nicht zusammen verwendet werden

en: -mbranch-cost=COST	Set the cost of branches to roughly COST instructions.
de: -mbranch-cost=KOSTEN	Sprungkosten auf ungefähr KOSTEN Befehle setzen.

en: -mbranch-cost=N	Set the cost of branches to roughly N instructions.
de: -mbranch-cost=N	Sprungkosten auf ungefähr N Befehle setzen.

en: -mcall-ABI	Select ABI calling convention.
de: -mcall-ABI	ABI-Aufrufkonvention auswählen.

en: -mcode-readable=SETTING	Specify when instructions are allowed to access code.
de: -mcode-readable=SETTING	Angeben, wann Befehle zum Codezugriff erlaubt sind.

en: -mcode-region requires the large memory model (-mlarge)
de: »-mcode-region« benötigt das large-Speichermodell (»-mlarge«)

en: -mcpu=	Use features of and schedule code for given CPU.
de: -mcpu=	Eigenschaften der angegebenen CPU verwenden und entsprechend Code planen.

en: -mcpu=CPU	Compile code for ARC variant CPU.
de: -mcpu=CPU	Code für ARC-Variante CPU planen.

en: -mcpu=CPU	Use features of and schedule code for given CPU.
de: -mcpu=CPU	Eigenschaften der angegebenen CPU verwenden und entsprechend Code planen.

en: -mcpu=PROCESSOR		Use features of and schedule code for given CPU.
de: -mcpu=CPU		Eigenschaften der gegebenen CPU verwenden und entsprechend Code planen.

en: -mcpu=PROCESSOR	Use architecture of and optimize the output for PROCESSOR.
de: -mcpu=PROZESSOR	Architektur von PROZESSOR verwenden und die Ausgabe dafür optimieren.

en: -mcpu=m16c	Compile code for M16C variants.
de: -mcpu=m16c	Code für M16C-Varianten kompilieren.

en: -mcpu=m32c	Compile code for M32C variants.
de: -mcpu=m32c	Code für M32C-Varianten kompilieren.

en: -mcpu=m32cm	Compile code for M32CM variants.
de: -mcpu=m32cm	Code für M32CM-Varianten kompilieren.

en: -mcpu=r8c	Compile code for R8C variants.
de: -mcpu=r8c	Code für R8C-Varianten kompilieren.

en: -mdata-region requires the large memory model (-mlarge)
de: »-mdata-region« benötigt das large-Speichermodell (»-mlarge«)

en: -mdebug=	Enable debug output.
de: -mdebug=	Ausgaben zur Fehlersuche einschalten.

en: -mdouble=<BITS>	Use <BITS> bits wide double type.
de: -mdouble=<Bits>	Einen <Bits> breiten Typ für »double« verwenden.

en: -memregs=	Number of memreg bytes (default: 16, range: 0..16).
de: -memregs=	Anzahl der Memreg-Bytes (Standard: 16, Bereich: 0..16).

en: -mflush-func=FUNC	Use FUNC to flush the cache before calling stack trampolines.
de: -mflush-func=FUNC	FUNC verwenden, um den Cache zu entleeren, bevor Stapel-Trampoline aufgerufen werden.

en: -mfpu=FPU	Generate code for the given FPU.
de: -mfpu=FPU	Code für die angegebene FPU erzeugen.

en: -mhard-float not supported
de: -mhard-float wird nicht unterstützt

en: -mipsN	Generate code for ISA level N.
de: -mipsN	Code für ISA Stufe N erzeugen.

en: -mlarge-data-threshold=<number>	Data greater than given threshold will go into .ldata section in x86-64 medium model.
de: -mlarge-data-threshold=<Anzahl>	Daten größer als angegebener Schwellwert werden in .ldata-Abschnitt im x86-64 Medium-Modell gehen.

en: -mlong-double=<BITS>	Use <BITS> bits wide long double type.
de: -mlong-double=<Bits>	Einen <Bits> breiten Typ für »long double« verwenden.

en: -mmax-inline-memcpy-size=SIZE	Set the max size of memcpy to inline, default is 1024.
de: -mmax-inline-memcpy-size=SIZE	Die maximale Größe von inline-memcpy festlegen, Standard ist 1024.

en: -mmax-stackframe=SIZE	Warn when a stackframe is larger than the specified size.
de: -mmax-stackframe=GRÖẞE	Warnen, wenn ein Stapelrahmen größer als die angegebene Größe ist.

en: -mmcu=MCU	Select the target MCU.
de: -mmcu=MCU	Die Ziel-MCU auswählen.

en: -mmcu=MCU	Select the target System-On-Chip variant that embeds this PRU.
de: -mmcu=MCU	Ziel-System-On-Chip-Variante auswählen, die diese PRU einbettet.

en: -mmpy-option=MPY	Compile ARCv2 code with a multiplier design option.
de: -mmpy-option=MPY	ARCv2-Code mit einer Option für das Multiplizierer-Design kompilieren.

en: -mnan=ENCODING	Select the IEEE 754 NaN data encoding.
de: -mnan=CODIERUNG	Datencodierung für IEEE-754-NaN angeben.

en: -mno-serialize-volatile	Do not serialize volatile memory references with MEMW instructions.
de: -mno-serialize-volatile	»volatile«-Speicherreferenzen nicht mit MEMW-Befehlen serialisieren.

en: -moverride=<string>	Power users only! Override CPU optimization parameters.
de: -moverride=<Zeichenkette>	Nur für Powernutzer! CPU-Optimierungsparameter übersteuern.

en: -mpointer-size=[no,32,short,64,long]	Set the default pointer size.
de: -mpointer-size=[no,32,short,64,long]	Standardgröße für Zeiger festlegen.

en: -mr10k-cache-barrier=SETTING	Specify when r10k cache barriers should be inserted.
de: -mr10k-cache-barrier=EINSTELLUNG	Angabe, wann r10k-Cachegrenzen eingefügt werden sollen.

en: -msdata=[none,data,sysv,eabi]	Select method for sdata handling.
de: -msdata=[none,data,sysv,eabi]	Methode für sdata-Behandlung auswählen.

en: -msim	Use simulator runtime.
de: -msim	Simulator-Laufzeitumgebung verwenden.

en: -msingle-float and -msoft-float cannot both be specified
de: »-msingle-float« und »-msoft-float« dürfen nicht zusammen angegeben werden

en: -msmall-data-limit=N	Put global and static data smaller than <number> bytes into a special section (on some targets).
de: -msmall-data-limit=N	Globale und statische Daten kleiner als <N> Bytes in einen gesonderten Abschnitt legen (bei manchen Zielarchitekturen).

en: -mstack-size=<number>	Set the private segment size per wave-front, in bytes.
de: -mstack-size=<Anzahl>	Größe des privaten Segments pro Wellenfront festlegen, in Bytes.

en: -msve-vector-bits=<number>	Set the number of bits in an SVE vector register.
de: -msve-vector-bits=<Anzahl>	Anzahl der Bits in einem SVE-Vektorregister festlegen.

en: -mtarget-linker <version>	Specify that ld64 <version> is the toolchain linker for the current invocation.
de: -mtarget-linker <Version>	ld64 <Version> als Toolchain-Linker für den aktuellen Aufruf festlegen.

en: -mtls-size=[16,32]	Specify bit size of immediate TLS offsets.
de: -mtls-size=[16,32]	Bit-Breite des unmittelbaren TLS-Offsets angeben.

en: -mtraceback=[full,part,no]	Select type of traceback table.
de: -mtraceback=[full,part,no]	Art der Traceback-Tabelle wählen (vollständig, teilweise, keine).

en: -mtune=	Schedule code for given CPU.
de: -mtune=	Code für die angegebene CPU planen.

en: -mtune=ARCH	Tune alignment for the specified chip or CPU version.
de: -mtune=ARCH	Ausrichtung für angegebene Chip- oder CPU-Version optimieren.

en: -mtune=PROCESSOR	Generate optimized code for PROCESSOR.
de: -mtune=<Prozessor>	Code für <Prozessor> optimieren.

en: -mtune=PROCESSOR	Optimize the output for PROCESSOR.
de: -mtune=PROZESSOR	Ausgabe für PROZESSOR optimieren.

en: -mtune=TUNE	Tune code for given ARC variant.
de: -mcpu=TUNE	Code für angegebene ARC-Variante feintunen.

en: -mx32 is not supported on Solaris
de: %<-mx32%> wird unter Solaris nicht unterstützt

en: -o <file>	Place output into <file>.
de: -o <Datei>	Ausgabe in <Datei> schreiben.

en: -pagezero_size <size>	Allows setting the page 0 size to 4kb when required.
de: -pagezero_size <Größe>	Erlaubt es, die Größe der Seite 0 für bestimmte Sonderfälle auf 4 kB festzulegen.

en: -pg and -fomit-frame-pointer are incompatible
de: »-pg« und »-fomit-frame-pointer« sind unverträglich

en: -pie is not supported in this configuration
de: -pie wird in dieser Konfiguration nicht unterstützt

en: -private_bundle not allowed with -dynamiclib
de: »-private_bundle« ist mit »-dynamiclib« nicht erlaubt

en: -read_only_relocs <treatment>	Allow relocations in read-only pages (not recommended).
de: -read_only_relocs <Behandlung>	Dies ermöglicht Codeverschiebungen in schreibgeschützten Seiten (nicht ratsam).

en: -sectalign <segname> <sectname> <value>	Set section <sectname> in segment <segname> to have alignment <value> which must be an integral power of two expressed in hexadecimal form.
de: -sectalign <Segmentname> <Abschnittsname> <Wert>	Festlegen, dass der genannte Abschnitt im genannten Segment die genannte Ausrichtung hat. Die Ausrichtung muss eine Zweierpotenz in hexadezimaler Form sein.

en: -sectcreate <segname> <sectname> <file>	Create section <sectname> in segment <segname> from the contents of <file>.
de: -sectcreate <Segmentname> <Abschnittsname> <Datei>	Den genannten Abschnitt im genannten Segment aus der angegebenen Datei erstellen.

en: -seg_addr_table <file>	Specify the base addresses for dynamic libraries; <file> contains a line for each library.
de: -seg_addr_table <Datei>	Basisadressen für dynamische Bibliotheken festlegen, <Datei> enthält eine Zeile für jede Bibliothek.

en: -segaddr <name> <address>	Set the base address of segment <name> to <address> which must be aligned to a page boundary (currently 4kb).
de: -segaddr <Name> <Adresse>	Basisadresse des Segments <Name> auf <Adresse>festlegen. Die Adresse muss an einer Seitenbegrenzung ausgerichtet sein (derzeit 4 kB).

en: -segprot <segname> <max_prot> <init_prot>	The virtual memory protections for segment <segname> have maximum and initial values <max_prot> and <init_prot> respectively.  The specified values may contain "r", "w", "x" or "-" the latter meaning "no access".
de: -segprot <Segmentname> <Max-Schutz> <Init-Schutz>	Die Schutzwerte für virtuellen Speicher für das Segment <Segmentname> haben die maximalen und initialen Werte <Max-Schutz> und <Init-Schutz>. Als Werte sind »r«, »w«, »x« oder »-« möglich, letzteres bedeutet »kein Zugriff«.

en: -segs_read_only_addr <address>	Specify that <address> is the base address of the read-only segments of a dylib.
de: -segs_read_only_addr <Adresse>	Adresse des schreibgeschützten Teils einer Dylib festlegen.

en: -segs_read_write_addr <address>	Specify that <address> is the base address address of the read-write segments of a dylib.
de: -segs_read_write_addr <Adresse>	Die <Adresse> als Basisadresse des Lese-/Schreibteils einer Dylib festlegen.

en: -stdlib=[libstdc++|libc++]	The standard library to be used for C++ headers and runtime.
de: -stdlib=[libstdc++|libc++]	Die Standardbibliothek, die für C++-Header und Laufzeit verwendet wird.

en: -sub_library <name>	Library named <name> will be re-exported (only useful for dylibs).
de: -sub_library <Name>	Die Bibliothek <Name> wird wieder-exportiert (nur für Dylibs sinnvoll).

en: -sub_umbrella <name>	Framework named <name> will be re-exported (only useful for dylibs).
de: -sub_umbrella <Name>	Das Framework <Name> wird wieder-exportiert (nur für Dylibs sinnvoll).

en: -trigraphs	Support ISO C trigraphs.
de: -trigraphs	Trigraphen nach ISO C unterstützen.

en: -umbrella <framework>	The specified framework will be re-exported.
de: -umbrella <Framework>	Das angegebene Framework wird re-exportiert.

en: -undefined <treatment>	Specify the handling for undefined symbols (default is error).
de: -undefined <Auswirkung>	Auswirkung von undefinierten Symbolen festlegen (Vorgabewert ist »error«).

en: -unexported_symbols_list <filename>	Do not export the global symbols listed in <filename>.
de: -unexported_symbols_list <Datei>	Globale Symbole, die in <Datei> aufgelistet sind, nicht exportieren.

en: -weak_reference_mismatches <treatment>	Specifies what to do if a symbol import conflicts between file (weak in one and not in another) the default is to treat the symbol as non-weak.
de: -weak_reference_mismatches <Auswirkung>	Auswirkung von Symbol-Importkonflikten zwischen Dateien (schwach in der einen und nicht in der anderen) festlegen. Vorgabewert ist, das Symbol als nicht »weak« zu behandeln.

en: ... this enumerator %qD
de: ... diesem Aufzählungswert %qD

en: ... to the previous %qs clause here
de: … zur vorherigen %qs-Klausel hier

en: ... with %qs clause here
de: … mit %qs-Klausel hier

en: ... without %qs clause near to here
de: … ohne %qs-Klausel hier in der Nähe

en: ...following parameter %P which has a default argument
de: ... folgt auf Parameter %P, der ein Defaultargument hat

en: ...this statement, but the latter is misleadingly indented as if it were guarded by the %qs
de: … diese Anweisung, aber letztere ist verwirrend eingerückt, als wäre sie abhängig von %qs

en: .NOT. operator in expression at %L must have a LOGICAL operand
de: .NOT.-Operator in Ausdruck bei %L muss einen LOGICAL-Operanden haben

en: .XOR. operator at %C
de: .XOR.-Operator bei %C

en: /* Prototypes for external procedures generated from %s
       by GNU Fortran %s%s.
    
       Use of this interface is discouraged, consider using the
       BIND(C) feature of standard Fortran instead.  */
de: /* Prototypen für externe Prozeduren, generiert aus %s
       von GNU Fortran %s%s.
    
       Die Verwendung dieser Schnittstelle wird nicht empfohlen,
       verwenden Sie besser das BIND(C)-Feature, das standardmäßig
       in Fortran angeboten wird. */

en: 128-bit %<long double%> not supported for VAX floats
de: 128-bit %<long double%> wird für VAX floats nicht unterstützt

en: 31 bit ABI.
de: 31-Bit-ABI.

en: 387 instruction set disabled, using SSE arithmetics
de: 387-Befehlssatz ausgeschaltet, es wird SSE-Arithmetik verwendet

en: 64 bit ABI.
de: 64-Bit-ABI.

en: 64-bit ABI not supported in ESA/390 mode
de: 64-Bit-ABI nicht unterstützt im ESA/390-Modus

en: ; use assignment instead
de: ; verwenden Sie stattdessen eine Zuweisung

en: ; use assignment or value-initialization instead
de: ; verwenden Sie stattdessen eine Zuweisung oder Wertinitialisierung

en: ; use copy-assignment instead
de: ; verwenden Sie stattdessen eine Kopierzuweisung

en: ; use copy-assignment or copy-initialization instead
de: ; verwenden Sie stattdessen eine Kopierzuweisung oder Kopierinitialisierung

en: ; use copy-initialization instead
de: ; verwenden Sie stattdessen eine Kopierinitialisierung

en: ; use value-initialization instead
de: ; verwenden Sie stattdessen eine Wertinitialisierung

en: <During initialization>
de: <Während Initialisierung>

en: <anonymous>
de: <anonym>

en: <brace-enclosed initializer list>
de: <geschweift geklammerte Initialisierungsliste>

en: <built-in>
de: <eingebaut>

en: <command-line>
de: <Kommandozeile>

en: <declaration error>
de: <Deklarationsfehler>

en: <enumerator>
de: {Aufzählung}

en: <erroneous-expression>
de: <fehlerhafter-Ausdruck>

en: <expression error>
de: <Ausdrucksfehler>

en: <message unknown at compile time>
de: <Meldung nicht zur Compilierzeit bekannt>

en: <missing>
de: <fehlt>

en: <return value>
de: <Rückgabewert>

en: <return-value>
de: <Rückgabewert>

en: <statement>
de: <Anweisung>

en: <structured bindings>
de: <strukturierte Bindungen>

en: <tag-error>
de: <Markierungsfehler>

en: <template arguments error>
de: <Template-Argumente-Fehler>

en: <template parameter error>
de: <Template-Parameter-Fehler>

en: <throw-expression>
de: <throw-Ausdruck>

en: <type error>
de: <Typfehler>

en: <type-error>
de: <Typ-Fehler>

en: <typedef-error>
de: <typedef-Fehler>

en: <typeprefixerror>
de: <Typpräfixfehler>

en: <ubsan routine call>
de: <ubsan-Unterprogramm-Aufruf>

en: <unknown operator>
de: <unbekannter Operator>

en: <unknown>
de: <unbekannt>

en: <unnamed %s>
de: <unbenanntes %s>

en: <unnamed-fixed:
de: <unbenannt-Festkomma:

en: <unnamed-float:
de: <unbenannt-Gleitkomma:

en: <unnamed-unsigned:
de: <unbenannt-vorzeichenlos:

en: <unnamed>
de: <unbenannt>

en: <unparsed>
de: <nicht-analysiert>

en: <unresolved overloaded function type>
de: <unaufgelöster überladener Funktionstyp>

en: A BOZ literal constant at %L cannot appear as an actual argument in a function reference
de: Eine BOZ-Literalkonstante bei %L kann nicht als tatsächliches Argument in einer Funktionsreferenz verwendet werden

en: A BOZ literal constant at %L cannot appear as an actual argument in a subroutine reference
de: Eine BOZ-Literalkonstante bei %L kann nicht als tatsächliches Argument in einer Unterprogrammreferenz erscheinen

en: A factor for tuning the upper bound that swing modulo scheduler uses for scheduling a loop.
de: Ein Faktor, um die obere Schranke des Swing-Modulo-Schedulers für Schleifenplanung einzustellen.

en: A floatig point to integer truncation may be replaced with rounding to save mode switching.
de: Abschneiden von Gleitkomma- zu Ganzzahl darf durch Rundung ersetzt werden, um Modusumschaltung zu verhindern.

en: A non-default set of initial values has been requested, which violates the ABI
de: Es wurde ein nicht standardmäßiger Satz von Anfangswerten angefordert, was gegen das ABI verstößt

en: A parameter name is required at %C
de: Bei %C wird ein Parametername erwartet

en: A synonym for -std=c89 (for C) or -std=c++98 (for C++).
de: Ein Synonym für -std=c89 (für C) oder -std=c++98 (für C++).

en: A threshold on the average loop count considered by the swing modulo scheduler.
de: Schwellwert für vom Swing-Modulo-Scheduler betrachteten Durchschnitts-Schleifen-Zähler.

en: A type parameter list is required at %C
de: Bei %C wird eine Typparameterliste erwartet

en: AAPCS does not support %<-mcallee-super-interworking%>
de: AAPCS unterstützt nicht %<-mcallee-super-interworking%>

en: AAPCS does not support %<-mcaller-super-interworking%>
de: AAPCS unterstützt nicht %<-mcaller-super-interworking%>

en: ABI %qs cannot be implemented due to limited instruction set %qs, falling back to %qs
de: ABI %qs kann aufgrund des begrenzten Befehlssatzes %qs nicht implementiert werden, stattdessen wird %qs verwendet

en: ABI %qs is not enabled at configure-time, the linker might report an error
de: ABI %qs ist zur Konfigurationszeit nicht aktiviert, der Linker meldet möglicherweise einen Fehler

en: ABI changed (%qs to %qs) while multilib is disabled
de: ABI geändert (von %qs auf %qs), während Multilib ausgeschaltet ist

en: ABI for flattened struct with zero-length bit-fields changed in GCC 10
de: ABI für abgeflachte Struktur mit Bit-Feldern der Länge 0 hat wurde mit GCC 10 geändert

en: ABI requires %<-march=rv%d%>
de: ABI erfordert %<-march=rv%d%>

en: ABI variant code generation (for use with -mabi= option):
de: ABI-Varianten für Codeerzeugung (zur Verwendung mit der Option »-mabi=«):

en: ABI with startfiles: %s
de: ABI mit Startdateien: %s

en: ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)
de: ABSTRACT INTERFACE %qs bei %L darf kein angenommenes Zeichenlängenergebnis haben (F2008: C418)

en: ABSTRACT INTERFACE %qs must not be referenced at %L
de: ABSTRACT INTERFACE %qs darf bei %L nicht referenziert werden

en: ABSTRACT INTERFACE at %C
de: ABSTRACT INTERFACE bei %C

en: ABSTRACT type %qs used at %L
de: ABSTRACT-Typ %qs bei %L verwendet

en: ABSTRACT type at %C
de: ABSTRACT-Typ bei %C

en: AC-IMPLIED-DO final expression references control variable at %L
de: letzter Ausdruck von AC-IMPLIED-DO referenziert Steuervariable bei %L

en: AC-IMPLIED-DO initial expression references control variable at %L
de: erster Ausdruck von AC-IMPLIED-DO referenziert Steuervariable bei %L

en: AC-IMPLIED-DO step expression references control variable at %L
de: Schrittausdruck von AC-IMPLIED-DO referenziert Steuervariable bei %L

en: ACC CACHE directive must be inside of loop %C
de: ACC-CACHE-Direktive bei %C muss innerhalb einer Schleife sein

en: ACCESS specification at %L was already specified
de: ACCESS-Spezifikation bei %L wurde bereits spezifiziert

en: ACLE function %qD is incompatible with the use of %qs
de: ACLE-Funktion %qD ist nicht kompatibel mit der Verwendung von %qs

en: ACLE function %qD requires ISA extension %qs
de: ACLE-Funktion %qD erfordert ISA-Erweiterung %qs

en: ACQUIRED_LOCK variable
de: Variable ACQUIRED_LOCK

en: ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable
de: »ACQUIRED_LOCK=«-Argument bei %L muss skalare LOGICAL-Variable sein

en: ACTION type conflicts with READONLY specifier at %L
de: ACTION-Typ bei %L steht in Konflikt mit READONLY-Spezifizierer

en: ALLOCATABLE attribute at %C in a STRUCTURE definition
de: Attribut ALLOCATABLE bei %C in einer STRUCTURE-Definition

en: ALLOCATABLE attribute at %C in a TYPE definition
de: Attribut ALLOCATABLE bei %C in einer TYPE-Definition

en: ALLOCATABLE object %qs in %s clause at %L
de: ALLOCATABLE-Objekt %qs in Klausel %s bei %L

en: ALLOCATABLE specified outside of INTERFACE body at %L
de: ALLOCATABLE außerhalb des INTERFACE-Körpers bei %L angegeben

en: ALLOCATE object
de: ALLOCATE Objekt

en: ALLOCATE of coarray at %C in CRITICAL block
de: ALLOCATE von Koarray bei %C in CRITICAL-Block

en: ALLOCATE of coarray at %C in DO CONCURRENT block
de: ALLOCATE von Koarray bei %C in DO CONCURRENT-Block

en: ALLOCATED intrinsic at %L requires an array or scalar allocatable entity
de: Das intrinsische ALLOCATED bei %L erfordert ein Feld oder eine skalar allozierbare Entity

en: ALTERNATE RETURN not permitted at %L
de: ALTERNATE RETURN bei %L nicht erlaubt

en: APCS reentrant code not supported.  Ignored
de: wiedereinsprungsfähiger APCS-Code nicht unterstützt. Ignoriert

en: ARMv8-M Security Extensions incompatible with selected FPU
de: ARMv8-M Security Extensions sind mit der gewählten FPU inkompatibel

en: ASSIGN statement at %C
de: ASSIGN-Anweisung bei %C

en: ASSIGN statement at %L requires a scalar default INTEGER variable
de: ASSIGN-Anweisung bei %L erfordert eine skalare Standard-INTEGER-Variable

en: ASSIGNED GOTO statement at %L requires a scalar INTEGER variable
de: Anweisung ASSIGNED GOTO bei %L erfordert eine skalare INTEGER-Variable

en: ASSIGNED variable in FORMAT tag at %L
de: ASSIGNED-Variable in FORMAT-Markierung bei %L

en: ASSOCIATE construct at %C
de: ASSOCIATE-Konstrukt bei %C

en: ASYNCHRONOUS attribute at %C
de: ASYNCHRONOUS-Attribut bei %C

en: ASYNCHRONOUS statement at %C
de: ASYNCHRONOUS-Anweisung bei %C

en: ASYNCHRONOUS= at %L not allowed in Fortran 95
de: ASYNCHRONOUS= bei %L ist in Fortran 95 nicht erlaubt

en: ATOM argument at %L of the %s intrinsic function shall be a coarray or coindexed
de: ATOM-Argument bei %L der intrinsischen Funktion %s muss Koarray oder koindiziert sein

en: ATOM argument at %L to intrinsic function %s shall be an integer of ATOMIC_INT_KIND
de: ATOM-Argument bei %L für intrinsische Funktion %s muss eine ATOMIC_INT_KIND-Ganzzahl sein

en: ATOM argument at %L to intrinsic function %s shall be an integer of ATOMIC_INT_KIND or a logical of ATOMIC_LOGICAL_KIND
de: ATOM-Argument bei %L für intrinsische Funktion %s muss eine ATOMIC_INT_KIND-Ganzzahl oder ein ATOMIC_LOGICAL_KIND-Logikwert sein

en: ATOM argument of the %s intrinsic function at %L shall be definable
de: ATOM-Argument der intrinsischen Funktion »%s« bei %L muss definierbar sein

en: AUX pointer initialized for edge %d->%d
de: AUX-Zeiger für Kante %d->%d initialisiert

en: AVX vector argument without AVX enabled changes the ABI
de: AVX-Vektorargument ohne eingeschaltetes AVX ändert das ABI

en: AVX vector return without AVX enabled changes the ABI
de: AVX-Vektorrückgabe ohne eingeschaltetes AVX ändert das ABI

en: AVX512F vector argument without AVX512F enabled changes the ABI
de: AVX512F-Vektorargument ohne eingeschaltetes AVX512F ändert das ABI

en: AVX512F vector return without AVX512F enabled changes the ABI
de: AVX512F-Vektorrückgabe ohne eingeschaltetes AVX512F ändert das ABI

en: Abbreviation for "-g -feliminate-unused-debug-symbols".
de: Abkürzung für »-g -feliminate-unused-debug-symbols«.

en: Abbreviation for "-g -fno-eliminate-unused-debug-symbols".
de: Abkürzung für »-g -fno-eliminate-unused-debug-symbols«.

en: Absolute value of SHIFT shall be less than or equal to SIZE at %C
de: Der absolute Wert von SHIFT muss kleiner oder gleich SIZE bei %C sein

en: Abstract interface %qs is invalid in procedure pointer assignment at %L
de: Abstrakte Schnittstelle %qs ist in Zuweisung des Prozedurzeigers bei %L ungültig

en: Accept argument mismatches in procedure calls.
de: Unpassende Argumente in Prozeduraufrufen akzeptieren.

en: Accept extensions to support legacy code.
de: Erweiterungen akzeptieren, um alten Code zu unterstützen.

en: Access data in the same section from shared anchor points.
de: Auf Daten im gleichen Abschnitt von gemeinsam verwendeten Ankerpunkten zugreifen.

en: Access offset before parent offset
de: Offset des Zugriffs liegt vor dem Offset des Elternteils

en: Access overlaps with its sibling
de: Zugriff überschneidet sich mit seinem Geschwisterteil

en: Access size greater or equal to its parent size
de: Größe des Zugriffs ist größer oder gleich der übergeordneten Größe

en: Access specification of the %s operator at %C has already been specified
de: Zugriffsspezifikation des Operators %s bei %C wurde bereits spezifiziert

en: Access specification of the .%s. operator at %C has already been specified
de: Zugriffsspezifikation des Operators .%s. bei %C wurde bereits spezifiziert

en: Access terminates outside of its parent
de: Zugriff endet außerhalb des Elternteils

en: Accumulate outgoing function arguments and acquire/release the needed stack space for outgoing function arguments in function prologue/epilogue.  Without this option, outgoing arguments are pushed before calling a function and popped afterwards.  This option can lead to reduced code size for functions that call many functions that get their arguments on the stack like, for example printf.
de: Ausgehende Funktionsargumente sammeln und den nötigen Stapelspeicher für ausgehende Argumente im Prolog/Epilog der Funktion reservieren/freigeben. Ohne diese Option werden ausgehende Argumente auf den Stapel geschoben und hinter zurückgeholt. Diese Option kann für Funktionen, die viele Funktionen mit Argumentübergabe über den Stapel aufrufen, z.B. printf, zu kleinerem Code führen.

en: Actual CLASS array argument for %qs must be a full array at %L
de: Effektives CLASS-Feldargument für %qs muss ein vollständiges Feld bei %L sein

en: Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array
de: Effektives Argument bei %L für INTENT(%s)-Dummy %qs von ELEMENTAL-Unterprogramm %qs ist skalar, aber ein anderes effektives Argument ist ein Feld

en: Actual argument at %L of %qs intrinsic shall be an associated pointer
de: Argument bei %L von der intrinsischen Funktion %qs muss ein verbundener Zeiger sein

en: Actual argument at %L to allocatable or pointer dummy argument %qs must have a deferred length type parameter if and only if the dummy has one
de: Effektives Argument bei %L an reservierbares oder Zeiger-Scheinargument %qs muss Parameter mit Typ aufgeschobener Länge haben, genau dann, wenn das Scheinargument einen solchen hat

en: Actual argument at %L to assumed-type dummy has type parameters or is of derived type with type-bound or FINAL procedures
de: Argument bei %L für den angenommenen Typ des Dummys hat Typparameter oder hat einen abgeleiteten Typ mit typgebundenen oder FINAL-Prozeduren

en: Actual argument contains too few elements for dummy argument %qs (%lu/%lu) at %L
de: Effektives Argument enthält zuwenige Elemente für Scheinargument %qs (%lu/%lu) bei %L

en: Actual argument for %qs cannot be an assumed-size array at %L
de: Effektives Argument für %qs kann nicht Feld vermuteter Größe bei %L sein

en: Actual argument for %qs must be ALLOCATABLE at %L
de: Effektives Argument für %qs muss ALLOCATABLE bei %L sein

en: Actual argument for %qs must be a pointer at %L
de: Effektives Argument für %qs muss ein Zeiger bei %L sein

en: Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs
de: Effektives Argument mit EVENT_TYPE oder mit EVENT_TYPE-Komponente bei %L erfordert eine explizite Schnittstelle für Prozedur %qs

en: Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs
de: Effektives Argument mit LOCK_TYPE oder mit LOCK_TYPE-Komponente bei %L erfordert eine explizite Schnittstelle für Prozedur %qs

en: Actual argument to %qs at %L must be a coarray
de: Effektives Argument für %qs bei %L sein muss Koarray sein

en: Actual argument to %qs at %L must be polymorphic
de: Effektives Argument für %qs bei %L muss polymorph sein

en: Actual argument to %qs at %L must be simply contiguous or an element of such an array
de: Effektives Argument für %qs bei %L muss einfach fortlaufend oder ein Element eines solchen Feldes sein

en: Actual argument to %qs at %L must be unlimited polymorphic since the formal argument is a pointer or allocatable unlimited polymorphic entity [F2008: 12.5.2.5]
de: Effektives Argument für %qs bei %L muss unbegrenzt polymorph sein, da das formale Argument ein Zeiger oder reservierbare unbegrenzt polymorphe Entität ist [F2008: 12.5.2.5]

en: Actual argument to %qs at %L must have the same declared type
de: Effektives Argument für %qs bei %L muss denselben deklarierten Typ haben

en: Actual argument to assumed-rank INTENT(OUT) dummy %qs at %L cannot be of unknown size
de: Argument des INTENT(OUT)-Dummy für angenommenen Rang %qs bei %L muss eine bekannte Größe haben

en: Actual argument to contiguous pointer dummy %qs at %L must be simply contiguous
de: Effektives Argument für fortlaufenden Schein-Zeiger %qs bei %L muss einfach fortlaufend sein

en: Actual argument to non-INTENT(INOUT) dummy %qs at %L, which is EVENT_TYPE or has a EVENT_TYPE component
de: Effektives Argument für Nicht-INTENT(INOUT)-Platzhalter %qs bei %L mit Typ EVENT_TYPE oder einer EVENT_TYPE-Komponente

en: Actual argument to non-INTENT(INOUT) dummy %qs at %L, which is LOCK_TYPE or has a LOCK_TYPE component
de: Effektives Argument für Nicht-INTENT(INOUT)-Platzhalter %qs bei %L mit Typ LOCK_TYPE oder einer Komponente LOCK_TYPE

en: Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)
de: Effektive Zeichenkettenlänge passt nicht zur deklarierten für Scheinargument »%s« (%ld/%ld)

en: Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)
de: Effektive Zeichenkettenlänge ist kürzer als die deklarierte für Scheinargument »%s« (%ld/%ld)

en: Add CS prefix to call and jmp to indirect thunk with branch target in r8-r15 registers.
de: CS-Präfix zu call und jmp zu indirektem Thunk hinzufügen, wenn das Verzweigungsziel in den Registern r8-r15 liegt.

en: Add a common subexpression elimination pass after loop optimizations.
de: Einen Durchlauf zur Entfernung von Teilausdrücken nach Schleifenoptimierungen hinzufügen.

en: Add comments for ignored declarations in the generated C++ header.
de: Kommentare hinzufügen, wenn Deklarationen im generierten C++-Header ignoriert werden.

en: Add description attributes to some DWARF DIEs that have no name attribute.
de: Beschreibungsattribute zu einigen DWARF-DIEs hinzufügen, die kein Namensattribut haben.

en: Add explicit checks for division by zero.
de: Ausdrückliche Prüfungen für Division durch Null hinzufügen.

en: Add explicit checks for division overflow in INT_MIN / -1.
de: Ausdrückliche Prüfungen für Divisionsüberlauf in INT_MIN / -1 hinzufügen.

en: Add extra commentary to assembler output.
de: Zusätzliche Anmerkungen an Assemblerausgabe anfügen.

en: Add extra information to the executable that can speed up dynamic loading (provided that dependent libraries are unchanged).
de: Zusätzliche Informationen speicherm die das dynamische Laden beschleunigen können, solange die Binärdateien unverändert bleiben.

en: Add the .lower prefix to section names when compiling with -m{code,data}-region=lower (disabled by default).
de: Den Abschnittsnamen ».lower« voranstellen, wenn mit »-m{code,data}-region=lower« übersetzt wird (Vorgabe: nein).

en: Additional debug prints.
de: Zusätzliche Fehlerprotokollausdrucke.

en: After diagnosing undefined behavior attempt to continue execution.
de: Nach dem Erkennen von undefiniertem Verhalten versuchen, die Ausführung fortzusetzen.

en: Aggressively optimize loops using language constraints.
de: Schleifen aggressiv optimieren, dabei sprachspezifische Einschränkungen einbeziehen.

en: Alias and target%'s comdat groups differs
de: Interner Fehler: Alias and target%'s comdat groups differs

en: Alias and target%'s section differs
de: Interner Fehler: Alias and target%'s section differs

en: Alias for -mcpu=g10.
de: Alias für --mcpu=g10.

en: Alias for -mcpu=g13.
de: Alias für -mcpu=g13.

en: Alias for -mcpu=g14.
de: Alias für -mcpu=g14.

en: Alias has call edges
de: Interner Fehler: Alias has call edges

en: Alias has more than one alias reference
de: Interner Fehler: Alias has more than one alias reference

en: Alias has non-alias reference
de: Interner Fehler: Alias has non-alias reference

en: Align all labels.
de: Alle Marken ausrichten.

en: Align all loops to 32 byte boundary.
de: Alle Schleifen auf 32-Byte-Grenzen ausrichten.

en: Align code and data to 32 bits.
de: Code und Daten auf 32 Bit ausrichten.

en: Align destination of the string operations.
de: Ziel der Zeichenkettenoperationen ausrichten.

en: Align doubles at 64-bit boundaries.
de: Doubles auf 64-Bit-Grenzen ausrichten.

en: Align function entry to 4 byte.
de: Funktionseinsprung an 4-Byte-Grenze ausrichten.

en: Align labels which are only reached by jumping.
de: Marken ausrichten, die nur mit Sprüngen erreicht werden können.

en: Align some doubles on dword boundary.
de: Einige Doubles auf DWord-Grenze ausrichten.

en: Align the start of functions.
de: Funktionsanfänge ausrichten.

en: Align the start of loops.
de: Schleifenanfänge ausrichten.

en: Align to the base type of the bit-field.
de: Auf Basistyp des Bitfeldes ausrichten.

en: Align to the base type of the bit-field. Don't assume that unaligned accesses are handled by the system.
de: Auf Basistyp des Bitfeldes ausrichten. Nicht annehmen, dass unausgerichtete Zugriffe vom System behandelt werden.

en: Align variables on a 32-bit boundary.
de: Variablen auf 32-Bit-Grenzen ausrichten.

en: All intrinsics procedures are available regardless of selected standard.
de: Alle intrinsischen Prozeduren sind ungeachtet des gewählten Standards verfügbar.

en: All memory accesses use I/O load/store instructions.
de: Alle Speicherzugriffe nutzen I/O-load/store-Befehle.

en: All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED
de: Alle LEN-Typparameter in der TYPE-IS-Anweisung bei %C müssen ASSUMED sein

en: Allocatable %qs at %L cannot have an initializer
de: Zuordnungsfähiges %qs bei %L kann keine Initialisierung haben

en: Allocatable array %qs at %L must have a deferred shape or assumed rank
de: Reservierbares Feld %qs bei %L muss aufgeschobene Form oder vermuteten Rang haben

en: Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)
de: Das allozierbare Zeichen-Dummy-Argument %qs bei %L muss eine verzögerte Länge haben, da die Prozedur %qs BIND(C) ist

en: Allocatable coarray variable %qs at %L must have deferred shape
de: Zuordnungsfähige Koarray-Variable %qs bei %L muss aufgeschobene Form haben

en: Allocatable component %s at %L must have a codimension as it has a noncoarray subcomponent of type EVENT_TYPE
de: Allozierbare Komponente %s bei %L muss eine Kodimension haben, da sie eine Subkomponente als Nicht-Koarray des Typs EVENT_TYPE hat

en: Allocatable component %s at %L must have a codimension as it has a noncoarray subcomponent of type LOCK_TYPE
de: Allozierbare Komponente %s bei %L muss eine Kodimension haben, da es eine Subkomponente als Nicht-Koarray des Typs LOCK_TYPE hat

en: Allocatable component %s at %L of type EVENT_TYPE must have a codimension
de: Allozierbare Komponente %s bei %L des Typs EVENT_TYPE muss eine Kodimension haben

en: Allocatable component %s at %L of type LOCK_TYPE must have a codimension
de: Allozierbare Komponente %s bei %L des Typs LOCK_TYPE muss eine Kodimension haben

en: Allocatable component of structure at %C must have a deferred shape
de: Allozierbare Komponente der Struktur bei %C muss eine aufgeschobene Form haben

en: Allocatable component or deferred-shaped array near %C in DATA statement
de: Allozierbare Komponente oder deferred-shaped-Feld bei %C in DATA-Anweisung

en: Allocatable function %qs at %L must have an explicit function interface
de: Reservierbare Funktion %qs bei %L muss eine explizite Funktionsschnittstelle haben

en: Allocate local variables on the stack to allow indirect recursion.
de: Lokale Variablen auf Stapel anlegen, um indirekte Rekursion zu ermöglichen.

en: Allocate-object at %C is not a nonprocedure pointer nor an allocatable variable
de: Allocate-Objekt bei %C ist kein Nicht-Prozedur-Zeiger oder reservierbare Variable

en: Allocate-object at %L also appears at %L
de: ALLOCATE-Objekt bei %L tritt auch bei %L auf

en: Allocate-object at %L is neither a data pointer nor an allocatable variable
de: ALLOCATE-Objekt bei %L ist weder ein Datenzeiger noch eine reservierbare Variable

en: Allocate-object at %L is subobject of object at %L
de: ALLOCATE-Objekt bei %L ist Subobjekt des Objekts bei %L

en: Allocate-object at %L must be ALLOCATABLE or a POINTER
de: ALLOCATE-Objekt bei %L muss ALLOCATABLE oder ein POINTER sein

en: Allocate-object at %L with a deferred type parameter requires either a type-spec or SOURCE tag or a MOLD tag
de: ALLOCATE-Objekt bei %L mit Parameter aufgeschobenen Typs erfordert entweder eine Typspezifikation, SOURCE-Marke oder MOLD-Marke

en: Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration
de: Reservierung von %s bei %L mit Typspezifikation erfordert den selben Zeichenkettenlängenparameter wie in der Deklaration

en: Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr
de: Reservierung von %s mit ABSTRACT-Basistyp bei %L erfordert Typspezifikation oder Quellausdruck

en: Allow (or do not allow) gcc to use the LOOP instruction.
de: GCC erlauben (oder verbieten), LOOP-Befehle zu verwenden.

en: Allow IEC559 floating point exceptions in constant expressions.
de: IEC559-Gleitkommaausnahmen in konstanten Ausdrücken zulassen.

en: Allow a BOZ literal constant to appear in an invalid context and with X instead of Z.
de: Eine literale BOZ-Konstante in einem ungültigen Kontext erlauben, sowie mit X statt mit Z.

en: Allow access to instance variables as if they were local declarations within instance method implementations.
de: Zugriff auf Instanzvariablen erlauben, als ob sie lokale Deklarationen innerhalb der Instanzmethoden-Implementierungen wären.

en: Allow arbitrary character line width in fixed mode.
de: Im festen Modus beliebig lange Zeilen erlauben.

en: Allow arbitrary character line width in free mode.
de: Im freien Modus beliebig lange Zeilen erlauben.

en: Allow bit-fields to cross word boundaries.
de: Zulassen, dass Bitfelder Wortgrenzen überschneiden.

en: Allow branches to be packed with other instructions.
de: Erlauben, Sprünge mit anderen Befehlen zu packen.

en: Allow built-in functions ceil, floor, round, trunc to raise "inexact" exceptions.
de: Den eingebauten Funktionen ceil, floor, round, trunc erlauben, »inexact«-Exceptions zu werfen.

en: Allow dollar signs in entity names.
de: Dollarzeichen in Entitätsnamen erlauben.

en: Allow fast jumps to the message dispatcher.
de: Schnelle Sprünge zum Nachrichten-Dispatcher erlauben.

en: Allow function addresses to be held in registers.
de: Vorhalten von Funktionsadressen in Registern erlauben.

en: Allow gcc to generate LIW instructions.
de: GCC erlauben, LIW-Befehle zu verwenden.

en: Allow gcc to generate the SETLB and Lcc instructions.
de: GCC erlauben, SETLB- und Lcc-Befehle zu verwenden.

en: Allow hardware floating-point instructions to cover both 32-bit and 64-bit operations.
de: Hardware-Gleitkommabefehle erlauben, um 32-Bit- und 64-Bit-Befehle abzudecken.

en: Allow implicit conversions between vectors with differing numbers of subparts and/or differing element types.
de: Implizite Umwandlungen zwischen Vektoren mit unterschiedlicher Anzahl der Teile und/oder abweichenden Elementtypen erlauben.

en: Allow interposing function (or variables) by ones with different semantics (or initializer) respectively by dynamic linker.
de: Erlauben, dass der dynamische Linker Funktionen und Variablen mit solchen unterschiedlicher Semantik (oder Initialisierungen) gemischt platzieren darf.

en: Allow math optimizations that may violate IEEE or ISO standards.
de: Mathematische Optimierungen erlauben, die IEEE- oder ISO-Standards verletzen könnten.

en: Allow optimization for floating-point arithmetic which may change the result of the operation due to rounding.
de: Optimierung für Gleitkommaarithmetik erlauben, auch wenn durch Runden ein anderes Ergebnis herauskommen kann.

en: Allow premature scheduling of queued insns.
de: Nicht ausgereifte Planung von eingereihten Befehlen erlauben.

en: Allow readonly data in sdata.
de: Nur-Lese-Daten in sdata-Abschnitt erlauben.

en: Allow sign extension in fusion operations.
de: Vorzeichenerweiterung in Fusionsoperationen erlauben.

en: Allow speculative motion of more loads.
de: Spekulative Bewegung bei mehr Ladebefehlen erlauben.

en: Allow speculative motion of non-loads.
de: Spekulative Bewegung von Nicht-Lade-Befehlen erlauben.

en: Allow speculative motion of some loads.
de: Spekulative Bewegung bei einigen Ladebefehlen erlauben.

en: Allow the arguments of the '?' operator to have different types.
de: Verschiedene Typen für die Argumente des »?«-Operators erlauben.

en: Allow the compiler to introduce new data races on stores.
de: Dem Compiler erlauben, neue Datenwettläufe bei Speichervorgängen einzuführen.

en: Allow the store merging pass to introduce unaligned stores if it is legal to do so.
de: Im Durchlauf, der Speicheroperationen zusammenfasst, unausgerichtete Speicherungen zulassen, sofern es erlaubt ist.

en: Allow the use of MDMX instructions.
de: Verwendung von MDMX-Befehlen erlauben.

en: Allow the use of MT instructions.
de: Verwendung von MT-Befehlen erlauben.

en: Allow the use of hardware floating point instructions for V850E2V3 and up.
de: Verwendung von Hardware-Gleitkommabefehlen für V850E2V3 und aufwärts erlauben.

en: Allow the use of hardware floating-point ABI and instructions.
de: Verwendung von Hardware-Gleitkomma-ABI und -befehlen erlauben.

en: Allow to use truncation instead of rounding towards zero for fractional fixed-point types.
de: Für Festkomma-Bruchzahlen das Abschneiden statt Runden erlauben.

en: Allow two instructions to be issued per cycle.
de: Zwei Befehle pro Taktzyklus erlauben.

en: Allow usage of __gcc_isr pseudo instructions in ISR prologues and epilogues.
de: Verwendung von __gcc_isr-Pseudobefehlen in ISR-Prologen und -Epilogen erlauben.

en: Allow use of '=>' for methods and top-level functions in addition to lambdas.
de: Verwendung von »=>« für Methoden und Top-Level-Funktionen zusätzlich zu Lambdas zulassen.

en: Allow use r15 for inline ASM.
de: Verwendung von r15 für Inline-Assembler erlauben.

en: Allow variadic functions without named parameter.
de: Variadische Funktionen ohne benannte Parameter erlauben.

en: Already inside a CONTAINS block at %C
de: Bereits in CONTAINS-Block bei %C

en: Alternate RETURN statement at %C is only allowed within a SUBROUTINE
de: Alternative RETURN-Anweisung bei %C ist nur innerhalb einer SUBROUTINE erlaubt

en: Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier
de: Alternative RETURN-Anweisung bei %L erfordert einen SCALAR-INTEGER-Spezifizierer als Rückgabe

en: Alternate calling convention.
de: Alternative Aufrufkonvention.

en: Alternate return at %L is not permitted in a DTIO procedure
de: Alternativer Rücksprung bei %L ist in einer DTIO-Prozedur nicht erlaubt

en: Alternate return cannot appear in operator interface at %L
de: Alternative Rückgabe kann nicht in Operatorschnittstelle bei %L auftreten

en: Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L
de: Alternatives Rückgabe-Dummyargument kann nicht in einer SUBROUTINE mit BIND(C)-Attribut bei %L auftreten

en: Alternate return specifier in elemental subroutine %qs at %L is not allowed
de: Alternativer Rückgabespezifizierer in elementarem Unterprogramm %qs bei %L ist nicht erlaubt

en: Alternate return specifier in function %qs at %L is not allowed
de: Alternativer Rückgabespezifizierer in Funktion %qs bei %L ist nicht erlaubt

en: Alternate-return argument at %C
de: Argument für Alternativrückgabe bei %C

en: Although not referenced, %qs has ambiguous interfaces at %L
de: Obwohl nicht referenziert, hat %qs mehrdeutige Schnittstellen bei %L

en: AltiVec argument passed to unprototyped function
de: AltiVec-Argument an Funktion ohne Prototyp übergeben

en: AltiVec not supported in this target
de: AltiVec wird für dieses Ziel nicht unterstützt

en: Always align function entry, jump target and return address.
de: Funktionseinsprung, Sprungziele und Rücksprungadressen ausrichten.

en: Always generate long calls.
de: Immer weite Aufrufe erzeugen.

en: Always save $lp in the stack.
de: Register $lp immer auf dem Stapel speichern.

en: Always treat bitfields as int-sized.
de: Bitfelder immer als gleichgroß wie »int« ansehen.

en: Always use Dynamic Realigned Argument Pointer (DRAP) to realign stack.
de: Immer Dynamic Realigned Argument Pointer (DRAP) verwenden, um den Stapel neu auszurichten.

en: Always use JSR, never BSR, for calls.
de: Immer JSR für Aufrufe verwenden, niemals BSR.

en: Ambiguous !$OMP DECLARE REDUCTION from module %s at %L
de: Mehrdeutiges !$OMP DECLARE REDUCTION von Modul %s bei %L

en: Ambiguous interfaces in %s for %qs at %L and %qs at %L
de: Mehrdeutige Schnittstellen in %s für %qs bei %L und %qs bei %L

en: Ambiguous symbol in TYPE definition at %C
de: Mehrdeutiges Symbol in TYPE-Definition bei %C

en: Amend appropriate diagnostic messages with the command line option that controls them.
de: Die geeignete Diagnosemeldung mit der Kommandozeilenoption anreichern, die sie steuert.

en: Amount of local data-share (LDS) memory to reserve for gang-private variables.
de: Die Menge an lokalem, gemeinsam genutztem Speicher (LDS), die für private Gang-Variablen reserviert werden soll.

en: An alias for minterlink-compressed provided for backward-compatibility.
de: Alias für -minterlink-compressed; für Rückwärtskompatibilität erhalten.

en: An alternate return at %L without a * dummy argument
de: Alternative Rückkehr bei %L ohne ein *-Scheinargument

en: An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is:
de: Interner Fehler: An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is:

en: An outer FORALL construct already has an index with this name %L
de: Ein äußeres FORALL-Konstrukt hat bereits einen Index mit Namen %L

en: Analyze and remove doubleword swaps from VSX computations.
de: Doppelwort-Vertauschungen aus VSX-Berechnungen analysieren und entfernen.

en: Analyzed alias has no reference
de: Interner Fehler: Analyzed alias has no reference

en: Annotate assembler instructions with estimated addresses.
de: Assemblerbefehle mit geschätzten Adressen kommentieren.

en: Append a second underscore if the name already contains an underscore.
de: Einen zweiten Unterstrich anhängen, wenn der Name bereits einen Unterstrich enthält.

en: Append underscores to externally visible names.
de: Unterstriche an extern sichtbare Namen anhängen.

en: Apply negative sign to zero values.
de: Negatives Vorzeichen auf Null-Werte anwenden.

en: Apply special rules for compiling runtime package.
de: Besondere Regeln anwenden, um Paket für die Laufzeitumgebung zu kompilieren.

en: Apply variable expansion when loops are unrolled.
de: Variablenerweiterung anwenden, wenn Schleifen abgerollt werden.

en: Approximate the effect of function calls to simplify analysis.
de: Die Auswirkungen von Funktionsaufrufen abschätzen, um die Analyse zu vereinfachen.

en: Argument %<A%> with INTENT(INOUT) at %L of the intrinsic subroutine %s shall not have a vector subscript
de: Argument %<A%> mit INTENT(OUT) bei %L des intrinsischen Unterprogramms %s darf keinen Vektorindex haben

en: Argument %<S%> of NEAREST at %L shall not be zero
de: Argument %<S%> von NEAREST bei %L darf nicht Null sein

en: Argument %qs appears twice in call to %qs at %L
de: Argument %qs tritt im Aufruf von %qs bei %L doppelt auf

en: Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L
de: Argument %qs des intrinsischen %qs bei %L muss typkonform zu Argument %qs bei %L sein

en: Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE
de: Argument %qs von %qs mit PASS(%s) bei %L darf nicht ALLOCATABLE sein

en: Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute
de: Argument %qs von %qs mit PASS(%s) bei %L darf kein POINTER-Attribut haben

en: Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs
de: Argument %qs von %qs mit PASS(%s) bei %L muss abgeleiteten Typ %qs haben

en: Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs
de: Argument %qs von %qs mit PASS(%s) bei %L muss abgeleiteten Typ %qs haben

en: Argument %qs of %qs with PASS(%s) at %L must be scalar
de: Parameter %qs von %qs mit PASS(%s) bei %L muss skalar sein

en: Argument %qs of MOD at %L shall not be zero
de: Argument %qs von MOD bei %L darf nicht Null sein

en: Argument %qs of MODULO at %L shall not be zero
de: Argument %qs von MODULO bei %L darf nicht 0 sein

en: Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute
de: Für Argument %qs des elementaren Unterprogrammes %qs bei %L muss INTENT oder das VALUE-Attribut angegeben werden

en: Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute
de: Argument %qs der elementaren Prozedur bei %L kann kein ALLOCATABLE-Attribut haben

en: Argument %qs of elemental procedure at %L cannot have the POINTER attribute
de: Argument %qs der elementaren Prozedur bei %L kann kein POINTER-Attribut haben

en: Argument %qs of elemental procedure at %L must be scalar
de: Argument %qs der elementaren Prozedur bei %L muss skalar sein

en: Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE
de: Argument %qs der reinen Funktion %qs bei %L muss INTENT(IN) oder VALUE sein

en: Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)
de: Argument %qs der reinen Funktion %qs bei %L mit VALUE-Attribut, aber ohne INTENT(IN)

en: Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute
de: Für Argument %qs des reinen Unterprogrammes %qs bei %L muss INTENT oder das VALUE-Attribut angegeben werden

en: Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT
de: Argument %qs des reinen Unterprogrammes %qs bei %L mit VALUE-Attribut, aber ohne INTENT

en: Argument '%s' of statement function '%s' at %L must be scalar
de: Argument »%s« der Anweisungs-Funktion »%s« bei %L muss skalar sein

en: Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)
de: Argument CPTR bei %L für C_F_POINTER muss den Typen TYPE(C_PTR) haben

en: Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)
de: Argument CPTR bei %L für C_F_PROCPOINTER muss den Typen TYPE(C_FUNPTR) haben

en: Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)
de: Argument C_PTR_1 bei %L für C_ASSOCIATED muss den Typ TYPE(C_PTR) oder TYPE(C_FUNPTR) haben

en: Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1: %s instead of %s
de: Argument C_PTR_2 bei %L für C_ASSOCIATED muss denselben Typ wie C_PTR_1 haben: %s statt %s

en: Argument FPTR at %L to C_F_POINTER must be a pointer
de: Argument FPTR bei %L für C_F_POINTER muss ein Zeiger sein

en: Argument FPTR at %L to C_F_POINTER shall not be coindexed
de: Argument FPTR für C_F_POINTER bei %L darf nicht koindiziert sein

en: Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer
de: Argument FPTR bei %L für C_F_PROCPOINTER muss ein Prozedurzeiger sein

en: Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed
de: Argument FPTR bei %L für C_F_PROCPOINTER darf nicht koindiziert sein

en: Argument NCOPIES of REPEAT intrinsic is negative (its value is %ld)
de: Argument NCOPIES des intrinsischen REPEAT ist negativ (sein Wert ist %ld)

en: Argument NCOPIES of REPEAT intrinsic is negative at %L
de: Argument NCOPIES des intrinsischen REPEAT ist bei %L negativ

en: Argument NCOPIES of REPEAT intrinsic is too large
de: Argument NCOPIES des intrinsischen REPEAT ist zu groß

en: Argument NCOPIES of REPEAT intrinsic is too large at %L
de: Argument NCOPIES des intrinsischen REPEAT ist bei %L zu groß

en: Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer
de: Argument X bei %L für C_FUNLOC muss eine Prozedur oder ein Prozedurzeiger sein

en: Argument X at %L to C_FUNLOC shall not be coindexed
de: Argument X bei %L für C_FUNLOC darf nicht koindiziert sein

en: Argument X at %L to C_LOC shall be not be a zero-sized string
de: Argument X bei %L für C_LOC darf keine Zeichenkette der Länge 0 sein

en: Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute
de: Argument X bei %L für C_LOC muss entweder POINTER- oder TARGET-Attribut haben

en: Argument X at %L to C_LOC shall not be coindexed
de: Argument X bei %L für C_LOC darf nicht koindiziert sein

en: Argument at %L to C_LOC shall not be polymorphic
de: Argument bei %L für C_LOC darf nicht polymorph sein

en: Argument dim at %L must be of INTEGER type
de: Argument dim bei %L muss INTEGER-Typ haben

en: Argument dim at %L must be scalar
de: Argument dim bei %L muss skalar sein

en: Argument mismatch for the overriding procedure %qs at %L: %s
de: Unpassende Argumente für die überschreibende Prozedur %qs bei %L: %s

en: Argument of %s at %L must be of length one
de: Argument von %s bei %L muss von der Länge eins sein

en: Argument of %s function at %L is negative
de: Argument der Funktion %s bei %L ist negativ

en: Argument of %s function at %L is too large for the collating sequence of kind %d
de: Argument der Funktion %s bei %L ist zu groß für die zusammenfassende Sequenz der Art %d

en: Argument of %s function at %L outside of range [0,127]
de: Argument der Funktion %s bei %L außerhalb des Wertebereichs [0,127]

en: Argument of ACOS at %L must be between -1 and 1
de: Argument von ACOS bei %L muss zwischen -1 und 1 liegen

en: Argument of ACOSD at %L must be between -1 and 1
de: Argument von ACOSD bei %L muss zwischen -1 und 1 liegen

en: Argument of ACOSH at %L must not be less than 1
de: Argument von ACOSH bei %L darf nicht kleiner als 1 sein

en: Argument of ASIN at %L must be between -1 and 1
de: Argument von ASIN bei %L muss zwischen -1 und 1 liegen

en: Argument of ASIND at %L must be between -1 and 1
de: Argument von ASIND bei %L muss zwischen -1 und 1 liegen

en: Argument of ATANH at %L must be inside the range -1 to 1
de: Argument von ATANH bei %L muss im Bereich -1 bis 1 liegen

en: Argument of FINAL procedure at %L must be of type %qs
de: Argument der FINAL-Prozedur bei %L muss Typ %qs haben

en: Argument of FINAL procedure at %L must not be ALLOCATABLE
de: Argument der FINAL-Prozedur bei %L darf nicht ALLOCATABLE sein

en: Argument of FINAL procedure at %L must not be INTENT(OUT)
de: Argument der FINAL-Prozedur bei %L darf nicht INTENT(OUT) sein

en: Argument of FINAL procedure at %L must not be OPTIONAL
de: Argument der FINAL-Prozedur bei %L darf nicht OPTIONAL sein

en: Argument of FINAL procedure at %L must not be a POINTER
de: Argument der FINAL-Prozedur bei %L darf kein POINTER sein

en: Argument of IACHAR at %L must be of length one
de: Argument von IACHAR bei %L muss Länge Eins haben

en: Argument of IACHAR function at %L outside of range 0..127
de: Argument der IACHAR-Funktion bei %L außerhalb des Wertebereiches 0..127

en: Argument of ICHAR at %L must be of length one
de: Argument von ICHAR bei %L muss Länge Eins haben

en: Argument of LOG at %L cannot be less than or equal to zero
de: Argument von LOG bei %L kann nicht kleiner oder gleich Null sein

en: Argument of LOG10 at %L cannot be less than or equal to zero
de: Argument von LOG10 bei %L kann nicht kleiner oder gleich Null sein

en: Argument of SELECT statement at %L cannot be %s
de: Argument der SELECT-Anweisung bei %L kann nicht %s sein

en: Argument of SELECT statement at %L must be a scalar expression
de: Argument der SELECT-Anweisung bei %L muss ein skalarer Ausdruck sein

en: Argument of SQRT at %L has a negative value
de: Argument von SQRT bei %L hat negativen Wert

en: Argument to %<-fcheck%> is not valid: %s
de: Argument für %<-fcheck%> ist ungültig: %s

en: Argument to %<-ffpe-summary%> is not valid: %s
de: Argument für %<-ffpe-summary%> ist ungültig: %s

en: Argument to %<-ffpe-trap%> is not valid: %s
de: Argument für %<-ffpe-trap%> ist ungültig: %s

en: Argument types of %qs intrinsic at %L must match (%s/%s)
de: Argumenttypen des intrinsischen %qs bei %L müssen passen (%s/%s)

en: Arguments of %qs at %L and %L cannot both be BOZ literal constants
de: Argumente von %qs bei %L und %L können nicht beide literale BOZ-Konstanten sein

en: Arguments of %qs have different kind type parameters at %L
de: Argumente von %qs unterscheiden sich im Typ bei %L

en: Arithmetic IF statement at %C
de: Arithmetische IF-Anweisung bei %C

en: Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression
de: Arithmetische IF-Anweisung bei %L erfordert einen skalaren REAL- oder INTEGER-Ausdruck

en: Arithmetic NaN at %L
de: Arithmetisches NaN bei %L

en: Arithmetic NaN converting %s to %s at %L. This check can be disabled with the option %<-fno-range-check%>
de: Arithmetisches NaN bei Umwandlung von %s in %s bei %L. Diese Überprüfung kann mit der Option %<-fno-range-check%> ausgeschaltet werden

en: Arithmetic OK at %L
de: Arithmetik OK bei %L

en: Arithmetic OK converting %s to %s at %L
de: Arithmetik OK beim Konvertieren von %s in %s bei %L

en: Arithmetic overflow at %L
de: Arithmetik-Überlauf bei %L

en: Arithmetic overflow converting %s to %s at %L. This check can be disabled with the option %<-fno-range-check%>
de: Arithmetischer Überlauf bei Umwandlung von %s in %s bei %L. Diese Überprüfung kann mit der Option %<-fno-range-check%> ausgeschaltet werden

en: Arithmetic underflow at %L
de: Arithmetik-Unterlauf bei %L

en: Arithmetic underflow converting %s to %s at %L. This check can be disabled with the option %<-fno-range-check%>
de: Arithmetischer Unterlauf bei Umwandlung von %s in %s bei %L. Diese Überprüfung kann mit der Option %<-fno-range-check%> ausgeschaltet werden

en: Array %qs at %L cannot have a deferred shape
de: Feld %qs bei %L kann keine aufgeschobene Form haben

en: Array %qs at %L is a variable, which does not reduce to a constant expression
de: Feld %qs bei %L ist eine Variable, die nicht zu konstantem Ausdruck reduziert

en: Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute.
de: Das Feld %qs bei %L ist größer als der Grenzwert, der durch %<-fmax-stack-var-size=%> festgelegt wurde, daher wurde es vom Stapel in den statischen Speicher verschoben. Dies macht die Prozedur unsicher, wenn sie rekursiv oder gleichzeitig von mehreren Threads aus aufgerufen wird. Erwägen Sie, die Grenze für %<-fmax-stack-var-size=%> anzuheben, verwenden Sie %<-frecursive%> (dadurch wird die Beschränkung von %<-fmax-stack-var-size%> aufgehoben), oder ändern Sie den Code so, dass er ein ALLOCATABLE-Feld verwendet. Wenn auf die Variable niemals nebenläufig zugegriffen wird, können Sie diese Warnung ignorieren, Sie könnten diese Variable auch mit dem Attribut SAVE deklarieren.

en: Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object
de: Feld %qs bei %L mit nicht-konstanten Grenzen kann kein EQUIVALENCE-Objekt sein

en: Array %qs is not permitted in reduction at %L
de: Feld %qs ist nicht in Reduzierung bei %L erlaubt

en: Array bound mismatch for dimension 1 of array (%ld/%ld)
de: Unstimmige Arraygrenzen für Dimension 1 des Arrays (%ld/%ld)

en: Array bound mismatch for dimension 2 of array (%ld/%ld)
de: Unstimmige Arraygrenzen für Dimension 2 des Arrays (%ld/%ld)

en: Array component of structure at %C must have an explicit shape
de: Feldkomponente der Struktur bei %C muss eine explizite Form haben

en: Array component of structure at %C must have explicit or deferred shape
de: Feldkomponente der Struktur bei %C muss explizite oder aufgeschobene Form haben

en: Array constructor including type specification at %C
de: Feldkonstruktor mit Typspezifikation bei %C

en: Array constructor value at %L shall not be unlimited polymorphic [F2008: C4106]
de: Wert für Feldkonstruktor bei %L darf nicht unbegrenzt polymorph sein [F2008: C4106]

en: Array entity required at %L
de: Feldeinheit bei %L benötigt

en: Array in initializer list at %L must have an explicit shape
de: Feld in der Initialisierungsliste bei %L muss eine explizite Form haben

en: Array index at %L is an array of rank %d
de: Feldindex bei %L ist ein Feld mit Rang %d

en: Array index at %L must be of INTEGER type, found %s
de: Feldindex bei %L muss INTEGER-Typ haben, %s gefunden

en: Array index at %L must be scalar
de: Feldindex bei %L muss skalar sein

en: Array is not contiguous at %L
de: Feld ist nicht zusammenhängend bei %L

en: Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size
de: Feld von interoperablem Typ bei %L für C_LOC; es ist nichtallozierbar und hat weder angenommene noch explizite Größe

en: Array operands are incommensurate at %L
de: Array-Operanden sind unzureichend bei %L

en: Array operands are incommensurate converting %s to %s at %L
de: Arrayoperanden sind unzureichend beim Konvertieren von %s in %s bei %L

en: Array pointer %qs at %L must have a deferred shape or assumed rank
de: Feldzeiger %qs bei %L muss aufgeschobene Form oder vermuteten Rang haben

en: Array reference at %C cannot have more than %d dimensions
de: Feldreferenz bei %C kann nicht mehr als %d Dimensionen haben

en: Array reference at %C has more than 7 dimensions
de: Feldreferenz bei %C darf nur maximal 7 Dimensionen haben

en: Array reference at %L is out of bounds (%ld < %ld) in codimension %d
de: Feldreferenz bei %L ist außerhalb der Grenzen (%ld < %ld) in Kodimension %d

en: Array reference at %L is out of bounds (%ld < %ld) in dimension %d
de: Feldreferenz bei %L ist außerhalb der Schranken (%ld < %ld) in Dimension %d

en: Array reference at %L is out of bounds (%ld > %ld) in codimension %d
de: Feldreferenz bei %L ist außerhalb der Grenzen (%ld > %ld) in Kodimension %d

en: Array reference at %L is out of bounds (%ld > %ld) in dimension %d
de: Feldreferenz bei %L ist außerhalb der Schranken (%ld > %ld) in Dimension %d

en: Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L
de: Feldreferenz bei %L ist außerhalb der Grenzen (%ld < %ld) in Schleife, die bei %L beginnt

en: Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L
de: Feldreferenz bei %L ist außerhalb der Grenzen (%ld > %ld) in Schleife, die bei %L beginnt

en: Array reference in EQUIVALENCE at %C cannot be an array section
de: Feldreferenz in EQUIVALENCE bei %C kann kein Feldabschnitt sein

en: Array reference out of bounds
de: Feldreferenz außerhalb des Wertebereichs

en: Array section at %L to C_LOC
de: Feldabschnitt bei %L für C_LOC

en: Array section designator, e.g. '(:)', is required besides the coarray designator '[...]' at %C
de: Feldauswahlbezeichner, z.B. »(:)«, wird neben dem Koarray-Bezeichner »[...]« bei %C benötigt

en: Array section with a vector subscript at %L shall not be the target of a pointer
de: Feldabschnitt mit Vektorindex bei %L darf nicht das Ziel eines Zeigers sein

en: Array sections: %qs not allowed in !$ACC DECLARE at %L
de: Feldabschnitte: %qs ist in !$ACC DECLARE bei %L nicht erlaubt

en: Array specification at %C has more than %d dimensions
de: Feldspezifikation bei %C hat mehr als %d Dimensionen

en: Array specification at %C with more than 7 dimensions
de: Feldspezifikation bei %C mit mehr als 7 Dimensionen

en: Array specification for symbol %qs in COMMON at %C must be explicit
de: Feldspezifikation für Symbol %qs in COMMON bei %C muss explizit sein

en: Array specification must be deferred at %L
de: Feldspezifikation muss bei %L aufgeschoben werden

en: Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L
de: Feldspezifikation oder feldwertiger SOURCE=-Ausdruck erforderlich in ALLOCATE-Anweisung bei %L

en: Array specification required in ALLOCATE statement at %L
de: In ALLOCATE-Anweisung bei %L ist Feld-Spezifikation erforderlich

en: Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute
de: Feldbereich als effektives Argument bei %L ist wegen VOLATILE-Attribut unverträglich mit dem Scheinargument ohne vermutete Form %qs

en: Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs
de: Feldbereich mit Vektorindex als effektives Argument bei %L ist unverträglich mit INTENT(OUT), INTENT(INOUT), VOLATILE- und ASYNCHRONOUS-Attribut des Scheinarguments %qs

en: As extending type %qs at %L has a coarray component, parent type %qs shall also have one
de: Da der erweiterte Typ %qs bei %L eine Koarray-Komponente hat, muss der Elterntyp %qs auch eine haben

en: Assembler options
    =================
de: Assembleroptionen
    =================

en: Assigned GOTO statement at %C
de: Zugewiesene GOTO-Anweisung bei %C

en: Assigned label is not a target label
de: Zugewiesene Marke ist keine Zielmarke

en: Assigning value other than 0 or 1 to LOGICAL has undefined result at %L
de: Zuweisung eines anderen Wertes als 0 oder 1 an LOGICAL hat bei %L undefiniertes Ergebnis

en: Assignment of scalar to unallocated array
de: Zuweisung von Skalar zu unalloziertem Array

en: Assignment operator interface at %L must be a SUBROUTINE
de: Schnittstelle für Zuweisungsoperator bei %L muss eine SUBROUTINE sein

en: Assignment operator interface at %L must have two arguments
de: Schnittstelle des Zuweisungsoperators bei %L muss zwei Argumente haben

en: Assignment operator interface at %L must not redefine an INTRINSIC type assignment
de: Schnittstelle des Zuweisungsoperators bei %L darf keine INTRINSIC Typzuweisung redefinieren

en: Assignment to a FORALL index variable at %L
de: Zuweisung an FORALL-Indexvariable bei %L

en: Assignment to a LEN or KIND part_ref at %L is not allowed
de: Die Zuweisung zu einer KIND- oder LEN-part_ref bei %L ist nicht erlaubt

en: Assignment to a constant expression at %C
de: Zuweisung an einen konstanten Ausdruck bei %C

en: Assignment to an allocatable polymorphic variable at %L
de: Zuweisung an allozierbare polymorphe Variable bei %L

en: Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>
de: Zuweisung an allozierbare polymorphe Variable bei %L erfordert %<-frealloc-lhs%>

en: Assignment to coindexed variable at %L in a PURE procedure
de: Zuweisung an koindizierte Variable bei %L in einer PURE-Prozedur

en: Assignment to contiguous pointer from non-contiguous target at %L
de: Zuweisung an zusammenhängenden Zeiger von nichtzusammenhängendem Ziel bei %L

en: Assignment to polymorphic coarray at %L is not permitted
de: Zuweisung an polymorphes Koarray bei %L ist nicht erlaubt

en: Associate name %qs in %s clause at %L
de: Associate-Name %qs in %s-Klausel bei %L

en: Associate name %qs in SHARED clause at %L
de: Associate-Name %qs in SHARED-Klausel bei %L

en: Associate-name %qs at %L is used as array
de: Zugeordneter Name %qs bei %L wird als Feld verwendet

en: Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either
de: Associate-Name %qs kann nicht in Variablen-Definitionskontext (%s) bei %L auftreten, da sein Ziel bei %L es auch nicht kann

en: Associating entity %qs at %L is a procedure name
de: Zugeordneter Name %qs bei %L ist ein Prozedurname

en: Associating entity %qs at %L is a procedure pointer
de: Zugeordneter Name %qs bei %L ist ein Prozedurzeiger

en: Associating selector-expression at %L yields a procedure
de: Der zuordnende Selektor-Ausdruck bei %L ergibt eine Prozedur

en: Association target at %C must not be coindexed
de: Verknüpfungsziel bei %C darf nicht koindiziert sein

en: Association target at %L cannot be a BOZ literal constant
de: Zuordnungsziel bei %L darf kein BOZ-Literal sein

en: Assume ES is zero throughout program execution, use ES: for read-only data.
de: Annehmen, dass ES während der gesamten Laufzeit 0 ist; verwenden Sie ES: für schreibgeschützte Daten.

en: Assume ICPLBs are enabled at runtime.
de: Annahme, dass ICPLBs zur Laufzeit eingeschaltet sind.

en: Assume a large TLS segment.
de: Von einem großen TLS-Segment ausgehen.

en: Assume all symbols have 32-bit values.
de: Annehmen, dass alle Symbole 32-Bit-Werte haben.

en: Assume all variable arg functions are prototyped.
de: Annehmen, dass alle Funktionen mit variablen Argumenten Prototypen haben.

en: Assume assembler support for (DWARF2+) .loc directives.
de: Assembler-Unterstützung für (DWARF2+-).loc-Direktiven annehmen.

en: Assume assembler support for view in (DWARF2+) .loc directives.
de: Assembler-Unterstützung für Ansicht in (DWARF2+-).loc-Direktiven annehmen.

en: Assume code will be assembled by GAS.
de: Annehmen, dass der Code mit GAS assembliert wird.

en: Assume code will be linked by GNU ld.
de: Annehmen, dass der Code später mit GNU ld gebunden wird.

en: Assume code will be linked by HP ld.
de: Annehmen, dass der Code später mit HP ld gebunden wird.

en: Assume common declarations may be overridden with ones with a larger trailing array.
de: Annehmen, dass gemeinsame Deklarationen durch solche übersteuert werden dürfen, die ein längeres hintangestelltes Array haben.

en: Assume data segments are relative to text segment.
de: Annehmen, dass Datensegmente relativ zum Textsegment liegen.

en: Assume floating-point operations can trap.
de: Annehmen, dass Gleitkommaoperationen abgefangen werden können (»trap«).

en: Assume incoming stack aligned to this power of 2.
de: Annehmen, dass der ankommende Stapel an dieser Potenz von 2 ausgerichtet ist.

en: Assume labels and symbols can be addressed using 16 bit absolute addresses.
de: Annahme, dass Marken und Symbole mit absoluten 16-Bit-Adressen adressiert werden können.

en: Assume loading data from flash is slower than fetching instructions.
de: Annehmen, dass das Datenladen aus dem Flashspeicher langsamer ist als Befehle zu laden.

en: Assume memory references are ordered and barriers are not needed.
de: Annehmen, dass die Speicherverweise geordnet sind und daher keine Barrieren erforderlich sind.

en: Assume no NaNs or infinities are generated.
de: Annehmen, dass keine NaNs oder Unendlichkeiten erzeugt werden.

en: Assume normal C execution environment.
de: Normale C-Ausführungsumgebung vermuten.

en: Assume pointer overflow wraps around.
de: Annehmen, dass Zeigerüberläufe überschlagen (Wraparound).

en: Assume possible double misalignment.
de: Mögliche doppelte Fehlausrichtung annehmen.

en: Assume round to nearest is selected for purposes of scheduling.
de: Rundung zur nächsten Ganzzahl für Zwecke der Planung annehmen.

en: Assume signed arithmetic overflow wraps around.
de: Annehmen, dass vorzeichenbehaftete arithmetische Überläufe regulär überschlagen (Wraparound).

en: Assume small address space.
de: Kleinen Adressraum annehmen.

en: Assume strict aliasing rules apply across (uninlined) function boundaries.
de: Annehmen, dass strenge Alias-Regeln über nicht-inline-Funktionsgrenzen hinweg gelten.

en: Assume strict aliasing rules apply.
de: Annehmen, dass strenge Alias-Regeln gelten.

en: Assume target CPU is configured as big endian.
de: Ziel-CPU als »big endian«-konfiguriert annehmen.

en: Assume target CPU is configured as little endian.
de: Ziel-CPU als »little endian«-konfiguriert annehmen.

en: Assume that all data in static storage can be accessed by LDS / STS.  This option is only useful for reduced Tiny devices.
de: Annemhne, dass auf alle Daten im statischen Speicher via LDS/STS zugegriffen werden kann. Diese Option ist nur für eingeschränkte Tiny-Geräte sinnvoll.

en: Assume that floating-point stores and loads are not likely to cause conflict when placed into one instruction group.
de: Annehmen, dass Gleitkomma-Speichern und -Laden wahrscheinlich keinen Konflikt verursachen, wenn sie in dieselbe Befehlsgruppe gelegt werden.

en: Assume that loops with an exit will terminate and not loop indefinitely.
de: Annehmen, dass Schleifen mit einem Ausgang keine Endlosschleifen sind.

en: Assume that receivers of Objective-C messages may be nil.
de: Annehmen, dass Empfänger von Objective-C-Nachrichten nil sein können.

en: Assume that run-time support has been provided, so omit -lsim from the linker command line.
de: Annehmen, dass Laufzeitunterstützung vorhanden ist, und daher -lsim von Linker-Kommandozeile auslassen.

en: Assume that standard D runtime libraries and "D main" exist.
de: Annehmen, dass Standard-D-Laufzeitbibliotheken und »D main« vorhanden sind.

en: Assume that the reciprocal estimate instructions provide more accuracy.
de: Annahme, dass die reziproken abschätzenden Befehle höhere Genauigkeit bieten.

en: Assume that the source file is fixed form.
de: Annehmen, dass Quelldatei in fester Form vorliegt.

en: Assume that the source file is free form.
de: Annehmen, dass Quelldatei in freier Form vorliegt.

en: Assume that values of enumeration type are always within the minimum range of that type.
de: Annehmen, dass die Werte einer Aufzählung immer im kleinsten Bereich des Typs liegen.

en: Assume that zero displacement conditional branches are fast.
de: Annehmen, dass bedingte Sprünge mit Weite Null schnell sind.

en: Assume the VxWorks RTP environment.
de: VxWorks RTP-Umgebung vermuten.

en: Assume the VxWorks vThreads environment.
de: VxWorks vThreads-Umgebung vermuten.

en: Assume unified syntax for inline assembly code.
de: Einheitliche Syntax für Inline-Assemblercode annehmen.

en: Assumed or deferred character length variable %qs in constant expression at %L
de: Variable %qs mit vermuteter oder aufgeschobener Zeichenlänge in konstantem Ausdruck bei %L

en: Assumed rank array %qs in %s clause at %L
de: Feld %qs mit vermutetem Rang in Klausel %s bei %L

en: Assumed shape array %qs at %L is not permitted in an initialization expression
de: Feld %qs mit vermuteter Form bei %L ist nicht in einem Initialisierungs-Ausdruck erlaubt

en: Assumed shape array at %L must be a dummy argument
de: Feld mit vermuteter Form bei %L muss ein Scheinargument sein

en: Assumed size array %qs at %L is not permitted in an initialization expression
de: Feld %qs mit vermuteter Größe bei %L ist nicht in einem Initialisierungs-Ausdruck erlaubt

en: Assumed size array %qs in %s clause at %L
de: Feld %qs mit vermuteter Größe in Klausel %s bei %L

en: Assumed size array %qs in COPYPRIVATE clause at %L
de: Feld %qs mit vermuteter Größe in Klausel COPYPRIVATE bei %L

en: Assumed size array %qs in namelist %qs at %C is not allowed
de: Feld %qs mit vermuteter Größe in Namensliste %qs bei %C ist nicht erlaubt

en: Assumed size array %qs in namelist %qs at %L is not allowed
de: Feld %qs mit vermuteter Größe in Namensliste %qs bei %L ist nicht erlaubt

en: Assumed size array at %L must be a dummy argument
de: Feld mit vermuteter Größe bei %L muss ein Schein-Argument sein

en: Assumed type at %C
de: Vermuteter Typ bei %C

en: Assumed type at %C is not allowed for components
de: Vermuteter Typ bei %C ist für Komponenten nicht erlaubt

en: Assumed type of variable %s at %L is only permitted for dummy variables
de: Vermuteter Typ der Variable %s bei %L ist nur für Scheinvariablen erlaubt

en: Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute
de: Das Zeichen-Dummy-Argument %qs bei %L hat eine angenommene Länge und gehört zur Prozedur %qs mit Attribut BIND(C)

en: Assumed-rank argument at %L is only permitted as actual argument to intrinsic inquiry functions
de: Argument mit angenommenem Rang bei %L ist nur als effektives Argument der intrinsischen Abfragefunktionen erlaubt

en: Assumed-rank argument at %L is only permitted as first actual argument to the intrinsic inquiry function %s
de: Argument mit angenommenem Rang bei %L ist nur als erstes effektives Argument der intrinsischen Abfragefunktion »%s« erlaubt

en: Assumed-rank argument requires an explicit interface at %L
de: Argument vermuteten Ranges erfordert eine explizite Schnittstelle bei %L

en: Assumed-rank array %qs at %L is not permitted in an initialization expression
de: Feld %qs mit vermutetem Rang bei %L ist nicht in einem Initialisierungs-Ausdruck erlaubt

en: Assumed-rank array at %C
de: Feld mit vermutetem Rang bei %C

en: Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute
de: Feld mit vermutetem Rang bei %L darf kein Attribut VALUE oder CODIMENSION haben

en: Assumed-rank array at %L must be a dummy argument
de: Feld mit vermutetem Rang bei %L muss ein Scheinargument sein

en: Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument
de: Variable %s vermuteten Ranges bei %L als effektives Argument für Abfragefunktion muss das erste Argument sein

en: Assumed-rank variable %s at %L may only be used as actual argument
de: Variable %s vermuteten Ranges bei %L kann nur als effektives Argument verwendet werden

en: Assumed-rank variable %s at %L shall not have a subobject reference
de: Variable »%s« vermuteten Ranges bei %L darf keine Referenz auf Subobjekt haben

en: Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute
de: Effektives Argument mit vermuteter Form bei %L ist wegen VOLATILE-Attribut unverträglich mit dem Scheinargument ohne vermutete Form %qs

en: Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L
de: Feld mit angenommener Form %qs bei %L als Scheinargument für die BIND(C)-Prozedur %qs bei %L

en: Assumed-shape array %qs at %L is not permitted in an initialization expression
de: Feld %qs mit vermuteter Form bei %L ist nicht in einem Initialisierungs-Ausdruck erlaubt

en: Assumed-size dummy array with !$ACC DECLARE at %L
de: Dummyfeld mit vermuteter Größe mit »!$ACC DECLARE« bei %L

en: Assumed-type actual argument at %L corresponding to assumed-rank dummy argument %qs must be assumed-shape or assumed-rank
de: Argument für angenommenen Typ bei %L, das dem Dummy-Argument %qs für den angenommenen Rang entspricht, muss von angenommener Form oder angenommenem Rang sein

en: Assumed-type actual argument at %L requires that dummy argument %qs is of assumed type
de: Feld mit vermutetem Rang bei %L erfordert Scheinargument %qs mit vermutetem Rang

en: Assumed-type argument %s at %L requires an explicit interface
de: Argument »%s« bei %L vermuteten Typs erfordert eine explizite Schnittstelle

en: Assumed-type argument at %L is not permitted as actual argument to the intrinsic %s
de: Argument bei %L mit angenommenem Typ ist nicht als effektives Argument der intrinsischen Routine »%s« erlaubt

en: Assumed-type argument at %L is only permitted as first actual argument to the intrinsic %s
de: Argument bei %L mit angenommenem Typ ist nur als erstes Argument der intrinsischen Routine »%s« erlaubt

en: Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument
de: Variable %s vermuteten Typs bei %L als effektives Argument für Abfragefunktion muss das erste Argument sein

en: Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute
de: Variable %s vermuteten Typs bei %L darf nicht die Attribute ALLOCATABLE, CODIMENSION, POINTER oder VALUE haben

en: Assumed-type variable %s at %L may not have the INTENT(OUT) attribute
de: Variable %s vermuteten Typs bei %L darf nicht das Attribut INTENT(OUT) haben

en: Assumed-type variable %s at %L may only be used as actual argument
de: Variable %s vermuteten Typs bei %L kann nur als effektives Argument verwendet werden

en: Assumed-type variable %s at %L shall not be an explicit-shape array
de: Variable %s vermuteten Typs bei %L darf kein Feld mit ausdrücklicher Form sein

en: Assumed-type variable %s at %L shall not have a subobject reference
de: Variable %s vermuteten Typs bei %L darf keine Referenz auf Subobjekt haben

en: At global scope:
de: Im globalen Gültigkeitsbereich:

en: At most %i profile runs is supported. Perhaps corrupted profile?
de: Es werden höchstens %i Profildurchläufe unterstützt. Evtl. beschädigte Datei?

en: At top level:
de: Auf höchster Ebene:

en: Attempt to DEALLOCATE unallocated '%s'
de: Versuch, nicht reserviertes »%s« freizugeben

en: Attempt to fill delay slots of branch instructions.
de: Versuchen, die Verzögerungsschlitze der Sprungbefehle auszufüllen.

en: Attempt to indirectly overlap COMMON blocks %s and %s by EQUIVALENCE at %C
de: Versuch, die COMMON-Blöcke %s und %s durch EQUIVALENCE bei %C indirekt zu überschneiden

en: Attempt to keep stack aligned to this power of 2.
de: Versuch, den Stapel an dieser Potenz von 2 auszurichten.

en: Attempt to merge identical constants across compilation units.
de: Versuchen, identische Konstanten über Übersetzungseinheiten hinweg zu verschmelzen.

en: Attempt to merge identical constants and constant variables.
de: Versuchen, identische Konstanten und konstante Variablen zu verschmelzen.

en: Attempt to merge identical debug strings across compilation units.
de: Versuchen, identische Zeichenketten zur Fehlersuche über Übersetzungseinheiten hinweg zu verschmelzen.

en: Attempting to allocate already allocated variable
de: Versuch, bereits reservierte Variable zu reservieren

en: Attempting to allocate already allocated variable '%s'
de: Versuch, bereits reservierte Variable »%s« zu reservieren

en: Attribute %s at %L in a TYPE definition
de: Attribut %s bei %L in einer TYPE-Definition

en: Attribute at %L is not allowed in a STRUCTURE definition
de: Attribut bei %L ist in STRUCTURE-Definition nicht erlaubt

en: Attribute at %L is not allowed in a TYPE definition
de: Attribut bei %L ist in TYPE-Definition nicht erlaubt

en: Attribute at %L is not allowed outside a TYPE definition
de: Attribut bei %L ist außerhalb einer TYPE-Definition nicht erlaubt

en: Augment variable location lists with progressive views.
de: Adresslisten der Variablen mit progressiven Sichten anreichern.

en: AutoFDO profile magic number does not match
de: Erkennungszahl des AutoFDO-Profils passt nicht

en: AutoFDO profile version %u does not match %u
de: Version %u des AutoFDO-Profils passt nicht zu %u

en: Automatic array %qs at %L cannot have an initializer
de: Automatisches Feld %qs bei %L kann keine Initialisierung haben

en: Automatically adds space for longer path names in load commands (up to MAXPATHLEN).
de: Fügt automatisch Platz für längere Pfadnamen in Ladebefehlen hinzu (bis zu MAXPATHLEN).

en: Automatically align branch targets to reduce branch penalties.
de: Zweigziele automatisch ausrichten, um Strafzyklen für Verzweigung zu verringern.

en: Available BITS selections:
de: Verfügbare Werte für Bits:

en: Average number of iterations of a loop.
de: Durchschnittliche Anzahl der Iterationen einer Schleife.

en: Avoid all range limits on call instructions.
de: Alle Bereichsgrenzen bei Aufrufbefehlen vermeiden.

en: Avoid combining multiple statements into one exploded edge.
de: Vermeiden, dass mehrere Anweisungen zu einer expandierten Kante zusammengefasst werden.

en: Avoid generating pc-relative calls; use indirection.
de: Erzeugung PC-relativer Aufrufe verhindern; Indirektion verwenden.

en: Avoid generation of indexed load/store instructions when possible.
de: Erzeugung indizierter Laden/Speichern-Befehle verhindern, wo möglich.

en: Avoid overlapping destination and address registers on LDRD instructions that may trigger Cortex-M3 errata.
de: Sich überschneidende Ziel- und Adressregister bei solchen LDRD-Befehlen vermeiden, die Cortex-M3-Errata auslösen können.

en: Avoid placing any readable data in program memory.
de: Vermeiden, lesbare Daten in Programmspeicher abzulegen.

en: Avoid speculative loads to work around a hardware anomaly.
de: Spekulative Ladeoperationen verhindern, um Hardwarebesonderheiten zu umgehen.

en: Avoid use of the DIV and MOD instructions.
de: Verwendung von DIV- und MOD-Befehlen verhindern.

en: BB %i cannot throw but has an EH edge
de: Interner Compilerfehler: BB %i cannot throw but has an EH edge

en: BB %i has incorrect edge
de: Interner Compilerfehler: BB %i has incorrect edge

en: BB %i has incorrect fallthru edge
de: Interner Compilerfehler: BB %i has incorrect fallthru edge

en: BB %i has multiple EH edges
de: Interner Compilerfehler: BB %i has multiple EH edges

en: BB %i is missing an EH edge
de: Interner Compilerfehler: BB %i is missing an EH edge

en: BB %i is missing an edge
de: Interner Compilerfehler: BB %i is missing an edge

en: BB %i last statement has incorrectly set lp
de: Interner Compilerfehler: BB %i last statement has incorrectly set lp

en: BB %i too many fallthru edges
de: Interner Compilerfehler: BB %i too many fallthru edges

en: BB_RTL flag not set for block %d
de: Interner Fehler: BB_RTL flag not set for block %d

en: BIND(C) Variable %qs at %L must have length one
de: BIND(C)-Variable %qs bei %L muss Länge eins haben

en: BIND(C) applied to %s %s at %L
de: BIND(C) auf %s %s bei %L angewendet

en: BIND(C) at %L
de: BIND(C) bei %L

en: BIND(C) attribute at %C requires an interface with BIND(C)
de: BIND(C)-Attribut bei %C erfordert eine Schnittstelle mit BIND(C)

en: BIND(C) attribute at %L can only be used for variables or common blocks
de: BIND(C)-Attribut bei %L kann nur für Variablen oder gemeinsame Blöcke verwendet werden

en: BIND(C) attribute at %L may not be specified for an internal procedure
de: BIND(C)-Attribut bei %L kann nicht für eine interne Prozedur angegeben werden

en: BIND(C) procedure with NAME may not have POINTER attribute at %C
de: BIND(C)-Prozedur mit NAME darf kein POINTER-Attribut bei %C haben

en: BIND(C) statement at %C
de: BIND(C)-Anweisung bei %C

en: BLANK= at %L not allowed in Fortran 95
de: BLANK= bei %L ist in Fortran 95 nicht erlaubt

en: BLOCK DATA construct at %L
de: BLOCK-DATA-Konstrukt bei %L

en: BLOCK DATA element %qs at %L must be in COMMON
de: BLOCK DATA Element %qs bei %L muss in COMMON sein

en: BLOCK construct at %C
de: BLOCK-Konstrukt bei %C

en: BMX instructions are only supported with R2 architecture
de: BMX-Befehle werden nur auf der R2-Architektur unterstützt

en: BOZ at %L cannot appear in an old-style initialization
de: BOZ bei %L kann nicht in einer Initialisierung alten Stils vorkommen

en: BOZ constant at %C uses nonstandard postfix syntax
de: BOZ-Konstante bei %C verwendet Nicht-Standard-Postfix-Syntax

en: BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram
de: BOZ-Konstante bei %L kann nicht innerhalb eines COMPLEX-intrinsischen Unterprogramms vorkommen

en: BOZ literal constant at %L cannot appear as an initializer
de: Die BOZ-Literalkonstante bei %L darf nicht als Initialisierer vorkommen

en: BOZ literal constant at %L cannot appear in ACHAR intrinsic subprogram
de: Die BOZ-Literalkonstante bei %L darf nicht in einem ACHAR-intrinsischen Unterprogramm vorkommen

en: BOZ literal constant at %L cannot appear in CHAR intrinsic subprogram
de: Die BOZ-Literalkonstante bei %L darf nicht in einem CHAR-intrinsischen Unterprogramm vorkommen

en: BOZ literal constant at %L cannot appear in a structure constructor
de: Die BOZ-Literalkonstante bei %L darf nicht in einem Strukturkonstruktor vorkommen

en: BOZ literal constant at %L cannot appear in an array constructor
de: Die BOZ-Literalkonstante bei %L darf nicht in einem Feldkonstruktor vorkommen

en: BOZ literal constant at %L cannot appear in an output IO list
de: BOZ-Literalkonstante bei %L darf nicht in einer Ausgabe-IO-Liste vorkommen

en: BOZ literal constant at %L cannot appear in the FLOAT intrinsic subprogram
de: BOZ-Literalkonstante bei %L darf nicht in einem FLOAT-intrinsischen Unterprogramm vorkommen

en: BOZ literal constant at %L cannot be an actual argument to %qs
de: Die BOZ-Literalkonstante bei %L darf kein tatsächliches Argument für %qs sein

en: BOZ literal constant at %L cannot be an operand of unary operator %qs
de: BOZ-Literalkonstante bei %L kann kein Operand des einstelligen Operators %qs sein

en: BOZ literal constant at %L is neither a DATA statement value nor an actual argument of INT/REAL/DBLE/CMPLX intrinsic subprogram
de: BOZ-Literal bei %L darf nur als Wert einer DATA-Anweisung oder als Argument des intrinsischen Unterprogramms INT/REAL/DBLE/CMPLX vorkommen

en: BOZ literal constant near %L cannot appear as an operand of a relational operator
de: BOZ-Literalkonstante bei %L kann nicht als Operand eines Vergleichsoperators vorkommen

en: BOZ literal constant near %L cannot be assigned to a %qs variable
de: BOZ-Literalkonstante in der Nähe von %L kann nicht einer %qs-Variablen zugewiesen werden

en: BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization
de: Die BOZ-Literalkonstante in der Nähe von %L kann bei einer Initialisierung alten Stils nicht einer %qs-Variablen zugewiesen werden

en: BOZ used outside a DATA statement at %L
de: BOZ außerhalb einer DATA-Anweisung bei %L verwendet

en: BPF CO-RE does not support LTO
de: BPF CO-RE unterstützt LTO nicht

en: BPF CO-RE requires BTF debugging information, use %<-gbtf%>
de: BPF CO-RE erfordert BTF-Debugging-Informationen, verwenden Sie %<-gbtf%>

en: BYTE type at %C
de: BYTE-Typ bei %C

en: BYTE type used at %C is not available on the target machine
de: Bei %C verwendeter BYTE-Typ ist auf der Zielmaschine nicht verfügbar

en: Bad 128-bit move
de: Falsche 128-Bit-Verschiebung

en: Bad GPR fusion
de: Falsche GPR-Fusion

en: Bad INTENT specification at %C
de: Falsche INTENT-Spezifikation bei %C

en: Bad IO basetype (%d)
de: Falscher IO-Basistyp (%d)

en: Bad allocate-object at %C for a PURE procedure
de: Falsches Reservierungs-Objekt bei %C für eine PURE-Prozedur

en: Bad array dimension at %L
de: Ungültige Felddimension bei %L

en: Bad array reference at %L
de: Ungültige Feldreferenz bei %L

en: Bad array spec of component %qs referenced in structure constructor at %L
de: Der Strukturkonstruktor bei %2$L verweist auf die falsche Feldangabe der Komponente %1$qs

en: Bad array specification for an explicitly shaped array at %C
de: Falsche Feldangabe für Feld mit explizit gebildeter Form bei %C

en: Bad array specification for assumed shape array at %C
de: Falsche Feldangabe für Feld mit durch Vermutung gebildeter Form bei %C

en: Bad array specification for implied-shape array at %C
de: Falsche Feldangabe für Feld mit implizit gebildeter Form bei %C

en: Bad array specification in ALLOCATE statement at %L
de: Falsche Feldspezifikation in ALLOCATE-Anweisung bei %L

en: Bad character %qc in OPERATOR name at %C
de: Ungültiges Zeichen %qc in OPERATOR-Name bei %C

en: Bad coarray specification in ALLOCATE statement at %L
de: Falsche Koarray-Spezifikation in ALLOCATE-Anweisung bei %L

en: Bad continuation line at %C
de: Falsche Fortsetzungszeile bei %C

en: Bad kind expression for function %qs at %L
de: Falscher Art-Ausdruck für Funktion %qs bei %L

en: Bad kind for logical constant at %C
de: Falsche Art für Logikkonstante bei %C

en: Bad name
de: Schlechter Name

en: Bad operator
de: Falscher Operator

en: Bad specification for assumed size array at %C
de: Falsche Spezifikation für Feld mit impliziter Größe bei %C

en: Bad specification for assumed size array at %L
de: Falsche Spezifikation für Feld bei %L mit angenommener Größe

en: Bad specification for deferred shape array at %C
de: Falsche Spezifikation für Feld mit zurückgestellter Form bei %C

en: Bad target in pointer assignment in PURE procedure at %L
de: Falsches Ziel in Zeigerzuweisung in PURE-Prozedur bei %L

en: Bad type in constant expression
de: Falscher Typ in Konstanten-Ausdruck

en: Base ABI types for LoongArch:
de: Basis-ABI-Typen für LoongArch:

en: Base object for NOPASS type-bound procedure call at %L must be scalar
de: Basisobjekt für Aufruf der typgebundenen NOPASS-Prozedur bei %L muss skalar sein

en: Base object for procedure-pointer component call at %L is of ABSTRACT type %qs
de: Basisobjekt für Aufruf der Prozedurzeigerkomponente bei %L hat ABSTRACT-Typ %qs

en: Base object for type-bound procedure call at %L is of ABSTRACT type %qs
de: Basisobjekt für Aufruf der typgebundenen Prozedur bei %L hat ABSTRACT-Typ %qs

en: Basic ISAs of LoongArch:
de: Grundlegende ISAs von LoongArch:

en: Binding at %C must have the same access as already defined binding %qs
de: Bindung bei %C muss denselben Zugriff wie bereits definierte Bindung %qs haben

en: Binding attributes already specify passing, illegal NOPASS at %C
de: Bindeattribute legen bereits Durchleitung fest, unzulässiges NOPASS bei %C

en: Binding attributes already specify passing, illegal PASS at %C
de: Bindeattribute legen bereits Durchleitung fest, unzulässiges PASS bei %C

en: Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L
de: Leeres BLOCK DATA bei %C steht in Konflikt mit vorherigem BLOCK DATA bei %L

en: Blank required in %s statement near %C
de: Leerzeichen in %s-Anweisung in der Nähe von %C erwartet

en: Blanket SAVE statement at %C follows previous SAVE statement
de: Umfassende SAVE-Anweisung bei %C folgt vorheriger SAVE-Anweisung

en: Block label is not appropriate for IF statement at %C
de: Blockmarke ist ungeeignet für IF-Anweisung bei %C

en: Block label not appropriate for arithmetic IF statement at %C
de: Blockmarke passt nicht zu arithmetischer IF-Anweisung bei %C

en: Board name [and memory region].
de: Boardname [und Speicherbereich].

en: Both MONOTONIC and NONMONOTONIC schedule modifiers specified at %L
de: Beide Planungsmodifizierer MONOTONIC und NONMONOTONIC bei %L angegeben

en: Both section and comdat group is set
de: Interner Fehler: Both section and comdat group is set

en: Bound on number of candidates below that all candidates are considered in iv optimizations.
de: Schranke für Anzahl der Kandidaten, unter der alle Kandidaten in IV-Optimierungen betrachtet werden.

en: Bound on number of iv uses in loop optimized in iv optimizations.
de: Schranke für Anzahl der IV-Verwendungen in bei IV-Optimierungen optimierter Schleife.

en: Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check.
de: Schranke für Anzahl der Laufzeitprüfungen, die von Schleifenversionierung des Vektorisierers für Aliasprüfung eingefügt werden.

en: Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check.
de: Schranke für Anzahl der Laufzeitprüfungen, die von Schleifenversionierung des Vektorisierers für Ausrichtungsprüfung eingefügt werden.

en: Bound on size of expressions used in the scalar evolutions analyzer.
de: Schranke für Größe von Ausdrücken, die im skalaren Evolutions-Analysierer verwendet werden.

en: Bound on the complexity of the expressions in the scalar evolutions analyzer.
de: Schranke für die Komplexität von Ausdrücken im skalaren Evolutions-Analysierer.

en: Bound on the cost of an expression to compute the number of iterations.
de: Schranke für die Kosten eines Ausdrucks, um die Anzahl der Durchläufe zu berechnen.

en: Bound on the number of iterations the brute force # of iterations analysis algorithm evaluates.
de: Schranke für die Anzahl der Iterationen, die der Brute-Force-Algorithmus zur Auswertung der Anzahl von Iterationen auswertet.

en: Bounds specification for %qs in pointer assignment at %L
de: Grenzenangabe für %qs in Zeigerzuweisung bei %L

en: Branch at %L may result in an infinite loop
de: Sprung bei %L könnte Endlosschleife bewirken

en: Branches are this expensive (arbitrary units).
de: Verzweigungen sind so teuer wie hier angegeben (beliebige Einheit).

en: Branches executed:%s of %d
de: %s von %d Zweigen ausgeführt

en: Build for Core A.
de: Für Kern A bauen.

en: Build for Core B.
de: Für Kern B bauen.

en: Build for SDRAM.
de: Für SDRAM bauen.

en: Builtin %qF requires z14 or higher
de: Eingebaute %qF erfordert z14 oder höher

en: Builtin %qF requires z15 or higher
de: Eingebaute %qF erfordert z15 oder höher

en: Builtin not implemented
de: Eingebaute Funktion nicht implementiert

en: By-value argument at %L cannot be an array or an array section
de: Wertargument bei %L kann kein Feld oder Feldabschnitt sein

en: By-value argument at %L is not allowed in this context
de: Wertargument bei %L ist in diesem Kontext nicht erlaubt

en: By-value argument at %L is not of numeric type
de: Wertargument bei %L hat keinen numerischen Typ

en: C interoperable character dummy variable %qs at %L with VALUE attribute must have length one
de: C-kompatible zeichenwertige Scheinvariable %qs bei %L mit VALUE-Attribut muss Länge eins haben

en: C kind type parameter is for type %s but type at %L is %s
de: Typ-Parameter nach C-Art ist für Typ %s, aber Typ bei %L ist %s

en: C++ constructors and destructors will not be invoked for Objective-C fields
de: C++-Konstruktoren und -Destruktoren werden für Objective-C-Felder nicht aufgerufen

en: C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>
de: designierte Initialisierer für C++ sind erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: C++ lookup of %qD would return a field, not a type
de: Nachschlagen von %qD würde in C++ ein Feld, keinen Typen zurückgeben

en: C++ modules are incompatible with precompiled headers
de: C++-Module sind nicht kompatibel mit vorkompilierten Headern

en: C++ modules are incompatible with traditional preprocessing
de: C++-Module sind nicht mit der traditionellen Vorverarbeitung kompatibel

en: C++ requires promoted type, not enum type, in %<va_arg%>
de: C++ erfordert weitergegebenen Typ, nicht Enum-Typ, in %<va_arg%>

en: C++11 %<constexpr%> only available with %<-std=c++11%> or %<-std=gnu++11%>
de: %<constexpr%> von C++11 ist nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: C++11 %<noexcept%> only available with %<-std=c++11%> or %<-std=gnu++11%>
de: %<noexcept%> von C++11 ist nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: C++11 %<thread_local%> allows dynamic initialization and destruction
de: %<thread_local%> in C++11 erlaubt dynamische Initialisierung und Zerstörung

en: C++11 %<thread_local%> only available with %<-std=c++11%> or %<-std=gnu++11%>
de: %<thread_local%> von C++11 ist nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>
de: C++11-Attribute sind erst ab %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>
de: C++11 %<auto%> ist nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: C++20 %<constinit%> only available with %<-std=c++20%> or %<-std=gnu++20%>
de: %<constinit%> aus C++20 ist erst ab %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: C++20 %qE only available with %<-fmodules-ts%>
de: C++20 %qE ist nur mit %<-fmodules-ts%> verfügbar

en: C++20 %qE only available with %<-fmodules-ts%>, which is not yet enabled with %<-std=c++20%>
de: %qE aus C++20 ist nur mit %<-fmodules-ts%> verfügbar, das ist jedoch noch nicht in %<-std=c++20%> enthalten

en: C++20 concept definition syntax is %<concept <name> = <expr>%>
de: Die Schreibweise der C++20-Konzeptdefinition ist %<concept <Name> = <Ausdruck>%>

en: C99 designator %qE is not an integral constant-expression
de: C99-Designator %qE ist kein konstanter Ganzzahlausdruck

en: C99 designator %qE outside aggregate initializer
de: C99-Bezeichner %qE außerhalb von Aggregatinitialisierung

en: CASE label at %L overlaps with CASE label at %L
de: CASE-Marke bei %L überschneidet sich mit CASE-Marke bei %L

en: CCTL intrinsic function subtype out of range
de: Untertyp der intrinsischen CCTL-Funktion ist außerhalb des gültigen Bereichs

en: CDX instructions are only supported with R2 architecture
de: CDX-Befehle werden nur auf der R2-Architektur unterstützt

en: CFString literal expression is not a string constant
de: CFString-Literalausdruck ist keine Zeichenkettenkonstante

en: CFString literal is missing
de: CFString-Literal fehlt

en: CHANGE TEAM statement at %C
de: CHANGE-TEAM-Anweisung bei %C

en: CHARACTER expression at %L is being truncated (%ld/%ld)
de: CHARACTER-Ausdruck bei %L wird abgeschnitten (%ld/%ld)

en: CHARACTER expression will be truncated in assignment (%ld/%ld) at %L
de: CHARACTER-Ausdruck wird in Zuweisung (%ld/%ld) bei %L abgeschnitten

en: CHARACTER expression will be truncated in constructor (%ld/%ld) at %L
de: CHARACTER-Ausdruck wird in Konstruktor (%ld/%ld) bei %L abgeschnitten

en: CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L
de: CHARACTER-Länge in !$OMP DECLARE REDUCTION %s ist bei %L nicht konstant

en: CHARACTER length must be a constant at %L
de: CHARACTER-Länge bei %L muss konstant sein

en: CHARACTER(*) function %qs at %L
de: CHARACTER(*)-Funktion %qs bei %L

en: CHARACTER(*) function %qs at %L cannot be array-valued
de: CHARACTER(*)-Funktion %qs bei %L darf nicht feld-wertig sein

en: CHARACTER(*) function %qs at %L cannot be pointer-valued
de: CHARACTER(*)-Funktion %qs bei %L darf nicht zeiger-wertig sein

en: CHARACTER(*) function %qs at %L cannot be pure
de: CHARACTER(*)-Funktion %qs bei %L darf nicht rein sein

en: CHARACTER(*) function %qs at %L cannot be recursive
de: CHARACTER(*)-Funktion %qs bei %L darf nicht rekursiv sein

en: CLASS entity at %C cannot have the PARAMETER attribute
de: CLASS-Entität bei %C kann nicht das PARAMETER-Attribut haben

en: CLASS selector at %L needs a temporary which is not yet implemented
de: CLASS-Selektor bei %L erfordert Zwischenspeicher, was noch nicht implementiert ist

en: CLASS statement at %C
de: CLASS-Anweisung bei %C

en: CLASS variable %qs at %L cannot have the PARAMETER attribute
de: COMMON-Block %qs bei %L kann nicht das EXTERNAL-Attribut haben

en: CLASS variable %qs at %L must be dummy, allocatable or pointer
de: CLASS-Variable %qs bei %L muss Attrappe, reservierbar oder Zeiger sein

en: CLOSE statement at %L requires a UNIT number
de: CLOSE-Anweisung bei %L erfordert eine UNIT-Zahl

en: CLOSE statement not allowed in PURE procedure at %C
de: CLOSE-Anweisung in PURE-Prozedur bei %C nicht erlaubt

en: CODIMENSION specified for %qs outside its INTERFACE body at %L
de: CODIMENSION für %qs außerhalb seines INTERFACE-Körpers bei %L angegeben

en: COLLAPSE clause argument not constant positive integer at %C
de: Argument der COLLAPSE-Klausel ist keine konstante positive Ganzzahl bei %C

en: COLLECT_GCC must be set
de: COLLECT_GCC muss gesetzt sein

en: COLLECT_GCC must be set.
de: COLLECT_GCC muss gesetzt sein.

en: COMMON %qs at %L does not exist
de: COMMON %qs bei %L existiert nicht

en: COMMON %qs at %L requires %d bytes of padding; reorder elements or use %<-fno-align-commons%>
de: COMMON %qs bei %L erfordert Auffüllen mit %d Bytes; bitte Elemente umordnen oder %<-fno-align-commons%> verwenden

en: COMMON at %L mentioned multiple times in clauses of the same OMP DECLARE TARGET directive
de: COMMON bei %L wird mehrfach in Klauseln derselben OMP-DECLARE-TARGET-Direktive erwähnt

en: COMMON at %L requires %d bytes of padding; reorder elements or use %<-fno-align-commons%>
de: COMMON bei %L erfordert Auffüllen mit %d Bytes; bitte Elemente umordnen oder %<-fno-align-commons%> verwenden

en: COMMON at %L set in previous OMP DECLARE TARGET directive to a different DEVICE_TYPE
de: COMMON bei %L wurde in einer vorangehenden Direktive OMP DECLARE TARGET auf einen abweichenden DEVICE_TYPE festgelegt

en: COMMON block %qs at %L cannot have the EXTERNAL attribute
de: COMMON-Block %qs bei %L kann nicht das EXTERNAL-Attribut haben

en: COMMON block %qs at %L is also an intrinsic procedure
de: COMMON-Block %qs bei %L ist auch eine intrinsische Prozedur

en: COMMON block %qs at %L is used as PARAMETER at %L
de: COMMON-Block %qs bei %L wird bei %L als PARAMETER verwendet

en: COMMON block %qs at %L that is also a function result
de: COMMON-Block %qs bei %L, der auch ein Funktionsergebnis ist

en: COMMON block %qs at %L that is also a global procedure
de: COMMON-Block %qs bei %L, der auch eine globale Prozedur ist

en: COMMON block %qs at %L uses the same global identifier as entity at %L
de: COMMON-Block %qs bei %L verwendet denselben globalen Bezeichner wie die Entität bei %L

en: COMMON block /%s/ not found at %C
de: COMMON-Block /%s/ bei %C nicht gefunden

en: COMMON block at %L
de: COMMON-Block bei %L

en: COMMON block at %L with binding label %qs uses the same global identifier as entity at %L
de: COMMON-Block bei %L mit Bindungsmarke %qs verwendet denselben globalen Bezeichner wie Entität bei %L

en: COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs
de: COMMON-Blockelement %qs bei %L darf in der PURE-Prozedur %qs kein EQUIVALENCE-Objekt sein

en: COMMON variable %qs at %L must have constant character length
de: COMMON-Variable %qs bei %L muss konstante Zeichenlänge haben

en: COMPLEX argument %qs of %qs intrinsic at %L
de: COMPLEX-Argument %qs ist Argument des intrinsischen %qs bei %L

en: COMPLEX quantities cannot be compared at %L
de: COMPLEX-Größen können nicht bei %L verglichen werden

en: CONTAINS block in derived type definition at %C
de: CONTAINS-Block in Definition des abgeleiteten Typs bei %C

en: CONTAINS statement at %C is already in a contained program unit
de: CONTAINS-Anweisung bei %C ist bereits in einer enthaltenen Programmeinheit

en: CONTAINS statement without FUNCTION or SUBROUTINE statement at %L
de: CONTAINS-Anweisung ohne FUNCTION- oder SUBROUTINE-Anweisung bei %L

en: CONTIGUOUS attribute at %C
de: CONTIGUOUS-Attribut bei %C

en: CONTIGUOUS statement at %C
de: CONTIGUOUS-Anweisung bei %C

en: CONVERT tag at %L
de: CONVERT-Marke bei %L

en: COUNT argument of the EVENT_QUERY intrinsic function at %L shall be definable
de: COUNT-Argument der intrinsischen Funktion »EVENT_QUERY« bei %L muss definierbar sein

en: COUNT argument of the EVENT_QUERY intrinsic function at %L shall have at least the range of the default integer
de: COUNT-Argument der intrinsischen Funktion EVENT_QUERY bei %L muss mindestens den Gültigkeitsbereich von Standard-Integer abdecken

en: COUNT argument to SYSTEM_CLOCK at %L has non-default kind
de: Das COUNT-Argument für SYSTEM_CLOCK bei %L hat nicht-Standard-Art

en: COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind
de: Das COUNT_MAX-Argument für SYSTEM_CLOCK bei %L hat nicht-Standard-Art

en: COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind
de: Das COUNT_RATE-Argument für SYSTEM_CLOCK bei %L hat nicht-Standard-Art

en: CPU you selected does not support x86-64 instruction set
de: Die ausgewählte CPU unterstützt nicht den x86-64-Befehlssatz

en: CRIS-port assertion failed: %s
de: CRIS-Port-Behauptung gescheitert: %s

en: CRITICAL block inside of OpenACC region at %C
de: CRITICAL-Block innerhalb von OpenACC-Region bei %C

en: CRITICAL block inside of OpenMP region at %C
de: CRITICAL-Block innerhalb von OpenMP-Region bei %C

en: CRITICAL statement at %C
de: CRITICAL-Anweisung bei %C

en: CTF debug info requested, but not supported for %qs frontend
de: CTF-Debuginformationen angefordert, jedoch nicht vom %qs-Frontend unterstützt

en: CYCLE statement at %C is not applicable to non-loop construct %qs
de: CYCLE-Anweisung bei %C ist nicht auf Nicht-Schleifenkonstrukt %qs anwendbar

en: CYCLE statement at %C to non-innermost collapsed !$ACC LOOP loop
de: CYCLE-Anweisung bei %C für nicht-innerste eingeklappte »!$ACC LOOP«-Schleife

en: CYCLE statement at %C to non-innermost collapsed !$OMP DO loop
de: CYCLE-Anweisung bei %C für nicht-innerste eingestürzte !$OMP DO-Schleife

en: CYCLE statement at %C to non-innermost tiled !$ACC LOOP loop
de: CYCLE-Anweisung bei %C für nicht-innerste gekachelte »!$ACC LOOP«-Schleife

en: Call mcount for profiling before a function prologue.
de: Vor jedem Funktionsprolog mcount für Profiling aufrufen.

en: Call the dump function for variables and function in IL.
de: Dump-Funktion für Variablen und Funktion in IL aufrufen.

en: Caller copies function arguments passed by hidden reference.
de: Der Aufrufer kopiert Funktionsargumente, die über versteckte Referenzen übergeben werden.

en: Calls executed:%s of %d
de: %s von %d Aufruf(en) ausgeführt

en: Cannot IMPORT %qs from host scoping unit at %C - does not exist.
de: IMPORT %qs aus Host-Sichtbarkeitseinheit bei %C nicht möglich - existiert nicht.

en: Cannot USE a module that is currently built
de: Das Modul, das gerade gebaut wird, kann nicht gleichzeitig mit USE verwendet werden

en: Cannot USE a submodule that is currently built
de: Das Teilmodul, das gerade gebaut wird, kann nicht gleichzeitig mit USE verwendet werden

en: Cannot change attributes of USE-associated symbol %s at %L
de: Attribute des USE-verbundenen Symbols %s bei %L können nicht verändert werden

en: Cannot change attributes of USE-associated symbol at %L
de: Attribute des USE-verbundenen Symbols bei %L können nicht verändert werden

en: Cannot change directory to %s
de: Verzeichnis %s kann nicht gewechselt werden

en: Cannot compute the length of the char array at %L.
de: Länge des Arrays bei %L kann nicht berechnet werden.

en: Cannot construct ABSTRACT type %qs at %L
de: ABSTRACT-Typ %qs bei %L kann nicht konstruiert werden

en: Cannot convert %qs to %qs at %L
de: Interner Fehler: Cannot convert %qs to %qs at %L

en: Cannot convert %qs to interoperable type at %L
de: %qs bei %L kann nicht in interoperablen Typ konvertiert werden

en: Cannot convert %s to %s at %L
de: %s kann nicht nach %s bei %L umgewandelt werden

en: Cannot delete module file %qs: %s
de: Moduldatei %qs kann nicht gelöscht werden: %s

en: Cannot delete temporary module file %qs: %s
de: Temporäre Moduldatei %qs kann nicht gelöscht werden: %s

en: Cannot find an intrinsic module named %qs at %C
de: Intrinsisches Modul namens %qs bei %C nicht gefunden

en: Cannot find keyword named %qs in call to %qs at %L
de: Schlüsselwort %qs in Aufruf von %qs bei %L kann nicht gefunden werden

en: Cannot find symbol %qs
de: Das Symbol %qs kann nicht gefunden werden

en: Cannot get current directory name
de: Name des aktuellen Verzeichnisses kann nicht ermittelt werden

en: Cannot initialize implied-shape array at %L with scalar
de: Das implied-shape-Feld bei %L kann nicht mit Skalar initialisiert werden

en: Cannot initialize parameter array at %L with variable length elements
de: Parameter-Feld bei %L kann nicht mit Elementen variabler Länge initialisiert werden

en: Cannot make directory %s
de: Verzeichnis %s kann nicht erstellt werden

en: Cannot map %s
de: »%s« kann nicht in den Speicher geladen werden

en: Cannot open %s
de: »%s« kann nicht geöffnet werden

en: Cannot open JSON output file %s
de: JSON-Ausgabedatei »%s« konnte nicht geöffnet werden

en: Cannot open file %qs
de: Datei %qs kann nicht geöffnet werden

en: Cannot open included file %qs
de: Die eingebundene Datei %qs kann nicht geöffnet werden

en: Cannot open module file %qs for reading at %C: %s
de: Moduldatei %qs kann bei %C nicht zum Lesen geöffnet werden: %s

en: Cannot open module file %qs for writing at %C: %s
de: Moduldatei %qs kann bei %C nicht zum Schreiben geöffnet werden: %s

en: Cannot open pre-included file %qs
de: Die vor-eingebundene Datei %qs kann nicht geöffnet werden

en: Cannot open source file %s
de: Quelldatei %s kann nicht geöffnet werden

en: Cannot overwrite GENERIC %qs at %L
de: GENERIC %qs bei %L kann nicht überschrieben werden

en: Cannot read %s
de: »%s« kann nicht gelesen werden

en: Cannot read module file %qs opened at %C, because it was created by a different version of GNU Fortran
de: Bei %2$C geöffnete Moduldatei %1$qs kann nicht gelesen werden, da sie von einer anderen Version von GNU Fortran erstellt wurde

en: Cannot rename module file %qs to %qs: %s
de: Moduldatei %qs kann nicht in %qs umbenannt werden: %s

en: Cannot set Cray pointee array spec.
de: Interner Fehler: Cannot set Cray pointee array spec.

en: Cannot set pointee array spec.
de: Interner Fehler: Cannot set pointee array spec.

en: Cannot specify IMPLICIT at %C after IMPLICIT NONE
de: IMPLICIT bei %C kann nicht hinter IMPLICIT NONE angegeben werden

en: Catch typos.
de: Tippfehler abfangen.

en: Cause gas to print tomcat statistics.
de: Gas veranlassen, Tomcat-Statistiken auszugeben.

en: Cgraph edge statement index not found
de: Index der Cgraph-Kantenanweisung nicht gefunden

en: Cgraph edge statement index out of range
de: Index der Cgraph-Kantenanweisung außerhalb des gültigen Bereichs

en: Chained transparent aliases
de: Interner Fehler: Chained transparent aliases

en: Change of value in conversion from %qs to %qs at %L
de: Wertänderung bei Umwandlung von %qs in %qs bei %L

en: Change only the low 8 bits of the stack pointer.
de: Nur die unteren 8 Bit des Stapelzeigers verändern.

en: Change the ABI to allow double word insns.
de: ABI ändern, um Doppelwortbefehle zuzulassen.

en: Change the amount of scheduler lookahead.
de: Menge der Vorausplanung ändern.

en: Change the maximum length of conditionally-executed sequences.
de: Größte Länge der bedingt ausgeführten Sequenzen ändern.

en: Change the number of temporary registers that are available to conditionally-executed sequences.
de: Anzahl der temporären Register ändern, die für bedingt ausgeführte Sequenzen zur Verfügung stehen.

en: Change the stack pointer without disabling interrupts.
de: Stapelzeiger ändern, ohne Unterbrechungen (Interrupts) auszuschalten.

en: Changes visibility to match Microsoft Visual Studio by default.
de: Sichtbarkeit wird geändert, um standardmäßig zu Microsoft Visual Studio zu passen.

en: Character %qs in string at %C is not representable in character kind %d
de: Zeichen %qs in Zeichenkette bei %C ist in Zeichenart %d nicht repräsentierbar

en: Character %qs in string at %L cannot be converted into character kind %d
de: Zeichen %qs in Zeichenkette bei %L kann nicht in Zeichenart %d umgewandelt werden

en: Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE
de: Zeichenkomponente %qs von %qs bei %L mit aufgeschobener Länge muss POINTER oder ALLOCATABLE sein

en: Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute
de: Das Zeichen-Dummy-Argument %qs bei %L muss entweder die konstante Länge 1 haben oder eine angenommene Länge, es sei denn, es hat eine angenommene Form oder einen angenommenen Rang, da die Prozedur %qs das Attribut BIND(C) hat

en: Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute
de: Das Zeichen-Dummy-Argument %qs bei %L muss die Länge 1 haben, da es das Attribut VALUE hat

en: Character dummy variable %qs at %L with VALUE attribute must have constant length
de: Zeichenwertige Scheinvariable %qs bei %L mit VALUE-Attribut muss konstante Länge haben

en: Character length mismatch (%ld/%ld) between actual argument and assumed-shape dummy argument %qs at %L
de: Zeichenlänge passt nicht (%ld/%ld) zwischen effektivem Argument und Scheinargument %qs mit vermuteter Form bei %L

en: Character length mismatch (%ld/%ld) between actual argument and pointer or allocatable dummy argument %qs at %L
de: Zeichenlänge passt nicht (%ld/%ld) zwischen effektivem Argument und Zeiger oder reservierbarem Scheinargument %qs bei %L

en: Character length of actual argument shorter than of dummy argument %qs (%lu/%lu) at %L
de: Zeichenlänge des effektiven Arguments kürzer als das des Scheinarguments %qs (%lu/%lu) bei %L

en: Character length of component %qs needs to be a constant specification expression at %L
de: Zeichenlänge der Komponente %qs muss ein konstanter Spezifikationsausdruck bei %L sein

en: Character-valued argument %qs of statement function at %L must have constant length
de: Zeichenwertiges Argument %qs der Anweisungsfunktion bei %L muss konstante Länge haben

en: Character-valued internal function %qs at %L must not be assumed length
de: Zeichenwertige interne Funktion %qs bei %L darf keine angenommene Länge haben

en: Character-valued module procedure %qs at %L must not be assumed length
de: Zeichenwertige Modulprozedur %qs bei %L darf keine vermutete Länge haben

en: Character-valued statement function %qs at %L must have constant length
de: Zeichenwertige Anweisungsfunktion %qs bei %L muss konstante Länge haben

en: Check for stack overflow at runtime.
de: Zur Laufzeit auf Stapelüberlauf prüfen.

en: Check for syntax errors, then stop.
de: Auf Syntaxfehler prüfen, dann anhalten.

en: Check the return value of new in C++.
de: Rückgabewert des C++-Operators new prüfen.

en: Chose strategy to generate stringop using.
de: Strategie zur Erzeugung von Zeichenkettenoperationen wählen.

en: Chunk size of omp schedule for loops parallelized by parloops.
de: Häppchengröße des OMP-Schedulers für Schleifen, die durch parloops parallelisiert wurden.

en: Clause expected at %C
de: Klausel erwartet bei %C

en: Clause expected at %C after trailing comma
de: Klausel erwartet bei %C nach dem abschließenden Komma

en: Clear all tune features.
de: Alle Tuningfeatures zurücksetzen.

en: Clear call-used registers upon function return.
de: Register, die beim Funktionsaufruf verwendet wurden, am Ende auf 0 zurücksetzen.

en: Clear hardware capabilities when linking.
de: Hardwarefähigkeiten beim Linken löschen.

en: Clear the BSS to zero and place zero initialized in BSS.
de: BSS komplett löschen und mit Null initialisierte Werte in BSS platzieren.

en: Coarray component %qs at %L must be allocatable with deferred shape
de: Koarray-Komponente %qs bei %L muss reservierbar mit aufgeschobener Form sein

en: Coarray declaration at %C
de: Coarray-Deklaration bei %C

en: Coarray designator at %C but %qs is not a coarray
de: Koarray-Bezeichner bei %C, aber %qs ist kein Koarray

en: Coarray dummy argument %qs at %L to elemental procedure
de: Koarray-Scheinargument %qs bei %L für elementare Prozedur

en: Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs
de: Coarray-Scheinvariable %qs bei %L in BIND(C)-Prozedur %qs nicht erlaubt

en: Coarray specification required in ALLOCATE statement at %L
de: Koarray-Spezifikation in ALLOCATE-Anweisung bei %L erforderlich

en: Coarray variable %qs at %L shall not have codimensions with deferred shape
de: Koarray-Variable %qs bei %L darf keine Kodimensionen mit aufgeschobener Form haben

en: Coarrays disabled at %C, use %<-fcoarray=%> to enable
de: Coarrays bei %C ausgeschaltet, %<-fcoarray=%> schaltet sie ein

en: Coarrays disabled at %L, use %<-fcoarray=%> to enable
de: Koarrays bei %L ausgeschaltet, %<-fcoarray=%> schaltet sie ein

en: Code for reallocating the allocatable array at %L will be added
de: Code zur Neu-Reservierung des reservierbaren Feldes bei %L wird hinzugefügt

en: Code for reallocating the allocatable variable at %L will be added
de: Code zur Neu-Reservierung der reservierbaren Variable bei %L wird hinzugefügt

en: Code size: small, medium or large.
de: Code-Größe: small, medium oder large.

en: Coindex of codimension %d must be a scalar at %L
de: Koindex der Kodimension %d muss bei %L ein Skalar sein

en: Coindex rank mismatch in array reference at %L (%d/%d)
de: Unpassende Ränge des Koindex in Feldreferenz bei %L (%d/%d)

en: Coindexed ASYNCHRONOUS or VOLATILE actual argument at %L requires that dummy %qs has neither ASYNCHRONOUS nor VOLATILE
de: Koindiziertes effektives ASYNCHRONOUS- oder VOLATILE-Argument bei %L erfordert, dass Schein-%qs weder ASYNCHRONOUS noch VOLATILE hat

en: Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument
de: Effektives koindiziertes Argument bei %L in PURE-Prozedur wird an POINTER-Scheinargument übergeben

en: Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument
de: Effektives koindiziertes Argument bei %L in PURE-Prozedur wird an INTENT(%s)-Argument übergeben

en: Coindexed actual argument at %L to allocatable dummy %qs requires INTENT(IN)
de: Koindiziertes effektives Argument bei %L an scheinreservierbares %qs erfordert INTENT(IN)

en: Coindexed actual argument at %L to pointer dummy %qs
de: Koindiziertes effektives Argument bei %L an Scheinzeiger %qs

en: Coindexed actual argument at %L with allocatable ultimate component to dummy %qs requires either VALUE or INTENT(IN)
de: Koindiziertes effektives Argument bei %L mit reservierbarer endgültiger Komponente für Schein-%qs erfordert entweder VALUE oder INTENT(IN)

en: Coindexed actual argument at %L with ultimate pointer component
de: Koindiziertes effektives Argument bei %L mit endgültiger Zeigerkomponente

en: Coindexed allocatable object at %L
de: Koindiziertes reservierbares Objekt bei %L

en: Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure
de: Koindizierter Ausdruck bei %L wird einer Variable abgeleiteten Typs mit einer POINTER-Komponente in einer PURE-Prozedur zugewiesen

en: Coindexed expression to pointer component %qs in structure constructor at %L
de: Koindizierter Ausdruck auf Zeigerkomponente %qs in Strukturkonstruktor bei %L

en: Coindexed object with polymorphic allocatable subcomponent at %L
de: Koindiziertes Objekt mit polymorpher reservierbarer Subkomponente bei %L

en: Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs
de: Koindiziertem polymorphen effektiven Argument bei %L wird polymorphes Scheinargument %qs übergeben

en: Coindexed procedure-pointer component at %C
de: Koindizierte Prozedurzeiger-Komponente bei %C

en: Coindexed variable must not have an allocatable ultimate component in assignment at %L
de: Koindizierte Variable darf keine reservierbare endgültige Komponente in Zuweisung bei %L haben

en: Collect and dump debug information into temporary file if ICE in C/C++ compiler occurred.
de: Im Falle eines internen Fehlers im C/C++-Compiler die Debuginformationen sammeln und in temporäre Datei ausgeben.

en: Comma after * at %C not allowed without I/O list
de: Komma hinter * bei %C ist nur zusammen mit einer I/O-Liste erlaubt

en: Comma before i/o item list at %L
de: Komma vor Ein-/Ausgabeelementliste bei %L

en: Comma expected at %C
de: Komma bei %C erwartet

en: Comma required after P descriptor in format string at %L
de: Fehlendes Komma nach P-Deskriptor in Formatzeichenkette bei %L

en: Compile code for big endian mode.
de: Code für »Big Endian«-Modus erzeugen.

en: Compile code for little endian mode.  This is the default.
de: Code für »Little Endian-Modus erzeugen. Dies ist der Standard.

en: Compile code that relies on Cygwin DLL wrappers to support C++ operator new/delete replacement.
de: Code übersetzen, der Cygwin DLL-Wrapper benötigt, um C++-Operator new/delete zu ersetzen.

en: Compile for 32-bit pointers.
de: Für 32-Bit-Zeiger kompilieren.

en: Compile for 64-bit pointers.
de: Für 64-Bit-Zeiger kompilieren.

en: Compile for ETRAX 100 (CRIS v8).
de: Für ETRAX 100 (CRIS v8) übersetzen.

en: Compile for ETRAX 4 (CRIS v3).
de: Für ETRAX 4 (CRIS v3) übersetzen.

en: Compile for V8+ ABI.
de: Für V8+-ABI-übersetzen.

en: Compile for devices requiring XNACK enabled. Default off.
de: Für Geräte kompilieren, die aktiviertes XNACK erfordern. Standardmäßig ausgeschaltet.

en: Compile for devices with the SRAM ECC feature enabled, or not. Default "any".
de: Für Geräte mit aktivierter SRAM-ECC-Funktion kompilieren (oder auch nicht). Vorgabewert ist »any«.

en: Compile for the DSBT shared library ABI.
de: Für das DSBT-Shared-Library-ABI kompilieren.

en: Compile for the m32r.
de: Für m32r übersetzen.

en: Compile for the m32r2.
de: Für m32r2 übersetzen.

en: Compile for the m32rx.
de: Für m32rx übersetzen.

en: Compile for the v850 processor.
de: Für v850-Prozessor übersetzen.

en: Compile for the v850e processor.
de: Für v850e-Prozessor übersetzen.

en: Compile for the v850e1 processor.
de: Für v850e1-Prozessor übersetzen.

en: Compile for the v850e2 processor.
de: Für v850e2-Prozessor übersetzen.

en: Compile for the v850e2v3 processor.
de: Für v850e2v3-Prozessor übersetzen.

en: Compile for the v850e3v5 processor.
de: Für v850e3v5-Prozessor übersetzen.

en: Compile for the v850es variant of the v850e1.
de: Für die v850es-Variante des v850e1 übersetzen.

en: Compile in debug code.
de: Debuggingcode mitcompilieren.

en: Compile in unittest code.
de: Unittest-Code eincompilieren.

en: Compile release version.
de: Release-Version compilieren.

en: Compile whole compilation unit at a time.
de: Ganze Übersetzungseinheit auf einmal übersetzen.

en: Compile with 32 bit longs and pointers, which is the only supported behavior and thus the flag is ignored.
de: Mit 32-Bit Longs und Zeigern kompilieren (einzige unterstützte Option).

en: Compile with 32 bit longs and pointers.
de: Mit 32-Bit Longs und Zeigern kompilieren.

en: Compile with 64 bit longs and pointers.
de: Mit 64-Bit Longs und Zeigern kompilieren.

en: Compile-time bonus IPA-CP assigns to candidates which make loop bounds or strides known.
de: Übersetzungszeit-Bonus, den IPA-CP an Kandidaten vergibt, die Schleifengrenzen oder Schrittweiten bekannt machen.

en: Complex argument of LOG at %L cannot be zero
de: Komplexes Argument von LOG bei %L kann nicht Null sein

en: Complex multiplication and division follow Fortran rules.
de: Komplexe Multiplikation und Division befolgen Fortran-Regeln.

en: Component %qs at %C already declared at %L
de: Komponente %qs bei %C bereits bei %L deklariert

en: Component %qs at %C already in the parent type at %L
de: Komponente %qs bei %C bereits im Elterntypen bei %L deklariert

en: Component %qs at %C is a PRIVATE component of %qs
de: Komponente %qs bei %C ist eine PRIVATE-Komponente von %qs

en: Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L
de: Komponente %qs bei %L kann nicht ALLOCATABLE-Attribut haben, da es Element des BIND(C)-abgeleiteten Typs %qs bei %L ist

en: Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L
de: Komponente %qs bei %L kann nicht POINTER-Attribut haben, da es Element des BIND(C)-abgeleiteten Typs %qs bei %L ist

en: Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer
de: Komponente %qs bei %L hat das CONTIGUOUS-Attribut, aber ist kein Feldzeiger

en: Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray
de: Komponente %qs bei %L mit TYPE(C_PTR) oder TYPE(C_FUNPTR) darf kein Koarray sein

en: Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar
de: Komponente %qs bei %L mit Koarray-Komponente darf ein Nicht-Zeiger und nicht-reservierbares Skalar sein

en: Component %qs in derived type %qs at %L may not be C interoperable
de: Komponente %qs in abgeleitetem Typ %qs bei %L könnte nicht C-kompatibel sein

en: Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)
de: Komponente %qs in abgeleitetem Typ %qs bei %L könnte nicht C-kompatibel sein, obwohl abgeleiteter Typ %qs BIND(C) ist

en: Component %qs is initialized twice in the structure constructor at %L
de: Komponente %qs wird im Strukturkonstruktor bei %L doppelt initialisiert

en: Component %qs of %qs at %L has the same name as an inherited type-bound procedure
de: Komponente %qs von %qs bei %L hat den gleichen Namen wie eine geerbte typgebundene Prozedur

en: Component %qs of BIND(C) type at %L must have length one
de: Komponente %qs von BIND(C)-Typ bei %L muss Länge eins haben

en: Component %qs with CLASS at %C must be allocatable or pointer
de: Komponente %qs mit CLASS bei %C muss allozierbar oder Zeiger sein

en: Component %s at %L of type EVENT_TYPE must have a codimension or be a subcomponent of a coarray, which is not possible as the component has the pointer attribute
de: Komponente %s bei %L des Typs EVENT_TYPE muss eine Kodimension haben oder eine Subkomponente eines Koarrays sein, was wegen des Zeigerattributs der Komponente nicht möglich ist

en: Component %s at %L of type LOCK_TYPE must have a codimension or be a subcomponent of a coarray, which is not possible as the component has the pointer attribute
de: Komponente %s bei %L des Typs LOCK_TYPE muss eine Kodimension haben oder eine Subkomponente eines Koarrays sein, was wegen des Zeigerattributs der Komponente nicht möglich ist

en: Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute
de: Komponente %s des bei %L deklarierten SEQUENCE-Typen hat kein SEQUENCE-Attribut

en: Component at %C must have the POINTER attribute
de: Komponente bei %C muss ein POINTER-Attribut haben

en: Component initializer without name after component named %s at %L
de: Komponenteninitialisierung ohne Namen hinter Komponente namens »%s« bei %L

en: Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L
de: Komponente rechts einer Teilreferenz mit Rang ungleich Null darf bei %L kein Attribut ALLOCATABLE haben

en: Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L
de: Komponente rechts einer Teilreferenz mit Rang größer Null darf kein POINTER-Attribut bei %L haben

en: Component with KIND attribute at %C must be INTEGER
de: Komponente mit KIND-Attribut bei %C muss ein INTEGER sein

en: Component with LEN attribute at %C must be INTEGER
de: Komponente mit LEN-Attribut bei %C muss INTEGER sein

en: Components in TYPE at %C must precede CONTAINS
de: Komponenten in TYPE bei %C müssen CONTAINS vorausgehen

en: Compute locview reset points based on insn length estimates.
de: Locview-Rücksetzpunkte auf Basis der geschätzten Befehlslängen berechnen.

en: Computed GOTO at %C
de: Berechnetes GOTO bei %C

en: Concat operator at %L must concatenate strings of the same kind
de: Verkettungsoperator bei %L muss Zeichenketten der gleichen Sorte verketten

en: Concatenation operator in expression at %L must have two CHARACTER operands
de: Verkettungsoperator in Ausdruck bei %L muss zwei CHARACTER-Operanden haben

en: Conditional moves for float are enabled.
de: Bedingte Kopierbefehle für Gleitkommazahlen aktivieren.

en: Conditional moves for integral are enabled.
de: Bedingte Kopierbefehle für Ganzzahlen aktivieren.

en: Configure the newlib board specific runtime.  The default is or1ksim.
de: Für das newlib-Board-spezifische Laufzeitumgebung konfigurieren. Vorgabewert ist or1ksim.

en: Configured with: %s
de: Konfiguriert mit: %s

en: Conflicting initializers in union at %L and %L
de: In Konflikt stehende Initialisierungen in Union bei %L und %L

en: Conform more closely to IBM XLC semantics.
de: Näher der IBM XLC-Semantik entsprechen.

en: Conform to nothing in particular.
de: Mit nichts besonderem übereinstimmen.

en: Conform to the ISO 1990 C standard as amended in 1994.
de: Mit dem ISO-C-Standard von 1990, wie 1994 ergänzt, übereinstimmen.

en: Conform to the ISO 1990 C standard with GNU extensions.
de: Mit dem ISO-C-Standard von von 1990 mit GNU-Erweiterungen übereinstimmen.

en: Conform to the ISO 1990 C standard.
de: Mit dem ISO-C-Standard von 1990 übereinstimmen.

en: Conform to the ISO 1998 C++ standard revised by the 2003 technical corrigendum with GNU extensions.
de: Mit dem ISO-C++-Standard von 1998 (inclusive technischer Korrekturen von 2003 sowie GNU-Erweiterungen) übereinstimmen.

en: Conform to the ISO 1998 C++ standard revised by the 2003 technical corrigendum.
de: Mit dem ISO-C++-Standard von 1998 (inclusive technischer Korrekturen von 2003) übereinstimmen.

en: Conform to the ISO 1999 C standard with GNU extensions.
de: Mit dem ISO-C-Standard von von 1999 mit GNU-Erweiterungen übereinstimmen.

en: Conform to the ISO 1999 C standard.
de: Mit dem ISO-C-Standard von 1999 übereinstimmen.

en: Conform to the ISO 2011 C standard with GNU extensions.
de: Mit dem ISO-C-Standard von von 2011 mit GNU-Erweiterungen übereinstimmen.

en: Conform to the ISO 2011 C standard.
de: Mit dem ISO-C-Standard von 2011 übereinstimmen.

en: Conform to the ISO 2011 C++ standard with GNU extensions.
de: Mit dem ISO-C++-Standard von 2011 mit GNU-Erweiterungen übereinstimmen.

en: Conform to the ISO 2011 C++ standard.
de: Mit dem ISO-C++-Standard von 2011 übereinstimmen.

en: Conform to the ISO 2014 C++ standard with GNU extensions.
de: Mit dem ISO-C++-Standard von 2014 mit GNU-Erweiterungen übereinstimmen.

en: Conform to the ISO 2014 C++ standard.
de: Mit dem ISO-C++-Standard von 2014 übereinstimmen.

en: Conform to the ISO 2017 C standard (published in 2018) with GNU extensions.
de: Mit dem ISO-C-Standard von 2017 (veröffentlicht 2018) mit GNU-Erweiterungen übereinstimmen.

en: Conform to the ISO 2017 C standard (published in 2018).
de: Mit dem ISO-C-Standard von 2017 (2018 veröffentlicht) übereinstimmen.

en: Conform to the ISO 2017 C++ standard with GNU extensions.
de: Mit dem ISO-C++-Standard von 2017 mit GNU-Erweiterungen übereinstimmen.

en: Conform to the ISO 2017 C++ standard.
de: Mit dem ISO-C++-Standard von 2017 übereinstimmen.

en: Conform to the ISO 2020 C++ standard (experimental and incomplete support).
de: Mit dem ISO-C++-Standard 2020 übereinstimmen (experimentelle und unvollständige Unterstützung).

en: Conform to the ISO 2020 C++ standard with GNU extensions (experimental and incomplete support).
de: Mit dem ISO-C++-Standard für 2020 mit GNU-Erweiterungen (experimentelle und unvollständige Unterstützung) übereinstimmen.

en: Conform to the ISO 2023 C++ draft standard (experimental and incomplete support).
de: Mit dem ISO-C++-Standardentwurf 2023 übereinstimmen (experimentelle und unvollständige Unterstützung).

en: Conform to the ISO 2023 C++ draft standard with GNU extensions (experimental and incomplete support).
de: Mit dem ISO-C++-Standardentwurf für 2023 mit GNU-Erweiterungen (experimentelle und unvollständige Unterstützung) übereinstimmen.

en: Conform to the ISO 202X C standard draft (experimental and incomplete support).
de: Mit dem ISO-C-Standardentwurf 202X übereinstimmen (experimentelle und unvollständige Unterstützung).

en: Conform to the ISO 202X C standard draft with GNU extensions (experimental and incomplete support).
de: Mit dem ISO-C-Standardentwurf für 202X mit GNU-Erweiterungen (experimentelle und unvollständige Unterstützung) übereinstimmen.

en: Conform to the ISO Fortran 2003 standard.
de: Mit dem Standard ISO Fortran 2003 übereinstimmen.

en: Conform to the ISO Fortran 2008 standard including TS 29113.
de: Mit dem Standard ISO Fortran 2008 inkl. TS 29113 übereinstimmen.

en: Conform to the ISO Fortran 2008 standard.
de: Mit dem Standard ISO Fortran 2008 übereinstimmen.

en: Conform to the ISO Fortran 2018 standard.
de: Mit dem Standard ISO Fortran 2018 übereinstimmen.

en: Conform to the ISO Fortran 95 standard.
de: Mit dem Standard ISO Fortran 95 übereinstimmen.

en: Conform to the Objective-C 1.0 language as implemented in GCC 4.0.
de: Mit der in GCC 4.0 implementierten Version Objective-C 1.0 übereinstimmen.

en: Conform to the o32 FPXX ABI.
de: Der ABI o32-FPXX entsprechen.

en: Consider access to byte sized memory slow.
de: Zugriff auf Speicher in Bytegröße als langsam betrachten.

en: Consider type 'int' to be 16 bits wide.
de: Typ »int« als 16 Bit breit ansehen.

en: Consider type 'int' to be 32 bits wide.
de: Typ »int« als 32 Bit breit ansehen.

en: Constant character expression required in MESSAGE clause at %L
de: Die MESSAGE-Klausel bei %L erfordert einen konstanten Zeichenausdruck

en: Constant expression in FORMAT tag at %L must be of type default CHARACTER
de: Konstanter Ausdruck in FORMAT-Markierung bei %L muss vom Standard-CHARACTER-Typ sein

en: Constant expression required at %C
de: Konstanten-Ausdruck erforderlich bei %C

en: Constant logical value in CASE statement is repeated at %L
de: Konstanter logischer Wert in CASE-Anweisung wird bei %L wiederholt

en: Constant memcpy size in bytes above which to start using MOPS sequence.
de: Konstante memcpy-Größe in Bytes, ab der die MOPS-Sequenz verwendet werden soll.

en: Constant memmove size in bytes above which to start using MOPS sequence.
de: Konstante memmove-Größe in Bytes, ab der die MOPS-Sequenz verwendet werden soll.

en: Constant memset size in bytes from which to start using MOPS sequence.
de: Konstante memset-Größe in Bytes, ab der die MOPS-Sequenz verwendet werden soll.

en: Construct webs and split unrelated uses of single variable.
de: Netze konstruieren und nicht zusammenhängende Verwendungen einzelner Variablen aufteilen.

en: Contained function %qs at %L has no IMPLICIT type
de: Enthaltene Funktion %qs bei %L hat keinen IMPLICIT-Typ

en: Contained procedure %qs at %C clashes with procedure defined at %L
de: Enthaltene Prozedur %qs bei %C steht in Konflikt mit Prozedur, die bei %L definiert wurde

en: Contained procedure %qs at %C is already ambiguous
de: Enthaltene Prozedur %qs bei %C ist bereits mehrdeutig

en: Contained procedure %qs at %L has the same name as its encompassing procedure
de: Schnittstellenprozedur %qs bei %L hat denselben Namen wie die umgebende Prozedur

en: Contained procedure %qs at %L of a PURE procedure must also be PURE
de: Enthaltene Prozedur %qs bei %L einer PURE-Prozedur muss auch PURE sein

en: Control generation of reciprocal estimates.
de: Erstellen der Steuerung für Kehrwertabschätzungen.

en: Control ira to consider matching constraint (duplicated operand number) heavily in all available alternatives for preferred register class.  If it is set as zero, it means ira only respects the matching constraint when it's in the only available alternative with an appropriate register class.  Otherwise, it means ira will check all available alternatives for preferred register class even if it has found some choice with an appropriate register class and respect the found qualified matching constraint.
de: Steuert, dass IRA die übereinstimmende Bedingung (doppelte Operandennummer) in allen verfügbaren Alternativen für die bevorzugte Registerklasse stark berücksichtigt. Wenn sie auf Null gesetzt ist, bedeutet dies, dass IRA die übereinstimmende Bedingung nur berücksichtigt, wenn sie in der einzigen verfügbaren Alternative mit einer geeigneten Registerklasse enthalten ist. Andernfalls bedeutet es, dass IRA alle verfügbaren Alternativen für die bevorzugte Registerklasse prüft, selbst wenn sie eine Auswahl mit einer geeigneten Registerklasse gefunden hat, und die gefundene qualifizierte übereinstimmende Einschränkung beachtet.

en: Control the IEEE trap mode.
de: Den IEEE-Trap-Modus steuern.

en: Control the generated fp rounding mode.
de: Den generierten FP-Rundungsmodus steuern.

en: Control the precision given to fp exceptions.
de: Die Präzision der FP-Ausnahmen steuern.

en: Control which events are displayed in diagnostic paths.
de: Steuern, welche Ereignisse in den Diagnosepfaden angegeben werden.

en: Controls how loop vectorizer uses partial vectors.  0 means never, 1 means only for loops whose need to iterate can be removed, 2 means for all loops.  The default value is 2.
de: Steuert, wie der Schleifenvektorisierer partielle Vektoren verwendet. 0 bedeutet nie, 1 bedeutet nur für Schleifen, die nicht unbedingt vektorisiert werden müssen, 2 bedeutet für alle Schleifen. Voreinstellung ist 2.

en: Conversion from %qs to %qs at %L
de: Umwandlung von %qs in %qs bei %L

en: Conversion from %s to %s at %L
de: Umwandlung von %s in %s bei %L

en: Conversion from %s to default-kind COMPLEX(%d) at %L might lose precision, consider using the KIND argument
de: Umwandlung von %s in standardartiges COMPLEX(%d) bei %L könnte Genauigkeit verlieren, evtl. KIND-Argument verwenden

en: Conversion of an Infinity or Not-a-Number at %L to INTEGER
de: Umwandlung einer Unendlichkeit oder NaN bei %L in INTEGER

en: Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores.
de: Adressen der Form BASE + LARGE_OFFSET in NEW_BASE + SMALL_OFFSET konvertieren, damit mehr Speicherzugriffe als komprimierte Anweisungen generiert werden können. Zielt derzeit auf 32-Bit-Integer-Laden/Speichern ab.

en: Convert conditional jumps in innermost loops to branchless equivalents.
de: Umwandlung bedingter Sprünge in innersten Schleifen in zweiglose Äquivalente durchführen.

en: Convert floating point constants to single precision constants.
de: Gleitkommakonstanten in Konstanten einfacher Genauigkeit umwandeln.

en: Convert function return to call and return thunk.
de: Funktionsrückkehr in Aufruf umwandeln und Thunk zurückgeben.

en: Convert indirect call and jump to call and return thunks.
de: Indirekte Aufrufe und Sprünge in Aufrufe umwandeln und Thunks zurückgeben.

en: Copy array sections into a contiguous block on procedure entry.
de: Feldabschnitte bei Prozedureintritt in einen zusammenhängenden Block kopieren.

en: Corank mismatch in argument %qs at %L (%d and %d)
de: Unpassender Korang in Argument %qs bei %L (%d und %d)

en: Cost at which GCSE optimizations will not constraint the distance an expression can travel.
de: Kosten, zu denen GCSE-Optimierungen nicht die Entfernung beeinträchtigen werden, um die ein Ausdruck verschoben werden kann.

en: Cost to assume for a branch insn.
de: Für Sprungbefehl anzunehmende Kosten.

en: Cost to assume for a multiply insn.
de: Für einen Multiplikationsbefehl anzunehmende Kosten.

en: Cost to assume for a multiply instruction, with 4 being equal to a normal insn.
de: Für einen Multiplikationsbefehl anzunehmende Kosten; 4 entspricht einem normalen Befehl.

en: Could not generate addis value for fusion
de: Addis-Wert für Fusion kann nicht erzeugt werden

en: Could not open output file '%s'
de: Ausgabedatei »%s« konnte nicht geöffnet werden

en: Count speculative dependencies while calculating priority of instructions.
de: Spekulative Abhängigkeiten während Prioritätsberechnung der Befehle zählen.

en: Cray Pointee at %C cannot be assumed shape array
de: Cray-Zeigerende bei %C kann nicht Feld mit impliziter Form sein

en: Cray Pointee at %L appears in multiple pointer() statements
de: Cray-Zeigerende bei %L tritt in mehreren pointer()-Anweisungen auf

en: Cray pointee %qs in %s clause at %L
de: Cray-Zeigerziel %qs in %s-Klausel bei %L

en: Cray pointee %qs in SHARED clause at %L
de: Cray-Zeigerziel %qs in Klausel SHARED bei %L

en: Cray pointee object %qs in %s clause at %L
de: Cray-Zeigerziel-Objekt %qs in Klausel %s bei %L

en: Cray pointee object %qs of derived type in %s clause at %L
de: Cray-Zeigerziel-Objekt %qs von abgeleitetem Typ in »%s«-Klausel bei %L

en: Cray pointee object %qs of polymorphic type in %s clause at %L
de: Cray-Zeigerziel-Objekt %qs von polymorphem Typ in %qs-Klausel bei %L

en: Cray pointer %qs in %s clause at %L
de: Cray-Zeiger %qs in %s-Klausel bei %L

en: Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes
de: Cray-Zeiger bei %C hat %d Bytes Genauigkeit; Speicheradressen benötigen %d Bytes

en: Cray pointer at %C must be an integer
de: Cray-Zeiger bei %C muss eine Ganzzahl sein

en: Cray pointer declaration at %C requires %<-fcray-pointer%> flag
de: Cray-Zeiger-Deklaration bei %C benötigt den Schalter %<-fcray-pointer%>

en: Cray pointer object %qs in %s clause at %L
de: Cray-Zeiger-Objekt %qs in Klausel %s bei %L

en: Cray pointer object %qs of derived type in %s clause at %L
de: Cray-Zeiger-Objekt von abgeleitetem Typ %qs in »%s«-Klausel bei %L

en: Cray pointer object %qs of polymorphic type in %s clause at %L
de: Cray-Zeiger-Objekt %qs von polymorphem Typ in %qs-Klausel bei %L

en: Create GUI application.
de: GUI-Anwendung erzeugen.

en: Create a dynamically linked position independent executable.
de: Dynamisch gebundene, lageunabhängige ausführbare Datei erzeugen.

en: Create a shared library.
de: Shared Library erzeugen.

en: Create a static position independent executable.
de: Statische, lageunabhängige ausführbare Datei erzeugen.

en: Create canonical induction variables in loops.
de: Kanonische Induktionsvariablen in Schleifen erzeugen.

en: Create console application.
de: Konsolenanwendung erzeugen.

en: Create data files needed by "gcov".
de: Von »gcov« benötigte Dateien anlegen.

en: Creating '%s'
de: »%s« wird erzeugt

en: Creating array temporary at %L
de: Zwischenergebnis-Feld bei %L wird erzeugt

en: Creating array temporary at %L for argument %qs
de: Bei %L wird ein vorübergehendes Feld für Argument %qs erzeugt

en: D does not support pointers on this target.
de: D unterstützt auf dieser Zielplattform keine Zeiger.

en: D inline assembler statements are not supported in GDC.
de: D-Inline-Assembler-Anweisungen werden in GDC nicht unterstützt.

en: DATA array %qs at %L must be specified in a previous declaration
de: DATA-Feld %qs bei %L muss in vorheriger Deklaration angegeben werden

en: DATA element %qs at %L cannot have a coindex
de: DATA-Element %qs bei %L kann keinen Coindex haben

en: DATA element %qs at %L cannot have the ALLOCATABLE attribute
de: Das DATA-Element %qs bei %L kann kein ALLOCATABLE-Attribut haben

en: DATA element %qs at %L is a pointer and so must be a full array
de: DATA-Element %qs bei %L ist ein Zeiger und muss daher ein vollständiges Feld sein

en: DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target
de: Das DATA-Objekt in der Nähe von %L hat das Zeiger-Attribut und der entsprechende DATA-Wert ist kein gültiges initial-data-target

en: DATA statement at %C after the first executable statement
de: DATA-Anweisung bei %C hinter der ersten ausführbaren Anweisung

en: DATA statement at %C cannot appear within an INTERFACE
de: DATA-Anweisung bei %C kann nicht innerhalb von INTERFACE auftreten

en: DATA statement at %C is not allowed in a PURE procedure
de: DATA-Anweisung bei %C ist in PURE-Prozedur nicht erlaubt

en: DATA statement at %L has more values than variables
de: DATA-Anweisung bei %L hat mehr Werte als Variablen

en: DATA statement at %L has more variables than values
de: DATA-Anweisung bei %L hat mehr Variablen als Werte

en: DC format specifier not allowed at %C
de: DC-Format-Spezifizierer bei %C nicht erlaubt

en: DEALLOCATE object
de: DEALLOCATE Objekt

en: DEALLOCATE of coarray at %C in CRITICAL block
de: DEALLOCATE von Koarray bei %C in CRITICAL-Block

en: DEALLOCATE of coarray at %C in DO CONCURRENT block
de: DEALLOCATE von Koarray bei %C in DO CONCURRENT-Block

en: DECIMAL= at %L not allowed in Fortran 95
de: DECIMAL= bei %L ist in Fortran 95 nicht erlaubt

en: DEFAULTMAP at %C but prior DEFAULTMAP for category %s
de: DEFAULTMAP bei %C, aber das vorherige DEFAULTMAP ist für Kategorie %s

en: DEFAULTMAP at %C but prior DEFAULTMAP with unspecified category
de: DEFAULTMAP bei %C, aber das vorherige DEFAULTMAP hat eine unspezifizierte Kategorie

en: DEF_INTERNAL_FLT_FN (%s) has no associated built-in functions
de: DEF_INTERNAL_FLT_FN (%s) hat keine verknüpften eingebauten Funktionen

en: DEF_INTERNAL_INT_FN (%s) has no associated built-in functions
de: DEF_INTERNAL_INT_FN (%s) hat keine verknüpften eingebauten Funktionen

en: DELIM= at %L not allowed in Fortran 95
de: DELIM= bei %L ist in Fortran 95 nicht erlaubt

en: DEPEND SINK used together with DEPEND SOURCE on the same construct at %L
de: DEPEND SINK wird zusammen mit DEPEND SOURCE an demselben Konstrukt bei %L verwendet

en: DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator
de: Die DEPEND-Klausel bei %L des OMP-DEPOBJ-Konstrukts darf nur einen einzigen Locator haben

en: DEPEND clause at %L of OMP DEPOBJ construct shall not have dependence-type SOURCE, SINK or DEPOBJ
de: DEPEND-Klausel bei %L des OMP-DEPOBJ-Konstrukts darf nicht den Abhängigkeitstyp SOURCE, SINK oder DEPOBJ haben

en: DEPOBJ in DEPOBJ construct at %L shall be a scalar integer of OMP_DEPEND_KIND kind
de: DEPOBJ im DEPOBJ-Konstrukt bei %L muss eine skalare Ganzzahl der Art OMP_DEPEND_KIND sein

en: DETACH event handle %qs in %s clause at %L
de: DETACH-Ereignisbehandler %qs in %s-Klausel bei %L

en: DETACH event handle %qs in SHARED clause at %L
de: DETACH-Ereignisbehandler %qs in SHARED-Klausel bei %L

en: DIM argument at %L is out of bounds
de: DIM-Argument bei %L ist außerhalb der Grenzen

en: DIM argument without COARRAY argument not allowed for THIS_IMAGE intrinsic at %L
de: DIM-Argument ohne COARRAY-Argument ist für intrinsisches THIS_IMAGE bei %L nicht erlaubt

en: DIMENSION specified for %qs outside its INTERFACE body at %L
de: DIMENSION für %qs außerhalb seines INTERFACE-Körpers bei %L angegeben

en: DISTANCE= argument to NUM_IMAGES at %L
de: Argument DISTANCE= für NUM_IMAGES bei %L

en: DISTANCE= argument to THIS_IMAGE at %L
de: Argument DISTANCE= für THIS_IMAGE bei %L

en: DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression
de: Die chunk_size der DIST_SCHEDULE-Klausel bei %L erfordert einen skalaren INTEGER-Ausdruck

en: DO CONCURRENT construct at %C
de: DO CONCURRENT-Konstrukt bei %C

en: DO loop at %L is undefined as it overflows
de: DO-Schleife bei %L ist undefiniert, da sie überläuft

en: DO loop at %L is undefined as it underflows
de: DO-Schleife bei %L ist undefiniert, da sie unterläuft

en: DO loop at %L will be executed zero times
de: DO-Schleife bei %L wird null mal ausgeführt

en: DO step value is zero
de: DO-Schrittwert ist Null

en: DO termination statement which is not END DO or CONTINUE with label %d at %C
de: DO-Abbruchanweisung ist nicht »END DO« oder »CONTINUE« mit Marke %d bei %C

en: DO-iterator %qs at %L is inside iterator of the same name
de: DO-Iterator %qs bei %L ist innerhalb eines Iterators mit gleichem Namen

en: DOUBLE COMPLEX at %C
de: DOUBLE COMPLEX bei %C

en: DP format specifier not allowed at %C
de: DP-Format-Spezifizierer bei %C nicht erlaubt

en: DTIO %s procedure at %L must be recursive
de: DTIO-%s-Prozedur bei %L muss rekursiv sein

en: DTIO character argument at %L must have assumed length
de: DTIO-Zeichenargument bei %L muss angenommene Länge haben

en: DTIO dummy argument at %L must be a scalar
de: DTIO-Scheinargument bei %L muss ein Skalar sein

en: DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY
de: DTIO-Scheinargument bei %L muss ein ASSUMED SHAPE ARRAY sein

en: DTIO dummy argument at %L must be of KIND = %d
de: DTIO-Scheinargument bei %L muss von KIND = %d sein

en: DTIO dummy argument at %L must be of type %s
de: DTIO-Scheinargument bei %L muss vom Typ %s sein

en: DTIO dummy argument at %L must have INTENT %s
de: DTIO-Scheinargument bei %L muss INTENT %s haben

en: DTIO procedure %qs at %L must be a subroutine
de: DTIO-Prozedur %qs bei %L muss ein Unterprogramm sein

en: Darwin does not support -mfentry or associated options
de: Darwin unterstützt »-mfentry« oder verwandte Optionen nicht

en: Darwin is not an mx32 platform
de: Darwin ist keine mx32-Plattform

en: Data element above array upper bound at %L
de: Datenelement oberhalb der oberen Feldgrenze bei %L

en: Data element below array lower bound at %L
de: Datenelement unterhalb der unteren Feldgrenze bei %L

en: Data is stored in big-endian format.
de: Daten werden im Big-Endian-Format gespeichert.

en: Data is stored in little-endian format.  (Default).
de: Daten werden im Little-Endian-Format gespeichert (Standard).

en: Data referenced by offset from start of text instead of GOT (with -fPIC/-fPIE).
de: Daten werden ausgehend vom Start des Programmcodes statt der GOT adressiert (mit -fPIC/-fPIE).

en: Data target at %L shall not have a coindex
de: Datenziel bei %L darf keinen Koindex haben

en: Data transfer element at %L cannot be a full reference to an assumed-size array
de: Datenübertragungselement bei %L kann keine vollständige Referenz auf Feld vermuteter Größe sein

en: Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure
de: Element zum Datenaustausch bei %L kann nicht polymorph sein, außer es wird von einer definierten E/A-Prozedur verarbeitet

en: Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure
de: Datenübertragungselement bei %L kann keine ALLOCATABLE-Komponenten haben, außer es wird von einer definierten E/A-Prozedur verarbeitet

en: Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure
de: Datenübertragungselement bei %L kann keine POINTER-Komponenten haben, außer es wird von einer definierten E/A-Prozedur verarbeitet

en: Data transfer element at %L cannot have PRIVATE components
de: Datenübertragungselement bei %L kann keine PRIVATE-Komponenten haben

en: Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure
de: Datenübertragungselement bei %L kann keine PRIVATE-Komponenten haben, außer es wird von einer definierten E/A-Prozedur verarbeitet

en: Data transfer element at %L cannot have procedure pointer components
de: Datenübertragungselement bei %L kann keine Prozedurzeiger-Komponenten haben

en: Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target
de: Datenzeigerobjekt bei %L muss unbegrenzt polymorph oder von einem Typ mit BIND- oder SEQUENCE-Attribut sein, um zum unbegrenzt polymorphen Ziel zu passen

en: Debug library to use instead of phobos.
de: Debugging-Bibliothe, die anstelle von phobos verwendet wird.

en: Declaring method %qD final would enable devirtualization of %i call | Declaring method %qD final would enable devirtualization of %i calls
de[0]: Wenn die Methode %qD als »final« deklariert wäre, würde das die Devirtualisierung von %d Aufruf einschalten
de[1]: Wenn die Methode %qD als »final« deklariert wäre, würde das die Devirtualisierung von %d Aufrufen einschalten

en: Declaring method %qD final would enable devirtualization of %i call executed %lli times | Declaring method %qD final would enable devirtualization of %i calls executed %lli times
de[0]: Wenn die Methode %qD als »final« deklariert wäre, würde das die Devirtualisierung von %d Aufruf, der %lli-mal ausgeführt wurde, einschalten
de[1]: Wenn die Methode %qD als »final« deklariert wäre, würde das die Devirtualisierung von %d Aufrufen, die %lli-mal ausgeführt wurden, einschalten

en: Declaring type %qD final would enable devirtualization of %i call | Declaring type %qD final would enable devirtualization of %i calls
de[0]: Wenn Typ %qD »final« wäre, würde %i Aufruf devirtualisiert werden
de[1]: Wenn Typ %qD »final« wäre, würden %i Aufrufe devirtualisiert werden

en: Declaring type %qD final would enable devirtualization of %i call executed %lli times | Declaring type %qD final would enable devirtualization of %i calls executed %lli times
de[0]: Wenn Typ %qD »final« wäre, würde %i Aufruf, der %lli-mal ausgeführt wurde, devirtualisiert werden
de[1]: Wenn Typ %qD »final« wäre, würden %i Aufrufe, die %lli-mal ausgeführt wurden, devirtualisiert werden

en: Declaring virtual destructor of %qD final would enable devirtualization of %i call | Declaring virtual destructor of %qD final would enable devirtualization of %i calls
de[0]: Wenn der virtuelle Destruktor von %qD als »final« deklariert wäre, würde das die Devirtualisierung von %d Aufruf einschalten
de[1]: Wenn der virtuelle Destruktor von %qD als »final« deklariert wäre, würde das die Devirtualisierung von %d Aufrufen einschalten

en: Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times | Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times
de[0]: Wenn der virtuelle Destruktor von %qD als »final« deklariert wäre, würde das die Devirtualisierung von %d Aufruf, der %lli-mal ausgeführt wurde, einschalten
de[1]: Wenn der virtuelle Destruktor von %qD als »final« deklariert wäre, würde das die Devirtualisierung von %d Aufrufen, die %lli-mal ausgeführt wurden, einschalten

en: Default library to use instead of phobos.
de: Standardbibliothek, die anstelle von phobos verwendet wird.

en: Default-initialized %s dummy argument %qs at %L is not permitted in BIND(C) procedure %qs
de: Das durch Vorgabe initialisierte Dummy-%qs-Argument %qs bei %L ist in der BIND(C)-Prozedur %qs nicht erlaubt

en: Defer popping functions args from stack until later.
de: Zurückholen der Funktionsargumente vom Stapel bis auf weiteres hinauszögern.

en: Deferred array %qs at %L is not permitted in an initialization expression
de: Aufgeschobenes Feld %qs bei %L ist nicht in einem Initialisierungs-Ausdruck erlaubt

en: Deferred type parameter not yet supported
de: Parameter aufgeschobenen Typs wird noch nicht unterstützt

en: Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute
de: Das Zeichen-Dummy-Argument %qs bei %L hat verzögerte Länge und gehört zur Prozedur %qs mit dem Attribut BIND(C)

en: Delete dead instructions that may throw exceptions.
de: Unerreichbare Befehle löschen, die Ausnahmen werfen können.

en: Delete useless null pointer checks.
de: Unnötige Nullzeigerprüfungen löschen.

en: Deleted feature:
de: Gelöschte Funktion:

en: Deprecated in favor of -std=c++11.
de: Veraltet zugunsten von -std=c++11.

en: Deprecated in favor of -std=c++14.
de: Veraltet zugunsten von -std=c++14.

en: Deprecated in favor of -std=c++17.
de: Veraltet zugunsten von -std=c++17.

en: Deprecated in favor of -std=c11.
de: Veraltet zugunsten von -std=c11.

en: Deprecated in favor of -std=c99.
de: Veraltet zugunsten von -std=c99.

en: Deprecated in favor of -std=gnu++11.
de: Veraltet zugunsten von -std=gnu++11.

en: Deprecated in favor of -std=gnu++14.
de: Veraltet zugunsten von -std=gnu++14.

en: Deprecated in favor of -std=gnu++17.
de: Veraltet zugunsten von -std=gnu++17.

en: Deprecated in favor of -std=gnu11.
de: Veraltet zugunsten von -std=gnu11.

en: Deprecated in favor of -std=gnu99.
de: Veraltet zugunsten von -std=gnu99.

en: Deprecated in favor of -std=iso9899:1999.
de: Veraltet zugunsten von -std=iso9899:1999.

en: Deprecated option.  Use -mno-vrsave instead.
de: Veraltete Option. Stattdessen -mno-vrsave verwenden.

en: Deprecated option.  Use -mvrsave instead.
de: Veraltete Option. Stattdessen -mvrsave verwenden.

en: Deprecated.  This switch has no effect.
de: Veraltet. Dieser Schalter hat keine Auswirkung.

en: Derived type %qs at %C is being used before it is defined
de: Abgeleiteter Typ %qs bei %C wird verwendet, bevor er definiert wird

en: Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)
de: Abgeleiteter Typ %qs bei %L kann nicht das SEQUENCE-Attribut haben, da er BIND(C) ist

en: Derived type %qs at %L has not been declared
de: Abgeleiteter Typ %qs bei %L wurde nicht deklariert

en: Derived type %qs at %L may not be ABSTRACT
de: Abgeleiteter Typ %qs bei %L darf nicht ABSTRACT sein

en: Derived type %qs at %L must be an extension of %qs
de: Abgeleiteter Typ %qs bei %L muss eine Erweiterung von %qs sein

en: Derived type %qs at %L must be extensible
de: Abgeleiteter Typ %qs bei %L muss erweiterbar sein

en: Derived type %qs cannot be used as a variable at %C
de: Abgeleiteter Typ %qs kann bei %C nicht als Variable verwendet werden

en: Derived type %qs cannot be used as a variable at %L
de: Abgeleiteter Typ %qs kann bei %L nicht als Variable verwendet werden

en: Derived type %qs declared at %L must have the BIND attribute to be C interoperable
de: Abgeleiteter Typ %qs, bei %L deklariert, muss BIND-Attribut haben, um C-kompatibel zu sein

en: Derived type %qs is used as an actual argument at %L
de: Abgeleiteter Typ %qs wird als Argument bei %L verwendet

en: Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor
de: Abgeleiteter Typ %qs mit Attribut BIND(C) bei %L ist leer und könnte für entsprechenden C-Prozessor unzugreifbar sein

en: Derived type at %C can only be PRIVATE in the specification part of a module
de: Abgeleiteter Typ bei %C kann nur PRIVATE im Spezifikationsteil eines Moduls sein

en: Derived type at %C can only be PUBLIC in the specification part of a module
de: Abgeleiteter Typ bei %C kann nur PUBLIC im Spezifikationsteil eines Moduls sein

en: Derived type at %C has not been previously defined and so cannot appear in a derived type definition
de: Abgeleiteter Typ bei %C wurde vorher nicht definiert und kann daher nicht in einer abgeleiteten Typdefinition auftreten

en: Derived type component %C is not a permitted EQUIVALENCE member
de: Komponente %C abgeleiteten Typs ist kein zulässiges EQUIVALENCE-Element

en: Derived type declaration with FINAL at %C must be in the specification part of a MODULE
de: Deklaration abgeleiteten Typs mit FINAL bei %C muss im Spezifikationsteil eines Moduls sein

en: Derived type definition at %C with empty CONTAINS section
de: Definition eines abgeleiteten Typs bei %C mit leerem CONTAINS-Abschnitt

en: Derived type definition at %C without components
de: Definition des abgeleiteten Typs bei %C ohne Komponenten

en: Derived type definition of %qs at %C has already been defined
de: Abgeleitete Typdefinition von %qs bei %C wurde bereits definiert

en: Derived type name %qs at %C already has a basic type
de: Abgeleiteter Typname %qs bei %C hat bereits einen Basistyp

en: Derived type name %qs at %C already has a basic type of %s
de: Abgeleiteter Typname %qs bei %C hat bereits einen Basistypen von %s

en: Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object
de: Variable %qs abgeleiteten Typs bei %L kann keine ALLOCATABLE-Komponenten haben, um EQUIVALENCE-Objekt zu sein

en: Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object
de: Variable %qs abgeleiteten Typs bei %L muss SEQUENCE-Attribut haben, um EQUIVALENCE-Objekt zu sein

en: Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON
de: Variable %qs abgeleiteten Typs bei %L mit Standardinitialisierung kann nicht in EQUIVALENCE mit einer Variablen in COMMON sein

en: Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object
de: Variable %qs abgeleiteten Typs bei %L mit Zeigerkomponenten kann kein EQUIVALENCE-Objekt sein

en: Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable
de: Variable %qs abgeleiteten Typs in COMMON bei %L hat eine endgültige Komponente, die allozierbar ist

en: Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute
de: Variable %qs abgeleiteten Typs in COMMON bei %L hat weder das SEQUENCE- noch das BIND(C)-Attribut

en: Derived type variable %qs in COMMON at %L may not have default initializer
de: Variable %qs abgeleiteten Typs in COMMON bei %L darf nicht Standardinitialisierung haben

en: Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden
de: Bei %2$L deklarierter abgeleiteter Typ %1$qs muss ABSTRACT sein, da %3$qs DEFERRED und nicht überschrieben ist

en: Derived-type %qs with BIND(C) must not have a CONTAINS section at %C
de: Abgeleiteter Typ %qs bei %C mit BIND(C) darf keinen CONTAINS-Abschnitt haben

en: Derived-type %qs with SEQUENCE must not have a CONTAINS section at %C
de: Abgeleiteter Typ %qs bei %C mit SEQUENCE darf keinen CONTAINS-Abschnitt haben

en: Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer
de: Scheinargument %qs abgeleiteten Typs bei %L war als INTENT(OUT) deklariert, aber nicht gesetzt und hat keine Standardinitialisierung

en: Description for mxl-mode-bootstrap.
de: Keine weiteren Informationen verfügbar.

en: Description for mxl-mode-executable.
de: Keine weiteren Informationen verfügbar.

en: Description for mxl-mode-novectors.
de: Keine weiteren Informationen verfügbar.

en: Description for mxl-mode-xmdstub.
de: Keine weiteren Informationen verfügbar.

en: Destruct fields of partially constructed objects.
de: Felder von teilweise konstruierten Objekten zerstören.

en: Detect paths that trigger erroneous or undefined behavior due to a null value being used in a way forbidden by a returns_nonnull or nonnull attribute.  Isolate those paths from the main control flow and turn the statement with erroneous or undefined behavior into a trap.
de: Ausführungspfade erkennen, die ausgelöst werden, indem ein Nullwert auf eine Weise verwendet wird, die durch ein »returns_nonnull«- oder »nonnull«-Attribut verboten ist. Solche Pfade werden aus dem Hauptablauf herausgenommen und durch eine Trap ersetzt.

en: Detect paths that trigger erroneous or undefined behavior due to dereferencing a null pointer.  Isolate those paths from the main control flow and turn the statement with erroneous or undefined behavior into a trap.
de: Ausführungspfade erkennen, die durch Dereferenzieren eines Nullzeigers fehlerhaftes oder undefiniertes Verhalten auslösen. Solche Pfade werden aus dem Hauptablauf herausgenommen und durch eine Trap ersetzt.

en: Determine which dependences between insns are considered costly.
de: Feststellen, welche Abhängigkeiten zwischen Befehlen als teuer angesehen werden.

en: Different CHARACTER lengths (%ld/%ld) in array constructor
de: Unterschiedliche CHARACTER-Längen (%ld/%ld) in Feldkonstruktor

en: Different CHARACTER lengths (%ld/%ld) in array constructor at %L
de: Unterschiedliche CHARACTER-Längen (%ld, %ld) in Feldkonstruktor bei %L

en: Different character kinds at %L
de: Verschiedene Zeichenarten bei %L

en: Different kind type parameters in pointer assignment at %L
de: Parameter verschiedener Typen in Zeigerzuweisung bei %L

en: Different ranks in pointer assignment at %L
de: Verschiedene Ränge in Zeigerzuweisung bei %L

en: Different shape for %s at %L on dimension %d (%d and %d)
de: Andere Form für %s bei %L für Dimension %d (%d und %d)

en: Different shape for arguments %qs and %qs at %L for intrinsic %<dot_product%>
de: Unterschiedliche Form für Argumente %qs und %qs bei %L für intrinsisches %<dot_product%>

en: Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul
de: Andere Form bei Dimension 1 für Argumente %qs und %qs bei %L für intrinsisches matmul

en: Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul
de: Andere Form bei Dimension 2 für Argument %qs und Dimension 1 für Argument %qs bei %L für intrinsisches matmul

en: Different type kinds at %L
de: Verschiedene Typ-Arten bei %L

en: Different types in pointer assignment at %L; attempted assignment of %s to %s
de: Verschiedene Typen in Zeigerzuweisung bei %L; Versuch der Zuweisung von %s an %s

en: Dimensions specified for %s at %L after its initialization
de: Für %s bei %L wurden Dimensionen nach dessen Initialisierung angegeben

en: Disable -Wframe-larger-than= warning.  Equivalent to -Wframe-larger-than=<SIZE_MAX> or larger.
de: Die Warnung »-Wframe-larger-than=« ausschalten. Entspricht »-Wframe-larger-than=<SIZE_MAX>« oder größer.

en: Disable -Wlarger-than= warning.  Equivalent to -Wlarger-than=<SIZE_MAX> or larger.
de: Die Warnung »-Wlarger-than=« ausschalten. Entspricht »-Wlarger-than=<SIZE_MAX>« oder größer.

en: Disable ARCompact specific pass to generate conditional execution instructions.
de: ARCompact-spezifischen Durchlauf, um Befehle für bedingte Ausführung zu erzeugen, ausschalten.

en: Disable FP regs.  Equivalent to -msoft-float.
de: Gleitkommaregister ausschalten. Äquivalent zu -msoft-float.

en: Disable FPU ISA, the ABI option must be enable %<-mfloat-abi=soft%>
de: FPU-ISA wird ausgeschaltet, kann mit %<-mfloat-abi=soft%> eingeschaltet werden

en: Disable LR and SR instructions from using FPX extension aux registers.
de: LR- und SR-Befehle davon abhalten, FPX-Erweiterungsregister zu verwenden.

en: Disable Markdown replacements in Ddoc.
de: Markdown-Ersetzungen in Ddoc ausschalten.

en: Disable Scalar to Vector optimization pass transforming 64-bit integer computations into a vector ones.
de: Durchlauf für Skalar-nach-Vektor-Optimierung ausschalten, der 64-Bit-Ganzzahlberechnungen in Vektorberechnungen umwandelt.

en: Disable Walloc-size-larger-than= warning.  Equivalent to Walloc-size-larger-than=<SIZE_MAX> or larger.
de: Die Warnung Walloc-size-larger-than= ausschalten. Entspricht Walloc-size-larger-than=<SIZE_MAX> oder größer.

en: Disable Walloca-larger-than= warning.  Equivalent to Walloca-larger-than=<SIZE_MAX> or larger.
de: Die Warnung Walloca-larger-than= ausschalten. Entspricht Walloca-larger-than=<SIZE_MAX> oder größer.

en: Disable Wstack-usage= warning.  Equivalent to Wstack-usage=<SIZE_MAX> or larger.
de: Die Warnung »-Wstack-usage=« ausschalten. Entspricht »-Wstack-usage=<SIZE_MAX>« oder größer.

en: Disable Wvla-larger-than= warning.  Equivalent to Wvla-larger-than=<SIZE_MAX> or larger.
de: Die Warnung Wvla-larger-than= ausschalten. Entspricht Wvla-larger-than=<SIZE_MAX> oder größer.

en: Disable access to shared memory objects.
de: Zugriff auf gemeinsamen Speicher ausschalten.

en: Disable floating point optimizations that ignore the IEEE signedness of zero.
de: Gleitkommaoptimierungen ausschalten, die die IEEE-Vorzeichenbehaftung von Null nicht beachten.

en: Disable hardware floating point.
de: Hardware-Gleitkommabefehle ausschalten.

en: Disable indexed addressing.
de: Indizierte Adressierung ausschalten.

en: Disable optimizations observable by IEEE signaling NaNs.
de: Von IEEE-Signalisierungs-NaNs wahrnehmbare Optimierungen ausschalten.

en: Disable optimizations that assume default FP rounding behavior.
de: Optimierungen, die Standard-Rundungsverhalten für Gleitkomma annehmen, ausschalten.

en: Disable position-independent code (PIC) for use in OS kernel code.
de: Lageunabhängigen Code (PIC) für Verwendung in BS-Kernelcode ausschalten.

en: Disable preprocessing.
de: Vorverarbeitung ausschalten.

en: Disable space regs.
de: Leerregister ausschalten.

en: Disable the use of RX FPU instructions.
de: Verwendung der RX-FPU-Befehle ausschalten.

en: Disallow direct calls to global functions.
de: Direkte Aufrufe von globalen Funktionen verbieten.

en: Disallow more than 'msched-max-memory-insns' in instruction group. Otherwise, limit is 'soft' (prefer non-memory operations when limit is reached).
de: Mehr als »msched-max-memory-insns« in Befehlsgruppe verbieten. Ansonsten ist Grenze »weich« (Nicht-Speicheroperationen beim Erreichen der Grenze bevorzugen).

en: Disallow tail call optimization when a calling routine may have omitted character lengths.
de: Optimierung der Endrekursion verbieten, wenn die aufrufende Routine die Zeichenlänge weggelassen haben könnte.

en: Discover pure and const functions.
de: Reine und konstante Funktionen entdecken.

en: Discover read-only and non addressable static variables.
de: Nur-lese und nicht-adressierbare statische Variablen entdecken.

en: Discover read-only, write-only and non-addressable static variables.
de: Nur-lese-, nur-schreib- und nicht-adressierbare statische Variablen entdecken.

en: Display compile time statistics.
de: Übersetzungszeitstatistik anzeigen.

en: Display statistics accumulated during compilation.
de: Während der Übersetzung angesammelte Statistik anzeigen.

en: Display target specific command line options (including assembler and linker options).
de: Zielspezifische Befehlszeilenoptionen (einschließlich Assembler- und Linker-Optionen) anzeigen.

en: Display the code tree after front end optimization.
de: Codebaum nach Frontend-Optimierung anzeigen.

en: Display the code tree after parsing.
de: Codebaum nach Analyse anzeigen.

en: Display the code tree after parsing; deprecated option.
de: Codebaum nach Analyse anzeigen; veraltete Option.

en: Display the compiler's version.
de: Compiler-Version anzeigen.

en: Display the frontend AST after parsing and semantic passes.
de: Frontend-AST nach dem Parsen und der semantischen Analyse anzeigen.

en: Display the global symbol table after parsing.
de: Die globale Symboltabelle nach dem Parsen anzeigen.

en: Display the symbols in reverse order.
de: Die Symbole in umgekehrter Reihenfolge ausgeben.

en: Display this information.
de: Diese Informationen anzeigen.

en: Division by zero at %L
de: Division durch Null bei %L

en: Division by zero converting %s to %s at %L
de: Division durch Null beim Konvertieren von %s in %s bei %L

en: Division strategy, one of: call-div1, call-fp, call-table.
de: Divisionsstrategie, eine von: call-div1, call-fp, call-table.

en: Do CFG-sensitive rematerialization in LRA.
de: In LRA die ablaufsensitive Rematerialisierung durchführen.

en: Do dispatch scheduling if processor is bdver1, bdver2, bdver3, bdver4 or znver1 and Haifa scheduling is selected.
de: Dispatch-Planung durchführen, wenn Prozessor bdver1, bdver2, bdver3, bdver4 oder znver1 ist und Haifa-Planung ausgewählt ist.

en: Do link the standard D startup files in the compilation.
de: Die D-Programmstart-Dateien mit dem Compilat binden.

en: Do no generate BRcc instructions in arc_reorg.
de: Keine BRcc-Befehle in arc_reorg erzeugen.

en: Do not add a default symbol exports to modules or dynamic libraries.
de: Keine Standardsymbolexporte zu Modulen oder dynamischen Bibliotheken hinzufügen.

en: Do not allow constant data to be placed in code sections.
de: Verbieten, dass konstante Daten in Codeabschnitten platziert werden.

en: Do not assume a large TLS segment.
de: Nicht von einem großen TLS-Segment ausgehen.

en: Do not assume that functions never executed during the train run are cold.
de: Nicht annehmen, dass Funktionen, die im Trainingslauf nie ausgeführt wurden, kalt sind.

en: Do not assume that standard C libraries and "main" exist.
de: Nicht annehmen, dass Standard-C-Bibliotheken und »main« vorhanden sind.

en: Do not disable space regs.
de: Leerregister nicht ausschalten.

en: Do not discard comments in macro expansions.
de: Kommentare in Makroexpansionen nicht verwerfen.

en: Do not discard comments.
de: Kommentare nicht verwerfen.

en: Do not display functions compiled or elapsed time.
de: Übersetzte Funktionen oder verstrichene Zeit nicht ausgeben.

en: Do not elide common elements in template comparisons.
de: Gemeinsame Elemente in Templatevergleichen nicht weglassen.

en: Do not emit addressing modes with side-effect assignment.
de: Keine Adressierungsmodi mit Seiteneffektzuweisungen erzeugen.

en: Do not emit complex integer constants to read-only memory.
de: Keine komplexen Ganzzahlkonstanten im Nur-Lese-Speicher erzeugen.

en: Do not emit function prologue or epilogue.
de: Keinen Funktionsprolog oder -epilog erzeugen.

en: Do not enforce strict alignment.
de: Strenge Ausrichtung nicht erzwingen.

en: Do not generate #line directives.
de: Keine #line-Direktiven erzeugen.

en: Do not generate .size directives.
de: Keine .size-Direktiven erzeugen.

en: Do not generate a single exit point for each function.
de: Nicht unbedingt einen einzigen Austrittspunkt für jede Funktion erzeugen.

en: Do not generate code that can only run in supervisor mode (default).
de: Keinen Code generieren, der nur im Supervisor-Modus läuft (Standard).

en: Do not generate load/store with update instructions.
de: Keine Befehle für Laden/Speichern mit Aktualisierung erzeugen.

en: Do not generate mpy instructions for ARC700.
de: Keine mpy-Befehle für ARC700 erzeugen.

en: Do not generate unaligned memory accesses.
de: Keine unausgerichteten Speicherzugriffe erzeugen.

en: Do not inline integer division.
de: Ganzzahldivision nicht »inline« generieren.

en: Do not inline square root.
de: Quadratwurzel nicht »inline« generieren.

en: Do not link against the device-specific library lib<MCU>.a.
de: Nicht gegen die Geräte-spezifische Bibliothek lib<MCU>.a binden.

en: Do not link the standard D library in the compilation.
de: D-Standardbibliothek nicht in die Compilierung einbinden.

en: Do not load the PIC register in function prologues.
de: PIC-Register nicht in Funktionsprologen laden.

en: Do not look for object files in standard path.
de: Nicht nach Objekten im Standardverzeichnis suchen.

en: Do not mark ABI switches in e_flags.
de: ABI-Schalter nicht in e_flags markieren.

en: Do not perform optimizations increasing noticeably stack usage.
de: Keine Optimierungen durchführen, die die Stapelverwendung deutlich erhöhen.

en: Do not place floating point constants in TOC.
de: Gleitkommakonstanten nicht ins TOC legen.

en: Do not place symbol+offset constants in TOC.
de: Symbol+Offset-Konstanten nicht ins TOC legen.

en: Do not predefine system-specific and GCC-specific macros.
de: Keine system- oder GCC-spezifischen Makros vordefinieren.

en: Do not pretty-print template specializations as the template signature followed by the arguments.
de: Template-Spezialisierungen für die Ausgabe nicht als Template-Signatur gefolgt von den Argumenten umformatieren.

en: Do not provide a default start-address 0x100 of the program.
de: Keine Standard-Start-Adresse 0x100 des Programmes bereitstellen.

en: Do not push extended registers on stack in monitor functions.
de: In Überwachungsfunktionen erweiterte Register nicht auf Stapel sichern.

en: Do not search standard system include directories (those specified with -isystem will still be used).
de: Standard-System-Einfügepfade nicht durchsuchen (die mit -isystem angegebenen werden trotzdem noch verwendet).

en: Do not search standard system include directories for C++.
de: Standard-System-Einfügeverzeichnisse nicht für C++ durchsuchen.

en: Do not support SSE4.1 and SSE4.2 built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für SSE4.1 und SSE4.2 nicht unterstützen.

en: Do not suppress C++ class debug information.
de: Keine Fehlersuchinformationen für C++-Klassen unterdrücken.

en: Do not suppress warnings from system headers.
de: Warnungen aus System-Headern nicht unterdrücken.

en: Do not treat local variables and COMMON blocks as if they were named in SAVE statements.
de: Lokale Variablen und COMMON-Blöcke behandeln, als ob sie in SAVE-Anweisungen benannt worden wären.

en: Do not tune code and read-only data alignment.
de: Ausrichtung von Code und der Nur-Lese-Daten nicht optimieren.

en: Do not tune stack alignment.
de: Stapelausrichtung nicht optimieren.

en: Do not tune writable data alignment.
de: Ausrichtung der schreibbaren Daten nicht optimieren.

en: Do not use GOT to access external symbols.
de: Die GOT nicht verwenden, um auf externe Symbole zuzugreifen.

en: Do not use MDMX instructions.
de: Keine MDMX-Befehle verwenden.

en: Do not use MIPS-3D instructions.
de: Keine MIPS-3D-Befehle verwenden.

en: Do not use VAX fp.
de: VAX-FP nicht verwenden.

en: Do not use a cache-flushing function before calling stack trampolines.
de: Keine Cache entleerende Funktion verwenden, bevor Stapel-Trampoline aufgerufen werden.

en: Do not use addresses that allocate global registers.
de: Adressen, die globale Register belegen, nicht verwenden.

en: Do not use condition codes from normal instructions.
de: Keine Bedingungscodes normaler Befehle verwenden.

en: Do not use hardware FP.
de: Hardware-Gleitkommabefehle nicht verwenden.

en: Do not use hardware floating point.
de: Hardware-Gleitkommabefehle nicht verwenden.

en: Do not use hardware fp.
de: Hardware-Gleitkommabefehle nicht verwenden.

en: Do not use hardware quad fp instructions.
de: Hardware-Vierfach-Gleitkommabefehle nicht verwenden.

en: Do not use the AIX Vector Extended ABI.
de: Die AIX-Vector-Extended-ABI nicht verwenden.

en: Do not use the AltiVec ABI extensions.
de: AltiVec-ABI-Erweiterungen nicht verwenden.

en: Do not use the bit-field instructions.
de: Bit-Feld-Befehle nicht verwenden.

en: Do not use the callt instruction (default).
de: Den callt-Befehl nicht verwenden (Standard).

en: Do not use the device-specific specs file device-specs/specs-<MCU>.
de: Nicht die gerätespezifische Specs-Datei »device-specs/specs-<MCU>« verwenden.

en: Do not use the fabsd custom instruction.
de: Spezifischen Befehl »fabsd« nicht verwenden.

en: Do not use the fabss custom instr.
de: Spezifischen Befehl »fabss« nicht verwenden.

en: Do not use the faddd custom instruction.
de: Spezifischen Befehl »faddd« nicht verwenden.

en: Do not use the fadds custom instruction.
de: Spezifischen Befehl »fadds« nicht verwenden.

en: Do not use the fatand custom instruction.
de: Spezifischen Befehl »fatand« nicht verwenden.

en: Do not use the fatans custom instruction.
de: Spezifischen Befehl »fatans« nicht verwenden.

en: Do not use the fcmpeqd custom instruction.
de: Spezifischen Befehl »fcmpeqd« nicht verwenden.

en: Do not use the fcmpeqs custom instruction.
de: Spezifischen Befehl »fcmpeqs« nicht verwenden.

en: Do not use the fcmpged custom instruction.
de: Spezifischen Befehl »fcmpged« nicht verwenden.

en: Do not use the fcmpges custom instruction.
de: Spezifischen Befehl »fcmpges« nicht verwenden.

en: Do not use the fcmpgtd custom instruction.
de: Spezifischen Befehl »fcmpgtd« nicht verwenden.

en: Do not use the fcmpgts custom instruction.
de: Spezifischen Befehl »fcmpgts« nicht verwenden.

en: Do not use the fcmpled custom instruction.
de: Spezifischen Befehl »fcmpled« nicht verwenden.

en: Do not use the fcmples custom instruction.
de: Spezifischen Befehl »fcmples« nicht verwenden.

en: Do not use the fcmpltd custom instruction.
de: Spezifischen Befehl »fcmpltd« nicht verwenden.

en: Do not use the fcmplts custom instruction.
de: Spezifischen Befehl »fcmplts« nicht verwenden.

en: Do not use the fcmpned custom instruction.
de: Spezifischen Befehl »fcmpned« nicht verwenden.

en: Do not use the fcmpnes custom instruction.
de: Spezifischen Befehl »fcmpnes« nicht verwenden.

en: Do not use the fcosd custom instruction.
de: Spezifischen Befehl »fcosd« nicht verwenden.

en: Do not use the fcoss custom instruction.
de: Spezifischen Befehl »fcoss« nicht verwenden.

en: Do not use the fdivd custom instruction.
de: Spezifischen Befehl »fdivd« nicht verwenden.

en: Do not use the fdivs custom instruction.
de: Spezifischen Befehl »fdivs« nicht verwenden.

en: Do not use the fexpd custom instruction.
de: Spezifischen Befehl »fexpd« nicht verwenden.

en: Do not use the fexps custom instruction.
de: Spezifischen Befehl »fexps« nicht verwenden.

en: Do not use the fextsd custom instruction.
de: Spezifischen Befehl »fextsd« nicht verwenden.

en: Do not use the fixdi custom instruction.
de: Spezifischen Befehl »fixdi« nicht verwenden.

en: Do not use the fixdu custom instruction.
de: Spezifischen Befehl »fixdu« nicht verwenden.

en: Do not use the fixsi custom instruction.
de: Spezifischen Befehl »fixsi« nicht verwenden.

en: Do not use the fixsu custom instruction.
de: Spezifischen Befehl »fixsu« nicht verwenden.

en: Do not use the floatid custom instruction.
de: Spezifischen Befehl »floatid« nicht verwenden.

en: Do not use the floatis custom instruction.
de: Spezifischen Befehl »floatis« nicht verwenden.

en: Do not use the floatud custom instruction.
de: Spezifischen Befehl »floatud« nicht verwenden.

en: Do not use the floatus custom instruction.
de: Spezifischen Befehl »floatus« nicht verwenden.

en: Do not use the flogd custom instruction.
de: Spezifischen Befehl »flogd« nicht verwenden.

en: Do not use the flogs custom instruction.
de: Spezifischen Befehl »flogs« nicht verwenden.

en: Do not use the fmaxd custom instruction.
de: Spezifischen Befehl »fmaxd« nicht verwenden.

en: Do not use the fmaxs custom instruction.
de: Spezifischen Befehl »fmaxs« nicht verwenden.

en: Do not use the fmind custom instruction.
de: Spezifischen Befehl »fmind« nicht verwenden.

en: Do not use the fmins custom instruction.
de: Spezifischen Befehl »fmins« nicht verwenden.

en: Do not use the fmuld custom instruction.
de: Spezifischen Befehl »fmuld« nicht verwenden.

en: Do not use the fmuls custom instruction.
de: Spezifischen Befehl »fmuls« nicht verwenden.

en: Do not use the fnegd custom instruction.
de: Spezifischen Befehl »fnegd« nicht verwenden.

en: Do not use the fnegs custom instruction.
de: Spezifischen Befehl »fnegs« nicht verwenden.

en: Do not use the frdxhi custom instruction.
de: Spezifischen Befehl »frdxhi« nicht verwenden.

en: Do not use the frdxlo custom instruction.
de: Spezifischen Befehl »frdxlo« nicht verwenden.

en: Do not use the frdy custom instruction.
de: Spezifischen Befehl »frdy« nicht verwenden.

en: Do not use the fsind custom instruction.
de: Spezifischen Befehl »fsind« nicht verwenden.

en: Do not use the fsins custom instruction.
de: Spezifischen Befehl »fsins« nicht verwenden.

en: Do not use the fsqrtd custom instruction.
de: Spezifischen Befehl »fsqrtd« nicht verwenden.

en: Do not use the fsqrts custom instruction.
de: Spezifischen Befehl »fsqrts« nicht verwenden.

en: Do not use the fsubd custom instruction.
de: Spezifischen Befehl »fsubd« nicht verwenden.

en: Do not use the fsubs custom instruction.
de: Spezifischen Befehl »fsubs« nicht verwenden.

en: Do not use the ftand custom instruction.
de: Spezifischen Befehl »ftand« nicht verwenden.

en: Do not use the ftans custom instruction.
de: Spezifischen Befehl »ftans« nicht verwenden.

en: Do not use the ftruncds custom instruction.
de: Den eigenen Befehl ftruncds nicht verwenden.

en: Do not use the fwrx custom instruction.
de: Spezifischen Befehl »fwrx« nicht verwenden.

en: Do not use the fwry custom instruction.
de: Spezifischen Befehl »fwry« nicht verwenden.

en: Do not use the round custom instruction.
de: Spezifischen Befehl »round« nicht verwenden.

en: Do not use unaligned memory references.
de: Keine unausgerichteten Speicherreferenzen verwenden.

en: Do not warn about specified attributes.
de: Nicht bei den angegebenen Attributen warnen.

en: Do not warn about using "long long" when -pedantic.
de: Nicht bei Verwendung von »long long« mit -pedantic warnen.

en: Do stack checking using bounds in L1 scratch memory.
de: Stapel-Überprüfung mit Grenzen im L1-Zwischenspeicher durchführen.

en: Does nothing.  Preserved for backward compatibility.
de: Tut nichts. Für Rückwärtskompatibilität erhalten.

en: Does nothing. Preserved for backward compatibility.
de: Tut nichts. Für Rückwärtskompatibilität erhalten.

en: Don't align items in code or data.
de: Code- und Datenelemente nicht ausrichten.

en: Don't allocate floats and doubles in extended-precision registers.
de: Keine floats und doubles in Registern erweiterter Genauigkeit reservieren.

en: Don't assume that unaligned accesses are handled by the system.
de: Nicht annehmen, dass unausgerichtete Zugriffe vom System behandelt werden.

en: Don't call any cache flush functions.
de: Keine Funktionen zum Entleeren des Cache aufrufen.

en: Don't call any cache flush trap.
de: Keine Abfangfunktion zum Entleeren des Cache aufrufen.

en: Don't create a dynamically linked position independent executable.
de: Keine dynamisch gebundene, lageunabhängige ausführbare Datei erzeugen.

en: Don't destruct fields of partially constructed objects.
de: Felder von teilweise konstruierten Objekten nicht zerstören.

en: Don't emit DWARF additions beyond selected version.
de: Keine DWARF-Ergänzungen über gewählte Version hinaus erzeugen.

en: Don't emit dllexported inline functions unless needed.
de: Keine DLL-exportierten Inline-Funktionen erzeugen, außer wenn nötig.

en: Don't generate DWARF pubnames and pubtypes sections.
de: Keine DWARF-Abschnitte für Pubnames und Pubtypes erzeugen.

en: Don't generate checks for control speculation in selective scheduling.
de: Keine Prüfungen für Steuerungs-Spekulation in selektiver Planung.

en: Don't generate privileged-mode only code; implies -mno-inline-ic_invalidate if the inline code would not work in user mode.
de: Keinen Code nur für privilegierten Modus erzeugen; bringt »-mno-inline-ic_invalidate« mit sich, wenn der »inline«-Code nicht im Usermodus funktionieren würde.

en: Don't indicate any priority with TARGET_REGISTER_PRIORITY.
de: Keine Priorität mit TARGET_REGISTER_PRIORITY ausdrücken.

en: Don't optimize block moves, use memcpy.
de: Blockverschiebungen nicht optimieren, sondern »memcpy« verwenden.

en: Don't optimize block moves.
de: Blockkopierbefehle nicht optimieren.

en: Don't use P-mnemonics for branches.
de: Keine P-Mnemonics für Zweige verwenden.

en: Don't use any of r32..r63.
de: Register r32..r63 nicht verwenden.

en: Don't use less than 25 bit addressing range for calls.
de: Mindestens 25-Bit-Addressraum für Aufrufe verwenden.

en: Don't warn about uses of Microsoft extensions.
de: Nicht bei Verwendung von Microsoft-Erweiterungen warnen.

en: Double CLASS IS block in SELECT TYPE statement at %L
de: Doppelter CLASS IS-Block in SELECT TYPE-Anweisung bei %L

en: Downgrade conformance errors to warnings.
de: Übereinstimmungsfehler zu Warnungen degradieren.

en: Driving:
de: Angesteuert:

en: Dummy %qs at %L cannot have an initializer
de: Schein-%qs bei %L kann keine Initialisierung haben

en: Dummy argument %qs at %L cannot be INTENT(OUT)
de: Scheinargument %qs bei %L kann nicht INTENT(OUT) sein

en: Dummy argument %qs at %L cannot be OPTIONAL
de: Scheinargument %qs bei %L kann nicht OPTIONAL sein

en: Dummy argument %qs at %L cannot be a derived type at %C
de: Scheinargument %qs bei %L darf kein abgeleiteter Typ bei %C sein

en: Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)
de: Das Dummy-Argument %qs bei %L kann kein Zeiger mit dem Attribut CONTIGUOUS sein, da die Prozedur %qs BIND(C) ist

en: Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)
de: Scheinargument %qs bei %L mit EVENT_TYPE darf nicht INTENT(OUT) sein

en: Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)
de: Scheinargument %qs bei %L mit LOCK_TYPE darf nicht INTENT(OUT) sein

en: Dummy argument %qs at %L was declared INTENT(OUT) but was not set
de: Scheinargument %qs bei %L war als INTENT(OUT) deklariert, aber nicht gesetzt

en: Dummy argument %qs has to be a pointer, assumed-shape or assumed-rank array without CONTIGUOUS attribute - as actual argument at %L is not simply contiguous and both are ASYNCHRONOUS or VOLATILE
de: Scheinargument %qs muss Zeiger oder Feld mit angenommener Form ohne CONTIGUOUS-Attribut sein, da das effektive Argument bei %L nicht einfach fortlaufend ist und beide ASYNCHRONOUS oder VOLATILE sind

en: Dummy argument %qs not allowed in expression at %L
de: Scheinargument %qs ist im Ausdruck bei %L nicht erlaubt

en: Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure
de: Scheinargument %qs von %qs bei %L sollte %qs genannt werden, um zum zugehörigen Argument der überschriebenen Prozedur zu passen

en: Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L
de: Scheinargument %qs mit INTENT(IN) in Zeiger-Verbindungskontext (%s) bei %L

en: Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L
de: Scheinargument %qs mit INTENT(IN) in Variablen-Definitionskontext (%s) bei %L

en: Dummy flag. This is the default unless FPX switches are provided explicitly.
de: Dummyflag. Dies ist die Voreinstellung, außer wenn FPX-Schalter explizit angegeben werden.

en: Dummy procedure %qs at %C cannot have a generic interface
de: Scheinprozedur %qs bei %C kann keine allgemeine Schnittstelle haben

en: Dummy procedure %qs at %L shall not be elemental
de: Scheinprozedur %qs bei %L darf nicht ELEMENTAL sein

en: Dummy procedure %qs is invalid in procedure pointer initialization at %L
de: Dummyprozedur %qs ist in Initialisierung des Prozedurzeigers bei %L ungültig

en: Dummy procedure %qs not allowed in elemental procedure %qs at %L
de: Scheinprozedur %qs nicht in elementarer Prozedur %qs bei %L erlaubt

en: Dummy procedure %qs of PURE procedure at %L must also be PURE
de: Scheinprozedur %qs der PURE-Prozedur bei %L muss auch PURE sein

en: Dummy procedure at %C may not have BIND(C) attribute with NAME
de: Scheinprozedur bei %C kann kein BIND(C)-Attribut mit NAME haben

en: Dump Source Coverage Obligations.
de: Quellcode-Abdeckungsverpflichtungen wegschreiben.

en: Dump a textual representation of each diagnostic's exploded path to SRCFILE.IDX.KIND.epath.txt.
de: Textdarstellung des Pfades jeder Diagnosemeldung nach QUELLDATEI.IDX.KIND.epath.txt wegschreiben.

en: Dump a textual representation of the exploded graph to SRCFILE.eg-ID.txt.
de: Textdarstellung des expandierten Graphen nach SRCFILE.eg-ID.txt wegschreiben.

en: Dump a textual representation of the exploded graph to SRCFILE.eg.txt.
de: Textdarstellung des expandierten Graphen nach SRCFILE.eg.txt wegschreiben.

en: Dump analyzer-specific call graph information to a SRCFILE.callgraph.dot file.
de: Aufrufgraphen des Analysierers nach SRCFILE.callgraph.dot wegschreiben.

en: Dump analyzer-specific data to a SRCFILE.analyzer.json.gz file.
de: Daten des Analysierers nach SRCFILE.analyzer.json.gz wegschreiben.

en: Dump declarations to a .decl file.
de: Deklaration in .decl-Datei ausgeben.

en: Dump detailed information on GCC's internal representation of source code locations.
de: Detaillierte Informationen über die GCC-interne Repräsentation von Quellcode-Stellen ausgeben.

en: Dump only the defined symbols.
de: Nur die definierten Symbole wegschreiben.

en: Dump optimization passes.
de: Optimierungsdurchläufe ausgeben.

en: Dump state-purging information to a SRCFILE.state-purge.dot file.
de: Informationen über das Wegwerfen von Zuständen nach SRCFILE.state-purge.dot wegschreiben.

en: Dump the analyzer exploded graph to a SRCFILE.eg.dot file.
de: Expandierten Graphen des Analysierers nach SRCFILE.eg.dot wegschreiben.

en: Dump the analyzer supergraph to a SRCFILE.supergraph.dot file.
de: Gesamtgraphen des Analysierers nach SRCFILE.supergraph.dot wegschreiben.

en: Dump the demangled output.
de: Die entmangelte Ausgabe wegschreiben.

en: Dump the details of LTO objects.
de: Die Details von LTO-Objekten wegschreiben.

en: Dump the dump tool command line options.
de: Die Kommandozeilenoptionen des Dump-Werkzeugs wegschreiben.

en: Dump the statistics of gimple statements.
de: Die Statistik der GIMPLE-Anweisungen wegschreiben.

en: Dump the statistics of tree types.
de: Die Statistik der Baumarten wegschreiben.

en: Dump the statistics of trees.
de: Die Statistik der Bäume wegschreiben.

en: Dump the symtab callgraph.
de: Den Aufrufgraphen der Symboltabelle wegschreiben.

en: Dump various analyzer internals to SRCFILE.*.fg.dot and SRCFILE.*.tg.dot.
de: Diverse Interna des Analysierers nach SRCFILE.*.fg.dot und SRCFILE.*.tg.dot wegschreiben.

en: Dump various analyzer internals to SRCFILE.analyzer.txt.
de: Diverse Interna des Analysierers nach SRCFILE.analyzer.txt wegschreiben.

en: Dump various analyzer internals to stderr.
de: Diverse Interna des Analysierers auf die Standardfehlerausgabe wegschreiben.

en: Duplicate %s attribute at %L
de: Doppeltes Attribut %s bei %L

en: Duplicate %s attribute specified at %L
de: Attribut %s doppelt angegeben bei %L

en: Duplicate %s label specification at %C
de: Doppelte Markenspezifikation %s bei %C

en: Duplicate %s specification at %C
de: Doppelte Spezifikation %s bei %C

en: Duplicate ASYNCHRONOUS attribute specified at %L
de: Doppeltes ASYNCHRONOUS-Attribut bei %L angegeben

en: Duplicate AUTOMATIC attribute specified at %L
de: Doppeltes AUTOMATIC-Attribut bei %L angegeben

en: Duplicate BIND attribute specified at %L
de: Doppeltes BIND-Attribut bei %L angegeben

en: Duplicate DEFERRED at %C
de: Doppeltes DEFERRED bei %C

en: Duplicate DIMENSION attribute at %C
de: Doppeltes DIMENSION-Attribut bei %C

en: Duplicate ELSE statements at %L and %C
de: Doppelte ELSE-Anweisungen bei %L und %C

en: Duplicate EXTENDS attribute specified at %L
de: Doppeltes EXTENDS-Attribut bei %L angegeben

en: Duplicate IMPLICIT NONE statement at %C
de: Doppelte IMPLICIT NONE-Anweisung bei %C

en: Duplicate NML specification at %C
de: Doppelte NML-Spezifikation bei %C

en: Duplicate NON_OVERRIDABLE at %C
de: Doppeltes NON_OVERRIDABLE bei %C

en: Duplicate POINTER attribute at %C
de: Doppeltes POINTER-Attribut bei %C

en: Duplicate PRIVATE statement at %C
de: Doppelte PRIVATE-Anweisung bei %C

en: Duplicate PROTECTED attribute specified at %L
de: Doppeltes PROTECTED-Attribut bei %L angegeben

en: Duplicate SAVE attribute specified at %L
de: SAVE-Attribut doppelt angegeben bei %L

en: Duplicate SEQUENCE statement at %C
de: Doppelte SEQUENCE-Anweisung bei %C

en: Duplicate UNIT specification at %C
de: Doppelte UNIT-Spezifikation bei %C

en: Duplicate VALUE attribute specified at %L
de: Doppeltes VALUE-Attribut bei %L angegeben

en: Duplicate VOLATILE attribute specified at %L
de: Doppeltes VOLATILE-Attribut bei %L angegeben

en: Duplicate access-specifier at %C
de: Doppelte Zugriffsspezifikation bei %C

en: Duplicate argument %qs at %L to intrinsic %s
de: Doppeltes Argument %qs bei %L für intrinsisches %s

en: Duplicate array spec for Cray pointee at %C
de: Doppelte Feldspezifikation für Cray-Zeigerende bei %C

en: Duplicate construct label %qs at %C
de: Doppelte Aufbau-Marke %qs bei %C

en: Duplicate format specification at %C
de: Doppelte Format-Spezifikation bei %C

en: Duplicate name %qs in association at %C
de: Doppelter Name %qs in Verknüpfung bei %C

en: Duplicate name %qs in parameter list at %C
de: Doppelter Name %qs in Parameterliste bei %C

en: Duplicate statement label %d at %L and %L
de: Doppelte Anweisungsmarke %d bei %L und %L

en: Duplicate symbol %qs in formal argument list at %C
de: Doppeltes Symbol %qs in formaler Argumentliste bei %C

en: Duplicated %qs clause at %L
de: Doppelte Klausel %qs bei %L

en: During link time optimization warn about mismatched types of global declarations.
de: Während der Optimierungen zur Linkzeit bei unpassenden Typen von globalen Deklarationen warnen.

en: Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return.
de: Dynamic Realign Argument Pointer (DRAP) wird in Interrupt-Service-Routinen nicht unterstützt. Ein Workaround ist, Funktionen mit Aggregat-Rückgabetypen zu vermeiden.

en: Dynamically allocate cc registers.
de: CC-Register dynamisch belegen.

en: E specifier not allowed with g0 descriptor in format string at %L
de: E-Angabe nicht erlaubt mit g0-Deskriptor in Formatzeichenkette bei %L

en: EDGE_CROSSING incorrectly set across same section
de: Interner Fehler: EDGE_CROSSING incorrectly set across same section

en: EDGE_CROSSING missing across section boundary
de: Interner Fehler: EDGE_CROSSING missing across section boundary

en: EH edge crosses section boundary in bb %i
de: Interner Fehler: EH edge crosses section boundary in bb %i

en: EH incoming edge mixed with non-EH incoming edges in bb %i
de: Interner Fehler: EH incoming edge mixed with non-EH incoming edges in bb %i

en: EH landing pad label %qD is not first in a sequence of labels in bb %d
de: Interner Fehler: EH landing pad label %qD is not first in a sequence of labels in bb %d

en: ELEMENTAL function %qs at %L must have a scalar result
de: ELEMENTAL-Funktion %qs bei %L muss ein skalares Ergebnis haben

en: ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L
de: ELEMENTAL, nicht-INTRINSIC-Prozedur %qs ist nicht als effektives Argument bei %L erlaubt

en: ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L
de: ELEMENTAL-Präfix fehlt in MODULE-PROCEDURE-Schnittstelle bei %L

en: ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L
de: ELEMENTAL Prozedurzeigerkomponente %qs ist nicht als effektives Argument bei %L erlaubt

en: ELFv2 parameter passing for an argument containing zero-width bit fields but that is otherwise a homogeneous aggregate was corrected in GCC 12
de: ELFv2-Parameterübergabe für ein Argument, das Bitfelder der Breite 0 enthält, aber ansonsten ein homogenes Aggregat ist, wurde in GCC 12 korrigiert

en: ELSE IF statement at %C cannot follow ELSE statement at %L
de: ELSE-IF-Anweisung bei %C kann nicht auf eine ELSE-Anweisung bei %L folgen

en: ELSEWHERE statement at %C follows previous unmasked ELSEWHERE
de: Anweisung ELSEWHERE bei %C folgt zuvor unmaskiertem ELSEWHERE

en: ELSEWHERE statement at %C not enclosed in WHERE block
de: ELSEWHERE-Anweisung bei %C nicht eingeschlossen in WHERE-Block

en: ENCODING= at %L not allowed in Fortran 95
de: ENCODING= bei %L ist in Fortran 95 nicht erlaubt

en: END TEAM statement at %C
de: END-TEAM-Anweisung bei %C

en: END statement instead of %s statement at %L
de: END-Anweisung statt %s-Anweisung bei %L

en: END tag at %C not allowed in output statement
de: END-Tag bei %C in Ausgabe-Anweisung nicht erlaubt

en: END tag label %d at %L not defined
de: END-Marke %d bei %L nicht definiert

en: ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE
de: ENTRY %qs bei %L kann nicht rekursiv aufgerufen werden, da Funktion %qs nicht RECURSIVE ist

en: ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE
de: ENTRY %qs bei %L kann nicht rekursiv aufgerufen werden, da Unterprogramm %qs nicht RECURSIVE ist

en: ENTRY %qs at %L has no IMPLICIT type
de: ENTRY %qs bei %L hat keinen IMPLICIT-Typ

en: ENTRY result %s cannot be a POINTER in FUNCTION %s at %L
de: ENTRY-Ergebnis %s kann kein POINTER in FUNCTION %s bei %L sein

en: ENTRY result %s cannot be an array in FUNCTION %s at %L
de: ENTRY-Ergebnis %s kann kein Feld in FUNCTION %s bei %L sein

en: ENTRY result %s cannot be of type %s in FUNCTION %s at %L
de: ENTRY-Ergebnis %s kann nicht vom Typ %s in FUNCTION %s bei %L sein

en: ENTRY statement at %C
de: ENTRY-Anweisung bei %C

en: ENTRY statement at %C cannot appear in a contained procedure
de: ENTRY-Anweisung bei %C kann nicht in einer enthaltenen Prozedur auftreten

en: ENTRY statement at %C cannot appear within a BLOCK DATA
de: ENTRY-Anweisung bei %C kann nicht innerhalb von BLOCK DATA auftreten

en: ENTRY statement at %C cannot appear within a DERIVED TYPE block
de: ENTRY-Anweisung bei %C kann nicht innerhalb eines DERIVED TYPE Blockes auftreten

en: ENTRY statement at %C cannot appear within a DO block
de: ENTRY-Anweisung bei %C kann nicht innerhalb eines DO-Blockes auftreten

en: ENTRY statement at %C cannot appear within a FORALL block
de: ENTRY-Anweisung bei %C kann nicht innerhalb eines FORALL-Blockes auftreten

en: ENTRY statement at %C cannot appear within a MODULE
de: ENTRY-Anweisung bei %C kann nicht innerhalb eines MODULEs auftreten

en: ENTRY statement at %C cannot appear within a PROGRAM
de: ENTRY-Anweisung bei %C kann nicht innerhalb eines PROGRAMmes auftreten

en: ENTRY statement at %C cannot appear within a SELECT block
de: ENTRY-Anweisung bei %C kann nicht innerhalb eines SELECT-Blockes auftreten

en: ENTRY statement at %C cannot appear within a STRUCTURE block
de: ENTRY-Anweisung bei %C kann nicht innerhalb eines STRUCTURE-Blockes auftreten

en: ENTRY statement at %C cannot appear within a SUBMODULE
de: ENTRY-Anweisung bei %C kann nicht innerhalb eines SUBMODULEs auftreten

en: ENTRY statement at %C cannot appear within a WHERE block
de: ENTRY-Anweisung bei %C kann nicht innerhalb eines WHERE-Blockes auftreten

en: ENTRY statement at %C cannot appear within a contained subprogram
de: ENTRY-Anweisung bei %C kann nicht innerhalb eines enthaltenen Subprogrammes auftreten

en: ENTRY statement at %C cannot appear within an IF-THEN block
de: ENTRY-Anweisung bei %C kann nicht innerhalb eines IF-THEN-Blockes auftreten

en: ENTRY statement at %C cannot appear within an INTERFACE
de: ENTRY-Anweisung bei %C kann nicht innerhalb von INTERFACE auftreten

en: ENTRY statement at %L with BIND(C) prohibited in an elemental procedure
de: ENTRY-Anweisung bei %L mit BIND(C) ist in einer elementaren Prozedur verboten

en: ENUM and ENUMERATOR at %C
de: ENUM und ENUMERATOR bei %C

en: ENUM declaration at %C has no ENUMERATORS
de: ENUM-Deklaration bei %C hat keine ENUMERATORen

en: ENUM definition statement expected before %C
de: Anweisung zur ENUM-Definition vor %C erwartet

en: ENUMERATOR %L not initialized with integer expression
de: ENUMERATOR %L nicht mit Ganzzahlausdruck initialisiert

en: EOR tag label %d at %L not defined
de: EOR-Marke %d bei %L nicht definiert

en: EQUIVALENCE at %C requires two or more objects
de: EQUIVALENCE bei %C erfordert zwei oder mehr Objekte

en: EQUIVALENCE statement at %C
de: EQUIVALENCE-Anweisung bei %C

en: ERR tag label %d at %L not defined
de: ERR-Marke %d bei %L nicht definiert

en: ERRMSG at %L
de: ERRMSG bei %L

en: ERRMSG at %L is useless without a STAT tag
de: ERRMSG bei %L ist ohne STAT-Marke nutzlos

en: ERRMSG tag at %L
de: ERRMSG-Markierung bei %L

en: ERRMSG variable
de: ERRMSG-Variable

en: ERRMSG variable at %L shall be a scalar default CHARACTER variable
de: »ERRMSG=«-Variable bei %L muss skalare Default-CHARACTER-Variable sein

en: ERRMSG= argument at %L must be a scalar CHARACTER variable
de: »ERRMSG=«-Argument bei %L muss skalare CHARACTER-Variable sein

en: ERROR STOP statement at %C
de: ERROR STOP-Anweisung bei %C

en: ESA/390 architecture.
de: ESA/390-Architektur.

en: EVENT POST statement at %C
de: »EVENT POST«-Anweisung bei %C

en: EVENT WAIT statement at %C
de: »EVENT WAIT«-Anweisung bei %C

en: EVENT argument at %L to the intrinsic EVENT_QUERY shall be of type EVENT_TYPE
de: EVENT-Argument bei %L für die intrinsische EVENT_QUERY muss vom Typ EVENT_TYPE sein

en: EXIT statement at %C terminating !$ACC LOOP loop
de: EXIT-Anweisung bei %C beendet »!$ACC LOOP«-Schleife

en: EXIT statement at %C terminating !$OMP DO loop
de: EXIT-Anweisung bei %C beendet !$OMP DO Schleife

en: EXIT statement with no do-construct-name at %C
de: EXIT-Anweisung ohne DO-CONSTRUCT-Name bei %C

en: EXTENDS at %L
de: EXTENDS bei %L

en: EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L
de: Attribut EXTERNAL steht mit Attribut FUNCTION in %qs bei %L in Konflikt

en: Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute
de: Entweder alle oder keines der Objekte in bei %L gesetztem EQUIVALENCE muss das Attribut PROTECTED haben

en: Element in %s array constructor at %L is %s
de: Element in Feldkonstruktor %s bei %L ist %s

en: Element of assumed-shape or pointer array as actual argument at %L cannot correspond to actual argument at %L
de: Element des Feldes mit vermuteter Form oder von Zeigern bei %L kann nicht zum Argument bei %L passen

en: Element of assumed-shape or pointer array passed to array dummy argument %qs at %L
de: Element des Feldes mit vermuteter Form oder von Zeigern wird bei %2$L an ein Feld-Scheinargument %1$qs übergeben

en: Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L
de: Element mit einem Wert von %1$d in ORDER bei %2$L muss für das intrinsische RESHAPE in der Nähe von %4$L im Bereich [1, …, %3$d] liegen

en: Elemental function as initialization expression with non-integer/non-character arguments at %L
de: Elementare Funktion als Initialisierungsausdruck mit Nicht-Ganzzahl-/Nicht-Zeichen-Argumenten bei %L

en: Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)
de: Elemente mit demselben Wert bei %L und %L in Vektorindex in einem Variablen-Definitionskontext (%s)

en: Eliminate multiple function invocations also for impure functions.
de: Mehrere Funktionsaufrufe auch für unreine Funktionen entfernen.

en: Emit .gnu_attribute tags.
de: ».gnu_attribute«-Etiketten erzeugen.

en: Emit .stack_size directives.
de: .stack_size-Direktiven erzeugen.

en: Emit 16-bit relocations to the small data areas.
de: 16-bit-Adressverschiebungen in kleinen Datenbereichen ablegen.

en: Emit 32-bit relocations to the small data areas.
de: 32-bit-Adressverschiebungen in kleinen Datenbereichen erzeugen.

en: Emit GNU_PROPERTY_X86_ISA_1_NEEDED GNU property.
de: Property GNU_PROPERTY_X86_ISA_1_NEEDED GNU generieren.

en: Emit IEEE-conformant code, without inexact exceptions.
de: IEEE-konformen Code erzeugen, ohne ungenaue Ausnahmen.

en: Emit RISC-V ELF attribute.
de: ELF-Attribut für RISC-V generieren.

en: Emit call graph information.
de: Informationen zum Aufrufgraph ausgeben.

en: Emit checks causing "break 8" instructions to execute when applying atomic builtins on misaligned memory.
de: Prüfungen generieren, die bei Anwendung atomarer eingebauter Operationen auf unausgerichtetem Speicher zu »break 8«-Befehlen führen.

en: Emit code for the byte/word ISA extension.
de: Code für die Byte/Word-ISA-Erweiterung erzeugen.

en: Emit code for the counting ISA extension.
de: Code für die Zählen-ISA-Erweiterung erzeugen.

en: Emit code for the fp move and sqrt ISA extension.
de: Code für die FP-Move- und SQRT-ISA-Erweiterung erzeugen.

en: Emit code for the motion video ISA extension.
de: Code für die Video-ISA-Erweiterung erzeugen.

en: Emit code using explicit relocation directives.
de: Code mit expliziten Adressverschiebungsbefehlen erzeugen.

en: Emit common-like symbols as weak symbols.
de: Common-ähnliche Symbole als schwache Symbole ausgeben.

en: Emit custom warnings with internal details intended for analyzer developers.
de: Benutzerdefinierte Warnungen mit internen Details ausgeben, die für Entwickler von Analyseprogrammen bestimmt sind.

en: Emit debug annotations during preprocessing.
de: Debug-Kommentare während der Vorverarbeitung ausgeben.

en: Emit debugging information related to the escape analysis pass when run with -fgo-optimize-allocs.
de: Debuginformation für den Escape-Analyse-Durchlauf ausgeben, wenn mit -fgo-optimize-allocs aufgerufen.

en: Emit diagnostics showing the location of nodes in the exploded graph.
de: Diagnoseinformationen zur Position der Knoten im expandierten Graphen ausgeben.

en: Emit direct branches to local functions.
de: Direkte Zweige in lokalen Funktionen erzeugen.

en: Emit extra code in the function prologue in order to trap if the stack size exceeds the given limit.
de: Zusätzlichen Code im Funktionsprolog ausgeben, um ein Überschreiten des angegebenen Limits für die Stapelgröße abzufangen (trap).

en: Emit function prologues only before parts of the function that need it, rather than at the top of the function.
de: Funktionsprologe nur vor Teilen der Funktion erzeugen, die diese benötigt, statt am Anfang der Funktion.

en: Emit function-calls using global offset table when generating PIC.
de: Bei PIC-Erzeugung Funktionsaufrufe ausgeben, die die globale Offsettabelle verwenden.

en: Emit fused multiply-add instructions for long doubles in vector registers (wfmaxb, wfmsxb, wfnmaxb, wfnmsxb).  Reassociation pass does not handle fused multiply-adds, therefore code generated by the middle-end is prone to having long fused multiply-add chains.  This is not pipeline-friendly, and the default behavior is to emit separate multiplication and addition instructions for long doubles in vector registers, because measurements show that this improves performance.  This option allows overriding it for testing purposes.
de: Verschmolzene multiply-add-Befehle für long double in Vektorregistern (wfmaxb, wfmsxb, wfnmaxb, wfnmsxb) generieren. Der Durchlauf für Neuverknüpfungen verarbeitet verschmolzene multiply-add-Befehle nicht, daher enthält der vom Mittelteil generierte Code häufig lange verschmolzene multiply-add-Ketten. Das kann die Pipeline nicht gut verarbeiten, daher ist das Standardverhalten, die multiply- und add-Befehle separat zu generieren, soweit es long double in Vektorregistern betrifft. Performancemessungen haben ergeben, dass das besser ist. Diese Option erlaubt das Standardverhalten zu übersteuern, zu Testzwecken.

en: Emit implicit instantiations of inline templates.
de: Implizite Instanziierungen von »inline«-Templates ausgeben.

en: Emit implicit instantiations of templates.
de: Implizite Instanziierungen von Templates ausgeben.

en: Emit indirect branches to local functions.
de: Indirekte Zweige in lokalen Funktionen erzeugen.

en: Emit instrumentation calls to __tsan_func_entry() and __tsan_func_exit().
de: Instrumentierungsaufrufe für Aufrufe von __tsan_func_entry() und __tsan_func_exit() erzeugen.

en: Emit long load/store sequences.
de: Lange Laden/Speichern-Folgen ausgeben.

en: Emit more verbose descriptions of control flow in diagnostics.
de: Ausführlichere Beschreibungen des Steuerablaufs in den Diagnosemeldungen ausgeben.

en: Emit more verbose descriptions of state changes in diagnostics.
de: Ausführlichere Beschreibungen der Zustandsänderungen in den Diagnosemeldungen ausgeben.

en: Emit optimization diagnostics.
de: Diagnosemeldungen für Optimierung ausgeben.

en: Emit profiling counter call at function entry before prologue.
de: Profiling-Zähleraufruf am Funktionsanfang vor Prolog ausgeben.

en: Emit profiling counter call at function entry before prologue. The compiled code will require a 64-bit CPU and glibc 2.29 or newer to run.
de: Aufruf für Profiling-Zähler am Funktionsanfang vor dem Prolog ausgeben. Der compilierte Code benötigt eine 64-Bit-CPU sowie glibc 2.29 oder neuer zum Laufen.

en: Emit progressive recommended breakpoint locations.
de: Progressive empfohlene Breakpoint-Stellen ausgeben.

en: Emit rdval instead of rduniq for thread pointer.
de: rdval statt rduniq für Thread-Zeiger erzeugen.

en: Emit special instrumentation for accesses to volatiles.
de: Spezielle Instrumentierung für Zugriff auf volatile-Objekte erzeugen.

en: Emit static const variables even if they are not used.
de: static-const-Variablen erzeugen, auch wenn sie nicht verwendet werden.

en: Emit stop bits before and after volatile extended asms.
de: Vor und nach »volatile extended«-asms Stopp-Bits ausgeben.

en: Emit template instantiations as weak symbols.
de: Template-Instanziierungen als schwache Symbole ausgeben.

en: Emit traps as "break 8", default for CRIS v3 and up.  If disabled, calls to abort() are used.
de: Traps als »break 8« ausgeben, voreingestellt für CRIS v3 und aufwärts. Wenn ausgeschaltet, werden Aufrufe von abort() verwendet.

en: Emit verbose debug information in assembly code.
de: Ausführliche Informationen zur Fehlersuche im Assemblercode ausgeben.

en: Empty FINAL at %C
de: Leeres FINAL bei %C

en: Empty IMPLICIT statement at %C
de: Leere IMPLICIT-Anweisung bei %C

en: Empty array constructor at %C is not allowed
de: Leerer Feldkonstruktor bei %C ist nicht erlaubt

en: Empty old style initializer list at %C
de: Leere Initialisierungsliste im alten Stil bei %C

en: Empty set of digits in BOZ constant at %C
de: Leere Ziffernmenge in BOZ-Konstante bei %C

en: Enable 'q' instruction alternatives.
de: Alternativen für q-Befehl einschalten.

en: Enable 16-entry register file.
de: Registersatz mit 16 Einträgen aktivieren.

en: Enable 32-bit ALU instructions.
de: 32-Bit-ALU-Befehle einschalten.

en: Enable 32-bit jump instructions.
de: 32-Bit-Sprungbefehle einschalten.

en: Enable 64-bit Time-Stamp Counter extension instruction.
de: Erweiterung für 64-Bit-Zeitstempel-Befehl einschalten.

en: Enable C++ coroutines (experimental).
de: C++-Koroutinen einschalten (experimentell).

en: Enable C++ header module (experimental).
de: C++-Header-Modul einschalten (experimentell).

en: Enable C++ modules-ts (experimental).
de: C++-modules-ts einschalten (experimentell).

en: Enable C++14 sized deallocation support.
de: Unterstützung für Deallozierung mit Größenangabe aus C++14 einschalten.

en: Enable C-SKY DSP instructions.
de: C-SKY-DSP-Befehle einschalten.

en: Enable C-SKY Enhanced DSP instructions.
de: Erweiterte C-SKY-DSP-Befehle einschalten.

en: Enable C-SKY SECURE instructions.
de: C-SKY-SECURE-Befehle einschalten.

en: Enable C-SKY TRUST instructions.
de: C-SKY-TRUST-Befehle einschalten.

en: Enable C-SKY Vector DSP instructions.
de: C-SKY-DSP-Vektorbefehle einschalten.

en: Enable CFI tables via GAS assembler directives.
de: CFI-Tabellen über GAS-Assembler-Direktiven einschalten.

en: Enable DEC-style STATIC and AUTOMATIC attributes.
de: STATIC- und AUTOMATIC-Attribute im DEC-Stil einschalten.

en: Enable DIV, DIVU.
de: DIV und DIVU einschalten.

en: Enable DIV-REM instructions for ARCv2.
de: DIV-REM-Befehle für ARCv2 einschalten.

en: Enable DSP 3.1 Pack A extensions.
de: DSP-3.1-Paket-A-Erweiterungen einschalten.

en: Enable DWARF line debug info via GNU as.
de: Dwarf-Zeilenfehlersuchinfo über GNU as einschalten.

en: Enable Dual and Single Operand Instructions for Telephony.
de: Befehle mit einem oder zwei Operanden für Telefonie einschalten.

en: Enable ENTER_S and LEAVE_S opcodes for ARCv2.
de: Die Opcodes ENTER_S und LEAVE_S für ARCv2 einschalten.

en: Enable FT32B code compression.
de: Codekomprimierung für FT32B-Code aktivieren.

en: Enable Full Redundancy Elimination (FRE) on trees.
de: Vollständige Redundanzentfernung (FRE) auf Bäumen einschalten.

en: Enable Function Descriptor PIC mode.
de: Funktionsdeskriptor-PIC-Modus einschalten.

en: Enable Graphite Identity transformation.
de: Transformation der Graphite-Identität einschalten.

en: Enable ID based shared library.
de: ID-basierte Shared Library einschalten.

en: Enable IEEE 128-bit floating point via the __float128 keyword.
de: IEEE-128-Bit-Gleitkommazahlen mittels Schlüsselwort »__float128« einschalten.

en: Enable Local Register Allocation.
de: Lokale Registerzuordnung einschalten.

en: Enable Locked Load/Store Conditional extension.
de: Erweiterung für gesperrte Load/Store-Conditional-Befehle einschalten.

en: Enable MUL instructions.
de: MUL-Befehle einschalten.

en: Enable MUL.X and UMUL.X instructions.
de: Befehle MUL.X und UMUL.X einschalten.

en: Enable MULX instructions, assume fast shifter.
de: MULX-Befehle einschalten, schnelle Bitverschiebung annehmen.

en: Enable Objective-C exception and synchronization syntax.
de: Objective-C-Ausnahme- und -Synchronisations-Syntax einschalten.

en: Enable Objective-C setjmp exception handling runtime.
de: Laufzeitbibliothek zur Objective-C setjmp-Ausnahmebehandlung einschalten.

en: Enable OpenACC.
de: OpenACC einschalten.

en: Enable OpenMP (implies -frecursive in Fortran).
de: OpenMP einschalten (bringt »-frecursive« in Fortran mit sich).

en: Enable OpenMP GPU offloading.
de: Auslagern an OpenMP-GPU einschalten.

en: Enable OpenMP's SIMD directives.
de: SIMD-Direktiven von OpenMP einschalten.

en: Enable PIC support for building libraries.
de: PIC-Unterstützung beim Bauen von Bibliotheken einschalten.

en: Enable Plan 9 language extensions.
de: Plan-9-Spracherweiterungen einschalten.

en: Enable Rcq constraint handling - most short code generation depends on this.
de: Rcq-Constraint-Handling einschalten – der Großteil der Kurzcodeerzeugung hängt davon ab.

en: Enable Rcw constraint handling - ccfsm condexec mostly depends on this.
de: Rcq-Constraint-Handling einschalten – ccfsm-condexec hängt zum großen Teil davon ab.

en: Enable Read-Modify-Write (RMW) instructions support/use.
de: Verwendung von Read-Modify-Write-Befehlen (RMW) einschalten.

en: Enable SSA coalescing of user variables.
de: Zusammenfassen von nutzersichtbaren Variablen während des SSA-Durchlaufs einschalten.

en: Enable SSA code sinking on trees.
de: SSA-Codeversenkung auf Bäumen einschalten.

en: Enable SSA dead code elimination optimization on trees.
de: Beseitigungsoptimierung für toten SSA-Code auf Bäumen einschalten.

en: Enable SSA-BIT-CCP optimization on trees.
de: SSA-BIT-CCP-Optimierungen auf Bäumen einschalten.

en: Enable SSA-CCP optimization on trees.
de: SSA-CCP-Optimierungen auf Bäumen einschalten.

en: Enable SSA-PRE optimization on trees.
de: SSA-PRE-Optimierungen auf Bäumen einschalten.

en: Enable TPF-OS tracing code.
de: TPF-OS-Tracing-Code einschalten.

en: Enable Virtual Hosting support.
de: Virtual-Hosting-Unterstützung einschalten.

en: Enable XY Memory extension (DSP version 3).
de: XY-Speicher-Erweiterung (DSP Version 3) einschalten.

en: Enable alignment of COMMON blocks.
de: Ausrichtung von COMMON-Blöcken einschalten.

en: Enable all -Wunused- warnings.
de: Alle -Wunused- Warnungen einschalten.

en: Enable all DEC language extensions.
de: Alle DEC-Spracherweiterungen zulassen.

en: Enable all optimization info dumps on stderr.
de: Alle Informationen über Optimierungen auf stderr einschalten.

en: Enable an RTL peephole pass before sched2.
de: Einen RTL-Guckloch-Durchlauf vor sched2 einschalten.

en: Enable asan allocas/VLAs protection.
de: ASan-Schutz für alloca/VLAs einschalten.

en: Enable asan builtin functions protection.
de: ASan-Schutz für eingebaute Funktionen einschalten.

en: Enable asan detection of use-after-return bugs.
de: ASan-Schutz für Verwendung-nach-Rückkehr-Fehler einschalten.

en: Enable asan globals protection.
de: ASan-Schutz für globale Variablen einschalten.

en: Enable asan load operations protection.
de: ASan-Schutz für Ladeoperationen einschalten.

en: Enable asan stack protection.
de: ASan-Schutz für Stapelspeicher einschalten.

en: Enable asan store operations protection.
de: ASan-Schutz für Speicheroperationen einschalten.

en: Enable assembler and linker relaxation.  Enabled by default at -Os.
de: Lockerung des Assemblers und Linkers einschalten. Per Vorgabe eingeschaltet bei -Os.

en: Enable atomic instructions.
de: Atomare Befehle einschalten.

en: Enable backend debugging.
de: Backend-Fehlersuche einschalten.

en: Enable backward propagation of use properties at the SSA level.
de: Rückwärtsübermittlung von Nutzungseigenschaften auf SSA-Ebene einschalten.

en: Enable barrel shift instructions.
de: Rohr-Bitschiebebefehle einschalten.

en: Enable basic block vectorization (SLP) on trees.
de: Vektorisierung von Basisblöcken (SLP) auf Bäumen einschalten.

en: Enable basic program profiling code.
de: Einfachen Programm-Profilierungscode einschalten.

en: Enable bbit peephole2.
de: Bbit-Peephole2 einschalten.

en: Enable cache bypass for volatile references.
de: Cache-Umgehung für flüchtige Referenzen umgehen.

en: Enable cache prefetch instructions.
de: Cache-Prefetch-Befehle einschalten.

en: Enable certain features present in the Concepts TS.
de: Bestimmte Features, die im Concept-TS vorhanden sind, einschalten.

en: Enable code density instructions for ARCv2.
de: Codedichte-Befehle für ARCv2 einschalten.

en: Enable code hoisting.
de: Codeanhebung einschalten.

en: Enable common options for generating profile info for profile feedback directed optimizations, and set -fprofile-dir=.
de: Allgemeine Optionen zum Erzeugen von Profil-Info für Profil-Feedback-gerichtete Optimierungen einschalten, und -fprofile-dir= setzen.

en: Enable common options for generating profile info for profile feedback directed optimizations.
de: Allgemeine Optionen zum Erzeugen von Profil-Info für Profil-Feedback-gerichtete Optimierungen einschalten.

en: Enable common options for performing profile feedback directed optimizations, and set -fprofile-dir=.
de: Allgemeine Optionen zum Durchführen von Profil-Feedback-gerichteten Optimierungen einschalten, und -fprofile-dir= setzen.

en: Enable common options for performing profile feedback directed optimizations.
de: Allgemeine Optionen zum Durchführen von Profil-Feedback-gerichteten Optimierungen einschalten.

en: Enable compact casesi pattern.
de: Kompakte casesi-Muster einschalten.

en: Enable conditional dead code elimination for builtin calls.
de: Beseitigung von bedingt totem Code für Aufrufe eingebauter Funktionen einschalten.

en: Enable conditional execution other than moves/scc.
de: Bedingte Ausführung (für andere Befehle als Kopieren/scc) einschalten.

en: Enable conditional move instruction usage.
de: Verwendung bedingter Kopierbefehle einschalten.

en: Enable conditional moves.
de: Bedingte Kopierbefehle einschalten.

en: Enable constructor/destructor feature.
de: Konstruktor-/Destruktor-Feature einschalten.

en: Enable coprocessor instructions.
de: Koprozessorbefehle einschalten.

en: Enable copy propagation of scalar-evolution information.
de: Kopieweitergabe von Informationen über Skalar-Evolution einschalten.

en: Enable copy propagation on trees.
de: Kopieweitergabe auf Bäumen einschalten.

en: Enable correction of flow inconsistent profile data input.
de: Korrektur fluss-unstimmiger Profildateneingabe einschalten.

en: Enable dead store elimination.
de: Entfernung toter Speicherungen einschalten.

en: Enable debug output.
de: Ausgaben zur Fehlersuche einschalten.

en: Enable decimal floating point hardware support.
de: Hardwareunterstützung für dezimales Gleitkomma einschalten.

en: Enable default conversions between __float128 & long double.
de: Standardumwandlungen zwischen »__float128« und »long double« einschalten.

en: Enable default widths for i, f and g format specifiers.
de: Standardbreiten für die Formatangaben i, f und g aktivieren.

en: Enable divide and modulus instructions.
de: Divisions- und Modulobefehle einschalten.

en: Enable dominator optimizations.
de: Dominator-Optimierungen einschalten.

en: Enable double load/store instructions for ARC HS.
de: Doppelte Load/Store-Befehle für ARC HS einschalten.

en: Enable dual viterbi butterfly extension.
de: Erweiterung Dual-Virterbi-Butterfly einschalten.

en: Enable earlier placing stop bits for better scheduling.
de: Frühere Stopp-Bit-Platzierung für bessere Planung einschalten.

en: Enable exception handling.
de: Ausnahmebehandlung einschalten.

en: Enable extra conditional-branch instructions j(s)lt and j(s)le.
de: Zusätzliche bedingte Verzweigungsanweisungen j(s)lt und j(s)le einschalten.

en: Enable forward propagation on trees.
de: Vorwärts-Übertragung auf Bäumen einschalten.

en: Enable front end optimization.
de: Frontend-Optimierung einschalten.

en: Enable function profiling.
de: Funktionsprofilierung einschalten.

en: Enable function reordering that improves code placement.
de: Funktionen umsortieren, um Codeplatzierung zu verbessern.

en: Enable garbage collection (GC) in Objective-C/Objective-C++ programs.
de: Garbage Collection (GC) in Objective-C/Objective-C++-Programmen einschalten.

en: Enable generation of ARC SIMD instructions via target-specific builtins.
de: Erzeugen von ARC-SIMD-Befehlen mithilfe von zielspezifischen eingebauten Funktionen zu erzeugen.

en: Enable generation of R2 BMX instructions.
de: Erzeugen von R2-BMX-Befehlen einschalten.

en: Enable generation of R2 CDX instructions.
de: Erzeugen von R2-CDX-Befehlen einschalten.

en: Enable generation of binaries which use functions from libgcc to perform divide operations.  The default is -mhard-div.
de: Binärdateien erzeugen, die Divisionen mit Funktionen aus der libgcc durchführen. Die Vorgabe ist »-mhard-div«.

en: Enable generation of binaries which use functions from libgcc to perform floating point operations.  This is the default; use -mhard-float to override.
de: Binärdateien erzeugen, die Gleitkommaberechnungen mit Funktionen aus der libgcc durchführen. Dies ist die Voreinstellung; änderbar mit »-mhard-float«.

en: Enable generation of binaries which use functions from libgcc to perform multiply operations. The default is -mhard-mul.
de: Binärdateien erzeugen, die Multiplikationen mit Funktionen aus der libgcc durchführen. Die Vorgabe ist »-mhard-mul«.

en: Enable generation of compare and set flag with immediate (l.sf*i) instructions. By default extra instructions will be generated to store the immediate to a register first.
de: Befehle für Vergleiche mit Setzen der Flags (l.sf*i) erlauben. Standardverhalten ist, stattdessen zusätzliche Befehle zu verwenden, die den Direktwert in ein Register zwischenspeichern.

en: Enable generation of conditional move (l.cmov) instructions.  By default the equivalent will be generated using set and branch.
de: Befehle für bedingte Zuweisungen (l.cmov) erlauben. Standardverhalten ist, stattdessen äquivalente set- und branch-Befehle zu verwenden.

en: Enable generation of hardware divide (l.div, l.divu) instructions.  This is the default; use -msoft-div to override.
de: Division mit Hardware-Befehlen (l.div, l.divu) aktivieren. Dies ist die Voreinstellung; änderbar mit »-msoft-div«.

en: Enable generation of hardware floating point instructions. The default is -msoft-float.
de: Gleitkommaberechnungen mit Hardware-Befehlen durchführen. Die Voreinstellung ist »-msoft-float«.

en: Enable generation of hardware multiply instructions (l.mul, l.muli) instructions. This is the default; use -msoft-mul to override.
de: Multiplikation mit Hardware-Befehlen (l.mul, l.muli) aktivieren. Dies ist die Vorgabe; änderbar mit »-msoft-mul«.

en: Enable generation of rotate right (l.ror) instructions.  By default functions from libgcc are used to perform rotate right operations.
de: Befehle für Rechtsdrehung (l.ror) erzeugen. Standardmäßig werden Funktionen aus der libgcc verwendet, um Rechtsdrehungen mit Direktoperand durchzuführen.

en: Enable generation of rotate right with immediate (l.rori) instructions.  By default functions from libgcc are used to perform rotate right with immediate operations.
de: Befehle für Rechtsdrehung mit Direktoperand (l.rori) erzeugen. Standardmäßig werden Funktionen aus der libgcc verwendet, um diese Befehle durchzuführen.

en: Enable generation of shift with immediate (l.srai, l.srli, l.slli) instructions. By default extra instructions will be generated to store the immediate to a register first.
de: Befehle für Bitverschiebung mit Direktwert (l.srai, l.srli, l.slli) erlauben. Standardverhalten ist, stattdessen zusätzliche Befehle zu verwenden, die den Direktwert in ein Register zwischenspeichern.

en: Enable generation of sign extension (l.ext*) instructions.  By default memory loads are used to perform sign extension.
de: Befehle für Vorzeichenerweiterung (l.ext*) erlauben. Standardverhalten ist, die Vorzeichenerweiterung mittels Ladebefehlen durchzuführen.

en: Enable guessing of branch probabilities.
de: Erraten der Sprungwahrscheinlichkeiten einschalten.

en: Enable hardware floating point.
de: Hardware-Gleitkommabefehle einschalten.

en: Enable hoisting adjacent loads to encourage generating conditional move instructions.
de: Herausziehen aufeinanderfolgender Ladeoperationen einschalten, um Erzeugung bedingter Kopieroperationen zu fördern.

en: Enable hoisting loads from conditional pointers.
de: Herausziehen von Ladeoperationen aus bedingten Zeigern einschalten.

en: Enable hwasan instrumentation of allocas/VLAs.
de: hwasan-Instrumentierung für alloca/VLAs einschalten.

en: Enable hwasan instrumentation of builtin functions.
de: hwasan-Instrumentierung für eingebaute Funktionen einschalten.

en: Enable hwasan instrumentation of load operations.
de: hwasan-Instrumentierung für Ladeoperationen einschalten.

en: Enable hwasan instrumentation of statically sized stack-allocated variables.
de: hwasan-Instrumentierung von auf dem Stapel allozierten Variablen fester Größe einschalten.

en: Enable hwasan instrumentation of store operations.
de: hwasan-Instrumentierung für Speicheroperationen einschalten.

en: Enable in and out of Graphite representation.
de: Ein- und Ausgabe der Graphite-Repräsentierung einschalten.

en: Enable inline checks for nil receivers with the NeXT runtime and ABI version 2.
de: »inline«-Prüfungen für NIL-Empfänger mit NeXT-Laufzeitumgebung und ABI-Version 2 einschalten.

en: Enable inlining of PLT in function calls.
de: Inlining von PLT in Funktionsaufrufen einschalten.

en: Enable inlining of function declared "inline", disabling disables all inlining.
de: Einschalten des Inlining von »inline«-Funktionen, ansonsten wird jegliches Inlining ausgeschaltet.

en: Enable instructions that guard against return-oriented programming attacks.
de: Befehle einschalten, die Angriffe über return-orientierte Programmierung vereiteln.

en: Enable interrupt stack instructions.
de: Interrupt-Stapelbefehle einschalten.

en: Enable kind-specific variants of integer intrinsic functions.
de: Artspezifische Varianten der intrinsischen Ganzzahlfunktionen einschalten.

en: Enable label alignment optimizations.
de: Sprungmarkenausrichtungs-Optimierungen einschalten.

en: Enable lazy module importing.
de: Faules Modul-Importieren einschalten.

en: Enable legacy math intrinsics for compatibility.
de: Intrinsische Altlasten-Mathematik-Funktionen für Kompatibilität einschaltet.

en: Enable legacy parsing of INCLUDE as statement.
de: Veraltetes Parsen von INCLUDE als Anweisung einschalten.

en: Enable link-time optimization.
de: Optimierungen zur Bindezeit einschalten.

en: Enable linker optimizations.
de: Binder-Optimierungen einschalten.

en: Enable linker relaxation.
de: Binderlockerung einschalten.

en: Enable linker relaxations.
de: Binderlockerungen einschalten.

en: Enable linker relaxing.
de: Binderlockerung einschalten.

en: Enable load/store bonding.
de: Zusammenfassen von benachbarten Lade-/Speicherbefehlen einschalten.

en: Enable loop distribution for patterns transformed into a library call.
de: Schleifenverteilung für in Bibliotheksaufruf umgewandelte Muster einschalten.

en: Enable loop distribution on trees.
de: Schleifenverteilung auf Bäumen einschalten.

en: Enable loop epilogue vectorization using smaller vector size.
de: Vektorisierung des Schleifen-Epilogs mit kleinerer Vektorgröße einschalten.

en: Enable loop header copying on trees.
de: Kopieren des Schleifenkopfes auf Bäumen einschalten.

en: Enable loop interchange on trees.
de: Umordnen der Schleifen auf Bäumen einschalten.

en: Enable loop invariant motion on trees.
de: Bewegung der Schleifeninvariante auf Bäumen einschalten.

en: Enable loop nest transforms.  Same as -floop-nest-optimize.
de: Schleifenschachtelungs-Umwandlungen einschalten. Entspricht -floop-next-optimize.

en: Enable loop optimizations on tree level.
de: Schleifenoptimierungen auf Baumebene einschalten.

en: Enable loop vectorization of floating point inductions.
de: Schleifenvektorisierung von Gleitkommabefehlen einschalten.

en: Enable loop vectorization on trees.
de: Schleifenvektorisierung auf Bäumen einschalten.

en: Enable machine specific peephole optimizations.
de: Maschinenspezifische Guckloch-Optimierungen einschalten.

en: Enable more verbose RTX cost dumps during debug.  For GCC developers use only.
de: Ausführlichere RTX-Kosten während des Debuggens ausgeben.  Nur für GCC-Entwickler gedacht.

en: Enable most warning messages.
de: Die meisten Warnungen einschalten.

en: Enable multicore support.
de: Multicore-Unterstützung einschalten.

en: Enable multiply instructions.
de: Multiplikationsbefehle einschalten.

en: Enable multiprocessor instructions.
de: Multiprozessorbefehle einschalten.

en: Enable nested conditional execution optimizations.
de: Optimierungen für geschachtelte bedingte Ausführung einschalten.

en: Enable optimizing &&/|| in conditional execution.
de: Optimierung von &&/|| in bedingter Ausführung einschalten.

en: Enable parsing GIMPLE.
de: GIMPLE-Parsen einschalten.

en: Enable pre-reload use of cbranchsi pattern.
de: Vorausschauende Verwendung von »cbranchsi«-Mustern einschalten.

en: Enable preprocessing.
de: Vorverarbeitung einschalten.

en: Enable range checking during compilation.
de: Bereichsprüfung während Kompilierung einschalten.

en: Enable reassociation on tree level.
de: Neuverbindung auf Baumebene einschalten.

en: Enable register pressure sensitive insn scheduling.
de: Registerdruckempfindliche Befehlsplanung einschalten.

en: Enable relaxing in the assembler.
de: Lockerung im Assembler einschalten.

en: Enable rvalue arguments to ref parameters.
de: rvalue-Argumente für ref-Parameter aktivieren.

en: Enable scheduling across basic blocks.
de: Planung über Basisblöcke hinaus einschalten.

en: Enable separate data segment.
de: Gesondertes Datensegment einschalten.

en: Enable setting GPRs to the result of comparisons.
de: Setzen von GPRs auf das Ergebnis von Vergleichen einschalten.

en: Enable shadow stack built-in functions from Control-flow Enforcement Technology (CET).
de: Stapelspeicher-Sicherungskopie im Rahmen der Control-Flow Enforcement Technology (CET) einschalten.

en: Enable sign extend instructions.
de: Vorzeichenerweiternde Befehle einschalten.

en: Enable split of 32 bit immediate loads into low / high part.
de: Aufteilung von 32-Bit-Immediates in oberen/unteren Teil einschalten.

en: Enable stack probing.
de: Stapelsondierung einschalten.

en: Enable static analysis pass.
de: Durchgang für statische Analyse einschalten.

en: Enable strict 32-bit psABI struct return checking.
de: Strenge Prüfung für 32-bit psABI Strukturrückgabe einschalten.

en: Enable string length optimizations on trees.
de: Zeichenkettenlängen-Optimierungen auf Bäumen einschalten.

en: Enable support for C++ concepts.
de: Unterstützung für C++-Konzepte einschalten.

en: Enable support for DEC STRUCTURE/RECORD.
de: Unterstützung für DEC STRUCTURE/RECORD einschalten.

en: Enable support for GNU transactional memory.
de: Unterstützung für GNU-Transaktionsspeicher einschalten.

en: Enable support for the RH850 ABI.  This is the default.
de: Unterstützung für RH850-ABI einschalten. Dies ist der Standard.

en: Enable support for the old GCC ABI.
de: Unterstützung für altes GCC-ABI einschalten.

en: Enable swap byte ordering extension instruction.
de: Erweiterung für Bytevertauschbefehle einschalten.

en: Enable tail merging on trees.
de: Enden-Zusammenfassung auf Bäumen einschalten.

en: Enable the char8_t fundamental type and use it as the type for UTF-8 string and character literals.
de: Den fundamentalen Typ char8_t einschalten und ihn als Typ für UTF-8-Zeichenketten und Zeichenliterale verwenden.

en: Enable the critical path heuristic in the scheduler.
de: Critical-Path-Heuristik im Planer einschalten.

en: Enable the dependent count heuristic in the scheduler.
de: Heuristik für Abhängigkeits-Zähler bei Planung einschalten.

en: Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision.
de: Annäherung der Division einschalten. Dies reduziert die Genauigkeit der Division auf etwa 16 Bits für einfache Genauigkeit und 32 Bits für doppelte Genauigkeit.

en: Enable the extended LRW instruction (default for CK801).
de: Erweiterte LRW-Befehle einschalten (Standard für CK801).

en: Enable the group heuristic in the scheduler.
de: Gruppenheuristik im Planer einschalten.

en: Enable the last instruction heuristic in the scheduler.
de: Heuristik für letzte Befehle im Planer einschalten.

en: Enable the loop nest optimizer.
de: Optimierer für geschachtelte Schleifen einschalten.

en: Enable the normal mode.
de: Normalen Modus einschalten.

en: Enable the rank heuristic in the scheduler.
de: Rang-Heuristik im Planer einschalten.

en: Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision.
de: Annäherung der reziproken Quadratwurzel einschalten. Dies reduziert die Genauigkeit der reziproken Quadratwurzelergebnisse auf etwa 16 Bits für einfache Genauigkeit und 32 Bits für doppelte Genauigkeit.

en: Enable the speculative instruction heuristic in the scheduler.
de: Heuristik für spekulative Befehle im Planer einschalten.

en: Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt.
de: Annäherung der Quadratwurzel einschalten. Dies reduziert die Genauigkeit der Quadratwurzelergebnisse auf etwa 16 Bits für einfache Genauigkeit und 32 Bits für doppelte Genauigkeit. Wenn eingeschaltet, bringt es »-mlow-precition-recip-sqrt« mit sich.

en: Enable the use of 64-bit floating point registers in fmov instructions.  See -mdalign if 64-bit alignment is required.
de: Verwendung von 64-Bit Gleitkommaregistern in FMOV-Befehlen einschalten. Siehe auch -mdalign, wenn 64-Bit-Ausrichtung benötigt wird.

en: Enable the use of RX FPU instructions.  This is the default.
de: Verwendung des RX-FPU-Befehls einschalten. Dies ist Standard.

en: Enable the use of blank format items in format strings.
de: Verwendung von leeren Formatelementen in Formatzeichenketten einschalten.

en: Enable the use of character literals in assignments and data statements for non-character variables.
de: Zeichenliterale in Zuweisungen und Datenanweisungen für Nichtzeichenvariablen aktivieren.

en: Enable the use of indexed loads.
de: Verwendung von indexierten Ladebefehlen einschalten.

en: Enable the use of pre/post modify with register displacement.
de: Verwendung von Pre-/Post-Modifikationen mit Registerversatz einschalten.

en: Enable the use of the LRA register allocator.
de: Verwendung des LRA-Registerallozierers einschalten.

en: Enable the use of the fsca instruction.
de: Verwendung des fsca-Befehls einschalten.

en: Enable the use of the fsrra instruction.
de: Verwendung des fsrra-Befehls einschalten.

en: Enable the use of the old, broken, ABI where all stacked function arguments are aligned to 32-bits.
de: Verwendung des alten, defekten ABI, bei dem alle Funktionsargumente auf dem Stapel auf 32 Bits ausgerichtet sind.

en: Enable the use of the short load instructions.
de: Verwendung der kurzen Ladebefehle einschalten.

en: Enable the use the standard RX ABI where all stacked function arguments are naturally aligned.  This is the default.
de: Verwendung des Standard-RX-ABI, wobei alle Funktionsargumente auf dem Stapel natürlich ausgerichtet sind. (Voreinstellung.)

en: Enable the z vector language extension providing the context-sensitive vector macro and enable the Altivec-style builtins in vecintrin.h.
de: Die z-Vektor-Spracherweiterung einschalten, die das kontextabhängige Vektormakro einschaltet und eingebaute Funktionen im Altivec-Stil aus vecintrin.h einschaltet.

en: Enable traditional preprocessing.
de: Traditionelle Vorverarbeitung einschalten.

en: Enable transitivity of constraints during analysis.
de: Transitivität von Beschränkungen während der Analyse berücksichtigen.

en: Enable unaligned word and halfword accesses to packed data.
de: Nicht ausgerichtete Wort- und Halbwortzugriffe auf gepackte Daten einschalten.

en: Enable use of BI/BIH instructions when available.
de: Verwendung der BI/BIH-Befehle einschalten, wenn verfügbar.

en: Enable use of GPREL for read-only data in FDPIC.
de: Verwendung von GPREL für Nur-Lese-Daten in FDPIC einschalten.

en: Enable use of NPS400 bit operations.
de: Verwendung der NPS400-Bitbefehle einschalten.

en: Enable use of NPS400 xld/xst extension.
de: Erweiterung für xld/xst für NPS400 einschalten.

en: Enable use of POST_INC / POST_DEC.
de: Verwendung von POST_INC / POST_DEC einschalten.

en: Enable use of POST_MODIFY.
de: Verwendung von POST_MODIFY einschalten.

en: Enable use of R16-R31 (default).
de: Verwendung von R16 bis R31 einschalten (Standard).

en: Enable use of odd-numbered single-precision registers.
de: Verwendung der ungeraden Register für Gleitkomma einfacher Genauigkeit erlauben.

en: Enable use of sdata/scommon/sbss.
de: Verwendung von sdata/scommon/sbss einschalten.

en: Enable user-defined instructions.
de: Benutzerdefinierte Befehle einschalten.

en: Enable using IEEE 128-bit floating point instructions.
de: IEEE-128-Bit-Gleitkomma-Befehle einschalten.

en: Enable v850e3v5 loop instructions.
de: Schleifenbefehle für v850e3v5 einschalten.

en: Enable variable polynomial CRC extension.
de: Variable polynomiale CRC-Erweiterung einschalten.

en: Enable vectorization on trees.
de: Vektorisierung auf Bäumen einschalten.

en: Enable verbose output.
de: Wortreiche Ausgabe einschalten.

en: Enable workaround for single erratum of AT697F processor (corresponding to erratum #13 of AT697E processor).
de: Workaround für einzelnes Erratum des AT697F-Prozessors einschalten (entspricht Erratum #13 des Prozessors AT697E).

en: Enable workarounds for the errata of the GR712RC processor.
de: Workarounds für Errata des GR712RC-Prozessors einschalten.

en: Enable workarounds for the errata of the UT699 processor.
de: Workaround für Errata des UT699-Prozessors einschalten.

en: Enable workarounds for the errata of the UT699E/UT700 processor.
de: Workarounds für Errata des UT699E/UT700-Prozessors einschalten.

en: Enable/Disable the traditional scheduling in loops that already passed modulo scheduling.
de: Traditionelle Planung in Schleifen, die bereits Modulo-Planung unterzogen wurden, einschalten/ausschalten.

en: Enable/disable GP-relative addressing.
de: Adressierung relativ zu GP ein-/ausschalten.

en: Enabled ID based shared library.
de: ID-basierte Shared Library einschalten.

en: Enables Position-Independent-Data (PID) mode.
de: Betriebsart für positionsunabhängige Daten (PID) einschalten.

en: Enables or disables the use of the SMOVF, SMOVB, SMOVU, SUNTIL, SWHILE and RMPA instructions.  Enabled by default.
de: Ein-/ausschalten der Verwendung der Befehle SMOVF, SMOVB, SMOVU, SUNTIL, SWHILE und RMPA. Vorgabe: eingeschaltet.

en: Enables the dynamic vectorizer cost model.  Preserved for backward compatibility.
de: Schaltet das dynamische Vektorisierer-Kostenmodell ein. Für Rückwärtskompatibilität erhalten.

en: Enables verbose cost model dumping in the debug dump files.
de: Ausführliche Ausgabe des Kostenmodells in den Debug-Dumpdateien einschalten.

en: Encode SSE instructions with VEX prefix.
de: SSE-Befehle mit VEX-Präfix kodieren.

en: End expression in DO loop
de: End-Ausdruck in DO-Schleife

en: End of nonblock DO statement at %C is interwoven with another DO loop
de: Ende der DO-Anweisung bei %C ist mit anderer DO-Schleife verwoben

en: End of nonblock DO statement at %C is within another block
de: Ende der DO-Anweisung ohne Block bei %C ist innerhalb eines anderen Blockes

en: End of scalar initializer expected at %C
de: Ende der skalaren Initialisierung bei %C erwartet

en: End of search list.
de: Ende der Suchliste.

en: Enforce class member access control semantics.
de: Semantik der Zugriffskontrolle für Klassenelemente erzwingen.

en: Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute
de: Entität %qs bei %L hat Parameter mit aufgeschobenem Typ und benötigt entweder das POINTER- oder ALLOCATABLE-Attribut

en: Entity %qs at %L is already present in the interface
de: Entität %qs bei %L ist bereits in der Schnittstelle vorhanden

en: Entity with assumed character length at %L must be a dummy argument or a PARAMETER
de: Entität mit vermuteter Zeichenlänge bei %L muss ein Scheinargument oder ein PARAMETER sein

en: Enumerator exceeds the C integer type at %C
de: Zähler übersteigt den C-Ganzzahltyp bei %C

en: Equality comparison for %s at %L
de: Vergleich auf Gleichheit für %s bei %L

en: Equivalence for %qs does not match ordering of COMMON %qs at %L
de: Äquivalenz für %qs passt nicht zur Anordnung von COMMON %qs bei %L

en: Equivalent to -mgpopt=local.
de: Äquivalent zu »-mgpopt=local«.

en: Equivalent to -mgpopt=none.
de: Äquivalent zu »-mgpopt=none«.

en: Errmsg-variable at %L shall not be %sd within the same %s statement
de: ERRMSG-Variable bei %L darf nicht »%s« innerhalb der selben »%s«-Anweisung sein

en: Error
de: Fehler

en: Error allocating %lu bytes
de: Fehler beim Reservieren von %lu Bytes

en: Error converting PARAMETER constant in complex constant at %C
de: Fehler bei Umwandlung von PARAMETER-Konstante in komplexer Konstante bei %C

en: Error converting integer
de: Fehler beim Umwandeln einer Ganzzahl

en: Error in array constructor referenced at %L
de: Fehler in Feldkonstruktor, auf den bei %L verwiesen wird

en: Error in pointer initialization at %C
de: Fehler in Zeigerinitialisierung bei %C

en: Error in type-spec at %L
de: Fehler in Typspezifikation bei %L

en: Error in typebound call at %L
de: Fehler in Typbeschränktem Aufruf bei %L

en: Error reallocating to %lu bytes
de: Fehler beim Vergrößern des Speicherblocks auf %lu Bytes

en: Error writing JSON output file %s
de: Fehler beim Schreiben der JSON-Ausgabedatei »%s«

en: Error writing module file %qs for writing: %s
de: Fehler beim Schreiben der Moduldatei %qs: %s

en: Error writing modules file: %s
de: Fehler beim Schreiben der Moduldatei: %s

en: Error writing output file '%s'
de: Fehler beim Schreiben der Ausgabedatei »%s«

en: Evaluation of nonstandard initialization expression at %L
de: Auswertung des nicht standardisierten Initialisierungsausdrucks bei %L

en: Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs
de: Zeichenkette mit mehr als 2 hoch 28 Zeichen bei %L wird erst bei Ausführung des Programms ausgewertet werden, rechnen Sie mit Fehlern

en: Event
de: Ereignis

en: Event variable argument at %L must be a coarray but not coindexed
de: Argument für Ereignisvariable bei %L muss ein Koarray, aber nicht koindiziert sein

en: Event variable argument at %L must be a coarray or coindexed
de: Argument für Ereignisvariable bei %L muss ein Koarray oder koindiziert sein

en: Event variable at %L must be a scalar of type EVENT_TYPE
de: Ereignis-Variable bei %L muss Skalar mit EVENT_TYPE sein

en: Every subscript of target specification at %L must be a constant expression
de: Jeder Feldindex der Zielspezifikation bei %L muss ein konstanter Ausdruck sein

en: Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression
de: Abbruchbedingung der DO WHILE-Schleife bei %L muss ein skalarer LOGICAL-Ausdruck sein

en: Exit on the first error occurred.
de: Beim ersten auftretenden Fehler beenden.

en: Expand 32bit/64bit integer divide into 8bit unsigned integer divide with run-time check.
de: 32-/64-Bit-Ganzzahldivision in vorzeichenlose 8-Bit-Ganzzahldivision mit Laufzeitprüfung erweitern.

en: Expand adddi3 and subdi3 at rtl generation time into add.f / adc etc.
de: Im Zuge der RTL-Erzeugung die Befehle adddi3 und subdi3 in add.f/adc usw. expandieren.

en: Expected ")" at %C
de: »)« bei %C erwartet

en: Expected "," at %C
de: »,« bei %C erwartet

en: Expected %<( depobj )%> at %C
de: %<( depobj )%> bei %C erwartet

en: Expected %<(%> after %qs at %C
de: %<(%> nach %qs bei %C erwartet

en: Expected %<(%> at %C
de: %<(%> bei %C erwartet

en: Expected %<)%> or %<,%> at %C
de: %<)%> oder %<,%> bei %C erwartet

en: Expected %<,%> at %C
de: %<,%> bei %C erwartet

en: Expected %<,%> or end of statement at %C
de: %<,%> oder Ende der Anweisung bei %C erwartet

en: Expected %<:%> at %C
de: %<:%> bei %C erwartet

en: Expected %<::%> after binding-attributes at %C
de: %<::%> nach Bindeattributen bei %C erwartet

en: Expected %<::%> at %C
de: %<::%> bei %C erwartet

en: Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L
de: Atomarer Vergleichsausdruck %<==%>, %<.EQ.%> oder %<.EQV.%> bei %L erwartet

en: Expected %<=>%> at %C
de: %<=>%> bei %C erwartet

en: Expected %<END INTERFACE ASSIGNMENT (=)%> at %C
de: %<END INTERFACE ASSIGNMENT (=)%> bei %C erwartet

en: Expected '*' in coindex specification in ALLOCATE statement at %L
de: In Koindex-Spezifikation in ALLOCATE-Anweisung bei %L wird »*« erwartet

en: Expected :: in TYPE definition at %C
de: »::« in TYPE-Definition bei %C erwartet

en: Expected = sign in PARAMETER statement at %C
de: Zeichen »=« in PARAMETER-Anweisung bei %C erwartet

en: Expected ALLOC, TO, FROM, TOFROM, FIRSTPRIVATE, NONE or DEFAULT at %C
de: Eins von ALLOC, TO, FROM, TOFROM, FIRSTPRIVATE, NONE oder DEFAULT bei %C erwartet

en: Expected COMPILATION or EXECUTION in AT clause at %C
de: Entweder COMPILATION oder EXECUTION erwartet in AT-Klausel bei %C

en: Expected DEPEND, UPDATE, or DESTROY clause at %C
de: Eine der Klauseln DEPEND, UPDATE oder DESTROY bei %C erwartet

en: Expected DO loop at %C
de: DO-Schleife bei %C erwartet

en: Expected ELSE at %L in atomic compare capture
de: ELSE bei %L erwartet, in atomarer Vergleichserfassung

en: Expected FATAL or WARNING in SEVERITY clause at %C
de: Die SEVERITY-Klausel bei %C erwartet entweder FATAL oder WARNING

en: Expected HOST, NOHOST or ANY at %C
de: HOST, NOHOST oder ANY bei %C erwartet

en: Expected IF at %L in atomic compare capture
de: IF bei %L erwartet, in atomarer Vergleichserfassung

en: Expected IN, OUT, INOUT, MUTEXINOUTSET followed by %<)%> at %C
de: Eins von IN, OUT, INOUT, MUTEXINOUTSET bei %C erwartet, gefolgt von %<)%>

en: Expected INCLUSIVE or EXCLUSIVE clause at %C
de: Eine der Klauseln INCLUSIVE oder EXCLUSIVE bei %C erwartet

en: Expected INTEGER type at %L
de: INTEGER-Typ bei %L erwartet

en: Expected NONE or PRESENT in DEFAULT clause at %C
de: Eine der Klauseln NONE oder PRESENT bei %C erwartet

en: Expected NONE, FIRSTPRIVATE, PRIVATE or SHARED in DEFAULT clause at %C
de: Eins von NONE, FIRSTPRIVATE, PRIVATE oder SHARED erwartet, in DEFAULT-Klausel bei %C

en: Expected ORDER(CONCURRENT) at %C with optional %<reproducible%> or %<unconstrained%> modifier
de: ORDER(CONCURRENT) erwartet bei %C, optional mit Modifizierer %<reproducible%> oder %<unconstrained%>

en: Expected P edit descriptor in format string at %L
de: P-Bearbeitungsdeskriptor erwartet in Formatzeichenkette bei %L

en: Expected PARAMETER symbol in complex constant at %C
de: PARAMETER-Symbol in komplexer Konstante bei %C erwartet

en: Expected RANK or RANK DEFAULT following SELECT RANK at %C
de: RANK oder RANK DEFAULT gefolgt von SELECT RANK erwartet bei %C

en: Expected SCALAR, AGGREGATE, ALLOCATABLE or POINTER at %C
de: Eins von SCALAR, AGGREGATE, ALLOCATABLE oder POINTER bei %C erwartet

en: Expected SEQ_CST, ACQUIRE or RELAXED at %C
de: Eins von SEQ_CST, ACQUIRE oder RELAXED erwartet, bei %C

en: Expected SEQ_CST, ACQ_REL or RELAXED for ATOMIC_DEFAULT_MEM_ORDER clause at %C
de: Eins von SEQ_CST, ACQ_REL oder RELAXED erwartet, für ATOMIC_DEFAULT_MEM_ORDER-Klausel bei %C

en: Expected SEQ_CST, AQC_REL, RELEASE, or ACQUIRE at %C
de: Eins von SEQ_CST, AQC_REL, RELEASE oder ACQUIRE bei %C erwartet

en: Expected SHAPE argument to C_F_POINTER with array FPTR at %L
de: SHAPE-Argument für C_F_POINTER mit Array-FPTR bei %L erwartet

en: Expected TEAMS, PARALLEL or THREAD as binding in BIND at %C
de: Eins von TEAMS, PARALLEL oder THREAD erwartet als Bindung in BIND bei %C

en: Expected TYPE IS, CLASS IS or END SELECT statement following SELECT TYPE at %C
de: TYPE IS-, CLASS IS- oder END SELECT-Anweisung hinter SELECT TYPE bei %C erwartet

en: Expected UNIFIED_ADDRESS, UNIFIED_SHARED_MEMORY, DYNAMIC_ALLOCATORS, REVERSE_OFFLOAD, or ATOMIC_DEFAULT_MEM_ORDER clause at %L
de: Eine der Klauseln UNIFIED_ADDRESS, UNIFIED_SHARED_MEMORY, DYNAMIC_ALLOCATORS, REVERSE_OFFLOAD oder ATOMIC_DEFAULT_MEM_ORDER bei %L erwartet

en: Expected a CASE or END SELECT statement following SELECT CASE at %C
de: CASE- oder END-SELECT-Anweisung hinter SELECT CASE bei %C erwartet

en: Expected a nameless interface at %C
de: Namenlose Schnittstelle bei %C erwartet

en: Expected a procedure for argument %qs at %L
de: Prozedur für Argument %qs bei %L erwartet

en: Expected a procedure pointer for argument %qs at %L
de: Prozedurzeiger für Argument %qs bei %L erwartet

en: Expected a right parenthesis in expression at %C
de: Rechte Klammer in Ausdruck bei %C erwartet

en: Expected a step value in iterator at %C
de: Schrittvariable in Iterator bei %C erwartet

en: Expected access-specifier at %C
de: Zugriffsspezifikation bei %C erwartet

en: Expected alternate return label at %C
de: Alternative Rücksprungmarke bei %C erwartet

en: Expected an initialization expression at %C
de: Initialisierungsausdruck bei %C erwartet

en: Expected another dimension in array declaration at %C
de: Andere Dimension in Felddeklaration bei %C erwartet

en: Expected argument list at %C
de: Argumentliste bei %C erwartet

en: Expected array subscript at %C
de: Arrayindex erwartet bei %C

en: Expected array subscript stride at %C
de: Feldindexsprung erwartet bei %C

en: Expected association at %C
de: Verknüpfung bei %C erwartet

en: Expected association list at %C
de: Verknüpfungsliste bei %C erwartet

en: Expected attribute bit name
de: Attributbitname erwartet

en: Expected binding attribute at %C
de: Bindeattribut bei %C erwartet

en: Expected binding name at %C
de: Bindungsname bei %C erwartet

en: Expected binding target after %<=>%> at %C
de: Bindungsziel hinter %<=>%> bei %C erforderlich

en: Expected block name %qs of SELECT construct at %C
de: Blockname %qs des SELECT-Konstrukts bei %C erwartet

en: Expected block name of %qs in %s statement at %L
de: Blocknamen von %qs in »%s«-Anweisung bei %L erwartet

en: Expected bounds specification for %qs at %L
de: Grenzen für %qs bei %L erwartet

en: Expected coarray variable as %qs argument to the %s intrinsic at %L
de: Coarray-Variable als Argument %qs für intrinsisches %s bei %L erwartet

en: Expected comma in I/O list at %C
de: Komma in E/A-Liste bei %C erwartet

en: Expected component reference at %C
de: Referenz auf Komponente bei %C erwartet

en: Expected construct-type PARALLEL, SECTIONS, DO or TASKGROUP in $OMP CANCELLATION POINT statement at %C
de: Konstrukttyp PARALLEL, SECTIONS, DO oder TASKGROUP in Anweisung $OMP CANCELLATION POINT bei %C erwartet

en: Expected data constant after repeat spec at %C
de: Datenkonstante nach Wiederholungsangabe bei %C erwartet

en: Expected entity-list in AUTOMATIC statement at %C
de: In AUTOMATIC-Anweisung bei %C wird eine »entity-list« erwartet

en: Expected entity-list in STATIC statement at %C
de: »entity-list« in STATIC-Anweisung bei %C erwartet

en: Expected exponent in expression at %C
de: Exponent in Ausdruck bei %C erwartet

en: Expected expression at %C in PARAMETER statement
de: Ausdruck bei %C in PARAMETER-Anweisung erwartet

en: Expected expression in %s statement at %C
de: Ausdruck in %s-Anweisung bei %C erwartet

en: Expected expression in array specification at %C
de: Erwarteter Ausdruck in Feldspezifikation bei %C

en: Expected expression type
de: Ausdruckstyp erwartet

en: Expected formal argument list in function definition at %C
de: Formale Argumentliste in Funktionsdefinition bei %C erwartet

en: Expected generic name or operator descriptor at %C
de: Generischer Name oder Operatordeskriptor bei %C erwartet

en: Expected identifier at %C
de: Bezeichner bei %C erwartet

en: Expected initialization expression at %C
de: Initialisierungsausdruck bei %C erwartet

en: Expected initialization expression in CASE at %C
de: Erwarteter Initialisierungsausdruck in CASE bei %C

en: Expected integer
de: Ganzzahl erwartet

en: Expected integer expression at %C
de: Ganzzahlausdruck bei %C erwartet

en: Expected integer expression of the 'omp_allocator_handle_kind' kind at %L
de: Ganzzzahlausdruck der Art OMP_ALLOCATOR_HANDLE_KIND bei %L erwartet

en: Expected integer expression or a single device-modifier %<device_num%> or %<ancestor%> at %C
de: Entweder ein Ganzzahlausdruck oder genau ein Gerätemodifizierer %<device_num%> oder %<ancestor%> erwartet bei %C

en: Expected integer string
de: Ganzzahlzeichenkette erwartet

en: Expected intrinsic assignment in OMP WORKSHARE at %L
de: Erwarteter intrinsischer Initialisierungsausdruck OMP WORKSHARE bei %L

en: Expected label %qs for %s statement at %C
de: Marke %qs für »%s«-Anweisung bei %C erwartet

en: Expected left parenthesis
de: Linke Klammer erwartet

en: Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L
de: Liste von %<untere-Grenze :%> oder Liste von %<untere-Grenze : obere-Grenze%>-Angaben bei %L erwartet

en: Expected module procedure name at %C
de: Prozedurname im Modul bei %C erwartet

en: Expected name
de: Name erwartet

en: Expected parameter list in type declaration at %C
de: Parameterliste in Typdeklaration bei %C erwartet

en: Expected range-specification at %C
de: Bereichsangabe erwartet bei %C

en: Expected real string
de: Echte Zeichenkette erwartet

en: Expected register or constant integer.
de: Register oder konstante Ganzzahl erwartet.

en: Expected right parenthesis
de: Rechte Klammer erwartet

en: Expected scalar initialization expression at %C
de: Skalaren Initialisierungsausdruck bei %C erwartet

en: Expected scalar intrinsic expression at %L in atomic comparison
de: Skalarer intrinsischer Ausdruck bei %L erwartet, in atomarem Vergleich

en: Expected scalar intrinsic variable at %L in atomic comparison
de: Skalare intrinsische Variable bei %L erwartet, in atomarem Vergleich

en: Expected specific binding name at %C
de: Spezifischer Bindungsname bei %C erwartet

en: Expected string
de: Zeichenkette erwartet

en: Expected structure component name at %C
de: Strukturkomponentenname bei %C erwartet

en: Expected structure component or operator name after '.' at %C
de: Name einer Strukturkomponente oder eines Operators nach ».« bei %C erwartet

en: Expected terminating name at %C
de: Beendenden Namen bei %C erwartet

en: Expected type-bound procedure or procedure pointer component at %C
de: Typgebundene Prozedur oder Prozedurzeiger-Komponente bei %C erwartet

en: Expected variable list at %C
de: Variablenliste bei %C erwartet

en: Expected variable name at %C
de: Variablennamen bei %C erwartet

en: Expected variable name at %C in PARAMETER statement
de: Variablennamen bei %C in PARAMETER-Anweisung erwartet

en: Expecting %<END INTERFACE %s%> at %C
de: %<END INTERFACE %s%> bei %C erwartet

en: Expecting %<END INTERFACE OPERATOR (%s)%> at %C
de: %<END INTERFACE OPERATOR (%s)%> bei %C erwartet

en: Expecting %<END INTERFACE OPERATOR (%s)%> at %C, but got %qs
de: %<END INTERFACE OPERATOR (%s)%> bei %C erwartet, aber %qs erhalten

en: Expecting %<END INTERFACE OPERATOR (.%s.)%> at %C
de: %<END INTERFACE OPERATOR (.%s.)%> bei %C erwartet

en: Expecting %s at %C
de: %s bei %C erwartet

en: Expecting %s statement at %L
de: »%s«-Anweisung bei %L erwartet

en: Expecting a comma in EQUIVALENCE at %C
de: Komma in EQUIVALENCE bei %C erwartet

en: Expecting a scalar INTEGER expression at %C, found %s
de: Skalaren INTEGER-Ausdruck bei %C erwartet, aber %s gefunden

en: Expecting a variable at %L
de: Variable bei %L erwartet

en: Expecting definable entity near %L
de: Definierbare Entität bei %L erwartet

en: Expecting list of named entities at %C
de: Liste benannter Einträge bei %C erwartet

en: Expecting variable in READ statement at %C
de: Variable in READ-Anweisung bei %C erwartet

en: Expecting variable or io-implied-do at %L
de: Variable oder io-implied-do bei %L erwartet

en: Expecting variable or io-implied-do in READ statement at %L
de: Variable oder io-implied-do in READ-Anweisung bei %L erwartet

en: Explain what alignment considerations lead to the decision to make an insn short or long.
de: Erläutern, welche Ausrichtungsüberlegungen zu der Entscheidung führen, einen Befehl lang oder kurz zu machen.

en: Explicit array shape at %C must be constant of INTEGER type and not %s type
de: Explizite Arrayform bei %C muss eine Konstante vom Typ INTEGER sein, nicht %s

en: Explicit interface required for %qs at %L: %s
de: Explizite Schnittstelle für %qs bei %L erforderlich: %s

en: Explicit interface required for component %qs at %L: %s
de: Explizite Schnittstelle für Komponente %qs bei %L erforderlich: %s

en: Explicit interface required for polymorphic argument at %L
de: Explizite Schnittstelle für polymorphes Argument bei %L erforderlich

en: Explicit shaped array with nonconstant bounds at %C
de: Feld mit expliziter Form, aber nichtkonstanten Grenzen bei %C

en: Export functions even if they can be inlined.
de: Funktionen exportieren, auch wenn sie »inline« sein können.

en: Expression at %L in this context must be constant
de: Ausdruck bei %L muss in diesem Kontext eine Konstante sein

en: Expression at %L must be of INTEGER type, found %s
de: Ausdruck bei %L muss INTEGER-Typ haben, %s gefunden

en: Expression at %L must be scalar
de: Ausdruck bei %L muss skalar sein

en: Expression in CASE selector at %L cannot be %s
de: Ausdruck in CASE-Anweisung bei %L darf nicht %s sein

en: Expression in CASE selector at %L must be scalar
de: Ausdruck in CASE-Selektor bei %L muss skalar sein

en: Expression in CASE statement at %L is not in the range of %s
de: Ausdruck in CASE-Anweisung bei %L ist nicht im Bereich von %s

en: Expression in CASE statement at %L must be of kind %d
de: Ausdruck in CASE-Anweisung bei %L muss von der Art %d sein

en: Expression in CASE statement at %L must be of type %s
de: Ausdruck in CASE-Anweisung bei %L muss Typ %s haben

en: Expression in CASE statement at %L must be scalar
de: Ausdruck in CASE-Anweisung bei %L muss skalar sein

en: Extension: %s specifier in %s statement at %L has value %qs
de: Erweiterung: Spezifizierer %s in Anweisung %s bei %L hat Wert %qs

en: Extension: Conversion from %s to %s at %L
de: Erweiterung: Umwandlung von %s in %s bei %L

en: Extension: Scalar non-default-kind, non-C_CHAR-kind CHARACTER actual argument with array dummy argument %qs at %L
de: Erweiterung: Skalares effektives nicht-standardartiges, nicht-C_CHAR CHARACTER-Argument mit Feld-Scheinargument %qs bei %L

en: Extension: Unary operator following arithmetic operator (use parentheses) at %C
de: Erweiterung: Unärer Operator hinter arithmetischem Operator bei %C (Klammern verwenden)

en: Extension: Zero width after L descriptor at %L
de: Erweiterung: Nullbreite hinter L-Deskriptor bei %L

en: Extension: backslash character at %C
de: Erweiterung: Zeichen Backslash bei %C

en: Extension: exponent-letter %<q%> in real-literal-constant at %C
de: Erweiterung: Exponentbuchstabe %<q%> in literaler Realkonstante bei %C

en: External %qs at %L cannot have an initializer
de: Externes %qs bei %L kann keine Initialisierung haben

en: External IO UNIT cannot be an array at %L
de: Externe IO UNIT kann kein Feld bei %L sein

en: External object %qs at %L may not have an initializer
de: Externes Objekt %qs bei %L darf keinen Initialisierer haben

en: Extra option to %<-Xassembler%>: %s, dropping all %<-Xassembler%> and %<-Wa%> options.
de: Überflüssige Option für %<-Xassembler%>; %s, alle Optionen der Form %<-Xassembler%> und %<-Wa%> werden verworfen.

en: Extraneous characters in format at %L
de: Überschüssige Zeichen im Format bei %L

en: F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body
de: F2008: C1210 IMPORT-Anweisung bei %C ist im Körper einer Schnittstelle für Modulprozedur nicht erlaubt

en: FAIL IMAGE statement at %C
de: »FAIL IMAGE«-Anweisung bei %C

en: FAILED= argument to NUM_IMAGES at %L
de: Argument FAILED= für NUM_IMAGES bei %L

en: FDPIC mode is not supported in Thumb-1 mode
de: Der FDPIC-Modus wird im Thumb-1-Modus nicht unterstützt

en: FINAL clause at %L requires a scalar LOGICAL expression
de: FINAL-Klausel bei %L erfordert einen skalaren LOGICAL-Ausdruck

en: FINAL declaration at %C must be inside CONTAINS
de: FINAL-Deklaration bei %C muss innerhalb von CONTAINS sein

en: FINAL declaration at %C must be inside a derived type CONTAINS section
de: FINAL-Deklaration bei %C muss innerhalb eines CONTAINS-Abschnitts eines abgeleiteten Typs stehen

en: FINAL procedure %qs at %L is not a SUBROUTINE
de: FINAL-Prozedur %qs bei %L ist keine SUBROUTINE

en: FINAL procedure %qs declared at %L has the same rank (%d) as %qs
de: Bei %2$L deklarierte FINAL-Prozedur %1$qs hat denselben Rang (%3$d) wie %4$qs

en: FINAL procedure at %L must have exactly one argument
de: FINAL-Prozedur bei %L muss genau ein Argument haben

en: FINAL procedure declaration at %C
de: FINAL-Prozedurdeklaration bei %C

en: FLUSH statement at %C
de: FLUSH-Anweisung bei %C

en: FORALL construct at %L
de: FORALL-Konstrukt bei %L

en: FORALL end expression at %L must be a scalar INTEGER
de: FORALL-Endausdruck bei %L muss skalarer INTEGER sein

en: FORALL index %qs may not appear in triplet specification at %L
de: FORALL-Index %qs kann nicht in Tripel-Spezifikation bei %L auftreten

en: FORALL index-name at %L must be a scalar INTEGER
de: FORALL-Indexname bei %L muss skalarer INTEGER sein

en: FORALL index-name at %L must be a scalar variable of type integer
de: FORALL-Indexname bei %L muss skalarer INTEGER sein

en: FORALL mask clause at %L requires a scalar LOGICAL expression
de: FORALL-Maskenklausel bei %L erfordert einen skalaren LOGICAL-Ausdruck

en: FORALL start expression at %L must be a scalar INTEGER
de: FORALL-Anfangsausdruck bei %L muss skalarer INTEGER sein

en: FORALL stride expression at %L cannot be zero
de: FORALL-Schrittausdruck bei %L kann nicht Null sein

en: FORALL stride expression at %L must be a scalar %s
de: FORALL-Schrittausdruck bei %L muss skalares %s sein

en: FORM TEAM statement at %C
de: FORM-TEAM-Anweisung bei %C

en: FORMAT label %d at %L not defined
de: FORMAT-Marke %d bei %L nicht definiert

en: FORMAT statement at %C cannot appear within an INTERFACE
de: FORMAT-Anweisung bei %C kann nicht innerhalb von INTERFACE auftreten

en: FORMAT statement at %L does not have a statement label
de: FORMAT-Anweisung bei %L hat keine Anweisungsmarke

en: FORMAT tag at %L cannot be a zero-sized array
de: FORMAT-Kennzeichen bei %L kann kein Feld der Größe 0 sein

en: FORMAT tag at %L must be of type default-kind CHARACTER or of INTEGER
de: FORMAT-Markierung bei %L muss vom Typ Standard-CHARACTER oder INTEGER sein

en: FP exceptions are enabled.
de: Gleitkomma-Ausnahmen sind eingeschaltet.

en: FP registers might be clobbered despite %qE attribute: compile with %<-mgeneral-regs-only%>
de: Gleitkomma-Register könnten trotz Attribut %qE überschrieben werden: compilieren Sie mit %<-mgeneral-regs-only%>

en: FPTR argument at %L to C_F_POINTER shall not be polymorphic
de: Argument FPTR für C_F_POINTER bei %L darf nicht polymorph sein

en: FPU types of LoongArch:
de: FPU-Typen von LoongArch:

en: FPX fast and compact options cannot be specified together
de: FPX-Optionen »fast« und »compact« schließen sich aus

en: FPX: Enable Argonaut ARC CPU Double Precision Floating Point extensions.
de: FPX: Gleitkommaerweiterungen für doppelte Genauigkeit für Argonaut-ARC-CPU einschalten.

en: FPX: Generate Double Precision FPX (compact) instructions.
de: FPX: kompakte FPX-Befehle für doppelte Genauigkeit erzeugen.

en: FPX: Generate Double Precision FPX (fast) instructions.
de: FPX: schnelle FPX-Befehle für doppelte Genauigkeit erzeugen.

en: FPX: Generate Single Precision FPX (compact) instructions.
de: FPX: kompakte FPX-Befehle für einfache Genauigkeit erzeugen.

en: FPX: Generate Single Precision FPX (fast) instructions.
de: FPX: schnelle FPX-Befehle für einfache Genauigkeit erzeugen.

en: FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS
de: FROMPOS-Argument (%ld) außerhalb des Bereichs 0:%d in intrinsischem MVBITS

en: FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS
de: FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsischem MVBITS

en: FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L
de: FUNCTION-Ergebnis %s kann kein POINTER in FUNCTION %s bei %L sein

en: FUNCTION result %s cannot be an array in FUNCTION %s at %L
de: FUNCTION-Ergebnis %s kann kein Feld in FUNCTION %s bei %L sein

en: FUNCTION result %s cannot be of type %s in FUNCTION %s at %L
de: FUNCTION-Ergebnis %s kann nicht vom Typ %s in FUNCTION %s bei %L sein

en: Factor complex constructors and destructors to favor space over speed.
de: Komplexe Konstruktoren und Destruktoren ausfaktorisieren, um Speicherplatz gegenüber Geschwindigkeit zu gewinnen.

en: Failed to match clause at %C
de: Keine passende Klausel gefunden bei %C

en: Failure in conversion of BOZ to REAL at %L
de: Fehler bei Umwandlung von BOZ in REAL bei %L

en: Fatal Error
de: Schwerwiegender Fehler

en: File %qs is being included recursively
de: Die Datei %qs wird rekursiv eingebunden

en: File %qs opened at %C is not a GNU Fortran module file
de: Bei %2$C geöffnete Datei %1$qs ist keine GNU-Fortran-Moduldatei

en: Fine grain control of tune features.
de: Detaillierte Steuerung der Tuningfeatures.

en: First argument of defined assignment at %L must be INTENT(OUT) or INTENT(INOUT)
de: Erstes Argument der definierten Zuweisung bei %L muss INTENT(OUT) oder INTENT(INOUT) sein

en: First argument of operator interface at %L cannot be optional
de: Erstes Argument der Operatorschnittstelle bei %L kann nicht optional sein

en: First argument of operator interface at %L must be INTENT(IN)
de: Erstes Argument der Operatorschnittstelle bei %L muss INTENT(IN) sein

en: First or last !$OMP ATOMIC intrinsic argument must be %qs at %L
de: Erstes oder letztes intrinsisches Argument zu !$OMP ATOMIC muss bei %2$L %1$qs sein

en: Fixed line length must be at least seven
de: Feste Zeilenlänge muss mindestens sieben sein

en: Flag %<-fmax-stack-var-size=%d%> overwrites %<-frecursive%> implied by %qs
de: Schalter %<-fmax-stack-var-size=%d%> überschreibt %<-frecursive%> (ausgelöst durch %qs)

en: Flag %<-fno-automatic%> overwrites %<-fmax-stack-var-size=%d%>
de: Schalter %<-fno-automatic%> überschreibt %<-fmax-stack-var-size=%d%>

en: Flag %<-fno-automatic%> overwrites %<-frecursive%>
de: Schalter %<-fno-automatic%> überschreibt %<-frecursive%>

en: Flag %<-fno-automatic%> overwrites %<-frecursive%> implied by %qs
de: Schalter %<-fno-automatic%> überschreibt %<-frecursive%> (ausgelöst durch %qs)

en: Flag %<-frecursive%> overwrites %<-fmax-stack-var-size=%d%>
de: Schalter %<-frecursive%> überschreibt %<-fmax-stack-var-size=%d%>

en: Floating point custom instruction configuration name.
de: Name der Konfiguration für eigene Gleitkommabefehle.

en: Fold calls to simple inline functions.
de: Aufrufe von einfachen inline-Funktionen zusammenfalten.

en: Follow Renesas (formerly Hitachi) / SuperH calling conventions.
de: Renesas-(vormals Hitachi)/SuperH-Aufrufkonventionen folgen.

en: Follow the C++17 evaluation order requirements for assignment expressions, shift, member function calls, etc.
de: Die C++17-Anforderungen für die Auswertungsreihenfolge von Zuweisungsausdrücken, Bitverschiebungen, Elementfunktionsaufrufe, etc. befolgen.

en: Follow the EABI linkage requirements.
de: EABI-Bindeanforderungen befolgen.

en: For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L
de: Bei !$OMP ATOMIC COMPARE muss der erste Operand des Vergleichs bei %L die Variable %qs sein, in die die Aktualisierungsanweisung bei %L schreibt

en: For dummy procedure %s, no binding name is allowed in BIND(C) at %C
de: For Schein-Prozedur %s in BIND(C) bei %C ist kein bindender Name erlaubt

en: For intrinsics library: pass all parameters in registers.
de: Für Intrinsics-Bibliothek: alle Parameter in Registern übergeben.

en: For nested functions on stack executable permission is set.
de: Für geschachtelte Funktionen auf dem Stapel werden Ausführrechte gesetzt.

en: For shift operations by a constant amount, which require an individual instruction to shift by one position, set the maximum number of inline shift instructions (maximum value 64) to emit instead of using the corresponding __mspabi helper function. The default value is 4.
de: Für Bitschiebeoperationen mit konstanter Anzahl, die einen einzelnen Maschinenbefehl zur Verschiebung um eine Stelle erfordern, die maximale Anzahl von Inline-Verschiebeanweisungen (Maximalwert 64) festlegen, die ausgegeben werden sollen, anstatt die entsprechende Hilfsfunktion __mspabi zu verwenden. Der Standardwert ist 4.

en: For targets that normally need trampolines for nested functions, always generate them instead of using descriptors.
de: Für Ziele, die normalerweise Trampoline für geschachtelte Funktionen benötigen, diese stets generieren, statt Deskriptoren zu verwenden.

en: For the assembler (and linker) permit any architecture sub-variant to be used without error.
de: Dem Assembler (und Linker) erlauben, jede beliebige Architektur-Untervariante ohne Fehler zu verwenden.

en: Forbid performing fp-as-gp optimization.
de: FP-als-GP-Optimierung verbieten.

en: Forbid using $fp to access static and global variables.  This option strictly forbids fp-as-gp optimization regardless of '-mforce-fp-as-gp'.
de: Verbieten, dass mittels $fp auf statische oder globale Variablen zugegriffen wird. Diese Option verhindert die FP-als-GP-Optimierung, unabhängig von -mforce-fp-as-gp.

en: Force all calls to be made via a jli instruction.
de: Erzwingen, dass alle Aufrufe mittels des jli-Befehls erfolgen.

en: Force assembly output to always use hex constants.
de: Erzwingen, dass die Assembler-Ausgabe immer Hexadezimalkonstanten verwendet.

en: Force bitfield accesses to match their type width.
de: Bitfeld-Zugriffe zwingen, zu ihrer Typbreite zu passen.

en: Force creation of temporary to test infrequently-executed forall code.
de: Erzeugen von temporären Variablen erzwingen, um Code für selten ausgeführtes »forall« zu testen.

en: Force disable hardware loop, even use -mext-dsp.
de: Ausschalten der Hardwareschleife erzwingen, selbst wenn -mext-dsp angegeben ist.

en: Force functions to be aligned to a 4 byte boundary.
de: Funktionen auf 4-Byte-Grenzen zwingen.

en: Force generation of external symbol indirection stubs.
de: Codeerzeugung von Stummeln für die Indirektion externer Symbole erzwingen.

en: Force indirect call and jump via register.
de: Indirekte Aufrufe und Sprünge mittels Register erzwingen.

en: Force performing fp-as-gp optimization.
de: FP-als-GP-Optimierung erzwingen.

en: Force the underlying type for "wchar_t" to be "unsigned short".
de: Den für »wchar_t« zugrundeliegenden Typen auf »unsigned short« zwingen.

en: Force the usage of delay slots for conditional branches.
de: Verwendung der Delay-Slots für bedingte Sprünge erzwingen.

en: Format statement in module main block at %C
de: Formatanweisung im Hauptblock des Modules bei %C

en: Fortran 2003: %s specifier in %s statement at %L has value %qs
de: Fortran 2003: Spezifizierer %s in Anweisung %s bei %L hat Wert %qs

en: Fortran 2003: Character for %qs argument of %qs intrinsic at %L
de: Fortran 2003: Zeichen für Argument %qs des intrinsischen %qs bei %L

en: Fortran 2003: DT format specifier not allowed at %C
de: Fortran 2003: DT-Format-Spezifizierer bei %C nicht erlaubt

en: Fortran 2003: Scalar CHARACTER actual argument with array dummy argument %qs at %L
de: Fortran 2003: Skalares effektives CHARACTER-Argument mit Feld-Scheinargument %qs bei %L

en: Fortran 2008 obsolescent feature:
de: Fortran 2008: Veraltete Funktion:

en: Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L
de: Fortran 2008: COMMON-Block %qs mit Binde-Marke bei %L teilt sich Bezeichner mit gobaler nicht-COMMON-Blockentität bei %L

en: Fortran 2008: Non-pointer actual argument at %L to pointer dummy %qs
de: Fortran 2008: Effektives Nicht-Zeiger-Argument bei %L an Scheinzeiger %qs

en: Fortran 2008: Null pointer at %L to non-pointer dummy %qs
de: Fortran 2008: Nullzeiger bei %L an Nicht-Zeiger-Schein-%qs

en: Fortran 2008: Pointer functions in variable definition context (%s) at %L
de: Fortran 2008: Zeigerfunktionen in Variablen-Definitionskontext (%s) bei %L

en: Fortran 2008: Semicolon at %C without preceding statement
de: Fortran 2008: Semikolon bei %C ohne vorausgehende Anweisung

en: Fortran 2018 deleted feature:
de: Fortran 2018: gelöschtes Feature:

en: Fortran 2018 obsolescent feature:
de: Fortran 2018: Veraltetes Feature:

en: Fortran 95 requires default INTEGER in %s tag at %L
de: Fortran 95 erfordert Standard INTEGER in %s-Marke bei %L

en: Found no matching specific binding for the call to the GENERIC %qs at %L
de: Keine passende spezifische Bindung für Aufruf des GENERIC %qs bei %L gefunden

en: Free line length must be at least three
de: Freie Zeilenlänge muss mindestens drei sein

en: Function %qs as initialization expression at %L
de: Funktion %qs als Initialisierungsausdruck bei %L

en: Function %qs at %L cannot be called recursively, as it is not RECURSIVE
de: Funktion %qs bei %L kann nicht rekursiv aufgerufen werden, da sie nicht RECURSIVE ist

en: Function %qs at %L cannot have an initializer
de: Funktion %qs bei %L darf keinen Initialisierer haben

en: Function %qs at %L has no IMPLICIT type
de: Funktion %qs bei %L hat keinen IMPLICIT-Typ

en: Function %qs at %L has no IMPLICIT type; did you mean %qs?
de: Funktion %qs bei %L hat keinen IMPLICIT-Typ; meinen Sie %qs?

en: Function %qs at %L is INTRINSIC but is not compatible with an intrinsic
de: Funktion %qs bei %L ist INTRINSIC, aber nicht mit einer intrinsischen Funktion verträglich

en: Function %qs at %L must be PURE
de: Funktion %qs bei %L muss PURE sein

en: Function %qs in initialization expression at %L must be an intrinsic function
de: Funktion %qs in Initialisierungs-Ausdruck bei %L muss eine intrinsische Funktion sein

en: Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument
de: Funktion %qs ist als CHARACTER(*) deklariert und kann nicht bei %L verwendet werden, da es kein Scheinargument ist

en: Function %qs requires an argument list at %C
de: Funktion %qs erfordert eine Argumentliste bei %C

en: Function %s at %L has entries with mismatched array specifications
de: Funktion »%s« bei %L hat Einträge mit unpassenden Feldspezifikationen

en: Function %s at %L has entry %s with mismatched characteristics
de: Funktion »%s« bei %L hat Eintrag »%s« mit unpassenden Charakteristika

en: Function %s at %L with entries returning variables of different string lengths
de: Funktion »%s« bei %L mit Einträgen, die Variablen mit verschiedenen Zeichenkettenlängen zurückgeben

en: Function not found.
de: Funktion nicht gefunden.

en: Function result %qs at %L cannot have an initializer
de: Funktionsergebnis %qs bei %L kann keine Initialisierung haben

en: Function result %qs at %L has no IMPLICIT type
de: Funktionsergebnis %qs bei %L hat keinen IMPLICIT-Typ

en: Function result %qs at %L is invalid as X argument to C_FUNLOC
de: Funktionsergebnis %qs bei %L ist als X-Argument für C_FUNLOC ungültig

en: Function result %qs at %L shall not be a coarray or have a coarray component
de: Funktionsergebnis %qs bei %L darf weder Koarray sein noch eine Koarray-Komponente haben

en: Function result %qs is invalid as proc-target in procedure pointer assignment at %L
de: Funktionsergebnis %qs ist als Prozedurziel in Zuweisung des Prozedurzeigers bei %L ungültig

en: Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute
de: Funktionsergebnisvariable %qs bei %L von elementarer Funktion %qs darf nicht die Attribute ALLOCATABLE oder POINTER haben

en: Function starts are aligned to this power of 2.
de: Funktionsanfänge werden an dieser Potenz von 2 ausgerichtet.

en: Functions which return values must end with return statements.
de: Funktionen, die Werte zurückgeben, müssen mit return-Anweisungen enden.

en: Fuse certain integer operations together for better performance on power10.
de: Bestimmte Ganzzahloperationen verschmelzen, um die Performance auf power10 zu steigern.

en: Fuse certain integer operations together for better performance on power8.
de: Bestimmte Ganzzahloperationen verschmelzen, um die Performance auf power8 zu steigern.

en: GCC cannot support operators with integer types and fixed-point types that have too many integral and fractional bits together
de: GCC kann keine Operatoren mit Ganzzahl- und Festkommatypen unterstützen, die zusammen zu viele Ganzzahl- und Bruch-Bits haben

en: GCC does not currently support argument type %qT for %<simd%> functions
de: GCC bietet derzeit keine Unterstützung für Parametertyp %qT für %<simd%>-Funktionen

en: GCC does not currently support mixed size types for %<simd%> functions
de: GCC unterstützt derzeit keine Typen gemischter Größe für %<simd%>-Funktionen

en: GCC does not currently support return type %qT for %<simd%> functions
de: GCC bietet derzeit keine Unterstützung für Rückgabetyp %qT für %<simd%>-Funktionen

en: GCC does not currently support simdlen %wd for type %qT
de: GCC unterstützt derzeit %<simdlen %wd%> für Typ %qT nicht

en: GCC is not configured to support %qs as %<-foffload=%> argument
de: GCC ist nicht dafür konfiguriert, %qs als Argument für %<-foffload=%> zu unterstützen

en: GCC must be configured with %<--enable-newlib-nano-formatted-io%> to use %<-mtiny-printf%>
de: GCC muss mit %<--enable-newlib-nano-formatted-io%> konfiguriert werden, um %<-mtiny-printf%> zu verwenden

en: GCC supports only %u nested scopes
de: GCC unterstützt nur %u geschachtelte Gültigkeitsbereiche

en: GCC vector passed by reference: non-standard ABI extension with no compatibility guarantee
de: GCC-Vektor per Referenz übergegeben: Nicht-Standard-ABI-Erweiterung ohne Kompatibilitätsgarantie

en: GCC vector returned by reference: non-standard ABI extension with no compatibility guarantee
de: GCC-Vektor per Referenz zurückgegeben: Nicht-Standard-ABI-Erweiterung ohne Kompatibilitätsgarantie

en: GCN GPU type to use:
de: Zu verwendende GCN-CPU-Art:

en: GCSE disabled
de: GCSE ausgeschaltet

en: GENERIC %qs at %L cannot overwrite specific binding with the same name
de: GENERIC %qs bei %L kann nicht spezifische Bindung mit gleichem Namen überschreiben

en: GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too
de: GENERIC %qs bei %L muss auf spezifische Bindung abzielen, %qs ist ebenfalls GENERIC

en: GENERIC at %C must be inside a derived-type CONTAINS
de: GENERIC bei %C muss innerhalb eines CONTAINS eines abgeleiteten Typs sein

en: GENERIC binding at %C
de: GENERIC-Bindung bei %C

en: GENERIC procedure %qs is not allowed as an actual argument at %L
de: GENERIC-Prozedur %qs ist bei %L nicht als effektives Argument erlaubt

en: GMP version %s, MPFR version %s, MPC version %s, isl version %s
de: GMP Version %s, MPFR Version %s, MPC Version %s. isl Versiom %s

en: GNU C no longer supports -traditional without -E
de: GNU C unterstützt »-traditional« ohne »-E« nicht mehr

en: GNU Extension:
de: GNU-Erweiterung:

en: GNU Objective C no longer supports traditional compilation
de: GNU Objective C unterstützt keine traditionelle Übersetzung mehr

en: GNU-style attribute between label and declaration appertains to the label
de: Attribut im GNU-Stil zwischen Label und Deklaration bezieht sich auf das Label

en: GOTO statement at %L leaves CRITICAL construct for label at %L
de: GOTO-Anweisung bei %L hinterlässt CRITICAL-Konstrukt für Marke bei %L

en: GOTO statement at %L leaves DO CONCURRENT construct for label at %L
de: GOTO-Anweisung bei %L hinterlässt DO CONCURRENT-Konstrukt für Marke bei %L

en: Garbage after PARAMETERIZED TYPE declaration at %C
de: Syntaxfehler hinter PARAMETERIZED-TYPE-Deklaration bei %C

en: Generate (do not generate) MMA instructions.
de: MMA-Befehle erzeugen (oder auch nicht).

en: Generate (do not generate) code that uses the LXVKQ instruction.
de: Code erzeugen (oder auch nicht), der den Befehl LXVKQ verwendet.

en: Generate (do not generate) code that uses the XXSPLTIDP instruction.
de: Code erzeugen (oder auch nicht), der den Befehl XXSPLTIDP verwendet.

en: Generate (do not generate) code that uses the XXSPLTIW instruction.
de: Code erzeugen (oder auch nicht), der den Befehl XXSPLTIW verwendet.

en: Generate (do not generate) pc-relative memory addressing.
de: Speicheradressierung relativ zu PC (oder absolut) erzeugen.

en: Generate (do not generate) pc-relative memory optimizations for externals.
de: Optimierungen für Speicherzugriffe relative zu PC durchführen (nicht durchführen).

en: Generate (do not generate) prefixed memory instructions.
de: Speicherzugriffsbefehle mit (oder ohne) Präfix erzeugen.

en: Generate 16-bit instructions.
de: 16-Bit-Befehle erzeugen.

en: Generate 16bit i386 code.
de: 16-Bit-i386-Code erzeugen.

en: Generate 32-bit code.
de: 32-Bit-Code erzeugen.

en: Generate 32-bit offsets in switch tables.
de: 32-Bit-Versatz in switch-Tabellen erzeugen.

en: Generate 32bit i386 code.
de: 32-Bit-i386-Code erzeugen.

en: Generate 32bit x86-64 code.
de: 32-Bit-x86-64-Code erzeugen.

en: Generate 32x16 multiply and mac instructions.
de: 32x16-Multiplizier sowie Multiplizier+Addier-Befehle generieren.

en: Generate 64-bit code.
de: 64-Bit-Code erzeugen.

en: Generate 64bit x86-64 code.
de: 64-Bit-x86-64-Code erzeugen.

en: Generate APCS conformant stack frames.
de: APCS-konforme Stapelrahmen erzeugen.

en: Generate ARCompact 32-bit code for ARC600 processor.
de: ARCompact-32-Bit-Code für ARC600-Prozessor erzeugen.

en: Generate ARCompact 32-bit code for ARC601 processor.
de: ARCompact-32-Bit-Code für ARC601-Prozessor erzeugen.

en: Generate ARCompact 32-bit code for ARC700 processor.
de: ARCompact-32-Bit-Code für ARC700-Prozessor erzeugen.

en: Generate AT&T-style stubs for Mach-O.
de: Stubs im AT&T-Stil für Mach-O erzeugen.

en: Generate BTF debug information at default level.
de: BTF-Debug-Informationen auf Standardniveau erzeugen.

en: Generate C header of platform-specific features.
de: C-Header mit Plattform-spezifischen Merkmalen erzeugen.

en: Generate C prototypes from BIND(C) declarations.
de: C-Prototypen aus BIND(C)-Deklarationen generieren.

en: Generate C prototypes from non-BIND(C) external procedure definitions.
de: C-Prototypen aus Nicht-BIND(C)-Deklarationen für externe Prozeduren generieren.

en: Generate C++ Module dependency information.
de: Informationen zu Abhängigkeiten von C++-Modulen erzeugen.

en: Generate C-SKY FPU double float instructions (default for hard float).
de: FPU-Befehle mit doppelter Genauigkeit für C-SKY generieren (Vorgabe für Hardware-Gleitkomma).

en: Generate CTF debug information at default level.
de: CTF-Debug-Informationen auf Standardniveau erzeugen.

en: Generate DSP extension instructions.
de: Erweiterungsbefehle für DSP generieren.

en: Generate DWARF pubnames and pubtypes sections with GNU extensions.
de: DWARF-Abschnitte für Pubnames und Pubtypes mit GNU-Erweiterungen erzeugen.

en: Generate DWARF pubnames and pubtypes sections.
de: DWARF-Abschnitte für Pubnames und Pubtypes erzeugen.

en: Generate ELF FDPIC code.
de: ELF-FDPIC-Code erzeugen.

en: Generate GFLOAT double precision code.
de: GFLOAT-Code mit doppelter Genauigkeit generieren.

en: Generate H8/300H code.
de: H8/300H-Code erzeugen.

en: Generate H8S code.
de: H8S-Code erzeugen.

en: Generate H8S/2600 code.
de: H8S/2600-Code erzeugen.

en: Generate H8SX code.
de: H8SX-Code erzeugen.

en: Generate ILP32 code.
de: ILP32-Code erzeugen.

en: Generate IT blocks appropriate for ARMv8.
de: Für den ARMv8 angemessene IT-Blöcke erzeugen.

en: Generate JSON file.
de: JSON-Datei erzeugen.

en: Generate LP64 code.
de: LP64-Code erzeugen.

en: Generate MIPS16 code.
de: MIPS16-Code erzeugen.

en: Generate ModuleInfo struct for output module.
de: ModuleInfo-Struktur für Ausgabemodul generieren.

en: Generate PA1.0 code.
de: PA1.0-Code erzeugen.

en: Generate PA1.1 code.
de: PA1.1-Code erzeugen.

en: Generate PA2.0 code (requires binutils 2.10 or later).
de: PA2.0-Code erzeugen (erfordert binutils 2.10 oder neuer).

en: Generate SBIT, CBIT instructions.
de: SBIT, CBIT-Befehle erzeugen.

en: Generate SH1 code.
de: SH1-Code erzeugen.

en: Generate SH2 code.
de: SH2-Code erzeugen.

en: Generate SH2a FPU-less code.
de: FPU-freien SH2a-Code erzeugen.

en: Generate SH2e code.
de: SH2e-Code erzeugen.

en: Generate SH3 code.
de: SH3-Code erzeugen.

en: Generate SH3e code.
de: SH3e-Code erzeugen.

en: Generate SH4 FPU-less code.
de: FPU-freien SH4-Code erzeugen.

en: Generate SH4 code.
de: SH4-Code erzeugen.

en: Generate SH4-100 FPU-less code.
de: FPU-freien SH4-100-Code erzeugen.

en: Generate SH4-100 code.
de: SH4-100-Code erzeugen.

en: Generate SH4-200 FPU-less code.
de: FPU-freien SH4-200-Code erzeugen.

en: Generate SH4-200 code.
de: SH4-200-Code erzeugen.

en: Generate SH4-300 FPU-less code.
de: FPU-freien SH4-300-Code erzeugen.

en: Generate SH4-300 code.
de: SH4-300-Code erzeugen.

en: Generate SH4a FPU-less code.
de: FPU-freien SH4a-Code erzeugen.

en: Generate SH4a code.
de: SH4a-Code erzeugen.

en: Generate SH4al-dsp code.
de: SH4al-dsp-Code erzeugen.

en: Generate VRSAVE instructions when generating AltiVec code.
de: Beim Erzeugen von AltiVec-Code VRSAVE-Befehle erzeugen.

en: Generate __mcount_loc section with all _mcount and __fentry__ calls.
de: Separaten »__mcount_loc«-Abschnitt erzeugen, der alle Aufrufe von »_mcount« und »__fentry__« enthält.

en: Generate __mcount_loc section with all mcount or __fentry__ calls.
de: Separaten »__mcount_loc«-Abschnitt erzeugen, der alle Aufrufe von »mcount« und »__fentry__« enthält.

en: Generate a #line directive pointing at the current working directory.
de: Eine auf das aktuelle Verzeichnis verweisende #line-Anweisung erzeugen.

en: Generate a Mach-O bundle (file type MH_BUNDLE).
de: Ein Mach-O-Bundle erzeugen (Dateityp MH_BUNDLE).

en: Generate a __return_loc section pointing to all return instrumentation code.
de: Einen __return_loc-Abschnitt generieren, der auf jeden instrumentierten return-Code verweist.

en: Generate a call to abort if a noreturn function returns.
de: Die Funktion »abort« aufrufen, wenn eine »noreturn«-Funktion zurückkehrt.

en: Generate a default D main() function when compiling.
de: Beim Compilieren eine Default-main-Funktion für D generieren.

en: Generate a single exit point for each function.
de: Einen einzigen Austrittspunkt für jede Funktion erzeugen.

en: Generate absolute source path names for gcov.
de: Absolute Quellpfade für gcov erzeugen.

en: Generate aggregate parameter passing code with at most 64-bit alignment.
de: Code zum Übergeben von Aggregaten mit maximal 64-Bit-Ausrichtung erzeugen.

en: Generate all necessary information for BPF Compile Once - Run Everywhere.
de: Alle notwendigen Informationen für »BPF Compile Once - Run Everywhere« generieren.

en: Generate an output executable that binds symbols on load, rather than lazily.
de: Ausgabedatei erzeugen, die Symbole nicht erst bei Bedarf, sondern bereits beim Laden bindet.

en: Generate assembler output that is compatible with the Renesas AS100 assembler.  This may restrict some of the compiler's capabilities.  The default is to generate GAS compatible syntax.
de: Assemblerausgabe erzeugen, die mit Renesas AS100-Assembler verträglich ist. Dies schränkt einige Compilerfähigkeiten ein. Voreinstellung ist GAS-verträgliche Syntax.

en: Generate auto-inc/dec instructions.
de: Auto-inc/dec-Befehle erzeugen.

en: Generate big endian code.
de: Big-Endian-Code erzeugen.

en: Generate big-endian code.
de: Big-Endian-Code erzeugen.

en: Generate big-endian eBPF.
de: Big-Endian-eBPF erzeugen.

en: Generate bit instructions.
de: Bit-Befehle erzeugen.

en: Generate call insns as direct calls.
de: Sprungbefehle als direkte Sprünge erzeugen.

en: Generate call insns as indirect calls, if necessary.
de: Falls nötig, »call«-Befehle als indirekte Aufrufe erzeugen.

en: Generate call insns as indirect calls.
de: Sprungbefehle als indirekte Sprünge erzeugen.

en: Generate call insns as register indirect calls.
de: Aufrufbefehle als indirekte Registeraufrufe erzeugen.

en: Generate cld instruction in the function prologue.
de: Im Funktionsprolog cld-Befehle erzeugen.

en: Generate code for C-SKY compiler runtime instead of libgcc.
de: Code für Laufzeitumgebung des C-SKY-Compilers statt libgcc generieren.

en: Generate code for CR16C architecture.
de: Code für CR16C-Architektur erzeugen.

en: Generate code for CR16C+ architecture (Default).
de: Code für CR16C+-Architektur erzeugen (Standard).

en: Generate code for GNU as.
de: Code für GNU as erzeugen.

en: Generate code for GNU assembler (gas).
de: Code für GNU Assembler (gas) erzeugen.

en: Generate code for GNU ld.
de: Code für GNU ld erzeugen.

en: Generate code for GNU runtime environment.
de: Code für die GNU-Laufzeitumgebung erzeugen.

en: Generate code for NeXT (Apple Mac OS X) runtime environment.
de: Code für die NeXT-(Apple macOS X)-Laufzeitumgebung erzeugen.

en: Generate code for OpenMP offloading: enables -msoft-stack and -muniform-simt.
de: Code für OpenMP-Auslagerung erzeugen: schaltet »-msoft-stack« und »-muniform-simt« ein.

en: Generate code for SH4 340 series (MMU/FPU-less).
de: Code für Serie SH4 340 erzeugen (ohne MMU/FPU).

en: Generate code for SH4 400 series (MMU/FPU-less).
de: Code für Serie SH4 400 erzeugen (ohne MMU/FPU).

en: Generate code for SH4 500 series (FPU-less).
de: Code für Serie SH4 500 erzeugen (ohne FPU)

en: Generate code for Smart Mode.
de: Code für Smart Mode erzeugen.

en: Generate code for Thumb state.
de: Code für Thumb-Zustand erzeugen.

en: Generate code for UNIX assembler.
de: Code für UNIX-Assembler erzeugen.

en: Generate code for a 32-bit ABI.
de: Code für 32-Bit-ABI erzeugen.

en: Generate code for a 5206e.
de: Code für einen 5206e erzeugen.

en: Generate code for a 520X.
de: Code für einen 520X erzeugen.

en: Generate code for a 528x.
de: Code für einen 528x erzeugen.

en: Generate code for a 5307.
de: Code für einen 5307 erzeugen.

en: Generate code for a 5407.
de: Code für einen 5407 erzeugen.

en: Generate code for a 64-bit ABI.
de: Code für 64-Bit-ABI erzeugen.

en: Generate code for a 68000.
de: Code für 68000 erzeugen.

en: Generate code for a 68010.
de: Code für 68010 erzeugen.

en: Generate code for a 68020.
de: Code für 68020 erzeugen.

en: Generate code for a 68030.
de: Code für einen 68030 erzeugen.

en: Generate code for a 68040, without any new instructions.
de: Code für einen 68040 ohne neue Befehle erzeugen.

en: Generate code for a 68040.
de: Code für einen 68040 erzeugen.

en: Generate code for a 68060, without any new instructions.
de: Code für einen 68060 ohne neue Befehle erzeugen.

en: Generate code for a 68060.
de: Code für einen 68060 erzeugen.

en: Generate code for a 68302.
de: Code für einen 68302 erzeugen.

en: Generate code for a 68332.
de: Code für einen 68332 erzeugen.

en: Generate code for a 68851.
de: Code für einen 68851 erzeugen.

en: Generate code for a ColdFire v4e.
de: Code für ColdFire v4e erzeugen.

en: Generate code for a DLL.
de: Code für DLL erzeugen.

en: Generate code for a Fido A.
de: Code für Fido A erzeugen.

en: Generate code for a cpu32.
de: Code für eine cpu32 erzeugen.

en: Generate code for all template instantiations.
de: Code für alle Template-Instanziierungen einschalten.

en: Generate code for an 11/10.
de: Code für eine 11/10 erzeugen.

en: Generate code for an 11/40.
de: Code für eine 11/40 erzeugen.

en: Generate code for an 11/45.
de: Code für eine 11/45 erzeugen.

en: Generate code for assert contracts.
de: Code für Assert-Verträge generieren.

en: Generate code for class invariant contracts.
de: Code für Klassen-Invarianz-Verträge generieren.

en: Generate code for darwin loadable kernel extensions.
de: Code für ladbare Darwin-Kernelerweiterungen erzeugen.

en: Generate code for functions even if they are fully inlined.
de: Code für Funktionen erzeugen, auch wenn sie vollständig »inline« sind.

en: Generate code for given CPU.
de: Code für die angegebene CPU erzeugen.

en: Generate code for old exec BSS PLT.
de: Code für altes ausführbares BSS PLT erzeugen.

en: Generate code for postcondition contracts.
de: Code für Nachbedingungsverträge erzeugen.

en: Generate code for precondition contracts.
de: Code für Vorbedingungsverträge generieren.

en: Generate code for static functions even if they are never called.
de: Code für static-Funktionen erzeugen, auch wenn sie nie aufgerufen werden.

en: Generate code for switches without a default case.
de: Code für Switches ohne Default-Fall generieren.

en: Generate code for the Android platform.
de: Code für die Android-Plattform erzeugen.

en: Generate code for the M*Core M210.
de: Code für den M*Core M210 erzeugen.

en: Generate code for the M*Core M340.
de: Code für den M*Core M340 erzeugen.

en: Generate code for the kernel or loadable kernel extensions.
de: Code für ladbare Darwin-Kernelerweiterungen oder Kernel erzeugen.

en: Generate code for the supervisor mode (default).
de: Code für Supervisor-Modus generieren (Standard).

en: Generate code for the user mode.
de: Code für User-Modus generieren.

en: Generate code in 32 bit ARM state.
de: Code im 32-Bit-ARM-Zustand erzeugen.

en: Generate code in big endian mode.
de: Code im »Big Endian«-Modus erzeugen.

en: Generate code in big-endian mode.
de: Code im »Big Endian«-Modus erzeugen.

en: Generate code in little endian mode.
de: Code im »Little Endian«-Modus erzeugen.

en: Generate code in little-endian mode.
de: Code im »Little Endian«-Modus erzeugen.

en: Generate code suitable for executables (NOT shared libs).
de: Code für ausführbare Dateien (NICHT Shared Libraries) erzeugen.

en: Generate code suitable for fast turn around debugging.
de: Für schnelles Debugging geeigneten Code erzeugen.

en: Generate code that can be used in SVR4-style dynamic objects.
de: Code erzeugen, der in dynamischen Objekten im SVR4-Stil verwendet werden kann.

en: Generate code that can keep local state uniform across all lanes.
de: Code erzeugen, der lokalen Zustand in allen Bahnen einheitlich halten kann.

en: Generate code that conforms to Intel MCU psABI.
de: Code erzeugen, der zum Intel-MCU-psABI passt.

en: Generate code that conforms to the given ABI.
de: Code erzeugen, der zum angegebenen ABI passt.

en: Generate code that conforms to the specified ABI.
de: Code erzeugen, der zum angegebenen ABI passt.

en: Generate code that is link-compatible with MIPS16 and microMIPS code.
de: Code erzeugen, der sicher mit MIPS16- und microMIPS-Code gebunden werden kann.

en: Generate code that uses 68881 floating-point instructions.
de: Code erzeugen, der 68881-Gleitkommabefehle verwendet.

en: Generate code that will run in privileged state.
de: Code erzeugen, der im privilegierten Zustand läuft.

en: Generate code that won't be linked against any other ID shared libraries, but may be used as a shared library.
de: Code erzeugen, der nicht mit anderen ID-shared Libraries gelinkt werden würde, aber als Shared Library verwendet werden kann.

en: Generate code to check bounds before indexing arrays.
de: Code zur Überprüfung der Grenzen vor Arrayindizierung erzeugen.

en: Generate code to check exception specifications.
de: Code zur Überprüfung von Exception-Spezifikationen erzeugen.

en: Generate code to mitigate against straight line speculation.
de: Code generieren, der Gerade-Linie-Spekulationen abwehrt.

en: Generate code to track when the CPU might be speculating incorrectly.
de: Code generieren, um mitzuverfolgen, wann die CPU falsch spekulieren könnte.

en: Generate code to use a non-exec PLT and GOT.
de: Code erzeugen, der nicht ausführbares PLT und GOT enthält.

en: Generate code using global anchor symbol addresses.
de: Code mittels globaler Anker-Symboladressen generieren.

en: Generate code which uses hardware floating point instructions.
de: Code erzeugen, der Hardware-Gleitkommabefehle verwendet.

en: Generate code which uses only the general registers.
de: Code erzeugen, der nur die allgemeinen Register verwendet.

en: Generate code which uses the core registers only (r0-r14).
de: Code erzeugen, der nur die Kernregister (r0–r14) verwendet.

en: Generate code with library calls for floating point.
de: Code mit Bibliotheksaufrufen für Gleitkommaarithmetik erzeugen.

en: Generate code with unaligned load store, valid for MIPS R6.
de: Generierung von Code mit unausgerichtetem load/store, gültig für MIPS R6.

en: Generate code without GP reg.
de: Code ohne Register für globalen Zeiger erzeugen.

en: Generate compile-time CFString objects.
de: CFString-Objekte zum Kompilierungszeitpunkt generieren.

en: Generate compressed debug sections.
de: Komprimierte Fehlersuchinformationen erzeugen.

en: Generate conditional move instructions.
de: Verwendung bedingter Kopierbefehle einschalten.

en: Generate constant pools in the compiler instead of assembler.
de: Konstantenpools im Compiler statt im Assembler generieren.

en: Generate cpp defines for server IO.
de: cpp-Defines für Server-IO erzeugen.

en: Generate cpp defines for workstation IO.
de: cpp-Defines für Workstation-IO erzeugen.

en: Generate debug information in DWARF v2 (or later) format.
de: Fehlersuchinformationen im DWARF-v2-Format (oder neuer) erzeugen.

en: Generate debug information in STABS format.
de: Fehlersuchinformationen im STABS-Format erzeugen.

en: Generate debug information in VMS format.
de: Fehlersuchinformationen im VMS-Format erzeugen.

en: Generate debug information in XCOFF format.
de: Fehlersuchinformationen im XCOFF-Format erzeugen.

en: Generate debug information in default extended format.
de: Fehlersuchinformationen im erweiterten Standardformat erzeugen.

en: Generate debug information in default format.
de: Fehlersuchinformationen im Standardformat erzeugen.

en: Generate debug information in default version of DWARF format.
de: Fehlersuchinformationen im Standardversion des DWARF-Formats erzeugen.

en: Generate debug information in extended STABS format.
de: Fehlersuchinformationen im erweiterten STABS-Format erzeugen.

en: Generate debug information in extended XCOFF format.
de: Fehlersuchinformationen im erweiterten XCOFF-Format erzeugen.

en: Generate debug information in separate .dwo files.
de: Fehlersuchinformationen in separaten .dwo-Dateien erzeugen.

en: Generate default double-precision SH2a-FPU code.
de: Standard SH2a-FPU-Code mit doppelter Genauigkeit erzeugen.

en: Generate default single-precision SH2a-FPU code.
de: Standard SH2a-FPU-Code mit einfacher Genauigkeit erzeugen.

en: Generate default single-precision SH4 code.
de: Standard SH4-Code mit einfacher Genauigkeit erzeugen.

en: Generate default single-precision SH4-100 code.
de: Standard SH4-100-Code mit einfacher Genauigkeit erzeugen.

en: Generate default single-precision SH4-200 code.
de: Standard SH4-200-Code mit einfacher Genauigkeit erzeugen.

en: Generate default single-precision SH4-300 code.
de: Standard SH4-300-Code mit einfacher Genauigkeit erzeugen.

en: Generate default single-precision SH4a code.
de: Standard SH4a-Code mit einfacher Genauigkeit erzeugen.

en: Generate discontiguous stack frames.
de: Nicht zusammenhängende Stapelrahmen erzeugen.

en: Generate divide instructions.
de: Divisions-Befehle erzeugen.

en: Generate divide results with reminder having the same sign as the divisor (not the dividend).
de: Divisionsergebnisse mit dem gleichen Vorzeichen im Übertrag wie der Divisor (nicht der Dividend) erzeugen.

en: Generate documentation.
de: Dokumentation erzeugen.

en: Generate double-precision floating-point instructions.
de: Gleitkommabefehle doppelter Genauigkeit generieren.

en: Generate eBPF for the given Linux kernel version.
de: eBPF für die angegebene Linux-Kernelversion erzeugen.

en: Generate extended arithmetic instructions, only valid for ARC700.
de: Erweiterte arithmetische Befehle erzeugen, nur für ARC700 gültig.

en: Generate extended entry point information for inlined functions.
de: Erweiterte Informationen für Einsprungpunkt für inline-Funktionen erzeugen.

en: Generate fast indirect calls.
de: Schnelle indirekte Aufrufe erzeugen.

en: Generate floating point mathematics using given instruction set.
de: Gleitkommaarithmetik mit gegebenem Befehlssatz erzeugen.

en: Generate floating-point multiply-accumulation instructions.
de: Kombinierte Multiplizier-Addier-Befehle generieren.

en: Generate frecipd/fsqrtd/fdivd instructions (default for hard float).
de: Die Befehle frecipd/fsqrtd/fdivd generieren (Vorgabe für Hardware-Gleitkomma).

en: Generate hardware abs instructions.
de: Hardware-abs-Befehle generieren.

en: Generate inline floating point division, optimize for latency.
de: Eingebettete Gleitkommadivision erzeugen, auf Wartezeit optimieren.

en: Generate inline floating point division, optimize for throughput.
de: Eingebettete Gleitkommadivision erzeugen, auf Durchsatz optimieren.

en: Generate inline integer division, optimize for latency.
de: Eingebettete Ganzzahldivision erzeugen, auf Wartezeit optimieren.

en: Generate inline integer division, optimize for throughput.
de: Eingebettete Ganzzahldivision erzeugen, auf Durchsatz optimieren.

en: Generate inline square root, optimize for latency.
de: Quadratwurzel »inline« erzeugen, auf Wartezeit optimieren.

en: Generate inline square root, optimize for throughput.
de: Quadratwurzel »inline« erzeugen, auf Durchsatz optimieren.

en: Generate instructions supported by barrel shifter.
de: Befehle generieren, die vom Barrel-Shifter unterstützt werden.

en: Generate isel instructions.
de: isel-Befehle erzeugen.

en: Generate lazy class lookup (via objc_getClass()) for use in Zero-Link mode.
de: Lockeres Nachschlagen von Klassen (mit objc_getClass()) für Verwendung im Null-Verknüpfungs-Modus erzeugen.

en: Generate little endian code.
de: Little-Endian-Code erzeugen.

en: Generate little-endian code.
de: Little-Endian-Code erzeugen.

en: Generate little-endian eBPF.
de: Little-Endian-eBPF erzeugen.

en: Generate load/store multiple instructions.
de: Befehle zum gleichzeitigen Laden/Speichern mehrerer Daten erzeugen.

en: Generate load/store with update instructions.
de: Befehle für Laden/Speichern mit Aktualisierung erzeugen.

en: Generate local calls to out-of-line atomic operations.
de: Atomare Operationen durch Hilfsfunktionen implementieren.

en: Generate make dependencies and compile.
de: Make-Abhängigkeiten erzeugen und Code übersetzen.

en: Generate make dependencies.
de: Make-Abhängigkeiten erzeugen.

en: Generate mcount/__fentry__ calls as nops. To activate they need to be patched in.
de: Aufrufe von »mcount«/»__fentry__« als NOPs erzeugen. Um sie einzuschalten, müssen sie hineingepatcht werden.

en: Generate millicode thunks.
de: Millicode-Schnipsel erzeugen.

en: Generate mul64 and mulu64 instructions.
de: mul64- und mulu64-Befehle erzeugen.

en: Generate norm instruction.
de: norm-Befehl erzeugen.

en: Generate normal-mode code.
de: Code im normalen Modus erzeugen.

en: Generate only single-precision SH2a-FPU code.
de: SH2a-FPU-Code nur mit einfacher Genauigkeit erzeugen.

en: Generate only single-precision SH4 code.
de: SH4-Code nur mit einfacher Genauigkeit erzeugen.

en: Generate only single-precision SH4-100 code.
de: SH4-100-Code nur mit einfacher Genauigkeit erzeugen.

en: Generate only single-precision SH4-200 code.
de: SH4-200-Code nur mit einfacher Genauigkeit erzeugen.

en: Generate only single-precision SH4-300 code.
de: SH4-300-Code nur mit einfacher Genauigkeit erzeugen.

en: Generate only single-precision SH4a code.
de: SH4a-Code nur mit einfacher Genauigkeit erzeugen.

en: Generate pc-relative code.
de: PC-relativen Code erzeugen.

en: Generate performance extension instructions.
de: Erweiterungsbefehle für Performance einschalten.

en: Generate performance extension version 2 instructions.
de: Erweiterungsbefehle für Performance Version 2 einschalten.

en: Generate phony targets for all headers.
de: Unechte Ziele für alle Header erzeugen.

en: Generate position-independent code for executables if possible (large mode).
de: Wenn möglich, lageunabhängigen Code für ausführbare Dateien erzeugen (large mode).

en: Generate position-independent code for executables if possible (small mode).
de: Wenn möglich, positionsunabhängigen Code für ausführbare Dateien erzeugen (small mode).

en: Generate position-independent code if possible (large mode).
de: Wenn möglich, lageunabhängigen Code erzeugen (large mode).

en: Generate position-independent code if possible (small mode).
de: Wenn möglich, positionsunabhängigen Code erzeugen (small mode).

en: Generate prefetch instructions, if available, for arrays in loops.
de: Wenn verfügbar, Prefetch-Befehle für Arrays in Schleifen erzeugen.

en: Generate push/pop instructions (default).
de: Befehle push/pop generieren (Standard).

en: Generate re-entrant, PIC code.
de: Wiedereinsprungsfähigen PIC-Code erzeugen.

en: Generate reciprocals instead of divss and sqrtss.
de: Reziproke statt divss und sqrtss erzeugen.

en: Generate return instruction in naked function.
de: return-Befehl in nackter Funktion generieren.

en: Generate run time type descriptor information.
de: Informationen zur Typbeschreibung zur Laufzeit erzeugen.

en: Generate sdata references.  This is the default, unless you compile for PIC.
de: SData-Referenzen erzeugen. Dies ist die Voreinstellung, außer wenn PIC erzeugt wird.

en: Generate sections .s390_indirect_jump, .s390_indirect_call, .s390_return_reg, and .s390_return_mem to contain the indirect branch locations which have been patched as part of using one of the -mindirect-branch* or -mfunction-return* options.  The sections consist of an array of 32 bit elements. Each entry holds the offset from the entry to the patched location.
de: Abschnitte .s390_indirect_jump, .s390_indirect_call, .s390_return_reg, und .s390_return_mem erzeugen, in denen die Adressen für indirekte Sprungziele gespeichert werden, die aufgrund der Optionen -mindirect-branch* oder -mfunction-return* gepatcht wurden. Die Abschnitte bestehen aus einem Array von 32-Bit-Elementen. Jedes Element enthält den Offset vom Eintrag zu der gepatchten Adresse.

en: Generate self-relocatable code.
de: Selbstverschiebbaren Code erzeugen.

en: Generate sin, cos, sqrt for FPU.
de: sin, cos und sqrt für FPU erzeugen.

en: Generate single-precision floating-point instructions.
de: Gleitkommabefehle einfacher Genauigkeit generieren.

en: Generate software reciprocal divide and square root for better throughput.
de: Reziproke Division und Quadratwurzel in Software für besseren Durchsatz erzeugen.

en: Generate special Objective-C methods to initialize/destroy non-POD C++ ivars, if needed.
de: Wenn nötig, spezielle Objective-C-Methoden zur Initialisierung/Zerstörung von nicht-POD C++ ivars, erzeugen.

en: Generate stm/ldm instructions (default).
de: stm/ldm-Befehle erzeugen (Vorgabe).

en: Generate string extension instructions.
de: Erweiterungsbefehle für Zeichenketten einschalten.

en: Generate swap instruction.
de: swap-Befehl erzeugen.

en: Generate the integer modulo instructions.
de: Ganzzahl-Modulo-Befehle erzeugen.

en: Generate the quad word memory atomic instructions (lqarx/stqcx).
de: Atomare Quadword-Befehle zum Speicherzugriff verwenden (lqarx/stqcx).

en: Generate the quad word memory instructions (lq/stq).
de: Befehle zum Laden/Speichern von Quadwords (lq/stq) erzeugen.

en: Generate unaligned VSX load/store for inline expansion of memcpy/memmove.
de: Unausgerichtete VSX-Lade/Speicher-Befehle für Inline-Expansion von memcpy/memmove generieren.

en: Generate unaligned VSX vector pair load/store for inline expansion of memcpy/memmove.
de: Unausgerichtete VSX-Lade/Speicher-Befehle für Vektorpaare für Inline-Expansion von memcpy/memmove generieren.

en: Generate unwind tables that are exact at each instruction boundary.
de: Abwicklungstabellen erzeugen, die genau an jeder Befehlsgrenze liegen.

en: Generate v3 push25/pop25 instructions.
de: Befehle push25/pop25 für v3 erzeugen.

en: Generate vzeroupper instruction before a transfer of control flow out of the function.
de: »vzeroupper«-Befehl erzeugen, bevor der Ablauf die Funktion verlässt.

en: Generate xBPF.
de: xBPF erzeugen.

en: Generic function %qs at %L is not consistent with a specific intrinsic interface
de: Generische Funktion %qs bei %L ist nicht mit spezifischer intrinsischer Schnittstelle vereinbar

en: Generic name %qs of function %qs at %L being the same name as derived type at %L
de: Allgemeiner Name %qs der Funktion %qs bei %L ist der gleiche wie der des abgeleiteten Typs bei %L

en: Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface
de: Generisches Unterprogramm %qs bei %L ist nicht mit intrinsischer Unterprogrammschnittstelle vereinbar

en: Give branches their default cost.
de: Sprüngen ihre Standardkosten zuweisen.

en: Give external symbols a leading underscore.
de: Externen Symbolen einen führenden Unterstrich geben.

en: Global binding name %qs at %L is already being used as a %s at %L
de: Globaler Bindungs-Name %qs bei %L wird bereits als ein %s bei %L verwendet

en: Global binding name %qs at %L is already being used at %L
de: Globaler Bindungs-Name %qs bei %L wird bereits bei %L verwendet

en: Global entity %qs at %L cannot appear in a COMMON block at %L
de: Globale Entität %qs bei %L kann nicht in einem COMMON-Block bei %L vorkommen

en: Global name %qs at %L is already being used as a %s at %L
de: Globaler Name %qs bei %L wird bereits als ein %s bei %L verwendet

en: Global name %qs at %L is already being used at %L
de: Globaler Name %qs bei %L wird bereits bei %L verwendet

en: Graphite loop optimizations cannot be used (isl is not available) (%<-fgraphite%>, %<-fgraphite-identity%>, %<-floop-nest-optimize%>, %<-floop-parallelize-all%>)
de: Graphite-Schleifenoptimierungen können nicht verwendet werden (ISL ist nicht verfügbar) (%<-fgraphite%>, %<-fgraphite-identity%>, %<-floop-nest-optimize%>, %<-floop-parallelize-all%>)

en: Graphite loop optimizations cannot be used (isl is not available).
de: Graphite-Schleifenoptimierungen können nicht verwendet werden (ISL ist nicht verfügbar).

en: Guide linker to relax instructions.
de: Linker anweisen, Befehle zu lockern.

en: Handle atomic builtins that may be applied to unaligned data by calling library functions. Overrides -mtrap-unaligned-atomic.
de: Bibliotheksfunktionen aufrufen, wenn atomare eingebaute Operationen auf unausgerichteten Speicher angewendet werden können. Hebt -mtrap-unaligned-atomic auf.

en: Harden conditional branches by checking reversed conditions.
de: Bedingte Zweigen härten, indem die entgegengesetzten Bedingungen geprüft werden.

en: Harden conditionals not used in branches, checking reversed conditions.
de: Bedingungen, die nicht in den Zweigen verwendet werden, härten, indem die entgegengesetzten Bedingungen geprüft werden.

en: Hardware autoprefetcher scheduler model control flag.  Number of lookahead cycles the model looks into, at '0' only enable instruction sorting heuristic.  Disabled by default.
de: Hardware-Autoprefetcher-Scheduler-Modellsteuerung: Anzahl der Vorausschauzyklen, die das Modell untersucht, bei '0' ist nur die heuristische Sortierung von Befehlen aktiviert. Standardmäßig deaktiviert.

en: Hexadecimal constant at %L uses nonstandard X instead of Z
de: Hexadezimalkonstante bei %L verwendet Nicht-Standard X statt Z

en: Hollerith constant at %C
de: Hollerithkonstante bei %C

en: Host associated variable %qs may not be in the DATA statement at %C
de: Mit Host verbundene Variable %qs darf nicht in DATA-Anweisung bei %C stehen

en: How much can given compilation unit grow because of the inlining (in percent).
de: Wie viel die gegebene Übersetzungseinheit durch das »inline« wachsen kann (in Prozent).

en: How much can given compilation unit grow because of the interprocedural constant propagation (in percent).
de: Wie viel die gegebene Übersetzungseinheit durch die interprozedurale Konstantenweitergabe wachsen kann (in Prozent).

en: I/O register operand for '%%%c'
de: E/A-Registeroperand für »%%%c«

en: ICE: %<emit_insn%> used where %<emit_jump_insn%> needed:
de: ICE: %<emit_insn%> verwendet, wo %<emit_jump_insn%> erforderlich:

en: ID of shared library to build.
de: ID der zu bauenden Shared Library.

en: ID shared libraries and FD-PIC mode cannot be used together
de: gemeinsam genutzte ID-Bibliotheken und FD-PIC-Modus können nicht zusammen verwendet werden

en: IEEE_ARITHMETIC module at %C
de: IEEE_ARITHMETIC-Modul bei %C

en: IEEE_EXCEPTIONS module at %C
de: IEEE_EXCEPTIONS-Modul bei %C

en: IEEE_FEATURES module at %C
de: IEEE_FEATURES-Modul bei %C

en: IF clause at %L requires a scalar LOGICAL expression
de: IF-Klausel bei %L erfordert einen skalaren LOGICAL-Ausdruck

en: IF clause modifier %s at %L not appropriate for the current OpenMP construct
de: IF-Klausel-Modifizierer »%s« bei %L ist dem aktuellen OpenMP-Konstrukt nicht angemessen

en: IF clause without modifier at %L used together with IF clauses with modifiers
de: IF-Klausel ohne Modifizierer bei %L wird zusammen mit IF-Klauseln mit Modifizierert verwendet

en: IM part_ref at %C
de: IM-part_ref bei %C

en: IMPLICIT NONE (type) statement at %L following an IMPLICIT statement
de: »IMPLICIT NONE (type)«-Anweisung bei %L folgt einer IMPLICIT-Anweisung

en: IMPLICIT NONE with spec list at %C
de: IMPLICIT NONE mit Angabenliste bei %C

en: IMPLICIT statement at %C following an IMPLICIT NONE (type) statement
de: IMPLICIT-Anweisung bei %C folgt auf IMPLICIT NONE (Typ-)Anweisung

en: IMPORT statement at %C
de: IMPORT-Anweisung bei %C

en: IMPORT statement at %C only permitted in an INTERFACE body
de: IMPORT-Anweisung bei %C ist nur in einem INTERFACE-Körper erlaubt

en: IMPURE procedure at %C
de: IMPURE-Prozedur bei %C

en: INQUIRE statement at %L cannot contain both FILE and UNIT specifiers
de: INQUIRE-Anweisung bei %L kann nicht sowohl FILE- als auch UNIT-Spezifikationssymbole enthalten

en: INQUIRE statement at %L requires a PENDING= specifier with the ID= specifier
de: INQUIRE-Anweisung bei %L erfordert PENDING= mit Spezifizierung ID=

en: INQUIRE statement at %L requires either FILE or UNIT specifier
de: INQUIRE-Anweisung bei %L erfordert entweder FILE- oder UNIT-Spezifikationssymbol

en: INQUIRE statement not allowed in PURE procedure at %C
de: INQUIRE-Anweisung in PURE-Prozedur bei %C nicht erlaubt

en: INTEGER expression of %s clause at %L must be non-negative
de: INTEGER-Ausdruck von %s-Klausel bei %L darf nicht negativ sein

en: INTEGER expression of %s clause at %L must be positive
de: INTEGER-Ausdruck von %s-Klausel bei %L muss positiv sein

en: INTEGER expression of SCHEDULE clause's chunk_size at %L must be positive
de: INTEGER-Ausdruck der »chunk_size« der SCHEDULE-Klausel bei %L muss positiv sein

en: INTEGER(KIND=8) is not available for %<-fdefault-integer-8%> option
de: INTEGER(KIND=8) ist nicht verfügbar für Option %<-fdefault-integer-8%>

en: INTEGER(KIND=8) is not available for %<-finteger-4-integer-8%> option
de: INTEGER(KIND=8) ist nicht verfügbar für Option %<-finteger-4-integer-8%>

en: INTENT (%s) conflicts with INTENT(%s) at %L
de: INTENT(%s) steht mit INTENT(%s) bei %L in Konflikt

en: INTENT is not allowed inside of BLOCK at %C
de: INTENT ist in BLOCK bei %C nicht erlaubt

en: INTENT(%s) actual argument at %L might interfere with actual argument at %L.
de: Effektives Argument von INTENT(%s) bei %L könnte effektives Argument bei %L stören.

en: INTENT(IN) POINTER %qs in %s clause at %L
de: INTENT(IN) POINTER %qs in Klausel %s bei %L

en: INTENT(IN) POINTER %qs in COPYPRIVATE clause at %L
de: INTENT(IN)-Zeiger %qs in COPYPRIVATE-Klausel bei %L

en: INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic
de: Argument %1$qs bei %3$L für die reine Prozedur %2$qs ist INTENT(OUT) und darf daher nicht polymorph sein

en: INTERFACE procedure %qs at %L has the same name as the enclosing procedure
de: INTERFACE-Prozedur %qs bei %L hat denselben Namen wie die umgebende Prozedur

en: IO UNIT in %s statement at %L must be an internal file in a PURE procedure
de: IO UNIT in %s-Anweisung bei %L muss eine interne Datei in einer PURE-Prozedur sein

en: IO definition for %q+D needs an address
de: IO-Definition für %q+D erfordert eine Adresse

en: IOLENGTH tag invalid in INQUIRE statement at %C
de: IOLENGTH-Markierung in INQUIRE-Anweisung bei %C ungültig

en: IOMSG tag at %L
de: IOMSG-Markierung bei %L

en: IPA modref summary is missing in input file
de: IPA-modref-Zusammenfassung fehlt in Eingabedatei

en: IPA-SRA access verification failed
de: IPA-SRA-Zugriffs-Verifikation fehlgeschlagen

en: ISA %qs is not supported in %<target%> attribute, use %<arch=%> syntax
de: ISA %qs wird von Attribut %<target%> nicht unterstützt, verwenden Sie den Aufruf %<arch=%>

en: ISO C does not allow %<%E (expression)%>
de: ISO-C erlaubt kein %<%E (Ausdruck)%>

en: ISO C does not allow extra %<;%> outside of a function
de: ISO-C erlaubt kein zusätzliches %<;%> außerhalb einer Funktion

en: ISO C does not permit %<_Alignof%> applied to a function type
de: ISO-C erlaubt kein auf Funktionstypen angewendetes %<_Alignof%>

en: ISO C does not support %<#pragma STDC FLOAT_CONST_DECIMAL64%>
de: ISO C unterstützt nicht %<#pragma STDC FLOAT_CONST_DECIMAL64%>

en: ISO C does not support %<++%> and %<--%> on complex types
de: ISO-C unterstützt kein %<++%> und %<--%> für komplexe Typen

en: ISO C does not support %<[[]]%> attributes before C2X
de: ISO-C unterstützt %<[[]]%>-Attribute erst ab C2X

en: ISO C does not support %<__int%d%> types
de: ISO-C unterstützt die Typen %<__int%d%> nicht

en: ISO C does not support %<~%> for complex conjugation
de: ISO-C unterstützt nicht %<~%> für komplexe Konjugation

en: ISO C does not support %qs predefined identifier
de: ISO-C unterstützt den vordefinierten Bezeichner %qs nicht

en: ISO C does not support complex integer types
de: ISO-C unterstützt keine komplexen Ganzzahltypen

en: ISO C does not support decimal floating-point before C2X
de: ISO-C unterstützt dezimale Gleitkommazahlen erst ab C2X

en: ISO C does not support fixed-point types
de: ISO-C unterstützt keine Ganzzahltypen

en: ISO C does not support omitting parameter names in function definitions before C2X
de: ISO-C unterstützt das Weglassen von Parameternamen in Funktionsdefinitionen erst ab C2X

en: ISO C does not support plain %<complex%> meaning %<double complex%>
de: ISO-C unterstützt nicht %<double complex%> bedeutendes einfaches %<complex%>

en: ISO C does not support saturating types
de: ISO-C unterstützt keine sättigenden Typen

en: ISO C does not support the %<_Float%d%s%> type
de: ISO-C unterstützt den Typen %<_Float%d%s%> nicht

en: ISO C forbids %<goto *expr;%>
de: ISO-C verbietet %<goto *expr;%>

en: ISO C forbids %<return%> with expression, in function returning void
de: ISO-C verbietet %<return%> mit Ausdruck, in void zurückgebender Funktion

en: ISO C forbids an empty translation unit
de: ISO-C verbietet eine leere Quelldatei

en: ISO C forbids assignment between function pointer and %<void *%>
de: ISO-C verbietet Zuweisung zwischen Funktionszeiger und %<void *%>

en: ISO C forbids braced-groups within expressions
de: ISO-C verbietet geklammerte Gruppen innerhalb von Ausdrücken

en: ISO C forbids casting nonscalar to the same type
de: ISO-C verbietet Typkonvertierung von Nicht-Skalar auf selben Typen

en: ISO C forbids casts to union type
de: ISO-C verbietet Typkonvertierung auf union-Typ

en: ISO C forbids comparison of %<void *%> with function pointer
de: ISO-C verbietet Vergleich von %<void *%> mit Funktionszeiger

en: ISO C forbids conditional expr between %<void *%> and function pointer
de: ISO-C verbietet bedingten Ausdruck zwischen %<void *%> und Funktionszeiger

en: ISO C forbids conditional expr with only one void side
de: ISO-C verbietet bedingten Ausdruck mit nur einer void-Seite

en: ISO C forbids const or volatile function types
de: ISO-C verbietet const- oder volatile-Funktionstypen

en: ISO C forbids conversion of function pointer to object pointer type
de: ISO-C verbietet Konvertierung von Funktionszeigern in Objektzeigertyp

en: ISO C forbids conversion of object pointer to function pointer type
de: ISO-C verbietet Konvertierung von Objektzeigertypen in Funktionszeigertyp

en: ISO C forbids empty initializer braces
de: ISO-C verbietet leere Initialisierungsklammern

en: ISO C forbids forward parameter declarations
de: ISO-C verbietet Vorwärtsdeklaration für Parameter

en: ISO C forbids forward references to %<enum%> types
de: ISO-C verbietet Vorwärts-Referenzen auf %<enum%>-Typen

en: ISO C forbids initialization between function pointer and %<void *%>
de: ISO-C verbietet Initialisierung zwischen Funktionszeiger und %<void *%>

en: ISO C forbids label declarations
de: ISO-C verbietet Markendeklarationen

en: ISO C forbids member declarations with no members
de: ISO-C verbietet Elementdeklarationen ohne Elemente

en: ISO C forbids nested functions
de: ISO-C verbietet verschachtelte Funktionen

en: ISO C forbids omitting the middle term of a %<?:%> expression
de: ISO-C verbietet das Weglassen des mittleren Terms eines %<?:%>-Ausdruckes

en: ISO C forbids ordered comparisons of pointers to functions
de: ISO-C verbietet geordnete Vergleiche zwischen Zeigern auf Funktionen

en: ISO C forbids passing argument %d of %qE between function pointer and %<void *%>
de: ISO-C verbietet Übergabe des Arguments %d von %qE zwischen Funktionszeiger und %<void *%>

en: ISO C forbids qualified function types
de: ISO-C verbietet qualifizierte Funktionstypen

en: ISO C forbids return between function pointer and %<void *%>
de: ISO-C verbietet return zwischen Funktionszeiger und %<void *%>

en: ISO C forbids specifying range of elements to initialize
de: ISO-C verbietet die Angabe eines zu initialisierenden Elementebereiches

en: ISO C forbids subscripting %<register%> array
de: ISO-C verbietet, ein %<register%>-Array zu indizieren

en: ISO C forbids zero-size array
de: ISO-C verbietet Array der Größe null

en: ISO C forbids zero-size array %qE
de: ISO-C verbietet Array %qE der Größe null

en: ISO C prohibits argument conversion to union type
de: ISO-C verbietet Argumentkonvertierung in union-Typ

en: ISO C requires a named argument before %<...%>
de: ISO-C erfordert ein benanntes Argument vor %<...%>

en: ISO C restricts enumerator values to range of %<int%>
de: ISO-C beschränkt Aufzählungswerte auf Bereich von %<int%>

en: ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>
de: Attribut %qE aus ISO C++ ist nicht auf Funktionen anwendbar; wird als %<[[gnu::%E]]%> behandelt

en: ISO C++ 1998 does not support %<long long%>
de: ISO-C++ 1998 unterstützt nicht %<long long%>

en: ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations
de: ISO-C++ 1998 verbietet die Verwendung von %<extern%> bei expliziten Instanziierungen

en: ISO C++ allows bit-field attributes only before the %<:%> token
de: ISO C++ erlaubt Bitfeld-Attribute nur vor dem %<:%>-Token

en: ISO C++ did not adopt string literal operator templates taking an argument pack of characters
de: ISO C++ unterstützt keine Operatortemplates in Zeichenkettenliteralen, die eine Argumentpackung von Zeichen bekommen

en: ISO C++ does not allow %<?:%> with omitted middle operand
de: in ISO-C++ darf der mittlere Operand von %<?:%> nicht weggelassen werden

en: ISO C++ does not allow %<alignof%> with a non-type
de: ISO-C++ erlaubt kein %<alignof%> mit einem Nicht-Typ

en: ISO C++ does not allow C99 designated initializers
de: ISO-C++ erlaubt keine benannten Initialisierungen von C99

en: ISO C++ does not allow GNU designated initializers
de: ISO-C++ erlaubt keine benannten Initialisierungen (GNU)

en: ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>
de: ISO-C++ erlaubt nicht, %<%T::%D%> als %<%T::%D%> zu definieren

en: ISO C++ does not permit %<alignof%> applied to a function type
de: ISO-C++ erlaubt kein auf Funktionstypen angewendetes %<alignof%>

en: ISO C++ does not support %<__int%d%> for %qs
de: ISO-C++ unterstützt %<__int%d%> für %qs nicht

en: ISO C++ does not support plain %<complex%> meaning %<double complex%>
de: ISO-C++ unterstützt nicht, dass einfaches %<complex%> %<double complex%> bedeutet

en: ISO C++ forbids applying %<__alignof%> to an expression of function type
de: ISO-C++ verbietet Anwendung von %<__alignof%> auf einen Ausdruck mit Funktionstyp

en: ISO C++ forbids applying %<sizeof%> to an expression of function type
de: ISO-C++ verbietet Anwendung von %<sizeof%> auf einen Ausdruck mit Funktionstyp

en: ISO C++ forbids braced-groups within expressions
de: ISO-C++ verbietet Gruppen in geschweiften Klammern innerhalb von Ausdrücken

en: ISO C++ forbids calling %<::main%> from within program
de: ISO-C++ verbietet den Aufruf von %<::main%> vom Programm aus

en: ISO C++ forbids casting to an array type %qT
de: ISO-C++ verbietet Umwandlung in Arraytyp %qT

en: ISO C++ forbids comparison between pointer and integer
de: ISO-C++ verbietet Vergleich zwischen Zeiger und Ganzzahl

en: ISO C++ forbids comparison between pointer of type %<void *%> and pointer-to-function
de: ISO-C++ verbietet Vergleich zwischen Zeiger des Typs %<void *%> und Zeiger auf Funktion

en: ISO C++ forbids compound-literals
de: ISO-C++ verbietet zusammengesetzte Literale

en: ISO C++ forbids computed gotos
de: ISO-C++ verbietet berechnete Gotos

en: ISO C++ forbids conditional expression between pointer of type %<void *%> and pointer-to-function
de: ISO-C++ verbietet Bedingungsausdruck mit Zeiger des Typs %<void *%> und Zeiger auf Funktion

en: ISO C++ forbids conversion between pointer of type %<void *%> and pointer-to-function
de: ISO-C++ verbietet Umwandlung zwischen Zeiger des Typs %<void *%> und Zeiger auf Funktion

en: ISO C++ forbids converting a string constant to %qT
de: ISO C++ verbietet, eine Zeichenkettenkonstante in %qT zu konvertieren

en: ISO C++ forbids declaration of %qs with no type
de: ISO-C++ verbietet Deklaration von %qs ohne Typ

en: ISO C++ forbids decrementing a pointer of type %qT
de: ISO-C++ verbietet Verringern eines Zeigers vom Typ %qT

en: ISO C++ forbids decrementing an enum
de: ISO-C++ verbietet verringern einer Aufzählung

en: ISO C++ forbids empty unnamed enum
de: ISO-C++ verbietet leere unbenannte Aufzählung

en: ISO C++ forbids flexible array member %qs
de: ISO-C++ verbietet flexibles Arrayelement %qs

en: ISO C++ forbids flexible array members
de: ISO-C++ verbietet flexible Arrayelemente

en: ISO C++ forbids in-class initialization of non-const static member %qD
de: ISO-C++ verbietet Initialisierung des nicht konstanten statischen Elements %qD in der Klasse

en: ISO C++ forbids incrementing a pointer of type %qT
de: ISO-C++ verbietet Erhöhen eines Zeigers vom Typ %qT

en: ISO C++ forbids incrementing an enum
de: ISO-C++ verbietet erhöhen einer Aufzählung

en: ISO C++ forbids initialization of member constant %qD of non-integral type %qT
de: ISO-C++ verbietet Initialisierung der Elementkonstante %qD vom nicht eingebauten Typen %qT

en: ISO C++ forbids nested type %qD with same name as enclosing class
de: ISO-C++ verbietet geschachtelten Typen %qD mit gleichem Namen wie umschließende Klasse

en: ISO C++ forbids omitting the middle term of a %<?:%> expression
de: ISO-C++ verbietet das Auslassen des mittleren Terms eines %<?:%>-Ausdrucks

en: ISO C++ forbids taking address of function %<::main%>
de: ISO-C++ verbietet das Ermitteln der Adresse der Funktion %<::main%>

en: ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>
de: ISO-C++ verbietet das Ermitteln der Adresse einer gebundenen Elementfunktion, um einen Zeiger auf Elementfunktion zu erzeugen. Stattdessen %<&%T::%D%> verwenden

en: ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to member function.  Say %<&%T::%D%>
de: ISO-C++ verbietet das Ermitteln der Adresse einer nicht qualifizierten oder geklammerten nicht-statischen Elementfunktion, um einen Zeiger auf Elementfunktion zu erzeugen. Stattdessen %<&%T::%D%> verwenden

en: ISO C++ forbids the use of %qE on explicit instantiations
de: ISO-C++ verbietet die Verwendung von %qE bei expliziten Instanziierungen

en: ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>
de: ISO-C++ verbietet typename-Schlüssel in Template-Template-Parameter; verwenden Sie %<-std=c++17%> oder %<-std=gnu++17%>

en: ISO C++ forbids using a floating-point literal in a constant-expression
de: ISO-C++ verbietet Gleitkommaliterale in Konstanten-Ausdrücken

en: ISO C++ forbids using pointer of type %<void *%> in subtraction
de: ISO-C++ verbietet die Verwendung eines Zeigers des Typs %<void *%> in Subtraktion

en: ISO C++ forbids using pointer to a function in subtraction
de: ISO-C++ verbietet die Verwendung eines Zeigers auf eine Funktion in Subtraktion

en: ISO C++ forbids using pointer to a method in subtraction
de: ISO-C++ verbietet die Verwendung eines Zeigers auf Methode in Subtraktion

en: ISO C++ forbids variable length array
de: ISO-C++ verbietet Array variabler Länge

en: ISO C++ forbids variable length array %qD
de: ISO-C++ verbietet Array %qD variabler Länge

en: ISO C++ forbids zero-size array
de: ISO-C++ verbietet Array der Größe null

en: ISO C++ forbids zero-size array %qD
de: ISO-C++ verbietet Array %qD der Größe null

en: ISO C++ prohibits anonymous structs
de: ISO-C++ verbietet anonyme structs

en: ISO C++ prohibits overloading %<operator ?:%>
de: ISO-C++ verbietet Überladen von %<operator ?:%>

en: ISO C++ says that these are ambiguous, even though the worst conversion for the first is better than the worst conversion for the second:
de: ISO C++ besagt, dass diese mehrdeutig sind, auch wenn die schlechteste Umwandlung für das erste besser ist als die schlechteste Umwandlung für das zweite:

en: ISO C++17 does not allow %<register%> storage class specifier
de: ISO-C++17 erlaubt Speicherklassenangabe %<register%> nicht

en: ISO C++17 does not allow dynamic exception specifications
de: ISO C++17 erlaubt keine dynamischen Ausnahmespezifikationen

en: ISO C11 does not support omitting the string in %<_Static_assert%>
de: das Weglassen der Zeichenkette in %<_Static_assert%> wird von ISO C11 nicht unterstützt

en: ISO C90 does not support %<[*]%> array declarators
de: ISO-C90 unterstützt %<[*]%>-Arraydeklaratoren nicht

en: ISO C90 does not support %<_Alignas%>
de: ISO-C90 unterstützt nicht %<_Alignas%>

en: ISO C90 does not support %<_Generic%>
de: ISO-C90 unterstützt nicht %<_Generic%>

en: ISO C90 does not support %<_Noreturn%>
de: ISO-C90 unterstützt nicht %<_Noreturn%>

en: ISO C90 does not support %<_Static_assert%>
de: ISO-C90 unterstützt nicht %<_Static_assert%>

en: ISO C90 does not support %<__func__%> predefined identifier
de: ISO-C90 unterstützt den vordefinierten Bezeichner %<__func__%> nicht

en: ISO C90 does not support %<for%> loop initial declarations
de: Deklarationen im Initialisierungsteil einer %<for%>-Schleife werden von ISO C90 nicht unterstützt; ab ISO C99 geht es

en: ISO C90 does not support %<long long%>
de: ISO-C90 unterstützt nicht %<long long%>

en: ISO C90 does not support %<static%> or type qualifiers in parameter array declarators
de: ISO-C90 unterstützt kein %<static%> oder Typkennzeichner in Parameterarraydeklaratoren

en: ISO C90 does not support %qE
de: ISO-C90 unterstützt nicht %qE

en: ISO C90 does not support boolean types
de: ISO-C90 unterstützt keine booleschen Typen

en: ISO C90 does not support complex types
de: ISO-C90 unterstützt keine komplexen Typen

en: ISO C90 does not support flexible array members
de: ISO-C90 unterstützt keine flexiblen Arrays als Elemente

en: ISO C90 does not support the %<_Atomic%> qualifier
de: ISO-C90 unterstützt den %<_Atomic%>-Qualifizierer nicht

en: ISO C90 doesn%'t support unnamed structs/unions
de: ISO-C90 unterstützt keine namenlosen structs/unions

en: ISO C90 forbids array %qE whose size cannot be evaluated
de: ISO-C90 verbietet Array %qE, dessen Größe nicht ausgewertet werden kann

en: ISO C90 forbids array whose size cannot be evaluated
de: ISO-C90 verbietet Array, dessen Größe nicht ausgewertet werden kann

en: ISO C90 forbids compound literals
de: ISO-C90 verbietet zusammengesetzte Literale

en: ISO C90 forbids mixed declarations and code
de: ISO-C90 verbietet gemischte Deklarationen und Code

en: ISO C90 forbids specifying subobject to initialize
de: ISO-C90 verbietet die Angabe von zu initialisierenden Unterobjekten

en: ISO C90 forbids subscripting non-lvalue array
de: ISO-C90 verbietet, ein Nicht-L-Wert-Array zu indizieren

en: ISO C90 forbids variable length array
de: ISO-C90 verbietet Array variabler Größe

en: ISO C90 forbids variable length array %qE
de: ISO-C90 verbietet Array %qE variabler Größe

en: ISO C99 does not support %<_Alignas%>
de: ISO-C99 unterstützt nicht %<_Alignas%>

en: ISO C99 does not support %<_Generic%>
de: ISO-C99 unterstützt nicht %<_Generic%>

en: ISO C99 does not support %<_Noreturn%>
de: ISO-C99 unterstützt nicht %<_Noreturn%>

en: ISO C99 does not support %<_Static_assert%>
de: ISO-C99 unterstützt nicht %<_Static_assert%>

en: ISO C99 does not support %qE
de: ISO-C99 unterstützt nicht %qE

en: ISO C99 does not support the %<_Atomic%> qualifier
de: ISO-C99 unterstützt den %<_Atomic%>-Qualifizierer nicht

en: ISO C99 doesn%'t support unnamed structs/unions
de: ISO-C99 unterstützt keine namenlosen structs/unions

en: ISO_C_BINDING module at %C
de: Modul ISO_C_BINDING bei %C

en: ISO_FORTRAN_ENV intrinsic module at %C
de: Intrinsisches Modul ISO_FORTRAN_ENV bei %C

en: ITERATOR may not be combined with SINK at %C
de: ITERATOR bei %C kann nicht mit SINK kombiniert werden

en: ITERATOR may not be combined with SOURCE at %C
de: ITERATOR bei %C kann nicht mit SOURCE kombiniert werden

en: If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorization.
de: Wenn »-ftree-vectorize« verwendet wird, die minimale Schleifengrenze einer für Vektorisierung zu betrachtenden Schleife.

en: If -fvariable-expansion-in-unroller is used, the maximum number of times that an individual variable will be expanded during loop unrolling.
de: Wenn »-fvariable-expansion-in-unroller« verwendet wird, die Höchstzahl der Fälle, dass eine einzelne Variable während Loop-Unrolling expandiert wird.

en: If bounds remapping is specified at %L, the pointer target shall not be NULL
de: Wenn die Neuzuordnung von Grenzen bei %L angegeben wird, darf das Zeigerziel nicht NULL sein

en: If first argument of ATAN2 at %L is zero, then the second argument must not be zero
de: Wenn das erste Argument von ATAN2 bei %L 0 ist, dann darf das zweite Argument nicht 0 sein

en: If first argument of ATAN2D at %L is zero, then the second argument must not be zero
de: Wenn das erste Argument von ATAN2 bei %L 0 ist, dann darf das zweite Argument nicht 0 sein

en: If number of candidates in the set is smaller, we always try to remove unused ivs during its optimization.
de: Wenn die Anzahl der Kandidaten in der Menge kleiner ist, wird immer versucht, ungenutzte IVs während ihrer Optimierung zu entfernen.

en: If scheduling post reload, do superblock scheduling.
de: Wenn Planung nach dem Neuladen, dann Superblock-Planung.

en: Ignore 'D' in column one in fixed form.
de: »D« in Spalte eins in statischer Form ignorieren.

en: Ignore dllimport for functions.
de: Attribut dllimport für Funktionen ignorieren.

en: Ignore the normal two-level namespace; resolve symbols in command line order and do not record which library provided the resolved symbol.
de: Den normalen zweistufigen Namensraum ignorieren; Symbole in der Reihenfolge der Befehlszeile auflösen und nicht aufzeichnen, welche Bibliothek das aufgelöste Symbol bereitgestellt hat.

en: Ignore unsupported pragmas.
de: Nicht unterstützte Pragmas ignorieren.

en: Ignored, but preserved for backward compatibility.  Only 64-bit ABI is supported.
de: Tut nichts. Für Rückwärtskompatibilität erhalten.  Nur die 64-Bit-ABI wird unterstützt.

en: Ignored.
de: Ignoriert.

en: Illegal allocate-object at %C for a PURE procedure
de: Unzulässiges ALLOCATE-Objekt bei %C für eine PURE-Prozedur

en: Illegal assignment to external procedure at %L
de: Unzulässige Zuweisung an externe Prozedur bei %L

en: Illegal character in BOZ constant at %C
de: Unzulässiges Zeichen in BOZ-Konstante bei %C

en: Illegal preprocessor directive
de: Ungültige Präprozessordirektive

en: Illegal reference type at %L as EQUIVALENCE object
de: Ungültiger Referenztyp bei %L als EQUIVALENCE-Objekt

en: Illegal stride of zero at %L
de: Unzulässiger Schritt von Null bei %L

en: Illegal type in character concatenation at %L
de: Unzulässiger Typ in Zeichenverkettung bei %L

en: Image control statement %s at %C in CRITICAL block
de: Anweisung %s zur Image-Steuerung bei %C in CRITICAL-Block

en: Image control statement %s at %C in DO CONCURRENT block
de: Anweisung %s zur Image-Steuerung bei %C in DO CONCURRENT-Block

en: Image control statement %s at %C in PURE procedure
de: Anweisung %s zur Image-Steuerung bei %C in PURE-Prozedur

en: Image control statement CRITICAL at %C in DO CONCURRENT block
de: CRITICAL-Anweisung zur Image-Steuerung bei %C in DO CONCURRENT-Block

en: Image control statement CRITICAL at %C in PURE procedure
de: CRITICAL-Anweisung zur Image-Steuerung bei %C in PURE-Prozedur

en: Image control statement EVENT %s at %C in CRITICAL block
de: Anweisung »EVENT %s« zur Image-Steuerung bei %C in CRITICAL-Block

en: Image control statement EVENT %s at %C in DO CONCURRENT block
de: Anweisung »EVENT %s« zur Image-Steuerung bei %C in DO CONCURRENT-Block

en: Image control statement EVENT %s at %C in PURE procedure
de: Anweisung »EVENT %s« zur Image-Steuerung bei %C in PURE-Prozedur

en: Image control statement RETURN at %C in CRITICAL block
de: RETURN-Anweisung zur Image-Steuerung bei %C in CRITICAL-Block

en: Image control statement RETURN at %C in DO CONCURRENT block
de: PRINT-Anweisung zur Image-Steuerung bei %C in DO CONCURRENT-Block

en: Image control statement STOP at %C in CRITICAL block
de: STOP-Anweisung zur Image-Steuerung bei %C in CRITICAL-Block

en: Image control statement STOP at %C in DO CONCURRENT block
de: STOP-Anweisung zur Image-Steuerung bei %C in DO CONCURRENT-Block

en: Image control statement SYNC at %C in CRITICAL block
de: SYNC-Anweisung zur Image-Steuerung bei %C in CRITICAL-Block

en: Image control statement SYNC at %C in DO CONCURRENT block
de: SYNC-Anweisung zur Image-Steuerung bei %C in DO CONCURRENT-Block

en: Image control statement SYNC at %C in PURE procedure
de: SYNC-Anweisung zur Image-Steuerung bei %C in PURE-Prozedur

en: Imageset argument at %L must be a scalar or rank-1 INTEGER expression
de: Argument für Imageset bei %L muss Skalar oder Rang-1-INTEGER-Ausdruck sein

en: Imageset argument at %L must between 1 and num_images()
de: Argument für Imageset bei %L muss zwischen 1 und num_images() liegen

en: Implement 'in' contracts of overridden methods to be a superset of parent contract.
de: »in«-Verträge von überschriebenen Methoden als Obermenge des übergeordneten Vertrags umsetzen.

en: Implement 'in' parameters to mean scope const.
de: »in«-Parameter als »scope const« umsetzen.

en: Implement C++17 inheriting constructor semantics.
de: C++17-Semantik für erbende Konstruktoren umsetzen.

en: Implement DIP1000: Scoped pointers.
de: DIP1000 "Zeiger in Gültigkeitsbereichen" umsetzen.

en: Implement DIP1008: Allow exceptions in @nogc code.
de: DIP1008 "Ausnahmen im @nogc-Code zulassen" umsetzen.

en: Implement DIP1021: Mutable function arguments.
de: DIP1021 "Veränderbare Funktionsargumente" umsetzen.

en: Implement DIP25: Sealed references.
de: DIP25 "Versiegelte Referenzen" implementieren.

en: Implement __atomic operations via libcalls to legacy __sync functions.
de: __atomic-Operationen über Bibliotheksaufrufe alter __sync-Funktionen durchführen.

en: Implement resolution of DR 150 for matching of template template arguments.
de: Auflösung von DR 150 für Mustervergleich von Template-Template-Argumenten umsetzen.

en: Implicitly declared BIND(C) function %qs at %L may not be C interoperable
de: Implizit deklarierte BIND(C)-Funktion %qs bei %L ist möglicherweise nicht interoperabel mit C

en: Implicitly declared BIND(C) variable %qs at %L may not be C interoperable
de: Implizit deklarierte BIND(C)-Variable %qs bei %L könnte nicht C-kompatibel sein

en: Implicitly declared function %s used in !$OMP DECLARE REDUCTION at %L
de: Implizit deklarierte Funktion %s wird in !$OMP DECLARE REDUCTION bei %L verwendet

en: Implicitly declared subroutine %s used in !$OMP DECLARE REDUCTION at %L
de: Implizit deklariertes Unterprogramm %s wird in !$OMP DECLARE REDUCTION bei %L verwendet

en: Implicitly declared variable %qs at %L may not be C interoperable but it is a dummy argument to the BIND(C) procedure %qs at %L
de: Implizit deklarierte Variable %qs bei %L könnte nicht C-kompatibel sein, ist aber ein Scheinargument für BIND(C)-Prozedur %qs bei %L

en: Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type
de: Implizit angegebener PARAMETER %qs bei %L passt nicht zu früherem IMPLICIT-Typ

en: Implied SAVE for module variable %qs at %L, needed due to the default initialization
de: Einbezogenes SAVE für Modulvariable %qs bei %L, benötigt wegen Standardinitialisierung

en: Implied-shape array at %L
de: Feld mit impliziter Form bei %L

en: Improve GCC's ability to track column numbers in large source files, at the expense of slower compilation.
de: Verbesserung der Fähigkeit des GCC, Spaltennummern in großen Quelldateien zu verfolgen, auf Kosten einer langsameren Kompilierung.

en: Impure function %qs at %L might not be evaluated
de: Unreine Funktion %qs bei %L wird möglicherweise nicht ausgewertet

en: Impure function at %L might not be evaluated
de: Unreine Funktion bei %L wird möglicherweise nicht ausgewertet

en: In %s at %L procedures must be all FUNCTIONs as the generic name is also the name of a derived type
de: In %s bei %L müssen alle Prozeduren auch FUNCTIONs sein, da der allgemeine Name auch der Name des abgeleiteten Typs ist

en: In %s at %L procedures must be either all SUBROUTINEs or all FUNCTIONs
de: In %s bei %L müssen alle Prozeduren entweder SUBROUTINE oder FUNCTION sein

en: 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.
de: In C++ bedeutet ungleich Null die Warnung vor veralteter Umwandlung von Zeichenkettenliteralen in »char *«. In C erfolgt eine ähnliche Warnung, nur ist die Umwandlung nat. laut ISO-C-Standard nicht veraltet.

en: In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s
de: In Fortran 2003 ist der COMMON-Block %qs bei %L ein globaler Bezeichner und muss daher den selben Bindungsnamen haben wie der gleichbenannte COMMON-Block bei %L: %s vs. %s

en: In SSA-PRE optimization on trees, enable partial-partial redundancy elimination.
de: In SSA-PRE-Optimierungen auf Bäumen Teils-Teils-Redundanz eliminieren.

en: In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection.
de: In einem reinen Unterprogramm darf ein INTENT(IN)-Dummy-Argument nicht als »expr« bei %L einer intrinsischen Zuweisungsanweisung verwendet werden, in der die Variable von einem abgeleiteten Typ ist, wenn der abgeleitete Typ eine Zeigerkomponente auf irgendeiner Ebene der Komponentenauswahl hat.

en: In call to %qs at %L, type mismatch in argument %qs; pass %qs to %qs
de: Im Aufruf von %qs bei %L ist eine Typunverträglichkeit bei Argument %qs; %s wurde an %s übergeben

en: In constructor %qs
de: In Konstruktor %qs

en: In copy constructor %qs
de: In Kopierkonstruktor %qs

en: In destructor %qs
de: In Destruktor %qs

en: In file included from
de: In Datei, eingebunden von

en: In function %qs
de: In Funktion %qs

en: In lambda function
de: In Lambda-Funktion

en: In member function %qs
de: In Elementfunktion %qs

en: In module
de: In Modul

en: In module imported at
de: In Modul, importiert bei

en: In static member function %qs
de: In statischer Elementfunktion %qs

en: Include directory %qs: %s
de: Include-Verzeichnis %qs: %s

en: Included file %qs is not a regular file
de: Die eingebundene Datei %qs ist keine reguläre Datei

en: Incompatible allocate-object at %C for CHARACTER type-spec at %L
de: Inkompatibles ALLOCATE-Objekt bei %C für CHARACTER-Typspezifikation bei %L

en: Incompatible derived type in PARAMETER at %L
de: Unverträglicher abgeleiteter Typ in PARAMETER bei %L

en: Incompatible initialization between a derived type entity and an entity with %qs type at %C
de: Inkompatible Initialisierung zwischen einer abgeleiteten Typentität und einer Entität mit Typ %qs bei %C

en: Incompatible ranks %d and %d in assignment at %L
de: Unverträgliche Ränge %d und %d in Zuweisung bei %L

en: Incompatible ranks in %s (%d and %d) at %L
de: Unverträgliche Ränge in %s (%d und %d) bei %L

en: Incompatible types in DATA statement at %L; attempted conversion of %s to %s
de: Unverträgliche Typen in DATA-Anweisung bei %L; versuchte Umwandlung von %s an %s

en: Incompatible typespec for array element at %L
de: Unverträgliche Typangabe für Feldelement bei %L

en: Incompatible use of TILE and COLLAPSE at %L
de: Unverträgliche Verwendung von TILE und COLLAPSE bei %L

en: Inconsistent equivalence rules involving %qs at %L and %qs at %L
de: Inkonsistente Äquivalenzregeln mit %qs bei %L und %qs bei %L

en: Inconsistent internal state: No location in expression near %L
de: Interne Compilerwarnung: No location in expression near %L

en: Inconsistent internal state: No location in statement
de: Interne Compilerwarnung: Inconsistent internal state: No location in statement

en: Inconsistent ranks for operator at %%L and %%L
de: Ränge für Operator bei %%L und %%L stimmen nicht überein

en: Incorrect EH edge %i->%i
de: Interner Compilerfehler: Incorrect EH edge %i->%i

en: Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld
de: Falsche Ausdehnung in Argument B in MATMUL-Intrinsic in Dimension 1: ist %ld, sollte %ld sein

en: Increase the IEEE compliance for floating-point comparisons.
de: IEEE-Befolgung für Gleitkommavergleiche erhöhen.

en: Index in dimension %d is out of bounds at %L
de: Index in Dimension %d ist außerhalb der Grenzen bei %L

en: Index variable %qs not definable as INTENT(INOUT) argument at %L in procedure %qs called from within DO loop at %L
de: Indexvariable %qs ist nicht als INTENT(INOUT)-Argument definierbar bei %L in Prozedur %qs, die aus der DO-Schleife bei %L heraus aufgerufen wird

en: Index variable %qs not definable as INTENT(INOUT) argument at %L in subroutine %qs called from within DO loop at %L
de: Indexvariable %qs ist nicht als INTENT(INOUT)-Argument definierbar bei %L in Unterroutine %qs, die aus der DO-Schleife bei %L heraus aufgerufen wird

en: Index variable %qs redefined at %L in procedure %qs called from within DO loop at %L
de: Indexvariable %qs neudefiniert bei %L in Prozedur %qs, aufgerufen aus der DO-Schleife bei %L

en: Index variable %qs set to undefined as INTENT(OUT) argument at %L in procedure %qs called from within DO loop at %L
de: Indexvariable %qs wird auf undefiniert als INTENT(OUT)-Argument bei %L in Prozedur %qs gesetzt, wird aus der DO-Schleife bei %L aufgerufen

en: Index variable %qs set to undefined as INTENT(OUT) argument at %L in subroutine %qs called from within DO loop at %L
de: Indexvariable %qs wird auf undefiniert gesetzt als INTENT(OUT)-Argument bei %L in Unterroutine %qs, die aus der DO-Schleife bei %L heraus aufgerufen wird

en: Indicate presence of a processor erratum.
de: Auf Anwesenheit von Prozessorfehlern hinweisen.

en: Indicate priority for r0..r3 / r12..r15 with TARGET_REGISTER_PRIORITY.
de: Priorität für r0..r3 / r12..r15 mit TARGET_REGISTER_PRIORITY ausdrücken.

en: Inequality comparison for %s at %L
de: Vergleich auf Ungleichheit für %s bei %L

en: Inhibit the use of hardware floating point instructions.
de: Verwendung von Hardware-Gleitkommabefehlen unterdrücken.

en: Initialization at %C is not allowed in a PURE procedure
de: Initialisierung bei %C ist in PURE-Prozedur nicht erlaubt

en: Initialization at %C isn't for a pointer variable
de: Initialisierung bei %C ist nicht für eine Zeigervariable

en: Initialization of allocatable component at %C is not allowed
de: Initialisierung einer allozierbaren Komponente bei %C ist nicht erlaubt

en: Initialization of pointer at %C is not allowed in a PURE procedure
de: Initialisierung des Zeigers bei %C ist nicht in einer PURE-Prozedur erlaubt

en: Initialization of structure component with a HOLLERITH constant at %L is not allowed
de: Initialisierung einer Strukturkomponente mit einer HOLLERITH-Konstante bei %L ist nicht erlaubt

en: Initialization of variable at %C is not allowed in a PURE procedure
de: Initialisierung einer Variablen bei %C ist in einer PURE-Prozedur nicht erlaubt

en: Initialization string at %L was truncated to fit the variable (%ld/%ld)
de: Initialisierungszeichenkette bei %L wurde abgeschnitten, um zur Variable zu passen (%ld/%ld)

en: Initialize components of derived type variables according to other init flags.
de: Komponenten von abgeleiteten Typvariablen gemäß anderer init-Schalter initialisieren.

en: Initialize local variables to zero (from g77).
de: Lokale Variablen auf Null initialisieren (von g77).

en: Initialize ptx registers.
de: PTX-Register initialisieren.

en: Initialized symbol %qs at %C can only be COMMON in BLOCK DATA
de: Initialisiertes Symbol %qs bei %C kann nur COMMON in BLOCK DATA sein

en: Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks
de: Initialisierte Variable %qs bei %L ist in leerem COMMON, aber Initialisierung ist nur in benannten COMMON-Blöcken erlaubt

en: Initializer not allowed for PARAMETER %qs at %C
de: Initialisierer nicht erlaubt für PARAMETER %qs bei %C

en: Initializing already initialized variable at %C
de: Initialisierung einer bereits initialisierten Variablen bei %C

en: Inline __atomic operations when a lock free instruction sequence is available.
de: __atomic-Operationen »inline« erzeugen, wenn Lock-freie Befehlssequenz verfügbar ist.

en: Inline all known string operations.
de: Alle bekannten Zeichenkettenoperationen einbetten (inline).

en: Inline code to invalidate instruction cache entries after setting up nested function trampolines.
de: Code inline einbetten, um Befehlscache nach dem Aufsetzen verschachtelter Funktionstrampoline zu verwerfen.

en: Inline constants if it can be done in 2 insns or less.
de: Konstanten einbetten, wenn es mit 2 Befehlen oder weniger geht.

en: Inline memset/memcpy string operations, but perform inline version only for small blocks.
de: Zeichenkettenoperationen memset/memcpy als »inline« einfügen, aber Inline-Version nur für kleine Blöcke durchführen.

en: Inline recursively only when the probability of call being executed exceeds the parameter.
de: Rekursives inlinen nur, wenn die Wahrscheinlichkeit des Aufrufs den Parameter überschreitet.

en: Inquiry parameter cannot appear in a data-stmt-object-list at %C
de: Befragungsparameter darf nicht in einer data-stmt-object-list bei %C vorkommen

en: Insert ENDBR instruction at function entry only via cf_check attribute for CET instrumentation.
de: ENDBR-Befehl beim Betreten einer Funktion nur via cf_check-Attribut für CET-Instrumentierung einfügen.

en: Insert NOP instructions at each function entry.
de: In jedem Funktionsprolog NOP-Befehle erzeugen.

en: Insert arc-based program profiling code.
de: Arc-basierten Programm-Profilierungscode einfügen.

en: Insert code to probe each page of stack space as it is allocated to protect from stack-clash style attacks.
de: Code einfügen, der jede Speicherseite des Stapels bei der Allokation antestet, um vor Angriffen basierend auf Überschneidungen zu schützen.

en: Insert code to profile values of expressions.
de: Code einfügen, um Ausdrücke zu profilen.

en: Insert relax hint for linker to do relaxation.
de: Lockerungs-Hinweis an Linker übergeben, um Lockerung durchzuführen.

en: Insert stack checking code into the program.  Same as -fstack-check=specific.
de: Code zur Stapelprüfung in das Programm einfügen. Dasselbe wie -fstack-check=specific.

en: Instruction accounted for function prologue, epilogue and other overhead.
de: Anzahl der Maschinenbefehle, die für Funktionsprolog, -Epilog und sonstigen Overhead veranschlagt werden.

en: Instruction accounted for function thunk overhead.
de: Anzahl der Maschinenbefehle, die für Thunk-Overhead in Funktionen veranschlagt werden.

en: Instructions number above which STFL stall penalty can be compensated.
de: Zahl der Befehle, bei deren Überschreitung die STFL-Stall-Strafe kompensiert werden kann.

en: Instrument function entry and exit with profiling calls.
de: Ein- und Austritte von Funktionen beim Profilieren von Aufrufen verwenden.

en: Instrument function exit in instrumented functions with __fentry__.
de: Verlassen von Funktionen mit __fentry__ instrumentieren, in instrumentierten Funktionen.

en: Instrument only functions from files whose name does not match any of the regular expressions (separated by semi-colons).
de: Funktionen nur aus Dateien instrumentieren, deren Namen zu keinem der regulären Ausdrücke passen (durch Semikolon getrennt).

en: Instrument only functions from files whose name matches any of the regular expressions (separated by semi-colons).
de: Funktionen nur aus Dateien instrumentieren, deren Namen zu einem der regulären Ausdrücke passen (durch Semikolon getrennt).

en: Integer division truncated to constant %qs at %L
de: Ganzzahldivision bei %2$L zu Konstante %1$qs abgeschnitten

en: Integer expression required at %C
de: Ganzzahlausdruck erforderlich bei %C

en: Integer id (N) of fabsd custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fabsd«.

en: Integer id (N) of fabss custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fabss«.

en: Integer id (N) of faddd custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »faddd«.

en: Integer id (N) of fadds custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fadds«.

en: Integer id (N) of fatand custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fatand«.

en: Integer id (N) of fatans custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fatans«.

en: Integer id (N) of fcmpeqd custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fcmpeqd«.

en: Integer id (N) of fcmpeqs custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fcmpeqs«.

en: Integer id (N) of fcmpged custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fcmpged«.

en: Integer id (N) of fcmpges custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fcmpges«.

en: Integer id (N) of fcmpgtd custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fcmpgtd«.

en: Integer id (N) of fcmpgts custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fcmpgts«.

en: Integer id (N) of fcmpled custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fcmpled«.

en: Integer id (N) of fcmples custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fcmples«.

en: Integer id (N) of fcmpltd custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fcmpltd«.

en: Integer id (N) of fcmplts custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fcmplts«.

en: Integer id (N) of fcmpned custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fcmpned«.

en: Integer id (N) of fcmpnes custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fcmpnes«.

en: Integer id (N) of fcosd custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fcosd«.

en: Integer id (N) of fcoss custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fcoss«.

en: Integer id (N) of fdivd custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fdivd«.

en: Integer id (N) of fdivs custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fdivs«.

en: Integer id (N) of fexpd custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fexpd«.

en: Integer id (N) of fexps custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fexps«.

en: Integer id (N) of fextsd custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fextsd«.

en: Integer id (N) of fixdi custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fixdi«.

en: Integer id (N) of fixdu custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fixdu«.

en: Integer id (N) of fixsi custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fixsi«.

en: Integer id (N) of fixsu custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fixsu«.

en: Integer id (N) of floatid custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »floatid«.

en: Integer id (N) of floatis custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »floatis«.

en: Integer id (N) of floatud custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »floatud«.

en: Integer id (N) of floatus custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »floatus«.

en: Integer id (N) of flogd custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »flogd«.

en: Integer id (N) of flogs custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »flogs«.

en: Integer id (N) of fmaxd custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fmaxd«.

en: Integer id (N) of fmaxs custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fmaxs«.

en: Integer id (N) of fmind custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fmind«.

en: Integer id (N) of fmins custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fmins«.

en: Integer id (N) of fmuld custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fmuld«.

en: Integer id (N) of fmuls custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fmuls«.

en: Integer id (N) of fnegd custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fnegd«.

en: Integer id (N) of fnegs custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fnegs«.

en: Integer id (N) of frdxhi custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »frdxhi«.

en: Integer id (N) of frdxlo custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »frdxlo«.

en: Integer id (N) of frdy custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »frdy«.

en: Integer id (N) of fsind custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fsind«.

en: Integer id (N) of fsins custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fsins«.

en: Integer id (N) of fsqrtd custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fsqrtd«.

en: Integer id (N) of fsqrts custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fsqrts«.

en: Integer id (N) of fsubd custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fsubd«.

en: Integer id (N) of fsubs custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fsubs«.

en: Integer id (N) of ftand custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »ftand«.

en: Integer id (N) of ftans custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »ftans«.

en: Integer id (N) of ftruncds custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »ftruncds«.

en: Integer id (N) of fwrx custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fwrx«.

en: Integer id (N) of fwry custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »fwry«.

en: Integer id (N) of round custom instruction.
de: Ganzzahlige ID (N) des spezifischen Befehls »round«.

en: Integer kind %d at %C not available
de: Ganzzahlart %d bei %C nicht verfügbar

en: Integer outside symmetric range implied by Standard Fortran at %L
de: Ganzzahl außerhalb des symmetrischen Bereichs wegen Standard-Fortran bei %L

en: Integer outside symmetric range implied by Standard Fortran converting %s to %s at %L
de: Ganzzahl außerhalb des symmetrischen Bereiches wegen Standard-Fortran-Konvertierung von %s in %s bei %L

en: Integer overflow when calculating the amount of memory to allocate
de: Ganzzahlüberlauf bei der Berechnung des zu reservierenden Speichers

en: Integer too big for its kind at %C. This check can be disabled with the option %<-fno-range-check%>
de: Ganzzahl zu groß für ihre Art bei %C. Diese Überprüfung kann mit der Option %<-fno-range-check%> ausgeschaltet werden

en: Integer too large at %C
de: Ganzzahl bei %C zu groß

en: Integer value too large in expression at %C
de: Ganzzahlwert zu groß in Ausdruck bei %C

en: Integrate functions into their callers when code size is known not to grow.
de: Funktionen in ihre Aufrufer einfügen, wenn Codegröße als nicht wachsend bekannt ist.

en: Integrate functions not declared "inline" into their callers when profitable.
de: Nicht als »inline« deklarierte Funktionen in ihre Aufrufer einfügen, wenn gewinnbringend.

en: Integrate functions only required by their single caller.
de: Nur an einer Stelle aufgerufene Funktionen in ihre Aufrufer einfügen.

en: Intel MCU psABI isn%'t supported in %s mode
de: Intel-MCU-psABI wird im %s-Modus nicht unterstützt

en: Interchanging loops at %L
de: Schleifen bei %L werden getauscht

en: Interface %qs at %L is declared in a later PROCEDURE statement
de: Schnittstelle %qs bei %L ist in späterer PROCEDURE-Anweisung deklariert

en: Interface %qs at %L may not be a statement function
de: Schnittstelle %qs bei %L darf keine Anweisungsfunktion sein

en: Interface %qs at %L may not be generic
de: Schnittstelle %qs bei %L kann nicht allgemein sein

en: Interface %qs at %L must be explicit
de: Schnittstelle %qs bei %L muss explizit sein

en: Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s
de: Unpassende Schnittstelle für Prozedurzeiger-Komponente %qs in Strukturkonstruktor bei %L: %s

en: Interface mismatch in dummy procedure %qs at %L: %s
de: Schnittstelle in Scheinprozedur %qs bei %L passt nicht: %s

en: Interface mismatch in global procedure %qs at %L: %s
de: Schnittstelle in globaler Prozedur %qs bei %L passt nicht: %s

en: Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine
de: Unpassende Schnittstellen bei Zuweisung des Prozedurzeigers bei %L: %qs ist kein Unterprogramm

en: Interface mismatch in procedure pointer assignment at %L: %s
de: Unpassende Schnittstellen bei Zuweisung des Prozedurzeigers bei %L: %s

en: Interface must be specified for DEFERRED binding at %C
de: Schnittstelle muss für DEFERRED-Bindung bei %C angegeben werden

en: Interface-name expected after %<(%> at %C
de: Schnittstellenname nach %<(%> bei %C erforderlich

en: Internal file at %L with namelist
de: Interne Datei bei %L mit Namensliste

en: Internal procedure %qs in %s at %L
de: Interne Prozedur %qs in %s bei %L

en: Internal procedure %qs is invalid in procedure pointer assignment at %L
de: Interne Prozedur %qs ist in Zuweisung des Prozedurzeigers bei %L ungültig

en: Internal procedure %qs is invalid in procedure pointer initialization at %L
de: Interne Prozedur %qs ist in Initialisierung des Prozedurzeigers bei %L ungültig

en: Internal procedure %qs is used as actual argument at %L
de: Interne Prozedur %qs wird als effektives Argument bei %L verwendet

en: Internal unit with vector subscript at %L
de: Interne Einheit mit Vektor-Index bei %L

en: Interpret any INTEGER(4) as an INTEGER(8).
de: Jeden INTEGER(4) als INTEGER(8) interpretieren.

en: Interpret any REAL(4) as a REAL(10).
de: Jeden REAL(4) als REAL(10) interpretieren.

en: Interpret any REAL(4) as a REAL(16).
de: Jeden REAL(4) als REAL(16) interpretieren.

en: Interpret any REAL(4) as a REAL(8).
de: Jeden REAL(4) als REAL(8) interpretieren.

en: Interpret any REAL(8) as a REAL(10).
de: Jeden REAL(8) als REAL(10) interpretieren.

en: Interpret any REAL(8) as a REAL(16).
de: Jeden REAL(8) als REAL(16) interpretieren.

en: Interpret any REAL(8) as a REAL(4).
de: Jeden REAL(8) als REAL(4) interpretieren.

en: Interpret imaginary, fixed-point, or other gnu number suffix as the corresponding number literal rather than a user-defined number literal.
de: Imaginäre, Festkomma, oder andere GNU-Zahlenauffixe als das korrespondieren Zahlenliteral statt eines benutzerdefinierten Zahlenliterals interpretieren.

en: Interrupt Service Routines cannot be coded in Thumb-1 mode
de: Interrupt-Dienst-Routinen können nicht im »Thumb-1«-Modus codiert werden

en: Intersperse literal pools with code in the text section.
de: Im »text«-Abschnitt Literalbereiche mit Codebereichen verweben.

en: Interval in which to probe the stack expressed as a power of two in bytes.
de: Intervall, in dem der Stack geprüft wird, als Zweierpotenz in Bytes ausgedrückt.

en: Interval overlap of %<-fdbg-cnt=%s%>: [%u, %u] and [%u, %u]
de: Intervallüberlappung von %<-fdbg-cnt=%s%>: [%u, %u] und [%u, %u]

en: Intrinsic %qs (%s) used at %L
de: Intrinsisches %qs (%s) wird bei %L verwendet

en: Intrinsic %qs at %L cannot have an initializer
de: Intrinsisches %qs bei %L kann keine Initialisierung haben

en: Intrinsic %qs at %L is invalid in procedure pointer assignment
de: Eingebautes %qs bei %L ist in Zuweisung des Prozedurzeigers ungültig

en: Intrinsic %qs at %L is not allowed as an actual argument
de: Eingebautes %qs bei %L ist nicht als effektives Argument erlaubt

en: Intrinsic %qs at %L must have at least two arguments
de: Das intrinsische %qs bei %L muss mindestens zwei Argumente haben

en: Intrinsic TRANSFER at %L has partly undefined result: source size %ld < result size %ld
de: Intrinsisches TRANSFER bei %L hat teilweise undefiniertes Ergebnis: Quellgröße %ld < Ergebnisgröße %ld

en: Intrinsic function %qs (%d) not recognized
de: Intrinsische Funktion %qs (%d) nicht erkannt

en: Intrinsic function %qs at %L is not permitted in an initialization expression
de: Intrinsische Funktion %qs bei %L ist nicht in einem Initialisierungs-Ausdruck erlaubt

en: Intrinsic function %s at %L is not permitted for CO_REDUCE
de: Intrinsische Funktion »%s« bei %L ist nicht für CO_REDUCE erlaubt

en: Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer
de: Intrinsische Funktion NULL bei %L kann kein tatsächliches Argument für STORAGE_SIZE sein, da es einen disassoziierten Zeiger zurückgibt

en: Intrinsic operator %qs referenced at %L not found in module %qs
de: Bei %2$L referenzierter intrinsischer Operator %1$qs nicht im Modul %3$qs gefunden

en: Intrinsic operator interface at %L must be a FUNCTION
de: Schnittstelle des intrinsischen Operators bei %L muss eine FUNCTION sein

en: Intrinsic procedure %qs not allowed in PROCEDURE statement at %L
de: Intrinsische Prozedur %qs ist in PROCEDURE-Anweisung bei %L nicht erlaubt

en: Intrinsic procedure at %L cannot be a MODULE PROCEDURE
de: Intrinsische Prozedur bei %L kann keine MODULE PROCEDURE sein

en: Intrinsic subroutine %qs at %L shall not have a type specifier
de: Intrinsisches Unterprogramm %qs bei %L darf keine Typspezifizierung haben

en: Intrinsic symbol specified in !$ACC ROUTINE ( NAME ) at %C marked with incompatible GANG, WORKER, or VECTOR clause
de: Intrinsisches Symbol wurde bei %C in »!$ACC ROUTINE ( NAME )« angegeben und mit der inkompatiblen GANG, WORKER oder VECTOR-Klausel markiert

en: Intrinsic symbol specified in !$ACC ROUTINE ( NAME ) at %C marked with incompatible NOHOST clause
de: Intrinsisches Symbol wurde bei %C in »!$ACC ROUTINE ( NAME )« angegeben und mit der inkompatiblen NOHOST-Klausel markiert

en: Invalid BOZ literal constant used in subscript at %C
de: Ungültige BOZ-Literalkonstante, die bei %C im Feldindex verwendet wird

en: Invalid C identifier in NAME= specifier at %C
de: Ungültiger C-Name in NAME=-Spezifizierung bei %C

en: Invalid Hollerith constant at %L contains a wide character
de: Ungültige Hollerithkonstante bei %L enthält ein Wide-Zeichen

en: Invalid Hollerith constant: %L must contain at least one character
de: Ungültige Hollerithkonstante: %L muss mindestens ein Zeichen enthalten

en: Invalid Hollerith constant: Integer kind at %L should be default
de: Ungültige Hollerithkonstante: Ganzzahlart bei %L sollte Standard sein

en: Invalid KIND parameter of %s at %L
de: Ungültiger KIND-Parameter von %s bei %L

en: Invalid NAME %qs in !$ACC ROUTINE ( NAME ) at %C
de: Ungültiger NAME %qs in »!$ACC ROUTINE ( NAME )« bei %C

en: Invalid NULL at %L
de: Ungültiges NULL bei %L

en: Invalid argument to !$ACC WAIT at %C
de: Ungültiges Argument für »!$ACC WAIT« bei %C

en: Invalid association target at %C
de: Ungültiges Zuordnungsziel bei %C

en: Invalid character %<$%> at %L. Use %<-fdollar-ok%> to allow it as an extension
de: Ungültiges Zeichen %<$%> bei %L. %<-fdollar-ok%> verwenden, um es als Erweiterung zuzulassen

en: Invalid character %qc in variable name at %C
de: Ungültiges Zeichen %qc in Variablenname bei %C

en: Invalid character 0x%s at %C
de: Ungültiges Zeichen 0x%s bei %C

en: Invalid character in name at %C
de: Ungültiges Zeichen in Name bei %C

en: Invalid character(s) in ELSE statement after %C
de: Ungültige(s) Zeichen in ELSE-Anweisung nach %C

en: Invalid clause in module with !$ACC DECLARE at %L
de: Ungültige Klausel in Modul mit »!$ACC DECLARE« bei %L

en: Invalid codimension %d at %C, only %d codimensions exist
de: Ungültige Codimension %d bei %C, nur %d Codimensionen existieren

en: Invalid context for NULL () intrinsic at %L
de: Ungültiger Kontext für NULL()-Zeiger bei %L

en: Invalid context for NULL() pointer at %%L
de: Ungültiger Kontext für NULL()-Zeiger bei %%L

en: Invalid exponent-letter %<q%> in real-literal-constant at %C
de: Ungültiger Exponent-Buchstabe %<q%> in literaler Realkonstante bei %C

en: Invalid expression after %<%s(%> at %C
de: Ungültiger Ausdruck nach %<%s%> bei %C

en: Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure
de: Ungültiger Ausdruck im Strukturkonstruktor für Zeigerkomponente %qs bei %L in PURE-Prozedur

en: Invalid form of PROGRAM statement at %C
de: Ungültige Form der PROGRAM-Anweisung bei %C

en: Invalid form of WRITE statement at %L, UNIT required
de: Ungültige Form der WRITE-Anweisung bei %L, UNIT erforderlich

en: Invalid form of array reference at %C
de: Ungültige Form der Feldreferenz bei %C

en: Invalid form of coarray reference at %C
de: Ungültige Form der Coarray-Referenz bei %C

en: Invalid image number %d in SYNC IMAGES
de: Ungültige Bildanzahl %d in SYNC IMAGES

en: Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L
de: Ungültiger Initialisierungsausdruck für ALLOCATABLE-Komponente %qs in Strukturkonstruktor bei %L

en: Invalid initializer %s in Data statement at %C
de: Ungültige Initialisierung %s in Data-Anweisung bei %C

en: Invalid keyword %qs in %qs intrinsic function at %L
de: Ungültiges Schlüsselwort %qs in intrinsischer Funktion %qs bei %L

en: Invalid kind %d for CHARACTER constant at %C
de: Ungültige Art %d für CHARACTER-Konstante bei %C

en: Invalid kind for %s at %L
de: Ungültige Art für %s bei %L

en: Invalid mixing of IEEE 128-bit and IBM 128-bit floating point types
de: Unerlaubtes Mischen von IEEE-128-Bit- und IBM-128-Bit-Gleitkommatypen

en: Invalid old style initialization for derived type component at %C
de: Ungültige Initialisierung im alten Stil für abgeleitete Typkomponente bei %C

en: Invalid operator for !$OMP DECLARE REDUCTION %s at %L
de: Ungültiger Operator für !$OMP DECLARE REDUCTION %s bei %L

en: Invalid procedure argument at %L
de: Ungültiges Argument für Prozedur bei %L

en: Invalid procedure pointer assignment at %L
de: Ungültige Zuweisung eines Prozedurzeigers bei %L

en: Invalid range %s in option %s
de: Ungültiger Bereich %s in Option %s

en: Invalid real kind %d at %C
de: Unzulässige Realart %d bei %C

en: Invalid substring in data-implied-do at %L in DATA statement
de: Ungültige Teilzeichenkette in data-implied-do in DATA-Anweisung bei %L

en: Invalid type-spec at %C
de: Ungültiges Typspezifikation bei %C

en: Invalid use of BOZ literal constant at %L
de: Ungültige Verwendung der BOZ-Literalkonstante bei %L

en: Invalid value for %s specification at %C
de: Ungültiger Wert für Spezifikation %s bei %C

en: Issue a note when diagnostics are deduplicated.
de: Einen Hinweis ausgeben, wenn doppelte Diagnosemeldungen zusammengefasst werden.

en: Issue debug information for compiler-generated auxiliary variables.
de: Fehlersuche-Informationen für compilergenerierte Hilfsvariablen ausgeben.

en: Issue warnings needed for strict compliance to the standard.
de: Für strikte Standardbefolgung benötigte Warnungen ausgeben.

en: Iterator step at %L cannot be zero
de: Iteratorschritt bei %L kann nicht Null sein

en: Jump targets are aligned to this power of 2.
de: Sprungziele werden an dieser Potenz von 2 ausgerichtet.

en: Junk after ASSOCIATE statement at %C
de: Ausschuss hinter ASSOCIATE-Anweisung bei %C

en: Junk after CALL at %C
de: Ausschuss hinter CALL bei %C

en: Junk after GENERIC binding at %C
de: Ausschuss hinter GENERIC-Bindung bei %C

en: Junk after MAP statement at %C
de: Ausschuss hinter MAP-Anweisung bei %C

en: Junk after UNION statement at %C
de: Ausschuss hinter UNION-Anweisung bei %C

en: Junk after non-nested STRUCTURE statement at %C
de: Ausschuss hinter unverschachtelter STRUCTURE-Anweisung bei %C

en: Just generate unwind tables for exception handling.
de: Einfach Abwicklungstabellen für Ausnahmebehandlung erzeugen.

en: Just use icc0/fcc0.
de: Einfach icc0/fcc0 verwenden.

en: KIND attribute at %C in a STRUCTURE definition
de: KIND-Attribut bei %C in einer STRUCTURE-Definition

en: KIND attribute at %C in a TYPE definition
de: KIND-Attribut bei %C in einer TYPE-Definition

en: KIND parameter of %s at %L must be an initialization expression
de: KIND-Parameter von %s bei %L muss ein Initialisierungsausdruck sein

en: KIND part_ref at %C
de: KIND-part_ref bei %C

en: Keyword %qs at %C has already appeared in the current argument list
de: Schlüsselwort %qs bei %C bereits in aktueller Argumentliste aufgetreten

en: Keyword argument %qs at %L is already associated with another actual argument
de: Schlüsselwort-Argument %qs bei %L ist bereits mit einem anderen effektiven Argument verbunden

en: Keyword argument %qs at %L is invalid in a statement function
de: Schlüsselwort-Argument %qs bei %L darf innerhalb einer Anweisungsfunktion nicht auftauchen

en: Keyword argument %qs at %L is not in the procedure
de: Schlüsselwort-Argument %qs bei %L ist nicht in der Prozedur

en: Keyword argument %qs at %L is not in the procedure; did you mean %qs?
de: Schlüsselwort-Argument %qs bei %L ist nicht in der Prozedur; meinen Sie %qs?

en: Keyword argument requires explicit interface for procedure %qs at %L
de: Schlüsselwort-Argument erfordert explizite Schnittstelle für Prozedur %qs bei %L

en: Keyword argument requires explicit interface for procedure pointer component %qs at %L
de: Schlüsselwortargument erfordert explizite Schnittstelle für Prozedurzeigerkomponente %qs bei %L

en: Kind %d is not supported for CHARACTER at %C
de: Die Art %d wird für CHARACTER bei %C nicht unterstützt

en: Kind %d not supported for type %s at %C
de: Die Art %d wird für Typ %s bei %C nicht unterstützt

en: Kind type parameter for entity at %L differs from the kind type parameter of the typespec
de: Parameter mit KIND-Typ für Entität bei %L unterscheidet sich vom Parameter mit KIND-Typ der Typspezifikation

en: Known AArch64 ABIs (for use with the -mabi= option):
de: Bekannte AArch64-ABIs (für Verwendung mit Option -mabi=):

en: Known ABIs (for use with the -mabi= option):
de: Bekannte ABIs (für Verwendung mit Option -mabi=):

en: Known ARC CPUs (for use with the -mcpu= option):
de: Bekannte ARC-CPUs (für Verwendung mit Option -mcpu=):

en: Known ARM ABIs (for use with the -mabi= option):
de: Bekannte ARM-ABIs (für Verwendung mit Option -mabi=):

en: Known ARM CPUs (for use with the -mcpu= and -mtune= options):
de: Bekannte ARM-CPUs (für Verwendung mit Optionen -mcpu= und -mtune=):

en: Known ARM FPUs (for use with the -mfpu= option):
de: Bekannte ARM-FPUs (für Verwendung mit Option -mfpu=):

en: Known ARM architectures (for use with the -march= option):
de: Bekannte ARM-Architekturen (für Verwendung mit Option -march=):

en: Known C6X ISAs (for use with the -march= option):
de: Bekannte C6X ISAs (für Verwendung mit der Option -march=):

en: Known CPUs (for use with the -mcpu= and -mtune= options):
de: Bekannte CPUs (für Verwendung mit Optionen -mcpu= und -mtune=):

en: Known CSKY CPUs (for use with the -mcpu= options):
de: Bekannte CSKY-CPUs (für Verwendung mit Option -mcpu=):

en: Known CSKY FPUs (for use with the -mfpu= option):
de: Bekannte CSKY-FPUs (für Verwendung mit Option -mfpu=):

en: Known CSKY architectures (for use with the -march= option):
de: Bekannte CSKY-Architekturen (für Verwendung mit Option -march=):

en: Known FR-V CPUs (for use with the -mcpu= option):
de: Bekannte FR-V-CPUs (für Verwendung mit Option -mcpu=):

en: Known IQ2000 CPUs (for use with the -mcpu= option):
de: Bekannte IQ2000-CPUs (für Verwendung mit Option -mcpu=):

en: Known Itanium CPUs (for use with the -mtune= option):
de: Bekannte Itanium-CPUs (für Verwendung mit Option -mtune=):

en: Known M68K CPUs (for use with the -mcpu= option):
de: Bekannte M68K-CPUs (für Verwendung mit Option -mcpu=):

en: Known M68K ISAs (for use with the -march= option):
de: Bekannte M68K-ISAs (für Verwendung mit Option -march=):

en: Known M68K microarchitectures (for use with the -mtune= option):
de: Bekannte M68K-Mikroarchitekturen (für Verwendung mit Option -mtune=):

en: Known MIPS ABIs (for use with the -mabi= option):
de: Bekannte MIPS-ABIs (für Verwendung mit Option -mabi=):

en: Known MIPS CPUs (for use with the -march= and -mtune= options):
de: Bekannte MIPS-CPUs (für Verwendung mit Optionen -march= und -mtune=):

en: Known MIPS IEEE 754 settings (for use with the -mabs= and -mnan= options):
de: Bekannte MIPS-IEEE-754-Einstellungen (für Verwendung mit Optionen -mabs= und -mnan=):

en: Known MIPS ISA levels (for use with the -mips option):
de: Bekannte MIPS-ISA-Stufen (für Verwendung mit Option -mips):

en: Known PTX ISA target architectures (for use with the -misa= option):
de: Bekannte PTX-ISA-Architekturen (für Verwendung mit Option -misa=):

en: Known PTX ISA versions (for use with the -mptx= option):
de: Bekannte PTX-ISA-Versionen (für Verwendung mit Option -mptx=):

en: Known TILE-Gx CPUs (for use with the -mcpu= option):
de: Bekannte TILE-Gx CPUs (für Verwendung mit Option -mcpu=):

en: Known TILEPro CPUs (for use with the -mcpu= option):
de: Bekannte TILEPro-CPUs (für Verwendung mit Option -mcpu=):

en: Known TLS dialects (for use with the -mtls-dialect= option):
de: Bekannte TLS-Dialekte (für Verwendung mit Option -mtls-dialect=):

en: Known __fp16 formats (for use with the -mfp16-format= option):
de: Bekannte __fp16-Formate (für Verwendung mit der Option -mfp16-format=):

en: Known address mode (for use with the -maddress-mode= option):
de: Bekannter Adressmodus (für Verwendung mit Option -maddress-mode=):

en: Known arch types (for use with the -march= option):
de: Bekannte Architekturen (für Verwendung mit Option -march=):

en: Known assembler dialects (for use with the -masm= option):
de: Bekannte Assemblerdialekte (für Verwendung mit Option »-masm=«):

en: Known choices for mitigation against straight line speculation with -mharden-sls=:
de: Bekannte Möglichkeiten zur Abschwächung der geradlinigen Spekulation mit »-mharden-sls=«:

en: Known choices for return instrumentation with -minstrument-return=:
de: Bekannte Werte für Rückkehr-Instrumentierung mit -minstrument-return=:

en: Known cmodel types (for use with the -mcmodel= option):
de: Bekannte Codemodelle (für Verwendung mit Option -mcmodel=):

en: Known cmodel types (for use with the -mict-model= option):
de: Bekannte Codemodelle (für Verwendung mit Option -mict-model=):

en: Known code model types (for use with the -mcmodel= option):
de: Bekannte Codemodelle (für Verwendung mit Option -mcmodel=):

en: Known code models (for use with the -mcmodel= option):
de: Bekannte Codemodelle (für Verwendung mit Option -mcmodel=):

en: Known cpu types (for use with the -mcpu= option):
de: Bekannte CPU-Typen (für Verwendung mit Option -mcpu=):

en: Known data alignment choices (for use with the -malign-data= option):
de: Bekannte Datenausrichtungen (für Verwendung mit Option -malign-data=):

en: Known floating-point ABIs (for use with the -mfloat-abi= option):
de: Bekannte Gleitkomma-ABIs (für Verwendung mit Option -mfloat-abi=):

en: Known floating-point number of registers (for use with the -mconfig-fpu= option):
de: Bekannte Anzahl der Gleitkomma-Register (für Verwendung mit der Option -mconfig-fpu=):

en: Known indirect branch choices (for use with the -mindirect-branch=/-mfunction-return= options):
de: Bekannte indirekte Sprungauswahlen (für Verwendung mit den Optionen -mindirect-branch=/-mfunction-return=):

en: Known preferred register vector length (to use with the -mprefer-vector-width= option):
de: Bekannte bevorzugte Länge von Registervektoren (für Verwendung mit der Option -mprefer-vector-width=):

en: Known stack protector guard (for use with the -mstack-protector-guard= option):
de: Bekannte Stapelschutz-Wächter (für Verwendung mit Option -mstack-protector-guard=):

en: Known vectorization library ABIs (for use with the -mveclibabi= option):
de: Bekannte ABIs für Vektorisierungs-Bibliothek (für Verwendung mit Schalter -mveclibabi=):

en: L%d cache latency unknown for %s
de: L%d Cache-Wartezeit unbekannt für %s

en: LEN argument (%ld) out of range 0:%d in intrinsic MVBITS
de: LEN-Argument (%ld) außerhalb des Bereichs 0:%d in intrinsischem MVBITS

en: LEN argument (%ld) out of range 0:%ld in intrinsic IBITS
de: LEN-Argument (%ld) außerhalb des Bereichs 0:%ld in intrinsischem IBITS

en: LEN attribute at %C in a STRUCTURE definition
de: LEN-Attribut bei %C in einer STRUCTURE-Definition

en: LEN attribute at %C in a TYPE definition
de: LEN-Attribut bei %C in einer TYPE-Definition

en: LEN or KIND inquiry ref in DATA statement at %L
de: LEN oder KIND-Abfrageverweis in DATA-Anweisung bei %L

en: LEN part_ref at %C
de: LEN-part_ref bei %C

en: LHS in %<noreturn%> call
de: LHS in %<noreturn%>-Aufruf

en: LINEAR clause modifier used on DO or SIMD construct at %L
de: LINEAR-Klauselmodifizierer wird bei %L an DO- oder SIMD-Konstrukt verwendet

en: LINEAR clause specified together with ORDERED clause with argument at %L
de: Für Argument bei %L ist die LINEAR-Klausel zusammen mit ORDERED-Klausel angegeben

en: LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L
de: LINEAR-Dummy-Argument %qs mit VALUE-Attribut mit %s-Modifizierer bei %L

en: LINEAR variable %qs must be INTEGER at %L
de: LINEAR-Variable %qs bei %L muss INTEGER sein

en: LOCK statement at %C
de: LOCK-Anweisung bei %C

en: LOCK_EVENT in variable definition context (%s) at %L
de: LOCK_EVENT in Variablen-Definitionskontext (%s) bei %L

en: LOCK_TYPE in variable definition context (%s) at %L
de: LOCK_TYPE in Variablen-Definitionskontext (%s) bei %L

en: LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs
de: LOGICAL-Scheinargument %qs bei %L mit Nicht-C_Bool-Art in BIND(C)-Prozedur %qs

en: LOGICAL operands are required in expression at %L
de: LOGICAL-Operanden werden in Ausdruck bei %L benötigt

en: LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs
de: LOGICAL-Rückgabevariable %qs bei %L mit Nicht-C_Bool-Art in BIND(C)-Prozedur %qs

en: LTO support has not been enabled in this configuration
de: LTO-Unterstützung wurde in dieser Konfiguration nicht eingeschaltet

en: Label %d at %C already referenced as a format label
de: Marke %d bei %C bereits als eine Formatmarke referenziert

en: Label %d at %C already referenced as branch target
de: Marke %d bei %C bereits als Sprungziel referenziert

en: Label %d at %C previously used as a FORMAT label
de: Marke %d bei %C vorher als FORMAT-Marke verwendet

en: Label %d at %C previously used as branch target
de: Marke %d bei %C vorher als Sprungziel verwendet

en: Label %d at %L defined but cannot be used
de: Marke %d bei %L definiert, kann aber nicht verwendet werden

en: Label %d at %L defined but not used
de: Marke %d bei %L definiert, aber nicht verwendet

en: Label %d referenced at %L is never defined
de: Marke %d wird bei %L referenziert, aber nirgendwo definiert

en: Label %qs after %L doesn't match IF label %qs
de: Sprungmarke %qs nach %L passt nicht zur IF-Marke %qs

en: Label %qs at %C doesn't match IF label %qs
de: Marke %qs bei %C passt nicht zur IF-Marke %qs

en: Label %qs at %C doesn't match WHERE label %qs
de: Marke %qs bei %C passt nicht zur WHERE-Marke %qs

en: Label at %L is not in the same block as the GOTO statement at %L
de: Marke bei %L ist nicht im gleichen Block wie GOTO-Anweisung bei %L

en: Label name %qs at %C is ambiguous
de: Markenname %qs bei %C ist mehrdeutig

en: Labeled DO statement at %L
de: DO-Anweisung mit Label bei %L

en: Left parenthesis required after %<*%> in format string at %L
de: Öffnende Klammer benötigt nach %<*%> in Formatzeichenkette bei %L

en: Legacy Extension:
de: Alte Erweiterung:

en: Letter %qc already has an IMPLICIT type at %C
de: Buchstabe %qc hat bei %C bereits einen IMPLICIT-Typ

en: Letter %qc already set in IMPLICIT statement at %C
de: Buchstabe %qc wurde bereits in IMPLICIT-Anweisung bei %C gesetzt

en: Letters must be in alphabetic order in IMPLICIT statement at %C
de: Buchstaben in IMPLICIT-Anweisung bei %C müssen in alphabetischer Reihenfolge sein

en: Level not found, use none, slim, blocks, vops.
de: Stufe nicht gefunden, verwenden Sie %<none%>, %<slim%>, %<blocks%>, %<vops%>.

en: Lift restrictions on GOT size.
de: Beschränkungen für GOT-Größe aufheben.

en: Like -M but ignore system header files.
de: Wie -M, aber System-Header-Dateien ignorieren.

en: Like -MD but ignore system header files.
de: Wie -MD, aber System-Header-Dateien ignorieren.

en: Like -pedantic but issue them as errors.
de: Wie -pedantic, aber als Fehler ausgeben.

en: Like parameter rs6000-density-load-pct-threshold, we also check if the total number of load statements exceeds the threshold specified by this parameter, and penalize only if it's satisfied.  The default value is 20.
de: Wie beim Parameter rs6000-density-load-pct-threshold wird auch hier geprüft, ob die Gesamtzahl der Ladeanweisungen den durch diesen Parameter festgelegten Schwellwert überschreitet, und nur dann eine Strafe verhängt, wenn dieser Schwellwert erfüllt ist. Der Standardwert ist 20.

en: Like parameter rs6000-density-pct-threshold, we also check the total sum of vec_cost and non vec_cost, and penalize only if the sum exceeds the threshold specified by this parameter.  The default value is 70.
de: Wie beim Parameter rs6000-density-pct-threshold, wird die Gesamtsumme von vec_cost und nicht-vec_cost berechnet, und die Betrafung erfolgt nur, wenn die Summe den durch diesen Parameter festgelegten Schwellenwert überschreitet. Der Standardwert ist 70.

en: Limit how much the autovectorizer may unroll a loop.
de: Begrenzen, wie weit der Autovektorisierer eine Schleife abrollen darf.

en: Limit of %d continuations exceeded in statement at %C
de: Grenze von %d Fortsetzungen in Anweisung bei %C überschritten

en: Line truncated at %L
de: Zeile bei %L wird abgeschnitten

en: Lines executed:%s of %d
de: %s von %d Zeilen ausgeführt

en: Link in code for a __main kernel.
de: Code für einen __main-Kernel einbinden.

en: Link the standard D library dynamically in the compilation.
de: Die D-Standardbibliothek dynamisch in das Compilat binden.

en: Link the standard D library statically in the compilation.
de: Die D-Standardbibliothek statisch in das Compilat binden.

en: Link to emit program in ELF format (rather than mmo).
de: Binden, um Programm im ELF-Format zu erzeugen (statt mmo).

en: Link with HAL BSP.
de: Mit HAL BSP verlinken.

en: Link with a limited version of the C library.
de: Mit eingeschränkter Version der C-Bibliothek linken.

en: Link with libads.a, libc.a and crt0.o.
de: Mit libads.a, libc.a und crt0.o binden.

en: Link with libc.a and libdebug.a.
de: Mit libc.a und libdebug.a binden.

en: Link with libc.a and libsim.a.
de: Mit libc.a und libsim.a binden.

en: Link with libmvme.a, libc.a and crt0.o.
de: Mit libmvme.a, libc.a und crt0.o binden.

en: Link with libsim.a, libc.a and sim-crt0.o.
de: Mit libsim.a, libc.a und sim-crt0.o binden.

en: Link with libyk.a, libc.a and crt0.o.
de: Mit libyk.a, libc.a und crt0.o binden.

en: Link with the fast floating-point library.
de: Mit schneller Gleitkomma-Bibliothek linken.

en: Link with the library-pic libraries.
de: Mit Library-PIC-Bibliotheken linken.

en: Link-time optimization with number of parallel jobs or jobserver.
de: Optimierungen zur Bindezeit mit Anzahl paralleler Jobs oder Jobserver.

en: List all available debugging counters with their limits and counts.
de: Alle verfügbaren Fehleranalysezähler mit ihren Grenzen und Werten auflisten.

en: List all hidden GC allocations.
de: Alle versteckten GC-Allokationen auflisten.

en: List all non-mutable fields which occupy an object instance.
de: Alle unveränderlichen Felder auflisten, die eine Objektinstanz belegen.

en: List all usages of 'in' on parameter.
de: Alle Verwendungen von »in« mit Parametern auflisten.

en: List all variables going into thread local storage.
de: Alle Variablen auflisten, die im threadlokalen Speicher landen.

en: List information on all D language transitions.
de: Informationen über alle D-Sprachänderungen auflisten.

en: List instances of Markdown replacements in Ddoc.
de: Vorkommen von Markdown-Ersetzungen in Ddoc auflisten.

en: List item %qs at %L set in previous OMP DECLARE TARGET directive to a different DEVICE_TYPE
de: Listenelement %qs bei %L wurde von einer vorhergehenden Direktive OMP DECLARE TARGET auf einen abweichenden DEVICE_TYPE festgelegt

en: List item %qs with allocatable components is not permitted in map clause at %L
de: Listenelement %qs mit allozierbaren Komponenten ist nicht erlaubt in einer map-Klausel bei %L

en: List item shall not be coindexed at %C
de: Listenelement bei %C darf nicht koindiziert sein

en: List specified together with memory order clause in FLUSH directive at %C
de: Liste wurde zusammen mit Speicherreihenfolge-Klausel angegeben, in FLUSH-Direktive bei %C

en: List statistics on template instantiations.
de: Statistik zu Template-Instanziierung ausgeben.

en: Load all members of archive libraries, rather than only those that satisfy undefined symbols.
de: Alle Elemente der Archivbibliotheken laden, statt nur denen, die undefinierte Symbole erfüllen.

en: Locator %qs at %L in DEPEND clause of depobj type shall be a scalar integer of OMP_DEPEND_KIND kind
de: Locator %qs bei %L in der DEPEND-Klausel der Art DEPOBJ muss eine skalare Ganzzahl der Art OMP_DEPEND_KIND sein

en: Locator at %L in DEPEND clause of depobj type shall be a scalar integer of OMP_DEPEND_KIND kind
de: Der Locator bei %L in der DEPEND-Klausel vom Typ DEPOBJ muss eine skalare Ganzzahl der Art OMP_DEPEND_KIND sein

en: Lock variable at %L must be a scalar of type LOCK_TYPE
de: Lock-Variable bei %L muss Skalar mit LOCK_TYPE sein

en: Logical SELECT CASE block at %L has more that two cases
de: Logischer SELECT CASE Block bei %L hat mehr als zwei Fälle

en: Logical range in CASE statement at %L is not allowed
de: Logischer Bereich in CASE-Anweisung bei %L ist nicht erlaubt

en: Logicals at %%L must be compared with %s instead of %s
de: Logische Werte bei %%L müssen mit %s statt mit %s verglichen werden

en: Logs which object files the linker loads.
de: Die vom Linker geladenen Objektdateien wegschreiben.

en: Logs which symbol(s) caused an object to be loaded.
de: Symbole wegschreiben, die zum Laden eines Objekts geführt haben.

en: Look for and use PCH files even when preprocessing.
de: PCH-Dateien suchen und verwenden, sogar bei Vorverarbeitung.

en: Looks for opportunities to reduce stack adjustments and stack references.
de: Sucht Möglichkeiten, Stapel-Anpassungen und Stapel-Referenzen zu reduzieren.

en: LoongArch CPU types:
de: CPU-Typen für LoongArch:

en: Loop code aligned to this power of 2.
de: Schleifen an dieser Potenz von 2 ausrichten.

en: Loop iterates infinitely
de: Schleife läuft endlos

en: Loop variable
de: Schleifenvariable

en: Loop variable at %C cannot be a coarray
de: Schleifenvariable bei %C kann kein Koarray sein

en: Loop variable at %C cannot be a sub-component
de: Schleifenvariable bei %C kann keine Unter-Komponente sein

en: Loop variable at %C cannot be an array
de: Schleifenvariable bei %C kann kein Koarray sein

en: Loop variable has been modified
de: Schleifenvariable wurde geändert

en: Loops iterating at least selected number of iterations will get loop alignment.
de: Schleifen mit mindestens der angegebenen Durchlaufzahl erhalten Schleifenausrichtung.

en: Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d
de: Untere Feldreferenz bei %L ist außerhalb der Schranken (%ld < %ld) in Dimension %d

en: Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d
de: Untere Feldreferenz bei %L ist außerhalb der Schranken (%ld > %ld) in Dimension %d

en: MCU %qs does not have hardware multiply support, but %<-mhwmult%> is set to %s
de: MCU %qs unterstützt keine Hardware-Multiplikation, aber %<-mhwmult%> ist auf %s gesetzt

en: MCU %qs supports %s ISA but %<-mcpu%> option is set to %s
de: MCU %qs unterstützt %s-ISA, aber %<-mcpu%> ist auf %s gesetzt

en: MCU %qs supports %s hardware multiply, but %<-mhwmult%> is set to 16-bit
de: MCU %qs unterstützt %s-Hardware-Multiplikation, aber %<-mhwmult%> ist auf %<16-bit%> gesetzt

en: MCU %qs supports %s hardware multiply, but %<-mhwmult%> is set to 32-bit
de: MCU %qs unterstützt %s-Hardware-Multiplikation, aber %<-mhwmult%> ist auf %<32-bit%> gesetzt

en: MCU %qs supports %s hardware multiply, but %<-mhwmult%> is set to f5series
de: MCU %qs unterstützt %s-Hardware-Multiplikation, aber %<-mhwmult%> ist auf %<f5series%> gesetzt

en: MESSAGE clause at %L requires a scalar default-kind CHARACTER expression
de: Die MESSAGE-Klausel bei %L erfordert einen skalaren CHARACTER-Ausdruck der Standardart

en: MIPS16 %<-mxgot%> code
de: MIPS16 %<-mxgot%> Code

en: MIPS16 PIC for ABIs other than o32 and o64
de: MIPS16 PIC für ABIs außer o32 und o64

en: MMIX Internal: %s is not a shiftable integer
de: Interner Fehler: MMIX Internal: %s is not a shiftable int

en: MMIX Internal: Bad register: %d
de: Interner Fehler: MMIX Internal: Bad register: %d

en: MMIX Internal: Bad value for 'm', not a CONST_INT
de: MMIX-intern: Falscher Wert für 'm', kein CONST_INT

en: MMIX Internal: Cannot decode this operand
de: MMIX-internal: Dieser Operand kann nicht dekodiert werden

en: MMIX Internal: Expected a CONST_INT, not this
de: MMIX-intern: CONST_INT erwartet, aber nicht dies

en: MMIX Internal: Expected a constant, not this
de: MMIX-intern: Konstante erwartet, aber nicht dies

en: MMIX Internal: Expected a register, not this
de: MMIX-intern: Register erwartet, aber nicht dies

en: MMIX Internal: Last named vararg would not fit in a register
de: Interner Fehler: MMIX Internal: Last named vararg would not fit in a register

en: MMIX Internal: Missing %qc case in %<mmix_print_operand%>
de: Interner Fehler: MMIX Internal: Missing %qc case in %<mmix_print_operand%>

en: MMIX Internal: This is not a constant:
de: MMIX-intern: Dies ist keine Konstante:

en: MMIX Internal: This is not a recognized address
de: MMIX-intern: Diese Adresse wird nicht erkannt

en: MMIX Internal: Trying to output invalidly reversed condition:
de: MMIX-intern: Versuch, ungültig umgekehrte Bedingung auszugeben:

en: MMIX Internal: What is the CC of this?
de: MMIX-intern: Was ist der CC davon?

en: MMIX Internal: What's the CC of this?
de: MMIX-intern: Was ist der CC davon?

en: MMX vector argument without MMX enabled changes the ABI
de: MMX-Vektorargument ohne eingeschaltetes MMX ändert das ABI

en: MMX vector return without MMX enabled changes the ABI
de: MMX-Vektorrückgabe ohne eingeschaltetes MMX ändert das ABI

en: MODULE PROCEDURE at %C must be in a generic module interface
de: MODULE PROCEDURE bei %C muss in einer generischen Modulschnittstelle sein

en: MODULE PROCEDURE declaration at %C
de: MODULE-PROCEDURE-Deklaration bei %C

en: MODULE prefix at %C
de: MODULE-Präfix bei %C

en: MODULE prefix at %C found outside of a module, submodule, or interface
de: MODULE-Präfix bei %C muss innerhalb eines Moduls, Teilmoduls oder Interfaces sein

en: MOLD argument to NULL required at %L
de: MOLD-Argument an NULL bei %L erforderlich

en: MOLD tag at %L
de: MOLD-Marke bei %L

en: MOLD tag at %L conflicts with SOURCE tag at %L
de: MOLD-Marke bei %L steht mit SOURCE-Marke bei %L in Konflikt

en: MOLD tag at %L conflicts with the typespec at %L
de: MOLD-Marke bei %L steht mit Typspezifikation bei %L in Konflikt

en: MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s
de: In NULL()-Argument bei %L wird MOLD= benötigt: Mehrdeutig zwischen spezifischen Funktionen %s und %s

en: MSA MIPS16 code
de: MSA-MIPS16-Code

en: MSP430 built-in functions only work inside interrupt handlers
de: eingebaute MSP430-Funktionen sind nur innerhalb von Interrupt-Handlern einsetzbar

en: MULT case in %<cris_op_str%>
de: MULT-Fall in %<cris_op_str%>

en: Magnitude of second argument of %s exceeds bit size at %L
de: Größe des zweiten Arguments von %s überschreitet Bit-Größe bei %L

en: Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C
de: Größenordnung des zweiten Arguments von ISHFTC überschreitet BIT_SIZE des ersten Arguments bei %C

en: Maintain backchain pointer.
de: Rückwärtskettenzeiger pflegen.

en: Make "char" signed by default.
de: Macht »char« standardmäßig vorzeichenbehaftet.

en: Make "char" unsigned by default.
de: »char« standardmäßig vorzeichenlos machen.

en: Make GCC pass the --no-relax command-line option to the linker instead of the --relax option.
de: Dem Linker die Befehlszeilenoption »--no-relax« anstelle der Option »--relax« übergeben.

en: Make all function calls indirect.
de: Alle Funktionsaufrufe indirekt machen.

en: Make inline functions constexpr by default.
de: Inline-Funktionen standardmäßig zu »constexpr« machen.

en: Make integers 32 bits wide.
de: Ganzzahlen 32 Bit breit machen.

en: Make structs a multiple of 4 bytes (warning: ABI altered).
de: Structs auf Vielfache von 4 Bytes vergrößern (Warnung: ABI geändert).

en: Make the linker relaxation machine assume that a program counter wrap-around occurs.
de: Maschine zur Binder-Entspannung soll annehmen, dass ein Befehlszählerübersprung auftritt.

en: Malformed GENERIC statement at %C
de: Kaputte GENERIC-Anweisung bei %C

en: Malformed type-spec at %C
de: Falsch geformte Typspezifikation bei %C

en: Malloc data into P2 space.
de: Daten im P2-Raum reservieren.

en: Mangled derived type definition at %C
de: Gemangelte abgeleitete Typdefinition bei %C

en: Mapper for module to CMI files.
de: Zuordnung von Modulen zu CMI-Dateien.

en: Mark MAC register as call-clobbered.
de: MAC-Register als Aufruf-zerstört markieren.

en: Mark all loops as parallel.
de: Alle Schleifen als parallel markieren.

en: Mark implicitly-declared copy operations as deprecated if the class has a user-provided copy operation or destructor.
de: Implizit deklarierte Kopieroperationen als deprecated markieren, wenn die Klasse eine benutzerdefinierte Kopieroperation oder einen solchen Destruktor hat.

en: Mark implicitly-declared copy operations as deprecated if the class has a user-provided copy operation.
de: Implizit deklarierte Kopieroperationen als deprecated markieren, wenn die Klasse eine benutzerdefinierte Kopieroperation hat.

en: Marks all inlined functions and methods as having hidden visibility.
de: Alle inline-Funktionen und -Methoden mit versteckter Sichtbarkeit markieren.

en: Max basic blocks number in loop for loop invariant motion.
de: Höchstzahl der Basis-Blöcke in Schleife für Schleifeninvariantenbewegung.

en: Max loops number for regional RA.
de: Maximale Schleifenanzahl für regionale Registerzuweisung (RA).

en: Max number of bytes to compare with loops.
de: Maximalzahl der Bytes, die mit Schleifen verglichen werden.

en: Max number of bytes to compare without loops.
de: Maximalzahl der Bytes, die ohne Schleifen verglichen werden.

en: Max number of bytes to compare.
de: Maximalzahl der Bytes, die verglichen werden.

en: Max number of bytes to move inline.
de: Maximalzahl der Bytes, die inline kopiert werden.

en: Max size of conflict table in MB.
de: Maximale Größe der Konflikttabelle in MB.

en: Max. count of debug markers to expand or inline.
de: Maximalzahl der Debugmarkierungen, die expandiert oder eingereiht werden.

en: Max. recursion depth for expanding var tracking expressions.
de: Größte Rekursionstiefe für das Expandieren von variablenverfolgenden Ausdrücken.

en: Max. size of loc list for which reverse ops should be added.
de: Maximalgröße der Speicherort-Liste, bei der Umkehrungsoperationen hinzugefügt werden sollen.

en: Max. size of var tracking hash tables.
de: Maximale Größe variablenverfolgender Hash-Tabellen.

en: Maximal code growth caused by tail duplication (in percent).
de: Maximaler Code-Zuwachs durch Ende-Vervielfältigung (in Prozent).

en: Maximal estimated growth of function body caused by early inlining of single call.
de: Größtes durch frühes »inline« eines einzelnen Aufrufs abgeschätztes Wachstum des Funktionskörpers.

en: Maximal estimated outcome of branch considered predictable.
de: Größtes geschätztes Ergebnis eines als vorhersagbar betrachteten Sprunges.

en: Maximal growth due to inlining of large function (in percent).
de: Maximales Wachstum durch »inline« einer großen Funktion (in Prozent).

en: Maximal number of boundary endpoints of case ranges of switch statement used during IPA function summary generation.
de: Maximale Anzahl der Grenzendpunkte der Fallbereiche der Switch-Anweisung, die bei der Generierung der IPA-Funktionszusammenfassung verwendet werden.

en: Maximal size of a partition for LTO (in estimated instructions).
de: Kleinste Größe einer Partition für LTO (in geschätzten Befehlen)

en: Maximal stack frame growth due to inlining (in percent).
de: Maximales Stapelrahmen-Wachstum durch »inline« (in Prozent).

en: Maximum allowed growth of number and total size of new parameters that ipa-sra replaces a pointer to an aggregate with.
de: Maximal erlaubte Größenzunahme und Gesamtgröße der neuen Parameter, bis zu der IPA-RSA Zeiger auf Aggregate ersetzt.

en: Maximum amount of iterations of the pass over a function.
de: Höchstzahl der Iterationen des Durchgangs über eine Funktion.

en: Maximum amount of similar bbs to compare a bb with.
de: Höchstzahl der ähnlichen Basisblöcke, mit denen ein Basisblock verglichen wird.

en: Maximum combined size of caller and callee which is inlined if callee is called once.
de: Maximale Gesamtgröße von aufrufender und aufgerufener Funktion, für den Fall, dass die aufgerufene Funktion in die aufrufende eingereiht wird und die aufgerufene Funktion nur von einer Stelle aus aufgerufen wird.

en: Maximum depth of DFS walk used by modref escape analysis.
de: Höchsttiefe beim Durchlaufen des DFS durch die modref-Escapeanalyse.

en: Maximum depth of a loop nest to fully value-number optimistically.
de: Maximale Verschachtelungstiefe von Schleifen für optimistisches value-number.

en: Maximum depth of logical expression evaluation ranger will look through when evaluating outgoing edge ranges.
de: Maximale Tiefe der logischen Ausdrücke, die von der Bereichsanalyse erfasst werden, um ausgehende Bereiche zu evaluieren.

en: Maximum depth of recursive cloning for self-recursive function.
de: Maximale Tiefe des rekursiven Klonens für selbstrekursive Funktionen.

en: Maximum depth of search in the dominator tree for expressions to hoist.
de: Größte Tiefe der Suche im Dominator-Baum für anzuhebende Ausdrücke.

en: Maximum depth of sqrt chains to use when synthesizing exponentiation by a real constant.
de: Maximale Verschachtelung von Quadratwurzeln, um Potenzierung mit Gleitkommakonstanten abzubilden.

en: Maximum extension level reached with type %qs at %L
de: Höchste Erweiterungsstufe mit Typ %qs bei %L erreicht

en: Maximum length of candidate scans for straight-line strength reduction.
de: Maximallänge von Kandidatenprüfungen für geradlinige Stärkereduktion.

en: Maximum length of partial antic set when performing tree pre optimization.
de: Maximalgröße der partiellen Aufwandsmenge, wenn Baumvoroptimierung ausgeführt wird.

en: Maximum loop depth of a call which is considered for inlining functions called once.
de: Maximale Schleifentiefe eines Aufrufs, der beim inlinen von Funktionen, die nur einmal aufgerufen werden, berücksichtigt wird.

en: Maximum number of VALUEs handled during a single find_base_term call.
de: Maximale Anzahl der VALUEs, die während eines einzelnen Aufrufs von »find_base_term« verarbeitet werden.

en: Maximum number of accesses stored in each modref reference.
de: Höchstzahl der Zugriffe, die pro modref-Verweis gespeichert werden.

en: Maximum number of active local stores in RTL dead store elimination.
de: Höchstzahl der aktiven lokalen Speicherungen bei RTL-Eliminierung toter Speicherungen.

en: Maximum number of aggregate content items for a parameter in jump functions and lattices.
de: Höchstzahl der zusammengesetzten Elemente für einen Parameter in Sprungfunktionen und Gittern.

en: Maximum number of arguments in a PHI supported by TREE if-conversion unless the loop is marked with simd pragma.
de: Höchstzahl der Argumente in einem PHI, die einer TREE-if-Umwandlung unterstützt werden, außer wenn die Schleife mit einem SIMD-Pragma markiert ist.

en: Maximum number of arrays per SCoP.
de: Höchstzahl der Arrays in einem SCoP.

en: Maximum number of artificial accesses to enable forward propagation that Scalar Replacement of Aggregates will keep for one local variable.
de: Maximale Anzahl von künstlichen Zugriffen, um eine Vorwärtsausbreitung zu ermöglichen, die die Skalare Ersetzung von Aggregaten für eine lokale Variable beibehält.

en: Maximum number of assertions to add along the default edge of a switch statement during VRP.
de: Höchstzahl der Assertions, die während der VRP entlang der Standardkante einer switch-Anweisung hinzugefügt werden.

en: Maximum number of bases stored in each modref tree.
de: Höchstzahl der Basen, die pro modref-Baum gespeichert werden.

en: Maximum number of basic blocks before EVRP uses a sparse cache.
de: Höchstzahl der Basis-Blöcke, bevor EVRP einen spärlich gefüllten Cache verwendet.

en: Maximum number of basic blocks on a jump thread path.
de: Höchstzahl der Basis-Blöcke in einem Sprungpfad eines Threads.

en: Maximum number of bits for which we avoid creating FMAs.
de: Höchstzahl der Bits, für die keine FMAs erzeugt werden.

en: Maximum number of bits that can be moved from memory to memory efficiently.
de: Höchstzahl der Bits, die effizient von Speicher zu Speicher verschoben werden können.

en: Maximum number of bits that can be stored to memory efficiently.
de: Höchstzahl der Bits, die effizient im Speicher gespeichert werden können.

en: Maximum number of concurrently open C++ module files when lazy loading.
de: Höchstzahl der gleichzeitig offenen C++-Moduldateien beim verzögerten Laden.

en: Maximum number of conditional store pairs that can be sunk.
de: Höchstzahl von bedingten Speicherpaaren, die ausgegeben werden können.

en: Maximum number of constant stores to merge in the store merging pass.
de: Höchstzahl der konstanten Speicherungen, die im Speicherzusammenfassungs-Durchgang zusammengefasst werden.

en: Maximum number of datarefs in loop for building loop data dependencies.
de: Höchstzahl der Datenreferenzen in Schleife zum Aufbau der Abhängigkeiten der Schleifendaten.

en: Maximum number of different predicates used to track properties of loops in IPA analysis.
de: Maximale Anzahl verschiedener Prädikate, die zur Verfolgung der Eigenschaften von Schleifen in der interprozeduralen Analyse verwendet werden.

en: Maximum number of disambiguations to perform per memory access.
de: Höchstzahl der Auflösungen von Mehrdeutigkeiten pro Speicherzugriff.

en: Maximum number of escape points tracked by modref per SSA-name.
de: Höchstzahl der Ausstiegspunkte, die von modref pro SSA-Name aufgezeichnet werden.

en: Maximum number of fields in a structure before pointer analysis treats the structure as a single variable.
de: Die Höchstzahl der Felder in einer Struktur, bevor Zeigeranalyse sie als einzelne Variable behandelt.

en: Maximum number of insns in a basic block to consider for RTL if-conversion.
de: Höchstzahl der in Basis-Block zu betrachtenden Befehle für RTL-if-Umwandlung.

en: Maximum number of instructions in the ready list that are considered eligible for renaming.
de: Die Höchstzahl der Befehle in der ausführungsbereiten Liste, die zur Umbenennung in Frage kommen.

en: Maximum number of instructions to copy when duplicating blocks on a finite state automaton jump thread path.
de: Höchstzahl der zu kopierenden Befehle, wenn Blöcke auf einem Mehrsprungpfad des Zustandsautomaten dupliziert werden.

en: Maximum number of isl operations, 0 means unlimited.
de: Höchstzahl der ISL-Operationen, 0 bedeutet unbegrenzt.

en: Maximum number of loop peels to enhance alignment of data references in a loop.
de: Höchstzahl der Schleifenschälungen, um Ausrichtung von Datenreferenzen in einer Schleife zu verbessern.

en: Maximum number of may-defs visited when devirtualizing speculatively.
de: Höchstzahl der beim spekulativen Devirtualisieren besuchten may-defs.

en: Maximum number of namespaces to search for alternatives when name lookup fails.
de: Höchstzahl der Namensräume, in denen alternativ gesucht wird, wenn Nachschlagen eines Namens fehlschlägt.

en: Maximum number of nested calls to search for control dependencies during uninitialized variable analysis.
de: Höchstzahl der geschachtelten Aufrufe, die bei der Analyse für uninitialisierte Variablen auf Abhängigkeiten in der Ablaufsteuerung untersucht werden.

en: Maximum number of operations in a parameter expression that can be handled by IPA analysis.
de: Maximale Anzahl von Operationen in einem Parameterausdruck, die von der IPA-Analyse behandelt werden können.

en: Maximum number of outgoing edges in a switch before EVRP will not process it.
de: Höchstzahl der ausgehenden Kanten in einem Switch, bevor EVRP sie nicht mehr verarbeitet.

en: Maximum number of parameters in a SCoP.
de: Höchstzahl der Parameter in einem SCoP.

en: Maximum number of queries into the alias oracle per store.
de: Höchstzahl, wie oft das Alias-Orakel pro Speichervorgang befragt wird.

en: Maximum number of references stored in each modref base.
de: Höchstzahl der Verweise, die pro modref-Basis gespeichert werden.

en: Maximum number of relations the oracle will register in a basic block.
de: Höchstzahl an Beziehungen, die das Orakel pro Basis-Block registriert.

en: Maximum number of statements allowed in a block that needs to be duplicated when threading jumps.
de: Höchstzahl der in einem Block erlaubten Anweisungen, die für Sprungbehandlung vervielfältigt werden müssen.

en: Maximum number of statements that will be visited by IPA formal parameter analysis based on alias analysis in any given function.
de: Höchstzahl der Anweisungen, die von der Analyse der formalen Parameter für IPA besucht werden, basierend auf der Aliasanalyse in einer gegebenen Funktion.

en: Maximum number of statements visited during jump function offset discovery.
de: Höchstzahl der betrachteten Anweisungen für das Entdecken von Sprungfunktionsoffsets.

en: Maximum number of store chains to track at the same time in the store merging pass.
de: Höchstzahl der Speicherungsketten, die im Speicherzusammenfassungs-Durchgang gleichzeitig berücksichtigt werden.

en: Maximum number of strings for which strlen optimization pass will track string lengths.
de: Höchstzahl der Zeichenketten, für die der strlen-Optimierungsdurchgang Zeichenkettenlängen aufzeichnet.

en: Maximum number of tests performed by modref query.
de: Höchstzahl der Tests, die von modref-Anfragen durchgeführt werden.

en: Maximum number of times a given range is adjusted during the dataflow.
de: Maximale Anzahl, wie oft ein bestimmter Bereich während des Datenflusses angepasst wird.

en: Maximum number of times that an insn could be scheduled.
de: Höchstzahl, wie oft ein Befehl geplant werden könnte.

en: Maximum permissible cost for the sequence that would be generated by the RTL if-conversion pass for a branch that is considered predictable.
de: Maximal erlaubte Kosten für die Befehlsfolge, die vom RTL-if-Umwandlungs-Durchlauf für eine vorhersagbare Verzweigung erzeugt wird.

en: Maximum permissible cost for the sequence that would be generated by the RTL if-conversion pass for a branch that is considered unpredictable.
de: Maximal erlaubte Kosten für die Befehlsfolge, die vom RTL-if-Umwandlungs-Durchlauf für eine unvorhersagbare Verzweigung erzeugt wird.

en: Maximum pieces that IPA-SRA tracks per formal parameter, as a consequence, also the maximum number of replacements of a formal parameter.
de: Maximale Stücke, die IPA-SRA pro Formalparameter verfolgt, folglich auch die maximale Anzahl von Ersetzungen eines Formalparameters.

en: Maximum probability of the entry BB of split region (in percent relative to entry BB of the function) to make partial inlining happen.
de: Größte Wahrscheinlichkeit des Einsprung-BB der geteilten Region (in Prozent relativ zum Einsprung-BB der Funktion), um teilweises »inline« durchzuführen.

en: Maximum recursion depth allowed when querying a property of an SSA name.
de: Maximal erlaubte Rekursionstiefe beim Abfragen von Eigenschaften eines SSA-Namens.

en: Maximum size (in bytes) of objects tracked bytewise by dead store elimination.
de: Maximal Größe (in Bytes) der Objekte, die bei der Eliminierung toter Speicherungen byteweise verfolgt werden.

en: Maximum size in bytes of constant values allowed as operands.
de: Maximalgröße der als Operanden erlaubten Konstantenwerte in Bytes.

en: Maximum size of a list of values associated with each parameter for interprocedural constant propagation.
de: Maximale Größe einer jedem Parameter zugeordneten Liste von Werten für interprozedurale Konstantenweitergabe.

en: Maximum size of a single store merging region in bytes.
de: Maximale Größe eines einzelnen Bereichs einer Speicherzusammenführung in Bytes.

en: Maximum size of global and static variables which can be placed into the small data area.
de: Maximalgröße einer globalen oder statischen Variable, die in kleine Datenbereiche gelegt wird.

en: Maximum size, in storage units, of an aggregate which should be considered for scalarization when compiling for size.
de: Maximale Größe (in Speichereinheiten) von Aggregaten, die für Skalarisierung erwägt werden, wenn auf Codegröße optimiert wird.

en: Maximum size, in storage units, of an aggregate which should be considered for scalarization when compiling for speed.
de: Maximale Größe (in Speichereinheiten) von Aggregaten, die für Skalarisierung erwägt werden, wenn auf Geschwindigkeit optimiert wird.

en: Maximum subrecord length cannot exceed %d
de: Höchste Teildatensatzlänge kann %d nicht überschreiten

en: Maximum supported identifier length is %d
de: Höchste unterstützte Bezeichnerlänge ist %d

en: Maximum unroll factor for the unroll-and-jam transformation.
de: Maximaler Entrollfaktor für die »unroll-and-jam«-Transformation.

en: Member functions defined within their class are inline in module purview.
de: Memberfunktionen, die innerhalb ihrer Klasse definiert sind, sind im Zuständigkeitsbereich des Moduls inline.

en: Memory Tagging Extension does not support %<-mabi=ilp32%>
de: Die Speicher-Tagging-Erweiterung unterstützt nicht %<-mabi=ilp32%>

en: Merge adjacent stores.
de: Nebeneinanderliegende Speicheroperationen zusammenfassen.

en: Merge similar-enough states during analysis.
de: Zustände, die ähnlich genug sind, während der Analyse zusammenfassen.

en: Merge subcomand usage:
de: Aufruf des Teilbefehls »merge«:

en: Min. ratio of insns to mem ops to enable prefetching in a loop.
de: Kleinstes Verhältnis von Befehlen zu Speicheroperationen, um Prefetching in einer Schleife einzuschalten.

en: Min. ratio of insns to prefetches to enable prefetching for a loop with an unknown trip count.
de: Kleinstes Verhältnis von Befehlen zu Prefetches, um Prefetching für eine Schleife mit unbekannter Frequentierung einzuschalten.

en: Minimal distance between possibly conflicting store and load.
de: Kleinster Abstand zwischen möglicherweise in Konflikt stehendem Speichern und Laden.

en: Minimal fall-through edge probability in percentage used to add BB to inheritance EBB in LRA.
de: Mindestwahrscheinlichkeit in Prozent für Durchfall-Kanten, damit der BB zu geerbten EBB in LRA hinzugefügt wird.

en: Minimal size of a partition for LTO (in estimated instructions).
de: Kleinste Größe einer Partition für Linkzeitoptimierung (in geschätzten Befehlen).

en: Minimum heap expansion to trigger garbage collection, as a percentage of the total size of the heap.
de: Minimale Heaperweiterung, die Speicherbereinigung anstößt, als Prozentsatz der Gesamtgröße des Heap.

en: Minimum heap size before we start collecting garbage, in kilobytes.
de: Kleinste Heapgröße vor Speicherbereinigungsbeginn, in Kilobytes.

en: Minimum number of iterations per thread of an innermost parallelized loop.
de: Die Mindestzahl der Iterationen pro Thread in einer innersten parallelisierten Schleife.

en: Minimum page size for warning purposes.
de: Mindestseitengröße für Warnzwecke.

en: Minimum percentage of memrefs that must go away for unroll-and-jam to be considered profitable.
de: Mindestprozentsatz der Memrefs, die für unroll-and-jam verschwinden müssen, damit es profitabel ist.

en: Mismatch in BIND(C) names (%qs/%qs) at %C
de: Unverträglichkeit in BIND(C)-Namen (%qs/%qs) bei %C

en: Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s
de: Konflikt in ELEMENTAL-Attribut zwischen MODULE-PROCEDURE bei %L und seiner Schnittstelle in %s

en: Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C
de: Konflikt in formalen Argumentnamen (%s/%s) von MODULE PROCEDURE bei %C

en: Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s
de: Konflikt in PURE-Attribut zwischen MODULE-PROCEDURE bei %L und seiner Schnittstelle in %s

en: Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s
de: Konflikt in RECURSIVE-Attribut zwischen MODULE-PROCEDURE bei %L und seiner Schnittstelle in %s

en: Mismatch in components of derived type %qs from %qs at %C: expecting %qs, but got %qs
de: Unstimmigkeit in Komponenten von Typ %qs, der von %qs abgeleitet ist bei %C: %qs erwartet, aber %qs erhalten

en: Mismatch in number of MODULE PROCEDURE formal arguments at %C
de: Konflikt in Anzahl der formalen Argumente von MODULE PROCEDURE bei %C

en: Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention
de: Unpassende Zuweisung des Prozedurzeigers bei %L: Unpassende Aufrufkonvention

en: Mismatches between file architecture and one specified by "-arch" are errors instead of warnings.
de: Unstimmigkeiten zwischen Dateiarchitektur und »-arch« nicht als Warnungen, sondern als Fehler ansehen

en: Missing %<&%> in continued character constant at %C
de: In fortgesetzter Zeichenkonstante bei %C fehlt %<&%>

en: Missing %<(%> in ELSE IF expression at %C
de: Fehlendes %<(%> in ELSE-IF-Ausdruck bei %C

en: Missing %<(%> in IF-expression at %C
de: Fehlendes %<(%> in IF-Ausdruck bei %C

en: Missing %<)%> in ELSE IF expression at %C
de: Fehlendes %<)%> in ELSE-IF-Ausdruck bei %C

en: Missing %qs argument to %qs intrinsic at %L for %qs of type %qs
de: Argument %qs des intrinsischen %qs bei %L für %qs des Typs %qs fehlt

en: Missing %qs argument to the %s intrinsic at %L
de: Fehlendes %qs-Argument für %qs bei %L

en: Missing %qs in statement at or before %L
de: Fehlendes %qs in Anweisung bei oder vor %L

en: Missing -mcpu option in ASM_CPU_SPEC?
de: Fehlende »-mcpu«-Option in ASM_CPU_SPEC?

en: Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L
de: Fehlende INITIALIZER-Klausel für !$OMP DECLARE REDUCTION von abgeleitetem Typ ohne Defaultinitialisierer bei %L

en: Missing THEN in ELSE IF statement after %L
de: Fehlendes THEN in ELSE-IF-Anweisung nach %L

en: Missing actual argument %qs in call to %qs at %L
de: Fehlendes Argument %qs in Aufruf von %qs bei %L

en: Missing actual argument for argument %qs at %L
de: Fehlendes effektives Argument für Argument %qs bei %L

en: Missing alternate return spec in subroutine call at %L
de: Fehlende alternative Rückgabespezifikation in Unterprogrammaufruf bei %L

en: Missing alternate return specifier in subroutine call at %L
de: Fehlende alternative Rückgabespezifikation in Unterprogrammaufruf bei %L

en: Missing argument list in function %qs at %C
de: Fehlende Argumentliste in Funktion %qs bei %C

en: Missing argument to %qs at %C
de: Fehlendes Argument für %qs bei %C

en: Missing array specification at %L in CODIMENSION statement
de: Feldspezifikation bei %L in CODIMENSION-Anweisung fehlt

en: Missing array specification at %L in DIMENSION statement
de: Fehlende Feldspezifikation bei %L in DIMENSION-Anweisung

en: Missing character range in IMPLICIT at %C
de: Fehlender Zeichenbereich in IMPLICIT bei %C

en: Missing closing paren for binding label at %C
de: Schließende Klammer für Bindungsmarke bei %C fehlt

en: Missing codimension specification at %C
de: Fehlende Kodimensionsangabe bei %C

en: Missing comma at %L
de: Fehlendes Komma bei %L

en: Missing counts for called function %s
de: Fehlende Zähler für aufgerufene Funktion %s

en: Missing dimension specification at %C
de: Fehlende Dimensionsangabe bei %C

en: Missing entity or common block name for attribute specification statement at %C
de: Entität oder Name eines gemeinsamen Blocks für Attribut-Spezifikationsanweisung bei %C fehlt

en: Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L
de: Fehlende explizite Deklaration mit EXTERNAL-Attribut für Symbol %qs bei %L

en: Missing exponent in real number at %C
de: Fehlender Exponent in Realzahl bei %C

en: Missing format label at %C
de: Fehlende Format-Marke bei %C

en: Missing format with default unit at %C
de: Fehlendes Format mit Standard-Einheit bei %C

en: Missing generic specification in USE statement at %C
de: Fehlende allgemeine Spezifikation in USE-Anweisung bei %C

en: Missing item in format string at %L
de: Fehlendes Element in Formatzeichenkette bei %L

en: Missing keyword name in actual argument list at %C
de: Fehlender Schlüsselwortname in effektiver Argumentliste bei %C

en: Missing kind-parameter at %C
de: Fehlender Art-Parameter bei %C

en: Missing leading left parenthesis in format string at %L
de: Fehlende öffnende Klammer in Formatzeichenkette bei %L

en: Missing lower bound in assumed size coarray specification at %C
de: Fehlende untere Grenze bei der Angabe der angenommenen Größe des Kofeldes bei %C

en: Missing positive width after L descriptor at %L
de: Positive Breite hinter L-Deskriptor bei %L fehlt

en: Missing required parentheses before BIND(C) at %C
de: Erforderte Klammern vor BIND(C) bei %C fehlen

en: Missing right parenthesis at %C
de: Fehlende rechte Klammer bei %C

en: Missing right parenthesis or comma at %C
de: Fehlende rechte Klammer oder Komma bei %C

en: Missing symbol
de: Fehlendes Symbol

en: Mitigate issues with AES instructions on Cortex-A57 and Cortex-A72 (Arm erratum #1655431).
de: Probleme mit AES-Befehlen auf Cortex-A57 und Cortex-A72 umgehen (Arm Erratum #1655431).

en: Mitigate issues with AES instructions on Cortex-A57 and Cortex-A72 (Arm erratum #1742098).
de: Probleme mit AES-Befehlen auf Cortex-A57 und Cortex-A72 umgehen (Arm Erratum #1742098).

en: Mitigate issues with VLLDM on some M-profile devices (CVE-2021-35465).
de: Probleme mit VLLDM auf einigen M-Profil-Geräten umgehen (CVE-2021-35465).

en: Module %qs at line %d column %d: %s
de: Modul %qs in Zeile %d, Spalte %d: %s

en: Module file %qs has not been generated, either because the module does not contain a MODULE PROCEDURE or there is an error in the module.
de: Moduldatei %qs wurde nicht generiert, entweder weil das Modul keine MODULE PROCEDURE enthält oder weil es einen Fehler in dem Modul gibt.

en: Module nature in USE statement at %C shall be either INTRINSIC or NON_INTRINSIC
de: Modul-Eigenschaft in USE-Anweisung bei %C muss entweder INTRINSIC oder NON_INTRINSIC sein

en: More actual than formal arguments in procedure call at %L
de: Mehr effektive als formale Argumente in Prozeduraufruf bei %L

en: More than one edge out of thunk node
de: Interner Fehler: More than one edge out of thunk node

en: Move loop invariant computations out of loops.
de: Berechnung der Schleifeninvarianten außerhalb der Schleifen legen.

en: Move stores out of loops.
de: Speicheroperationen aus Schleifen herausverschieben.

en: Multiple identifiers provided with single NAME= specifier at %C
de: Mehrere Bezeichner mit einzelner Spezifikation NAME= bei %C angegeben

en: Multiple loop axes specified for routine at %C
de: Mehrere Schleifenachsen für Routine bei %C angegeben

en: NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L
de: Name %qs verweist nicht auf eine Unterroutine oder Funktion in !$ACC ROUTINE ( NAME ) bei %L

en: NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L
de: NAME %qs ist in »!$ACC ROUTINE ( NAME )« bei %L ungültig

en: NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C
de: NAME nicht erlaubt bei BIND(C) für ABSTRACT INTERFACE bei %C

en: NAME= specifier at %C should be a constant expression
de: Spezifikation NAME= bei %C sollte ein konstanter Ausdruck sein

en: NAME= specifier at %C should be a scalar of default character kind
de: NAME=-Angabe bei %C sollte ein Skalar der Standardzeichenart sein

en: NAMELIST %qs in READ statement at %L contains the symbol %qs which may not appear in a variable definition context
de: NAMELIST %qs in READ-Anweisung bei %L enthält Symbol %qs, das im Kontext zur Variablendefinition nicht auftreten darf

en: NAMELIST array object %qs with assumed shape in namelist %qs at %L
de: NAMELIST-Feldobjekt %qs mit vermuteter Form in Namensliste %qs bei %L

en: NAMELIST array object %qs with nonconstant shape in namelist %qs at %L
de: NAMELIST-Feldobjekt %qs ohne konstante Form in Namensliste %qs bei %L

en: NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L
de: NAMELIST-Objekt %qs hat PRIVATE-Komponenten und kann kein Element der PUBLIC-Namensliste %qs bei %L sein

en: NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L
de: NAMELIST-Objekt %qs hat Verwendungs-verbundene PRIVATE-Komponenten und kann kein Element der Namensliste %qs bei %L sein

en: NAMELIST object %qs in namelist %qs at %L has ALLOCATABLE or POINTER components and thus requires a defined input/output procedure
de: NAMELIST-Objekt %qs in Namensliste %qs bei %L hat ALLOCATABLE- oder POINTER-Komponenten erfordert daher eine definierte Ein-/Ausgabeprozedur

en: NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure
de: NAMELIST-Objekt %qs in Namensliste %qs bei %L ist polymorph und erfordert eine definierte Ein-/Ausgabeprozedur

en: NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components
de: NAMELIST-Objekt %qs in Namensliste %qs bei %L mit ALLOCATABLE- oder POINTER-Komponenten

en: NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L
de: NAMELIST-Objekt %qs wurde als PRIVATE deklariert und kann kein Element der PUBLIC-Namensliste %qs bei %L sein

en: NAMELIST object %qs with nonconstant character length in namelist %qs at %L
de: NAMELIST-Objekt %qs ohne konstante Zeichenlänge in Namensliste %qs bei %L

en: NEWUNIT specifier at %L
de: NEWUNIT-Spezifizierer bei %L

en: NEWUNIT specifier must have FILE= or STATUS='scratch' at %L
de: NEWUNIT-Spezifizierer muss FILE= oder STATUS='scratch' bei %L haben

en: NONMONOTONIC schedule modifier specified with ORDERED clause at %L
de: Planungsmodifizierer NONMONOTONIC zusammen mit ORDERED-Klausel bei %L angegeben

en: NON_OVERRIDABLE and DEFERRED cannot both appear at %C
de: NON_OVERRIDABLE und DEFERRED können nicht gleichzeitig bei %C auftreten

en: NOPASS or explicit interface required at %C
de: NOPASS oder explizite Schnittstelle bei %C erforderlich

en: NOTE_INSN_BASIC_BLOCK %d in middle of basic block %d
de: Interner Fehler: NOTE_INSN_BASIC_BLOCK %d in middle of basic block %d

en: NOTE_INSN_BASIC_BLOCK is missing for block %d
de: Interner Fehler: NOTE_INSN_BASIC_BLOCK is missing for block %d

en: NO_ARG_CHECK attribute
de: NO_ARG_CHECK-Attribut

en: NULL appears on right-hand side in assignment at %L
de: Auf rechter Seite in Zuweisung bei %L tritt NULL auf

en: NULL at %L is not permitted as actual argument to %qs intrinsic function
de: NULL bei %L ist nicht als tatsächliches Argument der intrinsischen Funktion %qs erlaubt

en: NULL intrinsic with allocatable MOLD at %L
de: intrinsisches NULL mit reservierbarem MOLD bei %L

en: NULL used in arithmetic
de: NULL in Arithmetik verwendet

en: NULL() at %C cannot appear in an array constructor
de: NULL() bei %C darf nicht in einem Feld-Konstruktor erscheinen

en: NULL() initialization at %C is ambiguous
de: NULL()-Initialisierung bei %C ist mehrdeutig

en: NULL() initialization at %C may not have MOLD
de: NULL()-Initialisierung bei %C könnte kein MOLD haben

en: NULL() near %L cannot appear in INQUIRE statement
de: NULL() in der Nähe von %L darf nicht in einer INQUIRE-Anweisung vorkommen

en: NULLIFY does not allow bounds remapping for pointer object at %C
de: NULLIFY erlaubt keine Neuzuordnung von Grenzen für Zeigerobjekt bei %C

en: NUM_TEAMS lower bound at %L larger than upper bound at %L
de: Untere Grenze von NUM_TEAMS bei %L ist größer als die obere Grenze bei %L

en: Name %qs at %C is already defined as a generic interface at %L
de: Name %qs bei %C ist bereits als eine allgemeine Schnittstelle bei %L definiert

en: Name %qs at %C is an ambiguous reference to %qs from current program unit
de: Name %qs bei %C ist eine mehrdeutige Referenz auf %qs von aktueller Programmeinheit

en: Name %qs at %C is an ambiguous reference to %qs from module %qs
de: Name %qs bei %C ist eine mehrdeutige Referenz auf %qs vom Modul %qs

en: Name %qs at %C is the name of the procedure
de: Name %qs bei %C ist der Name der Prozedur

en: Name %qs in %s statement at %C is not a construct name
de: Name %qs in %s-Anweisung bei %C ist kein Konstruktname

en: Name %qs in %s statement at %C is unknown
de: Name %qs in %s-Anweisung bei %C ist unbekannt

en: Name %qs of ABSTRACT INTERFACE at %C cannot be the same as an intrinsic type
de: Name %qs des ABSTRACT INTERFACE bei %C kann nicht der gleiche wie ein intrinsischer Typ sein

en: Name after !$omp critical and !$omp end critical does not match at %C
de: Name hinter »!$omp critical« und »!$omp end critical« passt nicht bei %C

en: Name at %C is too long
de: Name bei %C ist zu lang

en: Name of system library to link against.
de: Name der Systembibliothek, gegen die gelinkt wird.

en: Name of the startfile.
de: Name der Startdatei.

en: Name too long
de: Name zu lang

en: Named COMMON block %qs at %L shall be of the same size as elsewhere (%lu vs %lu bytes)
de: Benannter COMMON-Block %qs bei %L muss die gleiche Größe wie anderswo haben (%lu Bytes gegenüber %lu Bytes)

en: Named block DO at %L requires matching ENDDO name
de: Benanntes Block-DO bei %L erfordert passenden ENDDO-Namen

en: Named constant %qs at %L cannot be an EQUIVALENCE object
de: Benannte Konstante %qs bei %L kann kein EQUIVALENCE-Objekt sein

en: Named constant %qs in variable definition context (%s) at %L
de: Benannte Konstante %qs in Variablen-Definitionskontext (%s) bei %L

en: Named constant at %C in an EQUIVALENCE
de: Benannte Konstante bei %C in EQUIVALENCE

en: Namelist %qs cannot be an argument at %L
de: Namensliste %qs kann bei %L kein Argument sein

en: Namelist %qs cannot be an argument to subroutine or function at %L
de: Namensliste %qs kann bei %L nicht als Argument für Unterprogramm oder Funktion verwendet werden

en: Namelist group name %qs at %C already has a basic type of %s
de: Gruppenname %qs der Namensliste bei %C hat bereits einen Basistypen von %qs

en: Namelist group name %qs at %C already is USE associated and cannot be respecified.
de: Gruppenname %qs der Namensliste bei %C ist bereits USE-verbunden und kann nicht respezifiziert werden.

en: Namelist group name at %L cannot have the SAVE attribute
de: Name der Namenslisten-Gruppe bei %L kann kein SAVE-Attribut haben

en: Need either entity or common block name for attribute specification statement at %C
de: Entweder Entität oder Name eines gemeinsamen Blocks für Attribut-Spezifikationsanweisung bei %C erforderlich

en: Negative argument N at %L
de: Negatives Argument N bei %L

en: Negative exponent of integer has zero result at %L
de: Negativer Exponent der Ganzzahl bei %L ergibt 0 als Ergebnis

en: Nested CRITICAL block at %C
de: Geschachtelter CRITICAL-Block bei %C

en: Nested function trampolines not supported on CK801.
de: Geschachtelte Trampolin-Funktionen werden auf dem CK801 nicht unterstützt.

en: No binding name is allowed in BIND(C) at %C
de: In BIND(C) bei %C ist kein bindender Name erlaubt

en: No branches
de: Keine Zweige

en: No calls
de: Keine Aufrufe

en: No default crt0.o.
de: Kein voreingestelltes crt0.o.

en: No description yet.
de: Noch keine Beschreibung.

en: No edge out of thunk node
de: Interner Fehler: No edge out of thunk node

en: No executable lines
de: Keine ausführbaren Zeilen

en: No initializer for allocatable component %qs given in the structure constructor at %C
de: Im Strukturkonstruktor bei %2$C wurde keine Initialisierung für allozierbare Komponente %1$qs angegeben

en: No initializer for component %qs given in the structure constructor at %C
de: Im Strukturkonstruktor bei %2$C wurde keine Initialisierung für Komponente %1$qs angegeben

en: No longer supported.
de: Wird nicht mehr unterstützt.

en: No region crossing jump at section boundary in bb %i
de: Interner Fehler: No region crossing jump at section boundary in bb %i

en: Non-ELEMENTAL user-defined assignment in WHERE at %L
de: Benutzerdefinierte Nicht-ELEMENTAL-Zuweisung in WHERE bei %L

en: Non-PARAMETER symbol %qs at %L cannot be implied-shape
de: Nicht-PARAMETER-Symbol %qs bei %L kann nicht implied-shape sein

en: Non-POINTER in pointer association context (%s) at %L
de: Nicht-POINTER in Zeiger-Verbindungskontext (%s) bei %L

en: Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>
de: Nicht-RECURSIVE Prozedur %qs bei %L ruft sich möglicherweise rekursiv selbst auf. Sollte als RECURSIVE oder mit %<-frecursive%> verwendet werden

en: Non-THREADPRIVATE object %qs in COPYIN clause at %L
de: Nicht-THREADPRIVATE-Objekt %qs in Klausel COPYIN bei %L

en: Non-character assumed shape array element in FORMAT tag at %L
de: Element eines Feldes mit vermuteter Form aus Nicht-Schriftzeichen in FORMAT-Markierung bei %L

en: Non-character assumed size array element in FORMAT tag at %L
de: Element eines Feldes mit vermuteter Größe aus Nicht-Schriftzeichen in FORMAT-Markierung bei %L

en: Non-character in FORMAT tag at %L
de: Nicht-Zeichen in FORMAT-Markierung bei %L

en: Non-character non-Hollerith in FORMAT tag at %L
de: Weder Zeichen noch Hollerith in FORMAT-Markierung bei %L

en: Non-character pointer array element in FORMAT tag at %L
de: Element eines Zeigerfeldes aus Nicht-Schriftzeichen in FORMAT-Markierung bei %L

en: Non-constant lower bound in implied-shape declaration at %L
de: Nicht-konstante untere Grenze in Deklaration mit impliziter Form bei %L

en: Non-default LOGICAL kind in %s tag at %L
de: Nicht-Standard-LOGICAL in %s-Marke bei %L

en: Non-dummy object %qs in %s clause at %L
de: Nicht-Scheinobjekt %qs in %s-Klausel bei %L

en: Non-extensible derived-type %qs at %L must not be ABSTRACT
de: Nicht-erweiterbarer abgeleiteter Typ %qs bei %L darf nicht ABSTRACT sein

en: Non-numeric character in statement label at %C
de: Nicht-numerisches Zeichen in Anweisungsmarke bei %C

en: Non-polymorphic passed-object dummy argument of %qs at %L
de: Nicht-polymorphes Scheinargument von %qs für weitergegebenes Objekt bei %L

en: Non-scalar FINAL procedure at %L should have assumed shape argument
de: Nicht-skalare FINAL-Prozedur bei %L sollte Argument mit vermuteter Form haben

en: Non-significant digits in %qs number at %C, maybe incorrect KIND
de: Irrelevante Ziffern in %qs-Zahl bei %C, möglicherweise falsche KIND

en: Non-variable expression in variable definition context (%s) at %L
de: Nicht-variabler Ausdruck in Variablen-Definitionskontext (%s) bei %L

en: Non-zero imaginary part discarded in conversion from %qs to %qs at %L
de: Mögliche Wertänderung bei Umwandlung von %qs in %qs bei %L

en: Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for '=' operator
de: Variable darf in intrinsischer Zuweisung bei %L nicht polymorph sein - bitte prüfen, ob es ein passendes spezifisches Unterprogramm für den »=«-Operator gibt

en: Noncoarray component %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must have a codimension or be a subcomponent of a coarray. (Variables of type %s may not have a codimension as %s at %L has a codimension or a coarray subcomponent)
de: Nicht-Koarray-Komponente %s bei %L des Typs EVENT_TYPE oder mit Subkomponente des Typs EVENT_TYPE muss eine Kodimension haben oder die Subkomponente eines Koarrays sein. (Variablen des Typs %s dürfen keine Kodimension haben, da %s bei %L eine Kodimension oder Koarray-Subkomponente hat.)

en: Noncoarray component %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must have a codimension or be a subcomponent of a coarray. (Variables of type %s may not have a codimension as already a coarray subcomponent exists)
de: Nicht-Koarray-Komponente %s bei %L des Typs EVENT_TYPE oder mit Subkomponente des Typs EVENT_TYPE muss eine Kodimension haben oder die Subkomponente eines Koarrays sein. (Variablen des Typs %s dürfen keine Kodimension haben, da es bereits eine Koarray-Subkomponente gibt.)

en: Noncoarray component %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must have a codimension or be a subcomponent of a coarray. (Variables of type %s may not have a codimension as %s at %L has a codimension or a coarray subcomponent)
de: Nicht-Koarray-Komponente %s bei %L des Typs LOCK_TYPE oder mit Subkomponente des Typs LOCK_TYPE muss eine Kodimension haben oder die Subkomponente eines Koarrays sein. (Variablen des Typs %s dürfen keine Kodimension haben, da %s bei %L eine Kodimension oder Koarray-Subkomponente hat.)

en: Noncoarray component %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must have a codimension or be a subcomponent of a coarray. (Variables of type %s may not have a codimension as already a coarray subcomponent exists)
de: Nicht-Koarray-Komponente %s bei %L des Typs LOCK_TYPE oder mit Subkomponente des Typs LOCK_TYPE muss eine Kodimension haben oder die Subkomponente eines Koarrays sein. (Variablen des Typs %s dürfen keine Kodimension haben, da es bereits eine Koarray-Subkomponente gibt.)

en: Nonconforming tab character at %C
de: Tab-Zeichen bei %C passt nicht

en: Nonconforming tab character in column %d of line %d
de: Unpassendes Tab-Zeichen in Spalte %d der Zeile %d

en: Nonconforming tab character in format at %C
de: Tab-Zeichen in Format bei %C passt nicht

en: Nonconstant array section at %L in DATA statement
de: Abschnitt eines nicht konstanten Feldes bei %L in DATA-Anweisung

en: Nonexistent include directory %qs
de: Include-Verzeichnis %qs ist nicht vorhanden

en: Noninteger exponent in an initialization expression at %L
de: Nichtganzzahliger Exponent in einem Initialisierungsausdruck bei %L

en: Noninteroperable array FPTR at %L to C_F_POINTER: %s
de: Unverträglicher Feld-FPTR bei %L für C_F_POINTER: %s

en: Noninteroperable array at %L as argument to C_LOC: %s
de: Unverträgliches Feld bei %L als Argument für C_LOC: %s

en: Noninteroperable procedure at %L to C_FUNLOC
de: Unverträgliche Prozedur bei %L für C_FUNLOC

en: Noninteroperable procedure pointer at %L to C_F_PROCPOINTER
de: Unverträglicher Prozedurzeiger bei %L für C_F_PROCPOINTER

en: Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L
de: Nichtintrinsische elementare Prozedur %qs ist in Zuweisung des Prozedurzeigers bei %L ungültig

en: Nonnegative width required in format string at %L
de: Nichtnegative Breite in Formatzeichenkette bei %L benötigt

en: Nonpointer object %qs with default initialization shall not appear in a DATA statement at %L
de: Nichtzeiger-Objekt %qs mit Standard-Initialisierung darf nicht in einer DATA-Anweisung bei %L erscheinen

en: Nonpolymorphic reference to abstract type at %C
de: Nichtpolymorphe Referenz auf abstrakten Typ bei %C

en: Nonstandard conversion from %s to %s at %L
de: Nichtstandard-Umwandlung von %s in %s bei %L

en: Nonstandard type declaration %s*%d at %C
de: Nicht-Standard Typ-Deklaration %s*%d bei %C

en: Nonzero range step expected at %L
de: Die Schrittweite bei %L darf nicht 0 sein

en: Normal symbol loading not implemented in extreme mode.
de: Normales Laden von Symbolen ist im extremen Modus nicht implementiert.

en: Not configured with %<--enable-gather-detailed-mem-stats%>.
de: Nicht mit %<--enable-gather-detailed-mem-stats%> konfiguriert.

en: Not enough elements in array initializer at %C
de: Nicht genug Element in Feldinitialisierung bei %C

en: Not expected TAG.
de: Unerwartetes TAG.

en: Note #include directives not translated to import declarations, and not known to be textual.
de: Hinweisen, wenn #include-Direktiven nicht in import-Deklarationen übersetzt werden und nicht eindeutig textuell sind.

en: Note #include directives translated to import declarations.
de: Hinweisen, wenn #include-Direktiven in import-Deklarationen übersetzt werden.

en: Note Compiled Module Interface pathname of a specific module or header-unit.
de: Pfadname für compilierte Modulschnittstelle eines bestimmten Moduls oder Header-Einheit ausgeben.

en: Note Compiled Module Interface pathnames.
de: Pfadnamen für compilierte Modulschnittstellen zur Info ausgeben.

en: Note a #include translation of a specific header.
de: Hinweisen, wenn das #include eines bestimmten Headers übersetzt wird.

en: Number of partitions the program should be split to.
de: Anzahl der Partitionen, in die das Programm aufgeteilt werden soll.

en: Number of registers used to pass integer arguments.
de: Anzahl der zur Übergabe von Ganzzahlargumenten verwendeten Register.

en: Numeric PARAMETER required in complex constant at %C
de: Numerischer PARAMETER in komplexer Konstante bei %C erforderlich

en: Numeric operands are required in expression at %L
de: In Ausdruck bei %L werden numerische Operanden benötigt

en: Numeric or CHARACTER operands are required in expression at %L
de: Numerische oder CHARACTER-Operanden benötigt in Ausdruck bei %L

en: OLD argument of the %s intrinsic function at %L shall be definable
de: OLD-Argument der intrinsischen Funktion »%s« bei %L muss definierbar sein

en: OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used
de: OMP CRITICAL bei %L mit HINT-Klausel benötigt NAME, außer wenn omp_sync_hint_none verwendet wird

en: OMP DECLARE TARGET COMMON at %L previously mentioned in LINK clause and later in TO clause
de: OMP DECLARE TARGET COMMON bei %L wurde vorher in LINK-Klausel und später in TO-Klausel erwähnt

en: OMP DECLARE TARGET COMMON at %L previously mentioned in TO clause and later in LINK clause
de: OMP DECLARE TARGET COMMON bei %L wurde vorher in TO-Klausel und später in LINK-Klausel erwähnt

en: OMP DECLARE TARGET directive at %L with only DEVICE_TYPE clause is ignored
de: Direktive OMP DECLARE TARGET bei %L mit nur DEVICE_TYPE-Klausel wird ignoriert

en: OMP DECLARE TARGET variable at %L is an element of a COMMON block
de: »OMP DECLARE TARGET«-Variable bei %L ist ein Element eines COMMON-Blocks

en: OMP DECLARE TARGET variable at %L previously mentioned in LINK clause and later in TO clause
de: OMP-DECLARE-TARGET-Variable bei %L wurde vorher in LINK-Klausel und später in TO-Klausel erwähnt

en: OMP DECLARE TARGET variable at %L previously mentioned in TO clause and later in LINK clause
de: OMP-DECLARE-TARGET-Variable bei %L wurde vorher in TO-Klausel und später in LINK-Klausel erwähnt

en: OMP TARGET UPDATE at %L requires at least one TO or FROM clause
de: OMP TARGET UPDATE bei %L erfordert mindestens eine TO- oder FROM-Klausel

en: OPEN statement at %L must have UNIT or NEWUNIT specified
de: OPEN-Anweisung bei %L muss UNIT oder NEWUNIT haben

en: OPEN statement not allowed in PURE procedure at %C
de: OPEN-Anweisung in PURE-Prozedur bei %C nicht erlaubt

en: OPERATION argument at %L must be a PURE function
de: OPERATION-Argument bei %L muss eine PURE-Funktion sein

en: OPTIONAL is not allowed inside of BLOCK at %C
de: OPTIONAL ist in BLOCK bei %C nicht erlaubt

en: ORDER at %L is not a permutation of the size of SHAPE at %L
de: ORDER bei %L ist keine Permutation der Größe von SHAPE bei %L

en: ORDER clause must not be used together ORDERED at %L
de: ORDER-Klausel bei %L darf nicht zusammen mit ORDERED verwendet werden

en: ORDERED clause argument not constant positive integer at %C
de: Argument der ORDERED-Klausel bei %C ist keine konstante positive Ganzzahl

en: ORDERED clause parameter is less than COLLAPSE at %L
de: ORDERED-Parameter der Klausel bei %L ist weniger als COLLAPSE

en: ORDERED clause specified together with %<inscan%> REDUCTION clause at %L
de: %<ORDERED%>-Klausel darf nicht nicht zusammen mit %<inscan%>-REDUCTION-Klausel bei %L verwendet werden

en: Object %qs is not a variable at %L
de: Objekt %qs bei %L ist keine Variable

en: Object %qs is not a variable at %L; parameters cannot be and need not be copied
de: Objekt %qs bei %L ist keine Variable; Parameter können nicht kopiert werden und brauchen das auch nicht

en: Object %qs is not a variable at %L; parameters cannot be and need not be mapped
de: Objekt %qs bei %L ist keine Variable; Parameter können nicht zugeordnet werden und brauchen das auch nicht

en: Objective-C declarations may only appear in global scope
de: Objective-C-Deklarationen dürfen nur im globalen Gültigkeitsbereich erscheinen

en: Obsolescent feature:
de: Veraltete Funktion:

en: Offline tool to handle gcda counts
de: Ausgelagertes Werkzeug, um mit gcda-Zähler zu arbeiten

en: Old-style character length at %C
de: Zeichenlänge alten Stils bei %C

en: Old-style initialization at %C
de: Initialisierung im alten Stil bei %C

en: Old-style type declaration %s*%d not supported at %C
de: Deklaration %s*%d im alten Stil wird bei %C nicht unterstützt

en: Omit frame pointer for leaf functions.
de: Rahmenzeiger für Blattfunktionen auslassen.

en: Omit range reduction step when performing complex division.
de: Schritt zur Bereichsverkleinerung auslassen, wenn komplexe Division durchgeführt wird.

en: Omit the frame pointer in leaf functions.
de: Rahmenzeiger in Blattfunktionen auslassen.

en: One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L
de: Eins der tatsächlichen Argumente in INITIALIZER-Klausel von !$OMP DECLARE REDUCTION bei %L muss OMP_PRIV sein

en: Only DEFAULT permitted as reduction-modifier in REDUCTION clause at %L
de: Nur DEFAULT ist als Reduktionsmodifizierer erlaubt, in der REDUCTION-Klausel bei %L

en: Only SOURCE or SINK dependence types are allowed on ORDERED directive at %L
de: Nur SOURCE- oder SINK-Abhängigkeitstypen sind an ORDERED-Direktive bei %L erlaubt

en: Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one
de: Bei %2$L wurde nur FINAL-Feldprozedur für abgeleiteten Typ %1$qs definiert, skalare wird ebenfalls empfohlen

en: Only emit Compiled Module Interface.
de: Nur die Schnittstelle des compilierten Moduls (CMI) ausgeben.

en: Only generate absolute relocations on word sized values.
de: Absolute Auslagerungen nur bei Werten mit Wordgrößen erzeugen.

en: Only intrinsic operators can be used in expression at %L
de: Nur intrinsische Operatoren können in Ausdruck bei %L verwendet werden

en: Only issue one instruction per cycle.
de: Nur einen Befehl pro Taktzyklus ausgeben.

en: Only retained for backward compatibility.
de: Nur für Rückwärtskompatibilität erhalten.

en: Only the !$ACC ROUTINE form without list is allowed in interface block at %C
de: Nur die Form !$ACC ROUTINE ohne Liste ist im Schnittstellenblock bei %C erlaubt

en: Only the !$OMP DECLARE TARGET form without clauses is allowed in interface block at %C
de: Nur die Form !$OMP DECLARE TARGET ohne Klauseln ist im Schnittstellenblock bei %C erlaubt

en: Only use 32 FPRs.
de: Nur 32 FPRs verwenden.

en: Only use 32 GPRs.
de: Nur 32 GPRs verwenden.

en: OpenACC construct inside of non-OpenACC region
de: OpenACC-Konstrukt innerhalb einer Nicht-OpenACC-Region

en: OpenACC directive inside of CRITICAL block at %C
de: OpenACC-Direktive innerhalb von CRITICAL-Block bei %C

en: OpenACC directives other than ROUTINE may not appear in PURE procedures at %C
de: OpenACC-Direktiven außer ROUTINE dürfen in PURE-Prozeduren nicht vorkommen, bei %C

en: OpenACC loop directive must be associated with an OpenACC compute region
de: OpenACC-Schleifendirektive muss mit einer OpenACC-Berechnungsregion verknüpft sein

en: OpenACC region inside of OpenACC routine, nested parallelism not supported yet
de: OpenACC-Region innerhalb einer OpenACC-Routine, geschachtelter Parallelismus wird noch nicht unterstützt

en: OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>
de: OpenMP-Konstrukt inmitten der %<omp::directive%>-Attribute erfordert, dass alle %<omp::directive%>-Attribute derselben Anweisung in derselben %<omp::sequence%> liegen

en: OpenMP constructs are not allowed in target region with %<ancestor%>
de: OpenMP-Konstrukte sind in der Zielregion mit %<ancestor%> nicht erlaubt

en: OpenMP constructs other than %<ordered simd%>, %<simd%>, %<loop%> or %<atomic%> may not be nested inside %<simd%> region
de: OpenMP-Konstrukte außer %<ordered simd%>, %<simd%>, %<loop%> oder %<atomic%> dürfen nicht innerhalb von %<simd%>-Regionen geschachtelt sein

en: OpenMP constructs other than %<parallel%>, %<loop%> or %<simd%> may not be nested inside a %<loop%> region
de: OpenMP-Konstrukte außer %<parallel%>, %<loop%> oder %<simd%> dürfen nicht in einer %<loop%>-Region geschachtelt sein

en: OpenMP constructs other than %<parallel%>, %<loop%> or %<simd%> may not be nested inside a region with the %<order(concurrent)%> clause
de: OpenMP-Konstrukte außer %<parallel%>, %<loop%> oder %<simd%> dürfen nicht innerhalb einer Region mit %<order(concurrent)%>-Klausel geschachtelt sein

en: OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration
de: eine andere OpenMP-Direktive als %<declare simd%> oder %<declare variant%> gehört zu einer Deklaration

en: OpenMP directives other than SIMD or DECLARE TARGET at %C may not appear in PURE procedures
de: OpenMP-Direktiven außer SIMD und DECLARE TARGET bei %C dürfen in PURE-Prozeduren nicht vorkommen

en: OpenMP runtime API call %qD in a region with %<device(ancestor)%> clause
de: Aufruf der OpenMP-Laufzeit-API %qD in einer Region mit %<device(ancestor)%>-Klausel

en: OpenMP runtime API call %qD in a region with %<order(concurrent)%> clause
de: Aufruf der OpenMP-Laufzeit-API %qD in einer Region mit %<order(concurrent)%>-Klausel

en: OpenMP runtime API call %qD strictly nested in a %<teams%> region
de: OpenMP-Laufzeit-API-Aufruf %qD streng in einer %<teams%>-Region verschachtelt

en: Operand of .not. operator at %%L is %s
de: Operand des Operators .not. bei %%L ist %s

en: Operand of unary numeric operator %%<%s%%> at %%L is %s
de: Operand des unären numerischen Operators %%<%s%%> bei %%L ist %s

en: Operand of user operator %%<%s%%> at %%L is %s
de: Operand des Benutzeroperators %%<%s%%> bei %%L ist %s

en: Operands at %L and %L cannot appear as operands of binary operator %qs
de: Operanden bei %L und %L können nicht als Operanden des binären Operators %qs verwendet werden

en: Operands of binary numeric operator %%<%s%%> at %%L are %s/%s
de: Operanden des binären numerischen Operators %%<%s%%> bei %%L sind %s/%s

en: Operands of comparison operator %%<%s%%> at %%L are %s/%s
de: Operanden des Vergleichsoperators %%<%s%%> bei %%L sind %s/%s

en: Operands of logical operator %%<%s%%> at %%L are %s/%s
de: Operanden des logischen Operators %%<%s%%> bei %%L sind %s/%s

en: Operands of string concatenation operator at %%L are %s/%s
de: Operanden des Zeichenkettenverkettungsoperators bei %%L sind %s/%s

en: Operands of user operator %%<%s%%> at %%L are %s/%s
de: Operanden des Benutzeroperators %%<%s%%> bei %%L sind %s/%s

en: Operator interface at %L conflicts with intrinsic interface
de: Operatorschnittstelle bei %L steht mit intrinsischer Schnittstelle in Konflikt

en: Operator interface at %L has the wrong number of arguments
de: Operatorschnittstelle bei %L hat falsche Argumentanzahl

en: Operator interface at %L must have, at most, two arguments
de: Operatorschnittstelle bei %L darf höchstens zwei Argumente haben

en: Optimize amount of stdarg registers saved to stack at start of function.
de: Anzahl der stdarg-Register optimieren, die am Anfang einer Funktion auf dem Stapel gespeichert werden.

en: Optimize conditional patterns using SSA PHI nodes.
de: Bedingte Ausdrücke mittels SSA-PHI-Knoten optimieren.

en: Optimize for CPU.
de: Für CPU optimieren.

en: Optimize for debugging experience rather than speed or size.
de: Auf Fehlersuchmöglichkeiten statt Geschwindigkeit oder Größe optimieren.

en: Optimize for space aggressively rather than speed.
de: Aggressiv auf Größe statt Geschwindigkeit optimieren.

en: Optimize for space rather than speed.
de: Auf Größe statt Geschwindigkeit optimieren.

en: Optimize for speed disregarding exact standards compliance.
de: Auf Geschwindigkeit optimieren, unter Missachtung genauer Standardkonformität.

en: Optimize frame header.
de: Code für Rahmenkopf optimieren.

en: Optimize induction variables on trees.
de: Induktionsvariablen auf Bäumen optimieren.

en: Optimize lui/addiu address loads.
de: lui/addiu-Adressladebefehle optimieren.

en: Optimize opcode sizes at link time.
de: Opcodegrößen zur Linkzeit optimieren.

en: Optimize partition neutering.
de: Partitionsneutralisierung optimieren.

en: Optimize sibling and tail recursive calls.
de: Geschwister- und endrekursive Aufrufe optimieren.

en: Optimize tail call instructions in assembler and linker.
de: Ende-Aufruf-Befehle in Assembler und Binder optimieren.

en: Option %<-fallow-leading-underscore%> is for use only by gfortran developers, and should not be used for implicitly typed variables
de: Option %<-fallow-leading-underscore%> ist nur für gfortran-Entwickler gedacht und sollte nicht für implizit getypte Variable verwendet werden

en: Options to %<-Xassembler%> do not match: %s, %s, dropping all %<-Xassembler%> and %<-Wa%> options.
de: Optionen für %<-Xassembler%> passen nicht zueinander: %s, %s; alle Optionen der Form %<-Xassembler%> und %<-Wa%> werden verworfen.

en: Options:
de: Optionen:

en: Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)
de: Außerhalb des Wertebereichs in IMAGE_INDEX bei %L für Dimension %d, SUB hat %ld und untere Grenze für COARRAY ist %ld

en: Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)
de: Außerhalb des Wertebereichs in IMAGE_INDEX bei %L für Dimension %d, SUB hat %ld und obere Grenze für COARRAY ist %ld

en: Out of stack space.
de: Stapelspeicher aufgebraucht.

en: Output .debug_types section when using DWARF v4 debuginfo.
de: .debug_types-Abschnitt ausgeben, wenn DWARF v4-Debuginfo verwendet wird.

en: Output callgraph information on a per-file basis with decorations.
de: Information über Aufrufgraphen auf Dateibasis mit Dekoration ausgeben.

en: Output callgraph information on a per-file basis.
de: Information über Aufrufgraphen auf Dateibasis ausgeben.

en: Output lto objects containing both the intermediate language and binary output.
de: LTO-Objekte ausgeben, die sowohl Zwischensprache als auch Binärausgabe enthalten.

en: Output stack usage information on a per-function basis.
de: Information über Stapelverwendung auf Funktionsbasis ausgeben.

en: Output vtable verification counters.
de: Verifikationszähler für VTables ausgeben.

en: Output vtable verification pointer sets information.
de: Informationen über Zeigermengen der VTable-Verifikation ausgeben.

en: Overlap subcomand usage:
de: Aufruf des Teilbefehls »overlap«:

en: Overlapping unequal initializers in EQUIVALENCE at %C
de: Überlappende ungleiche Initialisierungen in EQUIVALENCE bei %C

en: Overlapping unequal initializers in EQUIVALENCE at %L
de: Überlappende ungleiche Initialisierungen in EQUIVALENCE bei %L

en: Override -mbest-lib-options.
de: -mbest-lib-options überschreiben.

en: P descriptor requires leading scale factor in format string at %L
de: P-Deskriptor benötigt führenden Skalierungsfaktor in Formatzeichenkette bei %L

en: PAD= at %L not allowed in Fortran 95
de: PAD= bei %L ist in Fortran 95 nicht erlaubt

en: PARAMETER %qs is used at %L before its definition is complete
de: PARAMETER %qs wird bei %L verwendet, bevor dessen Definition vollständig ist

en: PARAMETER %qs shall not appear in a DATA statement at %L
de: PARAMETER %qs darf nicht in einer DATA-Anweisung bei %L vorkommen

en: PARAMETER at %L is missing an initializer
de: Fehlende Initialisierung für PARAMETER bei %L

en: PARAMETER symbol in complex constant at %C
de: PARAMETER-Symbol in komplexer Konstante bei %C

en: PARAMETER without '()' at %C
de: PARAMETER ohne »()« bei %C

en: PAUSE statement at %C
de: PAUSE-Anweisung bei %C

en: PC relative literal loads.
de: Ladebefehle relativ zum PC.

en: PCH allocation failure
de: PCH-Alloziierungsfehler

en: PCH memory is not available: %m
de: PCH-Speicher nicht verfügbar: %m

en: PCS variant
de: PCS-Variante

en: PDP11 bit-field handling unsupported in %qs
de: PDP11-Bitfeld-Verarbeitung wird in %qs nicht unterstützt

en: PHI argument is missing for edge %d->%d
de: PHI-Argument fehlt für Kante %d->%d

en: PHI argument is not SSA_NAME, or invariant
de: PHI-Argument ist kein SSA_NAME, oder invariant

en: PHI argument on abnormal edge is not SSA_NAME
de: PHI-Argument an unnormaler Kante ist nicht SSA_NAME

en: PIC code generation is not compatible with fast indirect calls
de: PIC-Codeerzeugung ist mit schnellen indirekten Aufrufen unverträglich

en: PIC code generation is not supported in the portable runtime model
de: PIC-Codeerzeugung wird im portierbaren Laufzeitmodell nicht unterstützt

en: PIC is not supported for %qs
de: PIC wird für %qs nicht unterstützt

en: PIC is only supported for RTPs
de: PIC wird nur für RTPs unterstützt

en: PIC is required but not supported with CONST16 instructions
de: PIC wird benötigt, wird aber nicht mit CONST16-Befehlen unterstützt

en: PIC register clobbered by %qs in %<asm%>
de: PIC-Register durch %qs in %<asm%> zerstört

en: PIC support for %<-fstack-limit-symbol%>
de: PIC-Unterstützung für %<-fstack-limit-symbol%>

en: POINTER attribute is required for procedure pointer component at %C
de: POINTER-Attribut ist für Prozedurzeiger-Komponente bei %C erforderlich

en: POINTER object %qs in %s clause at %L
de: POINTER-Objekt %qs in Klausel %s bei %L

en: POINTER object %qs of polymorphic type in %s clause at %L
de: POINTER-Objekt %qs von polymorphem Typ in Klausel %s bei %L

en: POINTER-valued function appears on right-hand side of assignment at %L
de: POINTER-wertige Funktion tritt auf rechter Seite der Zuweisung bei %L auf

en: POS argument (%ld) out of range 0:%ld in intrinsic %s
de: POS-Argument (%ld) außerhalb des Bereichs 0:%ld in intrinsischem »%s«

en: POS argument (%ld) out of range 0:%ld in intrinsic BTEST
de: POS-Argument (%ld) außerhalb des Bereichs 0:%ld in intrinsischem BTEST

en: POS argument (%ld) out of range 0:%ld in intrinsic IBITS
de: POS-Argument (%ld) außerhalb des Bereichs 0:%ld in intrinsischem IBITS

en: POS(%ld)+LEN(%ld)>BIT_SIZE(%ld) in intrinsic IBITS
de: POS(%ld)+LEN(%ld)>BIT_SIZE(%ld) in intrinsischem IBITS

en: POSITION specifier in OPEN statement at %L only allowed for stream or sequential ACCESS
de: POSITION-Angabe in OPEN-Anweisung bei %L ist nur für Datenstrom-ACCESS oder für sequentiellen ACCESS erlaubt

en: PRE disabled
de: PRE ausgeschaltet

en: PRINT namelist at %C is an extension
de: PRINT-Namensliste bei %C ist eine Erweiterung

en: PRINT statement at %C not allowed within PURE procedure
de: PRINT-Anweisung bei %C innerhalb PURE-Prozedur nicht erlaubt

en: PRINT_OPERAND, invalid insn for %%C
de: PRINT_OPERAND, ungültiger Befehl für %%C

en: PRINT_OPERAND, invalid insn for %%N
de: PRINT_OPERAND, ungültiger Befehl für %%N

en: PRIVATE statement at %C is only allowed in the specification part of a module
de: PRIVATE-Anweisung bei %C ist nur in Spezifikationsteil eines Moduls erlaubt

en: PRIVATE statement at %C must precede procedure bindings
de: PRIVATE-Anweisung bei %C muss Prozedurbindungen vorausgehen

en: PRIVATE statement at %C must precede structure components
de: PRIVATE-Anweisung bei %C muss Strukturkomponenten vorausgehen

en: PRIVATE statement in TYPE at %C must be inside a MODULE
de: PRIVATE-Anweisung in TYPE bei %C muss innerhalb eines MODULEs sein

en: PROCEDURE %qs at %L may not be used as its own interface
de: PROCEDURE %qs bei %L darf nicht als ihre eigene Schnittstelle verwendet werden

en: PROCEDURE at %C must be in a generic interface
de: PROCEDURE bei %C muss in einer allgemeinen Schnittstelle sein

en: PROCEDURE attribute conflicts with INTENT attribute in %qs at %L
de: Attribut PROCEDURE steht mit Attribut INTENT in %qs bei %L in Konflikt

en: PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L
de: Attribut PROCEDURE steht mit Attribut NAMELIST in %qs bei %L in Konflikt

en: PROCEDURE attribute conflicts with PROTECTED attribute at %L
de: Attribut PROCEDURE steht mit Attribut PROTECTED bei %L in Konflikt

en: PROCEDURE attribute conflicts with RESULT attribute in %qs at %L
de: Attribut PROCEDURE steht mit Attribut RESULT in %qs bei %L in Konflikt

en: PROCEDURE attribute conflicts with SAVE attribute in %qs at %L
de: Attribut PROCEDURE steht mit Attribut SAVE in %qs bei %L in Konflikt

en: PROCEDURE list at %C
de: PROCEDURE-Liste bei %C

en: PROCEDURE statement at %C
de: PROCEDURE-Anweisung bei %C

en: PROCEDURE(interface) at %C should be declared DEFERRED
de: PROCEDURE(Schnittstelle) bei %C sollte als DEFERRED deklariert sein

en: PROTECTED at %C only allowed in specification part of a module
de: PROTECTED bei %C nur in Spezifikationsabschnitts eines Moduls erlaubt

en: PROTECTED attribute at %C
de: PROTECTED-Attribut bei %C

en: PROTECTED attribute conflicts with EXTERNAL attribute at %L
de: Attribut PROTECTED steht mit Attribut EXTERNAL bei %L in Konflikt

en: PROTECTED statement at %C
de: PROTECTED-Anweisung bei %C

en: PTX does not support weak declarations (only weak definitions)
de: PTX unterstützt keine schwachen Deklarationen (nur schwache Definitionen)

en: PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)
de: PTX-Version %<-mptx%> muss mindestens %s sein, um die ausgewählte %<-misa%> (sm_%s) zu unterstützen

en: PUBLIC %s %qs at %L of PRIVATE derived type %qs
de: PUBLIC %s %qs bei %L mit abgeleitetem PRIVATE-Typen %qs

en: PUBLIC function %qs at %L of PRIVATE type %qs
de: PUBLIC-Funktion %qs bei %L mit PRIVATE-Typ %qs

en: PUBLIC statement at %C is only allowed in the specification part of a module
de: PUBLIC-Anweisung bei %C ist nur in Spezifikationsteil eines Moduls erlaubt

en: PURE and IMPURE must not appear both at %C
de: PURE und IMPURE dürfen bei %C nicht gleichzeitig stehen

en: PURE prefix in MODULE PROCEDURE interface is missing at %L
de: PURE-Präfix fehlt in MODULE-PROCEDURE-Schnittstelle bei %L

en: Pack VLIW instructions.
de: VLIW-Befehle packen.

en: Pack structure members together without holes.
de: Strukturelemente ohne Lücken zusammenpacken.

en: Pad shorter fixed form lines to line width with spaces.
de: Kürzere feste Formularzeilen mit Leerzeichen auf Zeilenbreite auffüllen.

en: Padding of %d bytes required before %qs in COMMON %qs at %L; reorder elements or use %<-fno-align-commons%>
de: Auffüllen mit %d Bytes vor %qs in COMMON %qs bei %L erforderlich; bitte Elemente umordnen oder %<-fno-align-commons%> verwenden

en: Padding of %d bytes required before %qs in COMMON at %L; reorder elements or use %<-fno-align-commons%>
de: Auffüllen mit %d Bytes vor %qs in COMMON bei %L erforderlich; bitte Elemente umordnen oder %<-fno-align-commons%> verwenden

en: Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression
de: Parameter %qs bei %L wurde nicht deklariert oder ist eine Variable, die nicht zu konstantem Ausdruck reduziert

en: Parameter array %qs at %L cannot be automatic or of deferred shape
de: Parameterfeld %qs bei %L kann nicht automatische oder vermutete Form haben

en: Parameterized derived type at %C is ambiguous
de: Der parametrisierte abgeleitete Typ bei %C ist mehrdeutig

en: Parameterized type %qs does not have a component corresponding to parameter %qs at %L
de: Parametrisierter Typ %1$qs hat bei %3$L keine Komponente, die zu Parameter %2$qs gehört

en: Pass -EB option through to linker.
de: Option -EB an den Linker übergeben.

en: Pass -EL option through to linker.
de: Option -EL an den Linker übergeben.

en: Pass -marclinux option through to linker.
de: Option -marclinux an den Linker übergeben.

en: Pass -marclinux_prof option through to linker.
de: Option -marclinux_prof an den Linker übergeben.

en: Pass -z text to linker.
de: »-z text« an den Linker übergeben.

en: Pass the address of the ra save location to _mcount in $12.
de: Adresse der RA-Speicherstelle an _mcount in $12 übergeben.

en: Passed-object at %L must be scalar
de: Weitergegebenes Objekt bei %L muss Skalar sein

en: Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure
de: Scheinargument des übergebenen Objektes von %qs bei %L muss an der gleichen Stelle wie das Scheinargument des übergebenen Objektes der überschriebenen Prozedur stehen

en: Passed-object dummy argument of %qs at %L must be scalar
de: Scheinargument von %qs für weitergegebenes Objekt bei %L muss ein Skalar sein

en: Passed-object dummy argument of %qs at %L must not be ALLOCATABLE
de: Scheinargument von %qs für weitergegebenes Objekt bei %L darf nicht ALLOCATABLE sein

en: Passed-object dummy argument of %qs at %L must not be POINTER
de: Scheinargument von %qs für weitergegebenes Objekt bei %L darf nicht POINTER sein

en: Passes on a request to the assembler to enable fixes for various silicon errata.
de: Gibt an den Assembler eine Anforderung weiter, damit dieser diverse Chipfehler umgeht.

en: Passes on a request to the assembler to warn about various silicon errata.
de: Gibt an den Assembler eine Anforderung weiter, damit dieser bei diversen Chipfehlern warnt.

en: Passing coarray at %L to allocatable, noncoarray dummy argument %qs, which is invalid if the allocation status is modified
de: Koarray bei %L wird an reservierbares, Nicht-Coarray-Scheinargument %qs übergeben, das ungültig wird, wenn der Reservierungsstatus geändert wird

en: Passing coarray at %L to allocatable, noncoarray, INTENT(OUT) dummy argument %qs
de: Koarray bei %L wird an reservierbares, Nicht-Coarray, INTENT(OUT) Scheinargument %qs übergeben

en: Passing internal procedure at %L by location not allowed
de: Übergabe der eingebauten Prozedur über die Speicherstelle ist bei %L nicht erlaubt

en: Path to header file that should be pre-included before each compilation unit.
de: Pfad zu Headerdatei, die vor jeder Übersetzungseinheit eingebunden wird.

en: Percentage penalty functions containing a single call to another function will receive when they are evaluated for cloning.
de: Prozentuale Strafe für Funktionen, die nur einen einzigen Aufruf einer anderen Funktion enthalten, wenn sie zum Klonen evaluiert werden.

en: Percentage penalty the recursive functions will receive when they are evaluated for cloning.
de: Prozentuale Strafe für rekursive Funktionen, wenn sie zum Klonen evaluiert werden.

en: Perform IPA Value Range Propagation.
de: Informationen über IPA-Wertebereiche weitergeben.

en: Perform Identical Code Folding for functions and read-only variables.
de: Identischen Code für Funktionen und schreibgeschützte Variablen zusammenfassen.

en: Perform Identical Code Folding for functions.
de: Identischen Code für Funktionen zusammenfassen.

en: Perform Identical Code Folding for variables.
de: Identischen Code für Variablen zusammenfassen.

en: Perform SMS based modulo scheduling before the first scheduling pass.
de: SMS-basierte modulo-Planung vor erstem Planungsdurchlauf durchführen.

en: Perform SMS based modulo scheduling with register moves allowed.
de: SMS-basierte modulo-Planung mit erlaubten Register-Verschiebungen durchführen.

en: Perform VR4130-specific alignment optimizations.
de: VR4130-spezifische Ausrichtungs-Optimierungen durchführen.

en: Perform Value Range Propagation on trees.
de: Wertebereichsweitergabe auf Bäumen durchführen.

en: Perform a forward propagation pass on RTL.
de: Schritt zur Vorwärts-Übertragung auf RTL durchführen.

en: Perform a number of minor, expensive optimizations.
de: Eine Reihe kleiner, aber teurer, Optimierungen durchführen.

en: Perform a register copy-propagation optimization pass.
de: Optimierungsdurchlauf zur Kopierübertragung von Registern durchführen.

en: Perform a register renaming optimization pass.
de: Einen Optimierungsdurchgang zur Registerumbenennung durchführen.

en: Perform a target dependent instruction fusion optimization pass.
de: Einen zielabhängigen Optimierungsdurchgang zur Befehlsfusion durchführen.

en: Perform cloning to make Interprocedural constant propagation stronger.
de: Kopien erzeugen, um zwischenprozedurale Konstantenweitergabe zu verstärken.

en: Perform comparison elimination after register allocation has finished.
de: Beseitigung von Vergleichen nach Registerreservierung durchführen.

en: Perform conversion of conditional jumps to branchless equivalents.
de: Umwandlung bedingter Sprünge in zweiglose Äquivalente durchführen.

en: Perform conversion of conditional jumps to conditional execution.
de: Umwandlung bedingter Sprünge in bedingte Ausführung durchführen.

en: Perform conversions of switch initializations.
de: Umwandlungen von »switch«-Initialisierungen durchführen.

en: Perform cross-jumping optimization.
de: Optimierung zum Kreuzsprung durchführen.

en: Perform early inlining.
de: Frühes Inlining durchführen.

en: Perform enhanced load motion during global common subexpression elimination.
de: Erweiterte Ladebewegung während Beseitigung globaler gemeinsamer Teilausdrücke durchführen.

en: Perform function-local points-to analysis on trees.
de: Funktionslokale Analyse von Zeigerzielen auf Bäumen durchführen.

en: Perform global common subexpression elimination after register allocation has finished.
de: Beseitigung globaler gemeinsamer Teilausdrücke nach Registerreservierung durchführen.

en: Perform global common subexpression elimination.
de: Beseitigung globaler gemeinsamer Teilausdrücke durchführen.

en: Perform indirect inlining.
de: Indirektes Inlining durchführen.

en: Perform internal consistency checkings.
de: Interne Konsistenzprüfungen durchführen.

en: Perform interprocedural bitwise constant propagation.
de: Zwischenprozedurale bitweise Konstantenweitergabe durchführen.

en: Perform interprocedural constant propagation.
de: Zwischenprozedurale Konstantenweitergabe durchführen.

en: Perform interprocedural modref analysis.
de: Prozedurübergreifende modref-Analyse durchführen.

en: Perform interprocedural points-to analysis.
de: Zwischenprozedurale Zeigt-auf-Analyse durchführen.

en: Perform interprocedural profile propagation.
de: Zwischenprozedurale Profilweitergabe durchführen.

en: Perform interprocedural reduction of aggregates.
de: Zwischenprozedurale Reduktion von Aggregaten durchführen.

en: Perform jump threading optimizations.
de: Sprung-Threading-Optimierungen durchführen.

en: Perform live range splitting during the SSA->normal pass.
de: Lebensdaueraufteilung während des »SSA -> Normal«-Durchlaufs durchführen.

en: Perform loop peeling.
de: Schleifen-Schälung durchführen.

en: Perform loop splitting.
de: Schleifen-Aufteilung durchführen.

en: Perform loop unrolling for all loops.
de: Schleifenabwicklung für alle Schleifen durchführen.

en: Perform loop unrolling when iteration count is known.
de: Schleifenabwicklung durchführen, wenn Anzahl der Wiederholungen bekannt ist.

en: Perform loop unswitching.
de: Schleifenausschaltung durchführen.

en: Perform partial inlining.
de: Teilweises Inlining durchführen.

en: Perform redundant load after store elimination in global common subexpression elimination.
de: Beseitigung überflüssigen Ladens nach dem Abspeichern in globalem gemeinsamem Teilausdruck durchführen.

en: Perform scalar replacement of aggregates.
de: Skalarersetzung von Aggregaten durchführen.

en: Perform software pipelining of inner loops during selective scheduling.
de: Während selektiver Planung Software-Pipelining innerer Schleifen durchführen.

en: Perform software pipelining of outer loops during selective scheduling.
de: Während selektiver Planung Software-Pipelining äußerer Schleifen durchführen.

en: Perform speculative devirtualization.
de: Spekulative Devirtualisierung durchführen.

en: Perform store motion after global common subexpression elimination.
de: Speicherbewegung nach Beseitigung globaler gemeinsamer Teilausdrücke durchführen.

en: Perform straight-line strength reduction.
de: Geradlinige Stärkereduktion durchführen.

en: Perform superblock formation via tail duplication.
de: Superblockerzeugung über Ende-Vervielfältigung durchführen.

en: Perform unroll-and-jam on loops.
de: Schleifenabwicklung (unroll-and-jam) für Schleifen durchführen.

en: Perform unused symbol elimination in debug info.
de: Ungenutzte Symbole aus Info zur Fehlersuche entfernen.

en: Perform unused type elimination in debug info.
de: Ungenutzte Typen aus Info zur Fehlersuche entfernen.

en: Perform variable tracking and also tag variables that are uninitialized.
de: Variablenverfolgung durchführen und auch Variablen markieren, die uninitialisiert sind.

en: Perform variable tracking by annotating assignments.
de: Variablenverfolgung durch Zuweisungsanmerkungen durchführen.

en: Perform variable tracking.
de: Variablenverfolgung durchführen.

en: Perform whole program optimizations.
de: Gesamtprogrammoptimierung durchführen.

en: Period required in format specifier %s at %L
de: Formatspezifikation %s bei %L erfordert Punkt

en: Period required in format specifier at %L
de: Formatspezifikation bei %L erfordert Punkt

en: Period required in format specifier in format string at %L
de: Formatspezifikation benötigt Punkt in Formatzeichenkette bei %L

en: Permit '$' as an identifier character.
de: »$« als Bezeichnerzeichen zulassen.

en: Permit nonconforming uses of the tab character.
de: Unpassende Verwendungen des TAB-Zeichens erlauben.

en: Permit scheduling of a function's prologue and epilogue sequence.
de: Planung einer Sequenz für Funktionsprolog und -epilog erlauben.

en: Permit scheduling of a function's prologue sequence.
de: Planung einer Funktionsprologsequenz erlauben.

en: Permit scheduling of function prologue and epilogue sequences.
de: Planung von Funktionsprolog- und -epilogsequenzen erlauben.

en: Permit universal character names (\u and \U) in identifiers.
de: Universelle Zeichennamen (\u und \U) in Bezeichnern zulassen.

en: Place a stop bit after every cycle when scheduling.
de: Bei Planung ein Stopp-Bit nach jedem Takt einfügen.

en: Place data items into their own section.
de: Datenstücke in ihren eigenen Abschnitt legen.

en: Place each function into its own section.
de: Jede Funktion in ihren eigenen Abschnitt platzieren.

en: Place floating point constants in TOC.
de: Gleitkommakonstanten ins TOC legen.

en: Place symbol+offset constants in TOC.
de: Symbol+Offset-Konstanten ins TOC legen.

en: Please include the complete backtrace with any bug report.
de: Bitte fügen Sie jedem Fehlerbericht die vollständige Aufrufkette bei.

en: Please submit a full bug report, with preprocessed source (by using -freport-bug).
de: Bitte senden Sie einen vollständigen Fehlerbericht auf Englisch ein;
    inclusive vorverarbeitetem Quellcode (siehe -freport-bug).

en: Please submit a full bug report, with preprocessed source.
de: Bitte senden Sie einen vollständigen Fehlerbericht auf Englisch ein;
    inclusive vorverarbeitetem Quellcode.

en: Pointer array component of structure at %C must have a deferred shape
de: Zeigerfeld-Komponente der Struktur bei %C muss eine aufgeschobene Form haben

en: Pointer assignment target cannot be a constant at %L
de: Zeiger-Zuweisungsziel darf keine Konstante sein bei %L

en: Pointer assignment target has PROTECTED attribute at %L
de: Zeiger-Zuweisungsziel hat PROTECTED-Attribut bei %L

en: Pointer assignment target in initialization expression does not have the TARGET attribute at %L
de: Ziel der Zeigerzuweisung in Initialisierungsausdruck bei %L muss das TARGET-Attribut haben

en: Pointer assignment target is neither TARGET nor POINTER at %L
de: Zeiger-Zuweisungsziel bei %L ist weder TARGET noch POINTER

en: Pointer assignment target is not a POINTER at %L
de: Zeiger-Zuweisungsziel ist kein POINTER bei %L

en: Pointer assignment with vector subscript on rhs at %L
de: Zeigerzuweisung mit Vektorindex für rhs bei %L

en: Pointer at %L in pointer assignment might outlive the pointer target
de: Zeiger bei %L in Zeigerzuweisung könnte Zeigerziel überdauern

en: Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)
de: Das Zeichenzeiger-Dummy-Argument %qs bei %L muss eine verzögerte Länge haben, da die Prozedur %qs BIND(C) ist

en: Pointer component %s at %L has a noncoarray subcomponent of type EVENT_TYPE, which must have a codimension or be a subcomponent of a coarray
de: Zeigerkomponente %s bei %L hat eine Subkomponente als Nicht-Koarray des Type EVENT_TYPE, die eine Kodimension haben muss oder eine Subkomponente eines Koarrays sein muss

en: Pointer component %s at %L has a noncoarray subcomponent of type LOCK_TYPE, which must have a codimension or be a subcomponent of a coarray
de: Zeigerkomponente %s bei %L hat eine Subkomponente als Nicht-Koarray des Type LOCK_TYPE, die eine Kodimension haben muss oder eine Subkomponente eines Koarrays sein muss

en: Pointer initialization at %C requires %<=>%>, not %<=%>
de: Zeigerinitialisierung bei %C benötigt %<=>%>, nicht %<=%>

en: Pointer initialization target at %L must have the SAVE attribute
de: Ziel der Zeigerinitialisierung bei %L muss das SAVE-Attribut haben

en: Pointer initialization target at %L must have the TARGET attribute
de: Ziel der Zeigerinitialisierung bei %L muss das TARGET-Attribut haben

en: Pointer initialization target at %L must not be ALLOCATABLE
de: Ziel der Zeigerinitialisierung bei %L darf nicht ALLOCATABLE sein

en: Pointer object at %C shall not be coindexed
de: Zeigerobjekt bei %C darf nicht koindiziert sein

en: Pointer object at %L shall not have a coindex
de: Zeigerobjekt bei %L darf keinen Koindex haben

en: Pointer procedure assignment at %L
de: Zuweisung eines Prozedurzeigers bei %L

en: Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute
de: Zeigerfeld als effektives Argument bei %L erfordert wegen VOLATILE-Attribut ein Scheinargument %qs mit vermuteter Form oder als Zeigerfeld

en: Pointers are 32-bit.
de: Zeiger sind 32 Bit.

en: Pointers are 64-bit.
de: Zeiger sind 64 Bit.

en: Policies available for use with -mcompact-branches=:
de: Mögliche Richtlinien für »-mcompact-branches=«:

en: Polymorphic FPTR at %L to C_F_POINTER
de: Polymorpher FPTR bei %L für C_F_POINTER

en: Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s
de: Polymorphe Komponente %s bei %L in SEQUENCE oder BIND(C)-Typ %s

en: Polymorphic scalar passed to array dummy argument %qs at %L
de: Polymorphes Skalar wird an Feld-Scheinargument %qs bei %L übergeben

en: Polymorphic subobject of coindexed object at %L
de: Polymorphes Subobjekt des koindizierten Objektes bei %L

en: Positive exponent width required in format string at %L
de: Positive Exponentenbreite benötigt in Formatzeichenkette bei %L

en: Positive width required in format specifier %s at %L
de: Positive Breite in Formatspezifizierung %s bei %L erforderlich

en: Positive width required in format string at %L
de: Positive Breite in Formatzeichenkette bei %L benötigt

en: Positive width required with T descriptor in format string at %L
de: T-Deskriptor benötigt positive Breite in Formatzeichenkette bei %L

en: Possible change of value in conversion from %s to %s at %L
de: Mögliche Wertänderung bei Umwandlung von %s in %s bei %L

en: Prefer branches over conditional execution.
de: Zweige gegenüber bedingter Ausführung bevorzugen.

en: Prefer word accesses over byte accesses.
de: Wortzugriffe bevorzugen (statt Bytezugriffen).

en: Preferentially allocate registers that allow short instruction generation.
de: Vorzugsweise Register reservieren, die kurze Befehle ermöglichen.

en: Prepend global symbols with ":" (for use with PREFIX).
de: Globalen Symbolen ein »:« voranstellen (für Verwendung mit PREFIX).

en: Preprocess directives only.
de: Nur Direktiven vorverarbeiten.

en: Preprocessed source stored into %s file, please attach this to your bugreport.
de: Vorverarbeiteter Quellcode wurde in Datei %s gespeichert, bitte hängen Sie die an Ihren Fehlerbericht an.

en: Preserve the PowerPC 476's link stack by matching up a blr with the bcl/bl insns used for GOT accesses.
de: Bindestapel des PowerPC 476 durch Anpassen eines blr an bcl/bl-Befehle für GOT-Zugriffe beibehalten.

en: Pretend a branch-around-a-move is a conditional move.
de: Vorgeben, dass branch-around-a-move ein bedingter Sprung ist.

en: Prevent $fp being allocated during register allocation so that compiler is able to force performing fp-as-gp optimization.
de: Verhindern, dass $fp während der Registerallozierung alloziert wird, so dass der Compiler die FP-als-GP-Optimierung durchführen kann.

en: Prevent optimizing block moves, which is also the default behavior of -Os.
de: Die Optimierung von Blockkopieraktionen verhindern, was auch das Standardverhalten von -Os ist.

en: Prevent the use of all floating-point operations.
de: Verwendung aller Gleitkommaoperationen verhindern.

en: Prevent the use of all hardware floating-point instructions.
de: Verwendung aller Hardware-Gleitkommabefehle verhindern.

en: Previous !$OMP DECLARE REDUCTION at %L
de: Vorherige !$OMP DECLARE REDUCTION bei %L

en: Previous !$OMP DECLARE REDUCTION from module %s at %L
de: Vorherige !$OMP DECLARE REDUCTION von Modul %s bei %L

en: Print CPU tuning information as comment in assembler file.  This is an option used only for regression testing of the compiler and not intended for ordinary use in compiling code.
de: CPU-Feinabstimmung als Kommentar in Assemblerdatei ausgeben. Diese Option wird nur für Regressionstest des Compilers verwendet und ist nicht für den normalen Betrieb vorgesehen.

en: Print CWE identifiers for diagnostic messages, where available.
de: CWE-Identifikatoren für Diagnosemeldungen ausgeben, sofern verfügbar.

en: Print code coverage information.
de: Information zur Code-Überdeckung ausgeben.

en: Print extra (possibly unwanted) warnings.
de: Zusätzliche (möglicherweise ungewollte) Warnungen ausgeben.

en: Print fix-it hints in machine-readable form.
de: Behebungshinweise in maschinenlesbarer Form ausgeben.

en: Print fix-it hints to stderr in unified diff format.
de: Behebungshinweise in vereinheitlichtem Diff-Format auf stderr ausgeben.

en: Print hierarchical comparisons when template types are mismatched.
de: Hierarchische Vergleiche ausgeben, wenn die Templatetypen nicht zusammenpassen.

en: Print the initial values of the variables.
de: Den Initialwert der Variablen ausgeben.

en: Print the name of header files as they are used.
de: Namen der Header-Dateien ausgeben, wie sie verwendet werden.

en: Probability that COMDAT function will be shared with different compilation unit.
de: Wahrscheinlichkeit, dass die COMDAT-Funktion mit anderer Kompilationseinheit geteilt wird.

en: Procedure %qs at %C has an explicit interface from a previous declaration
de: Prozedur %qs bei %C hat eine explizite Schnittstelle aus einer vorherigen Deklaration

en: Procedure %qs at %C is already defined at %L
de: Prozedur %qs bei %C wurde bereits bei %L definiert

en: Procedure %qs at %L already has basic type of %s
de: Prozedur %qs bei %L hat bereits grundlegenden Typen %s

en: Procedure %qs at %L has the same name as a component of %qs
de: Prozedur %qs bei %L hat den gleichen Namen wie eine Komponente von %qs

en: Procedure %qs at %L has the same name as an inherited component of %qs
de: Prozedur %qs bei %L hat den selben Namen wie eine vererbte Komponente von %qs

en: Procedure %qs at %L may not have basic type of %s
de: Prozedur %qs bei %L kann nicht grundlegenden Typen %s haben

en: Procedure %qs at %L must have the BIND(C) attribute to be C interoperable
de: Prozedur %qs bei %L muss das BIND(C)-Attribut haben, um mit C interoperabel zu sein

en: Procedure %qs called at %L is not explicitly declared
de: Prozedur %qs, die bei %L aufgerufen wird, ist nicht explizit deklariert

en: Procedure %qs called at %L is not explicitly declared; did you mean %qs?
de: Prozedur %qs, die bei %L aufgerufen wird, ist nicht explizit deklariert; meinen Sie %qs?

en: Procedure %qs called with an implicit interface at %L
de: Prozedur %qs mit einer impliziten Schnittstelle bei %L aufgerufen

en: Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C
de: Die Prozedur %qs, die im Interface-Körper bei %L definiert ist, passt nicht zu der internen Prozedur bei %C

en: Procedure %qs in %s at %L has no explicit interface
de: Prozedur %qs in %s bei %L hat keine explizite Schnittstelle

en: Procedure %qs in %s at %L has no explicit interface; did you mean %qs?
de: Prozedur %qs in %s bei %L hat keine explizite Schnittstelle; meinen Sie %qs?

en: Procedure %qs in %s at %L is neither function nor subroutine
de: Prozedur %qs in %s bei %L ist weder Funktion noch Subroutine

en: Procedure %qs in %s at %L is neither function nor subroutine; did you mean %qs?
de: Prozedur %qs in %s bei %L ist weder Funktion noch Subroutine; meinen Sie %qs?

en: Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE
de: Prozedur %qs in PUBLIC-Schnittstelle %qs bei %L nimmt Scheinargumente von %qs, das PRIVATE ist

en: Procedure %qs with PASS at %L must have at least one argument
de: Prozedur %qs mit PASS bei %L muss mindestens ein Argument haben

en: Procedure %qs with PASS(%s) at %L has no argument %qs
de: Prozedur %qs mit PASS(%s) bei %L hat kein Argument %qs

en: Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L
de: Prozedur %1$qs bei %3$L mit Binde-Marke %2$qs verwenden denselben globalen Bezeichner wie die Entität bei %4$L

en: Procedure argument at %L is local to a PURE procedure and has the POINTER attribute
de: Prozedurargument bei %L ist lokal für PURE-Prozedur und hat das POINTER-Attribut

en: Procedure pointer %qs at %L shall not be elemental
de: Prozedurzeiger %qs bei %L darf nicht ELEMENTAL sein

en: Procedure pointer %qs in %s clause at %L
de: Prozedurzeiger %qs in %s-Klausel bei %L

en: Procedure pointer at %C
de: Prozedur-Zeiger bei %C

en: Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L
de: Komponente %qs des Prozedurzeigers bei %L kann kein Element des BIND(C)-abgeleiteten Typs %qs bei %L sein

en: Procedure pointer component %qs called with an implicit interface at %L
de: Prozedurzeiger-Komponente %qs mit einer impliziten Schnittstelle bei %L aufgerufen

en: Procedure pointer component %qs requires an argument list at %C
de: Prozedurzeiger-Komponente %qs erfordert eine Argumentliste bei %C

en: Procedure pointer component %qs with PASS at %L must have at least one argument
de: Prozedurzeiger-Komponente %qs mit PASS bei %L muss mindestens ein Argument haben

en: Procedure pointer component %qs with PASS(%s) at %L has no argument %qs
de: Prozedurzeiger-Komponente %qs mit PASS(%s) bei %L hat kein Argument %qs

en: Procedure pointer component at %C
de: Prozedurzeiger-Komponente bei %C

en: Procedure pointer initialization target at %L may not be a procedure pointer
de: Ziel der Zeigerinitialisierung für Prozedur bei %L darf kein Prozedurzeiger sein

en: Procedure pointer result %qs at %L is missing the pointer attribute
de: Dem Ergebnis %qs als Prozedurzeiger bei %L fehlt das POINTER-Attribut

en: Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute
de: Prozedurzeigerziel %qs bei %L muss entweder eine intrinsische Funktion, host- oder use-assoziiert oder referenziert sein, oder aber das EXTERNAL-Attribut haben

en: Process #ident directives.
de: #ident-Direktiven verarbeiten.

en: Process all modules specified on the command line, but only generate code for the module specified by the argument.
de: Alle in der Kommandozeile angegebenen Module verarbeiten, aber den Code nur für das im Argument angegebene Modul generieren.

en: Processing spec (%s), which is '%s'
de: Spezifikation (%s, ist »%s«) wird verarbeitet

en: Produce a Mach-O dylinker (file type MH_DYLINKER), only used for building dyld.
de: Einen Mach-O-Dylinker (Dateityp MH_DYLINKER) generieren. Wird nur verwendet, um dyld zu bauen.

en: Produce a Mach-O shared library (file type MH_DYLIB), synonym for "-shared".
de: Eine gemeinsam genutzte Mach-O-Bibliothek (Dateityp MH_DYLIB) generieren, Synonym für »-shared«.

en: Produce a backtrace when a runtime error is encountered.
de: Backtrace erzeugen, wenn Laufzeitfehler auftritt.

en: Produce a warning at runtime if a array temporary has been created for a procedure argument.
de: Warnung zur Laufzeit erzeugen, wenn ein temporäres Feld für Prozedurargument erzeugt wurde.

en: Produce big endian code.
de: Big-Endian-Code erzeugen.

en: Produce code relocatable at runtime.
de: Code erzeugen, der zur Laufzeit verschiebbar ist.

en: Produce little endian code.
de: Little-Endian-Code erzeugen.

en: Produces a Mach-O file suitable for embedded/ROM use.
de: Erzeugt eine Mach-O-Datei, die für die Verwendung in eingebetteten Systemen / ROMs geeignet ist.

en: Profile information in %s corrupted
de: Profilinformation in %s ist beschädigt

en: Program is entirely located in low 64k of memory.
de: Programm befindet sich vollständig in unteren 64k des Speichers.

en: Program unit at %L has OpenMP device constructs/routines but does not set !$OMP REQUIRES REVERSE_OFFSET but other program units do
de: Programmeinheit bei %L hat OpenMP-Geräte-Konstrukte/-Routinen, setzt jedoch nicht !$OMP REQUIRES REVERSE_OFFSET, aber andere Programmeinheiten tun das

en: Program unit at %L has OpenMP device constructs/routines but does not set !$OMP REQUIRES UNIFIED_ADDRESS but other program units do
de: Programmeinheit bei %L hat OpenMP-Geräte-Konstrukte/-Routinen, setzt jedoch nicht !$OMP REQUIRES UNIFIED_ADDRESS, aber andere Programmeinheiten tun das

en: Program unit at %L has OpenMP device constructs/routines but does not set !$OMP REQUIRES UNIFIED_SHARED_MEMORY but other program units do
de: Programmeinheit bei %L hat OpenMP-Geräte-Konstrukte/-Routinen, setzt jedoch nicht !$OMP REQUIRES UNIFIED_SHARED_MEMORY, aber andere Programmeinheiten tun das

en: Prohibit PC relative function calls.
de: PC-relative Funktionsaufrufe verbieten.

en: Prohibit PC relative jumps.
de: PC-relative Sprünge verbieten.

en: Protect parentheses in expressions.
de: Klammern in Ausdrücken schützen.

en: Provide bash completion for options starting with provided string.
de: Bash-Vervollständigung für Optionen anbieten, die mit der angegebenen Zeichenkette beginnen.

en: Provide libraries for the simulator.
de: Bibliotheken für den Simulator bereitstellen.

en: Purge unneeded state during analysis.
de: Ungenutze Zustände während der Analyse verwerfen.

en: Push extended registers on stack in monitor functions.
de: In Überwachungsfunktionen erweiterte Register auf Stapel sichern.

en: Put all local arrays on stack.
de: Alle lokalen Felder über Stapel übergeben.

en: Put everything in the regular TOC.
de: Alles in reguläres TOC legen.

en: Put jump tables for switch statements into the .data section rather than the .code section.
de: Sprungtabellen für »switch«-Anweisungen in den .data-Abschnitt statt in den .code-Abschnitt einfügen.

en: Put relocated read-only data into .data section.
de: Umgelagerte Nur-Lese-Daten in .data-Abschnitt legen.

en: Put uninitialized constants in ROM (needs -membedded-data).
de: Uninitialisierte Konstanten im ROM ablegen (benötigt -membedded-data).

en: Put uninitialized globals in the common section.
de: Uninitialisierte globale Symbole in gemeinsamen Abschnitt legen.

en: Put zero initialized data in the bss section.
de: Null-initialisierte Daten in den bss-Abschnitt legen.

en: QUIET specifier at %L must be a scalar LOGICAL
de: Der Spezifizierer QUIET bei %L muss ein skalarer LOGICAL sein

en: QUIET= specifier for %s at %L
de: Spezifizierer QUIET= für %s bei %L

en: R2 architecture is little-endian only
de: Die R2-Architektur ist ausschließlich Little-Endian

en: RANK (%i) at %L is repeated at %L
de: RANK (%i) bei %L wird bei %L wiederholt

en: RANK (*) at %L cannot be used with the pointer or allocatable selector at %L
de: RANK (*) bei %L kann nicht mit dem Zeiger oder dem allozierbaren Selektor bei %L verwendet werden

en: RANK (*) at %L is repeated at %L
de: RANK (*) bei %L wird bei %L wiederholt

en: RANK DEFAULT at %L is repeated at %L
de: RANK DEFAULT bei %L wird bei %L wiederholt

en: RE or IM part_ref at %C
de: RE oder IM part_ref bei %C

en: RE part_ref at %C
de: RE-part_ref bei %C

en: REAL array index at %L
de: REAL-Feld-Index bei %L

en: REAL(KIND=10) is not available for %<-fdefault-real-10%> option
de: REAL(KIND=10) ist nicht verfügbar für Option %<-fdefault-real-10%>

en: REAL(KIND=10) is not available for %<-freal-4-real-10%> option
de: REAL(KIND=10) ist nicht verfügbar für Option %<-freal-4-real-10%>

en: REAL(KIND=10) is not available for %<-freal-8-real-10%> option
de: REAL(KIND=10) ist nicht verfügbar für Option %<-freal-8-real-10%>

en: REAL(KIND=10) is not available for %<-freal-8-real-16%> option
de: REAL(KIND=10) ist nicht verfügbar für Option %<-freal-8-real-16%>

en: REAL(KIND=16) is not available for %<-fdefault-real-16%> option
de: REAL(KIND=16) ist nicht verfügbar für Option %<-fdefault-real-16%>

en: REAL(KIND=16) is not available for %<-freal-4-real-16%> option
de: REAL(KIND=16) ist nicht verfügbar für Option %<-freal-4-real-16%>

en: REAL(KIND=4) is not available for %<-freal-8-real-4%> option
de: REAL(KIND=4) ist nicht verfügbar für Option %<-freal-8-real-4%>

en: REAL(KIND=8) is not available for %<-fdefault-real-8%> option
de: REAL(KIND=8) ist nicht verfügbar für Option %<-fdefault-real-8%>

en: REAL(KIND=8) is not available for %<-freal-4-real-8%> option
de: REAL(KIND=8) ist nicht verfügbar für Option %<-freal-4-real-8%>

en: RECL in OPEN statement at %L must be positive
de: RECL in OPEN-Anweisung bei %L muss positiv sein

en: RECL specifier not allowed in OPEN statement at %L for stream I/O
de: RECL-Angabe nicht erlaubt in OPEN-Anweisung bei %L für Datenstrom-Ein-/Ausgabe

en: RECORD at %C is an extension, enable it with %<-fdec-structure%>
de: RECORD bei %C ist eine Erweiterung, muss mit %<-fdec-structure%> eingeschaltet werden

en: RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L
de: RECURSIVE-Präfix fehlt in MODULE-PROCEDURE-Schnittstelle bei %L

en: RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement
de: Die RESULT-Variable %qs bei %L verbietet, dass der FUNCTION-Name %qs bei %C in einer Spezifikationsanweisung auftritt

en: RESULT variable at %C must be different than function name
de: RESULT-Variable bei %C muss vom Funktionsnamen verschieden sein

en: RETURN statement in main program at %C
de: RETURN-Anweisung im Hauptprogramm bei %C

en: ROUND= at %L not allowed in Fortran 95
de: ROUND= bei %L ist in Fortran 95 nicht erlaubt

en: RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d
de: Interner Fehler: RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d

en: RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d
de: Interner Fehler: RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d

en: RTL check: access of hwi elt %d of vector with last elt %d in %s, at %s:%d
de: Interner Fehler: RTL check: access of hwi elt %d of vector with last elt %d in %s, at %s:%d

en: RTL check: attempt to treat non-block symbol as a block symbol in %s, at %s:%d
de: Interner Fehler: RTL check: attempt to treat non-block symbol as a block symbol in %s, at %s:%d

en: RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d
de: Interner Fehler: RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d

en: RTL check: expected code '%s', '%s' or '%s', have '%s' in %s, at %s:%d
de: Interner Fehler: RTL check: expected code '%s', '%s' or '%s', have '%s' in %s, at %s:%d

en: RTL check: expected code '%s', have '%s' in %s, at %s:%d
de: Interner Fehler: RTL check: expected code '%s', have '%s' in %s, at %s:%d

en: RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d
de: Interner Fehler: RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d

en: RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d
de: Interner Fehler: RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d

en: RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d
de: Interner Fehler: RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d

en: RTP PIC is incompatible with %<-msingle-pic-base%>
de: RTP PIC ist mit %<-msingle-pic-base%> unverträglich

en: RTP PIC is incompatible with Thumb
de: RTP PIC ist mit Thumb unverträglich

en: RTTI will not work on this type
de: RTTI wird für diesen Typ nicht funktionieren

en: RX FPU instructions do not support NaNs and infinities
de: RX-FPU-Befehle unterstützen keine NaNs und Unendlichkeiten

en: Raising a negative REAL at %L to a REAL power is prohibited
de: Erhöhung eines negativen REAL bei %L zu einer REAL-Potenz ist verboten

en: Range specification at %L can never be matched
de: Bereichsspezifikation bei %L kann nie passen

en: Rank mismatch between actual argument at %L and actual argument at %L (rank-%d and rank-%d)
de: Unverträgliche Ränge zwischen Argument bei %L und Argument bei %L (Rang-%d und Rang-%d)

en: Rank mismatch between actual argument at %L and actual argument at %L (rank-%d and scalar)
de: Unverträgliche Ränge zwischen Argument bei %L und Argument bei %L (Rang-%d und skalar)

en: Rank mismatch between actual argument at %L and actual argument at %L (scalar and rank-%d)
de: Unverträgliche Ränge zwischen Argument bei %L und Argument bei %L (skalar und Rang-%d)

en: Rank mismatch in argument %qs at %L (rank-%d and rank-%d)
de: Unpassender Rang in Argument %qs bei %L (Rang-%d und Rang-%d)

en: Rank mismatch in argument %qs at %L (rank-%d and scalar)
de: Unpassender Rang in Argument %qs bei %L (Rang-%d und Skalar)

en: Rank mismatch in argument %qs at %L (scalar and rank-%d)
de: Unpassender Rang in Argument %qs bei %L (Skalar und Rang-%d)

en: Rank mismatch in array reference at %L (%d/%d)
de: Unpassende Ränge in Feldreferenz bei %L (%d/%d)

en: Rank mismatch of array at %L and its initializer (%d/%d)
de: Rangabweichung zwischen dem Array bei %L und seinem Initialisierer (%d/%d)

en: Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L
de: Das Umordnen des Rangs erfordert eine Liste von %<untere-Grenze : obere-Grenze%>-Angaben bei %L

en: Rank remapping target is not rank 1 at %L
de: Ziel der Rang-Neuzuordnung ist nicht Rang 1 bei %L

en: Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L
de: Ziel der Rang-Neuzuordnung ist kleiner als die Größe des Zeigers (%ld < %ld) bei %L

en: Rank remapping target must be rank 1 or simply contiguous at %L
de: Ziel der Rang-Neuzuordnung muss Rang 1 oder einfach fortlaufend bei %L sein

en: Reading file %qs as free form
de: Datei %qs wird in Freiform gelesen

en: Reading module %qs at line %d column %d: %s
de: Modul %qs in Zeile %d, Spalte %d wird gelesen: %s

en: Reading specs from %s
de: Lesen der Spezifikationen von %s

en: Real COUNT_RATE argument to SYSTEM_CLOCK at %L
de: Reelles COUNT_RATE-Argument für SYSTEM_CLOCK bei %L

en: Real constant overflows its kind at %C
de: Realkonstante überschreitet seine Art bei %C

en: Real constant underflows its kind at %C
de: Realkonstante unterschreitet seine Art bei %C

en: Real number at %C has a %<d%> exponent and an explicit kind
de: Realzahl bei %C hat einen %<d%>-Exponenten und eine explizite Art

en: Real number at %C has a %<q%> exponent and an explicit kind
de: Realzahl bei %C hat einen %<q%>-Exponenten und eine explizite Art

en: Realign stack in prologue.
de: Stapel in Prolog neu ausrichten.

en: Reallocate the LHS in assignments.
de: LHS in Zuweisungen neu reservieren.

en: Recognize C++ keywords like "compl" and "xor".
de: C++-Schlüsselworte wie »compl« und »xor« erkennen.

en: Recognize GNU-defined keywords.
de: GNU-definierte Schlüsselworte erkennen.

en: Recognize built-in functions.
de: Eingebaute Funktionen erkennen.

en: Recognize the "asm" keyword.
de: Das »asm«-Schlüsselwort erkennen.

en: Record DW_AT_decl_column and DW_AT_call_column in DWARF.
de: DW_AT_decl_column und DW_AT_call_column in DWARF aufzeichnen.

en: Record gcc command line switches in DWARF DW_AT_producer.
de: GCC-Kommandozeilenschalter in DWARF DW_AT_producer aufzeichnen.

en: Record gcc command line switches in the object file.
de: GCC-Kommandozeilenschalter in Objektdateien aufzeichnen.

en: Record times taken by sub-phases separately.
de: Dauer der Teilphasen separat aufzeichnen.

en: Recursive cloning only when the probability of call being executed exceeds the parameter.
de: Rekursives Klonen nur dann, wenn die Wahrscheinlichkeit, dass der Aufruf ausgeführt wird, den Parameter überschreitet.

en: Redefinition of !$OMP DECLARE REDUCTION at %L
de: Redefinition von !$OMP DECLARE REDUCTION bei %L

en: Redefinition of predefined !$OMP DECLARE REDUCTION at %L
de: Redefinition der vordefinierten !$OMP DECLARE REDUCTION bei %L

en: Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L
de: Redefinition der vordefinierten !$OMP DECLARE REDUCTION »%s« bei %L

en: Reduce priority for r0..r3 / r12..r15 with TARGET_REGISTER_PRIORITY.
de: Priorität für r0..r3 / r12..r15 mit TARGET_REGISTER_PRIORITY reduzieren.

en: Reduce stack alignment on call sites if possible.
de: Stapelausrichtung im Aufrufer reduzieren, wenn möglich.

en: Redundant !$ACC END LOOP at %C
de: Redundantes !$ACC END LOOP bei %C

en: Redundant ACQUIRED_LOCK tag found at %L
de: Redundante ACQUIRED_LOCK-Marke bei %L gefunden

en: Redundant ERRMSG tag found at %L
de: Redundante ERRMSG-Marke bei %L gefunden

en: Redundant MOLD tag found at %L
de: Überflüssige MOLD-Marke bei %L gefunden

en: Redundant SOURCE tag found at %L
de: Überflüssige SOURCE-Marke bei %L gefunden

en: Redundant STAT tag found at %L
de: Redundante STAT-Marke bei %L gefunden

en: Redundant UNTIL_COUNT tag found at %L
de: Redundante UNTIL_COUNT-Marke bei %L gefunden

en: Reference statement index not found
de: Index der Referenzanweisung nicht gefunden

en: Reference statement index out of range
de: Index der Referenzanweisung außerhalb des gültigen Bereichs

en: Reference to impure function %qs at %L inside a DO CONCURRENT %s
de: Referenz auf Nicht-PURE-Funktion %qs bei %L innerhalb eines DO CONCURRENT %s

en: Reference to impure function %qs at %L inside a FORALL %s
de: Referenz auf Nicht-PURE-Funktion %qs bei %L innerhalb eines FORALL %s

en: Reference to impure function %qs at %L within a PURE procedure
de: Referenz auf Nicht-PURE-Funktion %qs bei %L innerhalb einer PURE-Prozedur

en: Region crossing jump across same section in bb %i
de: Interner Fehler: Region crossing jump across same section in bb %i

en: Register the profile information in the .gcov_info section instead of using a constructor/destructor.
de: Profilinformation im Abschnitt .gcov_info registrieren, statt einen Konstruktor/Destruktor zu verwenden.

en: Register the profile information in the specified section instead of using a constructor/destructor.
de: Profilinformation im angegebenen Abschnitt registrieren, statt einen Konstruktor/Destruktor zu verwenden.

en: Regular expression matching additional GP-addressible section names.
de: Regulärer Ausdruck, um zusätzliche Allzweck-adressierbare Abschnittsnamen anzugeben.

en: Regular expression matching section names for r0-relative addressing.
de: Regulärer Ausdruck, um relativ zu r0 adressierbare Abschnittsnamen anzugeben.

en: Relax branches.
de: Zweige entspannen.

en: Relax cmpxchg loop for atomic_fetch_{or,xor,and,nand} by adding load and cmp before cmpxchg, execute pause and loop back to load and compare if load value is not expected.
de: Die cmpxchg-Schleife für atomic_fetch_{or,xor,and,nand} entspannen, indem load und cmp vor cmpxchg eingefügt wird, sowie pausieren und zurückspringen zu Laden-und-Vergleichen, wenn der Ladewert nicht der erwartete ist.

en: Relax literals in assembler and place them automatically in the text section.
de: Literale in Assembler lockern und automatisch in den »text«-Abschnitt platzieren.

en: Relief of register pressure through live range shrinkage.
de: Entlastung des Registerdrucks durch Live-Bereichs-Schrumpfung.

en: Remap file names when including files.
de: Dateinamen beim Einfügen von Dateien neu abbilden.

en: Remove code and data that is unreachable from any exported symbol (including the entry point).
de: Code und Daten, die unerreichbar von jeglichen exportierten Symbolen sind, entfernen (inclusive dem Einstiegspunkt).

en: Remove prefix from absolute path before mangling name for -fprofile-generate= and -fprofile-use=.
de: Präfix von absolutem Pfad abschneiden, bevor dieser Name für »-fprofile-generate=« und »-fprofile-use=« gemangelt wird.

en: Remove redundant membars.
de: Redundante Membars entfernen.

en: Removed in GCC 10.  This switch has no effect.
de: In GCC 10 entfernt. Dieser Schalter hat keine Auswirkung.

en: Removed in GCC 8.  This switch has no effect.
de: In GCC 8 entfernt. Dieser Schalter hat keine Auswirkung.

en: Removed in GCC 9.  This switch has no effect.
de: In GCC 9 entfernt. Dieser Schalter hat keine Auswirkung.

en: Removing '%s'
de: »%s« wird gelöscht

en: Removing call to impure function %qs at %L
de: Aufruf von unreiner Funktion %qs bei %L wird entfernt

en: Removing call to impure function at %L
de: Aufruf von unreiner Funktion bei %L wird entfernt

en: Renaming operators in USE statements at %C
de: Umbenennungsoperatoren in USE-Anweisungen bei %C

en: Reorder basic blocks and partition into hot and cold sections.
de: Basisblöcke und in heiße und kalte Abschnitte umordnen und partitionieren.

en: Reorder basic blocks to improve code placement.
de: Basisblöcke umsortieren, um Codeplatzierung zu verbessern.

en: Reorder functions to improve code placement.
de: Funktionen umsortieren, um Codeplatzierung zu verbessern.

en: Reorder top level functions, variables, and asms.
de: Funktionen, Variablen und asms höchster Ebene umordnen.

en: Repeat spec invalid in scalar initializer at %C
de: Ungültige Wiederholungsangabe in Skalar-Initialisierung bei %C

en: Repeat spec must be an integer at %C
de: Wiederholungsangabe bei %C muss eine Ganzzahl sein

en: Replace add, compare, branch with branch on count register.
de: Addieren, Vergleichen, Verzweigen mit Verzweigung anhand des Zählregisters ersetzen.

en: Replace temporary expressions in the SSA->normal pass.
de: Vorübergehende Ausdrücke im SSA->Normal-Durchlauf ersetzen.

en: Report on consistency of profile.
de: Über Konsistenz des Profils berichten.

en: Report on memory allocation before interprocedural optimization.
de: Über Speicherbelegung vor zwischenprozeduraler Optimierung berichten.

en: Report on permanent memory allocation in WPA only.
de: Nur in WPA über dauerhafte Speicherreservierung berichten.

en: Report on permanent memory allocation.
de: Über dauerhafte Speicherreservierung berichten.

en: Report the time taken by each compiler pass.
de: Benötigte Zeit für jeden Compilerdurchlauf ausgeben.

en: Report various link-time optimization statistics for WPA only.
de: Nur in WPA verschiedene Statistiken über Linkzeit-Optimierung ausgeben.

en: Report various link-time optimization statistics.
de: Verschiedene Statistiken über Linkzeit-Optimierung ausgeben.

en: Request IEEE-conformant math library routines (OSF/1).
de: IEEE-konforme Mathematik-Bibliotheksroutinen (OSF/1) anfordern.

en: Reschedule instructions after register allocation.
de: Befehle nach Registerbelegung neu planen.

en: Reschedule instructions before register allocation.
de: Befehle vor Registerbelegung neu planen.

en: Reschedule pipelined regions without pipelining.
de: Regionen mit Pipelining ohne Pipelining neu planen.

en: Reserve space for outgoing arguments in the function prologue.
de: Platz für Ausgabeargumente in Funktionsprolog reservieren.

en: Reshaped array too large at %C
de: Umgeformtes Feld bei %C zu groß

en: Restrict the analyzer to run just the named checker.
de: Die Analyse auf die Prüfung mit dem angegebenen Namen einschränken.

en: Restrict the use of hardware floating-point instructions to 32-bit operations.
de: Verwendung der Hardware-Gleitkomma-Befehle auf 32-Bit-Operationen beschränken.

en: Result %qs of contained function %qs at %L has no IMPLICIT type
de: Ergebnis %qs der enthaltenen Funktion %qs bei %L hat keinen IMPLICIT-Typ

en: Result mismatch for the overriding procedure %qs at %L: %s
de: Unpassendes Ergebnis für die überschreibende Prozedur %qs bei %L: %s

en: Result of %s gives range error for its kind at %L
de: Ergebnis von %s ergibt für seine Art einen Bereichsfehler bei %L

en: Result of %s is NaN at %L
de: Ergebnis von %s ist NaN bei %L

en: Result of %s overflows its kind at %L
de: Ergebnis von %s überschreitet seine Art bei %L

en: Result of %s underflows its kind at %L
de: Ergebnis von %s unterschreitet seine Art bei %L

en: Result of BESSEL_YN is -INF at %L
de: Ergebnis von BESSEL_YN ist -INF bei %L

en: Result of NEAREST is NaN at %L
de: Ergebnis von NEAREST ist NaN bei %L

en: Result of SCALE overflows its kind at %L
de: Ergebnis von SCALE überschreitet seine Art bei %L

en: Result of exponentiation at %L exceeds the range of %s
de: Potenzbildung bei %L überschreitet Wertebereich von %s

en: Return 8-byte vectors in memory.
de: 8-Byte-Vektoren über Speicher zurückgeben.

en: Return all structures in memory (AIX default).
de: Alle Strukturen über Speicher zurückgeben (AIX-Standard).

en: Return floating-point results in ac0 (fr0 in Unix assembler syntax).
de: Gleitkommaergebnisse über ac0 zurückgeben (fr0 in Unix-Assemblersyntax).

en: Return pointers in both a0 and d0.
de: Zeiger sowohl in a0 als auch in d0 zurückgeben.

en: Return small aggregates in memory, not registers.
de: Kleine Aggregate über Speicher, nicht Register, zurückgeben.

en: Return small aggregates in registers.
de: Kleine Aggregate über Register zurückgeben.

en: Return small structures in registers (SVR4 default).
de: Kleine Strukturen über Register zurückgeben (SVR4-Standard).

en: Return type mismatch of function %qs at %L (%s/%s)
de: Unpassender Rückgabetyp der Funktion %qs bei %L (%s/%s)

en: Return type of BIND(C) function %qs at %L cannot be an array
de: Rückgabetyp der BIND(C)-Funktion %qs bei %L kann kein Feld sein

en: Return type of BIND(C) function %qs of character type at %L must have length 1
de: Rückgabetyp der BIND(C)-Funktion %qs von Zeichentyp bei %L muss die Länge 1 haben

en: Return value %qs of function %qs declared at %L not set
de: Rückgabewert %1$qs der bei %3$L deklarierten Funktion %2$qs nicht gesetzt

en: Return value of function %qs at %L not set
de: Rückgabewert der Funktion %qs bei %L nicht gesetzt

en: Return values of functions in FPU registers.
de: Funktionswerte über FPU-Register zurückgeben.

en: Reuse r30 on a per function basis.
de: r30 auf Funktionsbasis wiederverwenden.

en: Revert DIP1000: Scoped pointers.
de: DIP1000 "Zeiger in Gültigkeitsbereichen" rückgängig machen.

en: Revert DIP25: Sealed references.
de: DIP25 "Versiegelte Referenzen" rückgängig machen.

en: Rewrite subcommand usage:
de: Aufruf des Teilbefehls »rewrite«:

en: Right parenthesis expected at %C in format string at %L
de: Schließende Klammer erwartet bei %C in Formatzeichenkette bei %L

en: Rightmost upper bound of assumed size array section not specified at %L
de: Rechte obere Schranke des Feldabschnitts angenommener Größe nicht angegeben bei %L

en: Run only the second compilation of -fcompare-debug.
de: Nur die zweite Kompilierung von -fcompare-debug laufen lassen.

en: Run predictive commoning optimization.
de: Vorhersehende vereinheitlichende Optimierung durchlaufen.

en: Run selective scheduling after reload.
de: Ausgewählte Planung nach Neuladen durchführen.

en: Run self-tests, using the given path to locate test files.
de: Selbsttests durchführen, mit dem angegebenen Pfad, um die Testdateien zu finden.

en: Run the link-time optimizer in local transformation (LTRANS) mode.
de: Den Bindezeitoptimierer im lokalen Transformationsmodus (LTRANS) laufen lassen.

en: Run the link-time optimizer in whole program analysis (WPA) mode.
de: Den Bindezeitoptimierer im Modus »komplettes Programm« (WPA) laufen lassen.

en: Running spec function '%s' with %d args
de: Unbekannte Spezifikationsfunktion »%s« mit %d Argumenten

en: Runtime name.
de: Laufzeitname.

en: SAVE attribute at %L cannot be specified in a PURE procedure
de: SAVE-Attribut bei %L kann nicht in einer PURE-Prozedur angegeben werden

en: SAVE statement at %C follows blanket SAVE statement
de: SAVE-Anweisung bei %C folgt umfassender SAVE-Anweisung

en: SCHEDULE clause specified together with %<inscan%> REDUCTION clause at %L
de: SCHEDULE-Klausel darf nicht zusammen mit %<inscan%>-REDUCTION-Klausel bei %L verwendet werden

en: SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression
de: chunk_size der SCHEDULE-Klausel bei %L erfordert einen skalaren INTEGER-Ausdruck

en: SELECT RANK statement at %C
de: SELECT-RANK-Anweisung bei %C

en: SELECT TYPE at %C cannot appear in this scope
de: SELECT TYPE bei %C darf nicht in diesem Gültigkeitsbereich vorkommen

en: SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L
de: SELECTED_REAL_KIND ohne Argument %<P%> oder %<R%> bei %L

en: SEQUENCE attribute at %C already specified in TYPE statement
de: SEQUENCE-Attribut bei %C bereits in TYPE-Anweisung angegeben

en: SEQUENCE statement at %C must precede CONTAINS
de: SEQUENCE-Anweisung bei %C muss CONTAINS vorausgehen

en: SEQUENCE statement at %C must precede structure components
de: SEQUENCE-Anweisung bei %C muss Strukturkomponenten vorausgehen

en: SH2a does not support little-endian
de: SH2a unterstützt nicht Little-Endian

en: SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR
de: SHAPE-Argument bei %L für C_F_POINTER muss dieselbe Größe haben wie der RANK des FPTR

en: SHIFT argument (%ld) out of range -%ld:%ld in intrinsic ISHFT
de: SHIFT-Argument (%ld) außerhalb des Bereichs -%ld:%ld in intrinsischem ISHFT

en: SHIFT argument (%ld) out of range -%ld:%ld in intrinsic ISHFTC
de: SIZE-Argument (%ld) außerhalb des Bereichs -%ld:%ld in intrinsischem ISHFTC

en: SHIFT argument (%ld) out of range 0:%ld in intrinsic %s
de: SHIFT-Argument (%ld) außerhalb des Bereichs 0:%ld in intrinsischem »%s«

en: SIGN= at %L not allowed in Fortran 95
de: SIGN= bei %L ist in Fortran 95 nicht erlaubt

en: SINK addend not a constant integer at %L
de: SINK-Summand bei %L ist keine konstante Ganzzahl

en: SINK dependence type only allowed on ORDERED directive at %L
de: SINK-Abhängigkeitstyp bei %L ist nur in ORDERED-Direktive erlaubt

en: SIZE argument (%ld) out of range 1:%ld in intrinsic ISHFTC
de: SIZE-Argument (%ld) außerhalb des Bereichs 1:%ld in intrinsischem ISHFTC

en: SIZE at %L must be positive
de: SIZE bei %L muss positiv sein

en: SOURCE dependence type only allowed on ORDERED directive at %L
de: SOURCE Abhängigkeitstyp ist nur an ORDERED-Direktive erlaubt bei %L

en: SOURCE tag at %L
de: SOURCE-Marke bei %L

en: SOURCE tag at %L conflicts with the typespec at %L
de: SOURCE-Marke bei %L steht mit Typspezifikation bei %L in Konflikt

en: SOURCE tag at %L with more than a single allocate object
de: SOURCE-Marke bei %L mit mehr als einem reservierbaren Objekt

en: SRAM-ECC modes:
de: SRAM-ECC-Modi:

en: SSA corruption
de: SSA-Beschädigung

en: SSA name %qE with version %d has no definition
de: SSA-Name %qE mit Version %d hat keine Definition

en: SSA name undeclared
de: Interner Fehler: SSA name undeclared

en: SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set
de: SSA_NAME_OCCURS_IN_ABNORMAL_PHI sollte gesetzt sein

en: SSE instruction set disabled, using 387 arithmetics
de: SSE-Befehlssatz ausgeschaltet, es wird 387-Arithmetik verwendet

en: SSE register argument with SSE disabled
de: SSE-Registerargument mit SSE ausgeschaltet

en: SSE register return with SSE disabled
de: SSE-Registerrückgabe mit SSE ausgeschaltet

en: SSE vector argument without SSE enabled changes the ABI
de: SSE-Vektorargument ohne eingeschaltetes SSE ändert das ABI

en: SSE vector return without SSE enabled changes the ABI
de: SSE-Vektorrückgabe ohne eingeschaltetes SSE ändert das ABI

en: STABS debugging information is obsolete and not supported anymore
de: STABS-Debugging-Informationen sind veraltet und werden nicht mehr unterstützt

en: STAT tag at %L cannot be a constant
de: STAT-Angabe bei %L darf keine Konstante sein

en: STAT variable
de: STAT-Variable

en: STAT= argument at %L must be a scalar INTEGER variable
de: »STAT=«-Argument bei %L muss skalare INTEGER-Variable sein

en: STAT= argument to %s at %L
de: STAT=-Argument für %s bei %L

en: STAT= attribute in %C misplaced
de: Attribut »STAT=« in %C fehlplatziert

en: STATUS at %L shall be an INTENT(OUT) variable
de: STATUS bei %L muss eine »INTENT(OUT)«-Variable sein

en: STOP code at %C cannot be negative
de: STOP-Code bei %C darf nicht negativ sein

en: STOP code at %C contains too many digits
de: STOP-Code bei %C enthält zu viele Ziffern

en: STOP code at %L must be a scalar CHARACTER constant or digit[digit[digit[digit[digit]]]]
de: STOP-Code bei %L muss eine skalare CHARACTER-Konstante oder Ziffer[Ziffer[Ziffer[Ziffer[Ziffer]]]] sein

en: STOP code at %L must be a scalar default CHARACTER or INTEGER constant expression
de: STOP-Code bei %L muss eine skalare CHARACTER- oder INTEGER-Konstante sein

en: STOP code at %L must be default character KIND=%d
de: STOP-Code bei %L muss Standardzeichentyp KIND=%d sein

en: STOP code at %L must be default integer KIND=%d
de: STOP-Code bei %L muss Standardganzzahltyp KIND=%d sein

en: STOP code at %L must be either INTEGER or CHARACTER type
de: STOP-Code bei %L muss entweder INTEGER- oder CHARACTER-Typ haben

en: STOP code at %L must be scalar
de: STOP-Code bei %L muss Skalar sein

en: SUBMODULE declaration at %C
de: SUBMODULE-Deklaration bei %C

en: SUBMODULE declaration at %C cannot appear within another scoping unit
de: SUBMODULE-Deklaration bei %C kann nicht innerhalb eines anderen Gültigkeitsbereichs auftreten

en: SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE
de: SUBROUTINE %qs bei %L kann nicht rekursiv aufgerufen werden, da sie nicht RECURSIVE ist

en: SVE type %qT cannot be passed to an unprototyped function
de: der SVE-Typ %qT kann nur an prototypisierte Funktionen übergeben werden

en: SVE type %qT does not have a defined alignment
de: der SVE-Typ %qT hat keine definierte Ausrichtung

en: SVE type %qT does not have a fixed size
de: der SVE-Typ %qT hat keine feste Größe

en: SYNC TEAM statement at %C
de: SYNC-TEAM-Anweisung bei %C

en: SYNC statement at %C
de: SYNC-Anweisung bei %C

en: Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L
de: Gleiches effektives Argument mit INTENT(%s)-Argument %qs und INTENT(%s)-Argument %qs bei %L verbunden

en: Same as %s%s (or, in negated form, %s%s).
de: Dasselbe wie %s%s (oder, in negierter Form, %s%s).

en: Same as %s%s.
de: Dasselbe wie %s%s.

en: Same as %s.
de: Dasselbe wie %s.

en: Same as -fassociative-math for expressions which include division.
de: Das gleiche wie -fassociative-math für Ausdrücke, die Division enthalten.

en: Same as -mA6.
de: Identisch zu -mA6.

en: Same as -mA7.
de: Identisch zu -mA7.

en: Same as: -mep -mprolog-function.
de: Das gleiche wie: -mep -mprolog-function.

en: Same identifier %qs specified again at %C
de: Derselbe Bezeichner %qs ist wiederholt angegeben bei %C

en: Save registers around function calls.
de: Register bei Funktionsaufrufen sichern.

en: Save the TOC in the prologue for indirect calls rather than inline.
de: TOC für indirekte Aufrufe im Prolog sichern, statt vor jedem Aufruf.

en: Scalar %qs in FORMAT tag at %L is not an ASSIGNED variable
de: Skalares %qs in FORMAT-Marke bei %L ist keine ASSIGNED-Variable

en: Scalar INTEGER expression expected at %L
de: Skalarer INTEGER-Ausdruck bei %L erwartet

en: Scalar PARAMETER required in complex constant at %C
de: Skalarer PARAMETER in komplexer Konstante bei %C erwartet

en: Scalar entity required at %L
de: Skalare Einheit bei %L benötigt

en: Scalar integer expression for range begin expected at %L
de: Der Bereichsbeginn bei %L erwartet einen skalaren Ganzzahlausdruck

en: Scalar integer expression for range end expected at %L
de: Das Bereichsende bei %L erwartet einen skalaren Ganzzahlausdruck

en: Scalar integer expression for range step expected at %L
de: Die Schrittweite des Bereichs bei %L erwartet einen skalarer Ganzzahlausdruck

en: Scalar object %qs at %L may not be ALLOCATABLE
de: Skalares Objekt %qs bei %L kann nicht ALLOCATABLE sein

en: Scale factor to apply to the number of blocks in a threading path when comparing to the number of (scaled) statements.
de: Skalierungsfaktor für die Anzahl der Blöcke in einem Threadingpfad, verglichen mit der Anzahl der (skalierten) Anweisungen.

en: Scale factor to apply to the number of statements in a threading path when comparing to the number of (scaled) blocks.
de: Skalierungsfaktor für die Anzahl der Anweisungen pro Threadingpfad, verglichen mit der Anzahl der (skalierten) Blöcke.

en: Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimizations.
de: Skalierungsfaktor bei Berechnung der größten Entfernung, um die ein Ausdruck durch GCSE-Optimierungen verschoben werden kann.

en: Schedule code for given CPU.
de: Code für die gegebene CPU planen.

en: Schedule given CPU.
de: Für angegebene CPU planen.

en: Schedule instructions using selective scheduling algorithm.
de: Befehle mit selektivem Planungs-Algorithmus einplanen.

en: Schedule the start and end of the procedure.
de: Anfang und Ende der Prozedur planen.

en: Second argument of %s is negative at %L
de: Zweites Argument von %s ist bei %L negativ

en: Second argument of defined assignment at %L must be INTENT(IN)
de: Zweites Argument der definierten Zuweisung bei %L muss INTENT(IN)

en: Second argument of operator interface at %L cannot be optional
de: Zweites Argument der Operatorschnittstelle bei %L kann nicht optional sein

en: Second argument of operator interface at %L must be INTENT(IN)
de: Zweites Argument der Operatorschnittstelle bei %L muss INTENT(IN) sein

en: See %s for instructions.
de: Weitere Hinweise finden Sie unter »%s«.

en: Select code model.
de: Codemodell auswählen.

en: Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment.
de: Auswahl des Anteils an der Höchstfrequenz der Ausführungen des Basisblocks in Funktion, vorausgesetzt, der Basisblock wird ausgerichtet.

en: Select large model - 20-bit addresses/pointers.
de: Großes Speichermodell wählen – 20-Bit-Adressen/-Zeiger.

en: Select method for sdata handling.
de: Methode für sdata-Behandlung auswählen.

en: Select return address signing scope.
de: Gültigkeitsbereich der signierten Rückgabeadressen.

en: Select small model - 16-bit addresses/pointers (default).
de: Kleines Speichermodell wählen – 16-Bit-Adressen/-Zeiger (Voreinstellung).

en: Select target ABI variant.
de: Ziel-ABI-Variante auswählen.

en: Select the name for storing the profile note file.
de: Name zum Speichern der Profilingnotizen festlegen.

en: Select the runtime.
de: Laufzeitumgebung auswählen.

en: Select type of coverage sanitization.
de: Art der Abdeckungs-Bereinigung auswählen.

en: Select what to sanitize.
de: Auswählen, was bereinigt werden soll.

en: Selection expression in computed GOTO statement at %L must be a scalar integer expression
de: Auswahlausdruck in berechneter GOTO-Anweisung bei %L muss ein skalarer Ganzzahlausdruck sein

en: Selector at %L cannot be NULL()
de: Selektor bei %L darf nicht NULL() sein

en: Selector at %L has no type
de: Selektor bei %L hat keinen Typ

en: Selector at %L must not be coindexed
de: Selektor bei %L darf nicht koindiziert sein

en: Selector in SELECT TYPE at %C is not a named variable; use associate-name=>
de: Selektor in SELECT TYPE bei %C ist keine benannte Variable; associate-name=> verwendet

en: Selector shall be polymorphic in SELECT TYPE statement at %L
de: Selektor muss in SELECT TYPE-Anweisung bei %L polymorph sein

en: Selects the type of RL78 core being targeted (g10/g13/g14).  The default is the G14.  If set, also selects the hardware multiply support to be used.
de: Wählt die Art der Ziel-RL78-Kerne aus (g10/g13/g14). Voreinstellung ist der G14. Wenn angegeben, wird auch die verwendete Hardwaremultiplikation ausgewählt.

en: Selects the type of hardware multiplication and division to use (none/g13/g14).
de: Wählt die zu verwendende Art der Hardware-Multiplikation und -division aus (none/g13/g14).

en: Self reference in character length expression for %qs at %L
de: Selbstreferenz im Zeichenlängenausdruck für %qs bei %L

en: Self-referential argument %qs at %L is not allowed
de: Selbstreferenzielles Argument %qs bei %L ist nicht erlaubt

en: Semicolon at %C needs to be preceded by statement
de: Semikolon bei %C muss Anweisung vorausgehen

en: Set 80387 floating-point precision to 32-bit.
de: Gleitkommapräzision von 80387 auf 32 Bit setzen.

en: Set 80387 floating-point precision to 64-bit.
de: Gleitkommapräzision von 80387 auf 64 Bit setzen.

en: Set 80387 floating-point precision to 80-bit.
de: Gleitkommapräzision von 80387 auf 80 Bit setzen.

en: Set Windows defines.
de: Windows-defines festlegen.

en: Set a hard limit for the size of each stack frame, in bytes.
de: Feste Obergrenze für die Größe jedes Stapelrahmens angeben, in Bytes.

en: Set branch cost.
de: Sprungkosten festlegen.

en: Set default accessibility of module entities to PRIVATE.
de: Standardzugriff von Modulentitäten auf PRIVATE setzen.

en: Set dependence distance checking in premature scheduling of queued insns.
de: Prüfung der Abhängigkeitsentfernung in nicht ausgereifter Planung von eingereihten Befehlen festlegen.

en: Set errno after built-in math functions.
de: Nach eingebauten Mathematikfunktionen errno setzen.

en: Set linker output type (used internally during LTO optimization).
de: Ausgabeart des Linkers festlegen (wird intern während der LTO-Optimierung verwendet).

en: Set minimum width of left margin of source code when showing source.
de: Mindestbreite des linken Randes des Quellcodes angeben, für das Ausgeben des Quellcodes.

en: Set name of __fentry__ symbol called at function entry.
de: Name des __fentry__-Symbols festlegen, das beim Betreten der Funktion aufgerufen wird.

en: Set name of main routine for the debugger.
de: Name der Hauptroutine für den Debugger festlegen.

en: Set name of output ALI file (internal switch).
de: Namen der ALI-Ausgabedatei setzen (interner Schalter).

en: Set name of section to record mrecord-mcount calls.
de: Name des Abschnitts festlegen, der die mrecord-mcount-Aufrufe aufnimmt.

en: Set number of bytes on the stack preallocated for use by the callee.
de: Anzahl der reservierten Bytes für die aufgerufene Funktion auf dem Stapel.

en: Set number of nops to emit before each insn pattern.
de: Anzahl der zu erzeugenden NOPs vor jeder Befehlsfolge festlegen.

en: Set register to hold -1.
de: Register festlegen, das den Wert -1 enthält.

en: Set sizeof(bool) to 1.
de: sizeof(bool) auf 1 festlegen.

en: Set start-address of data.
de: Start-Adresse der Daten festlegen.

en: Set start-address of the program.
de: Start-Adresse des Programmes festlegen.

en: Set the PPC_EMB bit in the ELF flags header.
de: PPC_EMB-Bit im ELF-Flags-Header setzen.

en: Set the branch costs for conditional branch instructions.  Reasonable values are small, non-negative integers.  The default branch cost is 0.
de: Sprungkosten für bedingte Sprungbefehle festlegen. Angemessene Werte sind kleine, nicht-negative Ganzzahlen. Vorgabewert ist 0.

en: Set the branch costs for conditional branch instructions.  Reasonable values are small, non-negative integers.  The default branch cost is 1.
de: Sprungkosten für bedingte Sprungbefehle setzen. Angemessene Werte sind kleine, nicht-negative Ganzzahlen. Standard ist 1.

en: Set the branch costs to roughly the specified number of instructions.
de: Verzweigungskosten auf ungefähr die angegebene Anzahl an Befehle setzen.

en: Set the cost of branches.
de: Sprungkosten festlegen.

en: Set the default double precision kind to an 8 byte wide type.
de: Standard-Doppelpräzisionsart auf einen 8 Bytes breiten Typen setzen.

en: Set the default integer kind to an 8 byte wide type.
de: Standard-Ganzzahlart auf einen 8 Bytes breiten Typen setzen.

en: Set the default real kind to an 10 byte wide type.
de: Standard-Realzahlart auf einen 10 Bytes breiten Typen setzen.

en: Set the default real kind to an 16 byte wide type.
de: Standard-Realzahlart auf einen 16 Bytes breiten Typen setzen.

en: Set the default real kind to an 8 byte wide type.
de: Standard-Realzahlart auf einen 8 Bytes breiten Typen setzen.

en: Set the estimated probability in percentage for builtin expect. The default value is 90% probability.
de: Wahrscheinlichkeit in Prozent für das eingebaute »expect«. Vorgabewert ist 90 % Wahrscheinlichkeit.

en: Set the max size of data eligible for the SDA area.
de: Maximalgröße der für den SDA-Bereich geeigneten Daten festlegen.

en: Set the max size of data eligible for the TDA area.
de: Maximalgröße der für den TDA-Bereich geeigneten Daten festlegen.

en: Set the max size of data eligible for the ZDA area.
de: Maximalgröße der für den ZDA-Bereich geeigneten Daten setzen.

en: Set the max. number of bytes which has to be left to stack size before a trap instruction is triggered.
de: Höchstanzahl der Bytes angeben, die noch im Stapel übrig sind, bevor ein Trap-Befehl ausgelöst wird.

en: Set the maximum amount for a single stack increment operation.
de: Größten Betrag für einzelne Stapelvergrößerungsoperation festlegen.

en: Set the maximum number of instructions executed in parallel in reassociated tree.  If 0, use the target dependent heuristic.
de: Höchstzahl der parallel ausgeführten Befehle im neuverbundenen Baum festlegen. Bei 0 die zielabhängige Heuristik verwenden.

en: Set the maximum number of template instantiation notes for a single warning or error.
de: Höchstzahl der Template-Instanziierungshinweise für einzelne Warnung oder Fehler festlegen.

en: Set the number of 64 KiB flash segments.
de: Anzahl der 64-KiB-Flash-Segmente festlegen.

en: Set the output object such that, on loading, dyld will ignore any two-level namespace information and resolve symbols in the discovery order for loaded libs.
de: Das Ausgabeobjekt so festlegen, dass beim Laden dyld alle 2-stufigen Namensraum-Informationen ignoriert, und Symbole in der Entdeckungsreihenfolge für geladene Bibliotheken auflösen.

en: Set the prologue and epilogue hook addresses to TPF_TRACE_PROLOGUE_SKIP_TARGET and TPF_TRACE_EPILOGUE_SKIP_TARGET. Equivalent to using -mtpf-trace-hook-prologue-target=TPF_TRACE_PROLOGUE_SKIP_TARGET and -mtpf-trace-hook-epilogue-target=TPF_TRACE_EPILOGUE_SKIP_TARGET
de: Adressen des Einhängpunkts im Prolog und Epilog auf TPF_TRACE_PROLOGUE_SKIP_TARGET und TPF_TRACE_EPILOGUE_SKIP_TARGET festlegen. Gleichbedeutend mit »-mtpf-trace-hook-prologue-target=TPF_TRACE_PROLOGUE_SKIP_TARGET« und »-mtpf-trace-hook-epilogue-target=TPF_TRACE_EPILOGUE_SKIP_TARGET«

en: Set the target CPU type.
de: Ziel-CPU-Typ angeben.

en: Set the top-level directory for storing the profile data. The default is 'pwd'.
de: Basisverzeichnis zum Speichern der Profildaten setzen. Vorgabe ist das aktuelle Verzeichnis.

en: Set the trace check address for epilogue tpf hook
de: Adresse der Verfolgungsprüfung für TPF-Einhängpunkt im Epilog festlegen

en: Set the trace check address for prologue tpf hook
de: Adresse der Verfolgungsprüfung für TPF-Einhängpunkt im Prolog festlegen

en: Set the trace jump address for epilogue tpf hook
de: Adresse des Verfolgungssprungs für TPF-Einhängpunkt im Epilog festlegen

en: Set the trace jump address for prologue tpf hook
de: Adresse des Verfolgungssprungs für TPF-Einhängpunkt im Prolog festlegen

en: Set the version of RISC-V ISA spec.
de: Die Version der RISC-V-ISA-Spezifikation festlegen.

en: Sets LP_COUNT register width.  Possible values are 8, 16, 20, 24, 28, and 32.
de: Legt die Registerbreite für LP_COUNT fest. Mögliche Werte sind 8, 16, 20, 24, 28 und 32.

en: Setting spec %s to '%s'
de: Spezifikation %s wird auf '%s' gesetzt

en: Shape specification for allocatable scalar at %C
de: Formspezifikation für reservierbares Skalar bei %C

en: Shapes for operands at %L and %L are not conformable
de: Formen der Operanden bei %L und %L stimmen nicht überein

en: Shapes of ORDER at %L and SHAPE at %L are different
de: Die Formen von ORDER bei %L und SHAPE bei %L sind unterschiedlich

en: Share slots for saving different hard registers.
de: Schlitze gemeinsam verwenden, um verschiedene harte Register zu sichern.

en: Share stack slots for spilled pseudo-registers.
de: Stapel-Schlitze für übergelaufene Pseudo-Register gemeinsam verwenden.

en: Shared DO termination label %d at %C
de: Gemeinsam genutzte DO-Abbruchmarke %d bei %C

en: Shorten address references during linking.
de: Beim Binden Adressreferenzen verkürzen.

en: Show column numbers in diagnostics, when available.  Default on.
de: Spaltenzahlen in Diagnose zeigen, wenn verfügbar. Standard: Ein.

en: Show labels annotating ranges of source code when showing source.
de: Beim Anzeigen von Quellcode Marker verwenden, um Bereiche des Quellcodes zu markieren.

en: Show line numbers in the left margin when showing source.
de: Beim Anzeigen von Quellcode Zeilennummern im linken Rand anzeigen.

en: Show stack depths of events in paths.
de: Stapeltiefe der Ereignisse in Pfaden anzeigen.

en: Show the source line with a caret indicating the column.
de: Quellzeile mit Einschaltungszeichen anzeigen, um die Spalte zu kennzeichnen.

en: Shrink-wrap parts of the prologue and epilogue separately.
de: Teile des Prologs und Epilogs separat an den nötigen Stellen erzeugen.

en: Simplification error
de: Interner Fehler: Simplification error

en: Simplification of SPREAD at %C not yet implemented
de: Vereinfachung von SPREAD bei %C ist noch nicht implementiert

en: Size in bytes after which thread-local aggregates should be instrumented with the logging functions instead of save/restore pairs.
de: Größe in Bytes, über der thread-lokale Zusammenfassungen mit Logging-Funktionen statt mit Save/Restore-Paaren instrumentiert werden sollten.

en: Size of %qs argument of %qs intrinsic at %L too small (%i/%i)
de: Größe des Arguments %qs des intrinsischen %qs bei %L ist zu klein (%i/%i)

en: Size of the stack guard expressed as a power of two in bytes.
de: Größe des Stapelschutzes, als Zweierpotenz von Bytes ausgedrückt.

en: Size of tiles for loop blocking.
de: Größe der Kacheln für Schleifenblockierung.

en: Size optimization level: 0:none 1:opportunistic 2: regalloc 3:drop align, -Os.
de: Größenoptimierungsstufe: 0:keine 1:vorteilhaft 2:regalloc 3:drop align, -Os.

en: Sizes of ORDER at %L and SHAPE at %L are different
de: Die Größen von ORDER bei %L und SHAPE bei %L sind unterschiedlich

en: Skip setting up RAX register when passing variable arguments.
de: Beim Übergeben von variablen Argumenten das Einrichten des RAX-Registers überspringen.

en: Small data area: none, sdata, use.
de: Bereich für kleine Daten: none, sdata, use.

en: 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.
de: Weiche Grenzen für Anzahl der Speicherzugriffsbefehle pro Befehlsgruppe. Späteren Speicherbefehlen, die versuchen, in gleicher Befehlsgruppe zu planen, wird niedrigere Priorität gegeben. Oft hilfreich, um Konflikte von Cachebänken zu vermeiden. Standard: 1.

en: Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct
de: Entschuldigung, !$ACC DECLARE bei %L ist in einem BLOCK-Konstrukt nicht erlaubt

en: Sorry, %qs clause at %L on REQUIRES directive is not yet supported
de: Sorry, die %qs-Klausel bei %L an einer REQUIRES-Direktive wird noch nicht unterstützt

en: Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported
de: Sorry, allozierbare/Zeiger-Komponenten in polymorphen (CLASS-)getypten Koarrays bei %L werden nicht unterstützt

en: Sorry, coindexed access to an unlimited polymorphic component at %L is not supported
de: Sorry, der koindizierte Zugriff bei %L auf eine unbegrenzt polymorphe Komponente wird nicht unterstützt

en: Sorry, coindexed access to an unlimited polymorphic object at %L is not supported
de: Sorry, der koindizierte Zugriff bei %L auf ein unbegrenzt polymorphes Objekt wird nicht unterstützt

en: Sorry, only support for integer kind %d implemented for image-set at %L
de: Entschuldigung; für Image-Set bei %2$L ist nur Unterstützung für Ganzzahl-Art %1$d implementiert

en: Sorry, polymorphic arrays not yet supported for firstprivate
de: Sorry, polymorphe Felder werden für firstprivate noch nicht unterstützt

en: Sorry, the event component of derived type at %L is not yet supported
de: Sorry, die Event-Komponente des abgeleiteten Typs bei %L wird noch nicht unterstützt

en: Sorry, the lock component of derived type at %L is not yet supported
de: Sorry, die Lockkomponente des abgeleiteten Typs bei %L wird noch nicht unterstützt

en: Sort the symbols according to size.
de: Die Symbole der Größe nach sortieren.

en: Sort the symbols alphabetically.
de: Die Symbole alphabetisch sortieren.

en: Source-expr at %L and allocate-object at %L must have the same shape
de: Quell-Ausdruck bei %L und ALLOCATE-Objekt bei %L müssen dieselbe Form haben

en: Source-expr at %L must be scalar or have the same rank as the allocate-object at %L
de: Quell-Ausdruck bei %L muss skalar sein oder den selben Rang wie das ALLOCATE-Objekt bei %L haben

en: Specification function %qs at %L cannot be RECURSIVE
de: Spezifikationsfunktion %qs bei %L kann nicht RECURSIVE sein

en: Specification function %qs at %L cannot be a statement function
de: Spezifikationsfunktion %qs bei %L kann keine Anweisungsfunktion sein

en: Specification function %qs at %L cannot be an internal function
de: Spezifikationsfunktion %qs bei %L kann keine interne Funktion sein

en: Specification function %qs at %L must be PURE
de: Spezifikationsfunktion %qs bei %L muss PURE sein

en: Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48.
de: Bit-Breite des unmittelbaren TLS-Versatzes angeben. Gültige Werte sind 12, 24, 32, 48.

en: Specifies the number of registers replicated in second register bank on entry to fast interrupt.
de: Gibt die Anzahl der Register an, die bei Eintritt und Austritt eines schnellen Interrupts in der zweiten Registerbank gesichert werden.

en: Specifies the number of registers to reserve for interrupt handlers.
de: Anzahl der für Interrupthandler zu reservierenden Register.

en: Specifies the registers that the processor saves on an interrupt entry and exit.
de: Gibt die Register an, die beim Eintritt und Austritt eines Interrupts gesichert werden.

en: Specifies whether interrupt functions should save and restore the accumulator register.
de: Angabe, ob Interruptfunktionen das Akkumulator-Register sichern und wiederherstellen sollen.

en: Specify CPU for code generation purposes.
de: CPU für Codeerzeugungszwecke angeben.

en: Specify CPU for scheduling purposes.
de: CPU für Planzwecke angeben.

en: Specify CPU for scheduling purposes.  Valid arguments are 700, 7100, 7100LC, 7200, 7300, and 8000.
de: CPU für Planungszwecke angeben. Gültige Argumente sind 700, 7100, 7100LC, 7200, 7300, und 8000.

en: Specify TLS dialect.
de: TLS-Dialekt angeben.

en: Specify UNIX standard for predefines and linking.
de: UNIX-Standard für Predefines und Bindung angeben.

en: Specify a file to which a list of files output by LTRANS is written.
de: Gibt die Datei an, welche die Liste der von LTRANS ausgegebenen Dateien geschrieben wird.

en: Specify a fpu configuration value from 0 to 7; 0-3 is as FPU spec says, and 4-7 is corresponding to 0-3.
de: FPU-Konfigurationswert von 0 bis 7 angeben; 0 bis 3 sind wie in der FPU-Spezifikation beschrieben, 4 bis 7 entsprechen 0 bis 3.

en: Specify a plugin to load.
de: Zu ladendes Plugin angeben.

en: Specify alignment of structure fields default/natural.
de: Ausrichtung der Strukturfelder als Standard/natürlich angeben.

en: Specify an ABI.
de: ABI angeben.

en: Specify bit size of immediate TLS offsets.
de: Bit-Breite des unmittelbaren TLS-Versatzes angeben.

en: Specify cache flush function.
de: Funktion zum Entleeren des Cache angeben.

en: Specify cache flush trap number.
de: Abfangfunktionsnummer zum Entleeren des Cache angeben.

en: Specify configuration of instruction mul: fast1, fast2 or slow. The default is fast1.
de: Konfiguration für den mul-Befehl angeben: fast1, fast2 oder slow. Vorgabe ist fast1.

en: Specify default OpenACC compute dimensions.
de: Standard-OpenACC-Berechnungsdimensionen angeben.

en: Specify how many read/write ports for n9/n10 cores.  The value should be 3r2w or 2r1w.
de: Anzahl der Lese-/Schreibports für n9-/n10-Kerne angeben. Der Wert sollte 3r2w oder 2r1w sein.

en: Specify how to access the thread pointer.
de: Angeben, wie auf den Threadzeiger zugegriffen wird.

en: Specify how to print any control-flow path associated with a diagnostic.
de: Angeben, wie jeder Kontrollflusspfad, der mit einer Diagnose verbunden ist, ausgegeben werden soll.

en: Specify if floating point hardware should be used.
de: Angeben, ob Gleitkommahardware verwendet werden sollte.

en: Specify integer and floating-point calling convention.
de: Aufrufkonventionen für Ganzzahl und Gleitkomma angeben.

en: Specify main object for TPF-OS.
de: Hauptobjekt für TPF-OS angeben.

en: Specify maximum error replay depth during recursive diagnosis of a constraint satisfaction failure.
de: Maximale Fehlerwiedergabetiefe während der rekursiven Diagnose eines Fehlschlags der Constraint-Erfüllung an.

en: Specify memcpy expansion strategy when expected size is known.
de: Expansionsstrategie für memcpy bei bekannter erwarteter Größe angeben.

en: Specify memset expansion strategy when expected size is known.
de: Expansionsstrategie für memset bei bekannter erwarteter Größe angeben.

en: Specify name for 32 bit signed division function.
de: Namen für die Funktion zur vorzeichenbehafteten 32-Bit-Division angeben.

en: Specify range of registers to make fixed.
de: Bereich der zu fixierenden Register angeben.

en: Specify scheduling priority for dispatch slot restricted insns.
de: Planungspriorität für Verteilschlitz-beschränkte Befehle angeben.

en: Specify size of .local memory used for stack when the exact amount is not known.
de: Größe des .local-Speichers angeben, der für den Stack verwendet wird, wenn die genaue Größe unbekannt ist.

en: Specify that an external BLAS library should be used for matmul calls on large-size arrays.
de: Angeben, dass eine externe BLAS-Bibliothek für matmul-Aufrufe mit großen Feldern verwendet werden sollte.

en: Specify that backslash in string introduces an escape character.
de: Angeben, dass Backslashes in Zeichenketten ein Fluchtzeichen einleiten.

en: Specify that no implicit typing is allowed, unless overridden by explicit IMPLICIT statements.
de: Angeben, dass keine implizite Typisierung erlaubt ist, außer es wird durch explizite IMPLICIT-Anweisungen überschrieben.

en: Specify that the compiler should target secure code as per ARMv8-M Security Extensions.
de: Angeben, dass der Compiler auf sicheren Code gemäß ARMv8-M-Security-Extensions abzielen soll.

en: Specify the ISA to build for: msp430, msp430x, msp430xv2.
de: ISA angeben, für die gebaut wird: msp430, msp430x, msp430xv2.

en: Specify the MCU to build for.
de: MCU angeben, für die gebaut wird.

en: Specify the PTX ISA target architecture to use.
de: Die zu verwendende PTX-ISA-Ziel-Architektur angeben.

en: Specify the PTX ISA version to use.
de: Die Version der PTX-ISA angeben, die verwendet wird.

en: Specify the __fp16 floating-point format.
de: Gleitkommaformat __fp16 angeben.

en: Specify the address generation strategy for ICT call's code model.
de: Strategie zur Adresserzeugung für das Codemodell von ICT-Aufrufen angeben.

en: Specify the address generation strategy for code model.
de: Strategie zur Adresserzeugung für das Codemodell angeben.

en: Specify the algorithm to partition symbols and vars at linktime.
de: Algorithmus, mit dem Symbole und Variablen zur Linkzeit partitioniert werden.

en: Specify the code model used for accessing memory addresses.  Specifying large enables generating binaries with large global offset tables.  By default the value is small.
de: Das Codemodell für den Zugriff auf Speicheradressen angeben. Die Angabe von »large« ermöglicht die Erzeugung von Binärdateien mit großen globalen Offset-Tabellen. Der Vorgabewert ist »small«.

en: Specify the code model.
de: Codemodell angeben.

en: Specify the compact branch usage policy.
de: Verwendungsrichtlinie für kompakte Verzweigungen angeben.

en: Specify the cpu for pipeline model.
de: CPU für Pipeline-Modell angeben.

en: Specify the memory model in effect for the program.
de: Für das Programm zu verwendende Speichermodell angeben.

en: Specify the minimum bit alignment of structures. (Deprecated).
de: Minimale Bitausrichtung von Strukturen angeben. (Veraltet)

en: Specify the model for atomic operations.
de: Das Modell für atomare Operationen angeben.

en: Specify the name of the target CPU.
de: Namen der Ziel-CPU angeben.

en: Specify the name of the target GPU.
de: Namen der Ziel-GPU angeben.

en: Specify the name of the target architecture.
de: Namen der Ziel-Architektur angeben.

en: Specify the name of the target floating point configuration.
de: Name der Gleitkommakonfiguration des Ziels angeben.

en: Specify the name of the target floating point hardware/format.
de: Namen der Gleitkommahardware/-format des Zielsystems angeben.

en: Specify the register to be used for PIC addressing.
de: Für PIC-Adressierung zu verwendendes Register angeben.

en: Specify the security level of c-isr for the whole file.
de: Für das Programm zu verwendende Sicherheitsstufe von c-isr für die ganze Datei angeben.

en: Specify the size of each cache block, which must be a power of 2 between 4 and 512.
de: Die Größe jedes Cache-Blocks (muss eine Zweierpotenz zwischen 4 und 512 sein).

en: Specify the size of each interrupt vector, which must be 4 or 16.
de: Die Größe jedes Interrupt-Vektors (muss 4 oder 16 sein).

en: Specify the target CPU.
de: Die Ziel-CPU auswählen.

en: Specify the target RX cpu type.
de: Typ der Ziel-RX-CPU auswählen.

en: Specify the target architecture.
de: Ziel-Architektur angeben.

en: Specify the target floating-point hardware/format.
de: Gleitkommahardware/-format des Zielsystems angeben.

en: Specify the target processor.
de: Ziel-Prozessor angeben.

en: Specify the type of hardware multiply to support.
de: Art der Hardware-Multiplikation angeben.

en: Specify thread local storage scheme.
de: Schema für thread-lokalen Speicher angeben.

en: Specify thread pointer register number.
de: Registernummer für Threadzeiger angeben.

en: Specify use soft floating point ABI which mean alias to -mabi=2.
de: Software-Gleitkomma-ABI verwenden, gleichbedeutend mit -mabi=2.

en: Specify use soft floating point ABI which mean alias to -mabi=2fp+.
de: Software-Gleitkomma-ABI verwenden, gleichbedeutend mit -mabi=2fp+.

en: Specify where to find the compiled intrinsic modules.
de: Angeben, wo die kompilierten intrinsischen Module zu finden sind.

en: Specify whether functions should be placed into the lower or upper memory regions, or if they should be shuffled between the regions (either) for best fit (default: lower).
de: Speicherbereiche, in den Funktionen abgelegt werden: lower (untere Bereiche), upper (obere), either (beide, platzsparend durchmischt); Vorgabe: lower.

en: Specify whether variables should be placed into the lower or upper memory regions, or if they should be shuffled between the regions (either) for best fit (default: lower).
de: Speicherbereiche, in den Variablen abgelegt werden: lower (untere Bereiche), upper (obere), either (beide, platzsparend durchmischt); Vorgabe: lower.

en: Specify which ABI to use for Objective-C family code and meta-data generation.
de: Zu verwendendes ABI für Code der Objective-C-Familie und Metadaten angeben.

en: Specify which ABI type to generate code for: 2, 2fp+.
de: ABI-Art, für die der Code generiert wird: 2, 2fp+.

en: Specify which post scheduling nop insertion scheme to apply.
de: Angeben, welches Schema zum Einfügen von NOPs nach der Planung angewendet werden soll.

en: Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated
de: VOLATILE für Coarray-Variable %qs bei %C angegeben, die use-/host-assoziiert ist

en: Split 32-byte AVX unaligned load.
de: Nicht ausgerichtetes 32-Byte AVX-Laden auftrennen.

en: Split 32-byte AVX unaligned store.
de: Nicht ausgerichtetes 32-Byte AVX-Speichern auftrennen.

en: Split lifetimes of induction variables when loops are unrolled.
de: Lebensdauer von Induktionsvariablen aufteilen, wenn Schleifen abgerollt werden.

en: Split paths leading to loop backedges.
de: Pfade aufteilen, die zu Schleifen-Rückkanten führen.

en: Split unaligned 8 byte vector moves before post-modify address generation.
de: Nicht ausgerichtete 8-Byte-Vektor-Bewegungen vor Nach-Bewegungs-Adresserzeugung aufteilen.

en: Split wide types into independent registers earlier.
de: Breite Typen bereits früher in unabhängige Register aufteilen.

en: Split wide types into independent registers.
de: Breite Typen in unabhängige Register aufteilen.

en: Stack frame larger than 2G is not supported for %<-fsplit-stack%>
de: Stapelrahmen größer als 2G wird für %<-fsplit-stack%> nicht unterstützt

en: Stack realignment not supported with %<__builtin_eh_return%>
de: Stapel-Neuausrichtung mit %<__builtin_eh_return%> wird nicht unterstützt

en: Start expression in DO loop
de: Anfangs-Ausdruck in DO-Schleife

en: Stat-variable at %L must be a scalar INTEGER variable
de: Stat-Variable bei %L muss skalare INTEGER-Variable sein

en: Stat-variable at %L shall not be %sd within the same %s statement
de: Stat-Variable bei %L darf nicht %s innerhalb der gleichen %s-Anweisung sein

en: Statement at %L is not a valid branch target statement for the branch statement at %L
de: Anweisung bei %L ist keine gültige Sprungzielanweisung für Sprungziel bei %L

en: Statement function %qs at %L conflicts with function name
de: Anweisungsfunktion %qs bei %L steht in Konflikt mit Funktionsname

en: Statement function %qs at %L is not allowed as an actual argument
de: Anweisungsfunktion %qs bei %L ist nicht als effektives Argument erlaubt

en: Statement function %qs at %L may not have pointer or allocatable attribute
de: Anweisungsfunktion %qs bei %L darf weder POINTER- oder ALLOCATABLE-Attribut haben

en: Statement function %qs is invalid in procedure pointer assignment at %L
de: Anweisungsfunktion %qs ist in Zuweisung des Prozedurzeigers bei %L ungültig

en: Statement function %qs requires argument list at %C
de: Anweisungsfunktion %qs erfordert Argumentliste bei %C

en: Statement function at %C
de: Anweisungsfunktion bei %C

en: Statement function at %L cannot appear within an INTERFACE
de: Anweisungsfunktion bei %L darf nicht innerhalb von INTERFACE auftreten

en: Statement function at %L is recursive
de: Anweisungsfunktion bei %L ist rekursiv

en: Statement label at %C is zero
de: Anweisungsmarke bei %C ist Null

en: Statement label in END CRITICAL at %C does not match CRITICAL label
de: Anweisungsmarke in END CRITICAL bei %C passt nicht zur CRITICAL-Marke

en: Statement label in ENDDO at %C doesn't match DO label
de: Anweisungsmarke in ENDDO bei %C passt nicht zum DO-Label

en: Statement label list in GOTO at %C cannot be empty
de: Anweisungsmarkenliste in GOTO bei %C kann nicht leer sein

en: Statement label without statement at %L
de: Anweisungsmarke in leerer Anweisung bei %L

en: Statically link the GNU Fortran helper library (libgfortran).
de: GNU Fortran Hilfsbibliothek (libgfortran) statisch binden.

en: Step expression in DO loop
de: Schrittausdruck in DO-Schleife

en: Step expression in DO loop at %L cannot be zero
de: Schrittausdruck in DO-Schleife bei %L kann nicht Null sein

en: Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is available.
de: Vorwärtswachstum anhalten, wenn die Wahrscheinlichkeit der besten Kante weniger als dieser Schwellwert ist. Verwendet, wenn Profil-Rückmeldung verfügbar ist.

en: Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is not available.
de: Vorwärtswachstum anhalten, wenn die Wahrscheinlichkeit der besten Kante weniger als dieser Schwellwert ist. Verwendet, wenn Profil-Rückmeldung nicht verfügbar ist.

en: Stop reverse growth if the reverse probability of best edge is less than this threshold (in percent).
de: Umgekehrtes Wachstum anhalten, wenn die umgekehrte Wahrscheinlichkeit der besten Kante weniger als dieser Schwellwert ist (in Prozent).

en: Store doubles in 64 bits.
de: Doubles in 64 Bits speichern.

en: Store function names in object code.
de: Funktionsnamen im Objektcode speichern.

en: Stores doubles in 32 bits.  This is the default.
de: Doubles in 32 Bits speichern. Dies ist Standard.

en: Stores the MDUC registers in interrupt handlers for G13 target.
de: Sichert die MDUC-Register in Interrupt-Handlern für die G13-Zielarchitektur.

en: Stream extra data to support more aggressive devirtualization in LTO local transformation mode.
de: Zusätzliche Daten verarbeiten, um in LTO-lokalem Umwandlungsmodus aggressiver zu devirtualisieren.

en: Stride must not be present at %L
de: Bei %L darf kein Schritt vorhanden sein

en: Stride should not be specified for array section in %s clause at %L
de: Schrittweite sollte für Feldabschnitt in %s-Klausel bei %L nicht angegeben werden

en: Strides not allowed in coarray subscript at %C
de: Schrittweiten in Coarray-Index bei %C nicht erlaubt

en: String length at %L is too large
de: Zeichenkettenlänge bei %L ist zu groß

en: Structure component %qs at %L cannot be an EQUIVALENCE object
de: Strukturkomponente %qs bei %L kann kein EQUIVALENCE-Objekt sein

en: Structure constructor with missing optional arguments at %C
de: Strukturkonstruktor mit fehlenden optionalen Argumenten bei %C

en: Structure constructor with named arguments at %C
de: Strukturkonstruktor mit benannten Argumenten bei %C

en: Structure name %qs at %C cannot be the same as an intrinsic type
de: Strukturname %qs bei %C kann nicht der gleiche wie ein intrinsischer Typ sein

en: Structure name expected after RECORD at %C
de: Strukturname nach RECORD bei %C erwartet

en: Structure name expected in non-nested structure declaration at %C
de: Strukturname erwartet in unverschachtelter Strukturdeklaration bei %C

en: Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic
de: Unterprogramm %qs bei %L ist INTRINSIC, aber nicht mit intrinsischer Funktion verträglich

en: Subroutine call to %qs at %L is not PURE
de: Unterprogrammaufruf von %qs bei %L ist nicht PURE

en: Subroutine call to %qs in DO CONCURRENT block at %L is not PURE
de: Unterprogrammaufruf von %qs in »DO CONCURRENT«-Block bei %L ist nicht PURE

en: Subroutine call to %qs in FORALL block at %L is not PURE
de: Unterprogrammaufruf von %qs in FORALL-Block bei %L ist nicht PURE

en: Subroutine call to intrinsic %qs at %L is not PURE
de: Unterprogrammaufruf des intrinsischen %qs bei %L ist nicht PURE

en: Subroutine call to intrinsic %qs in DO CONCURRENT block at %L is not PURE
de: Unterprogrammaufruf von intrinsischem %qs in »DO CONCURRENT«-Block bei %L ist nicht PURE

en: Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L
de: Unterprogrammaufruf mit alternativen Rückgaben in INITIALIZER-Klausel von !$OMP DECLARE REDUCTION bei %L

en: Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L
de: Unterprogrammaufruf mit alternativen Rückgaben in Kombinierer von !$OMP DECLARE REDUCTION bei %L

en: Substring at %L has length zero
de: Teilzeichenkette bei %L hat Länge Null

en: Substring end index (%ld) at %L exceeds string length
de: End-Index %ld der Teilzeichenkette bei %L überschreitet Zeichenkettenlänge

en: Substring end index at %L exceeds the string length
de: End-Index der Teilzeichenkette bei %L überschreitet Zeichenkettenlänge

en: Substring end index at %L is too large
de: End-Index der Teilzeichenkette bei %L ist zu groß

en: Substring end index at %L must be of type INTEGER
de: End-Index der Teilzeichenkette bei %L muss INTEGER-Typ haben

en: Substring end index at %L must be scalar
de: End-Index der Teilzeichenkette bei %L muss skalar sein

en: Substring start index (%ld) at %L below 1
de: Anfangs-Index der Teilzeichenkette %ld bei %L muss kleiner als 1 sein

en: Substring start index at %L is less than one
de: Anfangs-Index der Teilzeichenkette bei %L ist kleiner als Eins

en: Substring start index at %L must be of type INTEGER
de: Anfangs-Index der Teilzeichenkette bei %L muss INTEGER-Typ haben

en: Substring start index at %L must be scalar
de: Anfangs-Index der Teilzeichenkette bei %L muss skalar sein

en: Substring starting and ending points of target specification at %L must be constant expressions
de: Start- und Endposition der Teilzeichenkette der Zielspezifikation bei %L müssen konstante Ausdrücke sein

en: Suggest that the override keyword be used when the declaration of a virtual function overrides another.
de: Vorschlagen, dass das Schlüsselwort »override« für Deklarationen von virtuellen Funktionen verwendet wird, die andere Funktionen übersteuern.

en: Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d
de: Die Summe aus Feldrang %d und Korang %d bei %C übersteigt die Höchstanzahl %d an Dimensionen

en: Sum of second and third arguments of IBITS exceeds bit size at %L
de: Summe des zweiten und dritten Arguments von IBITS überschreitet Bit-Größe bei %L

en: Supply a list of objects to be linked from a file, rather than the command line.
de: Die Liste der zu bindenden Objekte aus einer Datei liefern, statt aus der Befehlszeile.

en: Support 3DNow! built-in functions.
de: Eingebaute 3DNow!-Funktionen unterstützen.

en: Support AES built-in functions and code generation.
de: Eingebaute AES-Funktionen und Codeerzeugung unterstützen.

en: Support AMX-BF16 built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für AMX-BF16 unterstützen.

en: Support AMX-INT8 built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für AMX-INT8 unterstützen.

en: Support AMX-TILE built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für AMX-TILE unterstützen.

en: Support AVX512VNNI built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für AVX512VNNI unterstützen.

en: Support AVX512VP2INTERSECT built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für AVX512VP2INTERSECT unterstützen.

en: Support Athlon 3Dnow! built-in functions.
de: Eingebaute Athlon-3Dnow!-Funktionen unterstützen.

en: Support BMI built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für BMI unterstützen.

en: Support BMI2 built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für BMI2 unterstützen.

en: Support C++17 allocation of over-aligned types.
de: C++17-Allozierung von überausgerichteten Typen unterstützen.

en: Support CLDEMOTE built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für CLDEMOTE unterstützen.

en: Support CLFLUSHOPT instructions.
de: CLFLUSHOPT-Befehle unterstützen.

en: Support CLWB instruction.
de: CLWB-Befehl unterstützen.

en: Support CLZERO built-in functions and code generation.
de: Eingebaute CLZERO-Funktionen und Codeerzeugung unterstützen.

en: Support ENQCMD built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für ENQCMD unterstützen.

en: Support F16C built-in functions and code generation.
de: Eingebaute F16C-Funktionen und Codeerzeugung unterstützen.

en: Support FMA4 built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für FMA4 unterstützen.

en: Support FSGSBASE built-in functions and code generation.
de: Eingebaute FSGSBASE-Funktionen und Codeerzeugung unterstützen.

en: Support FXSAVE and FXRSTOR instructions.
de: FXSAVE- und FXRSTOR-Befehle unterstützen.

en: Support GFNI built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für GFNI unterstützen.

en: Support HRESET built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für HRESET unterstützen.

en: Support Hardware Lock Elision prefixes.
de: Präfixe für Hardware-Lock-Auslassung unterstützen.

en: Support KL built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für KL unterstützen.

en: Support LWP built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für LWP unterstützen.

en: Support LZCNT built-in function and code generation.
de: Eingebaute Funktion und Codeerzeugung für LZCNT unterstützen.

en: Support MMX and SSE built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX und SSE unterstützen.

en: Support MMX built-in functions.
de: Eingebaute MMX-Funktionen unterstützen.

en: Support MMX, SSE and SSE2 built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE und SSE2 unterstützen.

en: Support MMX, SSE, SSE2 and SSE3 built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2 und SSE3 unterstützen.

en: Support MMX, SSE, SSE2, SSE3 and SSE4A built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3 und SSE4A unterstützen.

en: Support MMX, SSE, SSE2, SSE3 and SSSE3 built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3 und SSSE3 unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3 and SSE4.1 built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3 und SSE4.1 unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1 and SSE4.2 built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1 und SSE4.2 unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2 and AVX built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2 und AVX unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and AVX2 built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX und AVX2 unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and FMA built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX und FMA unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512BW built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F und AVX512BW unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512CD built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F und AVX512CD unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512DQ built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F und AVX512DQ unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512ER built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F und AVX512ER unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512IFMA built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F und AVX512IFMA unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512PF built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F und AVX512PF unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512VBMI built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F und AVX512VBMI unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512VL built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F und AVX512VL unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 und AVX512F unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F and AVX5124FMAPS built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F und AVX5124FMAPS unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F and AVX5124VNNIW built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F und AVX5124VNNIW unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F and AVX512BF16 built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F und AVX512BF16 unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F and AVX512BITALG built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F und AVX512BITALG unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F and AVX512FP16 built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F und AVX512FP16 unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F and AVX512VBMI2 built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F und AVX512VBMI2 unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F and AVX512VPOPCNTDQ built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, AVX512F und AVX512VPOPCNTDQ unterstützen.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2, and AVXVNNI built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 und AVXVNNI unterstützen.

en: Support MOVDIR64B built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MOVDIR64B unterstützen.

en: Support MOVDIRI built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für MOVDIRI unterstützen.

en: Support MWAIT and MONITOR built-in functions and code generation.
de: Eingebaute MWAIT- und MONITOR-Funktionen und Codeerzeugung unterstützen.

en: Support MWAITX and MONITORX built-in functions and code generation.
de: Eingebaute MWAITX- und MONITORX-Funktionen und Codeerzeugung unterstützen.

en: Support PCLMUL built-in functions and code generation.
de: Eingebaute PCLMUL-Funktionen und Codeerzeugung unterstützen.

en: Support PCONFIG built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für PCONFIG unterstützen.

en: Support PKU built-in functions and code generation.
de: Eingebaute PKU-Funktionen und Codeerzeugung unterstützen.

en: Support PREFETCHW instruction.
de: PREFETCHW-Befehl unterstützen.

en: Support PREFETCHWT1 built-in functions and code generation.
de: Eingebaute PREFETCHWT1-Funktionen und Codeerzeugung unterstützen.

en: Support PTWRITE built-in functions and code generation.
de: Eingebaute PTWRITE-Funktionen und Codeerzeugung unterstützen.

en: Support RDPID built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für RDPID unterstützen.

en: Support RDRND built-in functions and code generation.
de: Eingebaute RDRND-Funktionen und Codeerzeugung unterstützen.

en: Support RDSEED instruction.
de: RDSEED-Befehl unterstützen.

en: Support RTM built-in functions and code generation.
de: Eingebaute RTM-Funktionen und Codeerzeugung unterstützen.

en: Support SERIALIZE built-in functions and code generation.
de: Eingebaute Funktionen und Codegenerierung für SERIALIZE unterstützen.

en: Support SGX built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für SGX unterstützen.

en: Support SHA1 and SHA256 built-in functions and code generation.
de: Eingebaute SHA1- und SHA256-Funktionen und Codeerzeugung unterstützen.

en: Support TBM built-in functions and code generation.
de: Eingebaute TBM-Funktionen und Codeerzeugung unterstützen.

en: Support TLS segment larger than 64K.
de: TLS-Segment größer als 64K unterstützen.

en: Support TSXLDTRK built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für TSXLDTRK unterstützen.

en: Support UINTR built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für UINTR unterstützen.

en: Support VAES built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für VAES unterstützen.

en: Support VPCLMULQDQ built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für VPCLMULQDQ unterstützen.

en: Support WAITPKG built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für WAITPKG unterstützen.

en: Support WBNOINVD built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für WBNOINVD unterstützen.

en: Support WIDEKL built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für WIDEKL unterstützen.

en: Support XOP built-in functions and code generation.
de: Eingebaute Funktionen und Codeerzeugung für XOP unterstützen.

en: Support XSAVE and XRSTOR instructions.
de: XSAVE- und XRSTOR-Befehle unterstützen.

en: Support XSAVEC instructions.
de: XSAVEC-Befehle unterstützen.

en: Support XSAVEOPT instruction.
de: XSAVEOPT-Befehl unterstützen.

en: Support XSAVES and XRSTORS instructions.
de: XSAVES- und XRSTORS-Befehle unterstützen.

en: Support alignments of up to 64-bits.
de: Ausrichtungen von bis zu 64 Bits unterstützen.

en: Support calls between Thumb and ARM instruction sets.
de: Aufrufe zwischen Thumb- und ARM-Befehlssätzen unterstützen.

en: Support code generation of Advanced Bit Manipulation (ABM) instructions.
de: Codeerzeugung von Advanced-Bit-Manipulation-Befehle (ABM) unterstützen.

en: Support code generation of cmpxchg16b instruction.
de: Codeerzeugung von cmpxchg16b-Befehlen unterstützen.

en: Support code generation of crc32 instruction.
de: Codeerzeugung von crc32-Befehlen unterstützen.

en: Support code generation of movbe instruction.
de: Codeerzeugung von movbe-Befehlen unterstützen.

en: Support code generation of popcnt instruction.
de: Codeerzeugung von popcnt-Befehlen unterstützen.

en: Support code generation of sahf instruction in 64bit x86-64 code.
de: Codeerzeugung von sahf-Befehlen in 64-Bit x86-64-Code unterstützen.

en: Support dynamic initialization of thread-local variables in a different translation unit.
de: Dynamische Initialisierung thread-lokaler Variablen in anderer Übersetzungseinheit unterstützen.

en: Support flag-preserving add-carry instructions.
de: Flag-erhaltende Add-Carry-Befehle unterstützen.

en: Support for the A argument at %L which is polymorphic A argument or has allocatable components is not yet implemented
de: Unterstützung für das A-Argument bei %L, das ein polymorphes A-Argument ist oder allozierbare Komponenten hat, ist noch nicht implementiert

en: Support for the A argument at %L with allocatable components is not yet implemented
de: Unterstützung für das A-Argument bei %L mit allozierbaren Komponenten ist noch nicht implementiert

en: Support legacy multi-threading.
de: Altes Multi-Threading unterstützen.

en: Support message passing with the Parallel Environment.
de: Message-Passing mit der Parallel Environment unterstützen.

en: Support more than 8192 GOT entries on ColdFire.
de: Mehr als 8192 GOT-Einträge auf ColdFire unterstützen.

en: Support multi-threading.
de: Multi-Threading unterstützen.

en: Support multiply accumulate instructions.
de: Multiplizier-Addier-Befehle unterstützen.

en: Support synchronous non-call exceptions.
de: Synchrone Nicht-Aufruf-Ausnahmen unterstützen.

en: Supported AArch64 return address signing scope (for use with -msign-return-address= option):
de: Unterstützte Rückgabeadress-Signierbereiche für AArch64 (für die Option »-msign-return-address=«):

en: Supported ABIs (for use with the -mabi= option):
de: Unterstützte ABIs (für Verwendung mit Option »-mabi=«):

en: Supported ISA specs (for use with the -misa-spec= option):
de: Unterstützte ISA-Spezifikationen (für Verwendung mit Option »-misa-spec=«):

en: Supported LTO compression algorithms: zlib
de: Unterstützte LTO-Kompressionsalgorithmen: zlib

en: Suppress output of addresses in debugging dumps.
de: Ausgabe von Adressen in Fehlersuch-Auszügen unterdrücken.

en: Suppress output of instruction numbers, line number notes and addresses in debugging dumps.
de: Ausgabe von Befehlszahlen, Zeilennummernangaben und Adressen in Fehlersuch-Auszügen unterdrücken.

en: Suppress output of previous and next insn numbers in debugging dumps.
de: Ausgabe der vorigen und nächsten Befehlsnummern in Fehlersuch-Auszügen unterdrücken.

en: Suppress warnings.
de: Warnungen unterdrücken.

en: Switch ARM/Thumb modes on alternating functions for compiler testing.
de: ARM/Thumb-Modus pro Funktion abwechselnd an- und ausschalten, um den Compiler zu testen.

en: Switch on/off MIPS16 ASE on alternating functions for compiler testing.
de: MIPS16 ASE bei abwechselnden Funktionen für Compilertest ein-/ausschalten.

en: Switches off the -mstack-guard= option.
de: Die Option »-mstack-guard« ausschalten.

en: Switches off the -mstack-size= option.
de: Die Option »-mstack-size« ausschalten.

en: Symbol %qs already declared
de: Symbol %qs bereits deklariert

en: Symbol %qs at %C already declared
de: Symbol %qs bei %C bereits deklariert

en: Symbol %qs at %C also declared as a type at %L
de: Symbol %qs bei %C ist bereits bei %L als ein Typ deklariert

en: Symbol %qs at %C has already been host associated
de: Symbol %qs bei %C wurde bereits mit Host verbunden

en: Symbol %qs at %C has no IMPLICIT type
de: Symbol %qs bei %C hat keinen IMPLICIT-Typ

en: Symbol %qs at %C has not been previously defined
de: Symbol %qs bei %C wurde vorher noch nicht definiert

en: Symbol %qs at %C is already in a COMMON block
de: Symbol %qs bei %C ist bereits in einem COMMON-Block

en: Symbol %qs at %C is ambiguous
de: Symbol %qs bei %C ist mehrdeutig

en: Symbol %qs at %C must be a NAMELIST group name
de: Symbol %qs bei %C muss ein NAMELIST-Gruppenname sein

en: Symbol %qs at %L already has an explicit interface
de: Symbol %qs bei %L hat bereits eine explizite Schnittstelle

en: Symbol %qs at %L already has basic type of %s
de: Symbol %qs bei %L hat bereits grundlegenden Typen %s

en: Symbol %qs at %L cannot have a type
de: Symbol %qs bei %L kann keinen Typen haben

en: Symbol %qs at %L conflicts with symbol from module %qs, use-associated at %L
de: Symbol %qs bei %L steht mit Symbol aus Modul %qs in Konflikt, verbunden durch Verwendung bei %L

en: Symbol %qs at %L conflicts with the rename symbol at %L
de: Symbol %qs bei %L steht mit Umbenennungs-Symbol bei %L in Konflikt

en: Symbol %qs at %L conflicts with the symbol at %L
de: Symbol %qs bei %L steht mit Symbol bei %L in Konflikt

en: Symbol %qs at %L has no IMPLICIT type
de: Symbol %qs bei %L hat keinen IMPLICIT-Typ

en: Symbol %qs at %L has no IMPLICIT type; did you mean %qs?
de: Symbol %qs bei %L hat keinen IMPLICIT-Typ; meinen Sie %qs?

en: Symbol %qs at %L is ambiguous
de: Symbol %qs bei %L ist mehrdeutig

en: Symbol %qs at %L is marked PRIVATE but has been given the binding label %qs
de: Symbol %qs bei %L ist als PRIVATE markiert, aber wurde mit Bindung %qs markiert

en: Symbol %qs has mixed component and non-component accesses at %L
de: Das Symbol %qs hat gemischte Komponenten- und Nicht-Komponenten-Zugriffe bei %L

en: Symbol %qs in COMMON at %C cannot be a POINTER array
de: Symbol %qs in COMMON bei %C kann kein POINTER-Feld sein

en: Symbol %qs in COMMON at %C cannot be a coarray
de: Symbol %qs in COMMON bei %C kann kein Kofeld sein

en: Symbol %qs in namelist %qs at %C must be declared before the namelist is declared.
de: Symbol %qs in Namensliste %qs bei %C muss deklariert sein, bevor die Namensliste deklariert wird.

en: Symbol %qs in namelist %qs is INTENT(IN) at %C
de: Symbol %qs in Namensliste %qs ist INTENT(IN) bei %C

en: Symbol %qs is used before it is typed at %L
de: Symbol %qs wird bei %L verwendet, bevor es typisiert wird

en: Symbol %qs must be a PARAMETER in DATA statement at %C
de: Symbol %qs muss ein PARAMETER in DATA-Anweisung bei %C sein

en: Symbol %qs present on both FROM and TO clauses at %L
de: Symbol %qs tritt bei %L sowohl in der FROM- als auch in der TO-Klausel auf

en: Symbol %qs present on multiple clauses at %L
de: Symbol %qs bei %L in mehreren Klauseln vorhanden

en: Symbol %qs referenced at %L not found in intrinsic module ISO_C_BINDING
de: Bei %2$L referenziertes Symbol %1$qs nicht im Modul ISO_C_BINDING gefunden

en: Symbol %qs referenced at %L not found in intrinsic module ISO_FORTRAN_ENV
de: Bei %2$L referenziertes Symbol %1$qs nicht im intrinsischen Modul ISO_FORTRAN_ENV gefunden

en: Symbol %qs referenced at %L not found in module %qs
de: Bei %2$L referenziertes Symbol %1$qs nicht im Modul %3$qs gefunden

en: Symbol %qs, in COMMON block %qs at %C is being indirectly equivalenced to another COMMON block %qs
de: Symbol %qs in COMMON-Block %qs bei %C wird indirekt verglichen mit anderem COMMON-Block %qs

en: Symbol at %C is not appropriate for an expression
de: Symbol bei %C passt nicht zu einem Ausdruck

en: Symbol at %L is not a DUMMY variable
de: Symbol bei %L ist keine Scheinvariable

en: Synonym for "-export-dynamic" for linker versions that support it.
de: Synonym für »-export-dynamic« für Linker-Versionen, die dies unterstützen.

en: Synonym for "image_base".
de: Synonym für »image_base«.

en: Synonym for -Wcomment.
de: Synonym für -Wcomment.

en: Synonym of -gnatk8.
de: Synonym für -gnatk8.

en: Syntax error in !$ACC DECLARE list at %C
de: Syntaxfehler in »!$ACC DECLARE«-Liste bei %C

en: Syntax error in !$ACC ROUTINE ( NAME ) at %C
de: Syntaxfehler in »!$ACC ROUTINE ( NAME )« bei %C

en: Syntax error in !$ACC ROUTINE ( NAME ) at %C, expecting ')' after NAME
de: Syntaxfehler in !$ACC ROUTINE ( NAME ) bei %C, hinter NAME wird »)« erwartet

en: Syntax error in !$OMP DECLARE TARGET list at %C
de: Syntaxfehler in »!$OMP DECLARE TARGET«-Liste bei %C

en: Syntax error in !$OMP THREADPRIVATE list at %C
de: Syntaxfehler in !$OMP THREADPRIVATE Liste bei %C

en: Syntax error in !GCC$ ATTRIBUTES statement at %C
de: Syntaxfehler in !GCC$ ATTRIBUTES-Anweisung bei %C

en: Syntax error in !GCC$ IVDEP directive at %C
de: Syntaxfehler in !GCC$-IVDEP-Direktive bei %C

en: Syntax error in !GCC$ NOVECTOR directive at %C
de: Syntaxfehler in !GCC$-NOVECTOR-Direktive bei %C

en: Syntax error in !GCC$ UNROLL directive at %C
de: Syntaxfehler in !GCC$-UNROLL-Direktive bei %C

en: Syntax error in !GCC$ VECTOR directive at %C
de: Syntaxfehler in !GCC$-VECTOR-Direktive bei %C

en: Syntax error in %s statement at %C
de: Syntaxfehler in Anweisung %s bei %C

en: Syntax error in ABSTRACT INTERFACE statement at %C
de: Syntaxfehler in ABSTRACT INTERFACE-Anweisung bei %C

en: Syntax error in ASYNCHRONOUS statement at %C
de: Syntaxfehler in ASYNCHRONOUS-Anweisung bei %C

en: Syntax error in AUTOMATIC statement at %C
de: Syntaxfehler in AUTOMATIC-Anweisung bei %C

en: Syntax error in CASE specification at %C
de: Syntaxfehler in CASE-Spezifikation bei %C

en: Syntax error in CHARACTER declaration at %C
de: Syntaxfehler in CHARACTER-Deklaration bei %C

en: Syntax error in CLASS IS specification at %C
de: Syntaxfehler in CLASS IS-Spezifikation bei %C

en: Syntax error in COMPLEX constant at %C
de: Syntaxfehler in COMPLEX-Konstante bei %C

en: Syntax error in ELSE IF statement after %L
de: Syntaxfehler in ELSE-IF-Anweisung nach %L

en: Syntax error in ENUMERATOR definition at %C
de: Syntaxfehler in ENUMERATOR-Definition bei %C

en: Syntax error in EQUIVALENCE statement at %L
de: Syntaxfehler in EQUIVALENCE-Anweisung bei %L

en: Syntax error in FORALL iterator at %C
de: Syntaxfehler in FORALL-Iterator bei %C

en: Syntax error in I/O iterator at %C
de: Syntaxfehler in E/A-Iterator bei %C

en: Syntax error in IF-clause after %C
de: Syntaxfehler in IF-Klausel nach %C

en: Syntax error in IF-expression at %C
de: Syntaxfehler in IF-Ausdruck bei %C

en: Syntax error in IMPORT statement at %C
de: Syntaxfehler in IMPORT-Anweisung bei %C

en: Syntax error in NAME= specifier for binding label at %C
de: Syntaxfehler in NAME=-Spezifikation für Bindungsmarke bei %C

en: Syntax error in OpenACC expression list at %C
de: Syntaxfehler in OpenACC-Ausdrucksliste bei %C

en: Syntax error in OpenMP DEPEND SINK list at %C
de: Syntaxfehler in OpenMP-»DEPEND SINK«-Liste bei %C

en: Syntax error in OpenMP detach clause at %C
de: Syntaxfehler in OpenMP-detach-Klausel bei %C

en: Syntax error in OpenMP variable list at %C
de: Syntaxfehler in OpenMP-Variablenliste bei %C

en: Syntax error in PROCEDURE statement at %C
de: Syntaxfehler in PROCEDURE-Anweisung bei %C

en: Syntax error in PROTECTED statement at %C
de: Syntaxfehler in PROTECTED-Anweisung bei %C

en: Syntax error in RANK specification at %C
de: Syntaxfehler in RANK-Spezifikation bei %C

en: Syntax error in SAVE statement at %C
de: Syntaxfehler in SAVE-Anweisung bei %C

en: Syntax error in STATIC statement at %C
de: Syntaxfehler in STATIC-Anweisung bei %C

en: Syntax error in SUBMODULE statement at %C
de: Syntaxfehler in SUBMODULE-Anweisung bei %C

en: Syntax error in SUBSTRING specification at %C
de: Syntaxfehler in SUBSTRING-Spezifikation bei %C

en: Syntax error in TYPE IS specification at %C
de: Syntaxfehler in TYPE IS-Spezifikation bei %C

en: Syntax error in VALUE statement at %C
de: Syntaxfehler in VALUE-Anweisung bei %C

en: Syntax error in VOLATILE statement at %C
de: Syntaxfehler in VOLATILE-Anweisung bei %C

en: Syntax error in anonymous structure declaration at %C
de: Syntaxfehler in anonymer Struktur-Deklaration bei %C

en: Syntax error in argument list at %C
de: Syntaxfehler in Argumentliste bei %C

en: Syntax error in array constructor at %C
de: Syntaxfehler in Feldkonstruktor bei %C

en: Syntax error in character length specification at %C
de: Syntaxfehler in Zeichenlängenangabe bei %C

en: Syntax error in common block name at %C
de: Syntaxfehler im allgemeinen Blocknamen bei %C

en: Syntax error in data declaration at %C
de: Syntaxfehler in Daten-Deklaration bei %C

en: Syntax error in expression at %C
de: Syntaxfehler in Ausdruck bei %C

en: Syntax error in generic specification at %C
de: Syntaxfehler in allgemeiner Spezifikation bei %C

en: Syntax error in iterator at %C
de: Syntaxfehler in Iterator bei %C

en: Syntax error in nested structure declaration at %C
de: Syntaxfehler in geschachtelter Struktur-Deklaration bei %C

en: Syntax error in old style initialization of %s at %C
de: Syntaxfehler in Initialisierung im alten Stil von %s bei %C

en: Syntax error in old style initializer list at %C
de: Syntaxfehler in Initialisierungsliste im alten Stil bei %C

en: Syntax error in procedure pointer component at %C
de: Syntaxfehler in Prozedurzeiger-Komponente bei %C

en: Syntax error: Trailing garbage in END INTERFACE statement at %C
de: Syntaxfehler: Nachfolgender Überschuss in END INTERFACE-Anweisung bei %C

en: Syntax error: Trailing garbage in INTERFACE statement at %C
de: Syntaxfehler: Nachfolgender Überschuss in INTERFACE-Anweisung bei %C

en: TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L
de: TARGET DATA muss mindestens eine der Klauseln MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR enthalten, bei %L

en: TARGET ENTER DATA with map-type other than TO, or ALLOC on MAP clause at %L
de: TARGET ENTER DATA mit Zuordnungstyp außer TO oder ALLOC an MAP-Klausel bei %L

en: TARGET EXIT DATA with map-type other than FROM, RELEASE, or DELETE on MAP clause at %L
de: TARGET EXIT DATA mit Zuordnungstyp außer FROM, RELEASE oder DELETE MAP-Klausel bei %L

en: TARGET%s with map-type other than TO, FROM, TOFROM, or ALLOC on MAP clause at %L
de: TARGET%s mit Zuordnungstyp außer TO, FROM, TOFROM oder ALLOC an MAP-Klausel bei %L

en: TEAM argument at %L to the intrinsic TEAM_NUMBER shall be of type TEAM_TYPE
de: TEAM-Argument bei %L für die intrinsische TEAM_NUMBER muss vom Typ TEAM_TYPE sein

en: TEAM= attribute in %C misplaced
de: Attribut »TEAM=« in %C fehlplatziert

en: THREADPRIVATE object %qs in %s clause at %L
de: THREADPRIVATE-Objekt %qs in %s-Klausel bei %L

en: THREADPRIVATE object %qs in SHARED clause at %L
de: THREADPRIVATE-Objekt %qs in SHARED-Klausel bei %L

en: TILE requires constant expression at %L
de: TILE bei %L erfordert konstanten Ausdruck

en: TLS dialect to use:
de: Zu verwendende TLS-Dialekte:

en: TLS is not implemented for GCN.
de: TLS ist für GCN nicht implementiert.

en: TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions.
de: TODO: als typgebunden definierte Zuweisung(en) bei %L nicht durchgeführt, da Feldreferenzen mit mehreren Teilen in Ausdrücken als Zwischenergebnisse auftreten würden.

en: TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS
de: TOPOS-Argument (%ld) außerhalb des Bereichs 0:%d in intrinsischem MVBITS

en: TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS
de: TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsischem MVBITS

en: TYPE IS at %L overlaps with TYPE IS at %L
de: TYPE IS bei %L überlappt sich mit TYPE IS bei %L

en: TYPE with intrinsic-type-spec at %C
de: TYPE mit intrinsischer Typspezifikation bei %C

en: Take advantage of linker relaxations to reduce the number of instructions required to materialize symbol addresses.
de: Linker-Lockerungen ausnutzen, um die Anzahl der Befehle zu reduzieren, die für das Materialisieren von Symboladressen verwendet werden.

en: Taken at least once:%s of %d
de: %s von %d Zweigen mindestens einmal genommen

en: Takes two non-negative integer numbers separated by a comma. Prepend the function label with the number of two-byte Nop instructions indicated by the first.  Append Nop instructions covering the number of halfwords indicated by the second after the label.  Nop instructions of the largest possible size are used (six, four or two bytes), beginning with the largest possible size.  Using 0 for both values disables hotpatching.
de: Akzeptiert zwei durch Komma getrennte nichtnegative ganze Zahlen. Die erste Zahl gibt an, wie viele Zwei-Byte-NOP-Befehle vor der Funktionssprungmarke eingefügt werden. Die zweite Zahl gibt an, wie viele Halbwörter nach der Funktionssprungmarke mit NOP-Befehlen aufgefüllt werden. Es werden immer die größtmöglichen NOP-Befehle (6, 4 oder 2 Bytes) verwendet. Die Angabe von »0,0« schaltet das Hotpatching aus.

en: Target DFLOAT double precision code.
de: DFLOAT-Code mit doppelter Genauigkeit generieren.

en: Target block's relative execution frequency (as a percentage) required to sink a statement.
de: Zum Absenken einer Anweisung nötige relative Ausführungsfrequenz des Ziel-Blocks (in Prozent).

en: Target expression in pointer assignment at %L must deliver a pointer result
de: Zielausdruck in Zeigerzuweisung bei %L muss ein Zeigerergebnis liefern

en: Target has split I&D.
de: Ziel hat separates I&D.

en: Target of rank remapping is too small (%ld < %ld)
de: Ziel für neue Rangabbildung ist zu klein (%ld < %ld)

en: Target the AM33 processor.
de: Auf AM33-Prozessor abzielen.

en: Target the AM33/2.0 processor.
de: Auf AM33/2.0-Prozessor abzielen.

en: Target the AM34 processor.
de: Auf AM34-Prozessor abzielen.

en: Target the FT32B architecture.
de: Code für die FT32B-Architektur erzeugen.

en: Target the software simulator.
de: Auf den Software-Simulator abzielen.

en: Target: %s
de: Ziel: %s

en: Tell DCE to remove unused C++ allocations.
de: DCE mitteilen, dass ungenutzte C++-Allokationen entfernt werden.

en: Tell DSE that the storage for a C++ object is dead when the constructor starts and when the destructor finishes.
de: DSE mitteilen, dass der Speicher für ein C++-Objekt tot ist, wenn der Konstruktor anfängt und wenn der Destruktor aufhört.

en: The %<-mfloat128%> option may not be fully supported
de: Die Option %<-mfloat128%> wird möglicherweise nicht vollständig unterstützt

en: The %s directive cannot be specified within a %s region at %L
de: Die %1$s-Direktive bei %3$L darf nicht innerhalb einer %2$s-Region angegeben werden

en: The A argument at %L has type %s but the function passed as OPERATION at %L returns %s
de: Argument A bei %L hat Typ »%s«, aber die Funktion, die bei %L als OPERATION übergeben wurde, gibt »%s« zurück

en: The A argument at %L of CO_REDUCE shall not be polymorphic
de: Das A-Argument bei %L von CO_REDUCE darf nicht polymorph sein

en: The A argument at %L to the intrinsic %s shall not be coindexed
de: Argument A bei %L des intrinsischen %s darf keinen Koindex haben

en: The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)
de: Das AUTOMATIC-Objekt %qs bei %L darf kein SAVE-Attribut haben und dard auch keine Variable im main-Programm, einem Modul oder einem Teilmodus sein (F08/C513)

en: The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)
de: Die CHARACTER-Elemente des Feldkonstruktors bei %L müssen dieselbe Länge haben (%ld/%ld)

en: The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L
de: Der DEFAULT CASE bei %L kann nicht von zweitem DEFAULT CASE bei %L gefolgt werden

en: The DISTANCE argument may not be specified together with the COARRAY or DIM argument in intrinsic at %L
de: Das DISTANCE-Argument darf in intrinsischer Routine bei %L nicht zusammen mit COARRAY- oder DIM-Argument angegeben werden

en: The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object
de: Das FORALL mit Index %qs wird nicht auf der linken Seite der Zuweisung bei %L verwendet und könnte somit mehrere Zuweisungen an dieses Objekt auslösen

en: The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)
de: Die FROM- und TO-Argumente bei %L verletzen die Aliasing-Beschränkungen (F2003 12.4.1.7)

en: The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d
de: Die FROM- und TO-Argumente des intrinsischen MOVE_ALLOC bei %L müssen den selben Ko-Rang %d/%d haben

en: The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d
de: Die FROM- und TO-Argumente des intrinsischen MOVE_ALLOC bei %L müssen den selben Rang %d/%d haben

en: The FROM argument to MOVE_ALLOC at %L shall not be coindexed
de: Das FROM-Argument für MOVE_ALLOC bei %L darf keinen Koindex haben

en: The H format specifier at %L is a Fortran 95 deleted feature
de: Das Formatspezifikationssymbol H bei %L ist eine in Fortran 95 entfernte Besonderheit

en: The Hollerith constant at %L is truncated in conversion to %qs
de: Hollerith-Konstante bei %L wird bei der Umwandlung in %qs abgeschnitten

en: The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer
de: Das INTENT(OUT)-Scheinargument %qs bei %L hat ASSUMED SIZE und kann damit keine Standardinitialisierung haben

en: The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED
de: Der KIND-Parameter %qs bei %C darf weder ASSUMED noch DEFERRED sein

en: The KIND parameter %qs in the PDT constructor at %C has no value
de: Der KIND-Parameter %qs im PDT-Konstruktor bei %C hat keinen Wert

en: The KIND part_ref at %C must be applied to an expression of intrinsic type
de: Die KIND part_ref bei %C kann nur auf einen Ausdruck von intrinsischem Typ angewendet werden

en: The LEN part_ref at %C must be applied to a CHARACTER expression
de: Die LEN part_ref bei %C kann nur auf einen CHARACTER-Ausdruck angewendet werden

en: The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE
de: Das NULL im Strukturkonstruktor bei %L wird auf Komponente %qs angewandt, die aber weder ein POINTER noch ein ALLOCATABLE ist

en: The RE or IM part_ref at %C must be applied to a COMPLEX expression
de: Die RE oder IM part_ref bei %C kann nur auf einen COMPLEX-Ausdruck angewendet werden

en: The SELECT RANK CASE expression at %C must be a scalar, integer constant
de: Der SELECT-RANK-CASE-Ausdruck bei %C muss eine skalare, ganzzahlige Konstante sein

en: The SELECT RANK selector at %C must be an assumed rank variable
de: Der SELECT-RANK-Selektor bei %C muss eine angenommene Rangvariable sein

en: The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d
de: Das SHAPE-Feld für das intrinsische RESHAPE bei %L hat den negativen Wert %d für die Dimension %d

en: The STATUS specified in OPEN statement at %L cannot have the value SCRATCH if a FILE specifier is present
de: Der STATUS, der in der OPEN-Anweisung bei %L angegeben ist, kann nicht den Wert SCRATCH haben, wenn ein FILE angegeben ist

en: The STATUS specified in OPEN statement at %L is %qs and no FILE specifier is present
de: Der STATUS, der in der OPEN-Anweisung bei %L angegeben ist, ist %qs, es gibt jedoch keine dazu passende FILE-Angabe

en: The TO argument to MOVE_ALLOC at %L shall not be coindexed
de: Das TO-Argument für MOVE_ALLOC bei %L darf keinen Koindex haben

en: The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic
de: Die TO-Argumente in MOVE_ALLOC bei %L müssen polymorph sein, wenn FROM polymorph ist

en: The absolute value of SHIFT at %L must be less than or equal to BIT_SIZE(%qs)
de: Der absolute Wert von SHIFT bei %L muss kleiner oder gleich BIT_SIZE(%qs) sein

en: The absolute value of SHIFT at %L must be less than or equal to SIZE at %L
de: Der absolute Wert von SHIFT bei %L muss kleiner oder gleich SIZE bei %L sein

en: The allocatable object %qs at %L must have an explicit function interface or be declared as array
de: Das reservierbare Objekt %qs bei %L muss eine explizite Funktionsschnittstelle haben oder als Feld deklariert sein

en: The allocate-object at %L and the source-expr at %L shall have the same kind type parameter
de: Das ALLOCATE-Objekt bei %L und der Quellausdruck bei %L müssen Typparameter der gleichen Art haben

en: The argument list functions %%VAL, %%LOC or %%REF are not allowed in this context at %L
de: Die Argumentlistenfunktionen %%VAL, %%LOC oder %%REF bei %L sind in diesem Kontext nicht erlaubt

en: The argument of the RANK intrinsic at %L must be a data object
de: Argument des intrinsischen RANK bei %L muss ein Datenobjekt sein

en: The assignment to a KIND or LEN component of a parameterized type at %L is not allowed
de: Die Zuweisung zu einer KIND- oder LEN-Komponente eines parametrisierten Typs bei %L ist nicht erlaubt

en: The assumed-rank array %qs at %L shall not have a codimension
de: Das Feld %qs bei %L mit vermutetem Rang darf keine Kodimension haben

en: The assumed-rank array at %C shall not have a codimension
de: Das Feld vermuteten Ranges bei %C darf keine Kodimension haben

en: The assumed-rank array at %L requires that the dummy argument %qs has assumed-rank
de: Feld mit vermutetem Rang bei %L erfordert Scheinargument %qs mit vermutetem Rang

en: The base name at %L does not match the name of the current procedure
de: Der Basisname bei %L passt nicht zum Namen der aktuellen Prozedur

en: The base name at %L must not be a generic name
de: Der Basisname bei %L darf kein generischer Name sein

en: The base name at %L must not be a procedure pointer
de: Der Basisname bei %L darf kein Prozedurzeiger sein

en: The base name at %L must not be an entry name
de: Der Basisname bei %L darf kein Eintragsname sein

en: The base name for 'declare variant' must be specified at %L
de: Der Basisname für »declare variant« bei %L muss angegeben werden

en: The base procedure at %L must have an explicit interface
de: Die Basisprozedur bei %L muss eine explizite Schnittstelle haben

en: The bug is not reproducible, so it is likely a hardware or OS problem.
de: Der Fehler ist nicht reproduzierbar, daher handelt es sich wahrscheinlich um ein Problem mit der Hardware oder dem Betriebssystem.

en: The character constant at %L is truncated in conversion to %s
de: Zeichenkonstante bei %L wird bei der Umwandlung in %s abgeschnitten

en: The character length of the A argument at %L and of the arguments of the OPERATION at %L shall be the same
de: Die Zeichenlänge des A-Arguments bei %L und die der Argumente für die OPERATION bei %L muss dieselbe sein

en: The character length of the A argument at %L and of the function result of the OPERATION at %L shall be the same
de: Die Zeichenlänge des A-Arguments bei %L und die des Funktionsergebnisses der OPERATION bei %L muss dieselbe sein

en: The code model option names for -mcmodel:
de: Codemodell-Optionsnamen für -mcmodel:

en: The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute
de: Die Komponente bei %C, die in der Typparameterliste bei %L erscheint, hat weder KIND- noch LEN-Attribut

en: The component at %C which is a type parameter must be a scalar
de: Die Komponente bei %C, die ein Typparameter ist, muss ein Skalar sein

en: The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L
de: Die Komponente bei %C mit KIND- oder LEN-Attribut erscheint nicht in der Typparameterliste bei %L

en: The default (and opposite of -static), implied by user mode executables, shared libraries and bundles.
de: Der Vorgabewert (und das Gegenteil von »-static«), wird implizit von ausführbaren Dateien, gemeinsam genutzten Bibliotheken und Bündeln verwendet.

en: The denominator n of fraction 1/n of the execution frequency of the entry block of a function that a basic block of this function needs to at least have in order to be considered hot.
de: Der Nenner n des Bruchteils 1/n der Ausführungshäufigkeit des Eingangsblocks einer Funktion, den ein Basisblock dieser Funktion mindestens haben muss, um als heiß zu gelten.

en: The denominator n of fraction 1/n of the maximal execution count of a basic block in the entire program that a basic block needs to at least have in order to be considered hot (used in non-LTO mode).
de: Der Nenner n des Bruchteils 1/n der maximalen Ausführungsanzahl eines Basisblocks im gesamten Programm, den ein Basisblock mindestens haben muss, um als heiß zu gelten (im Nicht-LTO-Modus verwendet).

en: The denominator n of fraction 1/n of the number of profiled runs of the entire program below which the execution count of a basic block must be in order for the basic block to be considered unlikely.
de: Der Nenner n des Bruchteils 1/n der Anzahl der profilierten Durchläufe des gesamten Programms, unter dem die Ausführungszahl eines Grundblocks liegen muss, damit der Grundblock als unwahrscheinlich angesehen wird.

en: The derived parameter %qs at %C does not have a default value
de: Der abgeleitete Parameter %qs bei %C hat keinen Vorgabewert

en: The derived type %qs at %L is of type %qs, which has not been defined
de: Der abgeleitete Typ %qs bei %L hat Typ %qs, der nicht definiert wurde

en: The device has no SPH special function register. This option will be overridden by the compiler driver with the correct setting if presence/absence of SPH can be deduced from -mmcu=MCU.
de: Das Gerät hat kein Spezialfunktionsregister SPH. Diese Option wird vom Compilertreiber mit dem korrekten Wert überschrieben, wenn An-/Abwesenheit von SPH von -mmcu=MCU abgeleitet werden kann.

en: The earliest macOS version on which this program will run (formatted for the assembler).
de: Die älteste macOS-Version, auf der dieses Programm laufen wird (für den Assembler formatiert).

en: The earliest macOS version on which this program will run.
de: Die älteste macOS-Version, auf der dieses Programm laufen wird.

en: The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET
de: Das Element im Strukturkonstruktor bei %L für Zeigerkomponente %qs sollte ein POINTER oder ein TARGET sein

en: The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s
de: Das Element im Strukturkonstruktor bei %L für Zeigerkomponente %qs ist %s, sollte aber %s sein

en: The equivalence set for %qs cause an invalid extension to COMMON %qs at %L
de: Die Äquivalenzmenge für %qs bewirkt eine ungültige Erweiterung für COMMON %qs bei %L

en: The equivalence set for variable %qs declared at %L violates alignment requirements
de: Die Äquivalenzmenge für bei %2$L deklarierte Variable %1$qs verletzt Ausrichtungsanforderungen

en: The errmsg= argument at %L must be a default-kind character variable
de: Das Argument »errmsg=« bei %L muss eine standardartige Zeichenvariable sein

en: The event handle at %L must not be an array element
de: Das Ereignishandle bei %L darf kein Element eines Feldes sein

en: The event handle at %L must not be part of a derived type or class
de: Das Ereignishandle bei %L darf nicht Teil eines abgeleiteten Typs oder einer abgeleiteten Klasse sein

en: The event variable at %L shall not be coindexed
de: Event-Variable bei %L darf nicht koindiziert sein

en: The following options are language-independent
de: Die folgenden Optionen sind sprachunabhängig

en: The following options are language-related
de: Die folgenden Optionen sind sprachbezogen

en: The following options are not documented
de: Die folgenden Optionen sind nicht dokumentiert

en: The following options are specific to just the language
de: Die folgenden Optionen sind nur spezifisch für die Sprache

en: The following options are supported by the language
de: Die folgenden Optionen werden von der Sprache unterstützt

en: The following options are target specific
de: Die folgenden Optionen sind zielspezifisch

en: The following options control compiler warning messages
de: Die folgenden Optionen steuern Warnmeldungen des Compilers

en: The following options control optimizations
de: Die folgenden Optionen steuern Optimierungen

en: The following options control parameters
de: Die folgenden Optionen steuern Parameter

en: The following options take joined arguments
de: Die folgenden Optionen verwenden gemeinsame Argumente

en: The following options take separate arguments
de: Die folgenden Optionen verwenden separate Argumente

en: The function passed as OPERATION at %L has arguments of type %s and %s but shall have type %s
de: Die Funktion, die bei %L als OPERATION übergeben wurde, hat Argumente vom Typ »%s« und »%s«, muss aber Typ »%s« haben

en: The function passed as OPERATION at %L shall have scalar nonallocatable nonpointer arguments and return a nonallocatable nonpointer scalar
de: Die Funktion, die bei %L als OPERATION übergeben wird, muss Argumente haben, die skalar, nichtallozierbar und keine Zeiger sind, ebenso der Rückgabewert

en: The function passed as OPERATION at %L shall have the ASYNCHRONOUS attribute either for none or both arguments
de: Die Funktion, die bei %L als OPERATION übergeben wird, muss das ASYNCHRONOUS-Attribut entweder für keins oder für beide Argumente haben

en: The function passed as OPERATION at %L shall have the TARGET attribute either for none or both arguments
de: Die Funktion, die bei %L als OPERATION übergeben wird, muss das TARGET-Attribut entweder für keins oder für beide Argumente haben

en: The function passed as OPERATION at %L shall have the VALUE attribute either for none or both arguments
de: Die Funktion, die bei %L als OPERATION übergeben wird, muss das VALUE-Attribut entweder für keins oder für beide Argumente haben

en: The function passed as OPERATION at %L shall have two arguments
de: Die Funktion, die bei %L als OPERATION übergeben wird, muss zwei Argumente haben

en: The function passed as OPERATION at %L shall not have the OPTIONAL attribute for either of the arguments
de: Die Funktion, die bei %L als OPERATION übergeben wird, darf bei keinem der Argumente das OPTIONAL-Attribut haben

en: The function result on the lhs of the assignment at %L must have the pointer attribute.
de: Funktionsergebnis auf der linken Seite der Zuweisung bei %L muss Zeiger-Attribut haben.

en: The intrinsic %qs at %L is not included in the selected standard but %s and %qs will be treated as if declared EXTERNAL.  Use an appropriate %<-std=%> option or define %<-fall-intrinsics%> to allow this intrinsic.
de: Das intrinsische %qs bei %L ist nicht im ausgewählten Standard enthalten, aber %s und %qs werden wie mit EXTERNAL deklariert behandelt. Passende Option %<-std=%> verwenden oder %<-fall-intrinsics%> definieren, um dies zuzulassen.

en: The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it.
de: Das bei %2$L deklarierte INTRINSIC %1$qs ist in den derzeitigen Standardeinstellungen nicht verfügbar, außer %3$s. Entsprechende Option %<-std=*%> verwenden, oder %<-fall-intrinsics%> einschalten, um es zu verwenden.

en: The leftmost part-ref in a data-ref cannot be a function reference at %C
de: Bei %C darf das am weitesten links stehende part-ref in einem data-ref keine Funktionsreferenz sein

en: The lower bound for a buffer to be considered for stack smashing protection.
de: Untere Schranke für einen für Stack-Smashing-Protection betrachteten Puffer.

en: The max number of reload pseudos which are considered during spilling a non-reload pseudo.
de: Die Höchstzahl Reload-Pseudos, die beim Auslagern eines Nicht-Reload-Pseudos berücksichtigt werden.

en: The maximum amount of memory to be allocated by GCSE, in kilobytes.
de: Höchstmenge des von GCSE zu belegenden Speichers, in Kilobyte.

en: The maximum code size growth ratio when expanding into a jump table (in percent).  The parameter is used when optimizing for size.
de: Die maximale Wachstumsrate der Codegröße bei der Erweiterung in eine Sprungtabelle (in Prozent). Der Parameter wird bei der Optimierung auf Größe verwendet.

en: The maximum code size growth ratio when expanding into a jump table (in percent).  The parameter is used when optimizing for speed.
de: Die maximale Wachstumsrate der Codegröße bei der Erweiterung in eine Sprungtabelle (in Prozent). Der Parameter wird bei der Optimierung auf Geschwindigkeit verwendet.

en: The maximum conflict delay for an insn to be considered for speculative motion.
de: Höchste Verzögerung bei Konflikt, sodass Befehl für spekulative Bewegung in Betracht kommt.

en: The maximum depth of a loop nest we completely peel.
de: Die maximale Tiefe einer Schleifenschachtelung, die vollständig geschält wird.

en: The maximum depth of a symbolic value, before approximating the value as unknown.
de: Die maximale Tiefe eines symbolischen Wertes, bevor der Wert als unbekannt approximiert wird.

en: The maximum depth of exploded nodes that should appear in a dot dump before switching to a less verbose format.
de: Die maximale Tiefe der explodierten Knoten, die in einem Dot-Dump erscheinen sollen, bevor auf ein weniger ausführliches Format umgeschaltet wird.

en: The maximum depth of recursive inlining for inline functions.
de: Größte Tiefe mit rekursivem Inline für Inline-Funktionen.

en: The maximum depth of recursive inlining for non-inline functions.
de: Größte Tiefe rekursiven Inlinens für Nicht-Inline-Funktionen.

en: The maximum expansion factor when copying basic blocks.
de: Der höchste Erweiterungsfaktor beim Kopieren von Basisblöcken.

en: The maximum factor which the loop vectorizer applies to the cost of statements in an inner loop relative to the loop being vectorized.
de: Der maximale Faktor, den der Schleifenvektorisierer auf die Kosten der Anweisungen in einer inneren Schleife im Verhältnis zur vektorisierten Schleife anwendet.

en: The maximum instructions CSE process before flushing.
de: Die Höchstzahl der von CSE verarbeiteten Befehle vor dem Rücksetzen.

en: The maximum length of a constant string for a builtin string cmp call eligible for inlining. The default value is 3.
de: Die maximale Länge eines konstanten Strings, um den eingebauten Stringvergleich zu inlinen. Vorgabewert ist 3.

en: The maximum length of path considered in cse.
de: Größte Länge des betrachteten Pfades in CSE.

en: The maximum length of scheduling's pending operations list.
de: Die Maximallänge der Liste der anhängigen geplanten Operationen.

en: The maximum memory locations recorded by cselib.
de: Höchstzahl der Speicherstellen, die von cselib aufgezeichnet werden.

en: The maximum number of 'after supernode' exploded nodes within the analyzer per supernode, before terminating analysis.
de: Die maximale Anzahl von »nach dem Superknoten« expandierten Knoten innerhalb des Analysierers pro Superknoten, bevor die Analyse abbricht.

en: The maximum number of RTL nodes that can be recorded as combiner's last value.
de: Höchstzahl der RTL-Knoten, die als letzte Werte des Kombinierers aufgezeichnet werden können.

en: The maximum number of SSA_NAME assignments to follow in determining a value.
de: Die maximale Anzahl von SSA_NAME-Zuweisungen, die verfolgt werden, um einen Wert zu bestimmen.

en: The maximum number of backtrack attempts the scheduler should make when modulo scheduling a loop.
de: Die Höchstzahl der Versuche zur Rückverfolgung bei Modulo-Planung von Schleifen.

en: The maximum number of blocks in a region to be considered for interblock scheduling.
de: Höchstzahl der für Zwischen-Block-Scheduling zu betrachtenden Blöcke in einer Region.

en: The maximum number of branches on the path through the peeled sequence.
de: Höchstzahl der Zweige auf dem Pfad durch die geschälte Sequenz.

en: The maximum number of constraints per state.
de: Die Höchstzahl der Einschränkungen pro Zustand.

en: The maximum number of exploded nodes per program point within the analyzer, before terminating analysis of that point.
de: Die maximale Anzahl von expandierten Knoten pro Programmpunkt innerhalb des Analysierers, bevor die Analyse dieses Punkts abbricht.

en: The maximum number of incoming edges to consider for crossjumping.
de: Höchstzahl der zu betrachtenden eingehenden Kanten für Kreuzsprung.

en: The maximum number of infeasible edges to reject before declaring a diagnostic as infeasible.
de: Die maximale Anzahl der nicht durchführbaren Kanten, die zurückgewiesen werden, bevor eine Diagnose als nicht durchführbar erklärt wird.

en: The maximum number of insns combine tries to combine.
de: Höchstzahl von Befehlen, die »combine« zu kombinieren versucht.

en: The maximum number of insns in a region to be considered for interblock scheduling.
de: Höchstzahl der für Zwischen-Block-Scheduling zu betrachtenden Befehle in einer Region.

en: The maximum number of insns in loop header duplicated by the copy loop headers pass.
de: Die Höchstzahl der Befehle im Schleifenkopf, die während der Schleifenkopfkopier-Phase dupliziert werden.

en: The maximum number of insns of a completely peeled loop.
de: Die Höchstzahl der Befehle einer vollständig geschälten Schleife.

en: The maximum number of insns of a peeled loop.
de: Die Höchstzahl der Befehle einer geschälten Schleife.

en: The maximum number of insns of an unswitched loop.
de: Die Höchstzahl der Befehle einer ungeschalteten Schleife.

en: The maximum number of insns to duplicate when unfactoring computed gotos.
de: Die Höchstzahl der zu vervielfältigenden Befehle, wenn berechnete Gotos expandiert werden.

en: The maximum number of instructions in a single function eligible for inlining.
de: Die Höchstzahl der Befehle in einer einzelnen für »inline« geeigneten Funktion.

en: The maximum number of instructions in an inner loop that is being considered for versioning.
de: Die Höchstzahl der in einer inneren Schleife zu betrachtenden Befehle für Versionierung.

en: The maximum number of instructions in an outer loop that is being considered for versioning, on top of the instructions in inner loops.
de: Die Höchstzahl der in einer äußeren Schleife zu betrachtenden Befehle für Versionierung, zusätzlich zu den Befehlen in inneren Schleifen.

en: The maximum number of instructions inline function can grow to via recursive inlining.
de: Die Höchstzahl der Befehle, bis zu der eine Inline-Funktion per Rekursion wachsen kann.

en: The maximum number of instructions non-inline function can grow to via recursive inlining.
de: Die Höchstzahl der Befehle, bis zu der eine Nicht-Inline-Funktion per Rekursion wachsen kann.

en: The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass.
de: Höchstzahl der vom Scheduler während der ersten Planphase fertig zur Ausführung zu betrachtenden Befehle.

en: The maximum number of instructions to consider to fill a delay slot.
de: Die Höchstzahl der zu betrachtenden Befehle, um einen Verzögerungsschlitz zu füllen.

en: The maximum number of instructions to consider to find accurate live register information.
de: Die Höchstzahl der zu betrachtenden Befehle, um richtige aktive Registerinformationen zu finden.

en: The maximum number of instructions to consider to unroll in a loop on average.
de: Die Höchstzahl der zum Abrollen von Schleifen im Mittel zu betrachtenden Befehle.

en: The maximum number of instructions to consider to unroll in a loop.
de: Die Höchstzahl der zum Abrollen von Schleifen zu betrachtenden Befehle.

en: The maximum number of instructions to search backward when looking for equivalent reload.
de: Höchstzahl der rückwärts zu suchenden Befehle, wenn nach äquivalentem Neuladen gesucht wird.

en: The maximum number of instructions when automatically inlining small functions.
de: Die Höchstzahl der Befehle für automatisches Inlinen von kleinen Funktionen.

en: The maximum number of instructions when automatically inlining.
de: Die Höchstzahl der Befehle für automatisches Inlinen.

en: The maximum number of instructions when inlining for size.
de: Die Höchstzahl der Befehle für automatisches Inlinen beim Optimieren auf Codegröße.

en: The maximum number of iterations through CFG to extend regions.
de: Höchstzahl der Iterationen durch CFG zur Regionserweiterung.

en: The maximum number of loop iterations we predict statically.
de: Die Höchstzahl der Schleifendurchläufe, die statisch vorhergesagt werden.

en: The maximum number of nested indirect inlining performed by early inliner.
de: Die Höchstzahl von geschachteltem indirektem inlinen wurde bereits durch den frühen Inliner durchgeführt.

en: The maximum number of peelings of a single loop that is peeled completely.
de: Die Höchstzahl der Schälvorgänge einer einzelnen Schleife, die vollständig geschält wird.

en: The maximum number of peelings of a single loop.
de: Die Höchstzahl der Schälvorgänge einer einzelnen Schleife.

en: The maximum number of stmts in loop nest for loop interchange.
de: Die Höchstzahl der Anweisungen in geschachtelten Schleifen zum Schleifenaustausch.

en: The maximum number of times a callsite can appear in a call stack within the analyzer, before terminating analysis of a call that would recurse deeper.
de: Die Höchstzahl, die eine Aufrufstelle in einem Aufrufstapel innerhalb des Analysierers vorkommen darf, bevor die Analyse abgebrochen wird, um zu tiefe Rekursion zu vermeiden.

en: The maximum number of unrollings of a single loop.
de: Die Höchstzahl der Iterationen zum Abrollen in einzelner Schleife.

en: The maximum number of unswitchings in a single loop.
de: Die Höchstzahl der Abschaltungen in einer einzelnen Schleife.

en: The maximum ratio between array size and switch branches for a switch conversion to take place.
de: Maximales Verhältnis zwischen Arraygröße und Switch-Zweigen, bei dem eine Switch-Umwandlung erfolgt.

en: The maximum ratio of insertions to deletions of expressions in GCSE.
de: Das maximale Verhältnis von Einfügungen zu Löschungen von Ausdrücken in GCSE.

en: The maximum recommended size of contiguous memory occupied by two objects accessed with temporal locality by concurrent threads.  Typically the L1 cache line size, but can be smaller to accommodate a variety of target processors with different cache line sizes.
de: Die empfohlene maximale Größe des zusammenhängenden Speichers, der von zwei Objekten belegt wird, auf die von nebenläufigen Threads mit zeitlicher Lokalität zugegriffen wird. In der Regel die Größe der L1-Cache-Zeilen, kann aber auch kleiner sein, um diversen Zielprozessoren mit unterschiedlichen Cache-Zeilengrößen gerecht zu werden.

en: The maximum size of the lookahead window of selective scheduling.
de: Maximale Größe des Vorgriffsfensters der wählbaren Planung.

en: The minimal estimated speedup allowing inliner to ignore inline-insns-single and inline-insns-auto.
de: Kleinste voraussichtliche Beschleunigung, die dem Inliner erlaubt, inline-insns-single und inline-isnsns-auto zu ignorieren.

en: The minimal probability of speculation success (in percents), so that speculative insn will be scheduled.
de: Die Mindestwahrscheinlichkeit für spekulativen Erfolg (in Prozent), sodass spekulativer Befehl eingeplant wird.

en: The minimum UID to be used for a nondebug insn.
de: Kleinste UID für Nicht-Debug-Befehl.

en: The minimum constant stride beyond which we should use prefetch hints for.
de: Die kleinste Schrittweite, ab der Software-Prefetch-Tipps produziert werden.

en: The minimum cost of an expensive expression in the loop invariant motion.
de: Die Mindestkosten eines teuren Ausdrucks in der Schleifeninvariantenbewegung.

en: The minimum number of matching instructions to consider for crossjumping.
de: Mindestanzahl der passenden zu betrachtenden Befehle für Kreuzsprung.

en: The minimum number of supernodes within a function for the analyzer to consider summarizing its effects at call sites.
de: Die Mindestzahl an Superknoten innerhalb einer Funktion, die vom Analysierer berücksichtigt wird, um die Auswirkungen an den Aufrufstellen zusammenzufassen.

en: The minimum probability an edge must have for the scheduler to save its state across it.
de: Kleinste Wahrscheinlichkeit einer Kante, sodass bei der Planung ihr Zustand gesichert wird.

en: The minimum probability of reaching a source block for interblock speculative scheduling.
de: Die Mindestwahrscheinlichkeit für das Erreichen eines Quellblockes für spekulatives Zwischen-Block-Scheduling.

en: The minimum recommended offset between two concurrently-accessed objects to avoid additional performance degradation due to contention introduced by the implementation.  Typically the L1 cache line size, but can be larger to accommodate a variety of target processors with different cache line sizes. C++17 code might use this value in structure layout, but is strongly discouraged from doing so in public ABIs.
de: Der empfohlene Mindestoffset zwischen zwei Objekten, auf die nebenläufig zugegriffen wird, um zusätzliche Leistungseinbußen aufgrund von durch die Implementierung verursachten Konflikten zu vermeiden. Normalerweise die Größe der L1-Cache-Zeile, kann aber auch größer sein, um diverse Zielprozessoren mit unterschiedlichen Cache-Zeilengrößen zu berücksichtigen. C++17-Code kann diesen Wert im Strukturlayout verwenden, aber es wird dringend davon abgeraten, dies in öffentlichen ABIs zu tun.

en: The minimum size of variables taking part in stack slot sharing when not optimizing.
de: Mindestgröße von Variablen, die sich Stapelspeicher teilen, wenn nicht optimiert wird.

en: The minimum stride ratio for loop interchange to be profitable.
de: Das Mindestverhältnis der Schrittweiten, damit Schleifenaustausch profitabel ist.

en: The minimum threshold for probability of semi-invariant condition statement to trigger loop split.
de: Der minimale Schwellwert für die Wahrscheinlichkeit, dass eine halbinvariante Bedingungsanweisung eine Schleifenteilung auslöst.

en: The minimum value of stage count that swing modulo scheduler will generate.
de: Kleinster Wert der Stufenzahl, den der Swing-Modulo-Scheduler erzeugen wird.

en: The module or main program array %qs at %L must have constant shape
de: Das Feld %qs im Modul oder Hauptprogramm bei %L muss konstante Form haben

en: The name %qs at %C has already been used as an external module name
de: Der Name %qs bei %C wurde bereits als ein externer Modulname verwendet

en: The name %qs cannot be used as a defined operator at %C
de: Der Name %qs bei %C kann nicht als ein definierter Operator verwendet werden

en: The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2.
de: Die Anzahl der Newton-Iterationen, um den reziproken Wert einer double-Gleitkommazahl zu berechnen. Die Genauigkeit der Division ist proportional zu diesem Parameter, wenn die angenäherte Division angeschaltet ist. Standardwert ist 2.

en: The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1.
de: Die Anzahl der Newton-Iterationen, um den reziproken Wert einer float-Gleitkommazahl zu berechnen. Die Genauigkeit der Division ist proportional zu diesem Parameter, wenn die angenäherte Division angeschaltet ist. Standardwert ist 1.

en: The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d
de: Die Anzahl der Feldelemente des SUB-Arguments für IMAGE_INDEX bei %L muss %d (Korang) sein, nicht %d

en: The number of cycles the swing modulo scheduler considers when checking conflicts using DFA.
de: Anzahl der Zyklen, die der Swing-Modulo-Scheduler bei Konfliktprüfung mit DFA betrachtet.

en: The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option.
de: Die Anzahl der Elemente (%d) im Feldkonstruktor bei %L erfordert Erhöhung der erlaubten oberen Grenze %d. Siehe Option %<-fmax-array-constructor%>.

en: The number of elements for which hash table verification is done for each searched element.
de: Die Anzahl der Elemente, für die die Überprüfung der Hash-Tabelle für jedes gesuchte Element durchgeführt wird.

en: The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit.   See %<-fmax-array-constructor%> option
de: Die Anzahl der Elemente im Feldkonstruktor bei %L erfordert Erhöhung der erlaubten oberen Grenze %d. Siehe Option %<-fmax-array-constructor%>

en: The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option
de: Die Anzahl der Elemente im Feldkonstruktor bei %L erfordert Erhöhung der erlaubten oberen Grenze %d. Siehe Option %<-fmax-array-constructor%>

en: The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option
de: Die Anzahl der Elemente im Feldkonstruktor bei %L erfordert Erhöhung der erlaubten oberen Grenze %d. Siehe Option %<-fmax-array-constructor%>

en: The number of executions of a basic block which is considered hot. The parameter is used only in GIMPLE FE.
de: Die Anzahl der Ausführungen eines Basisblocks, der als heiß angesehen wird. Dieser Parameter wird nur im GIMPLE-Frontend verwendet.

en: The number of insns executed before prefetch is completed.
de: Die Anzahl der ausgeführten Befehle, bevor Prefetch abgeschlossen ist.

en: The number of most executed permilles of the profiled execution of the entire program to which the execution count of a basic block must be part of in order to be considered hot (used in LTO mode).
de: Die Anzahl der am häufigsten ausgeführten Promille der profilierten Ausführung des gesamten Programms, zu der die Ausführungszahl eines Basisblocks gehören muss, um als heiß zu gelten (im LTO-Modus verwendet).

en: The number of prefetches that can run at the same time.
de: Die Anzahl der Prefetches, die gleichzeitig laufen können.

en: The number of registers in each class kept unused by loop invariant motion.
de: Die Anzahl der Register in jeder Klasse, die von Schleifeninvariantenbewegung freigehalten werden.

en: The object %qs at %L has a deferred LEN parameter %qs and is neither allocatable nor a pointer
de: Das Objekt %qs bei %L hat aufgeschobenen LEN-Parameter %qs und ist weder allozierbar noch ein Zeiger

en: The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)
de: Das Objekt %qs bei %L mit ASSUMED-Typparametern muss ein Dummy oder ein SELECT-TYPE-Selektor sein (F08/4.2)

en: The parameter expression at %C does not simplify to an INTEGER constant
de: Der Parameterausdruck bei %C lässt sich nicht zu einer INTEGER-Konstante vereinfachen

en: The parameter expression at %C must be of INTEGER type and not %s type
de: Der Parameterausdruck bei %C muss vom Typ INTEGER sein, nicht %s

en: The path to devices.csv.  The GCC driver can normally locate devices.csv itself and pass this option to the compiler, so the user shouldn't need to pass this.
de: Der Pfad zu »devices.csv«. Im Normalfall kann der GCC-Treiber das selbst rausfinden und an den Compiler übermitteln, daher ist die Angabe eigentlich nicht nötig.

en: The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available.
de: Prozentsatz der Funktion, gewichtet nach Ausführungshäufigkeit, die bei Verfolgungsentwurf abgedeckt werden muss. Verwendet, wenn Profil-Rückmeldung verfügbar ist.

en: The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is not available.
de: Prozentsatz der Funktion, gewichtet nach Ausführungshäufigkeit, die bei Verfolgungsentwurf abgedeckt werden muss. Verwendet, wenn Profil-Rückmeldung nicht verfügbar ist.

en: The pointer object %qs at %L must have an explicit function interface or be declared as array
de: Das Zeigerobjekt %qs bei %L muss eine explizite Funktionsschnittstelle haben oder als Feld deklariert sein

en: The possible SVE vector lengths:
de: Mögliche SVE-Vektorlängen:

en: The possible TLS dialects:
de: Mögliche TLS-Dialekte:

en: The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)
de: Der Rang des Elements im Strukturkonstruktor bei %L passt nicht zu dem der Komponente (%d/%d)

en: The resolution file.
de: Die Datei mit den Auflösungen.

en: The scale (in percents) applied to inline-insns-single and auto limits when heuristics hints that inlining is very profitable.
de: Die Skalierung (in Prozent), die auf inline-insns-single und Auto-Limits angewendet wird, wenn die Heuristik darauf hinweist, dass Inlining sehr profitabel ist.

en: The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)
de: Die Form der Komponente %qs im Strukturkonstruktor bei %L unterscheidet sich von der Form der deklarierten Komponente für die Dimension %d (%ld/%ld)

en: The size of L1 cache line.
de: Die Größe einer L1-Cacheline.

en: The size of L1 cache.
de: Die Größe des L1-Caches.

en: The size of L2 cache.
de: Die Größe des L2-Caches.

en: The size of function body to be considered large.
de: Die Größe eines als groß angesehenen Funktionskörpers.

en: The size of stack frame to be considered large.
de: Die Größe eines als groß angesehenen Stapelrahmens.

en: The size of translation unit that IPA-CP pass considers large.
de: Die Größe einer Übersetzungseinheit, ab der der IPA-CP-Durchlauf sie als groß ansieht.

en: The size of translation unit to be considered large.
de: Die Größe einer als groß angesehenen Übersetzungseinheit.

en: 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.
de: Kleinste Zahl unterschiedlicher Werte, für die eine Sprungtabelle besser als ein Baum bedingter Sprünge ist; bei 0 wird der Standard für die Zielarchitektur verwendet.

en: The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray
de: Der Quellausdruck bei %L darf weder vom Typ EVENT_TYPE sein noch eine EVENT_TYPE-Komponente haben, wenn ALLOCATE-Objekt bei %L ein Koarray ist

en: The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray
de: Der Quellausdruck bei %L darf weder vom Typ LOCK_TYPE sein noch eine LOCK_TYPE-Komponente haben, wenn ALLOCATE-Objekt bei %L ein Koarray ist

en: The stat= argument at %L must be a kind=4 integer variable
de: Das Argument »stat=« bei %L muss INTEGER-Variable mit »kind=4« sein

en: The symbol %qs, referenced at %L, is not in the selected standard
de: Das bei %2$L referenzierte Symbol %1$qs ist nicht im gewählten Standard vorhanden

en: The threshold ratio for performing partial redundancy elimination after reload.
de: Der Schwellwert-Anteil für die Ausführung partieller Redundanzbeseitigung nach dem Neuladen.

en: The threshold ratio of critical edges execution count that permit performing redundancy elimination after reload.
de: Der Schwellwert-Anteil des Ausführungszählers kritischer Kanten, die Redundanzbeseitigung nach dem Neuladen erlauben.

en: The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L
de: Der Typ %qs bei %L darf nicht mit Wirt verbunden sein, da er von unverträglichem bei %L definierten Objekt mit gleichem Namen blockiert wird

en: The type for function %qs at %L is not accessible
de: Der Typ für Funktion %qs bei %L ist nicht zugreifbar

en: The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters
de: Die Typparameter-Angabenliste bei %C kann nicht gleichzeitig ASSUMED- und DEFERRED-Parameter enthalten

en: The type parameter spec list at %C contains too many parameter expressions
de: Die Typparameter-Angabenliste bei %C enthält zu viele Parameterausdrücke

en: The type parameter spec list at %C does not contain enough parameter expressions
de: Die Typparameter-Angabenliste bei %C enthält nicht genug Parameterausdrücke

en: The type parameter spec list in the type-spec at %L cannot contain DEFERRED parameters
de: Die Spezifikationsliste für Typparameter in der Spezifikation bei %L darf keine DEFERRED-Parameter enthalten

en: The type-spec at %L shall specify that each length type parameter is assumed
de: Die Typspezifikation bei %L muss angeben, dass jeder Parameter mit Längentyp vermutet ist

en: The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]
de: Typspezifikation darf keinen Sequenz-abgeleiteten Typ oder Typ mit BIND-Attribut in SELECT TYPE bei %C beschreiben [F2003:C815]

en: The upper bound for sharing integer constants.
de: Obere Schranke zum gemeinsamen Verwenden von Ganzzahlkonstanten.

en: The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L
de: Die obere Schranke in der letzten Dimension muss in der Referenz auf das Feld %qs vermuteter Größe bei %L auftreten

en: The value for the KIND parameter %qs at %C does not reduce to a constant expression
de: Der Wert für den KIND-Parameter %qs bei %C lässt sich nicht auf einen konstanten Ausdruck reduzieren

en: The value of n in %<-finit-character=n%> must be between 0 and 127
de: Der Wert von n in %<-finit-character=n%> muss zwischen 0 und 127 liegen

en: The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration
de: Der Wert des Parameters PDT LEN »%s« stimmt nicht mit dem in der Dummy-Deklaration überein

en: The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d
de: Der Wert des SELECT-RANK-CASE-Ausdrucks bei %C darf nicht kleiner als Null oder größer als %d sein

en: The version of the C++ ABI in use.
de: Die Version der C++-ABI, die verwendet wird.

en: The version of the C++ ABI used for -Wabi warnings and link compatibility aliases.
de: Die Version der C++-ABI, die für »-Wabi«-Warnungen und Bindungskompatibilitätsaliase verwendet wird.

en: There is already a procedure with binding name %qs for the derived type %qs at %C
de: Es gibt bereits eine Prozedur mit Bindungsname %qs für den abgeleiteten Typ %qs bei %C

en: There is no specific function for the generic %qs at %L
de: Es gibt keine spezifische Funktion für das allgemeine %qs bei %L

en: There is no specific subroutine for the generic %qs at %L
de: Es gibt kein spezifisches Unterprogramm für allgemeines %qs bei %L

en: There's already a non-generic procedure with binding name %qs for the derived type %qs at %C
de: Es gibt bereits eine nicht-generische Prozedur mit Bindungsname %qs für den abgeleiteten Typ %qs bei %C

en: This is free software; see the source for copying conditions.  There is NO
    warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
de: Dies ist freie Software; die Kopierbedingungen stehen in den Quellen. Es
    gibt KEINE Garantie; auch nicht für MARKTGÄNGIGKEIT oder FÜR SPEZIELLE ZWECKE.

en: This is the default.
de: Dies ist der Vorgabewert.

en: This option is deprecated and has no effect.
de: Dieser Schalter ist veraltet und hat keine Auswirkung.

en: This option is ignored; it is provided for compatibility purposes only.  This used to select linker and preprocessor options for use with newlib.
de: Diese Option wird ignoriert; sie wird nur zu Kompatibilitätszwecken bereitgestellt. Sie diente zur Auswahl von Linker- und Präprozessor-Optionen für die Verwendung mit der newlib.

en: This option lacks documentation.
de: Diese Option ist undokumentiert.

en: This switch is deprecated; do not use.
de: Dieser Schalter ist veraltet; nicht verwenden.

en: This switch is deprecated; use -Werror=implicit-function-declaration instead.
de: Dieser Schalter ist veraltet; stattdessen -Werror=implicit-function-declaration verwenden.

en: This switch is deprecated; use -Wextra instead.
de: Dieser Schalter ist veraltet; stattdessen -Wextra verwenden.

en: This switch is deprecated; use -fsanitize-recover= instead.
de: Dieser Schalter ist veraltet; stattdessen -fsanitize-recover= verwenden.

en: Thread model: %s
de: Thread-Modell: %s

en: Threadprivate at %L isn't SAVEd
de: Threadprivate bei %L ist nicht SAVEd

en: Threadprivate variable at %C is an element of a COMMON block
de: Threadprivate Variable bei %C ist ein Element eines COMMON-Blocks

en: Threshold ipa-cp opportunity evaluation that is still considered beneficial to clone.
de: Schwellwert für Auswertung der Möglichkeit von IPA-CP, der noch als vorteilhaft zum Kopieren betrachtet wird.

en: Thumb-1 %<hard-float%> VFP ABI
de: Thumb-1 %<hard-float%> VFP-ABI

en: Thumb: Assume function pointers may go to non-Thumb aware code.
de: Thumb: Annehmen, dass Funktionszeiger an Code übergeben werden können, der nichts von Thumb weiß.

en: Thumb: Assume non-static functions may be called from ARM code.
de: Thumb: Annehmen, dass nichtstatische Funktionen von ARM-Code aus aufgerufen werden können.

en: Thumb: Generate (leaf) stack frames even if not needed.
de: Thumb: (Blatt-)Stapelrahmen erzeugen, auch wenn nicht erforderlich.

en: Thumb: Generate (non-leaf) stack frames even if not needed.
de: Thumb: (Nicht-Blatt-)Stapelrahmen erzeugen, auch wenn nicht erforderlich.

en: Thunk is not supposed to have body
de: Interner Fehler: Thunk is not supposed to have body

en: Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L
de: Gekachelte Schleife bei %L kann nicht über Gangs, Worker oder Vektoren übergreifend parallelisiert werden

en: Time accounted for function prologue, epilogue and other overhead.
de: Zeit, die für Funktionsprolog, -Epilog und sonstigen Overhead veranschlagt wird.

en: Time accounted for function thunk overhead.
de: Zeit, die für Thunk-Overhead in Funktionen veranschlagt wird.

en: To enable preprocessing, use %<-cpp%>
de: Zum Einschalten der Vorverarbeitung %<-cpp%> verwenden

en: Toggle -fvar-tracking-assignments.
de: -fvar-tracking-assignments umschalten.

en: Toggle debug information generation.
de: Erzeugung von Fehlersuchinformationen umschalten.

en: Too few codimensions at %C, expected %d not %d
de: Zu wenige Codimensionen bei %C, %d statt %d erwartet

en: Too few dummy arguments in DTIO procedure %qs at %L
de: Zu wenige Scheinargumente in DTIO-Prozedur %qs bei %L

en: Too many arguments in call to %qs at %L
de: Zu viele Argumente in Aufruf von %qs bei %L

en: Too many arguments to %s at %L
de: Zu viele Argumente für %s bei %L

en: Too many codimensions at %C, expected %d not %d
de: Zu viele Codimensionen bei %C, %d statt %d erwartet

en: Too many components in structure constructor at %L
de: Zu viele Komponenten in Strukturkonstruktor bei %L

en: Too many digits in statement label at %C
de: Zu viele Ziffern in Anweisungsmarke bei %C

en: Too many dummy arguments in DTIO procedure %qs at %L
de: Zu viele Scheinargumente in DTIO-Prozedur %qs bei %L

en: Too many elements in array initializer at %C
de: Zu viele Elemente in Feldinitialisierung bei %C

en: Transform condition stores into unconditional ones.
de: Bedingte Speicherbefehle in unbedingte umwandeln.

en: Transformational function %qs at %L is invalid in an initialization expression
de: Transformierende Funktion %qs bei %L darf nicht in einem Initialisierungs-Ausdruck auftreten

en: Transparent alias and target%'s assembler names differs
de: Interner Fehler: Transparent alias and target%'s assembler names differs

en: Trap for signed overflow in addition, subtraction and multiplication.
de: Vorzeichenbehafteten Überlauf in Addition, Subtraktion und Multiplikation abfangen (»trap«).

en: Trap on integer divide by zero.
de: Ganzzahldivision durch Null abfangen.

en: Treat a throw() exception specification as noexcept to improve code size.
de: Um Codegröße zu verbessern, eine throw()-Ausnahmespezifikation als »noexcept« behandeln.

en: Treat all warnings as errors.
de: Alle Warnungen als Fehler behandeln.

en: Treat data references as near, far or medium. medium is default.
de: Datenreferenzen als near, far oder medium behandeln. Standard ist medium.

en: Treat integers as 32-bit.
de: Ganzzahlen als 32 Bit behandeln.

en: Treat known sprintf return values as constants.
de: Bekannte sprintf-Rückgabewerte als Konstanten behandeln.

en: Treat lines with 'D' in column one as comments.
de: Zeilen mit »D« in Spalte eins als Kommentar behandeln.

en: Treat main as if it had attribute OS_task.
de: »main« so behandeln, als hätte sie das Attribut OS_task.

en: Treat missing header files as generated files.
de: Fehlende Header-Dateien als generierte Dateien behandeln.

en: Treat signed overflow as undefined.  Negated as -fwrapv -fwrapv-pointer.
de: Vorzeichenbehafteten Überlauf als undefiniertes Verhalten behandeln. Wird mit -fwrapv -fwrapv-pointer negiert.

en: Treat specified warning as error.
de: Angegebene Warnung als Fehler behandeln.

en: Treat the input file as already preprocessed.
de: Die Eingabedatei als bereits vorverarbeitet behandeln.

en: True if a non-short-circuit operation is optimal.
de: Bei den booleschen Kurzschluss-Operatoren && und || beide Seiten auswerten, wenn das nebenwirkungsfrei zu besserem Code führt.

en: Try running '%s' in the shell to raise its limit.
de: »%s« in der Shell könnte diese Beschränkung erhöhen.

en: Try to allow the linker to turn PIC calls into direct calls.
de: Dem Linker erlauben, PIC-Aufrufe in direkte Aufrufe umzuwandeln.

en: Try to convert virtual calls to direct ones.
de: Versuchen, virtuelle Sprünge in direkte umzuwandeln.

en: Try to interchange loops if profitable.
de: Versuchen, Schleifen zu tauschen, wenn es nützt.

en: Try to lay out derived types as compactly as possible.
de: Versuchen, abgeleitete Typen so kompakt wie möglich anzuordnen.

en: Tune code for the given processor.
de: Code für angegebenen Prozessor optimieren.

en: Tune expected memory latency.
de: Die erwartete Speicher-Wartezeit abstimmen.

en: Tune for the specified target CPU or architecture.
de: Für angegebene Ziel-CPU oder Architektur optimieren.

en: Turn off all revertable D language features.
de: Alle Sprachfunktionen, die sich rückgängig machen lassen, ausschalten.

en: Turn off any diagnostics features that complicate the output, such as line numbers, color, and warning URLs.
de: Alle Diagnosefunktionen deaktivieren, die die Ausgabe verkomplizieren, wie Zeilennummern, Farbe und Warn-URLs.

en: Turn on CET instrumentation for switch statements that use a jump table and an indirect jump.
de: Aktiviert CET-Instrumentierung für solche switch-Anweisungen, die Sprungtabellen und indirekte Sprünge verwenden.

en: Turn on Redundant Extensions Elimination pass.
de: Durchlauf für Redundante Erweiterungsentfernung (REE) einschalten.

en: Turn on all upcoming D language features.
de: Alle zukünftigen D-Sprachfunktionen einschalten.

en: Two main PROGRAMs at %L and %C
de: Zwei Haupt-PROGRAMme bei %L und %C

en: Two or more part references with nonzero rank must not be specified at %L
de: Zwei oder mehr Teilreferenzen mit Rang größer Null dürfen nicht bei %L angegeben werden

en: Two symbols with same comdat_group are not linked by the same_comdat_group list.
de: Interner Fehler: Two symbols with same comdat_group are not linked by the same_comdat_group list.

en: Type %qs containing DEFERRED binding at %C is not ABSTRACT
de: Typ %qs mit DEFERRED-Bindung bei %C ist nicht ABSTRACT

en: Type %qs of CLASS variable %qs at %L is not extensible
de: Typ %qs der CLASS-Variable %qs bei %L ist nicht erweiterbar

en: Type declaration %qs at %L is not C interoperable but it is BIND(C)
de: Typdeklaration %qs bei %L ist nicht C-kompatibel, aber sie ist BIND(C)

en: Type definition of %qs at %C was already defined at %L
de: Typdefinition von %qs bei %C wurde bereits bei %L definiert

en: Type inaccessible in variable definition context (%s) at %L
de: Typ nicht zugreifbar in Variablen-Definitionskontext (%s) bei %L

en: Type mismatch between actual argument at %L and actual argument at %L (%s/%s).
de: Unverträgliche Typen zwischen Argument bei %L und Argument bei %L (%s/%s).

en: Type mismatch in argument %qs at %L; passed %s to %s
de: Unpassender Typ in Argument %qs bei %L; %s wurde an %s übergeben

en: Type name %qs at %C cannot be the same as an intrinsic type
de: Typname %qs bei %C kann nicht der gleiche wie ein intrinsischer Typ sein

en: Type name %qs at %C conflicts with previously declared entity at %L, which has the same name
de: Typname %qs bei %C in Konflikt mit vorher deklarierter Entität bei %L, die den gleichen Namen hat

en: Type name %qs at %C is ambiguous
de: Typname %qs bei %C ist mehrdeutig

en: Type of %s argument of IMAGE_INDEX at %L shall be INTEGER
de: Der Typ des Arguments »%s« von IMAGE_INDEX bei %L muss ein INTEGER sein

en: Type of entity at %L is type incompatible with source-expr at %L
de: Typ der Entität bei %L ist mit Quellausdruck bei %L typunverträglich

en: Type of entity at %L is type incompatible with typespec
de: Typ der Entität bei %L ist mit Typspezifikation unverträglich

en: Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L
de: Typparameter %qs bei %C hat keinen zugehörigen Eintrag in der Typparameter-Namensliste bei %L

en: Type specified for intrinsic function %qs at %L is ignored
de: Für intrinsische Funktion %qs angegebener Typ bei %L wird ignoriert

en: Type-bound operator at %L cannot be NOPASS
de: Typgebundener Operator bei %L kann nicht NOPASS sein

en: Type-bound procedure at %C
de: Typgebundene Prozedur bei %C

en: Type-spec at %L cannot contain a deferred type parameter
de: Typspezifikation bei %L kann keine Parameter mit aufgeschobenem Typ haben

en: Type-spec at %L cannot contain an asterisk for a type parameter
de: Typspezifikation bei %L darf kein Sternchen für einen Typparameter enthalten

en: UNIT not specified at %L
de: Bei %L wurde kein UNIT angegeben

en: UNIT number in CLOSE statement at %L must be non-negative
de: UNIT-Zahl in CLOSE-Anweisung bei %L muss nicht-negativ sein

en: UNIT number in INQUIRE statement at %L cannot be %d
de: UNIT-Zahl in INQUIRE-Anweisung bei %L darf nicht %d sein

en: UNIT number in statement at %L must be non-negative
de: UNIT-Zahl in Anweisung bei %L muss nicht-negativ sein

en: UNIT number missing in statement at %L
de: Fehlende UNIT-Zahl in Anweisung bei %L

en: UNIT specification at %L must be an INTEGER expression or a CHARACTER variable
de: UNIT-Spezifikation bei %L muss ein INTEGER-Ausdruck oder eine CHARACTER-Variable sein

en: UNIT specification at %L must not be a character PARAMETER
de: UNIT-Spezifikation bei %L darf kein Zeichen-PARAMETER sein

en: UNIT specifier not allowed with NEWUNIT at %L
de: UNIT-Spezifizierer mit NEWUNIT bei %L nicht erlaubt

en: UNLOCK statement at %C
de: UNLOCK-Anweisung bei %C

en: UNTIL_COUNT= argument at %L must be a scalar INTEGER expression
de: Argument UNTIL_COUNT= bei %L muss ein skalarer INTEGER-Ausdruck sein

en: USE statement at %C has no ONLY qualifier
de: USE-Anweisung bei %C hat keinen ONLY-Qualifizierer

en: Unable to find a specific INTRINSIC procedure for the reference %qs at %L
de: Spezifische INTRINSIC-Prozedur für Referenz %qs bei %L kann nicht gefunden werden

en: Unable to find symbol %qs
de: Symbol %qs kann nicht gefunden werden

en: Unable to generate load/store offset for fusion
de: Lade-/Speicheroffset für Fusion kann nicht generiert werden

en: Unable to resolve the specific function %qs at %L
de: Spezifische Funktion %qs bei %L kann nicht aufgelöst werden

en: Unable to resolve the specific subroutine %qs at %L
de: Spezifisches Unterprogramm %qs bei %L kann nicht aufgelöst werden

en: Unclassifiable GCC directive at %C
de: Nicht klassifizierbare GCC-Anweisung bei %C

en: Unclassifiable GCC directive at %C, ignored
de: Nicht klassifizierbare GCC-Direktive bei %C, wird ignoriert

en: Unclassifiable OpenACC directive at %C
de: Nicht klassifizierbare OpenACC-Anweisung bei %C

en: Unclassifiable OpenMP directive at %C
de: Nicht klassifizierbare OpenMP-Anweisung bei %C

en: Unclassifiable statement at %C
de: Nicht klassifizierbare Anweisung bei %C

en: Undefined specific binding %qs as target of GENERIC %qs at %L
de: Undefinierte spezifische Bindung %qs als Ziel des GENERIC %qs bei %L

en: Under -ffast-math, generate a FRIZ instruction for (double)(long long) conversions.
de: Unter -ffast-math einen FRIZ-Befehl für (double)(long long)-Umwandlungen erzeugen.

en: Under the control of Object Size type, warn about buffer overflow in string manipulation functions like memcpy and strcpy.
de: Unter der Kontrolle des Object-Size-Typs warnen, wenn Pufferüberläufe in Stringmanipulationsfunktionen wie memcpy und strcpy auftreten.

en: Unequal character lengths (%ld/%ld) in %s
de: Ungleiche Zeichenlängen (%ld/%ld) in %s

en: Unequal character lengths (%ld/%ld) in %s at %L
de: Ungleiche Zeichenlängen (%ld, %ld) in %s bei %L

en: Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L
de: Ungleiche Zeichenlängen (%wd/%wd) für Zeigerkomponente %qs in Konstruktor bei %L

en: Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause
de: Unerwartetes !$OMP SCAN bei %L außerhalb eines Schleifenkonstrukts mit %<inscan%>-REDUCTION-Klausel

en: Unexpected %<%c%> for nonderived-type variable %qs at %C
de: Unerwartetes %<%c%> für Variable %qs nicht-abgeleiteten Typs bei %C

en: Unexpected %<*%> for codimension %d of %d at %C
de: Unerwartetes %<*%> für Codimension %d von %d bei %C

en: Unexpected %<*%> in coarray subscript at %C
de: Unerwartetes %<*%> in Coarray-Index bei %C

en: Unexpected %s statement at %C
de: Unerwartete Anweisung %s bei %C

en: Unexpected %s statement at %C in INTERFACE body
de: Unerwartete Anweisung %s bei %C in INTERFACE-Körper

en: Unexpected %s statement in BLOCK DATA at %C
de: Unerwartete Anweisung %s in BLOCK DATA bei %C

en: Unexpected %s statement in CONTAINS section at %C
de: Unerwartete Anweisung %s in CONTAINS-Abschnitt bei %C

en: Unexpected %s statement in FORALL block at %C
de: Unerwartete Anweisung %s in FORALL-Block bei %C

en: Unexpected %s statement in INTERFACE block at %C
de: Unerwartete Anweisung %s in INTERFACE-Block bei %C

en: Unexpected %s statement in MODULE at %C
de: Unerwartete Anweisung %s in MODULE bei %C

en: Unexpected %s statement in WHERE block at %C
de: Unerwartete Anweisung %s in WHERE-Block bei %C

en: Unexpected CASE statement at %C
de: Unerwartete CASE-Anweisung bei %C

en: Unexpected DIM argument with noncoarray argument at %L
de: Unerwartetes DIM-Argument mit Nicht-COARRAY-Argument bei %L

en: Unexpected END statement at %C
de: Unerwartete END-Anweisung bei %C

en: Unexpected ENTRY statement at %C
de: Unerwartete ENTRY-Anweisung bei %C

en: Unexpected EOF
de: Unerwartetes EOF

en: Unexpected NULL() intrinsic at %L to dummy %qs
de: Unerwartetes intrinsisches NULL() bei %L für Schein-%qs

en: Unexpected OpenACC parallelism.
de: Unerwarteter OpenACC-Parallelismus.

en: Unexpected RANK statement at %C
de: Unerwartete RANK-Anweisung bei %C

en: Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR
de: Unerwartetes SHAPE-Argument bei %L für C_F_POINTER mit skalarem FPTR

en: Unexpected TYPE IS statement at %C
de: Unerwartete TYPE IS-Anweisung bei %C

en: Unexpected alternate return specifier in subroutine call at %L
de: Unerwartete alternative Rückgabespezifikation in Unterprogrammaufruf bei %L

en: Unexpected character in variable list at %C
de: Unerwartetes Zeichen in Variablenliste bei %C

en: Unexpected characters in PARAMETER statement at %C
de: Unerwartete Zeichen in PARAMETER-Anweisung bei %C

en: Unexpected coarray designator at %C
de: Unerwarteter Coarray-Bezeichner bei %C

en: Unexpected complex-parts designator reference in %s clause at %L
de: Unerwarteter Verweis auf »complex-parts designator« in »%s«-Klausel bei %L

en: Unexpected constant at %C
de: Unerwartete Konstante bei %C

en: Unexpected derived-type entities in binary intrinsic numeric operator %%<%s%%> at %%L
de: Unerwartete Entitäten mit abgeleitetem Typ im binären intrinsischen numerischen Operator %%<%s%%> bei %%L

en: Unexpected element %qc in format string at %L
de: Unerwartetes Element %qc in Formatzeichenkette bei %L

en: Unexpected end of file in %qs
de: Unerwartetes Dateiende in %qs

en: Unexpected end of format string in format string at %L
de: Unerwartetes Ende der Formatzeichenkette bei %L

en: Unexpected end of module
de: Unerwartetes Modulende

en: Unexpected intrinsic type %qs at %L
de: Unerwarteter intrinsischer Typ %qs bei %L

en: Unexpected junk after !$ACC ATOMIC statement at %C
de: Unerwarteter Ausschuss hinter »!$ACC ATOMIC«-Anweisung bei %C

en: Unexpected junk after !$ACC DECLARE at %C
de: Unerwarteter Ausschuss hinter »!$ACC DECLARE« bei %C

en: Unexpected junk after !$OMP DECLARE REDUCTION at %C
de: Unerwarteter Ausschuss hinter »!$OMP DECLARE REDUCTION« bei %C

en: Unexpected junk after !$OMP DECLARE TARGET at %C
de: Unerwarteter Ausschuss hinter »!$OMP DECLARE TARGET« bei %C

en: Unexpected junk after !$OMP SCAN at %C
de: Unerwarteter Ausschuss hinter !$OMP SCAN bei %C

en: Unexpected junk after $OMP BARRIER statement at %C
de: Unerwarteter Ausschuss hinter $OMP BARRIER-Anweisung bei %C

en: Unexpected junk after $OMP CANCELLATION POINT statement at %C
de: Unerwarteter Ausschuss hinter »$OMP CANCELLATION POINT«-Anweisung bei %C

en: Unexpected junk after $OMP CRITICAL statement at %C
de: Unerwarteter Ausschuss hinter $OMP CRITICAL-Anweisung bei %C

en: Unexpected junk after $OMP FLUSH statement at %C
de: Unerwarteter Ausschuss inter $OMP FLUSH-Anweisung bei %C

en: Unexpected junk after $OMP MASTER statement at %C
de: Unerwarteter Ausschuss hinter $OMP MASTER-Anweisung bei %C

en: Unexpected junk after $OMP NOTHING statement at %C
de: Unerwarteter Ausschuss hinter »$OMP NOTHING«-Anweisung bei %C

en: Unexpected junk after $OMP WORKSHARE statement at %C
de: Unerwarteter Ausschuss hinter $OMP WORKSHARE-Anweisung bei %C

en: Unexpected junk after %qs at %L
de: Unerwarteter Ausschuss hinter %qs bei %L

en: Unexpected junk after NOWAIT clause at %C
de: Unerwarteter Ausschuss hinter NOWAIT-Klausel bei %C

en: Unexpected junk after OMP THREADPRIVATE at %C
de: Unerwarteter Ausschuss hinter »OMP THREADPRIVATE« bei %C

en: Unexpected junk after TASKYIELD clause at %C
de: Unerwarteter Ausschuss hinter TASKYIELD-Klausel bei %C

en: Unexpected junk after function declaration at %C
de: Unerwartete Angaben hinter Funktionsdeklaration bei %C

en: Unexpected junk at %C
de: Unerwartete Zeichen bei %C

en: Unexpected junk in formal argument list at %C
de: Unerwartete Angaben in formaler Argumentliste bei %C

en: Unexpected substring reference in %s clause at %L
de: Unerwarteter Verweis auf Teilzeichenkette in %s-Klausel bei %L

en: Unexpected use of subroutine name %qs at %C
de: Unerwartete Verwendung des Unterprogrammnamens %qs bei %C

en: Uninitialized probability of edge %i->%i
de: Interner Fehler: Uninitialized probability of edge %i->%i

en: Unit number in I/O statement too large
de: Einheitszahl in E/A-Anweisung zu groß

en: Unit number in I/O statement too small
de: Einheitszahl in E/A-Anweisung zu klein

en: Unknown argument %qs at %L to intrinsic %s
de: Unbekanntes Argument %qs bei %L für intrinsisches %s

en: Unknown argument list function at %L
de: Unbekannte Argumentlistenfunktion bei %L

en: Unknown attribute in !GCC$ ATTRIBUTES statement at %C
de: Unbekanntes Attribut in !GCC$ ATTRIBUTES-Anweisung bei %C

en: Unknown form for stack limit expression
de: Unbekannte Form für Ausdruck für Stapelgrenze

en: Unknown intrinsic op
de: Unbekannte eingebauter Operator

en: Unknown operator %%<%s%%> at %%L
de: Unbekannter Operator %%<%s%%> bei %%L

en: Unknown operator %%<%s%%> at %%L; did you mean '%s'?
de: Unbekannter Operator %%<%s%%> bei %%L; meinten Sie »%s«?

en: Unknown procedure name %qs at %C
de: Unbekannter Prozedurname %qs bei %C

en: Unlimited polymorphic allocate-object at %L requires either a type-spec or SOURCE tag or a MOLD tag
de: Unbeschränkt polymorphes ALLOCATE-Objekt bei %L erfordert entweder eine Typspezifikation, SOURCE-Marke oder MOLD-Marke

en: Unrecognized MCU name %qs.
de: Unbekannter MCU-Name %qs.

en: Unrecognized option to %<-finit-logical%>: %s
de: Unbekannte Option für %<-finit-logical%>: %s

en: Unrecognized option to endianness value: %qs
de: Unbekannte Option für Endianess-Wert: %qs

en: Unrecognized option to floating-point init value: %qs
de: Unbekannte Option für Gleitkomma-Initialisierungswert: %qs

en: Unrecognized option: %qs
de: Unbekannte Option %qs

en: Unsupported code '%c' for fixed-point:
de: Code »%c« für Festkomma nicht unterstützt:

en: Unsupported operand for code '%c'
de: Operand für Code »%c« nicht unterstützt

en: Unsupported statement inside WHERE at %L
de: Nicht unterstützte Anweisung in WHERE bei %L

en: Unsupported value for mmpy-option
de: Nicht unterstützter Wert für »-mmpy-option«

en: Unsupported: multiple OpenACC 'routine' levels of parallelism
de: Mehrfache Parallelismus-Stufen in OpenACC-Routinen werden nicht unterstützt

en: Unterminated character constant beginning at %C
de: Unbeendete Zeichenkonstante beginnend bei %C

en: Unused PRIVATE module variable %qs declared at %L
de: Ungenutzte PRIVATE-Variable %qs bei %L deklariert

en: Unused dummy argument %qs at %L
de: Ungenutztes Dummyargument %qs bei %L

en: Unused initialization string at %L because variable has zero length
de: Unbenutzte Initialisierungszeichenkette bei %L, da die Variable die Länge 0 hat

en: Unused module variable %qs which has been explicitly imported at %L
de: Ungenutzte Modulvariable »%qs«, die bei %L ausdrücklich importiert wurde

en: Unused parameter %qs declared at %L
de: Ungenutzter Parameter %qs, bei %L deklariert

en: Unused parameter %qs which has been explicitly imported at %L
de: Ungenutzter Parameter %qs, der bei %L ausdrücklich importiert wurde

en: Unused variable %qs declared at %L
de: Ungenutzte Variable %qs, bei %L deklariert

en: Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d
de: Obere Feldreferenz bei %L ist außerhalb der Schranken (%ld < %ld) in Dimension %d

en: Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d
de: Obere Feldreferenz bei %L ist außerhalb der Schranken (%ld > %ld) in Dimension %d

en: Upper bound of last coarray dimension must be %<*%> at %C
de: Obere Grenze der letzten Coarray-Dimension muss %<*%> sein, bei %C

en: Upper cobound is less than lower cobound at %L
de: Obere Kogrenze ist kleiner als untere Kogrenze bei %L

en: Upper cobound is less than lower cobound of 1 at %L
de: Obere Kogrenze ist kleiner als untere Kogrenze von 1 bei %L

en: Usage: %s [OPTION]... SUB_COMMAND [OPTION]...
de: Aufruf: %s [Option]… <Teilbefehl> [Option]…

en: Usage: %s [options] file...
de: Aufruf: %s [Optionen] Datei...

en: Usage: gcov [OPTION...] SOURCE|OBJ...
de: Aufruf: gcov [OPTION]... QUELLE|OBJ...

en: Use "-Wa,OPTION" to pass "OPTION" to the assembler.
de: »-Wa,OPTION« verwenden, um »OPTION« an den Assembler zu übergeben.

en: Use "-Wl,OPTION" to pass "OPTION" to the linker.
de: »-Wl,OPTION« verwenden, um »OPTION« an den Linker zu übergeben.

en: Use %reloc() operators, rather than assembly macros, to load addresses.
de: %reloc()-Operatoren statt Assemblermakros verwenden, um Adressen zu laden.

en: Use -G for data that is not defined by the current object.
de: -G für Daten verwenden, die nicht von aktuellem Objekt definiert wurden.

en: Use -G for object-local data.
de: -G für objekt-lokale Daten verwenden.

en: Use -mlong-double-64 for 64-bit IEEE floating point format.  Use -mlong-double-128 for 128-bit floating point format (either IEEE or IBM).
de: Verwenden Sie »-mlong-double-64« für das 64-Bit-IEEE-Gleitkommazahlen-Format. Verwenden Sie »-mlong-double-128« für das 128-Bit-Gleitkommazahlen-Format (entweder IEEE oder IBM).

en: Use 128-bit AVX instructions instead of 256-bit AVX instructions in the auto-vectorizer.
de: 128-Bit-AVX-Befehle statt 256-Bit-AVX-Befehlen in Auto-Vektorisierer verwenden.

en: Use 128-bit long double.
de: 128-bit long double verwenden.

en: Use 16 bit int.
de: 16-Bit int verwenden.

en: Use 32 bit int.
de: 32-Bit int verwenden.

en: Use 32-bit ABI.
de: 32-Bit-ABI verwenden.

en: Use 32-bit DWARF format when emitting DWARF debug information.
de: Wenn DWARF-Debuginformationen erzeugt werden, dann im 32-Bit-Format.

en: Use 32-bit floating-point registers.
de: 32-Bit-Gleitkommaregister verwenden.

en: Use 32-bit general registers.
de: Allgemeine Register in 32 Bit Breite verwenden.

en: Use 32-bit offsets in jump tables rather than 16-bit offsets.
de: In Sprungtabellen 32-Bit-Offsets statt 16-Bit-Offsets verwenden.

en: Use 4 byte entries in switch tables.
de: 4-Byte-Einträge in switch-Tabellen verwenden.

en: Use 4 media accumulators.
de: 4 Medien-Register verwenden.

en: Use 4-operand madd.s/madd.d and related instructions where applicable.
de: Die 4-Operanden-Befehle madd.s/madd.d und ähnliche verwenden, wo möglich.

en: Use 4xx half-word multiply instructions.
de: 4xx-Halbwort-Multiplikationsbefehle verwenden.

en: Use 4xx string-search dlmzb instruction.
de: 4xx-dlmzb-Befehl zur Zeichenkettensuche verwenden.

en: Use 64 FPRs.
de: 64 FPRs verwenden.

en: Use 64 GPRs.
de: 64 GPRs verwenden.

en: Use 64-bit ABI.
de: 64-Bit-ABI verwenden.

en: Use 64-bit DWARF format when emitting DWARF debug information.
de: Wenn DWARF-Debuginformationen erzeugt werden, dann im 64-Bit-Format.

en: Use 64-bit floating-point registers.
de: 64-Bit-Gleitkommaregister verwenden.

en: Use 64-bit general registers.
de: Allgemeine Register in 64 Bit Breite verwenden.

en: Use 64-bit long double.
de: 64-bit long double verwenden.

en: Use 8 media accumulators.
de: 8 Medien-Register verwenden.

en: Use 80-bit long double.
de: 80-bit long double verwenden.

en: Use ABI reserved registers.
de: ABI-reservierte Register verwenden.

en: Use AltiVec instructions.
de: AltiVec-Befehle verwenden.

en: Use Bionic C library.
de: Bionic-C-Bibliothek verwenden.

en: Use Branch Likely instructions, overriding the architecture default.
de: »Branch Likely«-Befehle verwenden, Standard für die Architektur überschreiben.

en: Use C-style integral promotion for unary '+', '-' and '~'.
de: C-ähnliche Ganzzahl-Promotion für unäres »+«, »-« und »~« verwenden.

en: Use CONST16 instruction to load constants.
de: CONST16-Befehle zum Laden von Konstanten verwenden.

en: Use Cyclic Redundancy Check (CRC) instructions.
de: Befehle für Zyklische Redundanzprüfung (CRC) verwenden.

en: Use EABI.
de: EABI verwenden.

en: Use Enhanced Virtual Addressing instructions.
de: Befehle zur Erweiterten Virtuellen Adressierung verwenden.

en: Use Floating-point Multiply Single to Double (FsMULd) instruction.
de: Hardware-Gleitkommabefehle für Multiplikation von einfacher auf doppelte Genauigkeit (FsMULd) verwenden.

en: Use GNU C library.
de: Die GNU-C-Bibliothek verwenden.

en: Use GP relative sdata/sbss sections.
de: Abschnitte sdata/sbss relativ zum GP verwenden.

en: Use GP-relative addressing to access small data.
de: GP-relative Adressierung verwenden, auf um kleine Daten zuzugreifen.

en: Use Global INValidate (GINV) instructions.
de: Befehle für Globales INValidieren (GINV) verwenden.

en: Use H8/300 alignment rules.
de: H8/300-Ausrichtungsregeln verwenden.

en: Use IEEE math for fp comparisons.
de: IEEE-Arithmetik für Gleitkommavergleiche verwenden.

en: Use IRA based register pressure calculation in RTL hoist optimizations.
de: IRA-basierte Registerdruckberechnungen in RTL-Optimierungen zum Anheben verwenden.

en: Use IRA based register pressure calculation in RTL loop optimizations.
de: IRA-basierte Registerdruckberechnungen in RTL-Schleifenoptimierungen verwenden.

en: Use ISA 2.07 Category:Vector.AES and Category:Vector.SHA2 instructions.
de: Befehle aus ISA 2.07 Category:Vector.AES und Category:Vector.SHA2 verwenden.

en: Use ISA 2.07 transactional memory (HTM) instructions.
de: Befehle aus ISA 2.07 für transaktionalen Speicher (HTM) verwenden.

en: Use LRA instead of reload (transitional).
de: LRA statt Neuladen verwenden (übergangsweise).

en: Use LRA instead of reload.
de: LRA statt »reload« verwenden.

en: Use LRA register allocator.
de: LRA-Registerallozierer verwenden.

en: Use Loongson EXTension (EXT) instructions.
de: Loongson-Erweiterungsbefehle (EXT) verwenden.

en: Use Loongson EXTension R2 (EXT2) instructions.
de: Loongson-Erweiterungsbefehle R2 (EXT2) verwenden.

en: Use Loongson MultiMedia extensions Instructions (MMI) instructions.
de: Loongson-MultiMedia-Erweiterungsbefehle (MMI) verwenden.

en: Use MCU instructions.
de: MCU-Befehle verwenden.

en: Use MIPS MSA Extension instructions.
de: Befehle der MIPS-MSA-Erweiterung verwenden.

en: Use MIPS-3D instructions.
de: MIPS-3D-Befehle verwenden.

en: Use MIPS-DSP REV 2 instructions.
de: MIPS-DSP-Befehle REV 2 verwenden.

en: Use MIPS-DSP instructions.
de: MIPS-DSP-Befehle verwenden.

en: Use Mingw-specific thread support.
de: Mingw-spezifische Thread-Unterstützung verwenden.

en: Use Neon double-word (rather than quad-word) registers for vectorization.
de: Neon-Double-Word (statt Quad-Word) Register für Vektorisierung verwenden.

en: Use Neon quad-word (rather than double-word) registers for vectorization.
de: Neon-Quad-Word (statt Double-Word) Register für Vektorisierung verwenden.

en: Use NewABI-style %reloc() assembly operators.
de: %reloc()-Assembleroperatoren im NewABI-Stil verwenden.

en: Use P-mnemonics for branches statically predicted as taken.
de: P-Mnemonics für statisch als verfolgt vorhergesehene Zweige verwenden.

en: Use PLT for PIC calls (-fno-plt: load the address from GOT at call site).
de: PLT für PIC-Aufrufe verwenden (-fno-plt: die Adresse beim Aufrufer aus der GOT laden).

en: Use PMC-style 'mad' instructions.
de: »mad«-Befehle im PMC-Stil verwenden.

en: Use PowerPC General Purpose group optional instructions.
de: Optionale Befehle der PowerPC-Mehrzweck-Gruppe verwenden.

en: Use PowerPC Graphics group optional instructions.
de: Optionale Befehle der PowerPC-Grafik-Gruppe verwenden.

en: Use PowerPC V2.01 single field mfcr instruction.
de: Einzelfeld-mfcr-Befehl des PowerPC V2.01 verwenden.

en: Use PowerPC V2.02 floating point rounding instructions.
de: PowerPC V2.02 Gleitkomma-Rundungsbefehle verwenden.

en: Use PowerPC V2.02 popcntb instruction.
de: PowerPC V2.02 popcntb-Befehl verwenden.

en: Use PowerPC V2.05 compare bytes instruction.
de: PowerPC V2.05 Bytevergleichs-Befehl verwenden.

en: Use PowerPC V2.06 popcntd instruction.
de: PowerPC V2.06 popcntd-Befehl verwenden.

en: Use PowerPC-64 instruction set.
de: PowerPC-64-Befehlssatz verwenden.

en: Use RJMP / RCALL even though CALL / JMP are available.
de: RJMP/RCALL verwenden, selbst wenn CALL/JMP verfügbar sind.

en: Use ROM instead of RAM.
de: ROM statt RAM verwenden.

en: Use SSE register passing conventions for SF and DF mode.
de: SSE-Register-Übergabekonventionen für SF- und DF-Modus verwenden.

en: Use STB_GNU_UNIQUE if supported by the assembler.
de: STB_GNU_UNIQUE verwenden, sofern der Assembler es unterstützt.

en: Use SmartMIPS instructions.
de: SmartMIPS-Befehle verwenden.

en: Use UNIX assembler syntax.
de: UNIX-Assemblersyntax verwenden.

en: Use UltraSPARC Compare-and-Branch extensions.
de: Vergleich-und-Sprung-Erweiterungen für UltraSPARC verwenden.

en: Use UltraSPARC Fused Multiply-Add extensions.
de: Multiplizier-Addier-Erweiterungen für UltraSPARC verwenden.

en: Use UltraSPARC Population-Count instruction.
de: Bitzähl-Befehl für UltraSPARC verwenden.

en: Use UltraSPARC Subtract-Extended-with-Carry instruction.
de: Befehl für erweitertes Subtrahieren mit Übertrag für UltraSPARC verwenden.

en: Use UltraSPARC Visual Instruction Set version 1.0 extensions.
de: Visuelle Befehlssatzerweiterungen Version 1.0 für UltraSPARC verwenden.

en: Use UltraSPARC Visual Instruction Set version 2.0 extensions.
de: Visuelle Befehlssatzerweiterungen Version 2.0 für UltraSPARC verwenden.

en: Use UltraSPARC Visual Instruction Set version 3.0 extensions.
de: Visuelle Befehlssatzerweiterungen Version 3.0 für UltraSPARC verwenden.

en: Use UltraSPARC Visual Instruction Set version 4.0 extensions.
de: Visuelle Befehlssatzerweiterungen Version 4.0 für UltraSPARC verwenden.

en: Use VAX fp.
de: VAX-FP verwenden.

en: Use VAXC structure conventions.
de: VAXC-Strukturkonventionen verwenden.

en: Use VMS exit codes instead of posix ones.
de: Exitcodes von VMS statt POSIX verwenden.

en: Use Virtualization (VZ) instructions.
de: Virtualisierungsbefehle (VZ) verwenden.

en: Use __cxa_atexit to register destructors.
de: __cxa_atexit verwenden, um Destruktoren zu registrieren.

en: Use __cxa_get_exception_ptr in exception handling.
de: __cxa_get_exception_ptr in Ausnahmebehandlung verwenden.

en: Use a 32-bit long type.
de: Einen 32-Bit-»long«-Typ verwenden.

en: Use a 4-byte record marker for unformatted files.
de: Eine 4-Byte-Datensatzmarkierung für unformatierte Dateien verwenden.

en: Use a 64-bit long type.
de: Einen 64-Bit-»long«-Typ verwenden.

en: Use a lightweight configuration of printf and puts to reduce code size. For single-threaded applications, not requiring reentrant I/O only. Requires Newlib Nano IO.
de: Leichtgewichtige Konfiguration für printf und puts verwenden, um die Codegröße zu reduzieren. Nur für Anwendungen mit einem Thread, die keine reentrante E/A brauchen. Erfordert Newlib Nano IO.

en: Use a minimum runtime (no static initializers or ctors) for memory-constrained devices.
de: Minimale Laufzeitumgebung (keine statischen Initialisierer oder Konstruktoren) für speicherarme Geräte verwenden.

en: Use a smart stack protection method for certain functions.
de: Eine schlaue Stapelschutzmethode für gewisse Funktionen verwenden.

en: Use a stack protection method for every function.
de: Eine Stapelschutzmethode für jede Funktion verwenden.

en: Use additional VIS instructions introduced in OSA2017.
de: Zusätzliche VIS-Befehle verwenden, die in OSA2017 hinzugefügt wurden.

en: Use addresses that allocate global registers.
de: Adressen verwenden, die globale Register belegen.

en: Use all registers, reserving none for interrupt handlers.
de: Alle Register verwenden, dadurch keine für Interrupthandler reservieren.

en: Use alternate register names.
de: Alternative Registernamen verwenden.

en: Use an 8-bit 'int' type.
de: 8-Bit-»int«-Typ verwenden.

en: Use an 8-byte record marker for unformatted files.
de: Eine 8-Byte-Datensatzmarkierung für unformatierte Dateien verwenden.

en: Use an immediate to offset from the TLS register. This option is for use with fstack-protector-guard=tls and not for use in user-land code.
de: Einen Direktwert als Offset vom TLS-Register verwenden. Diese Option ist für fstack-protector-guard=tls gedacht und nicht für die Verwendung in Benutzer-Code.

en: Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code.
de: Einen konstanten Wert als Offset vom Stapelschutz-Wächterregister verwenden, sp_el0. Diese Option ist für fstack-protector-strong gedacht und nicht für die Verwendung in Benutzer-Code.

en: Use arbitrary sized immediates in bit operations.
de: Direktwerte beliebiger Größen in Bit-Operationen zulassen.

en: Use big-endian byte order.
de: Big-Endian Byte-Reihenfolge verwenden.

en: Use bit tests for sufficiently large switch statements.
de: Bittests für hinreichend große switch-Anweisungen verwenden.

en: Use branch-and-break sequences to check for integer divide by zero.
de: Sprung-und-Abbruch-Sequenzen verwenden, um auf Ganzzahldivision durch Null zu prüfen.

en: Use branch-protection features.
de: Verzweigungsschutz-Features verwenden.

en: Use bras for executable < 64k.
de: Für ausführbare Datei < 64k bras verwenden.

en: Use call-clobbered registers for parameters and return value.
de: Mit Aufruf verbundene Register für Parameter und Rückgabewerte verwenden.

en: Use call0 ABI.
de: call0-ABI verwenden.

en: Use callbacks instead of inline code if number of accesses in function becomes greater or equal to this number.
de: Rückruffunktionen statt inline-Code generieren, wenn innerhalb der Funktion mindestens diese Anzahl an Zugriffen stattfindet.

en: Use caller save register across calls if possible.
de: Vom Aufrufer zu sichernde Register über Aufrufe hinweg verwenden, wenn möglich.

en: Use certain scalar instructions added in ISA 3.0.
de: Bestimmte skalare Befehle verwenden, die in ISA 3.0 hinzugefügt wurden.

en: Use control speculation.
de: Steuerungsspekulation verwenden.

en: Use custom stacks instead of local memory for automatic storage.
de: Eigene Stacks statt lokalem Speicher für automatischen Speicher verwenden.

en: Use data speculation after reload.
de: Datenspekulation nach Neuladen verwenden.

en: Use data speculation before reload.
de: Datenspekulation vor Neuladen verwenden.

en: Use decimal floating point instructions.
de: Dezimale Gleitkommabefehle verwenden.

en: Use default method for sdata handling.
de: Standardmethode für sdata-Behandlung verwenden.

en: Use different calling convention using 'rtd'.
de: Andere Aufrufkonvention mit 'RTD' verwenden.

en: Use direct poisoning/unpoisoning instructions for variables smaller or equal to this number.
de: Direkt vergiftende/entgiftende Befehle für Variablen verwenden, die maximal die angegebene Größe haben.

en: Use direct references against %gs when accessing tls data.
de: Direkte Referenzen gegen %gs beim Zugriff auf TLS-Daten verwenden.

en: Use eXtended Physical Address (XPA) instructions.
de: Befehle für Erweiterte Physikalische Adresse (XPA) verwenden.

en: Use epsilon-respecting floating point compare instructions.
de: Epsilon beachtende Gleitkomma-Vergleichsbefehle verwenden.

en: Use expression value profiles in optimizations.
de: Profile von Ausdruckswerten in Optimierungen verwenden.

en: Use f2c calling convention.
de: Die f2c-Aufrufkonvention verwenden.

en: Use features of and optimize for CPU.
de: Eigenschaften der angegebenen CPU verwenden und dafür optimieren.

en: Use features of and schedule code for given CPU.
de: Eigenschaften der gegebenen CPU verwenden und entsprechend Code planen.

en: Use features of and schedule given CPU.
de: Für angegebene CPU planen und deren Eigenschaften verwenden.

en: Use features of architecture ARCH.
de: Eigenschaften der Architektur ARCH verwenden.

en: Use field-wise comparisons for struct equality.
de: Feldweisen Vergleich für Strukturgleichheit verwenden.

en: Use flat register window model.
de: Flaches Registerfenster-Modell verwenden.

en: Use fp double instructions.
de: Gleitkomma-double-Befehle verwenden.

en: Use fp registers.
de: FP-Register verwenden.

en: Use full-set registers for register allocation.
de: Vollständigen Registersatz für die Allozierung verwenden.

en: Use given SPARC-V9 code model.
de: Gegebenes SPARC-V9-Codemodell verwenden.

en: Use given TILE-Gx code model.
de: Gegebenes Codemodell TILE-Gx verwenden.

en: Use given address mode.
de: Angegebenen Adressierungsmodus verwenden.

en: Use given assembler dialect.
de: Angegebenen Assemblerdialekt verwenden.

en: Use given register vector width instructions instead of maximum register width in the auto-vectorizer.
de: Im Autovektorisierer die angegebene Breite für Vektorbefehle anstelle der maximalen Registerbreite verwenden.

en: Use given stack-protector guard.
de: Angegebenen Stapelschutz-Wächter verwenden.

en: Use given thread-local storage dialect.
de: Gegebenen Thread-lokalen Speicherdialekt verwenden.

en: Use given x86-64 code model.
de: Gegebenes x86-64-Codemodell verwenden.

en: Use hardware FP (default).
de: Hardware-Gleitkommabefehle verwenden (Standard).

en: Use hardware FP.
de: Hardware-Gleitkommabefehle verwenden.

en: Use hardware division instructions on ColdFire.
de: Hardware-Divisionsbefehle auf ColdFire verwenden.

en: Use hardware floating point conversion instructions.
de: Hardware-Gleitkommakonvertierungsbefehle verwenden.

en: Use hardware floating point instructions.
de: Hardware-Gleitkommabefehle verwenden.

en: Use hardware floating point square root instruction.
de: Hardware-Gleitkomma-Wurzel-Befehl verwenden.

en: Use hardware floating point.
de: Hardware-Gleitkommabefehle verwenden.

en: Use hardware floating-point divide and square root instructions.
de: Hardware-Gleitkommabefehle für Division und Quadratwurzel verwenden.

en: Use hardware fp.
de: Hardware-Gleitkommabefehle verwenden.

en: Use hardware instructions for integer division.
de: Hardwarebefehle für Ganzzahldivision verwenden.

en: Use hardware prefetch instruction.
de: Hardware-»prefetch«-Befehle verwenden.

en: Use hardware quad FP instructions.
de: Hardware-Vierfach-Gleitkommabefehle verwenden.

en: Use hardware transactional execution instructions.
de: Hardware-Transaktionsausführungs-Befehle verwenden.

en: Use hardware vector facility instructions and enable the vector ABI.
de: Hardware-Vektorbefehle verwenden und die Vektor-ABI einschalten.

en: Use in block control speculation.
de: Blockweise Steuerungsspekulation verwenden.

en: Use in block data speculation after reload.
de: Blockweise Datenspekulation nach Neuladen verwenden.

en: Use in block data speculation before reload.
de: Blockweise Datenspekulation vor Neuladen verwenden.

en: Use in/loc/out register names.
de: Registernamen der Form in/loc/out ausgeben.

en: Use indirect CALLXn instructions for large programs.
de: Indirekte CALLXn-Befehle für große Programme verwenden.

en: Use indirect calls.
de: Indirekte Aufrufe verwenden.

en: Use inline plt sequences to implement long calls and -fno-plt.
de: Inline-PLT-Sequenzen verwenden, um lange Aufrufe und -fno-plt zu implementieren.

en: Use instructions of and schedule code for given CPU.
de: Befehlssatz der angegebenen CPU verwenden und entsprechend Code planen.

en: Use integer madd/msub instructions.
de: Befehle zum Multiplizieren-Addieren/Subtrahieren verwenden.

en: Use internal function id in profile lookup.
de: Interne Funktions-ID bei Profilnachschlagen verwenden.

en: Use jump tables for sufficiently large switch statements.
de: Sprungtabellen für hinreichend große switch-Anweisungen verwenden.

en: Use ldcw/ldcd coherent cache-control hint.
de: Kohärente Cachesteuerungs-Hinweise für ldcw/ldcd verwenden.

en: Use libgcc stubs to save and restore registers clobbered by 64-bit Microsoft to System V ABI calls.
de: Stubs aus libgcc zum Speichern und Wiederherstellen von Registern verwenden, die beim Übergang von der 64-Bit-Microsoft- zur System-V-ABI überschrieben werden.

en: Use little-endian byte order.
de: Little-Endian Byte-Reihenfolge verwenden.

en: Use ll, sc and sync instructions.
de: Befehle ll, sc und sync verwenden.

en: Use lwxc1/swxc1/ldxc1/sdxc1 instructions where applicable.
de: Die Befehle lwxc1/swxc1/ldxc1/sdxc1 verwenden, wo möglich.

en: Use media instructions.
de: Media-Befehle verwenden.

en: Use microMIPS instructions.
de: microMIPS-Befehle verwenden.

en: Use multiply add/subtract instructions.
de: Befehle zum Multiplizieren-Addieren/Subtrahieren verwenden.

en: Use multiply high instructions for high part of 32x32 multiply.
de: Verwendet »multiply high«-Befehle für den oberen Teil einer 32×32-Multiplikation.

en: Use musl C library.
de: Die musl-C-Bibliothek verwenden.

en: Use native (MS) bitfield layout.
de: Native MS-Bitfeld-Anordnung verwenden.

en: Use new adddi3/subdi3 patterns.
de: Neue adddi3/subdi3-Muster verwenden.

en: Use normal calling convention.
de: Normale Aufrufkonvention verwenden.

en: Use of intrinsic module %qs at %C conflicts with non-intrinsic module name used previously
de: Verwendung des intrinsischen Moduls %qs bei %C steht mit nicht-intrinsischem vorher verwendeten Modulnamen in Konflikt

en: Use of non-intrinsic module %qs at %C conflicts with intrinsic module name used previously
de: Verwendung des nicht-intrinsischen Moduls %qs bei %C steht mit vorher verwendetem intrinsischen Modulnamen in Konflikt

en: Use of the NUMERIC_STORAGE_SIZE named constant from intrinsic module ISO_FORTRAN_ENV at %C is incompatible with option %s
de: Verwendung der Konstante NUMERIC_STORAGE_SIZE aus intrinsischem Modul ISO_FORTRAN_ENV bei %C ist mit Option %s unverträglich

en: Use of the NUMERIC_STORAGE_SIZE named constant from intrinsic module ISO_FORTRAN_ENV at %L is incompatible with option %qs
de: Verwendung der Konstante NUMERIC_STORAGE_SIZE aus intrinsischem Modul ISO_FORTRAN_ENV bei %L ist mit Option %qs unverträglich

en: Use only one TOC entry per procedure.
de: Nur einen TOC-Eintrag pro Prozedur verwenden.

en: Use ordinarily cached memory accesses for volatile references.
de: Gewöhnlich gecachete Speicherzugriffe für flüchtige Referenzen verwenden.

en: Use packed stack layout.
de: Gepacktes Stapellayout verwenden.

en: Use paired-single floating-point instructions.
de: Paarweise-single Gleitkommabefehle verwenden.

en: Use pattern compare instructions.
de: Mustervergleichsbefehle verwenden.

en: Use pc-relative switch case tables - this enables case table shortening.
de: PC-relative switch-Tabellen verwenden – dies erlaubt kürzere Fallunterscheidungs-Tabellen.

en: Use portable calling conventions.
de: Portierbare Aufrufkonventionen verwenden.

en: Use profiling information for branch probabilities.
de: Profilierungsinformationen für Verzweigungswahrscheinlichkeiten verwenden.

en: Use propolice as a stack protection method.
de: Propolice als Stapelschutzmethode verwenden.

en: Use push instructions to save outgoing arguments.
de: Push-Befehle verwenden, um ausgehende Argumente zu sichern.

en: Use r11 to hold the static link in calls to functions via pointers.
de: Register r11 verwenden, um die statische Bindung in Funktionsaufrufen über Zeiger zu speichern.

en: Use random base tag for each frame, as opposed to base always zero.
de: Zufällige Basisadresse für jeden Rahmen wählen, statt immer 0 zu verwenden.

en: Use red-zone in the x86-64 code.
de: Rote Zone in x86-64-Code verwenden.

en: Use reduced-set registers for register allocation.
de: Eingeschränkten Registersatz für die Allozierung verwenden.

en: Use register stack for parameters and return value.
de: Registerstapel für Parameter und Rückgabewerte verwenden.

en: Use registers for argument passing.
de: Register zur Argumentübergabe verwenden.

en: Use registers r2 and r5.
de: Register r2 und r5 verwenden.

en: Use reorder instructions (swap and byte reversed load/store) (default).
de: Umverteilungsbefehle verwenden (Austausch und umgekehrte Bytereihenfolge beim Laden/Speichern; Voreinstellung).

en: Use sample profile information for call graph node weights. The default profile file is fbdata.afdo in 'pwd'.
de: Profilierungsinformationen für Aufrufgraph-Knotengewichtungen verwenden. Vorgabe ist die Datei fbdata.afdo im aktuellen Arbeitsverzeichnis.

en: Use sample profile information for call graph node weights. The profile file is specified in the argument.
de: Profilierungsinformationen für Aufrufgraph-Knotengewichtungen verwenden. Die Profilierungsdatei ist im Argument angegeben.

en: Use shared libraries.
de: Shared Libraries verwenden.

en: Use simple data speculation check for control speculation.
de: Einfachen Datenspekulationstest für Steuerungsspekulation verwenden.

en: Use simple data speculation check.
de: Einfachen Datenspekulationstest verwenden.

en: Use simulator runtime.
de: Simulator-Laufzeitumgebung verwenden.

en: Use smaller but slower prologue and epilogue code.
de: Kleineren, aber langsameren Code für Funktionsprologe und -epiloge verwenden.

en: Use software emulation for floating point (default).
de: Software-Gleitkomma-Emulation verwenden (Standard).

en: Use software floating point comparisons.
de: Software-Gleitkommavergleiche verwenden.

en: Use software floating point.
de: Software-Gleitkomma verwenden.

en: Use software integer multiplication.
de: Software-Ganzzahlmultiplikation verwenden.

en: Use stack bias.
de: Stapelversatz verwenden.

en: Use stack protection method only for functions with the stack_protect attribute.
de: Stapelschutzmethode nur für Funktionen mit dem Attribut »stack_protect« verwenden.

en: Use structs on stronger alignment for double-word copies.
de: Structs an stärkeren Grenzen ausrichten, um Daten doppelwortweise zu kopieren.

en: Use stubs for function prologues.
de: Stubs für Funktionsprologe verwenden.

en: Use subroutines for function prologues and epilogues.
de: Für Funktionsprologe und -epiloge Unterprogramme verwenden.

en: Use synci instruction to invalidate i-cache.
de: synci-Befehl verwenden, um i-Cache ungültig zu machen.

en: Use table based fast divide (default at -O3).
de: Tabellenbasierte schnelle Division verwenden (Standard bei -O3).

en: Use table lookup optimization for small signed integer divisions.
de: Tabellenbasierte Optimierung für die Division kleiner vorzeichenbehafteter Ganzzahlen verwenden.

en: Use tas.b instruction for __atomic_test_and_set.
de: Befehl tas.b für __atomic_test_and_set verwenden.

en: Use the AIX Vector Extended ABI.
de: Die AIX-Vector-Extended-ABI verwenden.

en: Use the AltiVec ABI extensions.
de: Die AltiVec-ABI-Erweiterungen verwenden.

en: Use the Cray Pointer extension.
de: Die Cray-Zeiger-Erweiterung verwenden.

en: Use the DEC assembler syntax.
de: DEC-Assemblersyntax verwenden.

en: Use the ELFv1 ABI.
de: ELFv1-ABI verwenden.

en: Use the ELFv2 ABI.
de: ELFv2-ABI verwenden.

en: Use the GNU assembler syntax.
de: GNU-Assemblersyntax verwenden.

en: Use the GNU extension to the PE format for aligned common data.
de: GNU-Erweiterung für PE-Format für ausgerichtete gemeinsame Daten verwenden.

en: Use the Modern linker (MOLD) linker instead of the default linker.
de: Den Modernen Linker (MOLD) statt des Standardlinkers verwenden.

en: Use the RTL dead code elimination pass.
de: Den RTL-Durchlauf zur Entfernung toten Codes verwenden.

en: Use the RTL dead store elimination pass.
de: Den RTL-Durchlauf zur Entfernung toter Speicherungen verwenden.

en: Use the bfd linker instead of the default linker.
de: BFD-Linker statt Standardlinker verwenden.

en: Use the bit-field instructions.
de: Bit-Feld-Befehle verwenden.

en: Use the divide instruction.
de: Divisionsbefehl verwenden.

en: Use the floating point unit for integer add/subtract.
de: Gleitkommaeinheit für Ganzzahladdition und -subtraktion verwenden.

en: Use the given base register for addressing the stack-protector guard.
de: Angegebenes Basisregister zur Adressierung des Stapelschutz-Wächters verwenden.

en: Use the given data alignment.
de: Die angegebene Datenausrichtung verwenden.

en: Use the given offset for addressing the stack-protector guard.
de: Angegebenen Offset zur Addressierung des Stapelschutz-Wächters verwenden.

en: Use the given symbol for addressing the stack-protector guard.
de: Angegebenes Symbol für Adressierung des Stapelschutz-Wächters verwenden.

en: Use the gold linker instead of the default linker.
de: Gold-Linker statt Standardlinker verwenden.

en: Use the hardware barrel shifter instead of emulation.
de: Hardware-Barrel-Shifter statt der Emulation verwenden.

en: Use the lld LLVM linker instead of the default linker.
de: Den LLVM-lld-Linker statt des Standardlinkers verwenden.

en: Use the most feature-enabling options allowed by other options.
de: Die meisten Optionen verwenden, die spezielle Fähigkeiten einschalten, solange sie durch andere Optionen erlaubt sind.

en: Use the mvcle instruction for block moves.
de: Für Blockkopieroperationen den Befehl mvcle verwenden.

en: Use the narrowest integer type possible for enumeration types.
de: Den schmalstmöglichen Ganzzahltyp für Aufzählungstypen verwenden.

en: Use the new min/max instructions defined in ISA 3.0.
de: Min-/Max-Befehle verwenden, die in ISA 3.0 hinzugefügt wurden.

en: Use the simulator runtime.
de: Simulator-Laufzeitumgebung verwenden.

en: Use the soft multiply emulation (default).
de: Verwendet die Software-Multiplikationsemulation (Vorgabe).

en: Use the software emulation for divides (default).
de: Softwareemulation für Divisionen verwenden (Vorgabe).

en: Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code.
de: Das in der Kommandozeile angegebene Systemregister als Stapelschutz-Wächterregister verwenden. Diese Option ist für fstack-protector-strong gedacht und nicht für die Verwendung in Benutzer-Code.

en: Use traditional GNU semantics for inline functions.
de: Traditionelle GNU-Semantik für Inline-Funktionen verwenden.

en: Use trap instead of a library function for undefined behavior sanitization.
de: Für das Bereinigen von undefiniertem Verhalten eine Trap statt einer Bibliotheksfunktion verwenden.

en: Use trap instructions to check for integer divide by zero.
de: Trap-Befehle verwenden, um auf Ganzzahldivision durch Null zu prüfen.

en: Use uClibc C library.
de: Die uClibc-C-Bibliothek verwenden.

en: Use unicode startup and define UNICODE macro.
de: Unicode-Start verwenden und UNICODE-Makro definieren.

en: Use vector and scalar instructions added in ISA 2.07.
de: Vektor-/skalare (VSX) Befehle verwenden, die in ISA 2.07 hinzugefügt wurden.

en: Use vector instructions added in ISA 3.0.
de: Vektor-Befehle verwenden, die in ISA 3.0 hinzugefügt wurden.

en: Use vector/scalar (VSX) instructions.
de: Vektor-/skalare (VSX) Befehle verwenden.

en: Use windowed registers ABI.
de: ABI mit Fenster-Registern verwenden.

en: Use zero-extending memory loads, not sign-extending ones.
de: Nullerweiternde Speicherladungen verwenden, nicht vorzeichenerweiternde.

en: Used for generating code for some older kernel revisions.
de: Wird zur Generierung von Code für einige ältere Kernel-Revisionen verwendet.

en: Used in Fix-and-Continue mode to indicate that object files may be swapped in at runtime.
de: Im Fix-and-Continue-Modus verwendet, um anzuzeigen, dass Objektdateien zur Laufzeit eingetauscht werden können (»swap«).

en: User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct
de: Benutzerdefinierte nicht-ELEMENTAL-Funktion %qs bei %L ist in WORKSHARE-Konstrukt nicht erlaubt

en: User operator %qs referenced at %L not found in module %qs
de: Bei %2$L referenzierter Benutzeroperator %1$qs nicht im Modul %3$qs gefunden

en: User operator procedure %qs at %L cannot be assumed character length
de: Prozedur für Benutzeroperator %qs bei %L kann nicht vermutete Zeichenlänge haben

en: User operator procedure %qs at %L must be a FUNCTION
de: Prozedur für Benutzeroperator %qs bei %L muss eine FUNCTION sein

en: User operator procedure %qs at %L must have at least one argument
de: Prozedur für Benutzeroperator %qs bei %L muss mindestens ein Argument haben

en: Uses of this option are diagnosed.
de: Die Verwendung dieser Option wird diagnostiziert.

en: Using IBM extended precision %<long double%>
de: IBM %<long double%> mit erweiterter Genauigkeit wird verwendet

en: Using IEEE extended precision %<long double%>
de: IEEE %<long double%> mit erweiterter Genauigkeit wird verwendet

en: Using built-in specs.
de: Es werden eingebaute Spezifikationen verwendet.

en: Using function %qs at %L is deprecated
de: Verwendung der Funktion %qs bei %L ist veraltet

en: Using parameter %qs declared at %L is deprecated
de: Verwendung von Parameter %qs, der bei %L deklariert wurde, ist veraltet

en: Using subroutine %qs at %L is deprecated
de: Verwenden der Subroutine %qs bei %L ist veraltet

en: Using variable %qs at %L is deprecated
de: Verwendung der Variable %qs bei %L ist veraltet

en: Usually "private extern" (hidden) symbols are made local when linking, this command suppresses that such that they remain exported.
de: Normalerweise werden Symbole, die »private extern« (versteckt) sind, beim Linken lokal gemacht. Dieser Befehl unterdrückt das, so dass sie exportiert bleiben.

en: VALUE argument of the %s intrinsic function at %L shall be definable
de: VALUE-Argument der intrinsischen Funktion »%s« bei %L muss definierbar sein

en: VALUE attribute at %C
de: VALUE-Attribut bei %C

en: VALUE is not allowed inside of BLOCK at %C
de: VALUE ist in BLOCK bei %C nicht erlaubt

en: VALUE object %qs in %s clause at %L
de: VALUE-Objekt %qs in Klausel %s bei %L

en: VALUE statement at %C
de: VALUE-Anweisung bei %C

en: VOIDmode on an output
de: VOIDmode bei einer Ausgabe

en: VOLATILE attribute at %C
de: VOLATILE-Attribut bei %C

en: VOLATILE attribute at %L cannot be specified in a PURE procedure
de: VOLATILE-Attribut bei %L darf nicht in einer PURE-Prozedur angegeben werden

en: VOLATILE statement at %C
de: VOLATILE-Anweisung bei %C

en: Valid Nios II ISA levels (for -march):
de: Gültige Stufen für Nios-II-ISA (für -march):

en: Valid arguments for the -msdata= option:
de: Gültige Argumente für die Option -msdata=:

en: Valid arguments to -malign-:
de: Gültige Argumente für -malign-:

en: Valid arguments to -mcode-readable=:
de: Gültige Argumente für -mcode-readable=:

en: Valid arguments to -mfpmath=:
de: Gültige Argumente für -mfpmath=:

en: Valid arguments to -mr10k-cache-barrier=:
de: Gültige Argumente für -mr10k-cache-barrier=:

en: Valid arguments to -mstack-protector-guard=:
de: Gültige Argumente für -mstack-protector-guart=:

en: Valid arguments to -mstringop-strategy=:
de: Gültige Arguments für -mstringop-strategy=:

en: Valid arguments to -mtp=:
de: Gültige Argumente für -mtp=:

en: Valid options for GP-relative addressing (for -mgpopt):
de: Gültige Optionen für GP-relative Adressierung (für -mgpopt):

en: Validate vtable pointers before using them.
de: VTable-Zeiger validieren, bevor sie verwendet werden.

en: Value of HINT clause at %L shall be a valid constant hint expression
de: Der Wert der HINT-Klausel bei %L muss ein gültiger konstanter Hinweisausdruck sein

en: Variable %qs at %C cannot be redefined inside loop beginning at %L
de: Variable %qs bei %C kann nicht innerhalb der bei %L beginnenden Schleife redefiniert werden

en: Variable %qs at %C with an initializer already appears in a DATA statement
de: Variable %qs bei %C mit Initialisierung tritt bereits in einer DATA-Anweisung auf

en: Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope
de: Variable %qs bei %L kann nicht BIND(C) sein, weil es weder ein COMMON-Block noch mit Sichtbarkeit auf Modulebene deklariert ist

en: Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes
de: Variable %qs bei %L kann nicht gleichzeitig die Attribute ALLOCATABLE und BIND(C) haben

en: Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)
de: Variable %qs bei %L kann nicht gleichzeitig die Attribute OPTIONAL und VALUE haben, da Prozedur %qs BIND(C) ist

en: Variable %qs at %L cannot have both the POINTER and BIND(C) attributes
de: Variable %qs bei %L kann nicht gleichzeitig die Attribute POINTER und BIND(C) haben

en: Variable %qs at %L has not been assigned a format label
de: Variable %qs bei %L wurde keine Formatmarke zugewiesen

en: Variable %qs at %L in common block %qs at %C must be declared with a C interoperable kind since common block %qs is bind(c)
de: Variable %qs bei %L in Common-Block %qs bei %C muss in einer C-kompatiblen Art deklariert sein, da Common-Block %qs bind(c) ist

en: Variable %qs at %L in this context must be constant
de: Variable %qs bei %L muss in diesem Kontext eine Konstante sein

en: Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components
de: Variable %qs bei %L ist INTENT(OUT) und kann daher kein reservierbares Coarray sein oder Coarray-Komponenten haben

en: Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument
de: Variable %qs bei %L ist ein Koarray und ist weder ALLOCATABLE, SAVE, noch ein Scheinargument

en: Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable
de: Variable %qs bei %L ist ein Scheinargument für die BIND(C)-Prozedur %qs, könnte jedoch unverträglich mit C sein

en: Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable
de: Variable %qs bei %L ist ein Scheinargument für die BIND(C)-Prozedur %qs, jedoch nicht interoperabel mit C, da der abgeleitete Typ %qs nicht mit C interoperabel ist

en: Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic
de: Variable %qs bei %L ist ein Scheinargument für die BIND(C)-Prozedur %qs, jedoch nicht interoperabel mit C, da sie polymorph ist

en: Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed
de: Variable %qs bei %L ist in COMMON, aber Initialisierung ist nur in BLOCK DATA erlaubt

en: Variable %qs at %L may not be a C interoperable kind but it is BIND(C)
de: Variable %qs bei %L könnte mit C inkompatibel sein, aber sie ist BIND(C)

en: Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs
de: Variable %qs bei %L kann nicht innerhalb der bei %L beginnenden Schleife als INTENT(INOUT)-Argument für Funktion %qs definiert werden

en: Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs
de: Variable %qs bei %L kann nicht innerhalb der bei %L beginnenden Schleife als INTENT(INOUT)-Argument für Unterprogramm %qs definiert werden

en: Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray
de: Variable %qs bei %L mit TYPE(C_PTR) oder TYPE(C_FUNPTR) darf kein Koarray sein

en: Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs
de: Variable %qs bei %L auf undefinierten Wert innerhalb der bei %L beginnenden Schleife gesetzt, als INTENT(OUT)-Argument für Funktion %qs

en: Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to subroutine %qs
de: Variable %qs bei %L wird auf undefinierten Wert gesetzt, innerhalb der bei %L beginnenden Schleife, als INTENT(OUT)-Argument für Unterroutine %qs

en: Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)
de: Variable %qs bei %L mit OPTIONAL-Attribut in Prozedur %qs, die BIND(C) ist

en: Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)
de: Variable %qs bei %L mit OPTIONAL-Attribut in Prozedur %qs, die jedoch BIND(C) ist

en: Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)
de: Variable %qs bei %L mit OPTIONAL-Attribut in Prozedur %qs, die BIND(C) ist

en: Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray
de: Variable %qs bei %L mit Koarraykomponente muss ein Nichtzeiger, nichtallozierbares Skalar und damit kein Koarray sein

en: Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure
de: Variable %qs kann nicht in Variablen-Definitionskontext (%s) bei %L in PURE-Prozedur auftreten

en: Variable %qs cannot appear in the expression at %L
de: Variable %qs kann nicht im Ausdruck bei %L auftreten

en: Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs
de: Variable %qs aus Modul %qs mit Bindungsmarke %qs bei %L verwendet denselben globalen Bezeichner wie Entität bei %L aus Modul %qs

en: Variable %qs has not been assigned a target label at %L
de: Variable %qs bei %L wurde keine Zielmarke zugewiesen

en: Variable %qs in %s clause is used in NAMELIST statement at %L
de: Variable %qs in %s-Klausel wird in NAMELIST-Anweisung bei %L verwendet

en: Variable %qs in common block %qs at %C cannot be bind(c) since it is not global
de: Variable %qs in Common-Block %qs bei %C kann nicht BIND(C) sein, da sie nicht global ist

en: Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)
de: Variable %qs in gemeinsamem Block %qs bei %C muss mit einer mit C interoperablen Art deklariert sein, da der gemeinsame Block %qs BIND(C) ist

en: Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global
de: Variable %qs in gemeinsamem Block %qs bei %L kann nicht mit BIND(C) deklariert werden, da sie nicht global ist

en: Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)
de: Variable %qs in gemeinsamem Block %qs bei %L könnte inkompatibel mit C sein, obwohl gemeinsamer Block %qs BIND(C) ist

en: Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L
de: Variable %qs ist PROTECTED und kann nicht in einem Zeigerzuordnungskontext (%s) bei %L vorkommen

en: Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L
de: Variable %qs ist PROTECTED und kann nicht in Variablen-Definitionskontext (%s) bei %L auftreten

en: Variable %qs is not a dummy argument at %L
de: Variable %qs bei %L ist kein Dummyargument

en: Variable %qs is used at %L before the ENTRY statement in which it is a parameter
de: Variable %qs wird bei %L vor Anweisung ENTRY verwendet, in der sie ein Parameter ist

en: Variable %qs shall be declared in the same scoping unit as !$ACC DECLARE at %L
de: Variable %qs muss in derselben Gültigkeitsbereichseinheit wie »!$ACC DECLARE« bei %L sein

en: Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L
de: Variable %1$qs bei %3$L mit Binde-Marke %2$qs verwenden denselben globalen Bezeichner wie die Entität bei %4$L

en: Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter
de: In Spezifikationsausdruck verwendete Variable %qs wird bei %L vor Anweisung ENTRY referenziert, in der sie ein Parameter ist

en: Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray
de: Variable %s bei %L des Typs EVENT_TYPE oder mit Subkomponente des Typs EVENT_TYPE muss ein Koarray sein

en: Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray
de: Variable %s bei %L mit LOCK_TYPE oder mit Subkomponente mit LOCK_TYPE muss ein Koarray sein

en: Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute
de: Variable %s bei %L mit NO_ARG_CHECK-Attribut darf nicht die Attribute ALLOCATABLE, CODIMENSION, POINTER oder VALUE haben

en: Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute
de: Variable %s bei %L mit NO_ARG_CHECK-Attribut darf nicht das Attribut INTENT(OUT) haben

en: Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument
de: Variable %s bei %L mit NO_ARG_CHECK-Attribut kann nur als effektives Argument verwendet werden

en: Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument
de: Variable %s bei %L mit NO_ARG_CHECK-Attribut muss ein Scheinargument sein

en: Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type
de: Variable %s bei %L mit NO_ARG_CHECK-Attribut muss vom Typ TYPE(*) oder von einem numerischen intrinsischen Typ sein

en: Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array
de: Variable %s bei %L mit NO_ARG_CHECK-Attribut muss entweder skalar sein oder ein Feld vermuteter Größe

en: Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference
de: Variable %s bei %L mit NO_ARG_CHECK-Attribut darf keine Referenz auf Subobjekt haben

en: Variable %s cannot be INTENT(IN) at %C
de: Variable %s kann nicht INTENT(IN) bei %C sein

en: Variable %s cannot be assigned in PURE procedure at %C
de: Variable %s kann nicht in PURE-Prozedur bei %C zugewiesen werden

en: Variable at %C is an element of a COMMON block
de: Variable bei %C ist ein Element eines COMMON-Blocks

en: Variable at %L mentioned multiple times in clauses of the same OMP DECLARE TARGET directive
de: Variable bei %L wird mehrfach in Klauseln derselben OMP-DECLARE-TARGET-Direktive erwähnt

en: Variable is USE-associated with !$ACC DECLARE at %L
de: Variable ist USE-verknüpft mit »!$ACC DECLARE« bei %L

en: Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L
de: Variable außer OMP_OUT oder OMP_IN wird bei %L in Kombinierer von !$OMP DECLARE REDUCTION verwendet

en: Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L
de: Variable außer OMP_PRIV oder OMP_ORIG wird bei %L in INITIALIZER-Klausel von !$OMP DECLARE REDUCTION verwendet

en: Variable type is UNKNOWN in assignment at %L
de: Unbekannter Variablentyp in Zuweisung bei %L

en: Variable with NO_ARG_CHECK attribute at %L is only permitted as argument to the intrinsic functions C_LOC and PRESENT
de: Variable mit Attribut NO_ARG_CHECK bei %L ist nur als Argument der intrinsischen Funktionen C_LOC und PRESENT erlaubt

en: Vector library ABI to use.
de: Zu verwendendes Vektorbibliotheks-ABI.

en: Vectorize for double-word operations.
de: Für Doppelwort-Operationen vektorisieren.

en: Verify that paths are feasible when emitting diagnostics.
de: Sicherstellen, dass die Codepfade für die ausgegebenen Meldungen machbar sind.

en: Version loops based on whether indices have a stride of one.
de: Schleifen versionieren, je nachdem, ob sie eine Schrittweite von eins haben.

en: Virtual function multiversioning not supported
de: Multiversionierung virtueller Funktionen wird nicht unterstützt

en: Volatile memory accesses do not use I/O load/store instructions.
de: Zugriffe auf flüchtigen Speicher nutzen I/O-load/store-Befehle nicht.

en: Volatile memory accesses use I/O load/store instructions.
de: Zugriffe auf flüchtigen Speicher nutzen I/O-load/store-Befehle.

en: WAIT at %C not allowed in Fortran 95
de: WAIT bei %C ist in Fortran 95 nicht erlaubt

en: WAIT clause at %L requires a scalar INTEGER expression
de: WAIT-Klausel bei %L erfordert einen skalaren INTEGER-Ausdruck

en: WAIT statement not allowed in PURE procedure at %C
de: WAIT-Anweisung ist in PURE-Prozedur bei %C nicht erlaubt

en: WHERE assignment target at %L has inconsistent shape
de: WHERE-Zuweisungsziel bei %L hat ungültige Form

en: WHERE mask at %L has inconsistent shape
de: WHERE-Maske bei %L hat ungültige Form

en: WHERE/ELSEWHERE clause at %L requires a LOGICAL array
de: Klausel WHERE/ELSEWHERE bei %L erfordert ein LOGICAL-Feld

en: Warn about "extern" declarations not at file scope.
de: Bei »extern«-Deklarationen außerhalb des Dateisichtbarkeitsbereiches warnen.

en: Warn about "suspicious" constructs.
de: Bei »verdächtigen« Konstrukten warnen.

en: Warn about 'new' of type with extended alignment without -faligned-new.
de: Warnen, wenn »new« für Typen mit großer Ausrichtung aufgerufen wird, ohne dass »-faligned-new« angegeben ist.

en: Warn about @selector()s without previously declared methods.
de: Bei @selector() ohne vorher deklarierte Methoden warnen.

en: Warn about C constructs that are not in the common subset of C and C++.
de: Bei C-Konstrukten, die nicht in gemeinsamer Teilmenge von C und C++ sind, warnen.

en: Warn about C++ constructs whose meaning differs between ISO C++ 1998 and ISO C++ 2011.
de: Bei C++-Konstrukten, deren Bedeutung sich zwischen ISO C++ 1998 und ISO C++ 2011 unterscheidet, warnen.

en: Warn about C++ constructs whose meaning differs between ISO C++ 2011 and ISO C++ 2014.
de: Bei C++-Konstrukten, deren Bedeutung sich zwischen ISO C++ 2011 und ISO C++ 2014 unterscheidet, warnen.

en: Warn about C++ constructs whose meaning differs between ISO C++ 2014 and ISO C++ 2017.
de: Bei C++-Konstrukten, deren Bedeutung sich zwischen ISO C++ 2014 und ISO C++ 2017 unterscheidet, warnen.

en: Warn about C++ constructs whose meaning differs between ISO C++ 2017 and ISO C++ 2020.
de: Bei C++-Konstrukten warnen, deren Bedeutung sich zwischen ISO C++ 2017 und ISO C++ 2020 unterscheidet.

en: Warn about C++ polymorphic types where adding final keyword would improve code quality.
de: Bei polymorphen Typen in C++ warnen, bei denen das Schlüsselwort »final« die Codequalität verbessern würde.

en: Warn about C++ virtual methods where adding final keyword would improve code quality.
de: Bei virtuellen Methoden in C++ warnen, bei denen das Schlüsselwort »final« die Codequalität verbessern würde.

en: Warn about C++11 constructs in code compiled with an older standard.
de: Vor C++11-Konstrukten in Code warnen, der mit einem älteren Standard kompiliert wurde.

en: Warn about C++11 inheriting constructors when the base has a variadic constructor.
de: Bei vererbten Konstruktoren in C++11 warnen, wenn die Basisklasse variadischen Konstruktor hat.

en: Warn about C++14 constructs in code compiled with an older standard.
de: Vor C++14-Konstrukten in Code warnen, der mit einem älteren Standard kompiliert wurde.

en: Warn about C++17 constructs in code compiled with an older standard.
de: Vor C++17-Konstrukten in Code warnen, der mit einem älteren Standard kompiliert wurde.

en: Warn about C++20 constructs in code compiled with an older standard.
de: Vor C++20-Konstrukten in Code warnen, der mit einem älteren Standard kompiliert wurde.

en: Warn about C++23 constructs in code compiled with an older standard.
de: Vor C++23-Konstrukten in Code warnen, der mit einem älteren Standard kompiliert wurde.

en: Warn about GCC format strings with strings unsuitable for diagnostics.
de: Bei GCC-Formatzeichenketten warnen, die für Diagnosemeldungen ungeeignete Zeichenketten enthalten.

en: Warn about NULL being passed to argument slots marked as requiring non-NULL.
de: Warnen, wenn NULL an Argumentstellen, die als nicht-NULL erfordernd markiert sind, übergeben wird.

en: Warn about PCH files that are found but not used.
de: Bei PCH-Dateien, die gefunden, aber nicht verwendet werden, warnen.

en: Warn about USE statements that have no ONLY qualifier.
de: Bei USE-Anweisungen, die keinen ONLY-Qualifizierer haben, warnen.

en: Warn about __TIME__, __DATE__ and __TIMESTAMP__ usage.
de: Bei Verwendung von __TIME__, __DATE__ oder __TIMESTAMP__ warnen.

en: Warn about accesses to interior zero-length array members.
de: Bei Zugriffen auf ein innenliegendes Arrayfeld der Länge 0 warnen.

en: Warn about alignment of COMMON blocks.
de: Bei Ausrichtung von COMMON-Blöcken warnen.

en: Warn about all enumerated switches missing a specific case.
de: Bei »switch«-Anweisungen auf Aufzählungen, denen ein Fall fehlt, warnen.

en: Warn about an empty body in an if or else statement.
de: Bei leerem Körper in einer if- oder else-Anweisung warnen.

en: Warn about an invalid DO loop.
de: Bei ungültigen DO-Schleifen warnen.

en: Warn about boolean expression compared with an integer value different from true/false.
de: Warnen, wenn ein boolescher Ausdruck mit einer Ganzzahl verglichen wird, deren Wert ungleich true/false ist.

en: Warn about buffer overflow in string manipulation functions like memcpy and strcpy.
de: Bei Pufferüberlauf in Stringfunktionen wie memcpy und strcpy warnen.

en: Warn about called procedures not explicitly declared.
de: Bei Aufrufen nicht explizit deklarierter Prozeduren warnen.

en: Warn about calling std::move on a local object in a return statement preventing copy elision.
de: Warnen, wenn std::move auf einem lokalen Objekt in einer return-Anweisung aufgerufen wird und dadurch das Ersparen der Kopie verhindert.

en: Warn about calls to snprintf and similar functions that truncate output.
de: Warnen, wenn Aufrufe für snprintf und ähnliche Funktionen die Ausgabe abschneiden.

en: Warn about calls to snprintf and similar functions that truncate output. Same as -Wformat-truncation=1.
de: Bei Aufrufen von snprintf und ähnlichen Funktionen warnen, wenn sie die Ausgabe abschneiden. Entspricht -Wformat-truncation=1.

en: Warn about calls to strcmp and strncmp used in equality expressions that are necessarily true or false due to the length of one and size of the other argument.
de: Warnen bei Aufrufen von strcmp und strncmp, die auf Gleichheit geprüft werden und die notwendigerweise wahr oder falsch sind, wegen der Länge des einen und Größe des anderen Arguments.

en: Warn about calls with implicit interface.
de: Bei Aufrufen mit impliziter Schnittstelle warnen.

en: Warn about cases where -ftrivial-auto-var-init cannot initialize an auto variable.
de: Vor Fällen warnen, in denen -ftrivial-auto-var-init eine Auto-Variable nicht initialisieren kann.

en: Warn about casting functions to incompatible types.
de: Warnen, wenn Funktionen in unverträgliche Typen umgewandelt werden.

en: Warn about casts between incompatible function types.
de: Warnen, wenn Funktionen in unverträgliche Funktionstypen umgewandelt werden.

en: Warn about casts that will produce a null result.
de: Bei Umwandlungen warnen, die null als Ergebnis haben.

en: Warn about casts which discard qualifiers.
de: Bei Umwandlungen, die Qualifizierer streichen, warnen.

en: Warn about catch handlers of non-reference type.
de: Bei catch-Behandlern warnen, die nicht Referenztypen sind.

en: Warn about certain operations on boolean expressions.
de: Bei bestimmten Operationen auf booleschen Ausdrücken warnen.

en: Warn about code paths in which NULL is passed to a must-not-be-NULL function argument.
de: Bei Codepfaden warnen, in denen NULL an ein Funktionsargument übergeben wird, das nicht NULL sein darf.

en: Warn about code paths in which a NULL pointer is dereferenced.
de: Bei Codepfaden warnen, in denen ein NULL-Zeiger dereferenziert wird.

en: Warn about code paths in which a freed value is used.
de: Bei Codepfaden warnen, in denen ein bereits freigegebener Wert verwendet wird.

en: Warn about code paths in which a heap-allocated pointer leaks.
de: Bei Codepfaden warnen, in denen ein vom Heap reservierter Zeiger nicht freigegeben wird.

en: Warn about code paths in which a longjmp rewinds to a jmp_buf saved in a stack frame that has returned.
de: Bei Codepfaden warnen, in denen ein longjmp zurückspult zu einem jmp_buf, der in einem Stapelrahmen gespeichert wurde, der bereits verlassen wurde.

en: Warn about code paths in which a non-heap pointer is freed.
de: Bei Codepfaden warnen, in denen ein Zeiger freigegeben wird, der nicht vom Heap kommt.

en: Warn about code paths in which a pointer can be freed more than once.
de: Bei Codepfaden warnen, in denen ein Zeiger mehr als einmal freigegeben werden kann.

en: Warn about code paths in which a pointer to a stale stack frame is used.
de: Bei Codepfaden warnen, in denen ein Zeiger auf einen bereits verschwundenen Stapelrahmen verwendet wird.

en: Warn about code paths in which a possibly-NULL pointer is dereferenced.
de: Bei Codepfaden warnen, in denen ein Zeiger, der möglicherweise NULL ist, dereferenziert wird.

en: Warn about code paths in which a possibly-NULL value is passed to a must-not-be-NULL function argument.
de: Bei Codepfaden warnen, in denen ein Wert, der möglicherweise NULL ist, an ein Funktionsargument übergeben wird, das nicht NULL sein darf.

en: Warn about code paths in which a shift with count >= width of type is attempted.
de: Bei Codepfaden warnen, in denen Bits mit Anzahl >= Typbreite geschoben werden.

en: Warn about code paths in which a shift with negative count is attempted.
de: Bei Codepfaden warnen, in denen Bits mit negativer Anzahl geschoben werden.

en: Warn about code paths in which a stdio FILE can be closed more than once.
de: Bei Codepfaden warnen, in denen eine stdio-Datei mehr als einmal geschlossen werden kann.

en: Warn about code paths in which a stdio FILE is not closed.
de: Bei Codepfaden warnen, in denen eine stdio-Datei nicht geschlossen wird.

en: Warn about code paths in which an async-signal-unsafe function is called from a signal handler.
de: Bei Codepfaden warnen, in denen eine Funktion, die async-signal-unsafe ist, aus einem Signalbehandler heraus aufgerufen wird.

en: Warn about code paths in which an uninitialized value is used.
de: Bei Codepfaden warnen, in denen ein uninitialisierter Wert verwendet wird.

en: Warn about code paths in which an unsanitized value is used as a divisor.
de: Bei Codepfaden warnen, in denen ein nicht überprüfter Wert als Divisor verwendet wird.

en: Warn about code paths in which an unsanitized value is used as a pointer offset.
de: Bei Codepfaden warnen, in denen ein nicht überprüfter Wert als Zeiger-Offset verwendet wird.

en: Warn about code paths in which an unsanitized value is used as a size.
de: Bei Codepfaden warnen, in denen ein nicht überprüfter Wert als Größe verwendet wird.

en: Warn about code paths in which an unsanitized value is used as an allocation size.
de: Bei Codepfaden warnen, in denen ein nicht überprüfter Wert zur Speicherallozierung verwendet wird.

en: Warn about code paths in which an unsanitized value is used as an array index.
de: Bei Codepfaden warnen, in denen ein nicht überprüfter Wert als Arrayindex verwendet wird.

en: Warn about code paths in which sensitive data is written to a file.
de: Bei Codepfaden warnen, in denen sensible Daten in eine Datei geschrieben werden.

en: Warn about code paths in which the wrong deallocation function is called.
de: Bei Codepfaden warnen, in denen die falsche Deallozierungsfunktion aufgerufen wird.

en: Warn about code paths which attempt to write to a const object.
de: Bei Codepfaden warnen, in denen in ein const-Objekt geschrieben wird.

en: Warn about code paths which attempt to write to a string literal.
de: Bei Codepfaden warnen, in denen in ein Stringliteral geschrieben wird.

en: Warn about code which might break strict aliasing rules.
de: Bei Code warnen, der strict-aliasing-Regeln verletzen könnte.

en: Warn about comparison of different enum types.
de: Beim Vergleich verschiedener Enum-Typen warnen.

en: Warn about comparisons between two operands of array type.
de: Beim Vergleich zwischen zwei Operanden vom Typ Array warnen.

en: Warn about compile-time integer division by zero.
de: Bei Ganzzahldivisionen durch Null zur Übersetzungszeit warnen.

en: Warn about constant integer divisions with truncated results.
de: Bei Ganzzahldivisionen mit abgeschnittenem Ergebnis warnen.

en: Warn about creation of array temporaries.
de: Bei Erzeugung temporärer Felder warnen.

en: Warn about dangling else.
de: Bei »hängendem else« warnen.

en: Warn about declarations of entities that may be missing attributes that related entities have been declared with.
de: Bei Deklarationen von Entitys warnen, in denen Attribute fehlen, die bei verwandten Entitys jedoch angegeben wurden.

en: Warn about deleting polymorphic objects with non-virtual destructors.
de: Beim Löschen polymorpher Objekte mit nicht-virtuellen Destruktoren warnen.

en: Warn about deprecated 'vector long ...' AltiVec type usage.
de: Vor der Verwendung des veralteten AltiVec-Typen »vector long ...« warnen.

en: Warn about deprecated arithmetic conversions on operands of enumeration types.
de: Bei veralteten arithmetischen Umwandlungen von Operanden mit Aufzählungstypen warnen.

en: Warn about deprecated arithmetic conversions on operands where one is of enumeration type and the other is of a floating-point type.
de: Bei veralteten arithmetischen Umwandlungen von Operanden warnen, bei denen der eine von einem Aufzählungstyp ist und der andere eine Gleitkommazahl.

en: Warn about deprecated uses of volatile qualifier.
de: Warnen, wenn der Qualifizierer »volatile« in veralteter Form eingesetzt wird.

en: Warn about divisions of two sizeof operators when the first one is applied to an array and the divisor does not equal the size of the array element.
de: Bei Divisionen von zwei %<sizeof%>-Operatoren warnen, wenn der erste auf ein Array angewendet wird und der Divisor nicht die Größe des Arrayelements ist.

en: Warn about duplicated branches in if-else statements.
de: Bei doppelten Zweigen in if-else-Anweisungen warnen.

en: Warn about duplicated conditions in an if-else-if chain.
de: Warnen, wenn in einer if-else-if-Kette doppelte Bedingungen auftauchen.

en: Warn about enumerated switches missing a "default:" statement.
de: Bei »switch«-Anweisungen auf Aufzählungen ohne »default:«-Fall warnen.

en: Warn about enumerated switches, with no default, missing a case.
de: Bei »switch«-Anweisungen auf Aufzählungen, denen ein Fall fehlt und die kein »default:« haben, warnen.

en: Warn about equality comparisons involving REAL or COMPLEX expressions.
de: Bei Prüfung auf Gleichheit mit REAL- oder COMPLEX-Ausdrücken warnen.

en: Warn about features not present in ISO C11, but present in ISO C2X.
de: Bei Merkmalen, die in ISO C2X, aber noch nicht in ISO C11 verfügbar sind, warnen.

en: Warn about features not present in ISO C90, but present in ISO C99.
de: Bei Merkmalen, die in ISO C99, aber noch nicht in ISO C90 verfügbar sind, warnen.

en: Warn about features not present in ISO C99, but present in ISO C11.
de: Bei Merkmalen, die in ISO C11, aber noch nicht in ISO C99 verfügbar sind, warnen.

en: Warn about features not present in traditional C.
de: Bei Merkmalen, die in traditionellem C nicht verfügbar sind, warnen.

en: Warn about format strings that are not literals.
de: Bei Formatstrings, die keine Literale sind, warnen.

en: Warn about format strings that contain NUL bytes.
de: Bei Formatstrings, die NUL-Bytes enthalten, warnen.

en: Warn about function call elimination.
de: Beim Entfernen von Funktionsaufrufen warnen.

en: Warn about function calls with format strings that write past the end of the destination region.
de: Bei Funktionsaufrufen mit Formatzeichenketten warnen, die hinter das Ende der Zielregion schreiben.

en: Warn about function calls with format strings that write past the end of the destination region.  Same as -Wformat-overflow=1.
de: Bei Funktionsaufrufen mit Formatzeichenketten warnen, die hinter das Ende der Zielregion schreiben. Entspricht -Wformat-overflow=1.

en: Warn about function parameters declared without a type specifier in K&R-style functions.
de: Bei Funktionen im K&R-Stil, die Parameter ohne Typangabe haben, warnen.

en: Warn about function pointer arithmetic.
de: Bei Arithmetik mit Funktionszeigern warnen.

en: Warn about functions which might be candidates for __attribute__((cold)).
de: Bei Funktionen, die Kandidaten für __attribute__((cold)) sein könnten, warnen.

en: Warn about functions which might be candidates for __attribute__((const)).
de: Bei Funktionen, die Kandidaten für __attribute__((const)) sein könnten, warnen.

en: Warn about functions which might be candidates for __attribute__((malloc)).
de: Bei Funktionen, die Kandidaten für __attribute__((malloc)) sein könnten, warnen.

en: Warn about functions which might be candidates for __attribute__((noreturn)).
de: Bei Funktionen, die Kandidaten für __attribute__((noreturn)) sein könnten, warnen.

en: Warn about functions which might be candidates for __attribute__((pure)).
de: Bei Funktionen, die Kandidaten für __attribute__((pure)) sein könnten, warnen.

en: Warn about functions which might be candidates for format attributes.
de: Bei Funktionen, die Kandidaten für Formatattribute sein könnten, warnen.

en: Warn about global functions without previous declarations.
de: Vor globalen Funktionen ohne vorherige Deklaration warnen.

en: Warn about global functions without prototypes.
de: Bei globalen Funktionen ohne Prototypen warnen.

en: Warn about implicit conversion of enum types.
de: Bei impliziten Umwandlungen von enum-Typen warnen.

en: Warn about implicit conversions from "float" to "double".
de: Bei impliziten Umwandlungen von »float« nach »double« warnen.

en: Warn about implicit declarations.
de: Bei impliziten Deklarationen warnen.

en: Warn about implicit function declarations.
de: Bei impliziten Funktionsdeklarationen warnen.

en: Warn about inappropriate attribute usage.
de: Bei unpassender Attributverwendung warnen.

en: Warn about incompatible integer to pointer and pointer to integer conversions.
de: Bei inkompatiblen Umwandlungen zwischen Zahlen und Zeigern (in beide Richtungen) warnen.

en: Warn about invalid OpenACC dimensions.
de: Bei ungültigen OpenACC-Dimensionen warnen.

en: Warn about invalid uses of the "offsetof" macro.
de: Bei ungültigen Verwendungen des Makros »offsetof« warnen.

en: Warn about likely missing requires keyword.
de: Bei möglicherweise fehlendem Schlüsselwort »requires« warnen.

en: Warn about macros defined in the main file that are not used.
de: Bei in der Hauptdatei definierten, ungenutzten Makros warnen.

en: Warn about macros that have conflicting header units definitions.
de: Bei Makros warnen, deren Header-Einheits-Definitionen nicht übereinstimmen.

en: Warn about maybe uninitialized automatic variables.
de: Bei möglicherweise nicht initialisierten automatischen Variablen warnen.

en: Warn about mismatched declarations of VLA parameters.
de: Warnen, wenn Deklarationen von VLA-Parametern nicht übereinstimmen.

en: Warn about mismatched declarations of array parameters and unsafe accesses to them.
de: Bei widersprüchlichen Deklarationen von Arrayparametern und unsicherem Zugriff auf diese warnen.

en: Warn about missing ampersand in continued character constants.
de: Bei fehlendem »&« in fortgesetzten Zeichenkonstanten warnen.

en: Warn about missing fields in struct initializers.
de: Bei fehlenden Feldern in struct-Initialisierungen warnen.

en: Warn about missing sized deallocation functions.
de: Warnen, wenn Deallokationsfunktionen mit expliziter Größenangabe fehlen.

en: Warn about misuses of pragmas.
de: Bei Missbrauch von Pragmas warnen.

en: Warn about most implicit conversions.
de: Bei den meisten impliziten Umwandlungen warnen.

en: Warn about multiple declarations of the same object.
de: Bei mehreren Deklarationen desselben Objektes warnen.

en: Warn about narrowing conversions within { } that are ill-formed in C++11.
de: Bei verengenden Umwandlungen innerhalb von { }, die in C++11 unzulässig sind, warnen.

en: Warn about non-virtual destructors.
de: Bei nicht-virtuellen Destruktoren warnen.

en: Warn about none ISO msvcrt scanf/printf width extensions.
de: Bei fehlenden ISO msvcrt scanf/printf Breiten-Erweiterungen warnen.

en: Warn about nonsensical values of --param destructive-interference-size or constructive-interference-size.
de: Warnung vor unsinnigen Werten von --param destructive-interference-size oder constructive-interference-size.

en: Warn about optimizations that assume that signed overflow is undefined.
de: Bei Optimierungen, die annehmen, dass vorzeichenbehafteter Überlauf undefiniert ist, warnen.

en: Warn about overflow in arithmetic expressions.
de: Bei Überlauf in arithmetischen Ausdrücken warnen.

en: Warn about overloaded virtual function names.
de: Bei überladenen virtuellen Funktionsnamen warnen.

en: Warn about overriding initializers with side effects.
de: Beim Überschreiben von Initialisierungen mit Seiteneffekten warnen.

en: Warn about overriding initializers without side effects.
de: Beim Überschreiben von Initialisierungen ohne Seiteneffekte warnen.

en: Warn about packed bit-fields whose offset changed in GCC 4.4.
de: Bei gepackten Bitfeldern, deren Offset sich in GCC 4.4 geändert hat, warnen.

en: Warn about pointer casts which increase alignment.
de: Warnen, wenn Zeigerumwandlungen die Ausrichtung vergrößern.

en: Warn about positional initialization of structs requiring designated initializers.
de: Bei positioneller Initialisierung von Strukturen warnen, die designierte Initialisierungen erfordern.

en: Warn about possible aliasing of dummy arguments.
de: Bei möglichem Aliasing von Dummy-Argumenten warnen.

en: Warn about possible security problems with format functions.
de: Vor möglichen Sicherheitsproblemen mit Formatfunktionen warnen.

en: Warn about possible violations of sequence point rules.
de: Bei möglichen Verstößen gegen Sequenzpunktregeln warnen.

en: Warn about possibly incorrect subscripts in do loops.
de: Bei möglicherweise falschen Arrayindexen in do-Schleifen warnen.

en: Warn about possibly missing braces around initializers.
de: Bei möglicherweise fehlenden Klammern um Initialisierungen warnen.

en: Warn about possibly missing parentheses.
de: Bei möglicherweise fehlenden Klammern warnen.

en: Warn about possibly nested block comments, and C++ comments spanning more than one physical line.
de: Bei möglicherweise geschachtelten Blockkommentaren und C++-Kommentaren, die mehr als eine physikalische Zeile umfassen, warnen.

en: Warn about potentially suboptimal choices related to OpenACC parallelism.
de: Vor potenziell suboptimalen Entscheidungen im Zusammenhang mit OpenACC-Parallelität warnen.

en: Warn about printf/scanf/strftime/strfmon format string anomalies.
de: Bei Unregelmäßigkeiten in printf/scanf/strftime/strfmon-Formatstrings warnen.

en: Warn about questionable usage of the macros used to retrieve variable arguments.
de: Bei fragwürdiger Verwendung der Makros, die variable Argumente ermitteln, warnen.

en: Warn about reading past the end of a source array in string manipulation functions like memchr and memcpy.
de: Warnen, wenn das Quellarray über das Ende hinaus gelesen wird, in Speicherfunktionen wie %<memchr%> und %<memcpy%>.

en: Warn about real-literal-constants with 'q' exponent-letter.
de: Bei Gleitkommakonstanten-Literalen mit Exponentenbuchstaben »q« warnen.

en: Warn about redundant calls to std::move.
de: Bei redundanten Aufrufen von std::move warnen.

en: Warn about returning a pointer/reference to a local or temporary variable.
de: Bei Rückgabe eines Zeigers/Referenz an lokale oder temporäre Variable warnen.

en: Warn about returning structures, unions or arrays.
de: Bei zurückgegebenen Strukturen, Unions oder Arrays warnen.

en: Warn about semicolon after in-class function definition.
de: Bei Semikolon nach Funktionsdefinition innerhalb einer Klasse warnen.

en: Warn about sign differences with format functions.
de: Vor Vorzeichenunterschieden mit Formatfunktionen warnen.

en: Warn about signed-unsigned comparisons.
de: Bei Vergleichen von vorzeichenbehaftet mit vorzeichenlos warnen.

en: Warn about some C++ One Definition Rule violations during link time optimization.
de: Während der Optimierungen zur Linkzeit bei einigen Verletzungen der One-Definition-Rule aus C++ warnen.

en: Warn about statements between switch's controlling expression and the first case.
de: Bei Anweisungen warnen, die zwischen »switch (...)« und dem ersten »case:« stehen.

en: Warn about stray tokens after #else and #endif.
de: Bei verirrten Symbolen hinter #elif und #endif warnen.

en: Warn about strftime formats yielding 2-digit years.
de: Bei strftime-Formaten, die 2-stellige Jahreszahlen erzeugen, warnen.

en: Warn about subscripts whose type is "char".
de: Vor Indizes mit Typ »char« warnen.

en: Warn about suspicious calls to memset where the third argument contains the number of elements not multiplied by the element size.
de: Bei verdächtigen Aufrufen von memset warnen, wenn das dritte Argument die Anzahl der Elemente enthält, aber nicht mit der Elementgröße multipliziert.

en: Warn about suspicious calls to memset where the third argument is constant literal zero and the second is not.
de: Bei verdächtigen Aufrufen von memset warnen, wenn das dritte Argument eine Null ist, das zweite jedoch nicht.

en: Warn about suspicious declarations of "main".
de: Vor verdächtigen Deklarationen von »main« warnen.

en: Warn about suspicious divisions of two sizeof expressions that don't work correctly with pointers.
de: Warnen, wenn zwei sizeof-Ausdrücke durcheinander geteilt werden, die nicht korrekt mit Zeigern funktionieren.

en: Warn about suspicious length parameters to certain string functions if the argument uses sizeof.
de: Bei verdächtigen Aufrufen bestimmter Zeichenkettenfunktionen warnen, wenn im Argument sizeof vorkommt.

en: Warn about suspicious uses of memory addresses.
de: Vor verdächtigem Gebrauch von Speicheradressen warnen.

en: Warn about switch values that are outside of the switch's type range.
de: Warnen, wenn die Vergleichswerte einer switch-Anweisung außerhalb des für den Typ erreichbaren Bereichs liegen.

en: Warn about switches with boolean controlling expression.
de: Bei switch-Anweisungen mit booleschem Steuerausdruck warnen.

en: Warn about the most vexing parse syntactic ambiguity.
de: Bei den merkwürdigsten syntaktischen Mehrdeutigkeiten warnen.

en: Warn about things that change between the current -fabi-version and the specified version.
de: Bei Dingen warnen, die sich zwischen der aktuellen »-fabi-version« und der angegebenen Version ändern.

en: Warn about things that will change when compiling with an ABI-compliant compiler.
de: Bei Dingen warnen, die sich bei der Übersetzung mit einem ABI-konformen Compiler ändern werden.

en: Warn about truncated character expressions.
de: Bei abgeschnittenen Zeichenausdrücken warnen.

en: Warn about truncated source lines.
de: Bei abgeschnittenen Quelltextzeilen warnen.

en: Warn about truncation in string manipulation functions like strncat and strncpy.
de: Bei Abschneiden in Stringfunktionen wie strncat und strncpy warnen.

en: Warn about type safety and similar errors and mismatches in declarations with alias attributes.
de: In Deklarationen mit Alias-Attributen bezüglich Typsicherheit und ähnlicher Fehler und Irrtümer warnen.

en: Warn about uncasted NULL used as sentinel.
de: Bei als Wächter verwendetem, nicht umgewandeltem NULL warnen.

en: Warn about underflow of numerical constant expressions.
de: Bei Unterlauf numerischer Konstantenausdrücke warnen.

en: Warn about uninitialized automatic variables.
de: Bei nicht initialisierten automatischen Variablen warnen.

en: Warn about unprototyped function declarations.
de: Bei Funktionsdeklarationen ohne Prototyp warnen.

en: Warn about unrecognized pragmas.
de: Bei nicht erkannten Pragmas warnen.

en: Warn about unsafe macros expanding to multiple statements used as a body of a clause such as if, else, while, switch, or for.
de: Warnen bei unsicheren Makros, die zu mehreren Anweisungen expandiert werden und innerhalb eines if, else, while, switch oder for verwendet werden.

en: Warn about unsuffixed float constants.
de: Bei Gleitkommakonstanten ohne Suffix warnen.

en: Warn about unsupported features in ThreadSanitizer.
de: Bei nicht unterstützten Features im ThreadSanitizer warnen.

en: Warn about unused dummy arguments.
de: Bei nicht verwendeten Dummy-Argumenten warnen.

en: Warn about use of multi-character character constants.
de: Bei Verwendung von Zeichenkonstanten mit mehreren Zeichen warnen.

en: Warn about useless casts.
de: Bei unnützen Typumwandlungen warnen.

en: Warn about user-specified include directories that do not exist.
de: Bei durch den Benutzer angegebenen Einfügepfaden, die nicht vorhanden sind, warnen.

en: Warn about uses of __attribute__((deprecated)) declarations.
de: Bei Verwendungen von Deklarationen mit __attribute__((deprecated)) warnen.

en: Warn about uses of __attribute__((warning)) declarations.
de: Bei Verwendungen von Deklarationen mit __attribute__((warning)) warnen.

en: Warn about uses of a comma operator within a subscripting expression.
de: Warnen, wenn innerhalb eines Arrayindex ein Komma-Operator verwendet wird.

en: Warn about uses of register storage specifier.
de: Bei Verwendung der Speicherklassenangabe »register« warnen.

en: Warn about uses of std::initializer_list that can result in dangling pointers.
de: Bei Verwendung von std::initializer_list warnen, wenn dadurch baumelnde Zeiger entstehen können.

en: Warn about using variadic macros.
de: Bei Verwendung variadischer Makros warnen.

en: Warn about variables that might be changed by "longjmp" or "vfork".
de: Bei Variablen, die von »longjmp« oder »vfork« geändert werden könnten, warnen.

en: Warn about variables which are initialized to themselves.
de: Bei Variablen, die mit sich selbst initialisiert werden, warnen.

en: Warn about violations of Effective C++ style rules.
de: Bei Verstößen gegen die Stil-Richtlinien von »Effective C++« warnen.

en: Warn about zero-length formats.
de: Bei Formaten der Länge null warnen.

en: Warn about zero-trip DO loops.
de: Bei DO-Schleifen mit null Durchläufen warnen.

en: Warn for calls to allocation functions that specify zero bytes.
de: Bei Aufrufen von Allozierungsfunktionen warnen, bei denen als Größe 0 angegeben ist.

en: Warn for conditionally-supported constructs.
de: Bei Verwendung von bedingt unterstützten Konstrukten warnen.

en: Warn for converting NULL from/to a non-pointer type.
de: Bei Umwandlung von NULL in Nicht-Zeiger-Typ oder umgekehrt warnen.

en: Warn for deallocation calls with arguments returned from mismatched allocation functions.
de: Warnen bei Deallokationsaufrufen mit Argumenten, die von nicht übereinstimmenden Allokationsfunktionen zurückgegeben werden.

en: Warn for implicit type conversions between signed and unsigned integers.
de: Bei impliziten Typumwandlungen zwischen vorzeichenbehafteten und vorzeichenlosen Ganzzahlen warnen.

en: Warn for implicit type conversions that cause loss of floating point precision.
de: Bei impliziten Typumwandlungen warnen, die die Präzision von Gleitkommazahlen reduzieren.

en: Warn for implicit type conversions that may change a value.
de: Bei impliziten Typumwandlungen warnen, die einen Wert ändern könnten.

en: Warn for infinitely recursive calls.
de: Bei unendlich rekursiven Aufrufen warnen.

en: Warn for mismatches between calls to operator new or delete and the corresponding call to the allocation or deallocation function.
de: Warnen bei Nichtübereinstimmung zwischen Aufrufen der Operatoren »new« oder »delete« und dem entsprechenden Aufruf der Allokations- oder Deallokationsfunktion.

en: Warn for obsolescent usage in a declaration.
de: Bei veralteter Verwendung in einer Deklaration warnen.

en: Warn for placement new expressions with undefined behavior.
de: Bei Placement-New-Ausdrücken mit undefiniertem Verhalten warnen.

en: Warn for suspicious integer expressions in boolean context.
de: Bei verdächtigen Ganzzahl-Ausdrücken im Boolean-Kontext warnen.

en: Warn for unsafe raw memory writes to objects of class types.
de: Warnen bei unsicherem direkten Schreibzugriff in Speicher von Klassen-Objekten.

en: Warn for uses of pointers to auto variables whose lifetime has ended.
de: Vor der Verwendung von Zeigern auf Auto-Variablen, deren Lebensdauer abgelaufen ist, warnen.

en: Warn for uses of pointers to deallocated storage.
de: Vor der Verwendung von Zeigern auf freigegebenen Speicher warnen.

en: Warn from speculative compiles such as __traits(compiles).
de: Bei spekulativen Compilierungen wie zum Beispiel __traits(compiles) warnen.

en: Warn if "defined" is used outside #if.
de: Warnen, wenn »defined« außerhalb von »#if« verwendet wird.

en: Warn if C++17 noexcept function type will change the mangled name of a symbol.
de: Warnen, wenn ein C++17-noexcept-Funktionstyp den gemangelten Namen eines Symbols beeinflusst.

en: Warn if a C-style cast is used in a program.
de: Warnen, wenn eine Typumwandlung im C-Stil im Programm verwendet wird.

en: Warn if a caller of a function, marked with attribute warn_unused_result, does not use its return value.
de: Warnen, wenn der Rückgabewert der mit dem Attribut warn_unused_result definierten Funktion ignoriert wird.

en: Warn if a class interface has no superclass.  Root classes may use an attribute to suppress this warning.
de: Warnung, wenn eine Klassenschnittstelle keine Superklasse hat. Wurzelklassen können ein Attribut verwenden, um diese Warnung zu unterdrücken.

en: 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.
de: Warnen, wenn ein Klassentyp eine Basis oder ein Feld hat, deren Typ den unbenannten Namensraum verwendet oder von einem Typen ohne Bindung abhängt.

en: Warn if a comparison always evaluates to true or false.
de: Warnen, wenn ein Vergleich immer zu »wahr« oder »falsch« auswertet.

en: Warn if a comparison is always true or always false due to the limited range of the data type.
de: Warnen, wenn ein Vergleich durch beschränkten Wertebereich des Datentyps stets »wahr« oder »unwahr« ist.

en: Warn if a deprecated compiler feature, class, method, or field is used.
de: Warnen, wenn veraltetes Compiler-Merkmal, Klasse, Methode oder Feld verwendet wird.

en: Warn if a function uses alloca or creates an array with dynamic size.
de: Warnen, wenn eine Funktion alloca verwendet oder ein Array dynamischer Größe erzeugt.

en: Warn if a local declaration hides an instance variable.
de: Warnen, wenn eine lokale Deklaration eine Instanzvariable verdeckt.

en: Warn if a loop with constant number of iterations triggers undefined behavior.
de: Warnen, wenn Schleife mit konstanter Anzahl von Durchläufen zu undefiniertem Verhalten führt.

en: Warn if a property for an Objective-C object has no assign semantics specified.
de: Warnen, wenn für eine Eigenschaft eines Objective-C-Objektes keine Zuweisungssemantik spezifiert ist.

en: Warn if a selector has multiple methods.
de: Warnen, wenn ein Selektor mehrere Methoden hat.

en: Warn if a simd directive is overridden by the vectorizer cost model.
de: Warnen, wenn eine SIMD-Direktive vom Vektorisierer-Kostenmodell übersteuert wird.

en: Warn if a single function's framesize exceeds the given framesize.
de: Warnen, wenn Rahmengröße einer einzelnen Funktion die angegebene Rahmengröße überschreitet.

en: Warn if a string is longer than the maximum portable length specified by the standard.
de: Warnen, wenn Zeichenkette länger als die größte vom Standard angegebene portable Länge ist.

en: Warn if a subobject has an abi_tag attribute that the complete object type does not have.
de: Bei Teilobjekt mit Attribut abi_tag warnen, das das Gesamtobjekt nicht hat.

en: Warn if a throw expression will always result in a call to terminate().
de: Warnen, wenn ein throw-Ausdruck garantiert in einem Aufruf von terminate() endet.

en: Warn if a user-procedure has the same name as an intrinsic.
de: Warnen, wenn eine Benutzer-Prozedur denselben Namen wie ein Intrinsic hat.

en: Warn if a variable length array is used.
de: Warnen, wenn ein Array variabler Länge verwendet wird.

en: Warn if a virtual base has a non-trivial move assignment operator.
de: Warnen, wenn virtuelle Basis einen nicht trivialen Zuweisungsoperator (move) hat.

en: Warn if an MCU name is unrecognized or conflicts with other options (default: on).
de: Warnen, wenn ein MCU-Name unbekannt ist oder mit anderen Optionen unverträglich ist (Vorgabe: eingeschaltet).

en: Warn if an array is accessed out of bounds.
de: Warnen, wenn auf ein Array außerhalb der Grenzen zugegriffen wird.

en: Warn if an old-style parameter definition is used.
de: Warnen, wenn eine Parameterdefinition im alten Stil verwendet wird.

en: Warn if an undefined macro is used in an #if directive.
de: Warnen, wenn ein undefiniertes Makro in einer #if-Anweisung verwendet wird.

en: Warn if comparing pointer parameter with nonnull attribute with NULL.
de: Warnen, wenn ein Zeiger mit »nonnull«-Attribut mit NULL verglichen wird.

en: Warn if constant CFString objects contain non-portable characters.
de: Warnen, wenn konstante CFString-Objekte unportable Zeichen enthalten.

en: Warn if constructor or destructors with priorities from 0 to 100 are used.
de: Warnen, wenn Konstruktoren oder Destruktoren mit Prioritäten von 0 bis 100 verwendet werden.

en: Warn if conversion of the result of arithmetic might change the value even though converting the operands cannot.
de: Warnen, wenn das Ergebnis der arithmetischen Berechnungen einen falschen Wert ergeben könnte, selbst wenn die Operanden korrekt konvertiert werden.

en: Warn if dereferencing a NULL pointer may lead to erroneous or undefined behavior.
de: Warnen, wenn das Dereferenzieren eines Nullzeigers zu fehlerhaftem oder undefiniertem Verhalten führen kann.

en: Warn if devices.csv is not found or there are problem parsing it (default: on).
de: Warnen, wenn devices.csv nicht gefunden wird oder es Probleme beim Einlesen gibt (Vorgabe: an).

en: Warn if inherited methods are unimplemented.
de: Warnen, wenn geerbte Methoden nicht implementiert sind.

en: Warn if left shift of a signed value overflows.
de: Warnen, wenn das Linksschieben eines vorzeichenbehafteten Werts überläuft.

en: Warn if left shifting a negative value.
de: Warnen, wenn eine negative Zahl nach links geschoben wird.

en: Warn if loops have been interchanged.
de: Warnen, wenn Schleifen getauscht wurden.

en: Warn if passing too many arguments to a function for its format string.
de: Bei zu vielen Argumenten für eine Funktion (anhand Formatzeichenkette) warnen.

en: Warn if qualifiers on arrays which are pointer targets are discarded.
de: Warnen, wenn Qualifizierer von Arrays gestrichen werden, die Zeigerziele sind.

en: Warn if shift count >= width of type.
de: Warnen, wenn Rechts-Schiebe-Anzahl >= Breite des Typs ist.

en: Warn if shift count is negative.
de: Warnen, wenn Schiebe-Anzahl negativ ist.

en: Warn if testing floating point numbers for equality.
de: Bei Test von Gleitkommawerten auf Gleichheit warnen.

en: Warn if the ISR is misspelled, i.e. without __vector prefix. Enabled by default.
de: Warnen, wenn die ISR falschgeschrieben ist, beispielsweise ohne __vector-Präfix. Voreinstellung: eingeschaltet.

en: Warn if the NSObject attribute is applied to a non-typedef.
de: Warnen, wenn das NSObject-Attribut auf etwas Anderes als typedef angewendet wird.

en: Warn if the address space of an address is changed.
de: Warnen, wenn sich der Adressraum einer Adresse ändert.

en: Warn if the code is too complicated for the analyzer to fully explore.
de: Warnen, wenn der Code so kompliziert ist, dass er nicht vollständig analysiert werden kann.

en: Warn if the pointer in a pointer assignment might outlive its target.
de: Warnen, wenn der Zeiger in einer Zeigerzuweisung sein Ziel überleben könnte.

en: Warn if the type of a variable might be not interoperable with C.
de: Bei Unverträglichkeit eines Variablentyps mit C warnen.

en: Warn if trigraphs are encountered that might affect the meaning of the program.
de: Warnen, wenn Trigraphen auftreten, die die Bedeutung des Programmes beeinflussen könnten.

en: Warn if type qualifiers on pointers are discarded.
de: Warnen, wenn Typqualifizierer von Zeigern ignoriert werden.

en: Warn if type signatures of candidate methods do not match exactly.
de: Wenn Typsignaturen der Kandidatenmethoden nicht exakt passen, warnen.

en: Warn in case a function ends earlier than it begins due to an invalid linenum macros.
de: Warnen, wenn eine Funktion aufgrund eines ungültigen Zeilennummer-Makros früher endet als sie beginnt.

en: Warn in case profiles in -fprofile-use do not exist.
de: Warnen, wenn Profile in -fprofile-use nicht existieren.

en: Warn in case profiles in -fprofile-use do not match.
de: Warnen, wenn Profile in -fprofile-use nicht zueinander passen.

en: Warn of prototypes causing type conversions different from what would happen in the absence of prototype.
de: Bei Prototypen warnen, die zu anderen Typumwandlungen führen würden, wenn der Prototyp nicht angegeben wäre.

en: Warn on any use of alloca.
de: Bei jeglicher Verwendung von alloca warnen.

en: Warn on direct multiple inheritance.
de: Bei direkter Mehrfachvererbung warnen.

en: Warn on direct virtual inheritance.
de: Bei direkter virtueller Vererbung warnen.

en: Warn on intrinsics not part of the selected standard.
de: Bei Intrinsics, die nicht im gewählten Standard vorhanden sind, warnen.

en: Warn on namespace definition.
de: Bei Namensraum-Definition warnen.

en: Warn on primary template declaration.
de: Bei primärer Deklaration von Templates warnen.

en: Warn on suspicious calls of standard functions computing absolute values.
de: Bei verdächtigen Aufrufen von Standardfunktionen warnen, die absolute Werte berechnen.

en: Warn on suspicious constructs involving reverse scalar storage order.
de: Bei verdächtigen Konstrukten waren, an denen die umgekehrte skalare Speicherreihenfolge beteiligt ist.

en: Warn that -fno-automatic may break recursion.
de: Warnen, dass »-fno-automatic« Rekursion kaputtmachen könnte.

en: Warn when __builtin_frame_address or __builtin_return_address is used unsafely.
de: Warnen, wenn __builtin_frame_address oder __builtin_return_address auf unsichere Weise verwendet werden.

en: Warn when __sync_fetch_and_nand and __sync_nand_and_fetch built-in functions are used.
de: Warnen, wenn die eingebauten Funktionen __sync_fetch_and_nand und __sync_nand_and_fetch verwendet werden.

en: Warn when a #warning directive is encountered.
de: Warnen, wenn eine #warning-Direktive verwendet wird.

en: Warn when a base is inaccessible in derived due to ambiguity.
de: Warnen, wenn eine Basis aufgrund von Mehrdeutigkeit im abgeleiteten Typ unzugänglich wird.

en: Warn when a built-in function is declared with the wrong signature.
de: Warnen, wenn eine eingebaute Funktion mit der falschen Signatur deklariert wird.

en: Warn when a built-in preprocessor macro is undefined or redefined.
de: Bei undefiniertem oder redefiniertem eingebauten Präprozessormakro warnen.

en: Warn when a class is redeclared or referenced using a mismatched class-key.
de: Warnen, wenn eine Klasse neudeklariert oder mit einem unpassenden Klassenschlüssel auf sie verwiesen wird.

en: Warn when a class or enumerated type is referenced using a redundant class-key.
de: Warnen, wenn auf eine Klasse oder einen Aufzählungstyp mit einem redundanten Klassenschlüssel verwiesen wird.

en: Warn when a const variable is unused.
de: Warnen, wenn eine konstante Variable nicht verwendet wird.

en: Warn when a conversion function will never be called due to the type it converts to.
de: Warnen, wenn eine Umwandlungsfunktion niemals aufgerufen werden kann, aufgrund des Umwandlungs-Zieltypen.

en: Warn when a declaration does not specify a type.
de: Warnen, wenn eine Deklaration keinen Typ angibt.

en: Warn when a declaration has duplicate const, volatile, restrict or _Atomic specifier.
de: Warnen, wenn in einer Deklaration const, volatile, restrict oder _Atomic doppelt angegeben ist.

en: Warn when a declaration is found after a statement.
de: Warnen, wenn eine Deklaration hinter einer Anweisung gefunden wird.

en: Warn when a function is unused.
de: Warnen, wenn eine Funktion ungenutzt bleibt.

en: Warn when a function parameter is only set, otherwise unused.
de: Warnen, wenn ein Funktionsparameter zwar gesetzt, aber nicht verwendet wird.

en: Warn when a function parameter is unused.
de: Warnen, wenn ein Funktionsparameter nicht verwendet wird.

en: Warn when a jump misses a variable initialization.
de: Warnen, wenn ein Sprung die Initialisierung einer Variable überspringt.

en: Warn when a label is unused.
de: Warnen, wenn eine Sprungmarke ungenutzt bleibt.

en: Warn when a left-hand-side array variable is reallocated.
de: Warnen, wenn Feldvariable auf linker Seite wiederholt reserviert wird.

en: Warn when a left-hand-side variable is reallocated.
de: Warnen, wenn Variable auf linker Seite wiederholt reserviert wird.

en: Warn when a literal '0' is used as null pointer.
de: Warnen, wenn ein Literal 0 als NULL-Zeiger verwendet wird.

en: Warn when a logical operator is suspiciously always evaluating to true or false.
de: Warnen, wenn ein logischer Operator verdächtigerweise immer zu »wahr« oder »falsch« auswertet.

en: Warn when a noexcept expression evaluates to false even though the expression can't actually throw.
de: Warnen, wenn ein »noexcept«-Ausdruck zu »falsch« auswertet, obwohl der Ausdruck nicht werfen kann.

en: Warn when a pointer differs in signedness in an assignment.
de: Warnen, wenn sich ein Zeiger im Vorzeichenbesitz in einer Zuweisung unterscheidet.

en: Warn when a pointer is cast to an integer of a different size.
de: Bei Typkonvertierung von Zeiger auf Ganzzahl anderer Breite warnen.

en: Warn when a pointer is compared with a zero character constant.
de: Warnen, wenn ein Zeiger mit '\0' verglichen wird.

en: Warn when a range-based for-loop is creating unnecessary copies.
de: Warnen, wenn eine bereichsbasierte for-Schleife unnötige Kopien erzeugt.

en: Warn when a register variable is declared volatile.
de: Warnen, wenn eine Registervariable als »volatile« deklariert ist.

en: Warn when a string or character literal is followed by a ud-suffix which does not begin with an underscore.
de: Warnen, wenn Zeichenkette oder Zeichenliteral gefolgt von UD-Suffix auftritt, der nicht mit Unterstrich anfängt.

en: Warn when a switch case falls through.
de: Warnen, wenn in einem switch-Block ein case durchfällt.

en: Warn when a variable is only set, otherwise unused.
de: Warnen, wenn eine Variable zwar gesetzt, aber nicht verwendet wird.

en: Warn when a variable is unused.
de: Warnen, wenn eine Variable nicht verwendet wird.

en: Warn when a vector operation is compiled outside the SIMD.
de: Warnen, wenn Vektoroperation außerhalb von SIMD kompiliert wird.

en: Warn when all constructors and destructors are private.
de: Warnen, wenn alle Konstruktoren und Destruktoren privat sind.

en: Warn when an argument passed to a restrict-qualified parameter aliases with another argument.
de: Warnen, wenn ein Argument für einen »restrict«-Parameter auch in einem anderen Argument vorkommt.

en: Warn when an atomic memory model parameter is known to be outside the valid range.
de: Warnen, wenn ein Parameter des atomaren Speichermodells erkennbar außerhalb des Wertebereiches ist.

en: Warn when an exception handler is shadowed by another handler.
de: Warnen, wenn ein Ausnahmebehandler von einem anderen Behandler überdeckt wird.

en: Warn when an expression value is unused.
de: Warnen, wenn ein Ausdruckswert nicht verwendet wird.

en: Warn when an inlined function cannot be inlined.
de: Warnen, wenn eine inline-Funktion nicht als solche erzeugt werden kann.

en: Warn when an optimization pass is disabled.
de: Warnen, wenn ein Optimierungsdurchgang ausgeschaltet ist.

en: Warn when attempting to free a non-heap object.
de: Beim Versuch der Freigabe eines Nicht-Heap-Objektes warnen.

en: Warn when converting the type of pointers to member functions.
de: Bei Umwandlung des Typs von Zeigern auf Elementfunktionen warnen.

en: Warn when deleting a pointer to incomplete type.
de: Warnen, wenn ein Zeiger auf unvollständigen Typen gelöscht wird.

en: Warn when fields in a struct with the packed attribute are misaligned.
de: Warnen, wenn Felder in einer gepackten Struktur nicht ausgerichtet sind.

en: Warn when logical not is used on the left hand side operand of a comparison.
de: Warnen, wenn ein logisches Nicht im linken Operanden eines Vergleichs verwendet wird.

en: Warn when multiple, different, fast interrupt handlers are in the compilation unit.
de: Warnen, wenn mehrere unterschiedliche schnelle Interruptbehandlungsroutinen in Übersetzungseinheit sind.

en: Warn when non-templatized friend functions are declared within a template.
de: Warnen, wenn Nicht-Template-Friend-Funktionen innerhalb eines Templates deklariert werden.

en: Warn when not issuing stack smashing protection for some reason.
de: Warnen, wenn Stapelzerstörungsschutz aus irgendeinem Grund nicht erzeugt wird.

en: Warn when one local variable shadows another local variable or parameter of compatible type.
de: Warnen, wenn eine lokale Variable eine andere lokale Variable oder einen Parameter mit gleichem Typ überdeckt.

en: Warn when one local variable shadows another local variable or parameter.
de: Warnen, wenn eine lokale Variable eine andere lokale Variable oder einen Parameter überdeckt.

en: Warn when one variable shadows another (globally).
de: Warnen, wenn eine Variable eine andere überdeckt (global).

en: Warn when one variable shadows another.  Same as -Wshadow=global.
de: Warnen, wenn eine Variable eine andere überdeckt. Entspricht -Wshadow=global.

en: Warn when overload promotes from unsigned to signed.
de: Warnen, wenn Überladung zur Umwandlung von vorzeichenbehaftet zu vorzeichenlos führt.

en: Warn when padding is required to align structure members.
de: Warnen, wenn Auffüllen benötigt wird, um Strukturelemente auszurichten.

en: Warn when performing class template argument deduction on a type with no deduction guides.
de: Warnen beim Ableiten von Klassentemplateargumenten an Typen ohne Ableitungshinweise.

en: Warn when profiling instrumentation was requested, but could not be applied to a certain function.
de: Warnen, wenn Profiling-Instrumentierung verlangt wurde, aber auf eine bestimmte Funktion nicht angewandt werden konnte.

en: Warn when sizeof is applied on a parameter declared as an array.
de: Warnen, wenn sizeof auf einen Funktionsparameter angewendet wird, der als Array deklariert ist.

en: Warn when the address of packed member of struct or union is taken.
de: Warnen, wenn die Adresse eines gepackten Elements einer Struktur oder Union verwendet wird.

en: Warn when the compiler reorders code.
de: Warnen, wenn der Compiler Code umsortiert.

en: Warn when the field in a struct is not aligned.
de: Warnen, wenn Feld in einer Struktur nicht ausgerichtet ist.

en: Warn when the indentation of the code does not reflect the block structure.
de: Warnen, wenn die Einrückung des Codes nicht der Blockstruktur entspricht.

en: Warn when the packed attribute has no effect on struct layout.
de: Warnen, wenn das »packed«-Attribut keine Auswirkung auf Strukturanordnung hat.

en: Warn when the template keyword is missing after a member access token in a dependent member access expression if that member is a template.
de: Warnen, wenn das Schlüsselwort »template« nach einem Token für Memberzugriff in einem abhängigen Memberzugriff-Ausdruck fehlt, wenn dieser Member ein Template ist.

en: Warn when there is a cast to a pointer from an integer of a different size.
de: Bei Typumwandlung in Zeiger von Ganzzahl anderer Größe warnen.

en: Warn when there is a conversion between pointers that have incompatible types.
de: Bei Zeiger-Umwandlungen zwischen inkompatiblen Zeigertypen warnen.

en: Warn when typedefs locally defined in a function are not used.
de: Bei lokal in Funktionen definierten, aber nicht verwendeten Typedefs warnen.

en: Warn whenever a function's return type defaults to "int" (C), or about inconsistent return types (C++).
de: Bei Standardrückgabetyp »int« für Funktionen (C) und inkonsistenten Rückgabetypen (C++) warnen.

en: Warn whenever a trampoline is generated.
de: Warnen, wenn ein Trampolin generiert wird.

en: Warn whenever an Objective-C assignment is being intercepted by the garbage collector.
de: Immer warnen, wenn eine Objective-C-Zuweisung vom Garbage Collector abgefangen wird.

en: Warn whenever attributes are ignored.
de: Warnen, wenn Attribute ignoriert werden.

en: Warn whenever type qualifiers are ignored.
de: Warnen, wenn Typqualifizierer ignoriert werden.

en: Warning
de: Warnung

en: When "signed" or "unsigned" is not given make the bitfield signed.
de: Wenn weder »signed« noch »unsigned« angegeben wurden, das Bitfeld vorzeichenbehaftet machen.

en: When "signed" or "unsigned" is not given make the bitfield unsigned.
de: Wenn weder »signed« noch »unsigned« angegeben ist, das Bitfeld vorzeichenlos machen.

en: When -mhard-float is selected, enables generation of double-precision floating point instructions.  By default functions from libgcc are used to perform double-precision floating point operations.
de: Wenn »-mhard-float« ausgewählt ist, werden Gleitkommaberechnungen mit doppelter Genauigkeit in Hardware-Befehle übersetzt. Standardmäßig werden für diese Berechnungen Funktionen aus der libgcc verwendet.

en: When -mhard-float is selected, enables generation of unordered floating point compare and set flag (lf.sfun*) instructions.  By default functions from libgcc are used to perform unordered floating point compare and set flag operations.
de: Wenn »-mhard-float« ausgewählt ist, werden ungeordnete Fließkomma-Vergleichs- und Set-Flag-Befehle (lf.sfun*) erzeugt. Standardmäßig werden Funktionen von libgcc verwendet, um ungeordnete Fließkomma-Vergleichs- und Flag-Operationen durchzuführen.

en: When a symbol is resolved, check `alias this' scope before going to upper scopes.
de: Wenn ein Symbol aufgelöst wird, den Gültigkeitsbereich »alias this« prüfen, erst danach zu den höheren Bereichen gehen.

en: When accessing RAM, use X as imposed by the hardware, i.e. just use pre-decrement, post-increment and indirect addressing with the X register.  Without this option, the compiler may assume that there is an addressing mode X+const similar to Y+const and Z+const and emit instructions to emulate such an addressing mode for X.
de: Bei RAM-Zugriff X wie durch Hardware vorgegeben verwenden, d.h. Pre-Dekrement, Post-Inkrement und indirekte Adressierung mit dem X-Register. Ohne diese Option nimmt der Compiler an, dass es einen Adressierungsmodus X+const, ähnlich zu Y+const und Z+const gibt und erzeugt Befehle, die diesen Adressierungsmodus für X emulieren.

en: When both heuristics with rs6000-density-pct-threshold and rs6000-density-size-threshold are satisfied, we decide to penalize the loop body cost by the value which is specified by this parameter.  The default value is 10.
de: Wenn beide Heuristiken mit rs6000-density-pct-threshold und rs6000-density-size-threshold erfüllt sind, werden die Kosten des Schleifenkörpers mit dem Wert bestraft, der durch diesen Parameter festgelegt ist. Der Standardwert ist 10.

en: When costing for loop vectorization, we probably need to penalize the loop body cost by accounting for excess strided or elementwise loads.  We collect the numbers for general statements and load statements according to the information for statements to be vectorized, check the proportion of load statements, and penalize only if the proportion exceeds the threshold specified by this parameter.  The default value is 45.
de: Bei der Kostenkalkulation für die Vektorisierung von Schleifen müssen wir wahrscheinlich die Kosten für den Schleifenkörper bestrafen, indem wir übermäßig versetzte oder elementweise Lesezugriffe berücksichtigen. Wir sammeln die Zahlen für allgemeine Anweisungen und Ladeanweisungen entsprechend den Informationen für zu vektorisierende Anweisungen, prüfen den Anteil der Ladeanweisungen und bestrafen nur, wenn der Anteil den durch diesen Parameter festgelegten Schwellwert überschreitet. Der Standardwert ist 45.

en: When costing for loop vectorization, we probably need to penalize the loop body cost if the existing cost model may not adequately reflect delays from unavailable vector resources.  We collect the cost for vectorized statements and non-vectorized statements separately, check the proportion of vec_cost to total cost of vec_cost and non vec_cost, and penalize only if the proportion exceeds the threshold specified by this parameter.  The default value is 85.
de: Bei der Kostenkalkulation für die Vektorisierung von Schleifen müssen wahrscheinlich die Kosten für den Schleifenkörper bestraft werden, wenn das bestehende Kostenmodell Verzögerungen durch nicht verfügbare Vektorressourcen nicht angemessen widerspiegelt. Die Kosten für vektorisierte Anweisungen und nicht-vektorisierte Anweisungen werden getrennt gesammelt, und die Bestrafung erfolgt nur, wenn das Verhältnis von vec_cost zu (vec_cost + nicht-vec_cost) den durch diesen Parameter festgelegten Schwellenwert überschreitet. Der Standardwert ist 85.

en: When generating -fpic code, allow the use of PLTs. Ignored for fno-pic.
de: Bei Erzeugung von »-fpic«-Code den ausführbaren Dateien erlauben, PLTs zu verwenden. Ignoriert für »-fno-pic«.

en: When generating -mabicalls code, allow executables to use PLTs and copy relocations.
de: Bei Erzeugung von »-mabicalls«-Code den ausführbaren Dateien erlauben, PLTs und Kopierauslagerungen zu verwenden.

en: When generating -mabicalls code, make the code suitable for use in shared libraries.
de: Bei Erzeugung von -mabicalls den Code tauglich für gemeinsam genutzte Bibliotheken machen.

en: When linking for big-endian targets, generate a BE8 format image.
de: Beim Binden für Big-Endian-Zielsysteme ein Abbild im BE8-Format erzeugen.

en: When linking for big-endian targets, generate a legacy BE32 format image.
de: Beim Binden für Big-Endian-Zielsysteme ein Abbild im veralteten BE32-Format erzeugen.

en: When possible do not generate stack frames.
de: Wenn möglich, keine Stapelrahmen erzeugen.

en: When propagating IPA-CP effect estimates, multiply frequencies of recursive edges that bring back an unchanged value by this factor.
de: Bei der Weitergabe von IPA-CP-Effektschätzungen werden die Häufigkeiten der rekursiven Kanten, die einen unveränderten Wert zurückbringen, mit diesem Faktor multipliziert.

en: When running CSE, follow jumps to their targets.
de: Beim Durchlaufen von CSE: Sprüngen zu ihren Zielen folgen.

en: When using profile feedback, use the edge at this percentage position in frequncy histogram as the bases for IPA-CP heuristics.
de: Bei der Verwendung von Profil-Feedback wird die Kante an dieser prozentualen Position im Frequenzhistogramm als Grundlage für die IPA-CP-Heuristik verwendet.

en: When vectorizing for SVE, consider using unpacked vectors for smaller elements and use the cost model to pick the cheapest approach.  Also use the cost model to choose between SVE and Advanced SIMD vectorization.
de: Bei der Vektorisierung für SVE ungepackte Vektoren für kleinere Elemente in Betracht ziehen und das Kostenmodell verwenden, um den günstigsten Ansatz auszuwählen. Das Kostenmodell wählt außerdem zwischen SVE und Advanced SIMD-Vektorisierung.

en: Where shorter, use canonicalized paths to systems headers.
de: Falls kürzer, kanonische Pfade zu System-Headern verwenden.

en: Whether codegen errors should be ICEs when -fchecking.
de: Ob bei -fchecking Fehler im Codegenerator als interne Compilerfehler behandelt werden sollen.

en: Whether software prefetch hints should be issued for non-constant strides.
de: Ob Software-Prefetch-Tipps für nicht-konstante Schrittweiten produziert werden.

en: Whether to use canonical types.
de: Ob kanonische Typen zu verwenden sind.

en: Which -fsched-pressure algorithm to apply.
de: Anzuwendender Algorithmus für »-fsched-pressure«.

en: While setting up signal handler: %m
de: Während des Setzens des Signalhandlers: %m

en: While setting up signal stack: %m
de: Während des Setzens des Signalstapels: %m

en: Whole program analysis (WPA) mode with number of parallel jobs specified.
de: Modus für Ganzprogrammanalyse (WPA) mit Anzahl der parallelen Jobs angegeben.

en: With INSCAN at %L, expected loop body with !$OMP SCAN between two structured-block-sequences
de: Aufgrund des INSCAN bei %L wird ein Schleifenrumpf mit !$OMP SCAN zwischen zwei structured-block-sequences erwartet

en: Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape
de: Ohne Auffüllen gibt es nicht genügend Elemente in intrinsischer RESHAPE-Quelle bei %L, um zur Form zu passen

en: Work around VR4130 mflo/mfhi errata.
de: Errata für VR4130 mflo/mfhi umgehen.

en: Work around a hardware anomaly by adding a number of NOPs before a CSYNC or SSYNC instruction.
de: Hardwarebesonderheit umgehen, indem jedem CSYNC und SSYNC mehrere NOPs vorangestellt werden.

en: Work around an early 4300 hardware bug.
de: Einen frühen 4300-Hardware-Bug umgehen.

en: Work around bug in multiplication instruction.
de: Fehler in Multiplikationsbefehl umgehen.

en: Work around certain 24K errata.
de: Bestimmte 24K-Errata umgehen.

en: Work around certain R10000 errata.
de: Bestimmte R10000-Errata umgehen.

en: Work around certain R4000 errata.
de: Bestimmte R4000-Errata umgehen.

en: Work around certain R4400 errata.
de: Bestimmte R4400-Errata umgehen.

en: Work around certain RM7000 errata.
de: Bestimmte RM7000-Errata umgehen.

en: Work around certain VR4120 errata.
de: Bestimmte VR4120-Errata umgehen.

en: Work around errata for early SB-1 revision 2 cores.
de: Fehler früher SB-1 Revision 2 Kerne umgehen.

en: Work around hardware multiply bug.
de: Hardware-Multiplikationsfehler umgehen.

en: Work around the R5900 short loop erratum.
de: Workaround für R5900-Kurzschleifenfehler.

en: Workaround for ARM Cortex-A53 Erratum number 835769.
de: Umgehung von Erratum 835769 für ARM-Cortex-A53.

en: Workaround for ARM Cortex-A53 Erratum number 843419.
de: Umgehung von Erratum 843419 für ARM-Cortex-A53.

en: Wrap all indirect branches into execute in order to disable branch prediction.
de: Alle indirekten Sprünge mit execute-in-order umschließen, um Sprungvorhersage auszuschalten.

en: Wrap all indirect calls into execute in order to disable branch prediction.
de: Alle indirekten Aufrufe mit execute-in-order umschließen, um Sprungvorhersage auszuschalten.

en: Wrap all indirect return branches into execute in order to disable branch prediction.
de: Alle indirekten Rücksprünge mit execute-in-order umschließen, um Sprungvorhersage auszuschalten.

en: Wrap indirect return branches into execute in order to disable branch prediction. This affects only branches where the return address doesn't need to be restored from memory.
de: Alle indirekten Rücksprünge mit execute-in-order umschließen, um Sprungvorhersage auszuschalten. Dies betrifft nur Zweige, in denen die Rücksprungadresse nicht aus dem Speicher wiederhergestellt wird.

en: Wrap indirect return branches into execute in order to disable branch prediction. This affects only branches where the return address is going to be restored from memory.
de: Alle indirekten Rücksprünge mit execute-in-order umschließen, um Sprungvorhersage auszuschalten. Dies betrifft nur Zweige, in denen die Rücksprungadresse aus dem Speicher wiederhergestellt wird.

en: Wrap indirect table jumps and computed gotos into execute in order to disable branch prediction.  Using thunk or thunk-extern with this option requires the thunks to be considered signal handlers to order to generate correct CFI.  For environments where unwinding (e.g. for exceptions) is required please use thunk-inline instead.
de: Alle indirekten Tabellensprünge und berechnete Gotos mit execute-in-order umschließen, um Sprungvorhersage auszuschalten. Die Verwendung von thunk oder thunk-extern mit dieser Option erfordert, dass die Thunks als Signalhandler betrachtet werden, um korrekte CFI zu erzeugen. Für Umgebungen, in denen Abrollen erforderlich ist (beispielsweise für Ausnahmebehandlung), nutzen Sie stattdessen bitte thunk-inline.

en: Write a SRCFILE.opt-record.json file detailing what optimizations were performed.
de: Eine QUELLDATEI.opt-record.json schreiben mit Details, welche Optimierungen durchgeführt wurden.

en: Write all declarations as Ada code for the given file only.
de: Alle Deklarationen in Ada-Code nur für angegebene Datei schreiben.

en: Write all declarations as Ada code transitively.
de: Alle Deklarationen in Ada-Code transitiv schreiben.

en: Writing module %qs at line %d column %d: %s
de: Modul %qs in Zeile %d, Spalte %d wird geschrieben: %s

en: Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP
de: Falsche OpenACC-Fortsetzung bei %C: !$ACC erwartet, !$OMP gefunden

en: Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC
de: Falsche OpenMP-Fortsetzung bei %C: !$OMP erwartet, !$ACC gefunden

en: X argument at %L to C_LOC shall not be polymorphic
de: X-Argument bei %L für C_LOC darf nicht polymorph sein

en: X descriptor requires leading space count at %L
de: X-Deskriptor erfordert führenden Leerzeichenzähler bei %L

en: X32 does not support %<ms_abi%> attribute
de: X32 unterstützt %<ms_abi%>-Attribut nicht

en: XNACK support
de: XNACK-Unterstützung

en: XXX entering %<pop_everything ()%>
de: XXX %<pop_everything%> wird betreten

en: XXX leaving %<pop_everything ()%>
de: XXX %<pop_everything%> wird verlassen

en: You must enable MVE instructions to use these intrinsics
de: Um diese intrinsischen Funktionen zu verwenden, müssen Sie MVE-Befehle einschalten.

en: You must enable NEON instructions (e.g. %<-mfloat-abi=softfp%> %<-mfpu=neon%>) to use these intrinsics.
de: Um diese intrinsischen Funktionen zu verwenden, müssen Sie NEON-Befehle einschalten (zum Beispiel mit %<-mfloat-abi=softfp -mfpu=neon%>).

en: You must enable VFP instructions to use these intrinsics.
de: Um diese intrinsischen Funktionen zu verwenden, müssen Sie VFP-Befehle einschalten.

en: You must enable crypto instructions (e.g. include %<-mfloat-abi=softfp%> %<-mfpu=crypto-neon%>) to use these intrinsics.
de: Um diese intrinsischen Funktionen zu verwenden, müssen Sie Krypto-Befehle einschalten (zum Beispiel mit %<-mfloat-abi=softfp -mfpu=crypto-neon%>)

en: You need a C startup file for -msys-crt0=
de: Option »-msys-crt0=« erwartet eine C-Programmstart-Datei

en: Zero is not a valid statement label at %C
de: Null ist keine gültige Anweisungsmarke bei %C

en: Zero width in format descriptor in format string at %L
de: Breite null in Formatbeschreibung in Formatzeichenkette bei %L

en: Zero-sized array detected at %L where an entity with the TARGET attribute is expected
de: Array der Größe 0 bei %L gefunden, an dieser Stelle wird eine Entität mit TARGET-Attribut erwartet

en: [...]
de: […]

en: [...] style array constructors at %C
de: Feldkonstruktoren im [...]-Stil bei %C

en: [Leaving %s]
de: [%s wird verlassen]

en: [available in
de: [verfügbar in

en: [cannot find %s]
de: [%s kann nicht gefunden werden]

en: [default]
de: [Standard]

en: [disabled]
de: [ausgeschaltet]

en: [enabled]
de: [eingeschaltet]

en: `
de: »

en: a %<return%> statement is not allowed in coroutine; did you mean %<co_return%>?
de: eine %<return%>-Anweisung ist in einer Koroutine nicht erlaubt; meinten Sie %<co_return%>?

en: a GNU Fortran extension
de: eine GNU-Fortran-Erweiterung

en: a brace-enclosed initializer is not allowed here
de: eine geschweift geklammerte Initialisierung ist hier nicht erlaubt

en: a call to a constructor cannot appear in a constant-expression
de: ein Konstruktoraufruf kann nicht in einem Konstanten-Ausdruck auftreten

en: a cast to a type other than an integral or enumeration type cannot appear in a constant-expression
de: Eine Typumwandlung, die weder zu ganzzahligen noch Aufzählungstypen führt, kann nicht in einem Konstantenausdruck auftreten

en: a class template declaration must not declare anything else
de: eine Klassen-Templatedeklaration darf nichts anderes deklarieren

en: a comma operator cannot appear in a constant-expression
de: ein Komma-Operator kann nicht in einem Konstanten-Ausdruck auftreten

en: a concept cannot be a member function
de: ein Konzept kann keine Elementfunktion sein

en: a concept cannot be constrained
de: ein Konzept kann nicht eingeschränkt werden

en: a constructor cannot be %<concept%>
de: ein Konstruktor kann nicht %<concept%> sein

en: a conversion function cannot have a trailing return type
de: eine Umwandlungsfunktion darf keinen angehängten Rückgabetyp haben

en: a destructor cannot be %qs
de: ein Destruktor kann nicht %qs sein

en: a different type is defined in another translation unit
de: ein unterschiedlicher Typ ist in einer anderen Übersetzungseinheit definiert

en: a field of same name but different type is defined in another translation unit
de: ein Feld mit selbem Namen aber unterschiedlichem Typ ist in einer anderen Übersetzungseinheit definiert

en: a field with different name is defined in another translation unit
de: ein Feld mit unterschiedlichem Namen ist in einer anderen Übersetzungseinheit definiert

en: a function call cannot appear in a constant-expression
de: ein Funktionsaufruf kann nicht in einem Konstanten-Ausdruck auftreten

en: a function concept cannot be constrained
de: ein Funktionskonzept kann nicht eingeschränkt werden

en: a function-definition is not allowed here
de: eine Funktionsdefinition ist hier nicht erlaubt

en: a label can only be part of a statement and a declaration is not a statement
de: eine Marke kann nur Teil einer Anweisung sein, und eine Deklaration ist keine Anweisung

en: a lambda closure type has a deleted copy assignment operator
de: Lambda-Abschlusstyp hat gelöschten Kopier-Zuweisungsoperator

en: a lambda closure type has a deleted default constructor
de: Lambda-Abschlusstyp hat gelöschten Standardkonstruktor

en: a later %<-fabi-version=%> (or =0) avoids this error with a change in mangling
de: Eine spätere Option %<-fabi-version=%> (oder =0) verhindert diesen Fehler mit einer Änderung im Mangeln

en: a member of a structure or union cannot have a variably modified type
de: Ein Element einer Struktur oder Union kann nicht variabel modifizierten Typ haben

en: a nested function is not supported for reduced registers
de: geschachtelte Funktionen werden bei reduzierter Registeranzahl nicht unterstützt

en: a nested namespace definition cannot be inline
de: eine verschachtelte Namensraumdefinition darf nicht inline sein

en: a nested namespace definition cannot have attributes
de: eine verschachtelte Namensraum-Definition darf keine Attribute haben

en: a non-template variable cannot be %<concept%>
de: eine Nicht-Template-Variable kann nicht %<concept%> sein

en: a parameter cannot be declared %qs
de: ein Parameter kann nicht als %qs deklariert sein

en: a parameter list with an ellipsis cannot match an empty parameter name list declaration
de: eine Parameterliste mit Auslassung kann nicht zu einer leeren Parameternamenslistendeklaration passen

en: a statement expression is an insufficient context for overload resolution
de: ein Anweisungsausdruck reicht nicht als Kontext für Überladungs-Auflösung nicht aus

en: a storage class can only be specified for objects and functions
de: eine Speicherklasse kann nur für Objekte und Funktionen angegeben werden

en: a storage class on an anonymous aggregate in class scope is not allowed
de: Speicherklasse an anonymem Aggregat im Klassenbereich ist nicht erlaubt

en: a template cannot be defaulted
de: ein Template kann nicht vorbelegt werden

en: a template declaration cannot appear at block scope
de: eine Template-Deklaration kann nicht im Block-Gültigkeitsbereich auftreten

en: a template-id may not appear in a using-declaration
de: eine Template-ID darf nicht in »using«-Deklaration auftreten

en: a temporary bound to %qD only persists until the constructor exits
de: eine vorübergehende Bindung an %qD besteht nur, bis der Konstruktor beendet ist

en: a transaction expression cannot appear in a constant-expression
de: ein Transaktionsausdruck kann nicht in einem Konstanten-Ausdruck auftreten

en: a type defined in another translation unit is not polymorphic
de: ein Typ aus einer anderen Übersetzungseinheit ist nicht polymorph

en: a type defined in another translation unit is polymorphic
de: ein Typ aus einer anderen Übersetzungseinheit ist polymorph

en: a type with different bases is defined in another translation unit
de: ein Typ mit unterschiedlichen Basistypen ist in einer anderen Übersetzungseinheit definiert

en: a type with different number of fields is defined in another translation unit
de: ein Typ mit unterschiedlicher Anzahl von Feldern ist in einer anderen Übersetzungseinheit definiert

en: a type with different precision is defined in another translation unit
de: ein Typ mit unterschiedlicher Genauigkeit ist in einer anderen Übersetzungseinheit definiert

en: a type with different signedness is defined in another translation unit
de: ein Typ mit unterschiedlichem Vorzeichen ist in einer anderen Übersetzungseinheit definiert

en: a type with different size is defined in another translation unit
de: ein Typ mit unterschiedlicher Größe ist in einer anderer Übersetzungseinheit definiert

en: a type with different virtual table pointers is defined in another translation unit
de: ein Typ mit unterschiedlichen Zeigern in der virtuellen Tabelle ist in einer anderen Übersetzungseinheit definiert

en: a variable cannot be declared %<consteval%>
de: eine Variable kann nicht als %<consteval%> deklariert sein

en: a variable concept cannot be constrained
de: ein Variablenkonzept kann nicht eingeschränkt werden

en: a wide string is invalid in this context
de: eine Wide-Zeichenkette ist in diesem Kontext ungültig

en: abnormal call edges for non-call insn in bb %i
de: Interner Fehler: abnormal call edges for non-call insn in bb %i

en: abnormal edges for no purpose in bb %i
de: Interner Fehler: abnormal edges for no purpose in bb %i

en: abort in %s, at %s:%d
de: Abbruch in %s, bei %s:%d

en: absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value
de: die Betragsfunktion %qD bekommt hier ein Argument vom Typ %qT, erwartet jedoch einen Parameter vom Typ %qT; dadurch kann der übergebene Wert abgeschnitten werden

en: abstract declarator %qT used as declaration
de: abstrakter Deklarator %qT als Deklaration verwendet

en: access declarations are deprecated in favour of using-declarations; suggestion: add the %<using%> keyword
de: Zugriffsdeklarationen sind zugunsten von %<using%>-Deklarationen veraltet; Vorschlag: %<using%> hinzufügen

en: accessing %E byte in a region of size %E
de: Code greift auf %E Byte in einer Region der Größe %E zu

en: accessing %E bytes in a region of size %E
de: Code greift auf %E Bytes in einer Region der Größe %E zu

en: accessing %E or more bytes in a region of size %E
de: Code greift auf %E oder mehr Bytes in einer Region der Größe %E zu

en: accessing %qD member instead of initialized %qD member in constant expression
de: Zugriff auf Element %qD statt auf initialisiertes Element %qD in Konstantenausdruck

en: accessing a member %qE of an atomic structure %qE
de: Zugriff auf ein Element %qE einer atomaren Struktur %qE

en: accessing a member %qE of an atomic union %qE
de: Zugriff auf ein Element %qE einer atomaren Union %qE

en: accessing argument %u of a function declared with attribute %<%s%>
de: beim Zugriff auf Argument %u einer Funktion, die mit dem Attribut %qs deklariert wurde

en: accessing between %E and %E bytes in a region of size %E
de: Code greift auf zwischen %E und %E Bytes in einer Region der Größe %E zu

en: accessing data memory with program memory address
de: Zugriff auf Datenspeicher mit Programmspeicheradresse

en: accessing program memory with data memory address
de: Zugriff auf Programmspeicher mit Datenspeicheradresse

en: accessing thread-local storage is not currently supported with %<-mpure-code%> or %<-mslow-flash-data%>
de: Zugriff auf threadlokalen Speicher wird derzeit mit %<-mpure-code%> oder %<-mslow-flash-data%> nicht unterstützt

en: accessing uninitialized array element
de: Zugriff auf uninitialisiertes Arrayelement

en: accessing uninitialized member %qD
de: Zugriff auf uninitialisiertes Element %qD

en: accessing value of %qE through a %qT glvalue in a constant expression
de: auf Wert von %qE wird über ein %qT GL-Wert in Konstantenausdruck zugegriffen

en: accumulator is not a constant integer
de: Akkumulator ist keine Ganzzahlkonstante

en: accumulator number is out of bounds
de: Akkumulatorzahl außerhalb der Grenzen

en: actual argument to INTENT = OUT/INOUT
de: effektives Argument für INTENT = OUT/INOUT

en: add %<using namespace std::complex_literals%> (from %<<complex>%>) to enable the C++14 user-defined literal suffixes
de: fügen Sie %<using namespace std::complex_literals%> (aus %<<complex>%>) hinzu, um benutzerdefinierte Literalsuffixe aus C++14 einzuschalten

en: add a deduction guide to suppress this warning
de: fügen Sie einen Herleitungshinweis hinzu, um diese Warnung zu unterdrücken

en: add explicit %<this%> or %<*this%> capture
de: fangen Sie %<this%> oder %<*this%> explizit ein

en: add parentheses around %qE to silence this warning
de: klammern Sie den Ausdruck %qE, um diese Warnung zu unterdrücken

en: add parentheses around left hand side expression to silence this warning
de: klammern Sie den Ausdruck auf der linken Seite ein, um diese Warnung zu beheben

en: add parentheses around the second %<sizeof%> to silence this warning
de: klammern Sie den zweiten %<sizeof%>-Ausdruck, um diese Warnung zu unterdrücken

en: add parentheses to declare a variable
de: fügen Sie Klammern hinzu, um eine Variable zu deklarieren

en: add_sym(): Bad sizing mode
de: Interner Fehler: add_sym(): Bad sizing mode

en: adding %<-flarge-source-files%> will allow for more column-tracking support, at the expense of compilation time and memory
de: die Option %<-flarge-source-files%> erlaubt mehr Unterstützung für Spaltenverfolgung, braucht dafür jedoch mehr Zeit und Speicher beim Compilieren

en: additional enumerators beginning with %qD
de: zusätzliche Aufzählungswerte, die mit %qD beginnen

en: address area attribute cannot be specified for functions
de: Adressbereichsattribut kann nicht für Funktionen angegeben werden

en: address area of %q+D conflicts with previous declaration
de: Adressbereich von %q+D in Konflikt mit vorheriger Deklaration

en: address mode %qs not supported in the %s bit mode
de: Adressmodus %qs wird im %s-Bit-Modus nicht unterstützt

en: address of a call to %qs is not a constant expression
de: Adresse des Aufrufs von %qs ist kein konstanter Ausdruck

en: address of array with reverse scalar storage order requested
de: Adresse eines Arrays mit umgekehrter Speicherreihenfolge angefordert

en: address of explicit register variable %qD requested
de: Adresse der Register-Variablen %qD angefordert

en: address of global register variable %qD requested
de: Adresse der globalen Variablen %qD angefordert

en: address of label %qD returned
de: Adresse der lokalen Variable %qD zurückgegeben

en: address of local variable %qD returned
de: Adresse der lokalen Variable %qD zurückgegeben

en: address of overloaded function with no contextual type information
de: Adresse einer überladenen Funktion ohne Typinformationen aus Kontext

en: address of register variable %qD requested
de: Adresse der Register-Variablen %qD angefordert

en: address offset not a constant
de: Adressversatz ist keine Konstante

en: address operand requires constraint for X, Y, or Z register
de: Adressoperand erfordert Beschränkung für X-, Y- oder Z-Register

en: address requested for %qD, which is declared %<register%>
de: Adresse für %qD angefordert, was als %<register%> deklariert ist

en: address space %qs not supported for devices with flash size up to %d KiB
de: Adressraum %qs wird auf Geräten mit Flashspeicher bis zu %d KiB nicht unterstützt

en: address spaces are not supported for reduced Tiny devices
de: Adressräume werden auf reduzierten Tiny-Kernen nicht unterstützt

en: address taken but %<TREE_ADDRESSABLE%> bit not set
de: Adresse genommen, aber %<TREE_ADDRESSABLE%>-Bit nicht gesetzt

en: address taken, but ADDRESSABLE bit not set
de: Adresse genommen, aber ADDRESSABLE-Bit nicht gesetzt

en: address-of an object %qE with thread local or automatic storage is not a constant expression
de: Adresse eines Objektes %qE mit thread-lokalem oder automatischem Speicher ist kein konstanter Ausdruck

en: aggregate %q#D has incomplete type and cannot be defined
de: Aggregat %q#D hat unvollständigen Typ und kann nicht definiert werden

en: aggregate types are prohibited in %<__regio_symbol%> address space
de: Aggregatstypen sind im %<__regio_symbol%>-Adressraum verboten

en: aggregate value used where a complex was expected
de: zusammengesetzter Wert verwendet, wo »complex« erwartet wurde

en: aggregate value used where a fixed-point was expected
de: zusammengesetzten Wert verwendet, wo Festkomma erwartet wurde

en: aggregate value used where a floating-point was expected
de: zusammengesetzter Wert verwendet, wo Gleitkommawert erwartet wurde

en: aggregate value used where an integer was expected
de: zusammengesetzter Wert verwendet, wo Ganzzahl erwartet wurde

en: aka
de: alias

en: alias definitions not supported in Mach-O; ignored
de: Alias-Definitionen werden nicht in Mach-O unterstützt; ignoriert

en: alias definitions not supported in this configuration
de: Alias-Definitionen werden in dieser Konfiguration nicht unterstützt

en: alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>
de: Alias-Template-Herleitung ist erst ab %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>
de: Alias-Deklaration in Init-Anweisung ist erst mit %<-std=c++23%> oder %<-std=gnu++23%> verfügbar

en: aliased declaration here
de: hier ist die Alias-Deklaration

en: alignment %u of %qT is less than %u
de: verlangte Ausrichtung %u von %qT ist kleiner als %u

en: alignment may not be specified for %q+D
de: Für %q+D darf keine Ausrichtung angegeben werden

en: alignment must be a small power of two, not %d
de: Ausrichtung muss eine kleine Zweierpotenz sein, nicht %d

en: alignment of %q+D is greater than maximum object file alignment %d
de: Ausrichtung von %q+D ist größer als maximale Objektdateiausrichtung %d

en: alignment of %qD increased in %<-fabi-version=9%> (GCC 5.2)
de: Ausrichtung von %qD wurde in %<-fabi-version=9%> (GCC 5.2) erhöht

en: alignment of %qD is bigger than original declaration
de: Ausrichtung von %qD ist größer als ursprüngliche Deklaration

en: alignment of %qD will increase in %<-fabi-version=9%>
de: Ausrichtung von %qD wird in %<-fabi-version=9%> ansteigen

en: alignment of array elements is greater than element size
de: Ausrichtung der Arrayelemente ist größer als die Elementgröße

en: alignment specified for %<register%> object %qE
de: Ausrichtung für %<register%>-Objekt %qE angegeben

en: alignment specified for bit-field %qE
de: Ausrichtung für Bitfeld %qE angegeben

en: alignment specified for function %qE
de: Ausrichtung für Funktion %qE angegeben

en: alignment specified for parameter %qE
de: Ausrichtung für Parameter %qE angegeben

en: alignment specified for type name in %<sizeof%>
de: Ausrichtung für Typnamen in %<sizeof%> angegeben

en: alignment specified for type name in %qE
de: Ausrichtung für Typnamen in %qE angegeben

en: alignment specified for type name in cast
de: Ausrichtung für Typnamen in Cast angegeben

en: alignment specified for typedef %qE
de: Ausrichtung für typedef %qE angegeben

en: alignment specified for unnamed bit-field
de: Ausrichtung für unbenanntes Bitfeld angegeben

en: alignment specified for unnamed parameter
de: Ausrichtung für unbenannten Parameter angegeben

en: all member functions in class %qT are private
de: alle Elementfunktionen in Klasse %qT sind privat

en: all template parameters of %qD must be introduced
de: alle Template-Parameter von %qD müssen eingeführt sein

en: allocatable argument
de: allozierbares Argument

en: allocated here
de: wurde hier deklariert

en: allocation performed here
de: die Allokation ist hier

en: already captured %qD in lambda expression
de: %qD bereits in Lambda-Ausdruck erfasst

en: also found %<%c%s%>
de: auch %<%c%s%> gefunden

en: alternatives not allowed in %<asm%> flag output
de: Alternativen sind in %<asm%>-Flag-Ausgabe nicht erlaubt

en: ambiguating new declaration %q+#D
de: mehrdeutig machende neue Deklaration %q+#D

en: ambiguating new declaration of %q#D
de: macht neue Deklaration %q#D mehrdeutig

en: ambiguous attribute '%s'; could be '%s' (via '%s:%s') or '%s' (via '%s:%s')
de: mehrdeutiges Attribut »%s«; könnte »%s« (via »%s:%s«) oder »%s« (via »%s:%s«) sein

en: ambiguous conversion for array subscript
de: mehrdeutige Umwandlung für Feldindex

en: ambiguous default type conversion from %qT
de: mehrdeutige Standard-Typumwandlung von %qT

en: ambiguous method %s%s%s
de: mehrdeutige Methode %s%s%s

en: ambiguous overload for
de: mehrdeutiges Überladen für

en: ambiguous overload for intrinsic %qs
de: mehrdeutiges Überladen für intrinsisches %qs

en: ambiguous template instantiation for %q#D
de: mehrdeutige Template-Instanziierung für %q#D

en: ambiguous template instantiation for %q#T
de: mehrdeutige Template-Instanziierung für %q#T

en: ambiguous template specialization %qD for %q+D
de: mehrdeutige Templatespezialisierung %qD für %q+D

en: an %<asm%> specification is not allowed on a function-definition
de: eine %<asm%>-Spezifikation ist bei Funktionsdefinition nicht erlaubt

en: an address area attribute cannot be specified for local variables
de: für lokale Variablen kann kein Adressbereichsattribut angegeben werden

en: an argument type that has a default promotion cannot match an empty parameter name list declaration
de: ein Argumenttyp mit Standard-Promotion kann nicht zu einer leeren Parameternamenslistendeklaration passen

en: an array of different size is defined in another translation unit
de: ein Array unterschiedlicher Größe ist in einer anderen Übersetzungseinheit definiert

en: an array reference cannot appear in a constant-expression
de: eine Arrayreferenz kann nicht in einem Konstanten-Ausdruck auftreten

en: an assignment cannot appear in a constant-expression
de: eine Zuweisung kann nicht in einem Konstanten-Ausdruck auftreten

en: an attribute that appertains to a friend declaration that is not a definition is ignored
de: ein Attribut, das zu einer »friend«-Deklaration gehört, die keine Definition ist, wird ignoriert

en: an attribute that appertains to a type-specifier is ignored
de: ein Attribut, das sich auf eine Typspezifizierung bezieht, wird ignoriert

en: an decrement cannot appear in a constant-expression
de: eine Verringerung kann nicht in einem Konstanten-Ausdruck auftreten

en: an empty string cannot be in %<target_clones%> attribute
de: das Attribut %<target_clones%> darf keine leere Zeichenkette enthalten

en: an enum with different number of values is defined in another translation unit
de: eine Aufzählung mit anderer Anzahl von Werten ist in einer anderen Übersetzungseinheit definiert

en: an enum with different value name is defined in another translation unit
de: eine Aufzählung mit unterschiedlichen Wertnamen ist in einer anderen Übersetzungseinheit definiert

en: an enum with different values is defined in another translation unit
de: eine Aufzählung mit anderen Werten ist in einer anderen Übersetzungseinheit definiert

en: an explicit specialization must be preceded by %<template <>%>
de: einer expliziten Spezialisierung muss %<template <>%> vorausgehen

en: an explicit type suffix is needed when using a vector of base addresses
de: ein explizites Typensuffix ist erforderlich, wenn ein Vektor von Basisadressen verwendet wird

en: an increment cannot appear in a constant-expression
de: eine Erhöhung kann nicht in einem Konstanten-Ausdruck auftreten

en: an indirect edge from %s has no corresponding call_stmt
de: Interner Fehler: an indirect edge from %s has no corresponding call_stmt

en: an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:
de: Interner Fehler: an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:

en: an interrupt handler cannot be compiled with %<-muser-mode%>
de: Ein Interrupt-Handler kann nicht mit %<-muser-mode%> kompiliert werden

en: anachronism
de: Anachronismus

en: anachronism:
de: Anachronismus:

en: anachronistic old-style base class initializer
de: veraltete Basisklasseninitialisierung

en: and %qT has no template constructors
de: und %qT hat keinen Template-Konstruktor

en: and field
de: Interner Compilerfehler: and field

en: and the implicitly-defined constructor does not initialize %q#D
de: und der implizit definierte Konstruktor initialisiert %q#D nicht

en: anonymous %s declared inside parameter list will not be visible outside of this definition or declaration
de: das innerhalb der Parameterliste deklarierte anonyme »%s« ist außerhalb dieser Definition oder Deklaration nicht sichtbar

en: anonymous SSA name cannot have default definition
de: Interner Fehler: anonymous SSA name cannot have default definition

en: anonymous struct not inside named type
de: anonymes struct nicht innerhalb eines benannten Typs

en: anonymous struct with base classes
de: anonyme Struktur mit Basisklassen

en: anonymous union with no members
de: anonyme Union ohne Element

en: applying %<#pragma weak %+D%> after first use results in unspecified behavior
de: Anwendung von %<#pragma weak %+D%> nach erster Verwendung führt zu unspezifiziertem Verhalten

en: arch extension %<%s%> should be prefixed by %<+%>
de: der Arch-Erweiterung %qs sollte ein %<+%> vorangestellt werden

en: architecture %qs supported for assembler only
de: Architektur %qs wird nur für Assemblierung unterstützt

en: argument %d is an unsigned literal that is out of range
de: Argument %d ist ein vorzeichenloses Literal, aber außerhalb des gültigen Bereichs

en: argument %d must be a constant immediate
de: Argument %d muss eine direkt angegebene Konstante sein

en: argument %d must be a constant immediate in range [0,15]
de: Argument %d muss eine direkt angegebene Konstante im Bereich [0, 15] sein

en: argument %d must be a literal between %d and %d, inclusive
de: Argument %d muss ein Literal zwischen %d und %d sein

en: argument %d must be a literal between 0 and %d, inclusive
de: Argument %d muss ein Literal zwischen 0 und %d sein

en: argument %d must be a variable or a literal between %d and %d, inclusive
de: Argument %d muss eine Variable oder ein Literal zwischen %d und %d sein

en: argument %d must be an unsigned literal
de: Argument %d muss ein vorzeichenloses Literal sein

en: argument %d must be either a literal %d or a literal %d
de: Argument %d muss entweder eine literale %d oder eine literale %d sein

en: argument %d of %qE discards %<const%> qualifier
de: Argument %d von %qE entfernt Kennzeichner %<const%>

en: argument %d of %qE discards %<volatile%> qualifier
de: Argument %d von %qE entfernt Kennzeichner %<volatile%>

en: argument %d of %qE might be a candidate for a format attribute
de: Argument %d von %qE könnte Kandidat für Formatattribut sein

en: argument %d of %qE must be a pointer to a constant size type
de: Argument %d von %qE muss ein Zeiger auf Typen konstanter Größe sein

en: argument %d of %qE must be a pointer type
de: Argument %d von %qE muss eine Zeigertyp sein

en: argument %d of %qE must be an integer constant expression
de: Argument %d von %qE muss ein konstanter ganzzahliger Ausdruck sein

en: argument %d of %qE must not be a pointer to a %<const%> type
de: Argument %d von %qE darf kein Zeiger auf einen %<const%>-Typen sein

en: argument %d of %qE must not be a pointer to a %<volatile%> type
de: Argument %d von %qE darf kein Zeiger auf einen %<volatile%>-Typen sein

en: argument %d of %qE must not be a pointer to a function
de: Argument %d von %qE darf kein Zeiger auf eine Funktion sein

en: argument %d of '%s' did not have the expected name
de: Argument %d von »%s« hatte nicht den erwarteten Namen

en: argument %d to %qE must be a constant immediate in range [0-%d]
de: Argument %d von %qE muss eine direkt angegebene Konstante im Bereich [0-%d] sein

en: argument %d to the built-in must be a constant in range %d to %d
de: Argument %d der eingebauten Funktion muss eine Konstante aus dem Bereich %d bis %d sein

en: argument %i in the range [%E, %E]
de: Argument %i im Bereich [%E, %E]

en: argument %i is null but the corresponding size argument %i value is %s
de: Argument %i ist null, aber der Wert des zugehörigen Größenarguments %i ist %s

en: argument %i of variable length array %s is null but the corresponding bound argument %i value is %s
de: Argument %i des Arrays variabler Länge %s ist null, aber der Wert des zugehörigen verbundenen Arguments %i ist %s

en: argument %i range [%E, %E] exceeds maximum object size %E
de: Argument %i Bereich [%E, %E] übersteigt maximale Objektgröße %E

en: argument %i range [%E, %E] is negative
de: Argument %i Bereich [%E, %E] ist negativ

en: argument %i to %<%T[static %E]%> is null where non-null expected
de: Argument %i von %<%T[static %E]%> ist null, aber nicht-null wird erwartet

en: argument %i value %qE exceeds maximum object size %E
de: Argument %i Wert %qE übersteigt maximale Objektgröße %E

en: argument %i value %qE is negative
de: Argument %i Wert %qE ist negativ

en: argument %i value %s is negative
de: Argument %i Wert %s ist negativ

en: argument %i value is zero
de: Argument %i Wert ist null

en: argument %q+D might be clobbered by %<longjmp%> or %<vfork%>
de: Argument %q+D könnte von %<longjmp%> oder %<vfork%> zerstört werden

en: argument %qD declared here
de: Argument %qD ist hier deklariert

en: argument %qD doesn%'t match built-in prototype
de: Argument %qD passt nicht zu eingebautem Prototypen

en: argument %qD doesn%'t match prototype
de: Argument %qD passt nicht zum Prototypen

en: argument %qE
de: Argument %qE

en: argument %qT
de: Argument %qT

en: argument %qd is not a constant
de: Argument %qd ist keine Konstante

en: argument %qs to %<-Waligned-new%> not recognized
de: Argument %qs für %<-Waligned-new%> nicht bekannt

en: argument %qs to %<-Wbidi-chars%> not recognized
de: Argument %qs für %<-Wbidi-chars%> nicht bekannt

en: argument %qs to %<-Wnormalized%> not recognized
de: Argument %qs für %<-Wnormalized%> nicht erkannt

en: argument %qs to %<-femit-struct-debug-detailed%> not recognized
de: Argument %qs für %<-femit-struct-debug-detailed%> nicht erkannt

en: argument %qs to %<-femit-struct-debug-detailed%> unknown
de: Argument %qs für %<-femit-struct-debug-detailed%> unbekannt

en: argument %u in call to function %qE does not have integral type
de: Argument %u in Aufruf von %qE muss ein Ganzzahltyp sein

en: argument %u in call to function %qE does not have pointer type
de: Argument %u in Aufruf von %qE muss ein Zeigertyp sein

en: argument %u in call to function %qE has pointer to %qs type (%qT)
de: Argument %u in Aufruf von %qE darf kein Zeiger auf %qs sein (%qT)

en: argument %u in call to function %qE has pointer to a non-trivially-copyable type (%qT)
de: Argument %u in Aufruf von %qE darf kein Zeiger auf nicht-trivial kopierbaren Typ %qT sein

en: argument %u in call to function %qE points to incomplete type
de: Argument %u in Aufruf von %qE muss auf einen vollständigen Typ zeigen

en: argument %u null where non-null expected
de: Argument %u ist null, aber nichtnull wird erwartet

en: argument %u of %<__builtin_tgmath%> has no arguments
de: Argument %u für %<__builtin_tgmath%> hat keine Argumente

en: argument %u of %<__builtin_tgmath%> has variable arguments
de: Argument %u für %<__builtin_tgmath%> hat variable Anzahl von Argumenten

en: argument %u of %<__builtin_tgmath%> has wrong number of arguments
de: Argument %u für %<__builtin_tgmath%> hat falsche Anzahl der Argumente

en: argument %u of %<__builtin_tgmath%> is not a function pointer
de: Argument %u für %<__builtin_tgmath%> ist kein Funktionszeiger

en: argument %u of %<__builtin_tgmath%> is unprototyped
de: Argument %u für %<__builtin_tgmath%> hat keinen Prototypen

en: argument %u of type %s declared as a pointer
de: Argument %u vom Typ %s ist als Zeiger deklariert

en: argument %u of type %s declared as a variable length array
de: Argument %u vom Typ %s ist als Array variabler Länge deklariert

en: argument %u of type %s declared as an ordinary array
de: Argument %u vom Typ %s ist als gewöhnliches Array deklariert

en: argument %u of type %s declared with %u unspecified variable bound | argument %u of type %s declared with %u unspecified variable bounds
de[0]: Argument %u vom Typ %s ist mit %u unspezifizierten Variablengrenze deklariert
de[1]: Argument %u vom Typ %s ist mit %u unspezifizierten Variablengrenzen deklariert

en: argument %u of type %s declared with %u variable bound | argument %u of type %s declared with %u variable bounds
de[0]: Argument %u vom Typ %s ist mit %u Variablengrenze deklariert
de[1]: Argument %u vom Typ %s ist mit %u Variablengrenzen deklariert

en: argument %u of type %s declared with mismatched bound %<%s%>
de: Argument %u vom Typ %s ist mit abweichender Grenze %<%s%> deklariert

en: argument %u of type %s declared with mismatched bound argument %E
de: Argument %u vom Typ %s ist mit abweichendem Grenzargument %E deklariert

en: argument %u of type %s with mismatched bound
de: Argument %u vom Typ %s mit abweichender Grenze

en: argument %u to function %qE is of type %qT which is not known to be 128 bits wide
de: Argument %u von Funktion %qE ist vom Typ %qT, und der ist nicht garantiert 128 Bit groß

en: argument 1 must be a map
de: Argument 1 muss eine Abbildung sein

en: argument 1 of %qE must be a non-void pointer type
de: Argument 1 von %qE muss ein Nicht-Void-Zeigertyp sein

en: argument 1 of %qE must be a pointer to a complete type
de: Argument 1 von %qE muss ein Zeiger auf einen vollständigen Typen sein

en: argument 1 of %qE must be a pointer to a constant size type
de: Argument 1 von %qE muss ein Zeiger auf Typen konstanter Größe sein

en: argument 1 of %qE must be a pointer to a nonzero size object
de: Argument 1 von %qE muss ein Zeiger auf Objekt breiter als Null sein

en: argument 1 of %qs is out of range
de: Argument 1 von %qs ist außerhalb des Wertebereiches

en: argument 1 of %qs must be a constant
de: Argument 1 von %qs muss eine Konstante sein

en: argument 3 in call to function %qE does not have pointer to integral type
de: Argument 3 in Aufruf von %qE muss Zeiger auf Ganzzahltyp sein

en: argument 3 in call to function %qE has boolean type
de: Argument 3 in Aufruf von %qE darf kein boolescher Typ sein

en: argument 3 in call to function %qE has enumerated type
de: Argument 3 in Aufruf von %qE darf kein enum-Typ sein

en: argument 3 in call to function %qE has pointer to boolean type
de: Argument 3 in Aufruf von %qE darf kein Zeiger auf booleschen Typ sein

en: argument 3 in call to function %qE has pointer to enumerated type
de: Argument 3 in Aufruf von %qE darf kein Zeiger auf enum-Typ sein

en: argument list function at %C
de: Argumentlistenfunktion bei %C

en: argument must be a 16-bit constant immediate
de: Argument muss eine direkt angegebene 16-Bit-Konstante sein

en: argument must be a field reference
de: Argument muss eine Feldreferenz sein

en: argument must be array or slice or channel
de: Argument muss Array oder Scheibe oder Kanal sein

en: argument must be channel
de: Argument muss ein Kanal sein

en: argument must be string or array or slice or map or channel
de: Argument muss Zeichenkette oder Array oder Scheibe oder Map oder Kanal sein

en: argument must have complex type
de: Argument muss komplexen Typen haben

en: argument not permitted on %qs clause
de: Argument an %qs-Klausel nicht erlaubt

en: argument not permitted on %qs clause in OpenACC %<kernels%> region with a %qs clause
de: Argument an %qs-Klausel nicht erlaubt, in OpenACC-%<kernels%>-Region mit einer %qs-Klausel

en: argument of %<__builtin_eh_return_regno%> must be constant
de: Argument für %<__builtin_eh_return_regno%> muss konstant sein

en: argument of %qE attribute ignored
de: Argument des Attributs %qE wird ignoriert

en: argument of %qE attribute is missing
de: Argument des Attributs %qE fehlt

en: argument of %qE attribute is not "ilink" or "firq"
de: Argument des Attributes %qE ist weder »ilink« oder »firq«

en: argument of %qE attribute is not "ilink1" or "ilink2"
de: Argument des Attributes %qE ist weder »ilink1« oder »ilink2«

en: argument of %qE attribute is not %qs, %qs %qs, %qs, %qs, %qs, %qs, %qs, %qs or %qs
de: Das Argument des Attributs %qE ist nicht %qs, %qs %qs, %qs, %qs, %qs, %qs, %qs, %qs oder %qs

en: argument of %qE attribute is not a string constant
de: Argument des Attributes %qE ist keine Zeichenkettenkonstante

en: argument of %qE attribute is not a string constant or number
de: Argument des Attributs %qE ist weder Zeichenkettenkonstante noch Zahl

en: argument of Offsetof implies indirection of an embedded field
de: Argument von Offsetof bringt Indirektion eines eingebetteten Feldes mit sich

en: argument of function call might be a candidate for a format attribute
de: Argument des Funktionsaufrufs könnte Kandidat für Formatattribut sein

en: argument of type %qT not permitted with %<-mgeneral-regs-only%>
de: Argument vom Typ %qT ist zusammen mit %<-mgeneral-regs-only%> nicht erlaubt

en: argument references a symbol declared here
de: das Argument verweist auf ein Symbol, das hier deklariert ist

en: argument to %<-O%> should be a non-negative integer, %<g%>, %<s%>, %<z%> or %<fast%>
de: Argument von %<-O%> sollte eine nicht-negative Ganzzahl, %<g%>, %<s%>, %<z%> oder %<fast%> sein

en: argument to %<__integer_pack%> must be between 0 and %d
de: Argument von %<__integer_pack%> muss zwischen 0 und %d liegen

en: argument to %<alloca%> is too large
de: Argument für %<alloca%> ist zu groß

en: argument to %<alloca%> is zero
de: Argument für %<alloca%> ist 0

en: argument to %<alloca%> may be too large
de: Argument für %<alloca%> könnte zu groß sein

en: argument to %<decltype%> must be an expression
de: Argument für %<decltype%> muss ein Ausdruck sein

en: argument to %<sizeof%> in %qD call is the same expression as the destination; did you mean to dereference it?
de: Argument für %<sizeof%> in Aufruf von %qD ist der gleiche Ausdruck wie das Ziel; sollte es dereferenziert werden?

en: argument to %<sizeof%> in %qD call is the same expression as the destination; did you mean to provide an explicit length?
de: Argument für %<sizeof%> in Aufruf von %qD ist der gleiche Ausdruck wie das Ziel; sollte ausdrückliche Länge angegeben werden?

en: argument to %<sizeof%> in %qD call is the same expression as the destination; did you mean to remove the addressof?
de: Argument für %<sizeof%> in Aufruf von %qD ist der gleiche Ausdruck wie das Ziel; sollte addressof entfernt werden?

en: argument to %<sizeof%> in %qD call is the same expression as the first source; did you mean to dereference it?
de: Argument für %<sizeof%> in Aufruf von %qD ist der gleiche Ausdruck wie die erste Quelle; sollte es dereferenziert werden?

en: argument to %<sizeof%> in %qD call is the same expression as the first source; did you mean to provide an explicit length?
de: Argument für %<sizeof%> in Aufruf von %qD ist der gleiche Ausdruck wie die erste Quelle; sollte ausdrückliche Länge angegeben werden?

en: argument to %<sizeof%> in %qD call is the same expression as the first source; did you mean to remove the addressof?
de: Argument für %<sizeof%> in Aufruf von %qD ist der gleiche Ausdruck wie die erste Quelle; sollte addressof entfernt werden?

en: argument to %<sizeof%> in %qD call is the same expression as the second source; did you mean to dereference it?
de: Argument für %<sizeof%> in Aufruf von %qD ist der gleiche Ausdruck wie die zweite Quelle; sollte es dereferenziert werden?

en: argument to %<sizeof%> in %qD call is the same expression as the second source; did you mean to provide an explicit length?
de: Argument für %<sizeof%> in Aufruf von %qD ist der gleiche Ausdruck wie die zweite Quelle; sollte ausdrückliche Länge angegeben werden?

en: argument to %<sizeof%> in %qD call is the same expression as the second source; did you mean to remove the addressof?
de: Argument für %<sizeof%> in Aufruf von %qD ist der gleiche Ausdruck wie die zweite Quelle; sollte addressof entfernt werden?

en: argument to %<sizeof%> in %qD call is the same expression as the source; did you mean to dereference it?
de: Argument für %<sizeof%> in Aufruf von %qD ist der gleiche Ausdruck wie die Quelle; sollte es dereferenziert werden?

en: argument to %<sizeof%> in %qD call is the same expression as the source; did you mean to provide an explicit length?
de: Argument für %<sizeof%> in Aufruf von %qD ist der gleiche Ausdruck wie die Quelle; sollte ausdrückliche Länge angegeben werden?

en: argument to %<sizeof%> in %qD call is the same expression as the source; did you mean to remove the addressof?
de: Argument für %<sizeof%> in Aufruf von %qD ist der gleiche Ausdruck wie die Quelle; sollte addressof entfernt werden?

en: argument to %<sizeof%> in %qD call is the same expression as the source; did you mean to use the size of the destination?
de: Argument für %<sizeof%> in Aufruf von %qD ist der gleiche Ausdruck wie die Quelle; meinten Sie die Größe des Ziels?

en: argument to %<sizeof%> in %qD call is the same pointer type %qT as the destination; expected %qT or an explicit length
de: Argument für %<sizeof%> in Aufruf von %qD ist vom gleichen Zeigertyp %qT wie das Ziel; %qT oder ausdrückliche Länge erwartet

en: argument to %<sizeof%> in %qD call is the same pointer type %qT as the first source; expected %qT or an explicit length
de: Argument für %<sizeof%> in Aufruf von %qD ist vom gleichen Zeigertyp %qT wie die erste Quelle; %qT oder ausdrückliche Länge erwartet

en: argument to %<sizeof%> in %qD call is the same pointer type %qT as the second source; expected %qT or an explicit length
de: Argument für %<sizeof%> in Aufruf von %qD ist vom gleichen Zeigertyp %qT wie die zweite Quelle; %qT oder ausdrückliche Länge erwartet

en: argument to %<sizeof%> in %qD call is the same pointer type %qT as the source; expected %qT or an explicit length
de: Argument für %<sizeof%> in Aufruf von %qD ist vom gleichen Zeigertyp %qT wie die Quelle; %qT oder ausdrückliche Länge erwartet

en: argument to %qE attribute is neither eic, nor %<vector=<line>%>
de: Argument des Attributs %qE ist weder %<eic%> noch %<vector=<Zeile>%>

en: argument to %qE attribute is neither zero, nor one
de: Argument des Attributes %qE ist weder Null noch Eins

en: argument to %qE attribute is not %<"user"%>, %<"supervisor"%>, or %<"machine"%>
de: Argument des Attributs %qE muss %<"user"%>, %<"supervisor"%> oder %<"machine"%> sein

en: argument to %qE attribute is not (keep|thunk|thunk-extern)
de: Argument für %qE ist nicht (keep|thunk|thunk-extern)

en: argument to %qE attribute is not (keep|thunk|thunk-inline|thunk-extern)
de: Argument des Attributes %qE ist nicht (keep|thunk|thunk-inline|thunk-extern)

en: argument to %qE attribute is not intstack
de: Argument des Attributes %qE ist nicht »intstack«

en: argument to %qE attribute larger than %d
de: Argument für Attribut %qE ist größer als %d

en: argument to %qs is bigger than %d
de: Argument für %qs ist größer als %d

en: argument to %qs is not between %d and %d
de: Argument von %qs ist nicht zwischen %d und %d

en: argument to %qs is too large (max. %d)
de: Argument für %qs ist zu groß (max. %d)

en: argument to %qs should be a non-negative integer
de: Argument von %qs sollte eine nicht-negative Ganzzahl sein

en: argument to %qs should be a non-negative integer optionally followed by a size unit
de: Argument für %qs sollte eine nicht-negative Ganzzahl sein, optional gefolgt von einer Größeneinheit

en: argument to be formatted is not %<...%>
de: zu formatierendes Argument ist nicht %<...%>

en: argument to interrupt attribute is unsupported for weak functions
de: Argument für »interrupt«-Attribut wird für »weak«-Funktionen nicht unterstützt

en: argument to variable-length array is too large
de: Argument für Array mit variabler Länge ist zu groß

en: argument to variable-length array is zero
de: Argument für Array variabler Länge ist 0

en: argument to variable-length array may be too large
de: Argument für Array mit variabler Länge könnte zu groß sein

en: arguments %d and %d of %qE must have the same element size, but the values passed here have type %qT and %qT respectively
de: die Argumente %d und %d von %qE müssen die gleiche Elementgröße haben, aber die hier übergebenen Werte sind vom Typ %qT und %qT

en: arguments %d and %d of %qE must have the same signedness, but the values passed here have type %qT and %qT respectively
de: die Argumente %d und %d von %qE müssen die gleiche Vorzeichenhaftigkeit haben, aber die hier übergebenen Werte sind vom Typ %qT und %qT

en: arguments '%s' and '%s' for intrinsic %s
de: Argumente »%s« und »%s« für intrinsisches %s

en: arguments '%s' and '%s' for intrinsic '%s'
de: Argumente »%s« und »%s« für intrinsisches »%s«

en: arguments 'a%d' and 'a%d' for intrinsic '%s'
de: Argumente »a%d« und »a%d« für intrinsisches »%s«

en: arguments ignored for %<-Wattributes=%>; use %<-Wno-attributes=%> instead
de: Argumente für %<-Wattributes=%> ignoriert; verwenden Sie stattdessen %<-Wno-attributes=%>

en: arguments of type %qT require the SVE ISA extension
de: Argumente vom Typ %qT erfordern die SVE-ISA-Erweiterung

en: arguments to %qs should be non-negative integers
de: Argumente von %qs sollten nicht-negative Ganzzahlen sein

en: arguments to destructor are not allowed
de: Argumente für Destruktor sind nicht erlaubt

en: arguments to the %qE attribute must be narrow string literals
de: Argumente für Attribut %qE müssen enge Zeichenkettenliterale sein

en: arguments to the %qE attribute must contain valid identifiers
de: Argumente für Attribut %qE müssen gültige Bezeichner enthalten

en: arithmetic IF
de: arithmetisches IF

en: arithmetic between different enumeration types %qT and %qT is deprecated
de: Arithmetik zwischen den unterschiedlichen Aufzählungstypen %qT und %qT ist veraltet

en: arithmetic between enumeration type %qT and floating-point type %qT is deprecated
de: Arithmetik zwischen Aufzählungstyp %qT und Gleitkommatyp %qT ist veraltet

en: arithmetic between floating-point type %qT and enumeration type %qT is deprecated
de: Arithmetik zwischen Gleitkommatyp %qT und Aufzählungstyp %qT ist veraltet

en: arithmetic involving a null pointer in %qE
de: Arithmetik mit Nullzeiger in %qE

en: arithmetic on pointer to SVE type %qT
de: Arithmetik mit Zeiger auf SVE-Typen %qT

en: arithmetic on pointer to an empty aggregate
de: Arithmetik mit Zeiger auf leeres Aggregat

en: arithmetic on pointer to an incomplete type
de: Arithmetik mit Zeiger auf unvollständigen Typen

en: array %<TYPE_DOMAIN%> is not integer type
de: Interner Compilerfehler: array %<TYPE_DOMAIN%> is not integer type

en: array %q+D assumed to have one element
de: Array %q+D als einelementig betrachtet

en: array %qD declared here
de: Array %qD ist hier deklariert

en: array %qD initialized by parenthesized string literal %qE
de: Array %qD mit geklammerter Zeichenkettenkonstante %qE initialisiert

en: array assignment
de: Array-Zuweisung

en: array bound forbidden after parenthesized type-id
de: Arraygrenze hinter geklammerter type-id ist verboten

en: array bound is not an integer constant
de: Arraygrenze ist keine Ganzzahlkonstante

en: array deallocation of object allocated with non-array allocation
de: Array-Deallokation eines Objekts, das mit einer Nicht-Array-Allokation alloziert wurde

en: array elements cannot have SVE type %qT
de: Arrayelemente können nicht vom SVE-Typ %qT sein

en: array index in initializer exceeds array bounds
de: Arrayindex in Initialisierung überschreitet Arraygrenzen

en: array index in initializer is not an integer constant expression
de: Arrayindex in Initialisierung ist kein konstanter Ganzzahlausdruck

en: array index in initializer not of integer type
de: Arrayindex in Initialisierung hat nicht Ganzzahltyp

en: array index in non-array initializer
de: Arrayindex in Nicht-Array-Initialisierung

en: array index range in initializer exceeds array bounds
de: Arrayindexbereich in Initialisierung überschreitet Arraygrenzen

en: array initialized from non-constant array expression
de: Array mit nicht konstantem Arrayausdruck initialisiert

en: array initialized from parenthesized string constant
de: Array mit geklammerter Zeichenkettenkonstante initialisiert

en: array member %q#D declared here
de: Arrayelement %q#D hier deklariert

en: array must be initialized with a brace-enclosed initializer
de: Array muss mit Initialisierung mit umgebenden geschweiften Klammern initialisiert werden

en: array of inappropriate type initialized from string constant
de: Array unpassenden Typs mit Zeichenkettenkonstante initialisiert

en: array of runtime bound cannot be captured by copy, only by reference
de: Array mit Laufzeitgrenzen kann nicht durch Kopie eingefangen werden, sondern nur über eine Referenz

en: array result
de: Arrayergebnis

en: array section does not have mappable type in %qs clause
de: Arrayabschnitt in %qs-Klausel hat keinen zuordenbaren Typ

en: array section in %<#pragma acc declare%>
de: Arrayabschnitt in %<#pragma acc declare%>

en: array section is not contiguous in %qs clause
de: Arrayabschnitt ist in %qs-Klausel nicht zusammenhängend

en: array size in new-expression must be constant
de: Arraygröße in »new«-Ausdruck muss konstant sein

en: array size missing in %q+D
de: Arraygröße fehlt in %q+D

en: array size missing in %qD
de: Arraygröße fehlt in %qD

en: array size missing in %qT
de: Arraygröße fehlt in %qT

en: array subscript %<%T[%wi]%> is partly outside array bounds of %qT
de: Arrayindex %<%T[%wi]%> ist teilweise außerhalb der Arraygrenzen von %qT

en: array subscript %E is above array bounds of %qT
de: Arrayindex %E ist oberhalb der Arraygrenze von %qT

en: array subscript %E is below array bounds of %qT
de: Arrayindex %E ist unterhalb der Arraygrenze von %qT

en: array subscript %E is outside array bounds of %qT
de: Arrayindex %E liegt außerhalb der Arraygrenzen von %qT

en: array subscript %E is outside the bounds of an interior zero-length array %qT
de: Arrayindexwert %E liegt außerhalb der Grenzen des inneren Arraytyps %qT mit Länge 0

en: array subscript %qE is outside the bounds of an interior zero-length array %qT
de: Arrayindex %qE liegt außerhalb der Grenzen des Arraytyps %qT mit Länge 0

en: array subscript %wi is below array bounds of %qT
de: Arrayindex %wi ist unterhalb der Arraygrenze von %qT

en: array subscript %wi is outside array bounds of %qT
de: Arrayindex %wi ist außerhalb der Arraygrenzen von %qT

en: array subscript %wu is above array bounds of %qT
de: Arrayindex %wu ist oberhalb der Arraygrenze von %qT

en: array subscript [%E, %E] is outside array bounds of %qT
de: Arrayindex [%E, %E] ist außerhalb der Arraygrenzen von %qT

en: array subscript [%wi, %wi] is outside array bounds of %qT
de: Arrayindex [%wi, %wi] ist außerhalb der Arraygrenzen von %qT

en: array subscript has type %<char%>
de: Arrayindex hat Typ %<char%>

en: array subscript is not an integer
de: Arrayindex ist keine Ganzzahl

en: array subscript value %qE is outside the bounds of array %qD of type %qT
de: Arrayindexwert %qE ist außerhalb der Grenzen des Arrays %qD vom Typ %qT

en: array subscript value %qE is outside the bounds of array type %qT
de: Arrayindexwert %qE ist außerhalb der Grenzen des Arraytyps %qT

en: array type has incomplete element type %qT
de: Arraytyp hat unvollständigen Elementtypen %qT

en: array types have different bounds
de: Arraytypen haben unterschiedliche Grenzen

en: array used as initializer
de: Array als Initialisierung verwendet

en: array with qualifier on the element is not qualified before C2X
de: Array mit Qualifizierer auf dem Element wird vor C2X nicht qualifiziert

en: arrays of functions are not meaningful
de: Arrays von Funktionen sind sinnlos

en: assembler does not support %<-mabi=ilp32%>
de: Assembler unterstützt %<-mabi=ilp32%> nicht

en: assembler name hash list corrupted
de: Interner Fehler: assembler name hash list corrupted

en: assertion missing after %qs
de: Behauptung fehlt hinter %qs

en: assign semantics attributes of property %qD conflict with previous declaration
de: Attribute der Zuweisungssemantik der Eigenschaft %qD in Konflikt mit vorheriger Deklaration

en: assigned here
de: hier zugewiesen

en: assigning to an array from an initializer list
de: Zuweisung an Array von Initialisierungsliste

en: assignment
de: Zuweisung

en: assignment (not initialization) in declaration
de: Zuweisung (nicht Initialisierung) in Deklaration

en: assignment discards %qv qualifier from pointer target type
de: Zuweisung streicht Qualifizierer %qv von Zeiger-Zieltyp

en: assignment from distinct Objective-C type
de: Zuweisung von anderem Objective-C-Typ

en: assignment from pointer to non-enclosed address space
de: Zuweisung von Zeiger auf nicht eingeschlossenen Adressbereich

en: assignment from temporary %<initializer_list%> does not extend the lifetime of the underlying array
de: Zuweisung von temporärer %<initializer_list%> führt nicht dazu, dass die Lebenszeit des zugrundeliegenden Arrays ausgeweitet wird

en: assignment left-hand side might be a candidate for a format attribute
de: Links-Zuweisung könnte Kandidat für Formatattribut sein

en: assignment makes %q#v qualified function pointer from unqualified
de: Zuweisung erzeugt aus unqualifiziertem einen qualifizierten Funktionszeiger %q#v

en: assignment of constant field %qD
de: Zuweisung des konstanten Feldes %qD

en: assignment of function %qD
de: Zuweisung der Funktion %qD

en: assignment of member %qD in read-only object
de: Zuweisung von Element %qD in schreibgeschütztem Objekt

en: assignment of read-only location %qE
de: Zuweisung der schreibgeschützten Speicherstelle %qE

en: assignment of read-only member %qD
de: Zuweisung des schreibgeschützten Elementes %qD

en: assignment of read-only named return value %qD
de: Zuweisung des schreibgeschützten benannten Rückgabewertes %qD

en: assignment of read-only parameter %qD
de: Zuweisung des schreibgeschützten Parameters %qD

en: assignment of read-only reference %qD
de: Zuweisung der schreibgeschützten Referenz %qD

en: assignment of read-only variable %qD
de: Zuweisung der schreibgeschützten Variable %qD

en: assignment suppression
de: Zuweisungsunterdrückung

en: assignment to %qT from %qT makes integer from pointer without a cast
de: Zuweisung an %qT aus %qT wandelt einen Zeiger in eine Ganzzahl um, ohne explizite Typkonvertierung

en: assignment to %qT from %qT makes pointer from integer without a cast
de: Zuweisung an %qT von %qT wandelt eine Zahl in einen Zeiger um, ohne explizite Typkonvertierung

en: assignment to %qT from incompatible pointer type %qT
de: Zuweisung an %qT von inkompatiblem Zeigertyp %qT

en: assignment to %qT from pointer to %qD with incompatible type %qT
de: Zuweisung an %qT von Zeiger auf %qD mit inkompatiblem Typ %qT

en: assignment to %qT from pointer type %qT with incompatible scalar storage order
de: Zuweisung an %qT von Zeigertyp %qT mit inkompatibler Speicherreihenfolge für Skalare

en: assignment to expression with array type
de: Zuweisung an Ausdruck von Arraytyp

en: assumed-rank argument
de: Argument mit angenommenem Rang

en: assumed-shape argument
de: Argument mit angenommener Form

en: assumed-type argument
de: Argument von angenommenem Typ

en: assuming cast to type %qT from overloaded function
de: Umwandlung in Typ %qT von überladener Funktion wird angenommen

en: assuming directive output of %wu byte | assuming directive output of %wu bytes
de[0]: angenommen, dass die Ausgabe der Direktive %wu Byte groß ist
de[1]: angenommen, dass die Ausgabe der Direktive %wu Bytes groß ist

en: assuming pointer to member %qD
de: Zeiger auf Element %qD wird angenommen

en: assuming signed overflow does not occur when combining constants around a comparison
de: Annahme, dass vorzeichenbehafteter Überlauf nicht auftritt, wenn Konstanten um einen Vergleich kombiniert werden

en: assuming signed overflow does not occur when reducing constant in comparison
de: Annahme, dass vorzeichenbehafteter Überlauf nicht auftritt, wenn Konstante in Vergleich verringert wird

en: assuming signed overflow does not occur when simplifying %</%> or %<%%%> to %<>>%> or %<&%>
de: Annahme, dass vorzeichenbehafteter Überlauf nicht auftritt, wenn %</%> oder %<%%%> auf %<>>%> oder %<&%> vereinfacht wird

en: assuming signed overflow does not occur when simplifying %<X - Y %s 0%> to %<X %s Y%>
de: der Compiler geht davon aus, dass kein vorzeichenbehafteter Überlauf auftritt, und vereinfacht daher %<X - Y %s 0%> zu %<X %s 0%>

en: assuming signed overflow does not occur when simplifying %<abs (X)%> to %<X%> or %<-X%>
de: Annahme, dass vorzeichenbehafteter Überlauf nicht auftritt, wenn %<abs (X)%> auf %<X%> oder %<-X%> vereinfacht wird

en: assuming signed overflow does not occur when simplifying %<min/max (X,Y)%> to %<X%> or %<Y%>
de: Annehmen, dass vorzeichenbehafteter Überlauf nicht auftritt, wenn %<min/max (X,Y)%> zu %<X%> oder %<Y%> vereinfacht wird

en: assuming signed overflow does not occur when simplifying conditional
de: Annahme, dass vorzeichenbehafteter Überlauf bei Vereinfachung der Bedingung nicht auftritt

en: assuming signed overflow does not occur when simplifying conditional to constant
de: Annahme, dass vorzeichenbehafteter Überlauf nicht auftritt, wenn Bedingung zu Konstante vereinfacht wird

en: assuming signed overflow does not occur when simplifying range test
de: Annahme, dass vorzeichenbehafteter Überlauf nicht auftritt, wenn Bereichsprüfung vereinfacht wird

en: asynchronous argument
de: asynchrones Argument

en: at offset %s into destination object %qE of size %s
de: an Offset %s des Zielobjekts %qE der Größe %s

en: at offset %s into destination object of size %s allocated by %qE
de: an Offset %s des Zielobjekts der Größe %s, alloziert durch %qE

en: at offset %s into object %qE of size %s
de: an Offset %s des Objekts %qE der Größe %s

en: at offset %s into object of size %s allocated by %qE
de: an Offset %s des Objekts der Größe %s, alloziert durch %qE

en: at offset %s into source object %qE of size %s
de: an Offset %s des Quellobjekts %qE der Größe %s

en: at offset %s into source object of size %s allocated by %qE
de: an Offset %s des Quellobjekts der Größe %s, alloziert durch %qE

en: at offset %wi from %qD declared here
de: an Offset %wi von %qD, das hier deklariert ist

en: at offset [%wi, %wi] from %qD declared here
de: an Offset [%wi, %wi] von %qD, das hier deklariert ist

en: atexit failed
de: atexit gescheitert

en: attempt to take address of bit-field
de: Versuch, die Adresse eines Bitfelds zu bestimmen

en: attempt to take address of bit-field structure member %qD
de: Versuch, die Adresse des Bitfeldstrukturelements %qD zu ermitteln

en: attribute %<%E(%s)%> missing an argument
de: dem Attribut %<%E(%s)%> fehlt ein Argument

en: attribute %<%E(%s, %E)%> invalid positional argument %i
de: Attribut %<%E(%s, %E)%> hat ungültiges Positionsargument %i

en: attribute %<%E(%s, %E, %E)%> invalid positional argument %i
de: Attribut %<%E(%s, %E, %E)%> hat ungültiges Positionsargument %i

en: attribute %<fallthrough%> not preceding a case label or default label
de: %<fallthrough%>-Attribut ist nicht direkt vor einer case-Marke oder einer default-Marke

en: attribute %<fallthrough%> specified multiple times
de: Attribut %<fallthrough%> ist mehrfach angegeben

en: attribute %<target%> argument %qs is unknown
de: beim Attribut %<target%> ist das Argument %qs unbekannt

en: attribute %<target%> argument not a string
de: Argument für Attribut %<target%> ist keine Zeichenkette

en: attribute %qE argument must be one of %qs or %qs
de: Argument von Attribut %qE muss eins von %qs oder %qs sein

en: attribute %qE argument must be one of %qs, %qs, %qs, or %qs
de: Argument von Attribut %qE muss eins von %qs, %qs, %qs oder %qs sein

en: attribute %qE argument not a string
de: Attributargument von %qE ist keine Zeichenkette

en: attribute %qE invalid mode
de: ungültiger Modus für Attribut %qE

en: attribute %qE invalid mode %qs; expected one of %qs, %qs, %qs, or %qs
de: Attribut %qE ungültiger Modus %qs; erwartet wird einer von %qs, %qs, %qs oder %qs

en: attribute %qE mode %qE is not an identifier; expected one of %qs, %qs, %qs, or %qs
de: Attribut %qE Modus %qE ist kein Bezeichner; erwartet wird einer von %qs, %qs, %qs oder %qs

en: attribute %qE unexpected %<(%> after mode %qs; expected a positional argument or %<)%>
de: Attribut %qE enthält unerwartete %<(%> nach Modus %qs; erwartet wird ein Positionsargument oder %<)%>

en: attribute %qE without arguments on a non-prototype
de: Attribut %qE ohne Argumente bei einem Nicht-Prototyp

en: attribute %qs applies to array types only
de: Attribut %qs bezieht sich nur auf Arraytypen

en: attribute %qs argument %qs is unknown
de: beim Attribut %qs ist das Argument %qs unbekannt

en: attribute %qs argument is not a string
de: Argument von Attribut %qs muss eine Zeichenkette sein

en: attribute %qs invalid positional argument
de: Attribut %qs hat ungültiges positionelles Argument

en: attribute %qs mismatch with mode %qs
de: Attribut %qs ist unverträglich mit Modus %qs

en: attribute %qs mismatched positional argument values %i and %i
de: Attribut %qs enthält nicht übereinstimmende Positionsargumente mit den Werten %i und %i

en: attribute %qs missing positional argument 2 provided in previous designation by argument %u
de: dem Attribut %qs fehlt Positionsargument 2, das in der vorherigen Bestimmung in Argument %u angegeben wurde

en: attribute %qs positional argument %i invalid value %wi
de: beim Attribut %qs hat das Argument an Position %i den ungültigen Wert %wi

en: attribute %qs positional argument %i value %wi exceeds number of function arguments %u
de: beim Attribut %qs hat das positionelle Argument %i den Wert %wi, der die Anzahl der Funktionsparameter %u übersteigt

en: attribute %qs positional argument 1 references %qs-qualified argument type %qT
de: beim Attribut %1$qs verweist Argument 1 auf Typ %3$qT, der mit %2$qs qualifiziert ist

en: attribute %qs positional argument 1 references argument of function type %qT
de: Attribut %qs hat Positionsargument 1, das sich auf das Argument des Funktionstyps %qT bezieht

en: attribute %qs positional argument 1 references non-pointer argument type %qT
de: beim Attribut %qs verweist Argument 1 auf Typ %qT, der kein Zeigertyp ist

en: attribute %qs positional argument 2 conflicts with previous designation by argument %u
de: Attribut %qs positionelles Argument 2 widerspricht der vorherigen Bestimmung von Argument %u

en: attribute %qs positional argument 2 missing in previous designation
de: Attribut %qs positionelles Argument 2 fehlt in vorheriger Bestimmung

en: attribute %qs positional argument 2 references non-integer argument type %qT
de: beim Attribut %qs verweist Argument 2 auf Typ %qT, der nicht ganzzahlig ist

en: attribute %qs specified multiple times
de: Attribut %qs ist mehrfach angegeben

en: attribute declaration
de: Attribut-Deklaration

en: attribute for %q#T must follow the %qs keyword
de: Attribut für %q#T muss dem Schlüsselwort %qs folgen

en: attribute ignored
de: Attribut wird ignoriert

en: attribute ignored in declaration of %q#T
de: Attribut in Deklaration von %q#T ignoriert

en: attribute ignored in explicit instantiation %q#T
de: Attribut in expliter Instanziierung %q#T ignoriert

en: attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>
de: attribute-using-prefix ist nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar

en: attribute using prefix used together with scoped attribute token
de: Attribut, das Präfix verwendet, wird zusammen mit Gültigkeitsbereich-Attribut-Token verwendet

en: attribute value %qs is unknown in %qs attribute
de: Attributwert %qs ist im %qs-Attribut unbekannt

en: attribute value %qs was already specified in %qs attribute
de: der Wert %qs wurde bereits im Attribut %qs angegeben

en: attributes after parenthesized initializer ignored
de: Attribute hinter geklammerter Initialisierung werden ignoriert

en: attributes are not allowed on a function-definition
de: bei einer Funktionsdefinition sind keine Attribute erlaubt

en: attributes are not permitted in this position
de: Attribute dürfen an dieser Stelle nicht verwendet werden

en: attributes at the beginning of statement are ignored
de: Attribute am Anfang der Anweisung werden ignoriert

en: attributes ignored on elaborated-type-specifier that is not a forward declaration
de: Attribute an Spezifizierer ausführlichen Typs ignoriert, der keine Vorwärtsdeklaration ist

en: attributes ignored on template instantiation
de: Attribute an Templateinstanziierung ignoriert

en: attributes ignored on uninstantiated type
de: Attribute an instanziiertem Typen ignoriert

en: attributes in parameter array declarator ignored
de: Attribute in Parameterarraydeklarator ignoriert

en: attributes may be inserted here
de: Attribute dürfen hier eingesetzt werden

en: attributes may not be specified before the %<@%D%> Objective-C++ keyword
de: Attribute dürfen nicht vor dem Objective-C++-Schlüsselwort %<@%D%> angegeben werden

en: attributes should be specified before the declarator in a function definition
de: Attribute sollten in einer Funktionsdefinition vor dem Deklarator angegeben werden

en: auto fpu selection not currently permitted here
de: automatische FPU-Auswahl ist hier momentan nicht erlaubt

en: automatic variable %qE cannot be %<threadprivate%>
de: automatische Variable %qE kann nicht %<threadprivate%> sein

en: aux field set for edge %s->%s
de: Interner Fehler: aux field set for edge %s->%s

en: aux field set for indirect edge from %s
de: Interner Fehler: aux field set for indirect edge from %s

en: available since Fortran 77
de: verfügbar seit Fortran 77

en: await expressions are not permitted in handlers
de: await-Ausdrücke sind in Handlern nicht erlaubt

en: awaitable type %qT is not a structure
de: der abwartbare Typ %qT muss ein Strukturtyp sein

en: backend decl for module variable %qs already exists
de: Backend-Deklaration für Modulvariable %qs ist bereits vorhanden

en: bad ADDR_SPACE_GLOBAL address
de: falsche ADDR_SPACE_GLOBAL-Adresse

en: bad address
de: Falsche Adresse

en: bad address, not (reg+disp):
de: Falsche Adresse, nicht (reg+disp):

en: bad address, not a constant:
de: falsche Adresse, keine Konstante:

en: bad address, not an I/O address:
de: falsche Adresse, keine E/A-Adresse:

en: bad address, not post_inc or pre_dec:
de: Falsche Adresse, nicht post_inc oder pre_dec:

en: bad alignment: %d
de: falsche Ausrichtung: %d

en: bad amount of stack space removal: %d
de: Falscher Betrag der Stapelspeicherentfernung: %d

en: bad argument for %<-fdebug%>: %qs
de: falsches Argument für %<-fdebug%>: %qs

en: bad argument for %<-fextern-std%>: %qs
de: falsches Argument für %<-fextern-std%>: %qs

en: bad argument for %<-fmodule-file%>: %qs
de: falsches Argument für %<-fmodule-file%>: %qs

en: bad argument for %<-fversion%>: %qs
de: falsches Argument für %<-fversion%>: %qs

en: bad builtin code
de: Falscher eingebauter Code

en: bad builtin fcode
de: Falscher eingebauter fcode

en: bad builtin icode
de: Falscher eingebauter ICode

en: bad condition code
de: Falscher Bedingungscode

en: bad expression type during walk (%d)
de: Falscher Ausdruckstyp beim Durchlaufen (%d)

en: bad insn for 'A'
de: falscher Befehl für 'A'

en: bad insn in frv_print_operand, 0 case
de: Falscher Befehl in frv_print_operand, Fall 0

en: bad insn in frv_print_operand, bad const_double
de: Falscher Befehl in frv_print_operand, falsches const_double

en: bad insn in frv_print_operand, z case
de: Falscher Befehl in frv_print_operand, Fall »z«

en: bad insn to frv_print_operand, 'F' modifier:
de: Falscher Befehl für frv_print_operand, Modifizierer »F«:

en: bad insn to frv_print_operand, 'L' modifier:
de: Falscher Befehl für frv_print_operand, Modifizierer »L«:

en: bad insn to frv_print_operand, 'M/N' modifier:
de: Falscher Befehl für frv_print_operand, Modifizierer »M/N«:

en: bad insn to frv_print_operand, 'O' modifier:
de: Falscher Befehl für frv_print_operand, Modifizierer »O«:

en: bad insn to frv_print_operand, 'e' modifier:
de: Falscher Befehl für frv_print_operand, Modifizierer »e«:

en: bad insn to frv_print_operand, 'f' modifier:
de: Falscher Befehl für frv_print_operand, Modifizierer »f«:

en: bad insn to frv_print_operand, 'g' modifier:
de: Falscher Befehl für frv_print_operand, Modifizierer »g«:

en: bad insn to frv_print_operand, P modifier:
de: Falscher Befehl für frv_print_operand, Modifizierer »P«:

en: bad insn to frv_print_operand_address:
de: Falscher Befehl für frv_print_operand_address:

en: bad insn to frv_print_operand_memory_reference:
de: Falscher Befehl für frv_print_operand_memory_reference:

en: bad move
de: ungültige Bewegung

en: bad operand
de: ungültiger Operand

en: bad option %qs to attribute %<optimize%>
de: schlechte Option %qs für Attribut %<optimize%>

en: bad option %qs to pragma %<optimize%>
de: schlechte Option %qs für Pragma %<optimize%>

en: bad output_condmove_single operand
de: Falscher Operand für output_condmove_single

en: bad output_move_double operand
de: Falscher Operand für output_move_double

en: bad output_move_single operand
de: Falscher Operand für output_move_single

en: bad register
de: falsches Register

en: bad register to frv_print_operand_memory_reference_reg:
de: Falsches Register für frv_print_operand_memory_reference_reg:

en: bad return type for function argument %u of %<__builtin_tgmath%>
de: falscher Rückgabetyp für Funktionsargument %u von %<__builtin_tgmath%>

en: bad shift insn:
de: Falscher Schiebe-Befehl:

en: bad test
de: Falscher Test

en: bad type for argument %u of function argument %u of %<__builtin_tgmath%>
de: falscher Typ für Argument %u von Funktionsargument %u von %<__builtin_tgmath%>

en: bad usage of spec function %qs
de: falsche Verwendung der spec-Funktion %qs

en: bad value %<%s%> for %<-mtls-size=%> switch
de: Falscher Wert %<%s%> für Schalter %<-mtls-size=%>

en: bad value %qs for %<-march=%> switch
de: falscher Wert %qs für Schalter %<-march=%>

en: bad value %qs for %<-mcpu%> switch
de: Falscher Wert %qs für Schalter %<-mcpu%>

en: bad value %qs for %<-mfp-rounding-mode%> switch
de: Falscher Wert %qs für Schalter %<-mfp-rounding-mode%>

en: bad value %qs for %<-mfp-trap-mode%> switch
de: Falscher Wert %qs für Schalter %<-mfp-trap-mode%>

en: bad value %qs for %<-mmemory-latency%>
de: falscher Wert %qs für %<-mmemory-latency%>

en: bad value %qs for %<-mtls-size%> switch
de: Falscher Wert %qs für Schalter %<-mtls-size%>

en: bad value %qs for %<-mtrap-precision%> switch
de: falscher Wert %qs für Schalter %<-mtrap-precision%>

en: bad value %qs for %<-mtune%> switch
de: falscher Wert %qs für Schalter %<-mtune%>

en: bad value %qs for %<-mtune=%> switch
de: falscher Wert %qs für Schalter %<-mtune=%>

en: bad value %qs for %<target("arch=")%> attribute
de: unbekannter Wert %qs für Attribut %<target("arch=")%>

en: bad value %qs for %<target("tune=")%> attribute
de: falscher Wert %qs für Attribut %<target("tune=")%>

en: bad value for %<%s-%s%>
de: falscher Wert für %<%s-%s%>

en: bad value for %<%s=%s%>
de: falscher Wert für %<%s=%s%>

en: badly nested C headers from preprocessor
de: schlecht geschachtelte C-Header vom Präprozessor

en: bare apostrophe %<'%> in format
de: Apostroph %<'%> außerhalb von Anführungszeichen im Format

en: barrier region may not be closely nested inside of work-sharing, %<loop%>, %<critical%>, %<ordered%>, %<master%>, %<masked%>, explicit %<task%> or %<taskloop%> region
de: Sperrregion darf nicht innerhalb einer Region eng geschachtelt sein, die arbeitsteilend, %<loop%>, %<critical%>, %<ordered%>, %<master%>, %<masked%>, explizit %<task%> oder %<taskloop%> ist

en: base %qT will be initialized after
de: Basis %qT wird initialisiert nach

en: base class %q#T has accessible non-virtual destructor
de: Basisklasse %q#T hat einen zugänglichen nicht-virtuellen Destruktor

en: base class %q#T should be explicitly initialized in the copy constructor
de: Basisklasse %q#T sollte explizit im Kopierkonstruktor initialisiert werden

en: base class %qT is not public
de: Basisklasse %qT ist nicht %<public%>

en: base initializer expansion %qT contains no parameter packs
de: Expansion der Basisinitialisierung %qT enthält keine Parameterpacks

en: base operand of %<->%> has non-pointer type %qT
de: Basisoperand von %<->%> hat Nicht-Zeiger-Typ %qT

en: base operand of %<->%> is not a pointer
de: Basisoperand von %<->%> ist kein Zeiger

en: base type %qT fails to be a struct or class type
de: Basistyp %qT ist kein struct- oder Klassentyp

en: base variable or SSA name undeclared
de: Interner Fehler: base variable or SSA name undeclared

en: basic block %d pred edge is corrupted
de: Interner Fehler: basic block %d pred edge is corrupted

en: basic block %d should be marked irreducible
de: Interner Fehler: basic block %d should be marked irreducible

en: basic block %d should not be marked irreducible
de: Interner Fehler: basic block %d should not be marked irreducible

en: basic block %i edge lists are corrupted
de: Interner Fehler: basic block %i edge lists are corrupted

en: basic blocks not laid down consecutively
de: Interner Fehler: basic blocks not laid down consecutively

en: bb %d does not belong to loop %d
de: Interner Fehler: bb %d does not belong to loop %d

en: bb %d has father loop %d, should be loop %d
de: Interner Fehler: bb %d has father loop %d, should be loop %d

en: bb %d on wrong place
de: Interner Fehler: bb %d on wrong place

en: because %qT has user-provided %qD
de: da %qT vom Benutzer bereitgestelltes %qD hat

en: because it is a member of %qT
de: da es ein Element von %qT ist

en: because it is used as a glvalue
de: da er als glvalue verwendet wird

en: because the array element type %qT has variable size
de: da der Arrayelementtyp %qT variable Größe hat

en: begin expression refers to outer iterator %qD
de: Anfangsausdruck verweist auf äußeren Iterator %qD

en: binary argument %u to decimal-only type-generic function
de: binäres Argument %u für typgenerische Funktion, die ausschließlich dezimal ist

en: binary expression in operand of fold-expression
de: binärer Ausdruck in Operand von Faltungsausdruck

en: binary operator does not support mixing vector bool with floating point vector operands
de: binärer Operator unterstützt nicht, dass bool-Vektor mit Gleitkommavektor vermischt wird

en: binary operator does not support two vector bool operands
de: binärer Operator unterstützt keine zwei bool-Vektor-Operanden

en: binary operator does not support vector bool operand
de: Binärer Operator unterstützt Boolean-Vektor-Argument nicht

en: bind(c) procedure
de: bind(c)-Prozedur

en: binding reference of type %qH to %qI discards qualifiers
de: das Binden der Referenz vom Typ %qH an %qI streicht Qualifizierer

en: bit-field %q#D with non-integral type %qT
de: Bitfeld %q#D mit Nicht-Ganzzahl-Typ %qT

en: bit-field %q+D width not an integer constant
de: Breite des Bitfeldes %q+D ist keine Ganzzahlkonstante

en: bit-field %qD has non-integral type %qT
de: Bitfeld %qD mit Nicht-Ganzzahl-Typ %qT

en: bit-field %qD with non-integral type %qT
de: Bitfeld %qD mit Nicht-Ganzzahl-Typ %qT

en: bit-field %qE has atomic type
de: Bitfeld %qE hat atomaren Typen

en: bit-field %qE in %qs clause
de: Bitfeld %qE in %qs-Klausel

en: bit-field %qs has invalid type
de: Bitfeld %qs hat ungültigen Typen

en: bit-field %qs width not an integer constant
de: Breite des Bitfeldes %qs ist keine Ganzzahlkonstante

en: bit-field %qs width not an integer constant expression
de: Breite des Bitfeldes %qs ist kein Ganzzahlkonstantenausdruck

en: bit-field has atomic type
de: Bitfeld hat atomaren Typen

en: bitwise comparison always evaluates to false
de: Bitweiser Vergleich ergibt immer »false«

en: bitwise comparison always evaluates to true
de: Bitweiser Vergleich ergibt immer »true«

en: bitwise operation between different enumeration types %qT and %qT is deprecated
de: bitweise Operation zwischen den unterschiedlichen Aufzählungstypen %qT und %qT ist veraltet

en: block IF
de: Block-IF

en: block-scope extern declaration %q#D not permitted in module purview
de: extern-Deklaration %q#D mit Gültigkeitsbereich Block ist im Zuständigkeitsbereich des Moduls nicht erlaubt

en: body of %<constexpr%> function %qD not a return-statement
de: Körper der %<constexpr%>-Funktion %qD ist keine Rückgabeanweisung

en: bogus DISPOSE construction: %d
de: nur simulierte DISPOSE-Konstruktion: %d

en: bogus JARL construction: %d
de: falsche JARL-Konstruktion: %d

en: bogus JR construction: %d
de: nur simulierte JR-Konstruktion: %d

en: bogus PREPEARE construction: %d
de: nur simulierte PREPARE-Konstruktion: %d

en: bogus comparison result type
de: falscher Ergebnistyp bei Vergleich

en: boolean registers required for the floating-point option
de: Boolesche Register für die Gleitkommaoption benötigt

en: both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>
de: wenn %<-mstack-protector-guard=sysreg%> angegeben ist, müssen sowohl %<-mstack-protector-guard-offset%> als auch %<-mstack-protector-guard-reg%> angegeben werden

en: both %<__thread%> and %<thread_local%> specified
de: sowohl %<__thread%> als auch %<thread_local%> angegeben

en: both %<monotonic%> and %<nonmonotonic%> modifiers specified
de: widersprüchliche Modifizierer %<monotonic%> und %<nonmonotonic%> angegeben

en: both %qs and %qs specified
de: sowohl %qs als auch %qs angegeben

en: both %s and %qE attribute provide address
de: sowohl »%s« als auch das %qE-Attribut geben die Adresse an

en: both arguments in binary fold have unexpanded parameter packs
de: beide Argumente in binärer Faltung haben unexpandierte Parameterpackungen

en: both arguments must be compatible
de: die beiden Argumente müssen kompatibel sein

en: both arguments to %<__builtin___clear_cache%> must be pointers
de: beide Argumente für %<__builtin___clear_cache%> müssen Zeiger sein

en: both binary and decimal floating-point arguments to type-generic function
de: sowohl binäre als auch dezimale Gleitkomma-Argumente in Aufruf von typgenerischer Funktion

en: both branches of %<if%> statement marked as %qs
de: beide Zweige der %<if%>-Anweisung als %qs markiert

en: both complex and decimal floating-point arguments to type-generic function
de: sowohl komplexe als auch dezimale Gleitkomma-Argumente in Aufruf von typgenerischer Funktion

en: bound argument %i value %s is negative for a variable length array argument %i of type %s
de: gebundenes Argument %i mit Wert %s ist negativ, für Argument %i vom Typ Array variabler Länge vom Typ %s

en: braced spec %qs ends in escape
de: geschweift geklammerte Spezifikation %qs endet mit Escapezeichen

en: braced spec %qs is invalid at %qc
de: geschweift geklammerte Spezifikation %qs ist bei %qc ungültig

en: braced spec body %qs is invalid
de: geschweift geklammerter Spezifikationskörper %qs ist ungültig

en: braced-group within expression allowed only inside a function
de: geklammerte Gruppe innerhalb eines Ausdrucks nur in einer Funktion erlaubt

en: braces around scalar initializer
de: geschweifte Klammern um Skalar-Initialisierung

en: braces around scalar initializer for type %qT
de: geschweifte Klammern um skalare Initialisierung für Typ %qT

en: branch %2d never executed
de: Zweig %2d niemals ausgeführt

en: branch %2d taken %s%s
de: Zweig %2d wurde genommen: %s%s

en: break statement not within loop or switch
de: break-Anweisung nicht innerhalb einer Schleife oder »switch«

en: break statement used with OpenMP for loop
de: break-Anweisung mit OpenMP für Schleife verwendet

en: build_dt: format with namelist
de: build_dt: Format mit Namensliste

en: built-in %qD declared here
de: eingebaute %qD ist hier deklariert

en: built-in function %q+D declared as non-function
de: Eingebaute Funktion %q+D als Nicht-Funktion deklariert

en: built-in function %qD declared as non-function
de: eingebaute Funktion %qD als Nicht-Funktion deklariert

en: built-in function %qD requires the %<-mconstant-cfstrings%> flag
de: eingebaute Funktion %qD erfordert das Kennzeichen %<-mconstant-cfstrings%>

en: built-in function %qD takes one argument only
de: eingebaute Funktion %qD nimmt nur ein Argument

en: built-in function %qE must be directly called
de: eingebaute Funktion %qE muss direkt aufgerufen werden

en: built-in function %qE not supported for MIPS16
de: eingebaute Funktion %qE nicht für MIPS16 unterstützt

en: built-in function %s requires Nios II R%d
de: eingebaute Funktion %s erfordert Nios II R%d

en: built-in subscript operator with more than one expression in expression list
de: eingebauter Index-Operator mit mehr als einem Ausdruck in der Ausdrucksliste

en: built-in subscript operator without expression list
de: eingebauter Index-Operator ohne Ausdrucksliste

en: builtin %qF is deprecated
de: eingebaute Funktion %qF ist veraltet

en: builtin %qF is for GCC internal use only
de: eingebautes %qF ist nur für interne GCC-Nutzung

en: builtin %qF is not supported without %<-mhtm%> (default with %<-march=zEC12%> and higher)
de: eingebaute %qF wird nur mit %<-mhtm%> unterstützt (standardmäßig für %<-march=zEC12%> und höher eingeschaltet)

en: builtin %qF requires %<-mvx%> (default with %<-march=z13%> and higher)
de: eingebaute %qF wird nur mit %<-mvx%> unterstützt (standardmäßig für %<-march=z13%> und höher eingeschaltet)

en: builtin %qs can only be used on vector types
de: das eingebaute %qs kann nur mit Vektortypen verwendet werden

en: builtin %qs is only valid in 64-bit mode
de: eingebaute Funktion %qs kann nur im 64-Bit-Modus verwendet werden

en: builtin %qs needs GLIBC (2.23 and newer) that exports hardware capability bits
de: eingebaute Funktion %qs erfordert GLIBC (2.23 oder neuer), die Hardware-Fähigkeits-Bits exportiert

en: builtin %qs only accepts 1 argument
de: Eingebaute Funktion %qs akzeptiert genau 1 Argument

en: builtin %qs only accepts 2 arguments
de: Eingebaute Funktion %qs akzeptiert genau 2 Argumente

en: builtin %qs only accepts 3 arguments
de: Eingebaute Funktion %qs akzeptiert genau 3 Argumente

en: builtin %qs only accepts a string argument
de: eingebaute Funktion %qs akzeptiert nur ein Zeichenkettenargument

en: builtin requires an immediate for operand %d
de: Operand %d der eingebauten Funktion muss konstant sein

en: but %qD does not throw; perhaps it should be declared %<noexcept%>
de: aber %qD wirft nicht; vielleicht sollte sie als %<noexcept%> deklariert werden

en: but is prevailed by one without from other translation unit
de: wird aber überragt von einer Tabelle ohne RTTI-Informationen aus anderer Übersetzungseinheit

en: but not here
de: aber nicht hier

en: by argument %u of type %s to %qD declared here
de: durch Argument %u vom Typ %s nach %qD, die hier deklariert wurde

en: by argument %u of type %s to %qT
de: durch Argument %u vom Typ %s nach %qT

en: bytecode stream in file %qs generated with GCC compiler older than 10.0
de: Bytecode-Strom in Datei %qs, mit einem älteren GCC-Compiler als 10.0 erzeugt

en: bytecode stream in file %qs generated with LTO version %d.%d instead of the expected %d.%d
de: Bytecode-Strom in Datei %qs mit LTO-Version %d.%d statt des erwarteten %d.%d erzeugt

en: bytecode stream: expected tag %s instead of %s
de: Bytecode-Strom: Marke %s statt %s erwartet

en: bytecode stream: found empty cgraph node
de: Bytecode-Strom: Leeren Cgraph-Knoten gefunden

en: bytecode stream: found multiple instances of cgraph node with uid %d
de: Bytecode-Strom: Mehrere Instanzen des Cgraph-Knoten mit UID %d gefunden

en: bytecode stream: found non-null terminated string
de: Bytecode-Strom: Nicht nullterminierte Zeichenkette gefunden

en: bytecode stream: garbage at the end of symbols section
de: Bytecode-Strom: Ausschuss am Ende des »symbols«-Abschnitts

en: bytecode stream: no callee found while reading edge
de: Bytecode-Strom: Kein Gerufener beim Lesen der Kante gefunden

en: bytecode stream: no caller found while reading edge
de: Bytecode-Strom: Kein Aufrufer beim Lesen der Kante gefunden

en: bytecode stream: string too long for the string table
de: Bytecode-Strom: Zeichenkette zu lang für Zeichenkettentabelle

en: bytecode stream: trying to read %d bytes after the end of the input buffer
de: Bytecode-Strom: Versuch, %d Bytes nach Ende des Eingabepuffers zu lesen

en: bytecode stream: unexpected LTO section %s
de: Bytecode-Strom: unerwarteter LTO-Abschnitt %s

en: bytecode stream: unexpected tag %s
de: Bytecode-Strom: unerwartete Marke %s

en: call   %2d never executed
de: Aufruf %2d niemals ausgeführt

en: call   %2d returned %s
de: Aufruf %2d gab %s zurück

en: call has circular dependency
de: Aufruf hat ringförmige Abhängigkeit

en: call is considered never executed and code size would grow
de: Aufruf wird niemals ausgeführt und Codegröße würde wachsen

en: call is unlikely and code size would grow
de: Aufruf ist unwahrscheinlich und Codegröße würde wachsen

en: call of %<%T::operator[] (%A)%> is ambiguous
de: Aufruf von %<%T::operator[] (%A)%> ist mehrdeutig

en: call of %<(%T) (%A)%> is ambiguous
de: Aufruf von %<(%T) (%A)%> ist nicht eindeutig

en: call of overloaded %<%D(%A)%> is ambiguous
de: Aufruf des überladenen %<%D(%A)%> ist nicht eindeutig

en: call of overloaded %<%s(%A)%> is ambiguous
de: Aufruf des überladenen %<%s(%A)%> ist mehrdeutig

en: call stmt hash does not point to first direct edge of speculative call sequence
de: der Hash der Aufrufanweisung zeigt nicht auf die erste direkte Kante der Folge von spekulativen Aufrufen

en: call to %<__builtin_custom_%s%> conflicts with switch %<-mcustom-%s%>
de: Aufruf von %<__builtin_custom_%s%> steht in Konflikt mit Schalter %<-mcustom-%s%>

en: call to %qD
de: Aufruf von %qD

en: call to %qD here
de: %qD wird hier aufgerufen

en: call to %qD uses the default argument for parameter %P, which is not yet defined
de: Aufruf von %qD verwendet das Standardargument für Parameter %P, der noch nicht definiert wurde

en: call to %qE is ambiguous; argument %d has type %qs but argument %d has type %qs
de: Aufruf von %qE ist mehrdeutig; Argument %d ist vom Typ %qs, aber Argument %d ist vom Typ %qs

en: call to %qs declared with attribute error: %s
de: Aufruf von %qs mit Attributfehler deklariert: %s

en: call to %qs declared with attribute warning: %s
de: Aufruf von %qs mit Attributwarnung deklariert: %s

en: call to function %qD which throws incomplete type %q#T
de: Aufruf der Funktion %qD, die unvollständigen Typen %q#T wirft

en: call to function which throws incomplete type %q#T
de: Aufruf einer Funktion, die unvollständigen Typen %q#T wirft

en: call to internal function %qE
de: Aufruf für interne Funktion %qE

en: call to non-%<constexpr%> function %qD
de: Aufruf der nicht-%<constexpr%>-Funktion %qD

en: call to non-function %qD
de: Aufruf der Nicht-Funktion %qD

en: call-clobbered register used for global register variable
de: für Ruf vorgesehenes Register wurde für globale Registervariable verwendet

en: called from here
de: von hier aufgerufen

en: called from this function
de: von dieser Funktion aus aufgerufen

en: called object %qD is not a function or function pointer
de: gerufenes Objekt %qD ist keine Funktion oder Funktionszeiger

en: called object %qE is not a function or function pointer
de: gerufenes Objekt %qE ist keine Funktion oder Funktionszeiger

en: called object is not a function or function pointer
de: gerufenes Objekt ist keine Funktion oder Funktionszeiger

en: callee refers to comdat-local symbols
de: Aufgerufene Funktion verweist auf comdat-lokale Symbole

en: caller edge count does not match BB count
de: Interner Fehler: caller edge count does not match BB count

en: caller edge count invalid
de: Interner Fehler: caller edge count invalid

en: caller is not optimized
de: Aufrufer ist nicht optimiert

en: calling %qD with SSE calling convention without SSE/SSE2 enabled
de: Aufruf von %qD mit SSE-Aufrufkonvention, ohne dass SSE/SSE2 eingeschaltet ist

en: calling %qD with a nonzero argument is unsafe
de: das Aufrufen von %qD mit einem nicht-null-Argument ist unsicher

en: calling %qD with attribute sseregparm without SSE/SSE2 enabled
de: Aufruf von %qD mit Attribut sseregparam, ohne dass SSE/SSE2 eingeschaltet ist

en: calling %qT with attribute sseregparm without SSE/SSE2 enabled
de: Aufruf von %qT mit Attribut sseregparam, ohne dass SSE/SSE2 eingeschaltet ist

en: calling constexpr member function %qD through virtual base subobject
de: »constexpr«-Elementfunktion %qD kann nicht vom virtuellen Basisobjekt aus aufgerufen werden

en: calls to functions of type %qT require the SVE ISA extension
de: Aufrufe von Funktionen vom Typ %qT erfordern die SVE-ISA-Erweiterung

en: calls to overloaded operators cannot appear in a constant-expression
de: Aufrufe überladener Operatoren können nicht in einem Konstanten-Ausdruck auftreten

en: calls_comdat_local is set outside of a comdat group
de: calls_comdat_local wird außerhalb einer comdat-Gruppe gesetzt

en: can only use %qE attribute on file-scope definitions of objects of class type
de: nur Attribut %qE kann für Definitionen von Objekten eines Klassentyps im Datei-Gültigkeitsbereich verwendet werden

en: can use at most one of the %<constinit%> and %<constexpr%> specifiers
de: höchstens einer der Spezifizierer %<constinit%> und %<constexpr%> kann verwendet werden

en: can't use non gp relative absolute address
de: Nicht-GP-relative absolute Adresse kann nicht verwendet werden

en: candidate 1:
de: Kandidat 1:

en: candidate 2:
de: Kandidat 2:

en: candidate is: | candidates are:
de[0]: Kandidat ist:
de[1]: Kandidaten sind:

en: candidate:
de: Kandidat:

en: candidates are:
de: Kandidaten sind:

en: cannot %<dynamic_cast%> %qE (of type %q#T) to type %q#T (%s)
de: %<dynamic_cast%> %qE (des Typs %q#T) in Typ %q#T (%s) kann nicht vorgenommen werden

en: cannot %<goto%> into %<catch%> block
de: %<goto%> kann nicht in einen %<catch%>-Block hineinspringen

en: cannot %<goto%> into %<try%> block
de: %<goto%> kann nicht in einen %<try%>-Block hineinspringen

en: cannot add an enumerator list to a template instantiation
de: Aufzählungsliste kann nicht zu Template-Instanziierung hinzugefügt werden

en: cannot allocate an object of abstract type %qT
de: es kann kein Objekt des abstrakten Typs %qT belegt werden

en: cannot allocate objects with SVE type %qT
de: Objekte vom SVE-Typ %qT können nicht alloziert werden

en: cannot allocate stack for variable %q+D, naked function
de: Stapelspeicher für Variable %q+D kann nicht angefordert werden, nackte Funktion

en: cannot apply %<%s%> to %qD, which has also been marked with an OpenMP 'declare target' directive
de: %<%s%> kann nicht auf %qD angewendet werden, da diese bereits mit einer OpenACC-»declare target«-Direktive markiert wurde

en: cannot apply %<offsetof%> to a non constant address
de: %<offsetof%> kann nicht auf nicht-konstante Adresse angewandt werden

en: cannot apply %<offsetof%> to an enumerator %qD
de: %<offsetof%> kann nicht auf Aufzähler %qD angewandt werden

en: cannot apply %<offsetof%> to destructor %<~%T%>
de: %<offsetof%> kann nicht auf Destruktor %<~%T%> angewandt werden

en: cannot apply %<offsetof%> to member function
de: %<offsetof%> kann nicht auf Elementfunktion angewandt werden

en: cannot apply %<offsetof%> to member function %qD
de: %<offsetof%> kann nicht auf Elementfunktion %qD angewandt werden

en: cannot apply %<offsetof%> to static data member %qD
de: %<offsetof%> kann nicht auf statisches Datenelement %qD angewendet werden

en: cannot apply %<offsetof%> when %<operator[]%> is overloaded
de: %<offsetof%> kann nicht angewandt werden, wenn %<operator[]%> überladen ist

en: cannot apply both %<longcall%> and %<shortcall%> attributes to the same function
de: Die Attribute %<longcall%> und %<shortcall%> können nicht beide gleichzeitig für eine Funktion verwendet werden

en: cannot apply member pointer %qE to %qE, which is of non-class type %qT
de: Elementzeiger %qE kann nicht auf %qE angewandt werden, da letzteres vom Nicht-Klassen-Typ %qT ist

en: cannot bind bit-field %qE to %qT
de: das Bitfeld %qE kann nicht mit %qT verbunden werden

en: cannot bind lvalue reference of type %qH to an rvalue of type %qI
de: kann keine Lvalue-Referenz vom Typ %qH an einen Rvalue vom Typ %qI binden

en: cannot bind non-const lvalue reference of type %qH to a value of type %qI
de: nicht-konstante lvalue-Referenz vom Typ %qH kann nicht an Wert vom Typ %qI gebunden werden

en: cannot bind non-const lvalue reference of type %qH to an rvalue of type %qI
de: nicht-konstante lvalue-Referenz vom Typ %qH kann nicht an rvalue vom Typ %qI gebunden werden

en: cannot bind packed field %qE to %qT
de: das gepackte Feld %qE kann nicht mit %qT verbunden werden

en: cannot bind reference of type %qH to %qI due to different array bounds
de: Referenz vom Typ %qH kann nicht an %qI gebunden werden, da die Arraygrenzen sich unterscheiden

en: cannot bind rvalue %qE to %qT
de: der R-Wert %qE kann nicht mit %qT verbunden werden

en: cannot bind rvalue reference of type %qH to lvalue of type %qI
de: rvalue-Referenz vom Typ %qH kann nicht an lvalue vom Typ %qI gebunden werden

en: cannot call %<__builtin_custom_%s%> without specifying switch %<-mcustom-%s%>
de: %<__builtin_custom_%s%> kann nur aufgerufen werden, wenn %<-mcustom-%s%> angegeben ist

en: cannot call a concept as a function
de: ein Konzept kann nicht wie eine Funktion aufgerufen werden

en: cannot call constructor %<%T::%D%> directly
de: Konstruktor %<%T::%D%> kann nicht direkt aufgerufen werden

en: cannot call member function %qD without object
de: Elementfunktion %qD kann nicht ohne Objekt aufgerufen werden

en: cannot capture %qE by reference
de: %qE kann nicht per Referenz aufgefangen werden

en: cannot capture member %qD of anonymous union
de: Element %qD von unbenannter Union kann nicht eingefangen werden

en: cannot cast %qs to %qs since sizes do not line up
de: %qs kann nicht in %qs umgewandelt werden, da die Größen nicht passen

en: cannot cast expression of type %qs to %qs
de: Ausdruck vom Typ %qs kann nicht in %qs umgewandelt werden

en: cannot cast expression of type %qs to type %qs
de: Ausdruck vom Typ %qs kann nicht in den Typ %qs umgewandelt werden

en: cannot catch type %qT because it involves types of variable size
de: Exception vom Typ %qT kann nicht gefangen werden, da Typen mit variabler Größe beteiligt sind

en: cannot close nonexistent response file
de: Nicht existierende Antwortdatei konnte nicht geschlossen werden

en: cannot close receive-only channel
de: Nur-Empfangs-Kanal kann nicht geschlossen werden

en: cannot combine GNU and SVE vectors in a binary operation
de: GNU- und SVE-Vektoren können nicht in einer binären Operation kombiniert werden

en: cannot combine a base of type %qT with an index of type %qT
de: eine Basis vom Typ %qT kann nicht mit einem Index vom Typ %qT kombiniert werden

en: cannot combine a base of type %qT with an offset of type %qT
de: eine Basis vom Typ %qT kann nicht mit einem Offset vom Typ %qT kombiniert werden

en: cannot convert %qE from type %qH to type %qI
de: %qE kann nicht vom Typ %qH in den Typ %qI umgewandelt werden

en: cannot convert %qE from type %qT to type %qT
de: %qE kann nicht vom Typ %qT in den Typ %qT umgewandelt werden

en: cannot convert %qE to %qT
de: %qE kann nicht in %qT umgewandelt werden

en: cannot convert %qE to %qT because
de: %qE kann nicht in %qT umgewandelt werden, da

en: cannot convert %qH to %qI
de: %qH kann nicht nach %qI umgewandelt werden

en: cannot convert %qH to %qI in argument passing
de: %qH kann nicht nach %qI bei Argumentübergabe umgewandelt werden

en: cannot convert %qH to %qI in assignment
de: %qH kann nicht nach %qI in Zuweisung umgewandelt werden

en: cannot convert %qH to %qI in default argument
de: %qH kann nicht nach %qI im Standardargument umgewandelt werden

en: cannot convert %qH to %qI in initialization
de: %qH kann nicht nach %qI in Initialisierung umgewandelt werden

en: cannot convert %qH to %qI in return
de: %qH kann nicht nach %qI in Rückgabe umgewandelt werden

en: cannot convert a delegate expression to %qs
de: ein Delegatenausdruck kann nicht in %qs umgewandelt werden

en: cannot convert a value of type %qT to vector type %qT which has different size
de: Wert vom Typ %qT kann nicht in Vektortyp %qT konvertiert werden, da sie unterschiedlich groß sind

en: cannot convert a vector of type %qT to type %qT which has different size
de: Vektor vom Typ %qT kann nicht in Typ %qT konvertiert werden, da sie unterschiedlich groß sind

en: cannot convert from %qT to base class %qT because %qT is incomplete
de: Umwandlung von %qT in Basisklasse %qT nicht möglich, da %qT unvollständig ist

en: cannot convert from base class %qT to derived class %qT because the base is virtual
de: Umwandlung von Basisklasse %qT in abgeleitete Klasse %qT nicht möglich, da die Basisklasse virtuell ist

en: cannot convert from base class %qT to derived class %qT via virtual base %qT
de: Umwandlung von Basisklasse %qT in abgeleitete Klasse %qT nicht möglich, da die Basisklasse %qT virtuell ist

en: cannot convert from incomplete type %qH to %qI
de: unvollständiger Typ %qH kann nicht in %qI umgewandelt werden

en: cannot convert from pointer to base class %qT to pointer to derived class %qT because the base is virtual
de: Umwandlung von Zeiger auf Basisklasse %qT in Zeiger auf abgeleitete Klasse %qT nicht möglich, da die Basisklasse virtuell ist

en: cannot convert from pointer to base class %qT to pointer to derived class %qT via virtual base %qT
de: Umwandlung von Zeiger auf Basisklasse %qT in Zeiger auf abgeleitete Klasse %qT nicht möglich, da die Basisklasse %qT virtuell ist

en: cannot convert struct %qs to %qs
de: die Struktur %qs kann nicht in %qs umgewandelt werden

en: cannot convert to a pointer type
de: es kann nicht in Zeigertyp konvertiert werden

en: cannot convert type %qH to type %qI
de: Typ %qH kann nicht in den Typ %qI umgewandelt werden

en: cannot convert value to a vector
de: Wert kann nicht in einen Vektor umgewandelt werden

en: cannot create pointer to reference member %qD
de: Zeiger auf Referenzelement %qD kann nicht erzeugt werden

en: cannot create precompiled header %s: %m
de: der vorkompilierte Header %s kann nicht erzeugt werden: %m

en: cannot create type information for type %qT because it involves types of variable size
de: für Typ %qT kann keine Typinformation erzeugt werden, weil dies Typen variabler Größe umfasst

en: cannot declare %<::main%> to be %qs
de: %<::main%> kann nicht als %qs deklariert werden

en: cannot declare %<::main%> to be a global variable
de: %<::main%> kann nicht als globale Variable deklariert werden

en: cannot declare %<::main%> to be a template
de: %<::main%> kann nicht als Template deklariert werden

en: cannot declare %<::main%> to be inline
de: %<::main%> kann nicht inline deklariert werden

en: cannot declare %<::main%> to be static
de: %<::main%> kann nicht statisch deklariert werden

en: cannot declare %<catch%> parameter to be of abstract class type %qT
de: %<catch%>-Parameter kann nicht als abstrakter Klassentyp %qT deklariert werden

en: cannot declare %<catch%> parameter to be of rvalue reference type %qT
de: %<catch%>-Parameter kann nicht als R-Wert-Referenztyp %qT deklariert werden

en: cannot declare %qD in a different module
de: %qD kann nicht in einem anderen Modul deklariert sein

en: cannot declare %qD to be a bit-field type
de: %qD kann nicht als Bitfeldtyp deklariert werden

en: cannot declare a parameter with %<decltype(auto)%>
de: Parameter kann nicht mit %<decltype(auto)%> deklariert werden

en: cannot declare bit-field %qD with %<warn_if_not_aligned%> type
de: Bitfeld %qD kann nicht mit %<warn_if_not_aligned%>-Typ deklariert werden

en: cannot declare bit-field %qD with function type
de: Bitfeld %qD kann nicht mit Funktionstyp deklariert werden

en: cannot declare bit-field %qs with %<warn_if_not_aligned%> type
de: Bitfeld %qs kann nicht mit %<warn_if_not_aligned%>-Typ deklariert werden

en: cannot declare field %q+D to be of abstract type %qT
de: Feld %q+D kann nicht als vom abstrakten Typ %qT deklariert werden

en: cannot declare member %<%T::%s%> within %qT
de: Element %<%T::%s%> kann nicht in %qT deklariert werden

en: cannot declare member function %<%T::%s%> within %qT
de: Elementfunktion %<%T::%s%> kann nicht innerhalb von %qT deklariert werden

en: cannot declare member function %qD to have static linkage
de: Elementfunktion %qD kann nicht deklariert werden, statische Bindung zu haben

en: cannot declare parameter %q+D to be of abstract type %qT
de: Parameter %q+D kann nicht als vom abstrakten Typ %qT deklariert werden

en: cannot declare parameter to be of abstract type %qT
de: Parameter kann nicht als vom abstrakten Typ %qT deklariert werden

en: cannot declare pointer to %q#T
de: Zeiger auf %q#T kann nicht deklariert werden

en: cannot declare pointer to %q#T member
de: Zeiger auf Element %q#T kann nicht deklariert werden

en: cannot declare pointer to qualified function type %qT
de: Zeiger auf qualifizierten Funktionstypen %qT kann nicht deklariert werden

en: cannot declare reference to %q#T
de: Referenz auf %q#T kann nicht deklariert werden

en: cannot declare reference to %q#T, which is not a typedef or a template type argument
de: Referenz auf %q#T kann nicht deklariert werden, da letzteres weder Typedef noch Templatetyp-Argument ist

en: cannot declare reference to qualified function type %qT
de: Referenz auf qualifizierten Funktionstypen %qT kann nicht deklariert werden

en: cannot declare static function inside another function
de: statische Funktion innerhalb anderer Funktion kann nicht deklariert werden

en: cannot declare variable %q+D to be of abstract type %qT
de: Variable %q+D kann nicht als vom abstrakten Typ %qT deklariert werden

en: cannot decompose address
de: Adresse kann nicht zerlegt werden

en: cannot decompose class type %qT because it has an anonymous struct member
de: Klassentyp %qT kann nicht dekomponiert werden, da er ein unbenanntes Strukturelement hat

en: cannot decompose class type %qT because it has an anonymous union member
de: Klassentyp %qT kann nicht dekomponiert werden, da er ein unbenanntes Unionelement hat

en: cannot decompose class type %qT without non-static data members
de: Klassentyp %qT ohne nicht-static-Datenelemente kann nicht dekomponiert werden

en: cannot decompose class type %qT: both it and its base class %qT have non-static data members
de: Klassentyp %qT kann nicht dekomponiert werden, da sowohl er als auch seine Basisklasse %qT nichtstatische Datenelemente haben

en: cannot decompose class type %qT: its base classes %qT and %qT have non-static data members
de: Klassentyp %qT kann nicht dekomponiert werden, da seine Basisklassen %qT und %qT nichtstatische Datenelemente haben

en: cannot decompose inaccessible member %qD of %qT
de: unzugreifbares Element %qD von %qT kann nicht dekomponiert werden

en: cannot decompose lambda closure type %qT
de: Lambda-Abschluss-Typ %qT kann nicht dekomponiert werden

en: cannot decompose non-array non-class type %qT
de: nicht-Array-nicht-Klassentyp %qT kann nicht dekomponiert werden

en: cannot decompose union type %qT
de: Union-Typ %qT kann nicht dekomponiert werden

en: cannot decompose variable length array %qT
de: Array mit variabler Länge %qT kann nicht dekomponiert werden

en: cannot decompose variable length vector %qT
de: Vektor %qT variabler Länge kann nicht zerlegt werden

en: cannot decrement a pointer to incomplete type %qT
de: Zeiger auf unvollständigen Typen %qT kann nicht verringert werden

en: cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors
de: Templateargumente für die Kopierinitialisierung von %qT können nicht abgeleitet werden, da es keine expliziten Ableitungshinweise oder benutzerdeklarierten Konstruktoren gibt

en: cannot deduce template arguments of %qT, as it has no viable deduction guides
de: Templateargumente für %qT können nicht abgeleitet werden, da es keine Ableitungshinweise gibt

en: cannot deduce template parameters from introduction list
de: Template-Parameter können nicht aus der Einführungsliste abgeleitet werden

en: cannot default compare anonymous union member
de: für unbenannten Union-Member ist kein Standardvergleich definiert

en: cannot default compare flexible array member
de: für flexible Arraymember ist kein Standardvergleich definiert

en: cannot default compare reference member %qD
de: für Referenzelement %qD ist kein Standardvergleich definiert

en: cannot default compare union %qT
de: für Union-Typ %qT ist kein Standardvergleich definiert

en: cannot define %qD in different module
de: %qD kann nicht in einem anderen Modul definiert sein

en: cannot define friend function %qs in a local class definition
de: %<friend%>-Funktion %qs kann nicht in einer lokalen Klassendefinition definiert werden

en: cannot define member function %<%T::%s%> within %qT
de: Elementfunktion %<%T::%s%> kann nicht innerhalb von %qT definiert werden

en: cannot define member of dependent typedef %qT
de: Element des abhängigen Typedef %qT kann nicht definiert werden

en: cannot delete a function.  Only pointer-to-objects are valid arguments to %<delete%>
de: Eine Funktion kann nicht gelöscht werden. Nur Zeiger auf Objekte sind gültige Argumente für %<delete%>

en: cannot delete objects with SVE type %qT
de: Objekte vom SVE-Typ %qT können nicht gelöscht werden

en: cannot dereference %qE in %qs clause
de: %qE in %qs-Klausel kann nicht dereferenziert werden

en: cannot derive from %<final%> base %qT in derived type %qT
de: Es kann nicht von %<final%>-Basis %qT in abgeleiteten Typ %qT abgeleitet werden

en: cannot determine %<#include%> translation of %s: %s
de: Fehler beim Bestimmen der %<#include%>-Übersetzung von %s: %s

en: cannot determine the length of a %qs
de: die Länge von %qs kann nicht bestimmt werden

en: cannot disable built-in function %qs
de: Eingebaute Funktion %qs kann nicht abgeschaltet werden

en: cannot emit unaligned pointers in ptx assembly
de: in PTX-Assembler können keine unausgerichteten Zeiger erzeugt werden

en: cannot execute %qs: %s
de: %qs kann nicht ausgeführt werden: %s

en: cannot execute %qs: %s: %m
de: %qs kann nicht ausgeführt werden: %s: %m

en: cannot expand initializer for member %qD
de: Initialisierung für Element %qD kann nicht expandiert werden

en: cannot explicitly declare member %q#D to have extern linkage
de: Element %q#D kann nicht explizit deklariert werden, externe Bindung zu haben

en: cannot extend PCH file: %m
de: PCH-Datei kann nicht erweitert werden: %m

en: cannot fallthrough final case in switch
de: fallthrough ist bei letztem Fall einer switch-Anweisung unmöglich

en: cannot find %<ldd%>
de: %<ldd%> kann nicht gefunden werden

en: cannot find %<nm%>
de: %<nm%> kann nicht gefunden werden

en: cannot find %qs
de: %qs kann nicht gefunden werden

en: cannot find %s in plugin %s
    %s
de: %s kann nicht in Plugin %s gefunden werden
    %s

en: cannot find %s in plugin %s: %s
de: %s kann nicht in Plugin %s gefunden werden: %s

en: cannot find LTO cgraph in %s
de: LTO cgraph kann in %s nicht gefunden werden

en: cannot find LTO section refs in %s
de: LTO-Abschnittsreferenzen können in %s nicht gefunden werden

en: cannot find a register in class %qs while reloading %<asm%>
de: in der Klasse %qs konnte während des Neuladens von %<asm%> kein Register gefunden werden

en: cannot find a valid counter name %qs of %<-fdbg-cnt=%> option
de: kein gültiger Zählername %qs auffindbar für Option %<-fdbg-cnt=%>

en: cannot find class %qE
de: Klasse %qE kann nicht gefunden werden

en: cannot find instance variable associated with property
de: mit Eigenschaft verbundene Instanzvariable nicht gefunden

en: cannot find interface declaration for %qE
de: Schnittstellendeklaration für %qE kann nicht gefunden werden

en: cannot find interface declaration for %qE, superclass of %qE
de: Schnittstellendeklaration für %qE, Basisklasse von %qE, kann nicht gefunden werden

en: cannot find protocol declaration for %qE
de: Protokolldeklaration für %qE kann nicht gefunden werden

en: cannot find reference tag for class %qE
de: Referenzmarke für Klasse %qE kann nicht gefunden werden

en: cannot form pointer to member of non-class %q#T
de: Zeiger auf Element der Nicht-Klasse %q#T kann nicht erzeugt werden

en: cannot generate position-independent code for %qs
de: für %qs kann kein lageunabhängiger Code erzeugt werden

en: cannot get frame pointer to %qs
de: Zugriff auf den Rahmenzeiger von %qs ist nicht möglich

en: cannot get position in PCH file: %m
de: Position in PCH-Datei kann nicht ermittelt werden: %m

en: cannot get program status: %m
de: Programmstatus kann nicht ermittelt werden: %m

en: cannot handle comparison of type %<%s == %s%>
de: Vergleich vom Typ %<%s == %s%> kann nicht verarbeitet werden

en: cannot handle inconsistent calls to %qs
de: inkonsistente Aufrufe von %qs können nicht behandelt werden

en: cannot handle switch condition of type %s
de: Switch-Bedingung vom Typ %s kann nicht verarbeitet werden

en: cannot honor conflicting %qs clause
de: widersprüchliche %qs-Klausel kann nicht berücksichtigt werden

en: cannot import module in its own purview
de: ein Modul kann nicht in seinen eigenen Bereich importiert werden

en: cannot increment a pointer to incomplete type %qT
de: Zeiger auf unvollständigen Typen %qT kann nicht erhöht werden

en: cannot initialize a return object of type %qT with an rvalue of type %<void%>
de: ein Rückgabeobjekt vom Typ %qT kann nicht mit einem r-Wert vom Typ %<void%> initialisiert werden

en: cannot initialize aggregate of type %qT with a compound literal
de: Aggregat des Typs %qT kann nicht mit zusammengesetztem Literal initialisiert werden

en: cannot initialize array of %qT from a string literal with type array of %qT
de: Array von %qT kann nicht aus einem Zeichenkettenliteral mit Typ %<Array von %T%> initialisiert werden

en: cannot inline function %<main%>
de: %<main%> ist nicht als »inline« möglich

en: cannot instantiate %<coroutine traits%>
de: %<coroutine traits%> kann nicht instanziiert werden

en: cannot instantiate a %<coroutine handle%> for promise type %qT
de: %<coroutine handle%> konnte für den Versprechen-Typ %qT nicht instanziiert werden

en: cannot load plugin %s
    %s
de: Plugin %s kann nicht geladen werden
    %s

en: cannot load plugin %s: %s
de: Plugin %s kann nicht geladen werden: %s

en: cannot mix operands of decimal floating and complex types
de: Operanden von dezimalen Gleitkomma- und komplexen Typen können nicht gemischt werden

en: cannot mix operands of decimal floating and other floating types
de: Operanden von dezimalen und anderen Gleitkommatypen können nicht gemischt werden

en: cannot mix operands of decimal floating and vector types
de: Operanden von dezimalen Gleitkomma- und Vektortypen können nicht gemischt werden

en: cannot nest more than %d namespaces
de: es können maximal %d Namensräume geschachtelt werden

en: cannot open %qs for writing: %m
de: %qs kann nicht zum Schreiben geöffnet werden: %m

en: cannot open %s
de: »%s« kann nicht geöffnet werden

en: cannot open %s for writing: %m
de: %s kann nicht zum Schreiben geöffnet werden: %m

en: cannot open %s: %m
de: %s kann nicht geöffnet werden: %m

en: cannot open '%s'
de: »%s« kann nicht geöffnet werden

en: cannot open file %qs for writing optimization records
de: Datei %qs kann nicht zum Schreiben der Optimierungsdatensätze geöffnet werden

en: cannot open intermediate gcn asm file
de: Zwischenspeicherdatei für gcn-asm kann nicht geöffnet werden

en: cannot open intermediate gcn obj file
de: Zwischenspeicherdatei für gcn-obj kann nicht geöffnet werden

en: cannot open intermediate ptx file
de: zwischenzeitliche ptx-Datei kann nicht geöffnet werden

en: cannot open ldd output: %m
de: ldd-Ausgabe kann nicht geöffnet werden: %m

en: cannot open nested response file
de: Verschachtelte Antwortdatei konnte nicht geöffnet werden

en: cannot open nm output: %m
de: nm-Ausgabe kann nicht geöffnet werden: %m

en: cannot open profile file %s
de: Profilingdatei %s kann nicht geöffnet werden

en: cannot pass argument in vector register because altivec instructions are disabled, use %qs to enable them
de: Argument kann nicht in Vektorregister übergegeben werden, da AltiVec-Befehle ausgeschaltet sind; %qs schaltet sie ein

en: cannot put object with volatile field into register
de: Objekt mit volatile-Feld kann nicht in Register geladen werden

en: cannot read %<LTO_section_decls%> from %s
de: Fehler beim Einlesen von %<LOT_section_decls%> aus %s

en: cannot read %s: %m
de: %s kann nicht gelesen werden: %m

en: cannot read LTO mode table from %s
de: LTO-Modus-Tabelle kann nicht aus %s gelesen werden

en: cannot read PCH file: %m
de: PCH-Datei kann nicht gelesen werden: %m

en: cannot read function profile from %s
de: Funktionsprofil aus %s kann nicht gelesen werden

en: cannot read spec file %qs: %m
de: Spec-Datei %qs kann nicht gelesen werden: %m

en: cannot read string table from %s
de: Zeichenkettentabelle aus %s konnte nicht gelesen werden

en: cannot receive reference type %qT through %<...%>
de: Referenztyp %qT kann nicht über %<...%> empfangen werden

en: cannot reload integer constant operand in %<asm%>
de: Ganzzahlkonstantenoperand kann in %<asm%> nicht neu geladen werden

en: cannot represent built-in %<va_list%> type in D
de: der eingebauten Typ %<va_list%> kann nicht D nicht dargestellt werden

en: cannot resolve overloaded function %qD based on conversion to type %qT
de: überladene Funktion %qD konnte nicht durch Umwandlung in Typ %qT aufgelöst werden

en: cannot return from a handler of a function-try-block of a constructor
de: vom Behandler eines Funktions-try-Blocks eines Konstruktors kann nicht zurückgekehrt werden

en: cannot return value in vector register because altivec instructions are disabled, use %qs to enable them
de: Wert kann nicht in Vektorregister zurückgegeben werden, da AltiVec-Befehle ausgeschaltet sind; %qs schaltet sie ein

en: cannot set %qE attribute after definition
de: Attribut %qE kann nicht nach der Definition festgelegt werden

en: cannot set interrupt attribute: no current function
de: Unterbrechungsattribut kann nicht gesetzt werden; keine aktuelle Funktion

en: cannot set interrupt attribute: no such identifier
de: Unterbrechungsattribut kann nicht gesetzt werden: kein solcher Bezeichner

en: cannot set position in PCH file: %m
de: Position in PCH-Datei kann nicht festgelegt werden: %m

en: cannot specialize concept %q#D
de: Konzept %q#D kann nicht spezialisiert werden

en: cannot specify %<-o%> with %<-c%>, %<-S%> or %<-E%> with multiple files
de: %<-o%> kann nicht mit %<-c%>, %<-S%> oder %<-E%> mit mehreren Dateien angegeben werden

en: cannot specify %<override%> for a class
de: für eine Klasse kann kein %<override%> angegeben werden

en: cannot specify -static with -fsanitize=address
de: »-static« kann nicht mit »-fsanitize=Adresse« angegeben werden

en: cannot specify -static with -fsanitize=hwaddress
de: »-static« kann nicht mit »-fsanitize=hwaddress« angegeben werden

en: cannot specify -static with -fsanitize=thread
de: »-static« kann nicht mit »-fsanitize=thread« angegeben werden

en: cannot specify both %<-msep-data%> and %<-mid-shared-library%>
de: %<-msep-data%> und %<-mid-shared-library%> können nicht zusammen angegeben werden

en: cannot tail-call: %s
de: Tail-Call nicht möglich: %s

en: cannot take address of %qs
de: die Adresse von %qs kann nicht ermittelt werden

en: cannot take address of bit-field %qD
de: die Adresse des Bit-Feldes %qD kann nicht ermittelt werden

en: cannot take address of scalar with reverse storage order
de: Adresse eines Skalars mit umgekehrter Speicherreihenfolge kann nicht ermittelt werden

en: cannot take the address of %<this%>, which is an rvalue expression
de: Adresse von %<this%> kann nicht ermittelt werden, das ein R-Wert-Ausdruck ist

en: cannot throw C++ classes
de: C++-Klassen können nicht geworfen werden

en: cannot throw COM objects
de: COM-Objekte können nicht geworfen werden

en: cannot throw expression of type %qT because it involves types of variable size
de: Ausdruck vom Typ %qT kann nicht geworfen werden, da Typen mit variabler Größe beteiligt sind

en: cannot throw or catch SVE type %qT
de: der SVE-Typ %qT kann weder geworfen noch gefangen werden

en: cannot type switch on non-interface value
de: Typ-Switch mit Nicht-Interface-Wert ist nicht möglich

en: cannot update SSA form
de: SSA-Form kann nicht aktualisiert werden

en: cannot use %<-%> as input filename for a precompiled header
de: der Eingabedateiname für einen vorkompilierten Header darf nicht %<-%> sein

en: cannot use %<-mtp=cp15%> with 16-bit Thumb
de: %<-mtp=cp15%> kann nicht mit 16-Bit-Thumb verwendet werden

en: cannot use %<::%> in parameter declaration
de: %<::%> kann nicht in Parameterdeklaration verwendet werden

en: cannot use %<indirect_call%> attribute under linux toolchain
de: In der Linux-Toolchain kann das Attribut %<indirect_call%> nicht verwendet werden

en: cannot use %<typeid%> with %<-fno-rtti%>
de: %<typeid%> kann nicht mit %<-fno-rtti%> verwendet werden

en: cannot use %<va_arg%> with reverse storage order
de: %<va_arg%> kann nicht zusammen mit umgedreher Speicherreihenfolge verwendet werden

en: cannot use %<va_start%> in interrupt function
de: %<va_start%> kann nicht in Unterbrechungsfunktion verwendet werden

en: cannot use %qs as a call-saved register
de: %qs kann nicht als ein rufgesichertes Register verwendet werden

en: cannot use %qs as a call-used register
de: %qs kann nicht als ein rufverwendetes Register verwendet werden

en: cannot use %qs as a fixed register
de: %qs kann nicht als ein festes Register verwendet werden

en: cannot use an object as parameter to a method
de: ein Objekt kann nicht als Parameter für eine Methode verwendet werden

en: cannot use exception attributes to function %qD under linux toolchain
de: In der Linux-Toolchain kann die Funktion %qD nicht das Attribut »exception« haben

en: cannot use interrupt attributes to function %qD under linux toolchain
de: In der Linux-Toolchain kann die Funktion %qD nicht das Attribut »interrupt« haben

en: cannot use mode %qs for enumerated types
de: Modus %qs kann nicht für Aufzählungstypen verwendet werden

en: cannot use mshared and static together
de: mshared und static können nicht zusammen verwendet werden

en: cannot use mthreads and mlegacy-threads together
de: mthreads und mlegacy-threads können nicht zusammen verwendet werden

en: cannot use multiple stack checking methods together
de: Es können nicht mehrere Stapelprüfungsmethoden gleichzeitig verwendet werden

en: cannot use reset attributes to function %qD under linux toolchain
de: In der Linux-Toolchain kann die Funktion %qD nicht das Attribut »exception« haben

en: cannot use small-data accesses for %qs
de: Kleindatenzugriffe für %qs nicht möglich

en: cannot use type %s as type %s
de: Typ %s kann nicht als Typ %s verwendet werden

en: cannot value-initialize array of unknown bound %qT
de: Feld mit unbekannter Grenze %qT kann nicht mit Werten initialisiert werden

en: cannot write %s: %m
de: %s kann nicht geschrieben werden: %m

en: cannot write PCH file
de: PCH-Datei kann nicht geschrieben werden

en: cannot write PCH file: %m
de: PCH-Datei kann nicht geschrieben werden: %m

en: cannot write PCH file: required memory segment unavailable
de: PCH-Datei kann nicht geschrieben werden: erforderliches Speichersegment nicht verfügbar

en: cannot write padding to PCH file: %m
de: Auffüllung für PCH-Datei kann nicht geschrieben werden: %m

en: cannot write to %s: %m
de: in %s kann nicht geschrieben werden: %m

en: canonical types differ for identical types %qT and %qT
de: kanonische Typen unterscheiden sich für identische Typen %qT und %qT

en: capture by copy of SVE type %qT
de: der SVE-Typ %qT kann nicht durch Kopieren gefangen werden

en: capture by copy of incomplete type %qT
de: Einfangen per Kopie von unvollständigem Typ %qT

en: capture of non-variable %qE
de: Erfassung von Nicht-Variable %qE

en: capture of variable %qD with non-automatic storage duration
de: Erfassung der Variable %qD ohne automatische Speicherdauer

en: capture of variably-modified type %qT that is not an N3639 array of runtime bound
de: Einfangen des variabel geänderten Typs %qT, der kein N3639-Array mit Laufzeitgrenzen ist

en: case label %qE not within a switch statement
de: case-Marke %qE nicht innerhalb einer switch-Anweisung

en: case label does not reduce to an integer constant
de: case-Marke reduziert nicht auf Ganzzahlkonstante

en: case label is not an integer constant expression
de: »case«-Marke ist kein konstanter Ganzzahlausdruck

en: case label not within a switch statement
de: case-Marke nicht innerhalb einer switch-Anweisung

en: case label value exceeds maximum value for type
de: case-Marke überschreitet Maximalwert des Typs

en: case label value is less than minimum value for type
de: case-Marke ist kleiner als Minimalwert des Typs

en: case labels not sorted in switch statement
de: unsortierte case-Marken in switch-Anweisung

en: case labels not sorted:
de: Interner Fehler: case labels not sorted:

en: case value %qs not in enumerated type
de: case-Wert %qs nicht in Aufzählungstyp

en: case value %qs not in enumerated type %qT
de: case-Wert %qs nicht in Aufzählungstyp %qT

en: cast adds %q#v qualifier to function type
de: Typumwandlung fügt Qualifizierer %q#v zu Funktionstyp hinzu

en: cast between incompatible function types from %qH to %qI
de: Umwandlung zwischen inkompatiblen Funktionstypen von %qH nach %qI

en: cast between incompatible function types from %qT to %qT
de: unvollständiger Funktionstyp %qT kann nicht nach %qT umgewandelt werden

en: cast between incompatible pointer to member types from %qH to %qI
de: Umwandlung zwischen inkompatiblen Elementzeigertypen von %qH nach %qI

en: cast discards %qv qualifier from pointer target type
de: Typumwandlung streicht Qualifizierer %qv von Zeiger-Zieltyp

en: cast from %qH to %qI increases required alignment of target type
de: Umwandlung von %qH in %qI erhöht erforderliche Ausrichtung des Zieltyps

en: cast from %qH to %qI loses precision
de: Typumwandlung von %qH nach %qI verliert Genauigkeit

en: cast from %qT is not allowed
de: Cast von %qT ist nicht erlaubt

en: cast from %qs to %qs will produce zero result
de: Umwandlung von %qs nach %qs führt zum Ergebnis 0

en: cast from function call of type %qT to non-matching type %qT
de: Typumwandlung von Funktionsaufruf des Typs %qT in unpassenden Typen %qT

en: cast from pointer to integer of different size
de: Typkonvertierung von Zeiger auf Ganzzahl anderer Breite

en: cast from type %qT to type %qT casts away qualifiers
de: Umwandlung des Typs %qT in Typ %qT entfernt Qualifizierer

en: cast increases required alignment of target type
de: Typkonvertierung erfordert Ausrichtung des Zieltyps

en: cast specifies array type
de: Typkonvertierung gibt Arraytyp an

en: cast specifies function type
de: Typkonvertierung gibt Funktionstyp an

en: cast to %qs will produce null result
de: die Umwandlung nach %qs ergibt immer »null«

en: cast to %s address space pointer from disjoint %s address space pointer
de: Umwandlung in %s-Adressraumzeiger von getrenntem %s-Adressraumzeiger

en: cast to %s address space pointer from disjoint generic address space pointer
de: Umwandlung in %s-Adressraumzeiger aus getrenntem allgemeinen Adressraumzeiger

en: cast to generic address space pointer from disjoint %s address space pointer
de: Umwandlung in allgemeinen Adressraumzeiger von getrenntem %s-Adressraumzeiger

en: cast to non-integral type %qT in a constant expression
de: Umwandlung in Nicht-Ganzzahltyp %qT in konstantem Ausdruck

en: cast to pointer from integer of different size
de: Typkonvertierung in Zeiger von Ganzzahl anderer Breite

en: cast to union type from type not present in union
de: Typkonvertierung in union-Typ von nicht in union vorhandenem Typen

en: casting %qT to %qT does not dereference pointer
de: Umwandlung von %qT in %qT dereferenziert nicht den Zeiger

en: casting between pointer-to-function and pointer-to-object is conditionally-supported
de: Umwandlung zwischen Zeiger auf Funktion und Zeiger auf Objekt ist bedingt unterstützt

en: catching non-reference type %q#T
de: Nichtreferenztyp %q#T wird gefangen

en: catching polymorphic type %q#T by value
de: polymorpher Typ %q#T wird per Wertzuweisung gefangen

en: catching type %q#T by value
de: Typ %q#T wird per Wertzuweisung gefangen

en: category attributes are not available in Objective-C 1.0
de: Kategorie-Attribute sind in Objective-C 1.0 nicht verfügbar

en: category attributes are not available in this version of the compiler, (ignored)
de: Kategorie-Attribute sind in dieser Version des Compilers nicht verfügbar (wird ignoriert)

en: cdecl and thiscall attributes are not compatible
de: Attribute cdecl und thiscall sind nicht verträglich

en: cgraph count invalid
de: Interner Fehler: cgraph count invalid

en: cgraph_node has wrong clone list
de: Interner Fehler: cgraph_node has wrong clone list

en: cgraph_node has wrong clone_of
de: Interner Fehler: cgraph_node has wrong clone_of

en: cgraph_node has wrong prev_clone pointer
de: Interner Fehler: cgraph_node has wrong prev_clone pointer

en: cgraph_node is in clone list but it is not clone
de: Interner Fehler: cgraph_node is in clone list but it is not clone

en: change of the active member of a union from %qD to %qD
de: Änderung des aktiven Elements einer union von %qD zu %qD

en: change of the active member of a union from %qD to %qD during initialization
de: Änderung des aktiven Elements einer union von %qD zu %qD während der Initialisierung

en: changing the return type from %qs to a comparison category type will allow the comparison to use %qs and %qs
de: wenn Sie den Rückgabetyp von %qs in einen Vergleichskategorietyp ändern, kann der Vergleich %qs und %qs verwenden

en: checksum is (%x,%x) instead of (%x,%x)
de: Prüfsumme ist (%x,%x) statt (%x,%x)

en: choosing %qD over %qD
de: Wahl von %qD statt %qD

en: chunk size value must be positive
de: Wert der Chunkgröße muss positiv sein

en: circular pointer delegation detected
de: ringförmige Zeigerdelegation erkannt

en: class %qE already exists
de: Klasse %qE existiert bereits

en: class %qE defined without specifying a base class
de: Klasse %qE ist definiert, ohne eine Basisklasse anzugeben

en: class %qE is deprecated
de: Klasse %qE ist veraltet

en: class %qE is not available
de: Klasse %qE ist nicht verfügbar

en: class %qE is unavailable
de: Klasse %qE ist nicht verfügbar

en: class %qT does not have any field named %qD
de: Klasse %qT hat keinen Feldnamen %qD

en: class %qT is implicitly friends with itself
de: Klasse %qT ist implizit »friend« von ihr selbst

en: class %qs does not implement the %qE protocol
de: Klasse %qs implementiert nicht das Protokoll %qE

en: class attributes are not available in Objective-C 1.0
de: Klassenattribute sind in Objective-C 1.0 nicht verfügbar

en: class definition may not be declared a friend
de: Klassendefinition darf nicht als »friend« deklariert sein

en: class extension for class %qE declared after its %<@implementation%>
de: Klassenerweiterung für Klasse %qE nach seiner %<@implementation%> deklariert

en: class extensions are not available in Objective-C 1.0
de: Klassenerweiterungen sind in Objective-C 1.0 nicht verfügbar

en: class template %qD redeclared as non-template
de: Klassentemplate %qD als Nicht-Template redeklariert

en: class template argument deduction failed:
de: Argumentherleitung für Klassentemplate gescheitert:

en: class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization
de: Argumentherleitung für Klassentemplate von %qT fehlgeschlagen: expliziter Herleitungshinweis in copy-list-initialization ausgewählt

en: class template argument deduction is only available with %<-std=c++17%> or %<-std=gnu++17%>
de: Argumentherleitung von Klassentemplates ist nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar

en: class template placeholder %qE not permitted in this context
de: Platzhalter für Klassentemplate %qE ist in diesem Kontext nicht erlaubt

en: class type %qT is incomplete
de: Klassentyp %qT ist unvollständig

en: clauses in %<simd%> trait should be separated by %<,%>
de: Klauseln in %<simd%>-Eigenschaft sollten durch %<,%> getrennt werden

en: cleanup argument not a function
de: Argument für cleanup ist keine Funktion

en: cleanup argument not an identifier
de: Argument für cleanup ist kein Bezeichner

en: clones for %<target_clones%> attribute cannot be created
de: Klone für Attribut %<target_clones%> können nicht erzeugt werden

en: closed intervals
de: geschlossene Intervalle

en: closing LTRANS output list %s: %m
de: LTRANS-Ausgabeliste »%s« kann nicht geschlossen werden: %m

en: closing dependency file %s: %m
de: Abhängigkeitsdatei »%s« kann nicht geschlossen werden: %m

en: closing json file %s: %m
de: Fehler beim Schließen der JSON-Datei %s: %m

en: closing mixin file %s: %m
de: Fehler beim Schließen der Mixin-Datei %s: %m

en: coarray argument
de: Coarray-Argument

en: code may be misoptimized unless %<-fno-strict-aliasing%> is used
de: Code könnte fehloptimiert werden, es sei denn, %<-fno-strict-aliasing%> wird angegeben

en: code model %qs and %qs not support %s mode
de: die Codemodelle %qs und %qs unterstützen den Modus %qs nicht

en: code model %qs not supported in ilp32 mode
de: Codemodell %qs wird im ilp32-Modus nicht unterstützt

en: code model %qs not supported in the %s bit mode
de: Codemodell %qs wird im %s-Bit-Modus nicht unterstützt

en: code model %qs not supported in x32 mode
de: Codemodell %qs wird im x32-Modus nicht unterstützt

en: code model %qs with %<-f%s%>
de: Codemodell %qs mit %<-f%s%>

en: code model %s does not support PIC mode
de: Codemodell %s unterstützt keinen PIC-Modus

en: collapse argument needs positive constant integer expression
de: Collapse-Argument erfordert positiven konstanten Ganzzahlausdruck

en: collapsed %s loops not perfectly nested at %L
de: Zusammengefallene »%s«-Schleifen bei %L nicht perfekt geschachtelt

en: collapsed loops not perfectly nested
de: zusammengelegte Schleifen sind nicht perfekt geschachtelt

en: collect2 version %s
de: collect2-Version %s

en: collection in fast enumeration is not an object
de: Sammlung in schneller Aufzählung ist kein Objekt

en: comdat symbol cannot be versioned
de: comdat-Symbole können nicht versioniert werden

en: comdat-local function called by %s outside its comdat
de: Interner Fehler: comdat-local function called by %s outside its comdat

en: comdat-local symbol referred to by %s outside its comdat
de: Interner Fehler: comdat-local symbol referred to by %s outside its comdat

en: comma at end of enumerator list
de: Komma am Ende der Aufzählungsliste

en: comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>
de: kommagetrennte Liste in using-Deklaration ist nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar

en: command-line option %qs is not supported by this configuration
de: Kommandozeilenoption %qs wird von dieser Konfiguration nicht unterstützt

en: command-line option %qs is valid for %s but not for %s
de: Kommandozeilenoption %qs ist gültig für %s, aber nicht für %s

en: command-line option %qs is valid for the driver but not for %s
de: Kommandozeilenoption %qs ist gültig für den Treiber, aber nicht für %s

en: common symbol cannot be versioned
de: gemeinsames Symbol kann nicht versioniert werden

en: common symbol debug info is not structured as symbol+offset
de: Gemeinsame Symbol-Debuginfo ist nicht als Symbol+Offset strukturiert

en: common variables must have an alignment of 32678 or less
de: gemeinsam genutzte Variablen müssen eine Ausrichtung von 32768 oder weniger haben

en: comparing final insns dumps
de: Vergleich der endgültigen Befehlslisten

en: comparing floating-point with %<==%> or %<!=%> is unsafe
de: Vergleich von Gleitkomma mit %<==%> oder %<!=%> ist unsicher

en: comparing the result of pointer addition %qE and NULL
de: Vergleich des Ergebnisses der Zeigeraddition %qE mit NULL

en: comparing vectors with different element types
de: Vergleich von Vektoren mit verschiedenen Element-Typen

en: comparing vectors with different number of elements
de: Vergleich von Vektoren mit unterschiedlicher Elementanzahl

en: comparison always false due to limited range of data type
de: Vergleich ist durch beschränkten Wertebereich des Datentyps stets »unwahr«

en: comparison always true due to limited range of data type
de: Vergleich ist durch beschränkten Wertebereich des Datentyps stets »wahr«

en: comparison between %q#T and %q#T
de: Vergleich zwischen %q#T und %q#T

en: comparison between %qT and %qT
de: Vergleich zwischen %qT und %qT

en: comparison between distinct pointer types %qT and %qT lacks a cast
de: Vergleich zwischen den unterschiedlichen Zeigertypen %qT und %qT benötigt Umwandlung

en: comparison between distinct pointer-to-member types %qT and %qT lacks a cast
de: beim Vergleich zwischen unterschiedlichen Zeiger-auf-Element-Typen %qT und %qT fehlt eine Typkonvertierung

en: comparison between pointer and integer
de: Vergleich zwischen Zeiger und Ganzzahl

en: comparison between pointer and zero character constant
de: Vergleich zwischen Zeiger und '\0'

en: comparison between two arrays
de: Vergleich zwischen zwei Arrays

en: comparison between two arrays is deprecated in C++20
de: Vergleich zwischen zwei Arrays ist in C++20 veraltet

en: comparison between types %qT and %qT
de: Vergleich zwischen den Typen %qT und %qT

en: comparison is always %d
de: Vergleich ist immer %d

en: comparison is always %d due to width of bit-field
de: Vergleich ist immer %d wegen Breite des Bitfeldes

en: comparison is always false due to limited range of data type
de: Vergleich ist durch beschränkten Wertebereich des Datentyps stets »unwahr«

en: comparison is always true due to limited range of data type
de: Vergleich ist durch beschränkten Wertebereich des Datentyps stets »wahr«

en: comparison of complete and incomplete pointers
de: Vergleich von vollständigen und unvollständigen Zeigern

en: comparison of constant %qE with boolean expression is always false
de: Vergleich der Konstanten %qE mit booleschem Ausdruck ist stets »false«

en: comparison of constant %qE with boolean expression is always true
de: Vergleich der Konstanten %qE mit booleschem Ausdruck ist stets »true«

en: comparison of distinct Objective-C types lacks a cast
de: Im Vergleich verschiedener Objective-C-Typen fehlt Typumwandlung

en: comparison of distinct pointer types lacks a cast
de: in Vergleich verschiedener Zeigertypen fehlt Typkonvertierung

en: comparison of enumeration type %qT with floating-point type %qT is deprecated
de: Vergleich zwischen Aufzählungstyp %qT und Gleitkommatyp %qT ist veraltet

en: comparison of floating-point type %qT with enumeration type %qT is deprecated
de: Vergleich zwischen Gleitkommatyp %qT und Aufzählungstyp %qT ist veraltet

en: comparison of integer expressions of different signedness: %qT and %qT
de: Vergleich von Ganzzahlausdrücken, von denen nur einer ein Vorzeichen hat: %qT und %qT

en: comparison of pointers to disjoint address spaces
de: Vergleich von Zeigern auf disjunkte Adressräume

en: comparison of promoted bitwise complement of an unsigned value with constant
de: Vergleich von befördertem bitweisem Komplement eines vorzeichenlosen Werts mit einer Konstanten

en: comparison of promoted bitwise complement of an unsigned value with unsigned
de: Vergleich von befördertem bitweisem Komplement eines vorzeichenlosen Werts mit einer vorzeichenlosen Zahl

en: comparison of unsigned expression in %<< 0%> is always false
de: Vergleich eines vorzeichenlosen Ausdrucks in %<< 0%> ist stets unwahr

en: comparison of unsigned expression in %<>= 0%> is always true
de: Vergleich eines vorzeichenlosen Ausdrucks in %<>= 0%> ist stets wahr

en: comparison operator %q+D defaulted after its first declaration
de: Vergleichsoperator %q+D mit Standardimplementierung nach der ersten Deklaration [class.compare.default]

en: comparison required
de: Vergleich erforderlich

en: comparison with string literal results in unspecified behavior
de: Vergleich mit Zeichenkettenliteral führt zu unspezifiziertem Verhalten

en: comparisons like %<X<=Y<=Z%> do not have their mathematical meaning
de: Vergleiche wie %<X<=Y<=Z%> haben nicht ihre mathematische Bedeutung

en: compatible type is here
de: der kompatible Typ ist hier

en: compilation terminated due to -Wfatal-errors.
de: Kompilierung wegen »-Wfatal-errors« beendet.

en: compilation terminated due to -fmax-errors=%u.
de: Kompilierung wegen »-fmax-errors=%u« beendet.

en: compilation terminated.
de: Kompilierung beendet.

en: compiled module file is %qs
de: die compilierte Moduldatei ist %qs

en: compiled module is %sversion %s
de: das kompilierte Modul ist %sVersion %s

en: compiler does not support ZSTD LTO compression
de: der Compiler unterstützt ZSTD-LTO-Komprimierung nicht

en: compiler is %sversion %s%s%s
de: der Compiler ist %sVersion %s%s%s

en: complex argument %u to decimal-only type-generic function
de: komplexes Argument %u für typgenerische Funktion, die ausschließlich dezimal ist

en: complex arguments must have floating-point type
de: komplexe Argumente müssen Gleitkommatyp haben

en: complex arguments must have identical types
de: komplexe Argumente müssen identische Typen haben

en: complex floating point overflow in expression %qE of type %qT results in %qE
de: Überlauf von komplexen Gleitkommazahlen in Ausdruck %qE des Typs %qT ergibt %qE

en: complex floating point overflow in expression of type %qT results in %qE
de: Überlauf von komplexen Gleitkommazahlen in Ausdruck des Typs %qT ergibt %qE

en: complex integer overflow in expression %qE of type %qT results in %qE
de: Überlauf von komplexen Ganzzahlen in Ausdruck %qE des Typs %qT ergibt %qE

en: complex integer overflow in expression of type %qT results in %qE
de: Überlauf von komplexen Ganzzahlen in Ausdruck des Typs %qT ergibt %qE

en: complex invalid for %qs
de: complex ungültig für %qs

en: component %qs at %L has already been set by a parent derived type constructor
de: Komponente %qs bei %L wurde bereits von Konstruktor für abgeleitete Typen durch einen Elternteil gesetzt

en: compound assignment with %<volatile%>-qualified left operand is deprecated
de: Verbundzuweisung mit %<volatile%>-qualifiziertem linken Operanden ist veraltet

en: compound literal has variable size
de: zusammengesetztes Literal hat variable Größe

en: compound literal of non-object type %qT
de: zusammengesetztes Literal vom Nicht-Objekt-Typ %qT

en: compound literal qualified by address-space qualifier
de: Verbundliteral durch Adressraumqualifizierer qualifiziert

en: compound-statement in %<constexpr%> function
de: zusammengesetzte Anweisung in %<constexpr%>-Funktion

en: compressed stream: %s
de: komprimierter Strom: %s

en: computed goto must be pointer type
de: das berechnete Goto muss von einem Zeigertyp sein

en: concatenation of string literals with conflicting encoding prefixes
de: Verkettung von String-Literalen mit widersprüchlichen Kodierungspräfixen

en: concept %q#D declared with a deduced return type
de: Konzept %q#D mit hergeleitetem Rückgabetyp deklariert

en: concept %q#D declared with function parameters
de: Konzept %q#D mit Funktionsparametern deklariert

en: concept %q#D with non-%<bool%> return type %qT
de: Konzept %q#D mit nicht-%<bool%>-Rückgabetyp %qT

en: concept %qD has no definition
de: Konzept %qD hat keine Definition

en: concept %qE has multiple template parameter lists
de: das Konzept %qE hat mehrere Vorlagenparameterlisten

en: concept %qE not in namespace scope
de: das Konzept %qE ist nicht im Gültigkeitsbereich des Namensraums

en: concept defined here
de: das Konzept wurde hier definiert

en: concept must be defined at namespace scope
de: Konzept muss im Gültigkeitsbereich des Namensbereiches definiert werden

en: concept must have type %<bool%>
de: Konzept muss Typ %<bool%> haben

en: concept-id %qD in nested-name-specifier
de: Konzept-ID %qD in geschachteltem Namens-Spezifizierer

en: condition declares a function
de: Bedingung deklariert eine Funktion

en: condition declares an array
de: Bedingung deklariert ein Array

en: condition expression refers to iteration variable %qD
de: Bedingungsausdruck verweist auf Iterationsvariable %qD

en: conditional %<lastprivate%> clause on %qs construct
de: bedingte %<lastprivate%>-Klausel im %qs-Konstrukt

en: conditional %<lastprivate%> on loop iterator %qD ignored
de: bedingte %<lastprivate%>-Klausel an Schleifeniterator %qD wird ignoriert

en: conditional expression between distinct pointer types %qT and %qT lacks a cast
de: Bedingungsausdruck mit den unterschiedlichen Zeigertypen %qT und %qT benötigt Umwandlung

en: conditional expression between distinct pointer-to-member types %qT and %qT lacks a cast
de: im Bedingungsausdruck mit unterschiedlichen Zeiger-auf-Element-Typen %qT und %qT fehlt eine Typkonvertierung

en: conditional expression between enumeration type %qT and floating-point type %qT is deprecated
de: Bedingungsausdruck zwischen Aufzählungstyp %qT und Gleitkommatyp %qT ist veraltet

en: conditional expression between floating-point type %qT and enumeration type %qT is deprecated
de: Bedingungsausdruck zwischen Gleitkommatyp %qT und Aufzählungstyp %qT ist veraltet

en: conditional expression in operand of fold-expression
de: bedingter Ausdruck in Operand von Faltungsausdruck

en: conditionally executed loop in %<kernels%> region will be executed by a single gang; ignoring %<gang%> clause
de: bedingt ausgeführte Schleife im der Region %<kernels%> wird von einer einzelnen Bande ausgeführt; %<gang%>-Klausel wird ignoriert

en: conflicting C language linkage declaration %q#D
de: in Konflikt stehende Deklaration %q#D mit Bindung für die Sprache "C"

en: conflicting access specifications for field %qE, ignored
de: Zugriffsangaben für Feld %qE stehen in Konflikt, ignoriert

en: conflicting access specifications for method %q+D, ignored
de: Zugriffsangaben für Methode %q+D stehen in Konflikt, ignoriert

en: conflicting code generation switches
de: widersprüchliche Codegenerierungsschalter

en: conflicting declaration %q#D
de: in Konflikt stehende Deklaration %q#D

en: conflicting declaration of %q#D with %qL linkage
de: steht mit neuer Deklaration von %q#D mit %qL-Bindung in Konflikt

en: conflicting declaration of C function %q#D
de: in Konflikt stehende Deklaration für C-Funktion %q#D

en: conflicting declaration of template %q#D
de: unverträgliche Deklaration des Templates %q#D

en: conflicting exporting declaration %qD
de: in Konflikt stehende Export-Deklaration %qD

en: conflicting global module declaration %#qD
de: widersprüchliche globale Moduldeklaration %#qD

en: conflicting named address spaces (%s vs %s)
de: in Konflikt stehende benannte Adressräume (%s und %s)

en: conflicting named address spaces (%s vs %s) for %q+D
de: in Konflikt stehende benannte Adressräume (%s und %s) für %q+D

en: conflicting named address spaces (%s vs generic) for %q+D
de: in Konflikt stehende benannte Adressräume (%s und generisch) für %q+D

en: conflicting named address spaces (generic vs %s) for %q+D
de: in Konflikt stehende benannte Adressräume (generisch und %s) für %q+D

en: conflicting reduction operations for %qE
de: In Konflikt stehende Reduktionsoperationen für %qE

en: conflicting return type specified for %q+#D
de: in Konflikt stehenden Rückgabetyp für %q+#D angegeben

en: conflicting specifiers in declaration of %qs
de: in Konflikt stehende Spezifikationen für Deklaration von %qs

en: conflicting super class name %qE
de: in Konflikt stehender Basisklassenname %qE

en: conflicting type attributes specified for %q+#D
de: in Konflikt stehenden Typattribute für %q+#D angegeben

en: conflicting type qualifiers for %q+D
de: In Konflikt stehende Typqualifizierer für %q+D

en: conflicting types for %<%c%s%>
de: in Konflikt stehende Typen für %<%c%s%>

en: conflicting types for %q+D
de: In Konflikt stehende Typen für %q+D

en: conflicting types for %q+D; have %qT
de: abweichende Typen für %q+D; der bestehende Typ ist %qT

en: conflicting types for built-in function %q+D; expected %qT
de: in Konflikt stehende Typen für eingebaute Funktion %q+D; erwartet wurde %qT

en: conflicting use of %<-mcustom%> switches, target attributes, and/or %<__builtin_custom_%> functions
de: Fehlerhafte Verwendung von %<-mcustom%>-Schaltern, Zielattributen und/oder %<__builtin_custom_%>-Funktionen

en: conflicts with %qD
de: Konflikt mit %qD

en: consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit
de: erwägen Sie die Verwendung von %<-fno-module-lazy%>, die Erhöhung des Wertes von %<-param-lazy-modules=%u%> oder die Erhöhung der prozessspezifischen Dateideskriptorgrenze

en: consider using '-pg' instead of '-p' with gprof(1)
de: evtl. »-pg« statt »-p« mit gprof(1) verwendet

en: consider using `-pg' instead of `-p' with gprof (1)
de: evtl. »-pg« statt »-p« mit gprof(1) verwenden

en: consider using `-pg' instead of `-p' with gprof(1)
de: evtl. »-pg« statt »-p« mit gprof(1) verwenden

en: const, volatile or restrict qualified type in %<#pragma omp declare reduction%>
de: mit const, volatile oder restrict qualifizierter Typ in %<#pragma omp declare reduction%>

en: const/copy propagation disabled
de: Übertragung von const/copy ausgeschaltet

en: const_double_split got a bad insn:
de: const_double_split bekam einen falschen Befehl:

en: constant argument %d for builtin %qF is invalid (%s)
de: konstantes Argument %d für eingebautes %qF ist ungültig (%s)

en: constant argument %d for builtin %qF is out of range (%wd-%wd)
de: konstantes Argument %d für eingebaute %qF liegt außerhalb des Bereichs %wd bis %wd

en: constant argument %d for builtin %qF is out of range (0-%wu)
de: konstantes Argument %d für eingebaute %qF liegt außerhalb des Bereichs 0 bis %wu

en: constant argument %d for builtin %qF is out of range for target type
de: Konstantes Argument %d für eingebaute %qF liegt außerhalb des Wertebereiches für Zieltyp

en: constant argument out of range for %qs
de: Konstantes Argument außerhalb des Wertebereiches für %qs

en: constant argument out of range for %s
de: Konstantes Argument außerhalb des Wertebereiches für %s

en: constant field %qD used as %<asm%> output
de: konstantes Feld %qD als %<asm%>-Ausgabe verwendet

en: constant not recomputed when %<ADDR_EXPR%> changed
de: Konstante wird bei %<ADDR_EXPR%>-Änderung nicht neu berechnet

en: constant refers to itself
de: Konstante verweist auf sich selbst

en: constant value required for builtin %qF argument %d
de: Konstanter Wert erwartet für Argument %2$d der eingebauten Funktion %1$qF

en: constraint %qE has type %qT, not %<bool%>
de: Einschränkung %qE ist vom Typ %qT, muss aber %<bool%> sein

en: constraint expression does not have type %<bool%>
de: Einschränkungsausdruck muss vom Typ %<bool%> sein

en: constraint mismatch at argument %d in template parameter list for %qD
de: unpassende Beschränkungen für Argument %d in Template-Parameterliste für %qD

en: constraints not satisfied
de: Einschränkungen sind nicht erfüllt

en: constraints on a non-templated function
de: Einschränkungen auf einer Funktion, die kein Template hat

en: constructor cannot be static member function
de: Konstruktor kann keine statische Elementfunktion sein

en: constructor delegates to itself
de: Konstruktor verweist auf sich selbst

en: constructor delegation follows mem-initializer for %qD
de: Konstruktordelegation folgt Speicherinitialisierung für %qD

en: constructor for alien class %qT cannot be a member
de: Konstruktor für fremde Klasse %qT kann kein Element sein

en: constructor is not user-provided because it is explicitly defaulted in the class body
de: Konstruktor ist nicht benutzerdefiniert, da er im Klassenkörper ausdrücklich standardisiert ist

en: constructor priorities are not supported
de: Konstruktorprioritäten werden nicht unterstützt

en: constructor priorities from 0 to %d are reserved for the implementation
de: Konstruktorprioritäten von 0 bis %d sind für die Implementierung vorbehalten

en: constructor priorities must be integers from 0 to %d inclusive
de: Konstruktorprioritäten müssen Ganzzahlen von 0 bis einschließlich %d sein

en: constructor syntax used, but no constructor declared for type %qT
de: Konstruktorsyntax verwendet, aber kein Konstruktor für Typ %qT deklariert

en: constructors cannot be declared %<virtual%>
de: Konstruktoren dürfen nicht als %<virtual%> deklariert sein

en: constructors may not be cv-qualified
de: Konstruktoren dürfen nicht CV-qualifiziert sein

en: constructors may not be ref-qualified
de: Konstruktoren dürfen nicht ref-qualifiziert sein

en: containing loop here
de: enthaltende Schleife ist hier

en: contains additional virtual method %qD
de: enthält zusätzliche virtuelle Methode %qD

en: continue statement not within a loop
de: continue-Anweisung nicht innerhalb einer Schleife

en: contraction %<%.*s%> in format; use %qs instead
de: Zusammenziehung %<%.*s%> im Format; verwenden Sie stattdessen %qs

en: control flow in the middle of basic block %d
de: Interner Fehler: control flow in the middle of basic block %d

en: control passes through definition of %qD with static storage duration
de: der Programmfluss geht durch die Definition von %qD mit statischer Speicherdauer

en: control passes through definition of %qD with thread storage duration
de: der Programmfluss geht durch die Definition von %qD mit thread-lokaler Speicherdauer

en: control reaches end of non-void function
de: Kontrollfluss erreicht Ende von Nicht-void-Funktion

en: control register number must be in range 0-31 for %s
de: Steuerregisternummer für »%s« muss im Bereich von 0 bis 31 liegen

en: conversion between distinct pointer types %qT and %qT lacks a cast
de: Umwandlung zwischen den unterschiedlichen Zeigertypen %qT und %qT benötigt Umwandlung

en: conversion between distinct pointer-to-member types %qT and %qT lacks a cast
de: bei Umwandlung zwischen unterschiedlichen Zeiger-auf-Element-Typen %qT und %qT fehlt eine Typkonvertierung

en: conversion casts away constness
de: Umformung verwirft Konstantheit

en: conversion from %q#T to %q#T
de: Umwandlung von %q#T nach %q#T

en: conversion from %qH to %qI discards qualifiers
de: Umwandlung von %qH in %qI löscht Qualifizierer

en: conversion from %qH to %qI in a converted constant expression
de: Umwandlung von %qH nach %qI in einem umgewandelten konstanten Ausdruck

en: conversion from %qH to %qI is ambiguous
de: Umformung von %qH nach %qI ist mehrdeutig

en: conversion from %qH to non-scalar type %qI requested
de: Umwandlung von %qH in nicht-skalaren Typen %qI angefordert

en: conversion from %qT to %qT changes the value of %qE
de: Umformung von %qT nach %qT ändert den Wert von %qE

en: conversion from %qT to %qT changes value from %qE to %qE
de: Umwandlung von %qT in %qT ändert Wert von %qE nach %qE

en: conversion from %qT to %qT discards imaginary component
de: Umwandlung von %qT nach %qT verwirft imaginäre Komponente

en: conversion from %qT to %qT may change value
de: Umwandlung von %qT nach %qT könnte den Wert ändern

en: conversion from address space %qs to address space %qs
de: Umwandlung von Adressraum %qs in Adressraum %qs

en: conversion from normal type to notinheap type
de: Konvertierung von normalem zu »notinheap«-Typen

en: conversion from pointer type %qT to arithmetic type %qT in a constant expression
de: Umwandlung von Zeigertyp %qT in arithmetischen Typ %qT in Konstantenausdruck

en: conversion lacks type at end of format
de: bei der Konvertierung fehlt der Typ am Ende des Formates

en: conversion of %qE from %qH to %qI is ambiguous
de: Umwandlung von %qE von %qH nach %qI ist mehrdeutig

en: conversion of %qs on the left hand side of %qs
de: Umwandlung von %qs auf der linken Seite eines %qs

en: conversion of register to a different size in %qs
de: Umwandlung eines Registers auf eine andere Größe in %qs

en: conversion of scalar %qH to vector %qI involves truncation
de: Umwandlung von Skalar %qH in Vektor %qI führt zum Abschneiden

en: conversion of scalar %qT to vector %qT involves truncation
de: Umwandlung von Skalar %qT in Vektor %qT führt zum Abschneiden

en: conversion to %qT from %qT may change the sign of the result
de: Umwandlung in %qT von %qT könnte das Vorzeichen des Ergebnisses ändern

en: conversion to %qT from boolean expression
de: Umwandlung in %qT aus booleschem Ausdruck

en: conversion to incomplete type
de: Konvertierung in unvollständigen Typen

en: conversion to non-const reference type %q#T from rvalue of type %qT
de: Umwandlung in nicht-konstanten Referenztyp %q#T von R-Wert des Typs %qT

en: conversion to non-scalar type requested
de: Konvertierung zu Nicht-Skalar-Typ verlangt

en: conversion to void cannot resolve address of overloaded function
de: Umwandlung in void kann die Adresse der überladenen Funktion nicht auflösen

en: conversion to void will not access object %qE of incomplete type %qT
de: Umwandlung in void greift nicht auf Objekt %qE des unvollständigen Typs %qT zu

en: conversion to void will not access object of incomplete type %qT
de: Umwandlung in void greift nicht auf Objekt des unvollständigen Typs %qT zu

en: conversion to void will not access object of non-trivially-copyable type %qT
de: Umwandlung in void greift nicht auf Objekt des nicht trivial kopierbaren Typs %qT zu

en: conversion to void will not access object of type %qT
de: Umwandlung in void greift nicht auf Objekt des Typs %qT zu

en: conversion to volatile reference type %q#T from rvalue of type %qT
de: Umwandlung in »volatile« Referenztyp %q#T von R-Wert des Typs %qT

en: conversions to arrays of unknown bound are only available with %<-std=c++20%> or %<-std=gnu++20%>
de: Umwandlungen in Arrays mit unbekannten Grenzen sind erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: converting %<false%> to pointer type %qT
de: %<false%> wird in Zeigertyp %qT umgewandelt

en: converting %<false%> to pointer type for argument %P of %qD
de: %<false%> wird für Argument %P von %qD in Zeigertyp umgewandelt

en: converting %qT to %<void%> will never use a type conversion operator
de: Umwandlung von %qT in %<void%> wird nie einen Typumwandlungsoperator verwenden

en: converting %qT to a base class %qT will never use a type conversion operator
de: Umwandlung von %qT in Basisklasse %qT wird nie einen Typumwandlungsoperator verwenden

en: converting %qT to a reference to a base class %qT will never use a type conversion operator
de: Umwandlung von %qT in Referenz auf Basisklasse %qT wird nie einen Typumwandlungsoperator verwenden

en: converting %qT to a reference to the same type will never use a type conversion operator
de: Umwandlung von %qT in Referenz auf gleichen Typ wird nie einen Typumwandlungsoperator verwenden

en: converting %qT to the same type will never use a type conversion operator
de: Umwandlung von %qT in gleichen Typ wird nie einen Typumwandlungsoperator verwenden

en: converting NULL to non-pointer type
de: Umwandlung von NULL in Nicht-Zeiger-Typ

en: converting a packed %qT pointer (alignment %d) to a %qT pointer (alignment %d) may result in an unaligned pointer value
de: die Umwandlung eines gepackten Zeigers auf %qT (Ausrichtung %d) in einen Zeiger auf %qT (Ausrichtung %d) führt möglicherweise zu einem nicht ausgerichteten Zeiger

en: converting an array compound literal to a pointer is ill-formed in C++
de: Umwandlung eines zusammengesetzten Arrayliterals ist in C++ ungültig

en: converting far pointer to near pointer
de: far-Zeiger wird in near-Zeiger umgewandelt

en: converting from %qH to %qI
de: Umwandlung von %qH nach %qI

en: converting lambda that uses %<...%> to function pointer
de: Lambda, das %<...%> verwendendet, wird in Funktionszeiger umgewandelt

en: converting overloaded function %qD to type %q#T is ambiguous
de: Umwandung der überladenen Funktion %qD in den Typ %q#T ist mehrdeutig

en: converting to %qH from %qI requires direct-initialization
de: Umwandlung von %qH nach %qI erfordert direkte Initialisierung

en: converting to %qT from initializer list would use explicit constructor %qD
de: Umwandlung in %qT von Initialisierungsliste würde expliziten Konstruktor %qD verwenden

en: converting to non-pointer type %qT from NULL
de: Konvertierung in Nicht-Zeiger-Typ %qT von NULL

en: coproc must be a constant immediate in range [0-%d] enabled with %<+cdecp<N>%>
de: Koprozessornummer muss eine direkt angegebene Konstante im Bereich 0 bis %d sein, die mit %<+cdecp<N>%> aktiviert wurde

en: coprocessor %d is not enabled with +cdecp%d
de: Koprozessor %d ist nicht aktiviert mit +cdecp%d

en: copying non-static data member %q#D of rvalue reference type
de: Kopieren von nicht-statischem Datenelement %q#D von rvalue-Referenztyp

en: copyprivate variable %qE is not threadprivate or private in outer context
de: »copyprivate«-Variable %qE ist im äußeren Kontext weder »threadprivate« noch »private«

en: coroutines require a handle class template; cannot find %<%E::%E%>
de: Koroutinen erfordern eine Handle-Klassenvorlage; %<%E::%E%> wurde nicht gefunden

en: coroutines require a traits template; cannot find %<%E::%E%>
de: Koroutinen erfordern ein Traits-Template; %<%E::%E%> wurde nicht gefunden

en: corrupt loop tree root
de: Interner Fehler: corrupt loop tree root

en: corrupted exits list of loop %d
de: Interner Fehler: corrupted exits list of loop %d

en: corrupted head of the exits list of loop %d
de: Interner Fehler: corrupted head of the exits list of loop %d

en: corrupted ltrans output file %s
de: Beschädigte ltrans-Ausgabedatei %s

en: corrupted profile info: invalid time profile
de: beschädigte Profilinformationen: ungültiges Zeitprofil

en: corrupted profile info: number of executions for edge %d-%d thought to be %i
de: Info zum beschädigten Profil: Anzahl der Ausführungen der Kante »%d-%d« sollte %i sein

en: corrupted profile info: number of iterations for basic block %d thought to be %i
de: Info zum beschädigten Profil: Anzahl der Durchläufe des Basisblocks %d sollte %i sein

en: corrupted profile info: profile data is not flow-consistent
de: Info zum beschädigten Profil: Profildaten sind nicht Fluss-konsistent

en: corrupted value profile: %s profile counter (%d out of %d) inconsistent with basic-block count (%d)
de: kaputtes Werteprofil: %s-Profilzähler (%d von %d) ist inkonsistent zu Basisblock-Zähler (%d)

en: could not close Go dump file: %m
de: Go-Abzugsdatei konnte nicht geschlossen werden: %m

en: could not close final insn dump file %qs: %m
de: endgültige Abzugsdatei %qs der Befehle konnte nicht geschlossen werden: %m

en: could not close response file %s
de: Antwortdatei %s konnte nicht geschlossen werden

en: could not close temporary response file %s
de: temporäre Antwortdatei %s konnte nicht geschlossen werden

en: could not close zeroed insn dump file %qs: %m
de: Abzugsdatei %qs genullter Befehle konnte nicht geschlossen werden: %m

en: could not convert %qE from %<void%> to %<bool%>
de: %qE konnte nicht von %<void%> nach %<bool%> umgewandelt werden

en: could not convert %qE from %qH to %qI
de: %qE konnte nicht von %qH nach %qI umgewandelt werden

en: could not convert template argument %qE from %qT to %qT
de: Templateargument %qE konnte nicht von %qT in %qT umgewandelt werden

en: could not find %s in %s (consider using %<-B%>)
de: %s konnte nicht in %s gefunden werden (möglicherweise hilft %<-B%>)

en: could not find a spill register
de: es konnte kein Überlaufregister gefunden werden

en: could not find an integer type of the same size as %qT
de: kein ganzzahliger Typ mit derselben Größe wie %qT gefunden

en: could not find class %qE
de: Klasse %qE kann nicht gefunden werden

en: could not find interface for class %qE
de: Schnittstelle für Klasse %qE kann nicht gefunden werden

en: could not find setter/getter for %qE in class %qE
de: Setter/Getter für %qE in Klasse %qE kann nicht gefunden werden

en: could not find specs file %s
de: Spezifikationsdatei %s konnte nicht gefunden werden

en: could not find variant declaration
de: Variantendeklaration nicht gefunden

en: could not locate MCU data file %<devices.csv%>
de: MCU-Datendatei %<devices.csv%> konnte nicht gefunden werden

en: could not open Go dump file %qs: %m
de: Go-Abzugsdatei %qs konnte nicht geöffnet werden: %m

en: could not open dump file %qs: %m
de: Abzugsdatei %qs konnte nicht geöffnet werden: %m

en: could not open final insn dump file %qs: %m
de: endgültige Abzugsdatei %qs der Befehle konnte nicht geöffnet werden: %m

en: could not open response file %s
de: Antwortdatei %s konnte nicht geöffnet werden

en: could not open symbol resolution file: %m
de: Datei zur Symbolauflösung konnte nicht geöffnet werden: %m

en: could not open temporary response file %s
de: temporäre Antwortdatei %s konnte nicht geöffnet werden

en: could not parse file offset
de: Datei-Offset konnte nicht eingelesen werden

en: could not parse hex number
de: Hex-Zahl konnte nicht eingelesen werden

en: could not resolve typename type
de: Typnamen-Typ kann nicht aufgelöst werden

en: could not split insn
de: Befehl kann nicht aufgeteilt werden

en: could not understand %<kern.osversion%> %q.*s
de: unverständlicher Wert %q.*s von %<kern.osversion%>

en: could not understand version %qs
de: unverständliche Version %qs

en: could not write to response file %s
de: in Antwortdatei %s konnte nicht geschrieben werden

en: could not write to temporary response file %s
de: in temporäre Antwortdatei %s konnte nicht geschrieben werden

en: counter name
de: Zählername

en: counter value
de: Zählerwert

en: cpu %qs is an invalid argument to builtin %qs
de: CPU %qs ist ein ungültiges Argument für eingebaute Funktion %qs

en: cpu %s is not based on arch %s, ignoring the arch
de: die CPU »%s« basiert nicht auf Architektur »%s«, Architektur wird ignoriert

en: created and used with different ABIs
de: erzeugt und mit anderen ABIs verwendet

en: created and used with different architectures / ABIs
de: erzeugt und mit anderen Architekturen / ABIs verwendet

en: created and used with different endianness
de: erzeugt und mit anderer Bytereihenfolge verwendet

en: created and used with different settings of %<-fpic%>
de: erzeugt und mit anderen Einstellungen von %<-fpic%> verwendet

en: created and used with different settings of %<-fpie%>
de: erzeugt und mit anderen Einstellungen von %<-fpie%> verwendet

en: created and used with differing settings of '%s'
de: erzeugt und mit anderen Einstellungen von »%s« verwendet

en: creating array of %qT
de: Array von %qT wird erzeugt

en: creating array of %qT, which is an abstract class type
de: Array von %qT wird erzeugt, was ein abstrakter Klassentyp ist

en: creating array of function members
de: Feld von Funktionselementen wird erzeugt

en: creating array of functions
de: Array von Funktionen wird erzeugt

en: creating array of references
de: Feld von Referenzen wird erzeugt

en: creating array of template placeholder type %qT
de: Array des Template-Platzhaltertyps %qT wird erzeugt

en: creating array of void
de: Array von void wird erzeugt

en: creating pointer to member function of non-class type %qT
de: Erzeugung eines Zeigers auf Elementfunktion des Nicht-Klassentyps %qT

en: creating pointer to member of non-class type %qT
de: Zeiger auf Element des Nicht-Klassentypen %qT wird erzeugt

en: creating pointer to member of type void
de: Zeiger auf Element mit Typ »void« wird erzeugt

en: creating pointer to member reference type %qT
de: Zeiger auf Elementreferenztyp %qT wird erzeugt

en: creating selector for nonexistent method %qE
de: für nicht existierende Methode %qE wird Selektor erzeugt

en: critical attribute has no effect on interrupt functions
de: Attribut »critical« wirkt sich nicht auf Interrupt-Funktionen aus

en: custom instruction opcode must be a compile-time constant in the range 0-255 for %<__builtin_custom_%s%>
de: eigener Befehlsopcode für %<__builtin_custom_%s%> muss zur Kompilierzeit eine Konstante im Bereich 0 bis 255 sein

en: cv-qualified type parameter
de: cv-qualifizierter Typparameter

en: dangling pointer %qE to %qD may be used
de: baumelnder Zeiger %qE auf %qD wird möglicherweise verwendet

en: dangling pointer %qE to an unnamed temporary may be used
de: baumelnder Zeiger %qE auf ein unbenanntes temporäres Objekt wird möglicherweise verwendet

en: dangling pointer to %qD may be used
de: baumelnder Zeiger auf %qD wird möglicherweise verwendet

en: dangling pointer to an unnamed temporary may be used
de: baumelnder Zeiger auf ein unbenanntes temporäres Objekt wird möglicherweise verwendet

en: data area attributes cannot be specified for local variables
de: Datenbereichsattribute können nicht für lokale Variablen angegeben werden

en: data area of %q+D conflicts with previous declaration
de: Datenbereich von %q+D in Konflikt mit vorheriger Deklaration

en: data declaration
de: Daten-Deklaration

en: data definition has no type or storage class
de: Datendefinition hat keinen Typ oder Speicherklasse

en: data member %q+D invalidly declared function type
de: Datenelement %q+D hat ungültigerweise einen Funktionstypen deklariert

en: data member %q+D invalidly declared method type
de: Datenelement %q+D hat ungültigerweise einen Methodentyp deklariert

en: data member %qD cannot be a member template
de: Datenelement %qD kann kein Elementtemplate sein

en: data member may not have variably modified type %qT
de: Datenelement darf nicht variabel modifizierten Typ %qT haben

en: data type of %q+D isn%'t suitable for a register
de: Datentyp von %q+D ist nicht für Register geeignet

en: data-model=far not valid for cr16c architecture
de: data-modem=far ist für Architektur CR16C ungültig

en: dead histogram
de: Interner Compilerfehler: dead histogram

en: dead statement in EH table
de: unerreichbare Anweisung in EH-Tabelle

en: deallocation function declared here
de: die Deallokationsfunktion ist hier deklariert

en: deallocation of already deallocated storage
de: Versuch, bereits freigegebenen Speicher freizugeben

en: deallocation of storage that was not previously allocated
de: Speicher, der vorher nicht angefordert wurde, wird freigegeben

en: debug
de: Fehlersuche

en: debug format %qs conflicts with prior selection
de: Debugformat %qs steht in Konflikt mit vorheriger Auswahl

en: debug output level %qs is too high
de: Debugausgabestufe %qs ist zu groß

en: debug path
de: Debug-Pfad

en: debug:
de: zur Fehlersuche:

en: decimal floating-point argument %u to binary-only type-generic function
de: dezimales Gleitkomma-Argument %u für typgenerische Funktion mit nur binären Argumenten

en: decimal floating-point argument %u to complex-only type-generic function
de: dezimales Gleitkomma-Argument %u für typgenerische Funktion mit nur komplexen Argumenten

en: decimal floating-point not supported for this target
de: dezimale Gleitkommazahlen werden für dieses Ziel nicht unterstützt

en: declaration %qD conflicts with builtin
de: Deklaration %qD widerspricht der eingebauten Deklaration

en: declaration %qD conflicts with import
de: Deklaration %qD widerspricht dem Import

en: declaration %qD does not declare anything
de: Deklaration %qD deklariert nichts

en: declaration does not declare anything
de: Deklaration deklariert nichts

en: declaration for parameter %qD but no such parameter
de: Deklaration für nicht vorhandenen Parameter %qD

en: declaration of %<constexpr%> variable %qD is not a definition
de: Deklaration der %<constexpr%>-Variable %qD ist keine Definition

en: declaration of %<extern%> variable %qD in %<for%> loop initial declaration
de: Deklaration der %<extern%>-Variablen %qD in Anfangsdeklaration einer %<for%>-Schleife

en: declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template
de: Deklaration von %<std::initializer_list%> entspricht nicht %<#include <initializer_list>%>, ist kein Template

en: declaration of %<~%T%> as member of %qT
de: Deklaration von %<~%T%> als Element von %qT

en: declaration of %q#D changes meaning of %qD
de: Deklaration von %q#D ändert die Bedeutung von %qD

en: declaration of %q#D conflicts with built-in declaration %q#D
de: Deklaration von %q#D steht mit eingebauter Deklaration %q#D in Konflikt

en: declaration of %q#D has %<extern%> and is initialized
de: Deklaration von %q#D hat %<extern%> und ist initialisiert

en: declaration of %q#D has no initializer
de: Deklaration von %q#D hat keine Initialisierung

en: declaration of %q#D outside of class is not definition
de: Deklaration von %q#D außerhalb einer Klasse ist keine Definition

en: declaration of %q#D shadows a parameter
de: Deklaration von %q#D überdeckt einen Parameter

en: declaration of %q#T
de: Deklaration von %q#T

en: declaration of %q+#D shadows template parameter
de: Deklaration von %q+#D überdeckt einen Templateparameter

en: declaration of %q+D shadows a built-in function
de: Deklaration von %q+D überdeckt eine eingebaute Funktion

en: declaration of %q+D shadows previous non-variable
de: Deklaration von %q+D überdeckt eine vorhergehende Nicht-Variable

en: declaration of %q+D with attribute %<noinline%> follows inline declaration
de: Deklaration von %q+D mit Attribut %<noinline%> folgt auf inline-Deklaration

en: declaration of %q+D with no linkage follows extern declaration
de: Deklaration von %q+D ohne Bindung folgt einer extern-Deklaration

en: declaration of %qD ambiguates earlier template instantiation for %qD
de: Deklaration von %qD macht vorherige Template-Instanziierung für %qD mehrdeutig

en: declaration of %qD as %<typedef%>
de: Deklaration von %qD als %<typedef%>

en: declaration of %qD as array of function members
de: Deklaration von %qD als Feld von Funktionselementen

en: declaration of %qD as array of functions
de: Deklaration von %qD als Array von Funktionen

en: declaration of %qD as array of references
de: Deklaration von %qD als Array von Referenzen

en: declaration of %qD as array of void
de: Deklaration von %qD als Array von voids

en: declaration of %qD as member of %qT
de: Deklaration von %qD als Element %qT

en: declaration of %qD as multidimensional array must have bounds for all dimensions except the first
de: Deklaration von %qD als multidimensionales Feld muss für alle Dimensionen außer der ersten Grenzen haben

en: declaration of %qD as non-function
de: Deklaration von %qD als Nicht-Funktion

en: declaration of %qD as parameter
de: Deklaration von %qD als Parameter

en: declaration of %qD in %qD which does not enclose %qD
de: Deklaration von %qD in %qD, das nicht %qD einschließt

en: declaration of %qD in namespace %qD which does not enclose %qD
de: Deklaration von %qD in Namensraum %qD, der nicht %qD einschließt

en: declaration of %qD not in a namespace surrounding %qD
de: Deklaration von %qD nicht in einem Namensbereich um %qD

en: declaration of %qD shadows a built-in function
de: Deklaration von %qD überdeckt eine eingebaute Funktion

en: declaration of %qD shadows a global declaration
de: Deklaration von %qD überdeckt eine globale Deklaration

en: declaration of %qD shadows a member of %qT
de: Deklaration von %qD überdeckt ein Element von %qT

en: declaration of %qD shadows a parameter
de: Deklaration von %qD überdeckt einen Parameter

en: declaration of %qD shadows a previous local
de: Deklaration von %qD überdeckt einen vorhergehenden lokalen Bezeichner

en: declaration of %qE as array of functions
de: Deklaration von %qE als Array von Funktionen

en: declaration of %qE as array of voids
de: Deklaration von %qE als Array von voids

en: declaration of %qE as multidimensional array must have bounds for all dimensions except the first
de: Deklaration von %qE als multidimensionales Array muss für alle Dimensionen außer der ersten Grenzen haben

en: declaration of %qE as non-function
de: Deklaration von %qE als Nicht-Funktion

en: declaration of %qE as non-member
de: Deklaration von %qE als Nicht-Element

en: declaration of %qF has a different exception specifier
de: Deklaration von %qF hat unterschiedlichen Exceptionspezifizierer

en: declaration of built-in function %qD without a prototype; expected %qT
de: Deklaration der eingebauten Funktion %qD ohne Prototyp; erwartet wurde %qT

en: declaration of function %qD in invalid context
de: Deklaration der Funktion %qD in ungültigem Kontext

en: declaration of multidimensional array must have bounds for all dimensions except the first
de: Deklaration von multidimensionalem Array muss für alle Dimensionen außer der ersten Grenzen haben

en: declaration of non-variable %qD in %<for%> loop initial declaration
de: Deklaration der Nicht-Variablen %qD in Anfangsdeklaration einer %<for%>-Schleife

en: declaration of static variable %qD in %<for%> loop initial declaration
de: Deklaration der »static«-Variablen %qD in Anfangsdeklaration einer %<for%>-Schleife

en: declaration of template parameter %q+#D with different constraints
de: Deklaration von Templateparameter %q+#D mit unterschiedlichen Einschränkungen

en: declaration of template parameter %q+D shadows template parameter
de: Deklaration des Templateparameters %q+D überdeckt einen Templateparameter

en: declaration of type name as array of functions
de: Deklaration eines Typnamen als Array von Funktionen

en: declaration of type name as array of voids
de: Deklaration eines Typnamen als Array von voids

en: declarations in dependent base %qT are not found by unqualified lookup
de: Deklarationen in abhängiger Basis %qT wurden bei unqualifizierter Suche nicht gefunden

en: declarator-id missing; using reserved word %qD
de: Deklarator-ID fehlt: reserviertes Wort %qD wird verwendet

en: declared here
de: hier deklariert

en: declared private here
de: hier als »private« deklariert

en: declared protected here
de: hier als »protected« deklariert

en: decompressed stream: %s
de: dekomprimierter Strom: %s

en: decrement of a boolean expression
de: Dekrementieren eines booleschen Ausdrucks

en: decrement of constant field %qD
de: Verringerung des konstanten Feldes %qD

en: decrement of enumeration value is invalid in C++
de: Verringerung von Aufzählungswerten (enum) ist in C++ ungültig

en: decrement of function %qD
de: Verringerung der Funktion %qD

en: decrement of member %qD in read-only object
de: Verringerung des Elements %qD in schreibgeschütztem Objekt

en: decrement of pointer to an incomplete type %qT
de: Dekrementieren eines Zeigers auf unvollständigen Typ %qT

en: decrement of read-only location %qE
de: Verringerung der schreibgeschützten Speicherstelle %qE

en: decrement of read-only member %qD
de: Verringerung des schreibgeschützten Elementes %qD

en: decrement of read-only named return value %qD
de: Verringerung des schreibgeschützten benannten Rückgabewertes %qD

en: decrement of read-only parameter %qD
de: Verringerung des schreibgeschützten Parameters %qD

en: decrement of read-only reference %qD
de: Verringerung der schreibgeschützten Referenz %qD

en: decrement of read-only variable %qD
de: Verringerung der schreibgeschützten Variable %qD

en: deduced class type %qD in function return type
de: hergeleiteter Klassentyp %qD in Rückgabetyp von Funktion

en: deduced expression type does not satisfy placeholder constraints
de: hergeleiteter Ausdruckstyp erfüllt die Platzhalterbeschränkungen nicht

en: deduced initializer does not satisfy placeholder constraints
de: hergeleiteter Initialisierer erfüllt die Platzhalter-Beschränkungen nicht

en: deduced return type does not satisfy placeholder constraints
de: hergeleiteter Rückgabetyp erfüllt die Platzhalter-Beschränkungen nicht

en: deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>
de: hergeleiteter Rückgabetyp nur mit %<-std=c++14%> oder %<-std=gnu++14%> verfügbar

en: deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>
de: Ermittlung aus geschweift geklammerter Initialisierungsliste erfordert %<#include <initializer_list>%>

en: deduction guide %q+D redeclared
de: Herleitungshinweis %q+D neudeklariert

en: deduction guide %qD must be declared in the same scope as %qT
de: Herleitungshinweis %qD muss im selben Gültigkeitsbereich wie %qT deklariert sein

en: deduction guide %qD must have the same access as %qT
de: Herleitungshinweis %qD muss denselben Zugriff wie %qT haben

en: deduction guide %qD must not have a function body
de: Herleitungshinweis %qD darf keinen Funktionskörper haben

en: deduction guide for %qT must have trailing return type
de: Herleitungshinweis für %qT muss angehängten Rückgabetyp haben

en: default %<target_clones%> attribute was not set
de: Standard-%<target_clones%>-Attribut wurde nicht gesetzt

en: default CPU architecture (%qs) does not support %qs ABI, falling back to %<-m%s=%s%>
de: die Standard-CPU-Architektur %qs unterstützt die ABI %qs nicht, stattdessen wird %<-m%s=%s%> verwendet

en: default argument %qE uses %qD
de: Standardargument %qE verwendet %qD

en: default argument %qE uses local variable %qD
de: Standardargument %qE verwendet lokale Variable %qD

en: default argument for template parameter for class enclosing %qD
de: Standardargument für Template-Parameter für %qD umschließende Klasse

en: default argument given for parameter %d of %q#D
de: Standardargument für Parameter %d von %q#D angegeben

en: default argument mismatch in overload resolution
de: Zuordnungsfehler der Standardargumente in Überladungsauflösung

en: default argument missing for parameter %P of %q#D
de: Standardargument fehlt für Parameter %P von %q#D

en: default argument specified for lambda parameter
de: Standardargument für Lambda-Parameter angegeben

en: default argument specified in explicit specialization
de: Standardargument in expliziter Spezialisierung angegeben

en: default arguments are not allowed in declaration of friend template specialization %qD
de: Standardargumente sind nicht in Deklaration der friend-Template-Spezialisierung %qD erlaubt

en: default arguments are only permitted for function parameters
de: Standardargumente sind nur für Funktionsparameter zugelassen

en: default member initializer for %qD required before the end of its enclosing class
de: Vorgabeinitialisierer für Element %qD erforderlich vor dem Ende der umschließenden Klasse

en: default member initializer for unnamed bit-field
de: Defaultinitialisierer für unbenanntes Bitfeld-Element

en: default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>
de: Defaultinitialisierer für Bitfeld-Elemente sind erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: default template arguments may not be used in function template friend re-declaration
de: Standardtemplateargumente dürfen in friend-Redeklaration eines Funktionstemplates nicht verwendet werden

en: default template arguments may not be used in function templates without %<-std=c++11%> or %<-std=gnu++11%>
de: Standardtemplateargumente dürfen in Funktionstemplates nur mit %<-std=c++11%> und %<-std=gnu++11%> verwendet werden

en: default template arguments may not be used in partial specializations
de: Standardtemplateargumente dürfen in teilweiser Spezialisierung nicht verwendet werden

en: default template arguments may not be used in template friend declarations
de: Standardtemplateargumente dürfen in friend-Deklaration nicht verwendet werden

en: default type conversion cannot deduce template argument for %qD
de: Template-Argument für %qD kann nicht aus Default-Typumwandlung bestimmt werden

en: defaulted %qD is not a friend of %qT
de: %qD mit Vorgabewert ist kein »friend« von %qT

en: defaulted %qD must be %<const%>
de: standardmäßiges %qD muss %<const%> sein

en: defaulted %qD must have parameters of either type %<const %T&%> or %qT
de: %qD mit %<default%> muss entweder Parameter vom Typ %<const %T&%> oder %qT haben

en: defaulted %qD must have parameters of either type %<const %T&%> or %qT, not both
de: %qD mit %<default%> muss Parameter vom Typ %<const %T&%> oder %qT haben, nicht beide

en: defaulted %qD must not have %<&&%> ref-qualifier
de: %qD mit Vorgabewert kann keinen %<&&%>-ref-Qualifizierer haben

en: defaulted %qD must return %<bool%>
de: %qD mit %<default%> muss den Rückgabetyp %<bool%> haben

en: defaulted %qD only available with %<-std=c++20%> or %<-std=gnu++20%>
de: standardmäßiges %qD ist erst ab %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>
de: Standard- und gelöschte Funktionen nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: defaulted constructor calls non-%<constexpr%> %qD
de: vorgegebener Konstruktor ruft nicht-%<constexpr%> %qD auf

en: defaulted declaration %q+D does not match the expected signature
de: Default-Deklaration %q+D passt nicht zur erwarteten Signatur

en: defaulted default constructor does not initialize %q#D
de: Standardisierter Standardkonstruktor initialisiert %q#D nicht

en: defaulted default constructor does not initialize any non-static data member
de: Standardisierter Standardkonstruktor initialisiert kein nicht-statisches Datenelement

en: defaulted destructor calls non-%<constexpr%> %qD
de: Standarddestruktor ruft nicht-%<constexpr%> %qD auf

en: defaulted function %q+D with default argument
de: vorgegebene Funktion %q+D mit Standardargument

en: defaulted member %qD must have parameter type %<const %T&%>
de: das Member %qD mit %<default%> muss den Parametertyp %<const %T&%> haben

en: defaulted move assignment for %qT calls a non-trivial move assignment operator for virtual base %qT
de: Standard-Kopierzuweisung für %qT ruft nichttrivialen Operator zur Kopierzuweisung für virtuelle Basis %qT auf

en: deferred type parameter at %C
de: Parameter mit zurückgestelltem Typ bei %C

en: defined here
de: hier definiert

en: defined here %qD
de: %qD wurde hier definiert

en: defining a type in a cast is invalid in C++
de: Definition eines Typs in einer Umwandlung ist in C++ ungültig

en: defining a type in a compound literal is invalid in C++
de: Definition eines Typs in einem zusammengesetzten Literal ist in C++ ungültig

en: defining explicit specialization %qD in friend declaration
de: Definition der expliziten Spezialisierung %qD in friend-Deklaration

en: defining type in %qs expression is invalid in C++
de: Typdefinition in Ausdruck %qs ist in C++ ungültig

en: definition in block %i does not dominate use in block %i
de: Definition in Block %i herrscht nicht vor in Block %i

en: definition in block %i follows the use
de: Definition in Block %i folgt der Verwendung

en: definition of %q#D ambiguates built-in declaration %q#D
de: Definition von %q#D macht eingebaute Deklaration %q#D mehrdeutig

en: definition of %q#D is marked %<dllimport%>
de: Definition von %q#D ist als %<dllimport%> markiert

en: definition of %q#T inside template parameter list
de: Definition von %q#T in Templateparameterliste

en: definition of %q#T is not complete until the closing brace
de: Definition von %q#T ist erst nach der schließenden Klammer vollendet

en: definition of %qD does not match
de: Definition von %qD stimmt nicht überein

en: definition of %qD does not match %<#include <initializer_list>%>
de: Definition von %qD entspricht nicht %<#include <initializer_list>%>

en: definition of %qD is not in namespace enclosing %qT
de: Deklaration von %qD ist nicht in einem Namensbereich um %qT

en: definition of concept %qD has multiple statements
de: Definition des Konzepts %qD hat mehrere Anweisungen

en: definition of concept %qD is empty
de: Definition des Konzepts %qD ist leer

en: definition of explicitly-defaulted %q+D
de: Definition des explizit standardisierten %q+D

en: definition of implicitly-declared %qD
de: Definition des implizit deklarierten %qD

en: definition of protocol %qE not found
de: Definition des Protokolls %qE nicht gefunden

en: definition of static data member %q+D of dllimport%'d class
de: Definition des statischen Datenelementes %q+D einer »dllimport«-ierten Klasse

en: definition provided for explicit instantiation
de: Definition für explizite Instanziierung angegeben

en: delegates are only for non-static functions
de: Delegation ist nur bei nicht-statischen Funktionen möglich

en: delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>
de: delegierende Konstruktoren nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: deleted definition of %qD is not first declaration
de: gelöschte Definition von %qD ist nicht die erste Deklaration

en: deleted function %q+D overriding non-deleted function
de: gelöschte Funktion %q+D übersteuert nicht gelöschte Funktion

en: deleted in Fortran 95
de: gelöscht in Fortran 95

en: deleting %qT is undefined
de: Löschen von %qT ist nicht definiert

en: deleting LTRANS file %s: %m
de: LTRANS-Datei %s kann nicht gelöscht werden: %m

en: deleting array %q#E
de: Array %q#E wird gelöscht

en: deleting file %s: %m
de: Datei %s kann nicht gelöscht werden: %m

en: deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior
de: Löschen des Objekts mit abstraktem Klassentyp %qT mit nicht-virtuellem Destruktor bewirkt undefiniertes Verhalten

en: deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior
de: Löschen des Objekts mit polymorphem Klassentyp %qT mit nicht-virtuellem Destruktor bewirkt möglicherweise undefiniertes Verhalten

en: dependent-name %qE is parsed as a non-type, but instantiation yields a type
de: Abhängigenname %qE wird als Nicht-Typ erkannt, aber die Instanziierung liefert einen Typ

en: deprecated conversion from string constant to %qT
de: veraltete Konvertierung von Zeichenkettenkonstante in %qT

en: deprecated message is not a string
de: Veraltete Meldung ist keine Zeichenkette

en: dereference of non-pointer
de: Dereferenzierung eines Nicht-Zeigers

en: dereferencing %<void *%> pointer
de: Dereferenzierung eines %<void *%>-Zeigers

en: dereferencing a null pointer
de: Dereferenzierung eines Null-Zeigers

en: dereferencing a null pointer in %qE
de: Dereferenzierung eines Nullzeigers in %qE

en: dereferencing type-punned pointer might break strict-aliasing rules
de: Dereferenzierung eines Type-Pun-Zeigers könnte strict-aliasing-Regeln verletzen

en: dereferencing type-punned pointer will break strict-aliasing rules
de: Dereferenzierung eines Type-Pun-Zeigers verletzt strict-aliasing-Regeln

en: derived type declaration
de: Deklaration eines abgeleiteten Typs

en: derived union %qT invalid
de: abgeleitete Union %qT ist ungültig

en: designated initializers cannot be used with a non-aggregate type %qT
de: Initialisierer mit Bestimmung können nur mit Aggregat-Typen (Array, struct, union) verwendet werden, nicht mit %qT

en: designating the bound of variable length array argument %u
de: hier wird die Grenze des Arrays variabler Länge aus Argument %u festgelegt

en: designator order for field %qD does not match declaration order in %qT
de: Designator-Reihenfolge für Feld %qD passt nicht zur ursprünglichen Deklaration in %qT

en: destination object %qE of size %s
de: Zielobjekt %qE der Größe %s

en: destination object allocated here
de: Zielobjekt wird hier alloziert

en: destination object of size %s allocated by %qE
de: Zielobjekt der Größe %s, alloziert durch %qE

en: destination object referenced by %<restrict%>-qualified argument 1 was declared here
de: Zielobjekt, auf das durch %<restrict%>-qualifiziertes Argument 1 verwiesen wird, wurde hier deklariert

en: destroying %<operator delete%> must be a member function
de: der zerstörende %<operator delete%> muss eine Elementfunktion sein

en: destroying %<operator delete%> must be a usual deallocation function
de: der zerstörende %<operator delete%> muss eine übliche Deallozierungsfunktion sein

en: destroying delete %qD cannot be used to release the allocated memory if the initialization throws because the object is not constructed yet
de: das zerstörende Delete für %qD kann nicht verwendet werden, um den zugewiesenen Speicher freizugeben, wenn die Initialisierung fehlschlägt, weil das Objekt noch nicht konstruiert ist

en: destructor %qD declared as member template
de: Destruktor %qD als Element-Template deklariert

en: destructor cannot be static member function
de: Destruktor kann keine statische Elementfunktion sein

en: destructor for %qE shall not be run either
de: Destruktor für %qE darf auch nicht abgearbeitet werden

en: destructor for %qT is ambiguous
de: Destruktor für %qT ist mehrdeutig

en: destructor for alien class %qT cannot be a member
de: Destruktor für fremde Klasse %qT kann kein Element sein

en: destructor priorities are not supported
de: Destruktorprioritäten werden nicht unterstützt

en: destructor priorities from 0 to %d are reserved for the implementation
de: Destruktorprioritäten von 0 bis %d sind für die Implementierung vorbehalten

en: destructor priorities must be integers from 0 to %d inclusive
de: Destruktorprioritäten müssen Ganzzahlen von 0 bis einschließlich %d sein

en: destructors may not be cv-qualified
de: Destruktoren dürfen nicht CV-qualifiziert sein

en: destructors may not be ref-qualified
de: Destruktoren dürfen nicht ref-qualifiziert sein

en: destructors may not have parameters
de: Destruktoren dürfen keine Parameter haben

en: determining value of %qs
de: bei der Bestimmung des Wertes von %qs

en: did you mean %<-%s%>?
de: meinten Sie %<-%s%>?

en: did you mean %<using enum %T::%D%>?
de: meinten Sie %<using enum %T::%D%>?

en: did you mean to dereference the pointer?
de: wollten Sie vielleicht den Zeiger dereferenzieren?

en: did you mean to use logical not (%<!%>)?
de: meinten Sie ein logisches Nicht (%<!%>)?

en: did you mean to use logical not?
de: meinten Sie ein logisches Nicht (%<!%>)?

en: difference between %qE and %qD does not have integer type
de: Unterschied zwischen %qE und %qD hat keinen Ganzzahltyp

en: different number of parameters
de: unterschiedliche Parameteranzahl

en: different number of results
de: unterschiedliche Ergebnisanzahl

en: different parameter types
de: unterschiedliche Parametertypen

en: different receiver types
de: unterschiedliche Empfängertypen

en: different result types
de: unterschiedliche Ergebnistypen

en: different underlying type in enum %q#T
de: anderer zugrunde liegender Typ in enum %q#T

en: different varargs
de: unterschiedliche variable Argumente

en: direct base %qT inaccessible in %qT due to ambiguity
de: direkte Basis %qT ist in %qT durch Mehrdeutigkeit unzugänglich

en: direct call to %s in speculative call sequence has no speculative flag
de: der direkte Aufruf von %s in der Folge der spekulativen Aufrufe hat kein Spekulationsflag

en: direct call to %s in speculative call sequence has speculative_id %i out of range
de: der direkte Aufruf von %s in der Folge der spekulativen Aufrufe hat speculative_id %i außerhalb des Bereichs

en: direct-list-initialization of %<auto%> requires exactly one element
de: direct-list-initialization von %<auto%> erfordert genau ein Element

en: directive argument %qE
de: Direktiven-Argument %qE

en: directive argument in the range [%E, %E]
de: Direktiven-Argument im Bereich [%E, %E]

en: directive with only %<device_type%> clauses ignored
de: Direktiven mit nur %<device_type%>-Klauseln werden ignoriert

en: disable pass %s for function %s
de: Durchlauf %s für Funktion %s ausschalten

en: disable pass %s for functions in the range of [%u, %u]
de: Durchlauf %s für Funktionen im Bereich [%u, %u] ausschalten

en: distinct Objective-C type in return
de: Anderer Objective-C-Typ in Rückgabe

en: division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements
de: Division %<sizeof (%T) / sizeof (%T)%> berechnet nicht die Anzahl der Feldelemente

en: division by zero
de: Division durch Null

en: division by zero is not a constant expression
de: Division durch Null ist kein konstanter Ausdruck

en: do not specify both -march=... and -mcpu=...
de: »-march=…« und »-mcpu=…« dürfen nicht zusammen angegeben werden

en: do_check(): too many args
de: Interner Fehler: do_check(): too many args

en: does not match member template declaration here
de: entspricht nicht der Element-Templatedeklaration hier

en: does not support multilib
de: unterstützt nicht multilib

en: dominator of %d should be %d, not %d
de: Herrscher über %d sollte %d sein, nicht %d

en: dominator of %d status unknown
de: unbekannter Status für Herrscher über %d

en: don%'t know how to delete %qs
de: es ist unklar, wie %qs zu löschen ist

en: don%'t support DSP extension instructions
de: Erweiterungsbefehle für DSPs nicht unterstützen

en: don%'t support performance extension instructions
de: Erweiterungsbefehle für Performance nicht unterstützen

en: don%'t support performance extension version 2 instructions
de: Erweiterungsbefehle für Performance Version 2 nicht unterstützen

en: don%'t support string extension instructions
de: Erweiterungsbefehle für Zeichenketten nicht unterstützen

en: double colon in MODULE PROCEDURE statement at %L
de: »::« in MODULE PROCEDURE-Anweisung bei %L

en: double constants not supported
de: double-Konstanten werden nicht unterstützt

en: double linked list of assembler names corrupted
de: Interner Fehler: double linked list of assembler names corrupted

en: double linked list of clones corrupted
de: Interner Fehler: double linked list of clones corrupted

en: due to different exception specifications
de: durch andere Ausnahmespezifikationen

en: dump file: %s
de: Dumpdatei: %s

en: duplicate %<_Atomic%>
de: doppeltes %<_Atomic%>

en: duplicate %<_Thread_local%> or %<__thread%>
de: doppeltes %<_Thread_local%> oder %<__thread%>

en: duplicate %<asm%> operand name %qs
de: doppelter %<asm%>-Operandenname %qs

en: duplicate %<asm%> qualifier %qE
de: doppelter %<asm%>-Qualifizierer %qE

en: duplicate %<asm%> qualifier %qT
de: doppelter %<asm%>-Qualifizierer %qT

en: duplicate %<const%>
de: doppeltes %<const%>

en: duplicate %<default%> case in %<_Generic%>
de: doppelter %<default%>-Fall in %<_Generic%>

en: duplicate %<mutable%>
de: doppeltes %<mutable%>

en: duplicate %<restrict%>
de: doppeltes %<restrict%>

en: duplicate %<volatile%>
de: doppeltes %<volatile%>

en: duplicate %qD
de: doppeltes %qD

en: duplicate %qE
de: doppeltes %qE

en: duplicate %qE attribute
de: doppeltes Attribut %qE

en: duplicate %qE declaration specifier
de: Doppelter Deklarationsspezifizierer %qE

en: duplicate %qs
de: doppeltes %qs

en: duplicate %qs modifier
de: doppelter %qs-Modifizierer

en: duplicate (or overlapping) case value
de: Doppelte (oder sich überschneidende) case-Werte

en: duplicate base type %qT invalid
de: doppelter Basistyp %qT ungültig

en: duplicate case value
de: Doppelter case-Wert

en: duplicate cv-qualifier
de: doppelter CV-Qualifizierer

en: duplicate declaration for protocol %qE
de: doppelte Deklaration für Protokoll %qE

en: duplicate declaration of method %<%c%E%> with conflicting types
de: doppelte Deklaration der Methode %<%c%E%> mit in Konflikt stehenden Typen

en: duplicate definition of %qs
de: doppelte Definition von %qs

en: duplicate definition of '%s'
de: doppelte Definition von »%s«

en: duplicate definition of a symbol version
de: doppelte Definition einer Symbolversion

en: duplicate direct call to %s in speculative call sequence with speculative_id %i
de: doppelter direkter Aufruf von %s in der Folge der spekulativen Aufrufe mit speculative_id %i

en: duplicate explicit instantiation of %q#D
de: doppelte explizite Instanziierung von %q#D

en: duplicate explicit instantiation of %q#T
de: doppelte explizite Instanziierung von %q#T

en: duplicate info for %qE
de: doppelte Informationen für %qE

en: duplicate initialization of %qD
de: doppelte Initialisierung von %qD

en: duplicate instance variable %q+D
de: doppelte Instanzvariable %q+D

en: duplicate interface declaration for category %<%E(%E)%>
de: doppelte Schnittstellendeklaration für Kategorie %<%E(%E)%>

en: duplicate interface declaration for class %qE
de: doppelte Schnittstellendeklaration für Klasse %qE

en: duplicate label %qD
de: doppelte Marke %qD

en: duplicate label declaration %qE
de: Doppelte Markendeklaration %qE

en: duplicate loop header
de: Interner Fehler: duplicate loop header

en: duplicate member %q+D
de: doppeltes Element %q+D

en: duplicate reference %s in speculative call sequence with speculative_id %i
de: doppelter Verweis %s in der Folge der spekulativen Aufrufe mit speculative_id %i

en: duplicate type-generic parameter type for function argument %u of %<__builtin_tgmath%>
de: doppelter typgenerischer Parametertyp für Funktionsargument %u von %<__builtin_tgmath%>

en: duplicate virt-specifier
de: doppelter Virt-Spezifizierer

en: duplicated %<if%> condition
de: doppelte %<if%>-Bedingung

en: duplicated parameter specifier %qs in %<amdgpu_hsa_kernel%> attribute
de: doppelt angegebener Parameter %qs in Attribut %<amdgpu_hsa_kernel%>

en: during %<-fcompare-debug%> recompilation
de: während Neuübersetzung mit %<-fcompare-debug%>

en: during %s pass: %s
de: Im Durchlauf %s: %s

en: during load of binding %<%E%s%E%>
de: beim Lesen der Bindung %<%E%s%E%>

en: during load of binding %<%E%s%E@%s%>
de: beim Lesen der Bindung %<%E%s%E@%s%>

en: during load of pendings for %<%E%s%E%>
de: beim Laden der ausstehenden Einheiten für %<%E%s%E%>

en: dwarf version %wu is not supported
de: Dwarf-Version %wu wird nicht unterstützt

en: dynamic dependency %s not found
de: dynamische Abhängigkeit »%s« nicht gefunden

en: dynamic exception specifications are deprecated in C++11
de: dynamische Ausnahmespezifikationen sind in C++11 veraltet

en: dynamic type %qT of its operand does not have a base class of type %qT
de: dynamischer Typ %qT seines Operanden hat keine Basisklasse vom Typ %qT

en: dynamic type %qT of its operand does not have an unambiguous public base class %qT
de: der dynamische Typ %qT des Operanden hat keine eindeutige öffentliche Basisklasse %qT

en: eBPF stack limit exceeded
de: eBPF-Stapelgrenze überschritten

en: each undeclared identifier is reported only once for each function it appears in
de: jeder nicht deklarierte Bezeichner wird nur einmal für jede Funktion, in der er vorkommt, gemeldet

en: edge %s->%s has no corresponding call_stmt
de: Interner Fehler: edge %s->%s has no corresponding call_stmt

en: edge from %d to %d should be marked irreducible
de: Interner Fehler: edge from %d to %d should be marked irreducible

en: edge from %d to %d should not be marked irreducible
de: Interner Fehler: edge from %d to %d should not be marked irreducible

en: edge has both call_stmt and lto_stmt_uid set
de: Kante hat sowohl call_stmt als auch lto_stmt_uid gesetzt

en: edge not found
de: Interner Fehler: edge not found

en: edge points to wrong declaration:
de: Interner Fehler: edge points to wrong declaration:

en: either %<-fopenacc%> or %<-fopenmp%> must be set
de: entweder %<-fopenacc%> oder %<-fopenmp%> muss angegeben sein

en: either -fopenacc or -fopenmp must be set
de: entweder %<-fopenacc%> oder %<-fopenmp%> muss angegeben sein

en: either all initializer clauses should be designated or none of them should be
de: entweder sollten alle Initialisierer-Klauseln benannt sein oder gar keine

en: elaborated-type-specifier for a scoped enum must not use the %qD keyword
de: ausführliche Typ-Spezifikation für einen enum mit Gültigkeitsbereich darf nicht das Schlüsselwort %qD verwenden

en: element types must be the same
de: Elementtypen müssen dieselben sein

en: elemental binary operation
de: Elementare Binäroperation

en: elemental function arguments at %C are not compliant
de: elementare Funktionsargumente bei %C sind nicht konform

en: elemental procedure
de: Elementares Unterprogramm

en: elements of array %q#D have incomplete type
de: Elemente des Arrays %q#D haben unvollständigen Typ

en: elements of array %q#T have incomplete type
de: Elemente des Arrays %q#T haben unvollständigen Typ

en: embedded %<\0%> in format
de: eingebettetes %<\0%> im Format

en: embedded NUL in CFString literal
de: eingebettetes NUL in CFString-Literal

en: empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)
de: das ABI zum Übergeben von leeren Klassen (%qT) als Parametern hat sich mit %<-fabi-version=12%> (GCC 8) geändert

en: empty declaration
de: Leere Deklaration

en: empty declaration with %<_Alignas%> does not redeclare tag
de: Leere Deklaration mit %<_Alignas%> redeklariert nicht Symbol

en: empty declaration with storage class specifier does not redeclare tag
de: Leere Deklaration mit Speicherklassenangabe redeklariert nicht Symbol

en: empty declaration with type qualifier does not redeclare tag
de: Leere Deklaration mit Typqualifizierer redeklariert nicht Symbol

en: empty enum is invalid
de: Leeres Enum ist ungültig

en: empty file
de: leere Datei

en: empty index range in initializer
de: leerer Indexbereich in Initialisierung

en: empty initializer for lambda init-capture
de: nicht-leere Initialisierung »init-capture« eines Lambdas

en: empty initializer in lambda init-capture
de: leere Initialisierung in »init-capture« für Lambda

en: empty left precision in %s format
de: leere linke Präzision im Format %s

en: empty parentheses were disambiguated as a function declaration
de: leere Klammern sind mehrdeutig und werden als Funktionsdeklaration angesehen

en: empty precision in %s format
de: fehlende Präzision im Format %s

en: empty property attribute list
de: leere Liste von Eigenschaftsattributen

en: empty range specified
de: Leerer Wertebereich angegeben

en: empty scalar initializer
de: leere Skalar-Initialisierung

en: empty string in attribute %<target%>
de: Leere Zeichenkette in Attribut %<target%>

en: empty struct has size 0 in C, size 1 in C++
de: leere Struktur hat Größe 0 in C, aber 1 in C++

en: empty structured binding declaration
de: leere Deklaration für strukturierte Bindung

en: empty union has size 0 in C, size 1 in C++
de: leere Union hat Größe 0 in C, aber 1 in C++

en: enable pass %s for function %s
de: Durchlauf %s für Funktion %s einschalten

en: enable pass %s for functions in the range of [%u, %u]
de: Durchlauf %s für Funktionen im Bereich [%u, %u] einschalten

en: enabling backtrace support is only meaningful when compiling for the Thumb
de: Das Einschalten der Ablaufverfolgung ist nur bei der Übersetzung für THUMB sinnvoll

en: enabling callee interworking support is only meaningful when compiling for the Thumb
de: Das Einschalten der Unterstützung der Aufgerufenen-Zusammenarbeit ist nur bei der Übersetzung für THUMB sinnvoll

en: encapsulation is malformed
de: Fehler im ELF-Header

en: enclosing %<target%>
de: umgebendes %<target%>

en: enclosing %qs
de: umgebendes %qs

en: enclosing OpenACC %qs construct
de: umgebendes OpenACC-%qs-Konstrukt

en: enclosing class of %<constexpr%> non-static member function %q+#D is not a literal type
de: umschließende Klasse der %<constexpr%> nicht-statischen Elementfunktion %q+#D ist kein Literaltyp

en: enclosing class templates are not explicitly specialized
de: einschließende Klassentemplates werden nicht explizit spezialisiert

en: enclosing parent compute construct
de: umgebendes Eltern-Berechnungs-Konstrukt

en: enclosing region
de: umgebende Region

en: enclosing routine
de: umgebende Routine

en: enclosing target region
de: umgebende Zielregion

en: enclosing task
de: umgebende Task

en: end expression refers to outer iterator %qD
de: Endausdruck verweist auf äußeren Iterator %qD

en: end insn %d for block %d not found in the insn stream
de: Interner Fehler: end insn %d for block %d not found in the insn stream

en: end of implied-do loop at %L could not be simplified to a constant value
de: Ende der Implied-do-Schleife bei %L konnte nicht zu einem konstanten Wert vereinfacht werden

en: enum constant defined here
de: enum-Konstante hier definiert

en: enum constant in boolean context
de: enum-Konstante in booleschem Zusammenhang

en: enum conversion from %qT to %qT in assignment is invalid in C++
de: enum-Umwandlung von %qT nach %qT in Zuweisung ist in C++ ungültig

en: enum conversion from %qT to %qT in initialization is invalid in C++
de: enum-Umwandlung von %qT nach %qT in Initialisierung ist in C++ ungültig

en: enum conversion from %qT to %qT in return is invalid in C++
de: enum-Umwandlung von %qT nach %qT in Rückgabe ist in C++ ungültig

en: enum conversion in assignment is invalid in C++
de: enum-Umwandlung in Zuweisung ist in C++ ungültig

en: enum conversion in initialization is invalid in C++
de: enum-Umwandlung in Initialisierung ist in C++ ungültig

en: enum conversion when passing argument %d of %qE is invalid in C++
de: Enum-Umwandlung bei Übergabe des Arguments %d von %qE ist in C++ ungültig

en: enum type defined here
de: »enum«-Typ hier definiert

en: enum value is not %<CONST_DECL%> or %<INTEGER_CST%>
de: Interner Compilerfehler: enum value is not %<CONST_DECL%> or %<INTEGER_CST%>

en: enum value name is not %<IDENTIFIER_NODE%>
de: Interner Compilerfehler: enum value name is not %<IDENTIFIER_NODE%>

en: enum value type is not %<INTEGER_TYPE%> nor convertible to the enum
de: Interner Compilerfehler: enum value type is not %<INTEGER_TYPE%> nor convertible to the enum

en: enumerated and non-enumerated type in conditional expression
de: Aufzählungs- und Nicht-Aufzählungstyp in bedingtem Ausdruck

en: enumerated mismatch in conditional expression: %qT vs %qT
de: bedingter Ausdruck enthält unverträgliche Aufzählungswerte der Typen %qT und %qT

en: enumeration range differs
de: Aufzählungsbereich unterscheidet sich

en: enumeration value %qE not handled in switch
de: Aufzählungswert %qE wird nicht von switch behandelt

en: enumeration values exceed range of largest integer
de: Aufzählungswerte überschreiten Wertebereich des größten Ganzzahltypen

en: enumerator %qD does not match ...
de: der Aufzählungswert %qD passt nicht zu ...

en: enumerator value %qE is outside the range of underlying type %qT
de: Aufzählungswert %qE ist außerhalb des Gültigkeitsbereichs des zugrundeliegenden Typen %qT

en: enumerator value for %qD is not an integer constant
de: Aufzählungswert für %qD ist keine Ganzzahlkonstante

en: enumerator value for %qD must have integral or unscoped enumeration type
de: Aufzählungswert für %qD muss ganzzahligen oder Aufzählungstyp ohne Gültigkeitsbereich haben

en: enumerator value for %qE is not an integer constant
de: Aufzählungswert für %qE ist keine Ganzzahlkonstante

en: enumerator value for %qE is not an integer constant expression
de: Aufzählungswert für %qE ist kein Ganzzahlkonstantenausdruck

en: environment variable %<COLLECT_GCC%> must be set
de: Umgebungsvariable %<COLLECT_GCC%> muss gesetzt sein

en: environment variable %<COLLECT_GCC_OPTIONS%> must be set
de: Umgebungsvariable %<COLLECT_GCC_OPTIONS%> muss gesetzt sein

en: environment variable %<COLLECT_LTO_WRAPPER%> must be set
de: Umgebungsvariable %<COLLECT_LTO_WRAPPER%> muss gesetzt sein

en: environment variable %qs must expand to a non-negative integer less than or equal to %wd
de: Umgebungsvariable %qs muss ganzzahlig sein und zwischen 0 und %wd liegen

en: environment variable %qs not defined
de: Umgebungsvariable %qs nicht definiert

en: environment variable COLLECT_GCC_OPTIONS must be set
de: Umgebungsvariable COLLECT_GCC_OPTIONS muss gesetzt sein

en: environment variable DJGPP not defined
de: Umgebungsvariable DJGPP nicht definiert

en: environment variable DJGPP points to corrupt file %qs
de: Umgebungsvariable DJGPP zeigt auf kaputte Datei %qs

en: environment variable DJGPP points to missing file %qs
de: Umgebungsvariable DJGPP zeigt auf fehlende Datei %qs

en: error
de: Fehler

en: error closing %s: %m
de: Fehler beim Schließen von %s: %m

en: error closing optimization records %qs
de: Fehler beim Schließen der Datei für Optimierungsdatensätze %qs

en: error in arguments to spec function %qs
de: Fehler in Argumenten für Spezifikationsfunktion %qs

en: error in removing %s
de: Fehler beim Löschen von %s

en: error writing %qs
de: Fehler beim Schreiben von %qs

en: error writing optimization records to %qs: %s
de: Fehler beim Schreiben der Optimierungsdatensätze in %qs: %s

en: error writing to %s: %m
de: Fehler beim Schreiben der Datei %s: %m

en: error:
de: Fehler:

en: errors during merging of translation units
de: Fehler beim Einfügen von Übersetzungseinheiten

en: evaluating %qs
de: %qs wird ausgewertet

en: exception cleanup for this placement new selects non-placement %<operator delete%>
de: Exceptionaufräumen für dieses Placement-New wählt delete-Operator für Nicht-Placement

en: exception handling disabled, use %<-fexceptions%> to enable
de: Ausnahmebehandlung ausgeschaltet, %<-fexceptions%> schaltet sie ein

en: exception handling disabled; use %<-fexceptions%> to enable
de: Ausnahmebehandlung ausgeschaltet; %<-fexceptions%> schaltet sie ein

en: exception handling personality mismatch
de: Fehlzuordnung von Persönlichkeiten bei Ausnahmebehandlung

en: exception of type %<%T%> will be caught
de: Ausnahme des Typs %<%T%> wird gefangen werden

en: exception of type %qT will be caught by earlier handler
de: Ausnahme des Typs %qT wird bereits von einem früheren Exceptionhandler verarbeitet

en: exception specification of %qD depends on itself
de: Ausnahmen-Angabe von %qD hängt von sich selbst ab

en: excess elements in %<char%> array initializer
de: überzählige Elemente in %<char%>-Array-Initialisierung

en: excess elements in array initializer
de: Elementüberschreitung in Arrayinitialisierung

en: excess elements in scalar initializer
de: Elementüberschreitung in Skalarinitialisierung

en: excess elements in struct initializer
de: Elementüberschreitung in struct-Initialisierung

en: excess elements in union initializer
de: Elementüberschreitung in union-Initialisierung

en: excess elements in vector initializer
de: Elementüberschreitung in Vektorinitialisierung

en: excess use operand for statement
de: überzähliger Verwendungs-Operand für Anweisung

en: execution counts assumed to be zero
de: Ausführungszähler als null angenommen

en: execution counts estimated
de: Ausführungszähler geschätzt

en: existing declaration %#qD
de: bestehende Deklaration %#qD

en: existing definition %qD
de: bestehende Definition %qD

en: exit %d->%d not recorded
de: Interner Fehler: exit %d->%d not recorded

en: expansion pattern %qE contains no parameter packs
de: Expansionsmuster %qE enthält keine Parameterpacks

en: expansion pattern %qT contains no parameter packs
de: Expansionsmuster %qT enthält keine Parameterpacks

en: expansion point is location %i
de: Expansionspunkt ist Ort %i

en: expected %<"%>
de: %<"%> erwartet

en: expected %<#pragma acc%> clause
de: Klausel %<#pragma acc%> erwartet

en: expected %<#pragma omp scan%>
de: %<#pragma omp scan%> erwartet

en: expected %<#pragma omp section%> or %<}%>
de: %<#pragma omp section%> oder %<}%> erwartet

en: expected %<#pragma omp%> clause
de: Klausel %<#pragma omp%> erwartet

en: expected %<(%>
de: %<(%> erwartet

en: expected %<(%> after template-argument-list
de: %<(%> hinter template-argument-list erwartet

en: expected %<(%> or end of line
de: %<(%> oder Zeilenende erwartet

en: expected %<)%>
de: %<)%> erwartet

en: expected %<)%> or %<,%>
de: %<)%> oder %<,%> erwartet

en: expected %<*%>
de: %<*%> erwartet

en: expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier
de: %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> oder Bezeichner erwartet

en: expected %<,%>
de: %<,%> erwartet

en: expected %<,%> or %<)%>
de: %<,%> oder %<)%> erwartet

en: expected %<,%> or %<...%>
de: %<,%> oder %<...%> erwartet

en: expected %<,%> or %<;%>
de: %<,%> oder %<;%> erwartet

en: expected %<,%> or %<]%>
de: %<,%> oder %<]%> erwartet

en: expected %<,%> or %<}%>
de: %<,%> oder %<}%> erwartet

en: expected %<,%>, %<;%> or %<}%>
de: %<,%>, %<;%> oder %<}%> erwartet

en: expected %<.%>
de: %<.%> erwartet

en: expected %<...%>
de: %<...%> erwartet

en: expected %<:%>
de: %<:%> erwartet

en: expected %<:%> or %<)%>
de: %<:%> oder %<)%> erwartet

en: expected %<:%> or %<...%>
de: %<:%> oder %<...%> erwartet

en: expected %<:%> or %<::%>
de: %<:%> oder %<::%> erwartet

en: expected %<:%>, %<,%>, %<;%>, %<}%> or %<__attribute__%>
de: %<:%>, %<,%>, %<;%>, %<}%> oder %<__attribute__%> erwartet

en: expected %<::%>
de: %<::%> erwartet

en: expected %<;%>
de: %<;%> erwartet

en: expected %<;%> after class definition
de: %<;%> hinter Klassendefinition erwartet

en: expected %<;%> after struct definition
de: %<;%> hinter Strukturdefinition erwartet

en: expected %<;%> after union definition
de: %<;%> hinter Uniondefinition erwartet

en: expected %<;%> at end of member declaration
de: %<;%> am Ende von Elementdeklaration erwartet

en: expected %<;%> or %<{%>
de: %<;%> oder %<{%> erwartet

en: expected %<;%> or %<{%> after method attribute definition
de: %<;%> or %<{%> nach Definition der Methodenattribute erwartet

en: expected %<;%>, %<,%> or %<)%>
de: %<;%>, %<,%> oder %<)%> erwartet

en: expected %<;%>, identifier or %<(%>
de: %<;%>, Bezeichner oder %<(%> erwartet

en: expected %<<%>
de: %<<%> erwartet

en: expected %<=%>
de: %<=%> erwartet

en: expected %<=%> after Objective-C %qE
de: nach dem Objective-C-Attribut %qE wird ein %<=%> erwartet

en: expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>
de: %<=%>, %<,%>, %<;%>, %<asm%> oder %<__attribute__%> erwartet

en: expected %<==%> comparison in %<if%> condition
de: in der %<if%>-Bedingung wird ein Vergleich mit %<==%> erwartet

en: expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition
de: in der %<if%>-Bedingung wird ein Vergleich mit %<==%>, %<<%> oder %<>%> erwartet

en: expected %<>%>
de: %<>%> erwartet

en: expected %<@end%>
de: %<@end%> erwartet

en: expected %<@synchronized%>
de: %<@synchronized%> erwartet

en: expected %<@throw%>
de: %<@throw%> erwartet

en: expected %<@try%>
de: %<@try%> erwartet

en: expected %<[%>
de: %<[%> erwartet

en: expected %<]%>
de: %<]%> erwartet

en: expected %<__label__%>
de: %<__label__%> erwartet

en: expected %<__transaction_atomic%>
de: %<__transaction_atomic%> erwartet

en: expected %<__transaction_relaxed%>
de: %<__transaction_relaxed%> erwartet

en: expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>
de: %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> oder %<default%> erwartet

en: expected %<allocator%>
de: %<allocator%> erwartet

en: expected %<allocator%> or %<align%>
de: %<allocator%> oder %<align%> erwartet

en: expected %<ancestor%> or %<device_num%>
de: %<ancestor%> oder %<device_num%> erwartet

en: expected %<asm%>
de: %<asm%> erwartet

en: expected %<at%>, %<severity%> or %<message%> clause
de: eine der Klauseln %<at%>, %<severity%> oder %<message%> erwartet

en: expected %<auto%>
de: %<auto%> erwartet

en: expected %<auto%> or %<decltype(auto)%> after %qE
de: %<auto%> oder %<decltype(auto)%> nach %qE erwartet

en: expected %<big-endian%>, %<little-endian%>, or %<default%> after %<#pragma scalar_storage_order%>
de: %<big-endian%>, %<little-endian%> oder %<default%> nach %<#pragma scalar_storage_order%> erwartet

en: expected %<cancel%> %<if%> clause modifier
de: Klauselmodifizierer %<cancel%> %<if%> erwartet

en: expected %<catch%>
de: %<catch%> erwartet

en: expected %<class%>
de: %<class%> erwartet

en: expected %<class%> or %<typename%>
de: %<class%> oder %<typename%> erwartet

en: expected %<class%>, %<typename%>, or %<template%>
de: %<class%>, %<typename%> oder %<template%> erwartet

en: expected %<co_yield%>
de: %<co_yield%> erwartet

en: expected %<concurrent%>
de: %<concurrent%> erwartet

en: expected %<construct%>, %<device%>, %<implementation%> or %<user%>
de: %<construct%>, %<device%>, %<implementation%> oder %<user%> erwartet

en: expected %<data%>
de: %<data%> erwartet

en: expected %<data%> after %<#pragma acc %s%>
de: hinter %<#pragma acc %s%> wird %<data%> erwartet

en: expected %<data%>, %<update%>, %<enter%> or %<exit%>
de: %<data%>, %<update%>, %<enter%> oder %<exit%> erwartet

en: expected %<declare%>
de: %<declare%> erwartet

en: expected %<decltype%>
de: %<decltype%> erwartet

en: expected %<delete%>
de: %<delete%> erwartet

en: expected %<depend%>, %<destroy%> or %<update%> clause
de: eine der Klauseln %<depend%>, %<destroy%> oder %<update%> erwartet

en: expected %<directive%> or %<sequence%>
de: %<directive%> oder %<sequence%> erwartet

en: expected %<else%>
de: %<else%> erwartet

en: expected %<error%>, %<warning%>, %<ignored%>, %<push%>, %<pop%>, %<ignored_attributes%> after %<#pragma GCC diagnostic%>
de: %<error%>, %<warning%>, %<ignored%>, %<push%>, %<pop%>, %<ignored_attributes%> nach %<#pragma GCC diagnostic%> erwartet

en: expected %<extern%>
de: %<extern%> erwartet

en: expected %<finally%> or %<catch%>
de: %<finally%> oder %<catch%> erwartet

en: expected %<for%> after %qs
de: %<for%> hinter %qs erwartet

en: expected %<host%>, %<nohost%> or %<any%>
de: %<host%>, %<nohost%> oder %<any%> erwartet

en: expected %<in%>, %<out%>, %<inout%> or %<mutexinoutset%>
de: %<in%>, %<out%>, %<inout%> oder %<mutexinoutset%> erwartet

en: expected %<inclusive%> or %<exclusive%> clause
de: %<inclusive%>- oder %<exclusive%>-Klausel erwartet

en: expected %<match%>
de: %<match%> erwartet

en: expected %<namespace%>
de: %<namespace%> erwartet

en: expected %<new%>
de: %<new%> erwartet

en: expected %<none%> or %<present%>
de: %<none%> oder %<present%> erwartet

en: expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>
de: %<none%>, %<shared%>, %<private%> oder %<firstprivate%> erwartet

en: expected %<omp_priv%> or function-name
de: %<omp_priv%> oder Funktionsname erwartet

en: expected %<operator%>
de: %<operator%> erwartet

en: expected %<point%>
de: %<point%> erwartet

en: expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause
de: eine der Klauseln %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> oder %<hint%> erwartet

en: expected %<read%>, %<write%>, %<update%>, or %<capture%> clause
de: eine der Klauseln %<read%>, %<write%>, %<update%> oder %<capture%> erwartet

en: expected %<reproducible%> or %<unconstrained%>
de: %<reproducible%> oder %<unconstrained%> erwartet

en: expected %<return%>
de: %<return%> erwartet

en: expected %<scalar%>, %<aggregate%> or %<pointer%>
de: %<scalar%>, %<aggregate%> oder %<pointer%> erwartet

en: expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>
de: %<seq_cst%>, %<acq_rel%>, %<release%> oder %<acquire%> erwartet

en: expected %<seq_cst%>, %<acquire%> or %<relaxed%>
de: %<seq_cst%>, %<acquire%> oder %<relaxed%> erwartet

en: expected %<seq_cst%>, %<relaxed%> or %<acq_rel%>
de: %<seq_cst%>, %<relaxed%> oder %<acq_rel%> erwartet

en: expected %<simd%>, %<reduction%>, %<target%> or %<variant%>
de: %<simd%>, %<reduction%>, %<target%> oder %<variant%> erwartet

en: expected %<static_assert%>
de: %<static_assert%> erwartet

en: expected %<target%>
de: %<target%> erwartet

en: expected %<teams%>, %<parallel%> or %<thread%>
de: %<teams%>, %<parallel%> oder %<thread%> erwartet

en: expected %<template%>
de: %<template%> erwartet

en: expected %<throw%>
de: %<throw%> erwartet

en: expected %<try%>
de: %<try%> erwartet

en: expected %<unified_address%>, %<unified_shared_memory%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause
de: eine der Klauseln %<unified_address%>, %<unified_shared_memory%>, %<dynamic_allocators%>, %<reverse_offload%> oder %<atomic_default_mem_order%> erwartet

en: expected %<using%>
de: %<using%> erwartet

en: expected %<while%>
de: %<while%> erwartet

en: expected %<{%>
de: %<{%> erwartet

en: expected %<{%> or %<:%>
de: %<{%> oder %<:%> erwartet

en: expected %<}%>
de: %<}%> erwartet

en: expected %<}%> before %<else%>
de: %<}%> vor %<else%> erwartet

en: expected %<~%>
de: %<~%> erwartet

en: expected %d levels of template parms for %q#D, got %d
de: %d Ebenen von Template-Parametern für %q#D erwartet, %d erhalten

en: expected %i or more, found %i
de: %i oder mehr erwartet, %i gefunden

en: expected %qE selector name
de: Selektorname für %qE erwartet

en: expected %qT but argument is of type %qT
de: %qT erwartet, aber Argument hat Typ %qT

en: expected %qs %<if%> clause modifier rather than %qs
de: %qs %<if%>-Klausel-Modifizierer anstelle %qs erwartet

en: expected %qs keyword before dependent template name
de: Schlüsselwort %qs vor dem Namen des abhängigen Templates erwartet

en: expected %qs or %qs
de: %qs oder %qs erwartet

en: expected '(' at %C
de: »(« bei %C erwartet

en: expected ')' at %C
de: »)« bei %C erwartet

en: expected '=' at %C
de: »=« bei %C erwartet

en: expected 'construct', 'device', 'implementation' or 'user' at %C
de: »construct«, »device«, »implementation« oder »user« bei %C erwartet

en: expected 'match' at %C
de: »match« bei %C erwartet

en: expected '{' at %C
de: »{« bei %C erwartet

en: expected '}' at %C
de: »}« bei %C erwartet

en: expected ...
de: %<...%> erwartet

en: expected 64-bit address but argument 1 is %d-bit
de: 64-Bit-Adresse erwartet, aber Argument 1 hat %d Bit

en: expected 64-bit address but argument 2 is %d-bit
de: 64-Bit-Adresse erwartet, aber Argument 2 hat %d Bit

en: expected : at %C
de: »:« bei %C erwartet

en: expected OpenMP directive name
de: Name einer OpenMP-Direktive erwartet

en: expected a string after %<#pragma message%>
de: hinter %<#pragma message%> wird eine Zeichenkette erwartet

en: expected an argument to %<msp430_select_cpu%>
de: Argument zu %<msp430_select_cpu%> erwartet

en: expected an identifier for the attribute name
de: Bezeichner für den Attributnamen erwartet

en: expected attribute argument as balanced token sequence
de: Attribut-Argument als ausbalancierte Tokenfolge erwartet

en: expected attribute before %<...%>
de: Attribut vor %<...%> erwartet

en: expected between %i and %i, found %i
de: zwischen %i und %i erwartet, %i gefunden

en: expected binary operator
de: binärer Operator erwartet

en: expected block index
de: Interner Fehler: expected block index

en: expected block specifier
de: Interner Fehler: expected block specifier

en: expected boolean expression
de: boolescher Ausdruck erwartet

en: expected boolean type
de: boolescher Typ erwartet

en: expected case label
de: Interner Fehler: expected case label

en: expected channel
de: Kanal erwartet

en: expected class name
de: Klassenname erwartet

en: expected class-key
de: Klassenschlüssel erwartet

en: expected class-name
de: Klassenname erwartet

en: expected constant integer expression with valid sync-hint value
de: konstanter Ganzzahlausdruck mit gültigem sync-hint-Wert erwartet

en: expected constant offset
de: konstanter Offset erwartet

en: expected constant size
de: konstante Größe erwartet

en: expected constructor, destructor, or type conversion
de: Konstruktor, Destruktor oder Typumwandlung erwartet

en: expected count value
de: Wert für die Anzahl erwartet

en: expected declaration
de: Deklaration erwartet

en: expected declaration or statement
de: Deklaration oder Anweisung erwartet

en: expected declaration specifiers
de: Deklarationsspezifizierer erwartet

en: expected declaration specifiers or %<...%>
de: Deklarationsspezifizierer oder %<...%> erwartet

en: expected declarator
de: Deklarator erwartet

en: expected else statement
de: Interner Fehler: expected else statement

en: expected empty string after %<operator%> keyword
de: hinter Schlüsselwort %<operator%> wird leere Zeichenkette erwartet

en: expected end of capture-list
de: unerwartetes Ende der Auffangliste

en: expected end of line
de: Zeilenende erwartet

en: expected exactly 1 argument
de: genau 1 Argument erwartet

en: expected expression
de: Ausdruck erwartet

en: expected expression at %C
de: Ausdruck bei %C erwartet

en: expected expression-list or type-id
de: »expression-list« oder »type-id« erwartet

en: expected frequency quality
de: Häufigkeit erwartet

en: expected frequency value
de: Häufigkeitswert erwartet

en: expected function
de: Funktion erwartet

en: expected function name
de: Funktionsname erwartet

en: expected function-name %<(%>
de: Funktionsname und %<(%> erwartet

en: expected goto expression
de: Interner Fehler: expected goto expression

en: expected id-expression
de: ID-Ausdruck erwartet

en: expected id-expression (arguments)
de: »id-expression (arguments)« erwartet

en: expected identifier
de: Bezeichner erwartet

en: expected identifier at %C
de: Bezeichner bei %C erwartet

en: expected identifier or %<(%>
de: Bezeichner oder %<(%> erwartet

en: expected identifier or %<)%>
de: Bezeichner oder %<)%> erwartet

en: expected identifier or %<*%>
de: Bezeichner oder %<*%> erwartet

en: expected identifier or string literal
de: Bezeichner oder Zeichenkettenliteral erwartet

en: expected identifier or string literal at %C
de: Bezeichner oder Zeichenkettenliteral bei %C erwartet

en: expected initializer
de: Initialisierung erwartet

en: expected integer
de: Ganzzahl erwartet

en: expected integer expression
de: Ganzzahlausdruck erwartet

en: expected integer expression list
de: Liste von Ganzzahlausdrücken erwartet

en: expected interface or pointer to interface
de: Schnittstelle oder Zeiger auf Schnittstelle erwartet

en: expected iteration declaration or initialization
de: Schleifendeklaration oder Initialisierung erwartet

en: expected iteration-statement
de: Iterationsanweisung erwartet

en: expected jump-statement
de: Sprunganweisung erwartet

en: expected label
de: Sprungmarke erwartet

en: expected labeled-statement
de: benannte Anweisung erwartet

en: expected loop number
de: Interner Fehler: expected loop number

en: expected map index on right hand side
de: Abbildungsindex auf rechter Seite erwartet

en: expected module-name
de: Modulname erwartet

en: expected name at %C
de: Name bei %C erwartet

en: expected namespace-name
de: Namensraumname erwartet

en: expected nested-name-specifier
de: Spezifikation mit geschachteltem Namen erwartet

en: expected numeric type
de: numerischer Typ erwartet

en: expected operator
de: Operator erwartet

en: expected parameter pack before %<...%>
de: Parameterbündel vor %<...%> erwartet

en: expected pass name
de: Interner Fehler: expected pass name

en: expected pointer
de: Zeiger erwartet

en: expected pointer as argument of unary %<*%>
de: Interner Fehler: expected pointer as argument of unary %<*%>

en: expected pointer in %qs clause
de: Zeiger in %qs-Klausel erwartet

en: expected primary-expression
de: übergeordneter Ausdruck erwartet

en: expected ptr-operator
de: Ptr-Operator erwartet

en: expected qualified name in friend declaration for constructor %qD
de: Qualifizierten Namen in Friend-Deklaration für Konstruktor %qD erwartet

en: expected qualified name in friend declaration for destructor %qD
de: Qualifizierten Namen in Friend-Deklaration für Destruktor %qD erwartet

en: expected selection-statement
de: Auswahl-Anweisung erwartet

en: expected signature: %qD
de: erwartete Signatur: %qD

en: expected simd clause at %C
de: SIMD-Klausel bei %C erwartet

en: expected single pointer in %qs clause
de: einelnen Zeiger in %qs-Klausel erwartet

en: expected specifier-qualifier-list
de: Spezifizierer-Qualifizierer-Liste erwartet

en: expected statement
de: Anweisung erwartet

en: expected string literal
de: Zeichenkettenliteral erwartet

en: expected string-literal
de: Zeichenkettenliteral erwartet

en: expected suffix identifier
de: Suffixbezeichner erwartet

en: expected template-argument
de: Templateargument erwartet

en: expected template-id
de: Template-ID erwartet

en: expected template-id for type
de: Template-ID für Typ erwartet

en: expected template-name
de: Templatename erwartet

en: expected trait selector name
de: Name des Merkmalsselektors erwartet

en: expected trait selector name at %C
de: Name des Merkmalsselektors bei %C erwartet

en: expected type specifier
de: Typspezifizierer erwartet

en: expected type-name
de: Typ-Name erwartet

en: expected type-specifier
de: Typspezifikation erwartet

en: expected unqualified-id
de: unqualifizierte ID erwartet

en: expected variant name at %C
de: Variantenname bei %C erwartet

en: expecting %E byte in a region of size %E | expecting %E bytes in a region of size %E
de[0]: Code erwartet %E Byte in einer Region der Größe %E
de[1]: Code erwartet %E Bytes in einer Region der Größe %E

en: expecting %E or more bytes in a region of size %E
de: Code erwartet %E oder mehr Bytes in einer Region der Größe %E

en: expecting argument of type pointer or of type integer for argument 1
de: als Argument 1 wurde entweder ein Zeigertyp oder ein Ganzzahltyp erwartet

en: expecting between %E and %E bytes in a region of size %E
de: Code erwartet zwischen %E und %E Bytes in einer Region der Größe %E

en: expecting internal function name
de: Interner Fehler: expecting internal function name

en: explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>
de: explizites by-copy-Einfangen von %<this%> mit by-copy-Einfangvorgabe ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: explicit by-copy capture of %qD redundant with by-copy capture default
de: Explizite Erfassung (als Kopie) von %qD ist mit Standarderfassung (als Kopie) gedoppelt

en: explicit by-reference capture of %qD redundant with by-reference capture default
de: Explizite Erfassung (als Referenz) von %qD ist mit Standarderfassung (als Referenz) gedoppelt

en: explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>
de: explizite Umwandlungsoperatoren nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: explicit deduction guide declared here
de: der explizite Herleitungshinweis ist hier deklariert

en: explicit deduction guides not considered for copy-initialization
de: Explizite Herleitungshinweise werden nicht für »copy-initialization« berücksichtigt

en: explicit goto at end of bb %d
de: Interner Fehler: explicit goto at end of bb %d

en: explicit instantiation of %q#D
de: explizite Instanziierung von %q#D

en: explicit instantiation of %q#T before definition of template
de: explizite Instanziierung von %q#T vor Definition des Templates

en: explicit instantiation of %qD but no definition available
de: explizite Instanziierung von %qD, aber keine Definition verfügbar

en: explicit instantiation of %qD in namespace %qD (which does not enclose namespace %qD)
de: explizite Instanziierung von %qD in Namensbereich %qD (das nicht Namensbereich %qD einschließt)

en: explicit instantiation of %qD outside its namespace must use a nested-name-specifier
de: explizite Instanziierung von %qD außerhalb seines Namensraums muss einen nested-name-specifier verwenden

en: explicit instantiation of function concept %q#D
de: Explizite Instanziierung des Funktionskonzepts %q#D

en: explicit instantiation of non-class template %qD
de: explizite Instanziierung des Nicht-Klassen-Templates %qD

en: explicit instantiation of non-template %q#D
de: explizite Instanziierung des Nicht-Templates %q#D

en: explicit instantiation of non-template type %qT
de: explizite Instanziierung des Nicht-Templatetyps %qT

en: explicit instantiation of variable concept %q#D
de: Explizite Instanziierung des Variablenkonzepts %q#D

en: explicit instantiation shall not use %<consteval%> specifier
de: explizite Instanziierung darf kein %<consteval%> verwenden

en: explicit instantiation shall not use %<constexpr%> specifier
de: explizite Instanziierung darf kein %<constexpr%> verwenden

en: explicit instantiation shall not use %<inline%> specifier
de: explizite Instanziierung darf kein %<inline%> verwenden

en: explicit qualification in declaration of %qD
de: explizite Qualifizierung in Deklaration von %qD

en: explicit specialization %q#D may be missing attributes
de: der expliziten Spezialisierung %q#D fehlen möglicherweise Attribute

en: explicit specialization declared %<concept%>
de: explizite Spezialisierung als %<concept%> deklariert

en: explicit specialization in non-namespace scope %qD
de: explizite Spezialisierung in Gültigkeitsbereich des Nicht-Namensbereiches %qD

en: explicit specialization of %qD after first use
de: explizite Spezialisierung von %qD nach erster Verwendung

en: explicit specialization of %qD must be introduced by %<template <>%>
de: der expliziten Spezialisierung von %D muss %<template <>%> vorausgehen

en: explicit specialization of %qD outside its namespace must use a nested-name-specifier
de: explizite Spezialisierung von %qD außerhalb seines Namensraums muss einen nested-name-specifier verwenden

en: explicit specialization of function concept %qD
de: explizite Spezialisierung des Funktionskonzepts %qD

en: explicit specialization of non-template %qT
de: explizite Spezialisierung des Nicht-Templates %qT

en: explicit template argument list not allowed
de: explizite Templateargumentliste nicht erlaubt

en: explicit template specialization cannot have a storage class
de: explizite Template-Spezialisierung kann keine Speicherklasse haben

en: explicitly defaulted function %q+D cannot be declared %qs because the implicit declaration is not %qs:
de: Explizite Standardfunktion %q+D kann nicht als %qs deklariert werden, da die implizite Deklaration nicht %qs ist:

en: explicitly used registers must be grouped at top of stack
de: explizit verwendete Register müssen oben auf dem Stapel gruppiert werden

en: exponent-letter 'q' in real-literal-constant at %C
de: Exponent-Buchstabe »q« in Real-Literalkonstante bei %C

en: expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L
de: Der Ausdruck bei %L in der !$OMP-ATOMIC-COMPARE-Zuweisung »Variable = Ausdruck« muss skalar sein und darf die Variable nicht referenzieren

en: expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L
de: Ausdruck in !$OMP ATOMIC WRITE-Zuweisung »var = expr« muss skalar sein und kann keine Variable bei %L referenzieren

en: expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L
de: Ausdruck in Zuweisung !$OMP ATOMIC »var = var op expr« muss skalar sein und kann keine Variable bei %L referenzieren

en: expression %qE does not designate a %<constexpr%> function
de: Ausdruck %qE bezeichnet keine %<constexpr%>-Funktion

en: expression %qE is not a constant expression
de: Ausdruck %qE ist kein Konstantenausdruck

en: expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>
de: Ausdruck %qs erfordert %<object.TypeInfo%> und kann nicht mit %<-fno-rtti%> verwendet werden

en: expression cannot be used as a function
de: Ausdruck kann nicht als Funktion verwendet werden

en: expression does not compute the number of elements in this array; element type is %qT, not %qT
de: Ausdruck berechnet nicht die Anzahl der Elemente in diesem Array; der Elementtyp ist %qT, nicht %qT

en: expression in new-declarator must have integral or enumeration type
de: Ausdruck in new-Deklarator muss Ganzzahl- oder Aufzählungstyp haben

en: expression in static assertion is not an integer
de: Ausdruck in statischer Behauptung ist keine Ganzzahl

en: expression in static assertion is not an integer constant expression
de: Ausdruck in statischer Behauptung ist kein konstanter Ganzzahlausdruck

en: expression in static assertion is not constant
de: Ausdruck in statischer Behauptung ist nicht konstant

en: expression list treated as compound expression in functional cast
de: Ausdrucksliste als zusammengesetzten Ausdruck in funktionaler Umwandlung behandelt

en: expression list treated as compound expression in initializer
de: Ausdrucksliste als zusammengesetzten Ausdruck in Initialisierung behandelt

en: expression list treated as compound expression in mem-initializer
de: Ausdrucksliste als zusammengesetzten Ausdruck in Speicherinitialisierung behandelt

en: expression must be enclosed in parentheses
de: Ausdruck muss in runden Klammern eingeschlossen sein

en: expression must be integral
de: Ausdruck muss ganzzahlig sein

en: expression of abstract class type %qT cannot be used in throw-expression
de: Ausdruck von abstraktem Klassentyp %qT kann nicht in throw-Ausdruck verwendet werden

en: expression statement has incomplete type
de: Ausdrucksanweisung hat unvollständigen Typ

en: extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>
de: erweiterte Initialisierungslisten nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: extended registers have no high halves
de: erweiterte Register haben keine oberen Hälften

en: extern declaration of %q+D follows declaration with no linkage
de: extern-Deklaration von %q+D folgt Deklaration ohne Bindung

en: extern model globalvalue
de: Globaler Wert mit externem Modell

en: external TLS initialization functions not supported on this target
de: externe Funktionen zur TLS-Initialisierung werden auf diesem Ziel nicht unterstützt

en: external linkage required for symbol %q+D because of %qE attribute
de: für Symbol %q+D wird wegen des Attributes %qE externe Bindung benötigt

en: externally visible inline clone
de: Interner Fehler: externally visible inline clone

en: extra %<;%>
de: zusätzliches %<;%>

en: extra %<;%> after in-class function definition
de: zusätzliches %<;%> hinter Funktionsdefinition innerhalb einer Klasse

en: extra brace group at end of initializer
de: zusätzliche geschweifte Klammern am Ende der Initialisierung

en: extra elements in scalar initializer
de: zusätzliche Elemente in Skalar-Initialisierung

en: extra outgoing edge %d->%d
de: Interner Fehler: extra outgoing edge %d->%d

en: extra qualification %<%T::%> on member %qs
de: zusätzliche Qualifizierung %<%T::%> an Element %qs

en: extra qualification not allowed
de: zusätzliche Qualifizierung nicht erlaubt

en: extra semicolon
de: zusätzliches Semikolon

en: extra semicolon in method definition specified
de: zusätzliches Semikolon in Methodendefinition angegeben

en: extra semicolon in struct or union specified
de: zusätzliches Semikolon in »struct« oder »union« angegeben

en: extra type qualifiers in format argument (argument %d)
de: zusätzliche Typqualifizierer in Format-Argument (Argument %d)

en: extraneous data at end of file
de: zusätzliche Daten am Ende der Datei

en: fail to initialize plugin %s
de: Plugin %s kann nicht initialisiert werden

en: failed %s mapper %qs
de: Fehler beim »%s« des Mappers %qs

en: failed %s mapper %qs line %u
de: Fehler beim »%s« des Mappers %qs in Zeile %u

en: failed mapper handshake %s
de: Fehler beim Handshake des Mappers: %s

en: failed to expand built-in function
de: eingebaute Funktion konnte nicht expandiert werden

en: failed to get exit status: %m
de: Ende-Status konnte nicht ermittelt werden: %m

en: failed to get process times: %m
de: Verarbeitungszeiten konnten nicht ermittelt werden: %m

en: failed to initialize plugin %s
de: Plugin %s kann nicht initialisiert werden

en: failed to load binding %<%E%s%E%>
de: Fehler beim Laden der Bindung %<%E%s%E%>

en: failed to load binding %<%E%s%E@%s%>
de: Fehler beim Laden der Bindung %<%E%s%E@%s%>

en: failed to load pendings for %<%E%s%E%>
de: Fehler beim Laden der ausstehenden Einheiten für %<%E%s%E%>

en: failed to open temporary file %s for LTO output
de: temporäre Datei %s konnte nicht für LTO-Ausgaben geöffnet werden

en: failed to open temporary file %s with LTO output
de: temporäre Datei %s konnte nicht mit LTO-Ausgabe geöffnet werden

en: failed to read compiled module cluster %u: %s
de: Fehler beim Lesen des kompilierten Modul-Clusters %u: %s

en: failed to read compiled module: %s
de: Fehler beim Lesen des kompilierten Modus: %s

en: failed to reclaim unneeded function
de: Zurückfordern der nicht benötigten Funktion gescheitert

en: failed to reclaim unneeded function in same comdat group
de: Zurückfordern der nicht benötigten Funktion in gleicher Comdat-Gruppe gescheitert

en: failed to translate literal to execution character set %qT
de: Literal konnte nicht in den Zeichenvorrat %qT der Ausführungsumgebung übersetzt werden

en: failed to write compiled module: %s
de: Fehler beim Schreiben des kompilierten Moduls: %s

en: failure memory model %qs cannot be stronger than success memory model %qs for %qD
de: Fehler-Speichermodell %qs kann nicht stärker als Erfolgs-Speichermodell %qs für %qD sein

en: failure memory model %wi cannot be stronger than success memory model %wi for %qD
de: Fehler-Speichermodell %wi kann nicht stärker als Erfolgs-Speichermodell %wi für %qD sein

en: failure to simplify substring reference in DATA statement at %L
de: Fehlschlag bei Vereinfachung der Teil-Zeichenketten-Referenz in DATA-Anweisung bei %L

en: failure trying to reload:
de: Neuladen gescheitert:

en: fallthru edge after a control statement in bb %d
de: Interner Fehler: fallthru edge after a control statement in bb %d

en: fallthru edge after unconditional jump in bb %i
de: Interner Fehler: fallthru edge after unconditional jump in bb %i

en: fallthru edge crosses section boundary in bb %i
de: Interner Fehler: fallthru edge crosses section boundary in bb %i

en: fast enumeration is not available in Objective-C 1.0
de: in Objective-C 1.0 gibt es keine schnelle Aufzählung

en: fastcall and cdecl attributes are not compatible
de: Attribute fastcall und cdecl sind nicht verträglich

en: fastcall and regparm attributes are not compatible
de: Attribute fastcall und regparm sind nicht verträglich

en: fastcall and stdcall attributes are not compatible
de: Attribute fastcall und stdcall sind nicht verträglich

en: fastcall and thiscall attributes are not compatible
de: Attribute fastcall und thiscall sind nicht verträglich

en: fatal error:
de: schwerwiegender Fehler:

en: field %q#D can be accessed via %q#D
de: auf Feld %q#D kann mittels %q#D zugegriffen werden

en: field %q#D with same name as class
de: Feld %q#D mit gleichem Namen wie Klasse

en: field %qD has incomplete type %qT
de: Feld %qD hat unvollständigen Typen %qT

en: field %qE declared as a function
de: Feld %qE als Funktion deklariert

en: field %qE has incomplete type
de: Feld %qE hat unvollständigen Typen

en: field name not in record or union initializer
de: Feldname nicht in Datensatz- oder union-Initialisierung

en: field precision specifier
de: Feldpräzisionsangabe

en: field width
de: Feldbreite

en: field width in printf format
de: Feldbreite im printf-Format

en: field width in scanf format
de: Feldbreite im scanf-Format

en: field width in strfmon format
de: Feldbreite im strfmon-Format

en: field width in strftime format
de: Feldbreite im strftime-Format

en: field width specifier
de: Feldbreitenangabe

en: fields cannot have SVE type %qT
de: Felder können nicht vom SVE-Typ %qT sein

en: fields have different layout in another translation unit
de: Felder haben unterschiedliches Layout in einer anderen Übersetzungseinheit

en: file %qs left but not entered
de: Datei %qs verlassen, aber nicht betreten

en: file ends in default argument
de: Datei endet in Standardargument

en: file-scope declaration of %qE specifies %<auto%>
de: Deklaration von %qE in Datei-Sichtbarkeitsbereich spezifiziert %<auto%>

en: file-scope declaration of %qE specifies %<register%>
de: Deklaration von %qE in Datei-Sichtbarkeitsbereich spezifiziert %<register%>

en: filename %qs does not start with profile prefix %qs
de: der Dateiname %qs beginnt nicht mit dem Profil-Präfix %qs

en: fill character
de: Füllzeichen

en: fill character in strfmon format
de: Füllzeichen im strfmon-Format

en: fini function found in object %s
de: fini-Funktion im Objekt %s gefunden

en: first %<sizeof%> operand was declared here
de: der Operand des ersten %<sizeof%> wurde hier deklariert

en: first argument must be []byte
de: erstes Argument muss []byte sein

en: first argument of %q+D should be %<int%>
de: erstes Argument von %q+D sollte %<int%> sein

en: first argument of %qD must be a pointer, second integer constant
de: erstes Argument von %qD muss ein Zeiger, das zweite eine Ganzzahlkonstante sein

en: first argument to %<__builtin_call_with_static_chain%> must be a call expression
de: Erstes Argument für %<__builtin_call_with_static_chain%> muss ein Aufrufausdruck sein

en: first argument to %<__builtin_choose_expr%> not a constant
de: erstes Argument für %<__builtin_choose_expr%> ist keine Konstante

en: first argument to %<va_arg%> not of type %<va_list%>
de: Erstes Argument für %<va_arg%> nicht vom Typ %<va_list%>

en: first mismatch is field
de: Interner Compilerfehler: first mismatch is field

en: first offset must be in opposite direction of loop iterations
de: erster Offset muss in umgedrehter Richtung der Schleifeniterationen sein

en: first register must be R0
de: erstes Register muss R0 sein

en: first seen here
de: erstmals hier gesehen

en: first specified here
de: erstmals hier angegeben

en: fixed ebp register requires %<-maccumulate-outgoing-args%>
de: feststehendes ebp-Register erfordert %<-maccumulate-outgoing-args%>

en: fixed ebp register requires %<target("accumulate-outgoing-args")%>
de: feststehendes ebp-Register erfordert %<target("accumulate-outgoing-args")%>

en: fixed register %s used to pass parameter to function
de: festes Register %s zur Parameterübergabe an Funktion verwendet

en: fixed tree mismatch
de: reparierte Bäume sind unverträglich

en: fixed-point overflow in expression %qE of type %qT results in %qE
de: Festkommaüberlauf in Ausdruck %qE des Typs %qT ergibt %qE

en: fixed-point overflow in expression of type %qT results in %qE
de: Festkommaüberlauf in Ausdruck des Typs %qT ergibt %qE

en: fixed-point types not supported for this target
de: Festkommatypen werden für dieses Ziel nicht unterstützt

en: fixed-point types not supported in C++
de: Festkommatypen werden in C++ nicht unterstützt

en: flexible array member %qD does not have well defined padding bits for %qs
de: flexibles Arrayelement %qD hat keine wohldefinierten Paddingbits für %qs

en: flexible array member %qD in an otherwise empty %q#T
de: flexibles Arrayelement %qD in ansonsten leerem %q#T

en: flexible array member %qD in union
de: flexibles Arrayelement %qD in Union

en: flexible array member %qD not at end of %q#T
de: flexibles Arrayelement %qD nicht am Ende von %q#T

en: flexible array member in a struct with no named members
de: flexibles Arrayelement in einer Struktur ohne benannte Elemente

en: flexible array member in union
de: flexibles Arrayelement in Union

en: flexible array member not at end of struct
de: flexibles Arrayelement nicht am Ende von struct

en: floating constant exceeds range of %qT
de: Gleitkommakonstante überschreitet Wertebereich von %qT

en: floating constant misused
de: Gleitkommakonstante falsch verwendet

en: floating constant truncated to zero
de: Gleitkommakonstante auf Null abgeschnitten

en: floating literal exceeds range of %qT type
de: Gleitkommaliteral überschreitet Wertebereich des Typs %qT

en: floating literal truncated to zero
de: Gleitkommaliteral auf Null abgeschnitten

en: floating point overflow in expression %qE of type %qT results in %qE
de: Gleitkommaüberlauf in Ausdruck %qE des Typs %qT ergibt %qE

en: floating point overflow in expression of type %qT results in %qE
de: Gleitkommaüberlauf in Ausdruck des Typs %qT ergibt %qE

en: floating-point constant not a valid immediate operand
de: Gleitkommakonstante ist kein gültiger direkter Operand

en: floating-point suffix %qs shadowed by implementation
de: Gleitkomma-Suffix %qs durch Implementierung überdeckt

en: flow control insn inside a basic block
de: Ablaufsteuerungsbefehl innerhalb eines Basis-Blockes

en: fmax-include-depth=<number> Set the maximum depth of the nested #include.
de: fmax-include-depth=<Anzahl> Maximale Tiefe von verschachtelten #include festlegen.

en: fold check: original tree changed by fold
de: Faltungstest: ursprünglicher Baum durch Faltung geändert

en: fold of empty expansion over %O
de: Falten einer leeren Expansion über %O

en: fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>
de: fold-expressions sind nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar

en: for %qD
de: für %qD

en: for a function-style cast, remove the redundant %<::%D%>
de: um eine funktionsartige Umwandlung zu erreichen, entfernen Sie das redundante %<::%D%>

en: for array function parameter length expression must be specified
de: für Funktionsparameter vom Typ Array muss die Länge angegeben sein

en: for backward compatibility
de: für Rückwärtskompatibilität

en: for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)
de: um %<std::initializer_list%> herzuleiten, verwenden Sie einen copy-list-initialization (also mit %<=%> vor dem %<{%>)

en: for increment expression cannot resolve address of overloaded function
de: Erhöhungsausdruck kann die Adresse der überladenen Funktion nicht auflösen

en: for increment expression has no effect
de: Erhöhungsausdruck hat keinen Effekt

en: for increment expression is a reference, not call, to function %qE
de: Erhöhungsausdruck ist eine Referenz, kein Aufruf, zur Funktion %qE

en: for pointer type length expression must be specified
de: für Zeigertyp muss der Längenausdruck angegeben werden

en: for statement expected
de: für Anweisung erwartet

en: for template declaration %q+D
de: Für Template-Deklaration %q+D

en: for the option %<-mcache-block-size=X%>, the valid X must be: 4, 8, 16, 32, 64, 128, 256, or 512
de: für die Option %<-mcache-block-size=X%> sind nur die Werte 4, 8, 16, 32, 64, 128, 256 oder 512 gültig

en: for type %qT
de: für Typ %qT

en: for unknown bound array type length expression must be specified
de: für Arraytyp mit unbekannten Grenzen muss ein Längenausdruck angegeben werden

en: for, while or do statement expected
de: for-, while- oder do-Anweisung erwartet

en: format
de: Format

en: format argument %d unused before used argument %d in %<$%>-style format
de: Formatargument %d nicht verwendet vor verwendetem Argument %d im %<$%>-Stil-Format

en: format argument %d used more than once in %s format
de: Formatargument %d mehr als einmal im %s-Format verwendet

en: format argument should be a %qs reference
de: Formatargument sollte eine %qs-Referenz sein

en: format argument should be a %qs reference but a string was found
de: eine Zeichenkette wurde gefunden, aber das Format-Argument sollte eine %qs-Referenz sein

en: format is a wide character string
de: Format ist »wide character«-Zeichenkette

en: format not a string literal and no format arguments
de: Format ist kein Zeichenkettenliteral, und keine Formatargumente

en: format not a string literal, argument types not checked
de: Format ist kein Zeichenkettenliteral, Argumenttypen ungeprüft

en: format not a string literal, format string not checked
de: Format ist kein Zeichenkettenliteral, Formatzeichenkette ungeprüft

en: format of column headings in %<devices.csv%> is incorrect
de: Format der Spaltenüberschriften in %<devices.csv%> ist falsch

en: format string argument follows the arguments to be formatted
de: Format-Zeichenkettenargument folgt den zu formatierenden Argumenten

en: format string argument is not a string type
de: Format-Zeichenkettenargument ist kein Zeichenkettentyp

en: format string is defined here
de: Formatzeichenkette ist hier definiert

en: format string is not an array of type %qs
de: Formatzeichenkette ist kein Array vom Typ %qs

en: forming pointer to qualified function type %qT
de: Zeiger auf qualifizierten Funktionstypen %qT wird geformt

en: forming pointer to reference type %qT
de: Zeiger auf Referenztyp %qT wird geformt

en: forming reference to qualified function type %qT
de: Referenz auf qualifizierten Funktionstypen %qT wird geformt

en: forming reference to reference type %qT
de: Referenz auf Referenztyp %qT wird geformt

en: forming reference to void
de: Referenz auf »void« wird gebildet

en: forming type of %qs
de: beim Formen des Typs von %qs

en: forward declaration of %q#T
de: Vorwärtsdeklaration von %q#T

en: forward reference to frame of %qs
de: Vorwärtsbezug zum Rahmen von %qs

en: found %<%c%s%>
de: %<%c%s%> gefunden

en: found %<-%E%> instead of %<+%E%> in protocol(s)
de: %<-%E%> statt %<+%E%> in Protokoll(en) gefunden

en: found %<:%> in nested-name-specifier, expected %<::%>
de: %<:%> in Spezifikation mit geschachteltem Namen gefunden, %<::%> erwartet

en: found a %qT but the format argument should be a string
de: ein %qT wurde gefunden, aber das Format-Argument sollte eine Zeichenkette sein

en: found a %qs reference but the format argument should be a string
de: eine %qs-Referenz wurde gefunden, aber das Format-Argument sollte eine Zeichenkette sein

en: found default case not at the start of case vector
de: Interner Fehler: found default case not at the start of case vector

en: fp software completion requires %<-mtrap-precision=i%>
de: Gleitkomma-Software-Vervollständigung benötigt %<-mtrap-precision=i%>

en: fr30_print_operand: invalid %%F code
de: fr30_print_operand: ungültiger Code %%F

en: fr30_print_operand: invalid %%x code
de: fr30_print_operand: ungültiger Code %%x

en: fr30_print_operand: invalid operand to %%A code
de: fr30_print_operand: ungültiger Operand für Code %%A

en: fr30_print_operand: unhandled MEM
de: fr30_print_operand: unbehandeltes MEM

en: fr30_print_operand: unknown code
de: fr30_print_operand: unbekannter Code

en: fr30_print_operand: unrecognized %%B code
de: fr30_print_operand: nicht erkannter Code %%B

en: fr30_print_operand: unrecognized %%b code
de: fr30_print_operand: nicht erkannter Code %%b

en: fr30_print_operand: unrecognized %%p code
de: fr30_print_operand: nicht erkannter Code %%p

en: fr30_print_operand_address: unhandled address
de: fr30_print_operand_address: unbehandelte Adresse

en: frame pointer required, but reserved
de: Rahmenzeiger benötigt, aber reserviert

en: frame size of %qs is %wd bytes
de: Rahmengröße von %qs ist %wd Bytes

en: frame size of function %qs is %wd bytes exceeding user provided stack limit of %d bytes; an unconditional trap is added
de: Rahmengröße der Funktion %qs ist %wd Bytes, das ist größer als die benutzerdefinierte Stapelgrenze von %d Bytes; eine bedingungslose Falle wird gesetzt

en: frame size of function %qs is %wd bytes which is more than half the stack size; the dynamic check would not be reliable; no check emitted for this function
de: Rahmengröße der Funktion %qs ist %wd Bytes, das ist mehr als die Hälfte der Stapelgröße; die dynamische Prüfung wäre nicht zuverlässig; für diese Funktion wird keine Prüfcode generiert

en: frame size too large for reliable stack checking
de: Rahmengröße zu groß für zuverlässige Stapelüberprüfung

en: friend declaration %q#D declares a non-template function
de: »friend«-Deklaration %q#D deklariert eine Nicht-Template-Funktion

en: friend declaration %qD in local class without prior local declaration
de: Friend-Deklaration %qD in lokaler Klasse ohne vorherige Deklaration

en: friend declaration %qD is not visible to explicit specialization
de: »friend«-Deklaration %qD ist für explizite Spezialisierung nicht sichtbar

en: friend declaration %qD may not have virt-specifiers
de: »friend«-Deklaration %qD darf keine »virt-specifier« haben

en: friend declaration does not name a class or function
de: »friend«-Deklaration benennt keine Klasse oder Funktion

en: friend declaration here
de: %<friend%>-Deklaration hier

en: friend declaration not in class definition
de: friend-Deklaration nicht in Klassendefinition

en: friend declaration of %q#D specifies default arguments and isn%'t the only declaration
de: »friend«-Deklaration %q#D gibt Defaultargumente an und ist nicht die einzige Deklaration

en: friend declaration of %qD specifies default arguments and isn%'t a definition
de: »friend«-Deklaration von %qD gibt Defaultargumente an und ist keine Definition

en: friend declaration requires class-key, i.e. %<friend %#T%>
de: friend-Deklaration erfordert Klassenschlüssel, d.h. %<friend %#T%>

en: friend declaration requires class-key, i.e. %<friend class %T::%D%>
de: friend-Deklaration erfordert Klassenschlüssel, d.h. %<friend class %T::%D%>

en: friend function definition %qs cannot have a name qualified with %<%D::%>
de: Definition der Freundfunktion %qs kann keinen Namen haben, der mit %<%D::%> qualifiziert ist

en: friend function definition %qs cannot have a name qualified with %<::%>
de: Definition der Freundfunktion %qs kann keinen Namen haben, der mit %<::%> qualifiziert ist

en: from definition of %q#D
de: aus der Definition von %q#D

en: from previous declaration %qF
de: von vorheriger Deklaration %qF

en: frv_print_operand: unknown code
de: frv_print_operand: unbekannter Code

en: func can only be compared to nil
de: Funktion kann nur mit nil verglichen werden

en: function %q#D is initialized like a variable
de: Funktion %q#D ist wie eine Variable initialisiert

en: function %q+D definition is marked dllimport
de: Funktionsdefinition von %q+D ist als »dllimport« markiert

en: function %q+D part of alias cycle
de: Funktion %q+D Teil des Alias-Zyklus

en: function %q+F can never be copied because it has %<noclone%> attribute
de: Funktion %q+F kann nie kopiert werden, da sie das Attribut %<noclone%> hat

en: function %q+F can never be copied because it receives a non-local goto
de: die Funktion %q+F kann nie kopiert werden, da sie ein nichtlokales »goto« empfängt

en: function %q+F can never be copied because it saves address of local label in a static variable
de: die Funktion %q+F kann nie kopiert werden, da sie die Adresse einer lokalen Marke in statischer Variablen speichert

en: function %q+F can never be inlined because it contains a computed goto
de: die Funktion %q+F kann nie »inline« sein, da sie ein berechnetes »goto« enthält

en: function %q+F can never be inlined because it has a VLA argument
de: die Funktion %q+F kann nie »inline« sein, da sie ein Argument vom Typ Array variabler Länge hat

en: function %q+F can never be inlined because it is suppressed using %<-fno-inline%>
de: die Funktion %q+F kann nie inline sein, da dies mit %<-fno-inline%> unterdrückt wird

en: function %q+F can never be inlined because it uses %<__builtin_return%> or %<__builtin_apply_args%>
de: die Funktion %q+F kann nie »inline« sein, da sie %<__builtin_return%> oder %<__builtin_apply_args%> verwendet

en: function %q+F can never be inlined because it uses alloca (override using the always_inline attribute)
de: die Funktion %q+F kann nie »inline« sein, da sie alloca verwendet (zum Aufheben: Attribut »always_inline« verwenden)

en: function %q+F can never be inlined because it uses attributes conflicting with inlining
de: Funktion %q+F kann nie inline sein, da sie mit inline in Konflikt stehende Attribute hat

en: function %q+F can never be inlined because it uses non-local goto
de: die Funktion %q+F kann nie »inline« sein, da sie ein nichtlokales »goto« enthält

en: function %q+F can never be inlined because it uses setjmp
de: die Funktion %q+F kann nie »inline« sein, da sie setjmp verwendet

en: function %q+F can never be inlined because it uses setjmp-longjmp exception handling
de: die Funktion %q+F kann nie »inline« sein, da sie »setjmp-longjmp«-Ausnahmebehandlung verwendet

en: function %q+F can never be inlined because it uses variable argument lists
de: die Funktion %q+F kann nie »inline« sein, da sie eine variable Argumentliste verwendet

en: function %qD declared %<[[noreturn]]%> but its first declaration was not
de: Funktion %qD wurde als %<[[noreturn]]%> deklariert, das weicht von der ersten Deklaration ab

en: function %qD declared %<virtual%> inside a union
de: Funktion %qD wurde innerhalb einer Union als %<virtual%> deklariert

en: function %qD is initialized like a variable
de: Funktion %qD ist wie eine Variable initialisiert

en: function %qD might be a candidate for %qs format attribute
de: Funktion %qD könnte ein Kandidat für Formatattribut %qs sein

en: function %qD redeclared as variable
de: Funktion %qD als Variable redeklariert

en: function %qD used as %<asm%> output
de: Funktion %qD als %<asm%>-Ausgabe verwendet

en: function %qs cannot be declared %<mutable%>
de: Funktion %qs kann nicht als %<mutable%> deklariert sein

en: function %qs has been referenced in offloaded code but hasn%'t been marked to be included in the offloaded code
de: Funktion %qs wurde in ausgelagertem Code referenziert, wurde aber nicht markiert, dass sie im ausgelagerten Code enthalten sein dürfte

en: function %qs, parameter %u, has IPA-SRA accesses which overlap
de: Die Funktion %qs, Parameter %u, hat IPA-SRA-Zugriffe, die sich überlappen

en: function %qs, parameter %u, is used but does not have any certain IPA-SRA access
de: Funktion %qs, Parameter %u, wird verwendet, hat aber keinen bestimmten IPA-SRA-Zugriff

en: function arguments of %<__builtin_tgmath%> all have the same type
de: funktionsargumente von %<__builtin_tgmath%> haben alle denselben Typ

en: function arguments of %<__builtin_tgmath%> lack type-generic parameter
de: den Funktionsargumenten von %<__builtin_tgmath%> fehlt der typgenerische Parameter

en: function attributes %qs and %qs are mutually exclusive
de: Funktionsattribute %qs und %qs schließen sich gegenseitig aus

en: function body can be overwritten at link time
de: Funktionskörper kann zum Link-Zeitpunkt überschrieben werden

en: function body not available
de: Funktionskörper nicht verfügbar

en: function call has aggregate value
de: Funktionsaufruf hat zusammengesetzten Wert

en: function call of variable concept %qE
de: Funktionsaufruf des Variablenkonzepts %qE

en: function called through a non-compatible type
de: Funktion über nicht kompatiblen Typen aufgerufen

en: function concept must be called
de: Funktionskonzept muss aufgerufen werden

en: function declaration isn%'t a prototype
de: Funktionsdeklaration ist kein Prototyp

en: function declared %<noreturn%> has a %<co_return%> statement
de: eine mit %<noreturn%> deklarierte Funktion hat eine %<co_return%>-Anweisung

en: function declared %<noreturn%> has a %<return%> statement
de: als %<noreturn%> deklarierte Funktion hat %<return%>-Anweisung

en: function definition declared %<auto%>
de: Funktionsdefinition deklarierte %<auto%>

en: function definition declared %<register%>
de: Funktionsdefinition deklarierte %<register%>

en: function definition declared %<typedef%>
de: Funktionsdefinition deklarierte %<typedef%>

en: function definition declared %qs
de: Funktionsdefinition deklarierte %qs

en: function definition does not declare parameters
de: Funktionsdefinition deklariert keine Parameter

en: function definition has qualified void return type
de: Funktionsdefinition hat qualifizierten void-Rückgabetypen

en: function does not return string type
de: Funktion gibt keinen Zeichenkettentypen zurück

en: function has external linkage when the user requests only inlining static for live patching
de: Funktion ist extern gebunden, aufgrund einer Benutzeranforderung werden nur static-Funktionen geinlinet, um Live-Patchen zu ermöglichen

en: function may return address of local variable
de: Funktion liefert möglicherweise Adresse einer lokalen Variablen zurück

en: function might be candidate for attribute %qs
de: Funktion könnte ein Kandidat für Attribut %qs sein

en: function might be candidate for attribute %qs if it is known to return normally
de: Funktion könnte Kandidat für Attribut %qs sein, wenn sie als normal zurückkehrend bekannt ist

en: function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>
de: Funktionsname als linker Operand von %<<%> ist in C++20 verboten; klammern Sie den Funktionsnamen mit %<()%> ein

en: function not considered for inlining
de: Funktion kommt nicht für »inline« in Betracht

en: function not declared inline and code size would grow
de: Funktion nicht »inline« deklariert und Codegröße würde wachsen

en: function not inlinable
de: Funktion kann nicht »inline« sein

en: function not inline candidate
de: Funktion kein Kandidat für »inline«

en: function or array type %qT in %<#pragma omp declare reduction%>
de: Funktions- oder Arraytyp %qT in %<#pragma omp declare reduction%>

en: function or array type in %<#pragma omp declare reduction%>
de: Funktions- oder Arraytyp in %<#pragma omp declare reduction%>

en: function parameter
de: Funktionsparameter

en: function pointers not supported with %<-mabi=ti%> option
de: Funktionszeiger werden mit der Option %<-mabi=ti%> nicht unterstützt

en: function requires a dual-context, which is not yet supported by GDC
de: die Funktion erfordert einen Dual-Kontext, der von GDC noch nicht unterstützt wird

en: function result count mismatch
de: Unpassende Anzahl der Rückgabewerte

en: function return type cannot be function
de: Rückgabetyp der Funktion kann keine Funktion sein

en: function return types not compatible due to %<volatile%>
de: Funktionsrückgabetypen nicht kompatibel wegen %<volatile%>

en: function returning a function
de: Funktion gibt eine Funktion

en: function returning an array
de: Funktion gibt ein Array zurück

en: function returns address of label
de: Funktion liefert Adresse einer Sprungmarke zurück

en: function returns address of local variable
de: Funktion liefert Adresse einer lokalen Variablen zurück

en: function returns an aggregate
de: Funktion gibt Aggregat zurück

en: function starts on a higher line number than it ends
de: Funktion beginnt in einer höheren Zeilennummer als sie endet

en: function symbol is not function
de: Interner Fehler: function symbol is not function

en: function template %qD redeclared as a class template
de: Funktions-Template %qD als Klassentemplate redeklariert

en: function template-id %qD in nested-name-specifier
de: Bezeichner %qD für Funktionstemplate ist geschachteltem Namens-Spezifizierer

en: function types not truly compatible in ISO C
de: Funktionstypen nicht wirklich kompatibel in ISO-C

en: function versions cannot be marked as %<gnu_inline%>, bodies have to be generated
de: Funktionsversionen können nicht als %<gnu_inline%> markiert werden, Körper müssen generiert werden

en: function with qualified void return type called
de: Funktion mit qualifiziertem void-Rückgabetypen aufgerufen

en: function-scope %qE implicitly auto and declared %qs
de: Funktions-Gültigkeitsbereich %qE ist implizit auto, jedoch als %qs deklariert

en: function-scope %qs implicitly auto and declared %<__thread%>
de: Funktions-Gültigkeitsbereich %qs ist implizit auto und deklarierte %<__thread%>

en: function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>
de: Rumpf eines function-try-block in einem %<constexpr%>-Konstruktor ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>
de: Rumpf eines function-try-block in einer %<constexpr%>-Funktion ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: functional cast to array type %qT
de: funktionale Umwandlung in Arraytyp %qT

en: gang reduction on an orphan loop
de: Bandenreduzierung in einer verwaisten Schleife

en: garbage at end of %<#pragma nomember_alignment%>
de: Ausschuss am Ende von %<#pragma nomember_alignment%>

en: gcc driver version %s %sexecuting gcc version %s
de: gcc-Treiberversion %s %s führt GCC-Version %s aus

en: gcc version %s %s
de: gcc-Version %s %s

en: generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>
de: Interner Fehler: generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>

en: generic thunk code fails for method %qD which uses %<...%>
de: allgemeiner Thunk-Code für Methode %qD mit %<...%> scheitert

en: getting core file size maximum limit: %m
de: Kern-Dateigrößenlimit kann nicht geholt werden: %m

en: gfc_array_dimen_size(): Bad EXPR_ARRAY expr
de: Interner Fehler: gfc_array_dimen_size(): Bad EXPR_ARRAY expr

en: gfc_array_dimen_size(): Bad dimension
de: Interner Fehler: gfc_array_dimen_size(): Bad dimension

en: gfc_array_size failed
de: Interner Fehler: gfc_array_size failed

en: gfc_check_dependency: expecting an EXPR_VARIABLE
de: Interner Fehler: gfc_check_dependency: expecting an EXPR_VARIABLE

en: gfc_find_array_ref(): No ref found
de: Interner Fehler: gfc_find_array_ref(): No ref found

en: gfc_ref_dimen_size(): Bad dimen_type
de: Interner Fehler: gfc_ref_dimen_size(): Bad dimen_type

en: gfortran does not support -E without -cpp
de: gfortran unterstützt nicht -E ohne -cpp

en: gfortran: Only one %<-J%> option allowed
de: gfortran: Nur eine Option %<-J%> erlaubt

en: gimple call has no target
de: Gimple-Aufruf hat kein Ziel

en: gimple call has two targets
de: Gimple-Aufruf hat zwei Ziele

en: gimplification failed
de: Gimplifikation gescheitert

en: global constructors not supported on this target
de: globale Konstruktoren werden für dieses Ziel nicht unterstützt

en: global destructors not supported on this target
de: globale Destruktoren werden für dieses Ziel nicht unterstützt

en: global module fragment contents must be from preprocessor inclusion
de: der Inhalt des %<global-module-fragment%> muss aus einer Präprozessor-Einbindung stammen

en: global qualification of class name is invalid
de: globale Qualifizierung von Klassenname ist ungültig

en: global register variable %qD used in nested function
de: globale Register-Variable %qD in verschachtelter Funktion verwendet

en: global register variable follows a function definition
de: globale Registervariable folgt einer Funktionsdefinition

en: global register variable has initial value
de: globale Registervariable hat Anfangswert

en: global/static variable assignment has been intercepted
de: Globale/statische Variablenzuweisung wurde abgefangen

en: got %d template parameters for %q#D
de: %d Template-Parameter für %q#D erhalten

en: got %d template parameters for %q#T
de: %d Template-Parameter für %q#T erhalten

en: goto destination is neither a label nor a pointer
de: Goto-Ziel ist weder eine Marke noch ein Zeiger

en: gp is constant (but save/restore gp on indirect calls).
de: Globaler Zeiger ist konstant (trotzdem bei indirekten Aufrufen sichern/wiederherstellen).

en: grave accent %<`%> in format
de: Gravis-Akzent %<`%> außerhalb von Anführungszeichen im Format

en: gsplit-dwarf is not supported on this platform
de: gsplit-dwarf wird auf dieser Plattform nicht unterstützt

en: had semantic errors when compiling
de: hatte semantische Fehler beim Kompilieren

en: hardware decimal floating-point instructions not available in ESA/390 mode
de: Dezimale Hardware-Gleitkommabefehle sind im ESA/390-Modus nicht verfügbar

en: hardware decimal floating-point instructions not available on %s
de: Dezimale Hardware-Gleitkommabefehle sind auf %s nicht verfügbar

en: hardware vector support not available on %s
de: Hardware-Vektorunterstützung ist auf %s nicht verfügbar

en: hardware vector support not available with %<-msoft-float%>
de: Hardware-Vektorunterstützung ist mit %<-msoft-float%> nicht verfügbar

en: has different parameters in another translation unit
de: hat unterschiedliche Parameter in einer anderen Übersetzungseinheit

en: has different return value in another translation unit
de: hat unterschiedlichen Rückgabetyp in einer anderen Übersetzungseinheit

en: has scoped destruction, cannot build closure
de: hat bereichsbasierte Zerstörung, daher kann kein Funktionsabschluss gebaut werden

en: head insn %d for block %d not found in the insn stream
de: Interner Fehler: head insn %d for block %d not found in the insn stream

en: header module expected, module %qs found
de: Headermodul erwartet, Modul %qs gefunden

en: here
de: hier

en: high bound %qE above array section size in %qs clause
de: obere Grenze %qE geht über Abschnittsgröße in %qs-Klausel hinaus

en: histogram value statement does not correspond to the statement it is associated with
de: Interner Compilerfehler: histogram value statement does not correspond to the statement it is associated with

en: iWMMXt and NEON are incompatible
de: iWMMXt und NEON sind unverträglich

en: iWMMXt unsupported under Thumb mode
de: iWMMXt wird im Thumb-Modus nicht unterstützt

en: ia64_print_operand: unknown code
de: ia64_print_operand: unbekannter Code

en: identifier %qE conflicts with C++ keyword
de: Bezeichner %qE steht mit C++-Schlüsselwort in Konflikt

en: identifier %qE is a keyword in C++11
de: Bezeichner %qE wird in C++11 zum Schlüsselwort

en: identifier %qE is a keyword in C++20
de: Bezeichner %qE wird in C++20 zum Schlüsselwort

en: identifier expected after %<@protocol%>
de: Bezeichner nach %<@protocol%> erwartet

en: if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier
de: wenn eine der %<if%>-Klauseln einen Modifizierer verwendet, müssen alle %<if%>-Klauseln Modifizierer verwenden

en: if avoiding the apostrophe is not feasible, enclose it in a pair of %qs and %qs directives instead
de: wenn das Apostroph sich nicht vermeiden lässt, schließen Sie es stattdessen in ein Direktivenpaar %qs und %qs ein

en: if this code is reached, the program will abort
de: Wenn dieser Code erreicht wird, wird das Programm abgebrochen

en: if this use is part of a public ABI, change it to instead use a constant variable you define
de: wenn diese Verwendung Teil eines öffentlichen ABI ist, ändern Sie sie so, dass stattdessen eine konstante Variable verwendet wird, die Sie definieren

en: if using %qs is not feasible, use %qs instead
de: wenn %qs nicht verwendbar ist, verwenden Sie stattdessen %qs

en: ignoring %<#pragma %s %s%>
de: %<#pragma %s %s%> wird ignoriert

en: ignoring %<#pragma align%> for explicitly aligned %q+D
de: %<#pragma align%> wird für explizit ausgerichtetes %q+D ignoriert

en: ignoring %<#pragma omp declare simd%> on function with %<_Atomic%> qualified non-%<uniform%> argument
de: %<#pragma omp declare simd%> an Funktion mit %<_Atomic%>-qualifiziertem nicht-%<uniform%>-Argument wird ignoriert

en: ignoring %<#pragma omp declare simd%> on function with %<_Atomic%> qualified return type
de: %<#pragma omp declare simd%> an Funktion mit %<_Atomic%>-qualifiziertem Rückgabetyp wird ignoriert

en: ignoring %<-fschedule-insns%> because of exception handling bug
de: %<-fschedule-insns%> wird wegen Ausnahmebehandlungsfehler ignoriert

en: ignoring %<asm%> specifier for non-static local variable %q+D
de: %<asm%>-Angabe für nicht-statische lokale Variable %q+D wird ignoriert

en: ignoring %qD attribute on anonymous namespace
de: Attribut %qD an unbenanntem Namensraum wird ignoriert

en: ignoring %qD attribute on non-inline namespace
de: Attribut %qD an nicht-»inline«-Namensraum wird ignoriert

en: ignoring %qE attribute applied to template instantiation %qT
de: %qE-Attribut wird für Templateinstanziierung %qT ignoriert

en: ignoring %qE attribute applied to template specialization %qT
de: %qE-Attribut wird für Templatespezialisierung %qT ignoriert

en: ignoring %qE attribute not set on a variable
de: Attribut %qE wird ignoriert, da es sich nicht auf eine Variable bezieht

en: ignoring %qE attribute set on const variable
de: Attribut %qE wird ignoriert, da es sich auf eine Variable bezieht

en: ignoring %qE attribute set on initialized variable
de: Attribut %qE wird ignoriert, da es sich auf eine initialisierte Variable bezieht

en: ignoring %qE attribute set on uninitialized variable
de: Attribut %qE wird ignoriert, da es sich auf eine uninitialisierte Variable bezieht

en: ignoring attribute %<%E (%u)%> because it conflicts with attribute %<%E (%u)%>
de: Attribut %<%E (%u)%> wird ignoriert, da es mit Attribut %<%E (%u)%> in Konflikt steht

en: ignoring attribute %qE after earlier %qE
de: Attribut %qE wird nach dem früheren %qE ignoriert

en: ignoring attribute %qE because it conflicts with attribute %<either%>
de: Attribut %qE steht mit dem Attribut %<either%> in Konflikt; wird ignoriert

en: ignoring attribute %qE because it conflicts with attribute %<lower%>
de: Attribut %qE steht mit dem Attribut %<lower%> in Konflikt; wird ignoriert

en: ignoring attribute %qE because it conflicts with attribute %<noinit%>
de: Attribut %qE steht mit Attribut %<noinit%> in Konflikt; wird ignoriert

en: ignoring attribute %qE because it conflicts with attribute %<persistent%>
de: Attribut %qE steht mit dem Attribut %<persistent%> in Konflikt; wird ignoriert

en: ignoring attribute %qE because it conflicts with attribute %<section%>
de: Attribut %qE steht mit Attribut %<section%> in Konflikt; wird ignoriert

en: ignoring attribute %qE because it conflicts with attribute %<upper%>
de: Attribut %qE steht mit dem Attribut %<upper%> in Konflikt; wird ignoriert

en: ignoring attribute %qE because it conflicts with attribute %qs
de: Attribut %qE steht mit Attribut %qs in Konflikt; wird ignoriert

en: ignoring attribute %qE in declaration of a built-in function %qD because it conflicts with attribute %qs
de: Attribut %qE wird in Deklaration der eingebauten Funktion %qD ignoriert, da es mit Attribut %qs in Konflikt steht

en: ignoring attribute %qs because it conflicts with previous %qs
de: Attribut %qs wird ignoriert, da es dem vorherigen %qs widerspricht

en: ignoring attributes applied to %qT after definition
de: auf %qT nach einer Definition angewandte Attribute werden ignoriert

en: ignoring attributes applied to class type %qT outside of definition
de: auf Klassentyp %qT angewandte Attribute außerhalb einer Definition werden ignoriert

en: ignoring attributes applied to dependent type %qT without an associated declaration
de: auf abhängigen Typ %qT angewandte Attribute ohne zugehörige Deklaration werden ignoriert

en: ignoring attributes in template argument %qE
de: Attribute an Templateargument %qE werden ignoriert

en: ignoring attributes on template argument %qT
de: Attribute an Templateargument %qT werden ignoriert

en: ignoring duplicate directory "%s"
de: doppeltes Verzeichnis »%s« wird ignoriert

en: ignoring large linear step
de: große lineare Schrittweite wird ignoriert

en: ignoring loop annotation
de: Schleifenannotation wird ignoriert

en: ignoring malformed %<#pragma longcall%>
de: falsch geformtes %<#pragma longcall%>; wird ignoriert

en: ignoring nonexistent directory "%s"
de: nicht vorhandenes Verzeichnis »%s« wird ignoriert

en: ignoring packed attribute because of unpacked non-POD field %q#D
de: »packed«-Attribut für ungepacktes nicht-POD-Feld %q#D wird ignoriert

en: ignoring possibly conflicting option %<-fopt-info-%s%>
de: möglicherweise in Konflikt stehende Option %<-fopt-info-%s%> wird ignoriert

en: ignoring return value of %qD declared with attribute %<warn_unused_result%>
de: Der Rückgabewert von %qD, der mit dem Attribut %<warn_unused_result%> deklariert wurde, wird ignoriert

en: ignoring return value of %qD, declared with attribute %<nodiscard%>
de: der Rückgabewert von %qD (mit %<nodiscard%>-Attribut deklariert) wird ignoriert

en: ignoring return value of %qD, declared with attribute %<nodiscard%>%s
de: der Rückgabewert von %qD (mit %<nodiscard%>-Attribut markiert) wird ignoriert%s

en: ignoring return value of %qD, declared with attribute %<nodiscard%>: %<%s%>
de: der Rückgabewert von %qD (mit %<nodiscard%>-Attribut markiert) wird ignoriert: %<%s%>

en: ignoring return value of %qD, declared with attribute %<nodiscard%>: %E
de: der Rückgabewert von %qD (mit %<nodiscard%>-Attribut deklariert) wird ignoriert: %E

en: ignoring return value of %qD, declared with attribute %<warn_unused_result%>
de: %qD hat das Attribut %<warn_unused_result%>, daher sollte der Rückgabewert nicht ignoriert werden

en: ignoring return value of function declared with attribute %<warn_unused_result%>
de: Rückgabewert der mit dem Attribut %<warn_unused_result%> definierten Funktion wird ignoriert

en: ignoring return value of type %qT, declared with attribute %<nodiscard%>
de: der Rückgabewert vom Typ %qT (mit %<nodiscard%>-Attribut deklariert) wird ignoriert

en: ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E
de: der Rückgabewert vom Typ %qT (mit %<nodiscard%>-Attribut deklariert) wird ignoriert: %E

en: ignoring returned value of type %qT, declared with attribute %<nodiscard%>%s
de: der Rückgabewert von Typ %qT (mit %<nodiscard%>-Attribut markiert) wird ignoriert%s

en: ignoring returned value of type %qT, declared with attribute %<nodiscard%>: %<%s%>
de: der Rückgabewert von Typ %qT (mit %<nodiscard%>-Attribut markiert) wird ignoriert: %<%s%>

en: ignoring sink clause with offset that is not a multiple of the loop step
de: »sink«-Klausel wird ignoriert, da der Offset kein Vielfaches der Schrittweite ist

en: ignoring the %q#D declaration
de: Deklaration %q#D wird ignoriert

en: ignoring unknown option %q.*s
de: unbekannte Option %q.*s wird ignoriert

en: ignoring unrecognized switch %<-mcustom-fpu-cfg%> value %<%s%>
de: unbekannter Wert %<%s%> für Schalter %<-mcustom-fpu-cfg%> wird ignoriert

en: ignoring zero linear step
de: Schrittweite 0 wird ignoriert

en: illegal aggregate type %qE specified for instance variable %qs
de: unzulässiger Aggregattyp %qE für Instanzvariable %qs angegeben

en: illegal argument 0 to %qs
de: ungültiges Argument 0 für %qs

en: illegal operand
de: ungültiger Operand

en: illegal operand address (1)
de: ungültige Operandenadresse (1)

en: illegal operand address (2)
de: ungültige Operandenadresse (2)

en: illegal operand address (3)
de: ungültige Operandenadresse (3)

en: illegal operand address (4)
de: ungültige Operandenadresse (4)

en: illegal operand detected
de: ungültiger Operand wurde gefunden

en: illegal reference type specified for instance variable %qs
de: unzulässiger Referenztyp für Instanzvariable %qs angegeben

en: immediate evaluation returns address of immediate function %qD
de: unmittelbare Auswertung liefert die Adresse der unmittelbaren Funktion %qD

en: immediate value must fit into a %d-bit integer for %s
de: Der Direktwert für »%2$s« muss in eine %1$d-Bit-Ganzzahl passen

en: implicit capture of %qE via %<[=]%> is deprecated in C++20
de: implizites Einfangen von %qE via %<[=]%> ist in C++20 veraltet

en: implicit conversion from %qH to %qI to match other operand of binary expression
de: implizite Umwandlung von %qH in %qI zur Anpassung an anderen Operanden des Binärausdrucks

en: implicit conversion from %qH to %qI to match other result of conditional
de: implizite Umwandlung von %qH in %qI, um an das Ergebnis im anderen Zweig der Bedingung anzugleichen

en: implicit conversion from %qH to %qI when passing argument to function
de: implizite Umwandlung von %qH in %qI bei Übergabe von Argument an Funktion

en: implicit conversion from %qT to %qT
de: implizite Umwandlung von %qT nach %qT

en: implicit conversion from %qT to %qT to match other operand of binary expression
de: implizite Umwandlung von %qT in %qT zur Anpassung an anderen Operanden des Binärausdrucks

en: implicit conversion from %qT to %qT to match other result of conditional
de: implizite Umwandlung von %qT in %qT um an anderes Ergebnis von Bedingung anzupassen

en: implicit conversion from %qT to %qT when passing argument to function
de: implizite Umwandlung von %qT in %qT bei Übergabe von Argument an Funktion

en: implicit declaration of function %qE
de: Implizite Deklaration der Funktion %qE

en: implicit declaration of function %qE; did you mean %qs?
de: Implizite Deklaration der Funktion %qE; meinten Sie %qs?

en: implicit dereference will not access object of type %qT in for increment expression
de: implizite Dereferenzierung greift nicht auf Objekt des Typs %qT in Erhöhungsausdruck zu

en: implicit dereference will not access object of type %qT in left operand of comma operator
de: implizite Dereferenzierung greift nicht auf Objekt des Typs %qT in linkem Operanden des Kommaoperators zu

en: implicit dereference will not access object of type %qT in right operand of comma operator
de: implizite Dereferenzierung greift nicht auf Objekt des Typs %qT in rechtem Operanden des Kommaoperators zu

en: implicit dereference will not access object of type %qT in second operand of conditional expression
de: implizite Dereferenzierung greift nicht auf Objekt des Typs %qT in zweitem Operanden des bedingten Ausdrucks zu

en: implicit dereference will not access object of type %qT in statement
de: implizite Dereferenzierung greift nicht auf Objekt des Typs %qT in Anweisung zu

en: implicit dereference will not access object of type %qT in third operand of conditional expression
de: implizite Dereferenzierung greift nicht auf Objekt des Typs %qT in drittem Operanden des bedingten Ausdrucks zu

en: implicit mapping of assumed size array %qD
de: Implizite Zuordnung von Feld %qD mit angenommener Größe

en: implicit templates may not be %<virtual%>
de: Implizite Templates dürfen nicht %<virtual%> sein

en: implicit this pointer type mismatch
de: Fehlzuordnung in implizitem this-Zeiger

en: implicit_section flag is set but section isn%'t
de: Interner Fehler: implicit_section flag is set but section isn%'t

en: implicitly popped registers must be grouped at top of stack
de: implizit geholte (»pop«) Register müssen oben auf dem Stapel gruppiert werden

en: implicitly-declared %qD is deprecated
de: implizit deklariertes %qD ist veraltet

en: implied END DO
de: impliziertes END DO

en: import %qs has CRC mismatch
de: der Import %qs hat eine falsche CRC-Prüfsumme

en: import cannot appear directly in a linkage-specification
de: %<import%> kann nicht direkt in einer Bindungs-Angabe vorkommen

en: import declared %q#D here
de: der Import hat %q#D hier deklariert

en: import of named module %qs inside language-linkage block
de: Import eines benannten Moduls %qs innerhalb eines Sprachverlinkungsblocks

en: import-declaration must be at global scope
de: Import-Deklaration muss im globalen Gültigkeitsbereich sein

en: imported at
de: importiert bei

en: imports must be built before being imported
de: Importe müssen gebaut werden, bevor sie importiert werden können

en: impossible constraint in %<asm%>
de: unmögliche Bedingung in %<asm%>

en: impossible register constraint in %<asm%>
de: unmögliche Registerbedingung in %<asm%>

en: impossible type assertion: type does not implement interface
de: unmögliche Typenbehauptung: Typ implementiert nicht Schnittstelle

en: in %s, at %s:%d
de: in %s, bei %s:%d

en: in C++03 a class-key must be used when declaring a friend
de: in C++03 muss bei Deklaration eines »friend« ein Klassenschlüssel verwendet werden

en: in C++11 and above a default constructor can be explicit
de: in C++11 und neuer kann ein Defaultkonstruktor explizit sein

en: in C++11 destructors default to %<noexcept%>
de: in C++11 sind Destruktoren standardmäßig %<noexcept%>

en: in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>
de: in C++11 ruft dieses %<throw%> %<terminate%> auf, da Destruktoren standardmäßig %<noexcept%> sind

en: in C++20 this comparison calls the current function recursively with reversed arguments
de: in C++20 ruft dieser Vergleich die aktuelle Funktion rekursiv mit vertauschten Argumenten auf

en: in C++98 %<template%> (as a disambiguator) is only allowed within templates
de: in C++98 ist %<template%> (zum eindeutig machen) nur innerhalb von Templates erlaubt

en: in C++98 %q+D may not be static because it is a member of a union
de: %q+D kann in C++98 nicht static sein, da es ein Union-Element ist

en: in C++98 %qD must be initialized by constructor, not by %<{...}%>
de: in C++98 muss %qD mit Konstruktor initialisiert werden, nicht mit %<{...}%>

en: in a call to %qD declared with attribute %<%s%> here
de: in einem Aufruf von %qD, die mit Attribut %qs hier deklariert wurde

en: in a call to %qT declared with attribute %<%s%>
de: in einem Aufruf von %qT, die mit Attribut %qs deklariert wurde

en: in a call to allocation function %qD declared here
de: in einem Aufruf der hier deklarierten Allokationsfunktion %qD

en: in a call to built-in allocation function %qD
de: in einem Aufruf der eingebauten Allokationsfunktion %qD

en: in a call to built-in function %qD
de: in einem Aufruf der eingebauten Funktion %qD

en: in a call to function %qD
de: in einem Aufruf der Funktion %qD

en: in a call to function %qD declared %qs
de: in einem Aufruf der Funktion %qD, die als %qs deklariert ist

en: in a call to function %qD declared with attribute %qs
de: in einem Aufruf der Funktion %qD, die mit Attribut %qs deklariert wurde

en: in a call to non-static member function %qD
de: in einem Aufruf der nicht-statischen Elementfunktion %qD

en: in a call with type %qT
de: in einem Aufruf mit Typ %qT

en: in a call with type %qT and attribute %qs
de: in einem Aufruf mit Typ %qT und Attribut %qs

en: in argument to unary !
de: in Argument für unäres !

en: in basic block %d:
de: Interner Fehler: in basic block %d:

en: in call to %qD, declared here
de: im Aufruf von %qD, hier deklariert

en: in declaration %q+D
de: in Deklaration %q+D

en: in definition of macro %qs
de: in Definition des Makros %qs

en: in expansion of macro %qs
de: bei Substitution des Makros %qs

en: in initialization of structured binding variable %qD
de: in Initialisierung der Variable %qD für strukturierte Bindung

en: in passing argument %P of %qD
de: bei Übergabe des Arguments %P von %qD

en: in template argument for type %qT
de: in Templateargument für Typ %qT

en: in the definition of %q#T
de: in der Definition von %q#T

en: in this expression
de: in diesem Ausdruck

en: in-class initialization of static data member %q#D of incomplete type
de: Initialisierung innerhalb der Klasse des statischen Datenelements %q#D mit unvollständigem Typ

en: in-class initialization of static data member %q#D of non-literal type
de: Initialisierung innerhalb der Klasse des statischen Datenelements %q#D mit nicht eingebautem Typ

en: inaccessible plugin file %s expanded from short plugin name %s: %m
de: Zugriff auf nicht zugreifbare Plugin-Datei %s (aus kurzem Plugin-Namen %s erzeugt) nicht möglich: %m

en: inappropriate accumulator for %qs
de: unpassender Akkumulator für %qs

en: include %qs or provide a declaration of %qD
de: binden Sie %qs ein oder stellen Sie eine Deklaration von %qD bereit

en: include %qs or provide a declaration of %qE
de: binden Sie %qs ein oder stellen Sie eine Deklaration von %qE bereit

en: include %qs processed textually
de: %<include %s%> wurde textuell verarbeitet

en: include %qs translated to import
de: %<include %s%> wurde übersetzt zu »import«

en: incoming edge count does not match number of PHI arguments
de: Eingehende Kantenzahl passt nicht zur Anzahl der PHI-Argumente

en: incompatible %qs clause when applying %<%s%> to %qD, which has already been marked with an OpenACC 'routine' directive
de: inkompatible %qs-Klausel bei Anwendung von %<%s%> auf %qD, die bereits mit einer OpenACC-»routine«-Direktive gekennzeichnet wurde

en: incompatible address space qualifiers %qs and %qs
de: Inkompatible Adressraumkennzeichen %qs und %qs

en: incompatible data clause with reduction on %qE; promoting to %<present_or_copy%>
de: inkompatible Datenklausel mit Reduktion an %qE; wird zu %<present_or_copy%> befördert

en: incompatible floating point / vector register operand for '%%%c'
de: unverträglicher Gleitkomma- / Vektorregisteroperand für »%%%c«

en: incompatible implicit declaration of built-in function %qD
de: Unverträgliche implizite Deklaration der eingebauten Funktion %qD

en: incompatible implicit declaration of function %qD
de: Unverträgliche implizite Deklaration der Funktion %qD

en: incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>
de: die Optionen %<-mstack-protector-guard=global%> und %<-mstack-protector-guard-offset=%s%> sind unverträglich

en: incompatible register operand for '%%%c'
de: unverträglicher Registeroperand für »%%%c«

en: incompatible type for argument %d of %qE
de: Inkompatibler Typ für Argument %d von %qE

en: incompatible type for map index
de: inkompatible Typen für Abbildungsindex

en: incompatible type for method %s%s%s
de: Inkompatibler Typ für Methode %s%s%s

en: incompatible type for method %s%s%s (%s)
de: Inkompatibler Typ für Methode %s%s%s (%s)

en: incompatible type for receiver
de: inkompatible Typen für Empfänger

en: incompatible types in %<PHI%> argument %u
de: inkompatible Typen in %<PHI%>-Argument %u

en: incompatible types in assignment of %qT to %qT
de: unverträgliche Typen in Zuweisung von %qT an %qT

en: incompatible types in binary expression
de: inkompatible Typen in binärem Ausdruck

en: incompatible types in send
de: inkompatible Typen in »send«

en: incompatible types when assigning to type %qT from type %qT
de: unverträgliche Typen bei Zuweisung an Typ %qT von Typ %qT

en: incompatible types when initializing type %qT using type %qT
de: inkompatible Typen bei Initialisierung von Typ %qT mit Typ %qT

en: incompatible types when returning type %qT but %qT was expected
de: unverträgliche Typen bei Rückgabe von Typ %qT, aber %qT wurde erwartet

en: incompatible vector types in conditional expression: %qT, %qT and %qT
de: unverträgliche Vektortypen in bedingtem Ausdruck: %qT, %qT und %qT

en: incomplete implementation of category %qE
de: unvollständige Implementierung der Kategorie %qE

en: incomplete implementation of class %qE
de: unvollständige Implementierung der Klasse %qE

en: incomplete type %qT does not have member %qD
de: unvollständiger Typ %qT hat kein Element %qD

en: incomplete type %qT is not mappable
de: unvollständiger Typ %qT ist nicht zuordenbar

en: incomplete type %qT used in nested name specifier
de: unvollständiger Typ %qT in geschachtelter Namensangabe verwendet

en: inconsistent %<ifunc%> attribute
de: inkonsistentes %<ifunc%>-Attribut

en: inconsistent begin/end types in range-based %<for%> statement: %qT and %qT
de: unvereinbare Anfang-/Ende-Typen in bereichsbasierter %<for%>-Anweisung: %qT und %qT

en: inconsistent capitalization in format
de: inkonsistente Großschreibung im Format

en: inconsistent deduction for %qT: %qT and then %qT
de: widersprüchliche Herleitung für %qT: %qT und dann %qT

en: inconsistent deduction for auto return type: %qT and then %qT
de: widersprüchliche Herleitung für automatischen Rückgabetyp: %qT und dann %qT

en: inconsistent imported macro definition %qE
de: inkonsistente importierte Makrodefinition %qE

en: inconsistent instance variable specification
de: widersprüchliche Spezifikation von Instanzvariable

en: inconsistent operand constraints in an %<asm%>
de: inkonsistente Operandenbedingungen in einem %<asm%>

en: inconsistent types %qT and %qT deduced for lambda return type
de: widersprüchliche Typen %qT und %qT für Lambda-Rückgabetypen hergeleitet

en: inconsistent user-defined literal suffixes %qD and %qD in string literal
de: widersprüchliche benutzerdefinierte literale Suffixe %qD und %qD in Zeichenkettenliteral

en: incorrect comparison mode
de: Falscher Vergleichsmodus

en: incorrect entry in %<label_to_block_map%>
de: falscher Eintrag in %<label_to_block_map%>

en: incorrect format in scaling, using 1/1
de: Falsches Format der Skalierung; 1/1 wird verwendet

en: incorrect hint operand
de: Falscher Hinweis-Operand

en: incorrect insn:
de: Falscher Befehl:

en: incorrect number of arguments to function %qE
de: Falsche Anzahl der Argumente für Funktion %qE

en: incorrect number of vector %qs elements
de: falsche Anzahl der Vektor-%qs-Elemente

en: incorrect property %qs of %qs selector
de: falsche Eigenschaft %qs des %qs-Selektors

en: incorrect rounding operand
de: Falscher Rundungsoperand

en: incorrect type of vector %qs elements
de: ungültiger Typ der Vektor-%qs-Elemente

en: incorrect type of vector CONSTRUCTOR elements
de: falscher Typ der Elemente eines Vektorkonstruktors

en: incorrectly nested OpenACC loop parallelism
de: falsch geschachtelter OpenACC-Schleifenparallelismus

en: increment expression refers to iteration variable %qD
de: Inkrementausdruck verweist auf Schleifenvariable %qD

en: increment is not constant 1 or -1 for %<!=%> condition
de: Erhöhung ist weder konstant 1 noch konstant -1 für die %<!=%>-Bedingung

en: increment of a boolean expression
de: Inkrementieren eines booleschen Ausdrucks

en: increment of constant field %qD
de: Erhöhung des konstanten Feldes %qD

en: increment of enumeration value is invalid in C++
de: Schrittweite von Aufzählungswerten (enum) ist in C++ ungültig

en: increment of function %qD
de: Erhöhung der Funktion %qD

en: increment of member %qD in read-only object
de: Erhöhung des Elements %qD in schreibgeschütztem Objekt

en: increment of pointer to an incomplete type %qT
de: Inkrementieren eines Zeigers auf unvollständigen Typ %qT

en: increment of read-only location %qE
de: Erhöhung der schreibgeschützten Speicherstelle %qE

en: increment of read-only member %qD
de: Erhöhung des schreibgeschützten Elementes %qD

en: increment of read-only named return value %qD
de: Erhöhung des schreibgeschützten benannten Rückgabewertes %qD

en: increment of read-only parameter %qD
de: Erhöhung des schreibgeschützten Parameters %qD

en: increment of read-only reference %qD
de: Erhöhung der schreibgeschützten Referenz %qD

en: increment of read-only variable %qD
de: Erhöhung der schreibgeschützten Variable %qD

en: incremented enumerator value is too large for %<long%>
de: erhöhter Aufzählungswert ist zu groß für %<long%>

en: incremented enumerator value is too large for %<unsigned long%>
de: erhöhter Aufzählungswert ist zu groß für %<unsigned long%>

en: index %E denotes an offset greater than size of %qT
de: Index %E markiert einen Offset größer als die Größe von %qT

en: index in dimension %d is out of bounds at %L
de: Index in Dimension %d ist außerhalb der Grenzen bei %L

en: index must be integer
de: Index muss eine Ganzzahl sein

en: index value instead of field name in union initializer
de: Indexwert statt Feldname in Union-Initialisierung

en: index value is out of bound
de: Indexwert ist außerhalb der Grenzen

en: indirect call count does not match BB count
de: Interner Fehler: indirect call count does not match BB count

en: indirect call in function, which are not supported by eBPF
de: indirekter Aufruf in Funktion, das wird von eBPF nicht unterstützt

en: indirect call in speculative call sequence has no speculative flag
de: indirekter Aufruf in der Folge der spekulativen Aufrufe hat kein Spekulationsflag

en: indirect function %q+D cannot be declared %qE
de: indirekte Funktion %q+D kann nicht als %qE deklariert werden

en: indirect function %q+D cannot be declared weak
de: indirekte Funktion %q+D kann nicht als »schwach« deklariert werden

en: indirect function call with a yet undetermined callee
de: Indirekter Funktionsaufruf mit noch unbekanntem Aufrufer

en: indirect import %qs is not already loaded
de: der indirekte Import %qs ist noch nicht geladen

en: indirect jumps are not available on this target
de: indirekte Sprünge sind auf dieser Zielmaschine nicht verfügbar

en: indirection will not access object of incomplete type %qT in for increment expression
de: Indirektion greift nicht auf Objekt unvollständigen Typs %qT in Erhöhungsausdruck zu

en: indirection will not access object of incomplete type %qT in left operand of comma operator
de: Indirektion greift nicht auf Objekt unvollständigen Typs %qT in linkem Operanden des Kommaoperators zu

en: indirection will not access object of incomplete type %qT in right operand of comma operator
de: Indirektion greift nicht auf Objekt unvollständigen Typs %qT in rechtem Operanden des Kommaoperators zu

en: indirection will not access object of incomplete type %qT in second operand of conditional expression
de: Indirektion greift nicht auf Objekt unvollständigen Typs %qT in zweitem Operanden des bedingten Ausdrucks zu

en: indirection will not access object of incomplete type %qT in statement
de: Indirektion greift nicht auf Objekt unvollständigen Typs %qT in Anweisung zu

en: indirection will not access object of incomplete type %qT in third operand of conditional expression
de: Indirektion greift nicht auf Objekt unvollständigen Typs %qT in drittem Operanden des bedingten Ausdrucks zu

en: indirection will not access object of non-trivially-copyable type %qT in for increment expression
de: Indirektion greift nicht auf Objekt des nicht trivial kopierbaren Typs %qT in Erhöhungsausdruck zu

en: indirection will not access object of non-trivially-copyable type %qT in left operand of comma operator
de: Indirektion greift nicht auf Objekt des nicht trivial kopierbaren Typs %qT im linken Operanden des Kommaoperators zu

en: indirection will not access object of non-trivially-copyable type %qT in right operand of comma operator
de: Indirektion greift nicht auf Objekt des nicht trivial kopierbaren Typs %qT im rechten Operanden des Kommaoperators zu

en: indirection will not access object of non-trivially-copyable type %qT in second operand of conditional expression
de: Indirektion greift nicht auf Objekt des nicht trivial kopierbaren Typs %qT im zweiten Operanden des bedingten Ausdrucks zu

en: indirection will not access object of non-trivially-copyable type %qT in statement
de: Indirektion greift nicht auf Objekt des nicht trivial kopierbaren Typs %qT in Anweisung zu

en: indirection will not access object of non-trivially-copyable type %qT in third operand of conditional expression
de: Indirektion greift nicht auf Objekt des nicht trivial kopierbaren Typs %qT im dritten Operanden des bedingten Ausdrucks zu

en: inferred scalar type %qT is not an integer or floating-point type of the same size as %qT
de: erschlossener skalarer Typ %qT muss ein Ganzzahl- oder Gleitkommatyp derselben Größe wie %qT sein

en: infinite recursion detected
de: unendliche Rekursion erkannt

en: inherited constructor %qD is not %<constexpr%>
de: geerbter Konstruktor %qD ist nicht %<constexpr%>

en: inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>
de: erbende Konstruktoren nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: init function found in object %s
de: init-Funktion im Objekt %s gefunden

en: init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>
de: »init-statement in Auswahlanweisungen« ist nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar

en: initialization discards %qv qualifier from pointer target type
de: Initialisierung streicht Qualifizierer %qv von Zeiger-Zieltyp

en: initialization from distinct Objective-C type
de: Initialisierung von anderem Objective-C-Typ

en: initialization from pointer to non-enclosed address space
de: Initialisierung von Zeiger auf nicht enthaltenen Adressraum

en: initialization left-hand side might be a candidate for a format attribute
de: Linke-Initialisierung könnte Kandidat für Formatattribut sein

en: initialization makes %q#v qualified function pointer from unqualified
de: Initialisierung erzeugt aus unqualifiziertem einen qualifizierten Funktionszeiger %q#v

en: initialization of %qT from %qT makes integer from pointer without a cast
de: Initialisierung eines %qT aus %qT wandelt einen Zeiger in eine Zahl um, ohne explizite Typkonvertierung

en: initialization of %qT from %qT makes pointer from integer without a cast
de: Initialisierung von %qT von %qT wandelt eine Zahl in einen Zeiger um, ohne explizite Typkonvertierung

en: initialization of %qT from incompatible pointer type %qT
de: Initialisierung von %qT von inkompatiblem Zeigertyp %qT

en: initialization of %qT from pointer to %qD with incompatible type %qT
de: Initialisierung von %qT von Zeiger auf %qD mit inkompatiblem Typ %qT

en: initialization of %qT from pointer type %qT with incompatible scalar storage order
de: Initialisierung von %qT von Zeigertyp %qT mit inkompatibler Speicherreihenfolge für Skalare

en: initialization of a flexible array member
de: Initialisierung eines flexiblen Array-Elements

en: initialization of common block variable %qs in DATA statement at %C
de: Initialisierung der allgemeinen Blockvariable %qs in DATA-Anweisung bei %C

en: initialization of flexible array member in a nested context
de: Initialisierung eines flexiblen Array-Elements in geschachteltem Kontext

en: initialization of new-expression for type %<auto%> requires exactly one element
de: Initialisierung des new-Ausdrucks für Typ %<auto%> erfordert genau ein Element

en: initialization of non-const reference type %q#T from rvalue of type %qT
de: Initialisierung eines nicht-konstanten Referenztyps %q#T von R-Wert des Typs %qT

en: initialization of volatile reference type %q#T from rvalue of type %qT
de: Initialisierung des %<volatile%>-Referenztyps %q#T von R-Wert des Typs %qT

en: initializations for multiple members of %qT
de: Initialisierungen für mehrere Elemente von %qT

en: initialized field overwritten
de: initialisiertes Feld überschrieben

en: initialized field with side-effects overwritten
de: initialisiertes Feld mit Seiteneffekten überschrieben

en: initialized member %q+D declared here
de: das initialisierte Element %q+D wurde hier deklariert

en: initialized variable %q+D is marked dllimport
de: initialisierte Variable %q+D ist als »dllimport« markiert

en: initializer element is not a constant expression
de: Initialisierungselement ist kein konstanter Ausdruck

en: initializer element is not computable at load time
de: Initialisierungs-Element ist zur Lade-Zeit nicht berechenbar

en: initializer element is not constant
de: Initialisierungselement ist nicht konstant

en: initializer ends prematurely
de: Initialisierung endet vorzeitig

en: initializer expression refers to iteration variable %qD
de: Initialisierungsausdruck verweist auf Iterationsvariable %qD

en: initializer fails to determine size of %q+D
de: Initialisierung gibt nicht die Größe von %q+D an

en: initializer fails to determine size of %qD
de: Initialisierung gibt nicht die Größe von %qD an

en: initializer fails to determine size of %qT
de: Initialisierung gibt nicht die Größe von %qT an

en: initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?
de: Initialisierung für %<decltype(auto) %D%> hat Funktionstyp; %<()%> vergessen?

en: initializer for %q#D expands to an empty list of expressions
de: Initialisierer für %q#D expandiert zu einer leeren Ausdrucksliste

en: initializer for %q#D is invalid
de: Initialisierung für %q#D ist ungültig

en: initializer for %qT must be brace-enclosed
de: Initialisierung für %qT muss geklammert sein

en: initializer for flexible array member %q#D
de: Initialisierung eines flexiblen Arrayelements %q#D

en: initializer for floating value is not a floating constant
de: Initialisierung für Gleitkommawert ist keine Gleitkommakonstante

en: initializer for integer/fixed-point value is too complicated
de: Initialisierung für Ganzzahl-/Gleitkommazahlwert ist zu kompliziert

en: initializer in range-based %<for%> loop
de: Initialisierung in bereichsbasierter %<for%>-Schleife

en: initializer invalid for static member with constructor
de: Initialisierung ungültig für statisches Element mit Konstruktor

en: initializer provided for function
de: Initialisierung für Funktion bereitgestellt

en: initializer specified for friend function %qD
de: Initialisierung für »friend«-Funktion %qD angegeben

en: initializer specified for non-virtual method %q+D
de: Initialisierung für nicht-virtuelle Methode %q+D angegeben

en: initializer specified for static member function %qD
de: Initialisierung für statische Element-Funktion %qD angegeben

en: initializer-string for %qT is too long
de: Initialisierungs-Zeichenkette für %qT ist zu lang

en: initializing %qD from %qE does not extend the lifetime of the underlying array
de: dadurch, dass %qD mittels %qE initialisiert wird, verlängert sich die Lebenszeit des zugrundeliegenden Arrays nicht

en: initializing %qH with %qI in converted constant expression does not bind directly
de: das Initialisieren von %qH mit %qI in einem umgewandelten konstanten Ausdruck bindet nicht direkt

en: initializing a base class of type %qT results in object slicing
de: das Initialisieren einer Basisklasse vom Typ %qT führt zu Objektslicing

en: injected-class-name %qD used as template template argument
de: eingegebener Klassenname %qD als Template-Templateargument verwendet

en: inline assembly is not a constant expression
de: Inline-Assembler ist kein konstanter Ausdruck

en: inline clone in same comdat group list
de: Interner Fehler: inline clone in same comdat group list

en: inline clone is forced to output
de: Interner Fehler: inline clone is forced to output

en: inline clone with address taken
de: Interner Fehler: inline clone with address taken

en: inline declaration of %qD follows declaration with attribute %<noinline%>
de: inline-Deklaration von %qD folgt Deklaration mit Attribut %<noinline%>

en: inline function %q+D declared as dllimport: attribute ignored
de: »inline«-Funktion %q+D ist als »dllimport« deklariert: Attribut wird ignoriert

en: inline function %q+D declared but never defined
de: Inline-Funktion %q+D deklariert, aber nirgendwo definiert

en: inline function %q+D declared weak
de: »inline«-Funktion %q+D als »schwach« deklariert

en: inline function %q+D given attribute %qs
de: der inline-Funktion %q+D wurde das Attribut %qs gegeben

en: inline function %qD given attribute %qs
de: der inline-Funktion %qD wurde das Attribut %qs gegeben

en: inline function %qD used but never defined
de: inline-Funktion %qD verwendet, aber nirgendwo definiert

en: inline namespace must be specified at initial definition
de: ein %<inline%>-Namensraum muss bei der ersten Definition angegeben werden

en: inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>
de: »inline«-Namensräume nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>
de: »inline«-Variablen sind nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar

en: inlined_to pointer is set but no predecessors found
de: Interner Fehler: inlined_to pointer is set but no predecessors found

en: inlined_to pointer is wrong
de: Interner Fehler: inlined_to pointer is wrong

en: inlined_to pointer refers to itself
de: Interner Fehler: inlined_to pointer refers to itself

en: inlined_to pointer set for noninline callers
de: Interner Fehler: inlined_to pointer set for noninline callers

en: inlining failed in call to %<always_inline%> %q+F: %s
de: Inlining beim Aufruf von %q+F mit %<always_inline%> fehlgeschlagen: %s

en: inlining failed in call to %q+F: %s
de: »inline« beim Aufruf von %q+F gescheitert: %s

en: inner loop uses same OpenACC parallelism as containing loop
de: innere Schleife verwendet denselben OpenACC-Parallelismus wie enthaltende Schleife

en: input file %qs is the same as output file
de: Eingabedatei %qs ist dieselbe wie die Ausgabedatei

en: input operand constraint contains %qc
de: Bedingung für Eingabeoperanden enthält %qc

en: insert_bbt(): Duplicate key found
de: Interner Fehler: insert_bbt(): Duplicate key found

en: insertion out of range in %qs
de: Einschub außerhalb des gültigen Bereichs in %qs

en: insn %d basic block pointer is %d, should be %d
de: Interner Fehler: insn %d basic block pointer is %d, should be %d

en: insn %d in footer of bb %d has non-NULL basic block
de: Interner Fehler: insn %d in footer of bb %d has non-NULL basic block

en: insn %d in header of bb %d has non-NULL basic block
de: Interner Fehler: insn %d in header of bb %d has non-NULL basic block

en: insn %d is in multiple basic blocks (%d and %d)
de: Interner Fehler: insn %d is in multiple basic blocks (%d and %d)

en: insn %d outside of basic blocks has non-NULL bb field
de: Interner Fehler: insn %d outside of basic blocks has non-NULL bb field

en: insn addresses not freed
de: Befehlsadressen nicht freigegeben

en: insn addresses not set after shorten branches
de: Interner Fehler: insn addresses not set after shorten branches

en: insn contains an invalid address !
de: Befehl enthält eine ungültige Adresse!

en: insn does not satisfy its constraints:
de: Befehl erfüllt nicht seine Bedingungen:

en: insn outside basic block
de: Befehl außerhalb eines Basis-Blockes

en: insn with UID %i not found for operand %i (`%s') of insn %i
de: Befehl mit UID %i nicht gefunden für Operand %i (»%s«) von Befehl %i

en: insn with UID %i not found for operand %i of insn %i
de: Befehl mit UID %i nicht gefunden für Operand %i von Befehl %i

en: install: %s%s
de: installiere: %s%s

en: installation error, cannot find %<crtoffloadtable.o%>
de: Installationsfehler, %<crtoffloadtable.o%> kann nicht gefunden werden

en: instance variable %qE accessed in class method
de: in Klassenmethode wird auf Instanzvariable %qE zugegriffen

en: instance variable %qE is %s; this will be a hard error in the future
de: Instanzvariable %qE ist »%s«; dies wird zukünftig ein schwerer Fehler sein

en: instance variable %qE is declared %s
de: Instanzvariable %qE ist als »%s« deklariert

en: instance variable %qE is declared private
de: Instanzvariable %qE ist als »private« deklariert

en: instance variable %qs has unknown size
de: Instanzvariable %qs hat unbekannte Größe

en: instance variable %qs is declared private
de: Instanzvariable %qs ist als »private« deklariert

en: instance variable %qs uses flexible array member
de: Instanzvariable %qs verwendet flexibles Arrayelement

en: instance variable assignment has been intercepted
de: Zuweisung der Instanzvariable wurde abgefangen

en: instruction never executed
de: Befehl wird niemals ausgeführt

en: instruction scheduling not supported on this target machine
de: Befehlsplanung wird von dieser Zielmaschine nicht unterstützt

en: instruction set %qs cannot implement default ABI %qs, falling back to %qs
de: Befehlssatz %qs kann Standard-ABI %qs nicht implementieren, stattdessen wird %qs verwendet

en: insufficient contextual information to determine type
de: unzureichende Informationen für Typbestimmung aus Kontext

en: insufficient partitioning available to parallelize element loop
de: unzureichende Partitionierung verfügbar, um die Elementschleife zu parallelisieren

en: insufficient partitioning available to parallelize loop
de: unzureichende Partitionierung verfügbar, um Schleife zu parallelisieren

en: insufficient partitioning available to parallelize tile loop
de: unzureichende Partitionierung verfügbar, um die Kachelschleife zu parallelisieren

en: integer constant is too large for %<unsigned long%> type
de: Ganzzahlkonstante ist zu groß für %<unsigned long%>-Typ

en: integer division by zero
de: Ganzzahldivision durch Null

en: integer literal exceeds range of %qT type
de: Ganzzahlliteral überschreitet Wertebereich des Typs %qT

en: integer overflow in array size
de: Ganzzahlüberlauf in Arraygröße

en: integer overflow in expression %qE of type %qT results in %qE
de: Ganzzahlüberlauf in Ausdruck %qE des Typs %qT ergibt %qE

en: integer overflow in expression of type %qT results in %qE
de: Ganzzahlüberlauf in Ausdruck des Typs %qT ergibt %qE

en: integer suffix %qs shadowed by implementation
de: Ganzzahl-Suffix %qs durch Implementierung überdeckt

en: integral expression %qE is not constant
de: Ganzzahlausdruck %qE ist nicht konstant

en: integral result type precision does not match field size of %qs
de: Genauigkeit des ganzzahligen Ergebnistypen passt nicht zur Feldgröße von %qs

en: interface %qE does not have valid constant string layout
de: die Schnittstelle %qE hat keine gültige Form einer konstanten Zeichenkette

en: interface partition is not exported
de: Schnittstellenpartition wird nicht exportiert

en: intermediate array offset %wi is outside array bounds of %qT
de: Offset %wi des zwischenzeitlichen Arrays ist außerhalb der Arraygrenzen von %qT

en: internal compiler error
de: interner Compiler-Fehler

en: internal compiler error.  Bad address:
de: Interner Compiler-Fehler. Falsche Adresse:

en: internal compiler error.  Incorrect shift:
de: Interner Compiler-Fehler. Falsche Verschiebung:

en: internal compiler error.  Unknown mode:
de: Interner Compiler-Fehler. Unbekannter Modus:

en: internal compiler error:
de: interner Compiler-Fehler:

en: internal compiler error: error reporting routines re-entered.
de: Interner Compilerfehler: Fehlerbehandlungsroutinen doppelt betreten.

en: internal consistency failure
de: internes Konsistenzproblem

en: internal error: %<cris_side_effect_mode_ok%> with bad operands
de: interner Fehler: %<cris_side_effect_mode_ok%> mit falschen Operanden

en: internal error: bad register: %d
de: interner Fehler: falsches Register: %d

en: internal procedure %qs at %L conflicts with DUMMY argument
de: Interne Prozedur %qs bei %L steht in Konflikt mit DUMMY-Argument

en: internal unit in WRITE
de: interne Einheit in WRITE

en: interrupt and naked attributes are not compatible
de: die Attribute %<interrupt%> und %<naked%> sind nicht kompatibel

en: interrupt handlers cannot be MIPS16 functions
de: Interrupthandler können keine MIPS16-Funktionen sein

en: interrupt handlers cannot have arguments
de: Interrupthandler können keine Argumente haben

en: interrupt service routine can only have a pointer argument and an optional integer argument
de: Interrupt-Service-Routine darf nur ein Zeiger- und ein optionales Ganzzahl-Argument haben

en: interrupt service routine cannot be called directly
de: Interrupt-Dienst-Routinen können nicht direkt aufgerufen werden

en: interrupt service routine must return %<void%>
de: Interrupt-Service-Routine muss den Rückgabetyp %<void%> haben

en: interrupt service routine should have %qs as the second argument
de: in Interrupt-Service-Routinen sollte das zweite Argument vom Typ %qs sein

en: interrupt service routine should have a pointer as the first argument
de: in Interrupt-Service-Routinen sollte das erste Argument ein Zeiger sein

en: interrupt vector to %qE attribute is not %<vector=(sw0|sw1|hw0|hw1|hw2|hw3|hw4|hw5)%>
de: Interruptvektor für %qE-Attribut ist nicht %<vector=(sw0|sw1|hw0|hw1|hw2|hw3|hw4|hw5)%>

en: intrinsic register index is out of range
de: intrinsischer Registerindex ist außerhalb des gültigen Bereichs

en: intrinsic variable which isn't a procedure
de: innere Variable, die keine Prozedur ist

en: invalid %%%c operand
de: ungültiger %%%c-Operand

en: invalid %%-code
de: ungültiger %%-Code

en: invalid %%A operand
de: ungültiger %%A-Operand

en: invalid %%A value
de: ungültiger %%A-Wert

en: invalid %%B operand
de: ungültiger %%B-Operand

en: invalid %%C operand
de: ungültiger %%C-Operand

en: invalid %%C value
de: ungültiger %%C-Wert

en: invalid %%D operand
de: ungültiger %%D-Operand

en: invalid %%D value
de: ungültiger %%D-Wert

en: invalid %%E value
de: ungültiger %%E-Wert

en: invalid %%F value
de: ungültiger %%F-Wert

en: invalid %%G mode
de: ungültiger Modus %%G

en: invalid %%G value
de: ungültiger %%G-Wert

en: invalid %%H operand
de: ungültiger %%H-Operand

en: invalid %%H specifier
de: ungültiger %%H-Spezifizierer

en: invalid %%H value
de: ungültiger %%H-Wert

en: invalid %%I operand
de: ungültiger %%I-Operand

en: invalid %%J code
de: ungültiger %%J-Code

en: invalid %%J value
de: ungültiger %%J-Wert

en: invalid %%K value
de: ungültiger %%K-Wert

en: invalid %%L operand
de: ungültiger %%L-Operand

en: invalid %%L value
de: ungültiger %%L-Wert

en: invalid %%M operand
de: ungültiger %%M-Operand

en: invalid %%M value
de: ungültiger %%M-Wert

en: invalid %%N operand
de: ungültiger %%N-Operand

en: invalid %%N value
de: ungültiger %%N-Wert

en: invalid %%O value
de: ungültiger %%O-Wert

en: invalid %%P operand
de: ungültiger %%P-Operand

en: invalid %%P value
de: ungültiger %%P-Wert

en: invalid %%R value
de: ungültiger %%R-Wert

en: invalid %%T value
de: ungültiger %%T-Wert

en: invalid %%U value
de: ungültiger %%U-Wert

en: invalid %%V value
de: ungültiger %%V-Wert

en: invalid %%Y operand
de: ungültiger %%Y-Operand

en: invalid %%c operand
de: ungültiger %%c-Operand

en: invalid %%d operand
de: ungültiger %%d-Operand

en: invalid %%d value
de: ungültiger %%d-Wert

en: invalid %%e value
de: ungültiger %%e-Wert

en: invalid %%f operand
de: ungültiger %%f-Operand

en: invalid %%f value
de: ungültiger %%f-Wert

en: invalid %%h operand
de: ungültiger %%h-Operand

en: invalid %%h value
de: ungültiger %%h-Wert

en: invalid %%i operand
de: ungültiger %%i-Operand

en: invalid %%j code
de: ungültiger %%j-Code

en: invalid %%j operand
de: ungültiger %%j-Operand

en: invalid %%j value
de: ungültiger %%j-Wert

en: invalid %%k value
de: ungültiger %%k-Wert

en: invalid %%m value
de: ungültiger %%m-Wert

en: invalid %%p value
de: ungültiger %%p-Wert

en: invalid %%q value
de: ungültiger %%q-Wert

en: invalid %%r operand
de: ungültiger %%r-Operand

en: invalid %%r value
de: ungültiger %%r-Wert

en: invalid %%s operand
de: ungültiger %%s-Operand

en: invalid %%s value
de: ungültiger %%s-Wert

en: invalid %%t operand
de: ungültiger %%t-Operand

en: invalid %%t value
de: ungültiger %%t-Wert

en: invalid %%t/%%b value
de: ungültiger %%t/%%b-Wert

en: invalid %%u value
de: ungültiger %%u-Wert

en: invalid %%v value
de: ungültiger %%v-Wert

en: invalid %%x value
de: ungültiger %%x-Wert

en: invalid %%xn code
de: ungültiger %%xn-Code

en: invalid %%y value, try using the 'Z' constraint
de: ungültiger %%y-Wert, bitte »Z«-Bedingung probieren

en: invalid %%z value
de: ungültiger %%z-Wert

en: invalid %<#pragma %s%>
de: ungültiges %<#pragma %s%>

en: invalid %<CASE_CHAIN%>
de: ungültiges %<CASE_CHAIN%>

en: invalid %<CPU_TYPE%> value of %qs read from %<devices.csv%> for %qs
de: ungültiger %<CPU_TYPE%>-Wert %qs gelesen aus %<devices.csv%> für %qs

en: invalid %<MPY_TYPE%> value of %qs read from %<devices.csv%> for %qs
de: ungültiger %<MPY_TYPE%>-Wert %qs gelesen aus %<devices.csv%> für %qs

en: invalid %<PHI%> argument
de: ungültiges %<PHI%>-Argument

en: invalid %<PHI%> result
de: ungültiges %<PHI%>-Ergebnis

en: invalid %<const_cast%> from type %qT to type %qT
de: ungültiges %<const_cast%> von Typ %qT in Typ %qT

en: invalid %<const_cast%> of an rvalue of type %qT to type %qT
de: ungültiges %<const_cast%> eines R-Wertes des Typs %qT in Typ %qT

en: invalid %<static_cast%> from type %qT to type %qT
de: ungültiges %<static_cast%> von Typ %qT in Typ %qT

en: invalid %<sve_width%> value: %d
de: ungültiger Wert für %<sve_width%>: %d

en: invalid %<task%> reduction modifier on construct combined with %<simd%> or %<loop%>
de: ungültiger %<task%>-Reduktionsmodifizierer in Konstrukt kombiniert mit %<simd%> oder %<loop%>

en: invalid %<task%> reduction modifier on construct not combined with %<parallel%>, %<for%> or %<sections%>
de: ungültiger %<task%>-Reduktionsmodifizierer in Konstrukt, das nicht mit %<parallel%>, %<for%> oder %<sections%> kombiniert ist

en: invalid %<task%> reduction modifier on construct other than %<parallel%>, %qs or %<sections%>
de: ungültiger %<task%>-Reduktionsmodifizierer bei Konstrukt außer %<parallel%>, %qs oder %<sections%>

en: invalid %<task%> reduction modifier on construct other than %<parallel%>, %qs, %<sections%> or %<scope%>
de: ungültiger %<task%>-Reduktionsmodifizierer bei Konstrukt außer %<parallel%>, %qs, %<sections%> oder %<scope%>

en: invalid %qs offset operator
de: ungültiger Offset-Operator %qs

en: invalid 'asm':
de: ungültiges »asm«:

en: invalid (pointer) operands %qs
de: Ungültige (Zeiger-)Operanden %qs

en: invalid IACC argument
de: ungültiges IACC-Argument

en: invalid JSON syntax
de: ungültige JSON-Syntax

en: invalid LHS in gimple call
de: ungültige LHS in GIMPLE-Aufruf

en: invalid Objective-C++ selector name
de: Ungültiger Objective-C++-Selektorname

en: invalid OpenACC clause at file scope
de: ungültige OpenACC-Klausel im Datei-Gültigkeitsbereich

en: invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE
de: ungültiger nicht-rechteckiger OpenMP-Schleifenschritt; %<(%E - %E) * %E%> ist kein Vielfaches von Schleife %d Schritt %qE

en: invalid RHS for gimple memory store: %qs
de: ungültige rechte Seite für GIMPLE-Speicherung: %qs

en: invalid UNSPEC as operand
de: ungültiges UNSPEC als Operand

en: invalid UNSPEC as operand: %d
de: ungültiges UNSPEC als Operand: %d

en: invalid _Literal
de: Interner Fehler: invalid _Literal

en: invalid abstract parameter type %qT
de: ungültiger abstrakter Parametertyp %qT

en: invalid abstract return type %qT
de: ungültiger abstrakter Rückgabetyp %qT

en: invalid abstract return type for function %q+#D
de: ungültiger abstrakter Rückgabetyp für Funktion %q+#D

en: invalid abstract return type for member function %q+#D
de: ungültiger abstrakter Rückgabetyp für Elementfunktion %q+#D

en: invalid abstract type %qT for %qE
de: ungültiger abstrakter Typ %qT für %qE

en: invalid abstract type for %q+D
de: ungültiger abstrakter Typ für %q+D

en: invalid access to non-static data member %qD in virtual base of NULL object
de: ungültiger Zugriff auf nicht-statisches Datenelement %qD in virtueller Basis des NULL-Objektes

en: invalid address
de: ungültige Adresse

en: invalid address for 'O' output modifier
de: ungültige Adresse für Ausgabemodifizierer »O«

en: invalid address for 'R' output modifier
de: ungültige Adresse für Ausgabemodifizierer »R«

en: invalid address for 'S' output modifier
de: ungültige Adresse für Ausgabemodifizierer »S«

en: invalid address in operand
de: ungültige Adresse in Operand

en: invalid address mode
de: ungültiger Adressierungsmodus

en: invalid address operand in %qs
de: ungültiger Adressoperand in %qs

en: invalid addressing mode
de: ungültiger Adressierungsmodus

en: invalid alignment for %<#pragma align%>, ignoring
de: ungültige Ausrichtung für %<#pragma align%> - ignoriert

en: invalid alignment value for %<__builtin_arc_aligned%>
de: Ungültiger Ausrichtungswert für %<__builtin_arc_aligned%>

en: invalid application of %<__alignof%> to a bit-field
de: ungültige Anwendung von %<__alignof%> auf ein Bitfeld

en: invalid application of %<sizeof%> to a bit-field
de: ungültige Anwendung von %<sizeof%> auf ein Bitfeld

en: invalid application of %<sizeof%> to a function type
de: Ungültige Anwendung von %<sizeof%> auf einen Funktionstypen

en: invalid application of %qs to a member function
de: ungültige Anwendung von %qs auf Elementfunktion

en: invalid application of %qs to a void type
de: Ungültige Anwendung von %qs auf einen void-Typen

en: invalid application of %qs to array type %qT of incomplete element type
de: Ungültige Anwendung von %qs auf Arraytyp %qT mit unvollständigem Elementtyp

en: invalid application of %qs to incomplete type %qT
de: Ungültige Anwendung von %qs auf unvollständigen Typen %qT

en: invalid architecture for target attribute or pragma %qs
de: Ungültige Architektur für Zielattribut oder -pragma %qs

en: invalid argument %<%s%> for %<-mbranch-protection=%>
de: ungültiges Argument %qs für %<-mbranch-protection=%>

en: invalid argument %<%s%> for %<-mharden-sls=%>
de: ungültiges Argument %qs für %<-mharden-sls=%>

en: invalid argument %d for builtin %qF
de: Ungültiges Argument %d für eingebaute Funktion %qF

en: invalid argument %qs to %qs
de: ungültiges Argument %qs für %qs

en: invalid argument given to %<-mharden-sls=%>
de: ungültiges Argument für %<-mharden-sls=%>

en: invalid argument in option %qs
de: ungültiges Argument in Option %qs

en: invalid argument of %qE attribute
de: ungültiges Argument für Attribut %qE

en: invalid argument of %qs attribute
de: ungültiges Argument für Attribut %qs

en: invalid argument of SQRT at %L
de: Ungültiges Argument von SQRT bei %L

en: invalid argument to %qD
de: ungültiges Argument für %qD

en: invalid argument to built-in function
de: ungültiges Argument für eingebaute Funktion

en: invalid argument to built-in function %s
de: ungültiges Argument für eingebaute Funktion »%s«

en: invalid argument to gimple call
de: ungültiges Argument für GIMPLE-Aufruf

en: invalid arguments
de: ungültige Argumente

en: invalid arguments for %<-falign-%s%> option: %qs
de: ungültige Argumente für Option %<-falign-%s%>: %qs

en: invalid arguments for %<-fpatchable-function-entry%>
de: ungültige Argumente für %<-fpatchable-function-entry%>

en: invalid array assignment
de: Ungültige Arrayzuweisung

en: invalid base %qE for SSA name
de: Interner Fehler: invalid base %qE for SSA name

en: invalid base-class specification
de: ungültige Spezifizierung der Basisklasse

en: invalid block index
de: Interner Fehler: invalid block index

en: invalid branch to/from %s structured block
de: ungültiger Zweig zu/von strukturiertem %s-Block

en: invalid call to non-function
de: ungültiger Aufruf einer Nicht-Funktion

en: invalid calls_comdat_local flag
de: ungültiger Schalter »calls_comdat_local«

en: invalid case label in switch statement
de: ungültige »case«-Marke in switch-Anweisung

en: invalid case range in switch statement
de: ungültiger »case«-Bereich in switch-Anweisung

en: invalid cast from type %qT to type %qT
de: ungültige Umwandlung von Typ %qT in Typ %qT

en: invalid cast of a prvalue expression of type %qT to type %qT
de: ungültige Typumwandlung eines prvalue-Ausdrucks des Typs %qT in Typ %qT

en: invalid cast to abstract class type %qT
de: ungültige Umwandlung in abstrakte Klasse %qT

en: invalid cast to function type %qT
de: ungültige Umwandlung in Funktionstyp %qT

en: invalid class name in declaration of %qD
de: ungültiger Klassenname in Deklaration von %qD

en: invalid clique in %qs
de: ungültige Clique in %qs

en: invalid combination of multiple type-specifiers
de: ungültige Kombination mehrerer Typ-Spezifizierer

en: invalid comparison of generated array
de: ungültiger Vergleich eines generierten Arrays

en: invalid comparison of generated struct
de: ungültiger Vergleich mit einer generierten Struktur

en: invalid comparison of nil with nil
de: ungültiger Vergleich von nil mit nil

en: invalid comparison of non-comparable array
de: ungültiger Vergleich eines nicht-vergleichbaren Arrays

en: invalid comparison of non-comparable struct
de: ungültiger Vergleich einer nicht-vergleichbaren Struktur

en: invalid comparison of non-comparable type
de: ungültiger Vergleich eines nicht-vergleichbaren Typs

en: invalid comparison of non-ordered type
de: ungültiger Vergleich ungeordneter Typen

en: invalid comparison operator for 'E' output modifier
de: ungültiger Vergleichsoperator für Ausgabemodifizierer »E«

en: invalid const_double operand
de: ungültiger const_double-Operand

en: invalid constant
de: ungültige Konstante

en: invalid constant - try using an output modifier
de: Ungültige Konstante – anderen Ausgabemodifizierer probieren

en: invalid constant for output modifier '%c'
de: ungültige Konstante für Ausgabemodifizierer »%c«

en: invalid constant in %<#pragma %s%>
de: ungültige Konstante in %<#pragma %s%>

en: invalid constant in %<#pragma pack%> - ignored
de: ungültige Konstante in %<#pragma pack%> - ignoriert

en: invalid constant vector for output modifier '%c'
de: ungültiger konstanter Vektor für Ausgabemodifizierer »%c«

en: invalid constrained type parameter
de: ungültiger beschränkter Typparameter

en: invalid constraints
de: ungültige Einschränkungen

en: invalid constraints for operand
de: ungültige Bedingungen für Operand

en: invalid constructor; you probably meant %<%T (const %T&)%>
de: ungültiger Konstruktor; wahrscheinlich war %<%T (const %T&)%> gemeint

en: invalid control register %d for mvtc; using %<psw%>
de: ungültiges Steuerregister %d für mvtc; %<psw%> wird verwendet

en: invalid controlling predicate
de: Steuerprädikat ungültig

en: invalid conversion from %<__fpreg%>
de: ungültige Umwandlung von %<__fpreg%>

en: invalid conversion from %qH to %qI
de: ungültige Umwandlung von %qH in %qI

en: invalid conversion from type %<* __vector_pair%>
de: ungültige Umwandlung von %<* __vector_pair%>

en: invalid conversion from type %<* __vector_quad%>
de: ungültige Umwandlung von Typ %<* __vector_quad%>

en: invalid conversion from type %<__vector_pair%>
de: ungültige Umwandlung von %<__vector_pair%>

en: invalid conversion from type %<__vector_quad%>
de: ungültige Umwandlung von Typ %<__vector_quad%>

en: invalid conversion from type %<bfloat16_t%>
de: ungültige Umwandlung von Typ %<bfloat16_t%>

en: invalid conversion in gimple call
de: ungültige Umwandlung in GIMPLE-Aufruf

en: invalid conversion in return statement
de: ungültige Umwandlung in »return«-Anweisung

en: invalid conversion to %<__fpreg%>
de: ungültige Umwandlung in %<__fpreg%>

en: invalid conversion to type %<* __vector_pair%>
de: ungültige Umwandlung in %<* __vector_pair%>

en: invalid conversion to type %<* __vector_quad%>
de: ungültige Umwandlung in Typ %<* __vector_quad%>

en: invalid conversion to type %<__vector_pair%>
de: ungültige Umwandlung in %<__vector_pair%>

en: invalid conversion to type %<__vector_quad%>
de: ungültige Umwandlung in Typ %<__vector_quad%>

en: invalid conversion to type %<bfloat16_t%>
de: ungültige Umwandlung in Typ %<bfloat16_t%>

en: invalid conversion to type %qT from type %qT
de: ungültige Umwandlung in Typ %qT von Typ %qT

en: invalid covariant return type for %q#D
de: ungültiger kovarianter Rückgabetyp für %q#D

en: invalid covariant return type for %q+#D
de: ungültiger kovarianter Rückgabetyp für %q+#D

en: invalid cpu %qs for %s%qs%s
de: ungültige CPU %qs für %s%qs%s

en: invalid custom instruction option %qs
de: ungültige Option für benutzerdefinierten Befehl %qs

en: invalid data model option %<-mdata-model=%s%>
de: Ungültige Datenmodell-Option %<-mdata-model=%s%>

en: invalid declaration of %<%T::%E%>
de: ungültige Deklaration von %<%T::%E%>

en: invalid declaration of member template in local class
de: ungültige Deklaration eines Elementtemplates in lokaler Klasse

en: invalid declarator
de: ungültiger Deklarator

en: invalid default argument for a template template parameter
de: ungültiges Standardargument für einen Template-Templateparameter

en: invalid default case label in switch statement
de: ungültige %<default%>-Sprungmarke in switch-Anweisung

en: invalid definition of qualified type %qT
de: ungültige Definition des qualifizierten Typen %qT

en: invalid depend kind
de: ungültige Abhängigkeitsart

en: invalid depend kind in omp %<ordered%> %<depend%>
de: ungültige Abhängigkeitsart in omp %<ordered%> %<depend%>

en: invalid dist_schedule kind
de: ungültige »dist_schedule«-Art

en: invalid element index %qE to %<__builtin_shufflevector%>
de: Ungültiger Elementindex %qE für %<__builtin_shufflevector%>

en: invalid element type for attribute %qs
de: ungültiger Elementtyp für Attribut %qs

en: invalid embedcfg: Files entry is not a string
de: ungültige embedcfg: »Files«-Element ist keine Zeichenkette

en: invalid embedcfg: Files is not a JSON object
de: ungültige embedcfg: »Files« ist kein JSON-Objekt

en: invalid embedcfg: Patterns entry is not an array
de: ungültige embedcfg: »Patterns«-Element ist kein Array

en: invalid embedcfg: Patterns is not a JSON object
de: ungültige embedcfg: »Patterns« ist kein JSON-Objekt

en: invalid embedcfg: duplicate Patterns entry
de: ungültige embedcfg: doppeltes »Patterns«-Element

en: invalid embedcfg: missing Files
de: ungültige embedcfg: fehlendes »Files«

en: invalid embedcfg: missing Patterns
de: ungültige embedcfg: »Patterns« fehlt

en: invalid embedcfg: not a JSON object
de: ungültige embedcfg: kein JSON-Objekt

en: invalid encoding prefix in literal operator
de: ungültiges Encoding-Präfix in Literal-Operator

en: invalid entry to %s structured block
de: ungültiger Eintritt in strukturierten %s-Block

en: invalid exit from %s structured block
de: ungültiger Austritt aus strukturiertem %s-Block

en: invalid exit from OpenMP structured block
de: ungültiger Ausgang von strukturiertem OpenMP-Block

en: invalid explicit specialization
de: ungültige explizite Spezialisierung

en: invalid expression - try using an output modifier
de: ungültiger Ausdruck – anderen Ausgabemodifizierer probieren

en: invalid expression as operand
de: ungültiger Ausdruck als Operand

en: invalid expression for min lvalue
de: ungültiger Ausdruck für Min-L-Wert

en: invalid expression for output modifier '%c'
de: ungültiger Ausdruck für Ausgabemodifizierer »%c«

en: invalid expression for static array dimension: %s
de: ungültiger Ausdruck für statische Array-Dimension: %s

en: invalid expression type for %<#pragma omp atomic%>
de: ungültiger Ausdruckstyp für %<#pragma omp atomic%>

en: invalid failure memory model %qs for %qD
de: ungültiges Fehler-Speichermodell %qs für %qD

en: invalid feature modifier %qs in %<-march=%s%>
de: unbekannter Feature-Modifizierer %qs in %<-march=%s%>

en: invalid feature modifier %qs in %<-mcpu=%s%>
de: unbekannter Feature-Modifizierer %qs in %<-mcpu=%s%>

en: invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute
de: ungültiger Featuremodifizierer %qs mit Wert %qs in Pragma oder Attribut %<target()%>

en: invalid feature modifier %s of value %qs in %<target()%> pragma or attribute
de: ungültiger Featuremodifizierer %qs mit Wert %qs in Pragma oder Attribut %<target()%>

en: invalid fnsummary in LTO stream
de: ungültige »fnsummary« in LTO-Datenstrom

en: invalid form of %<#pragma omp atomic compare%>
de: ungültige Form von %<#pragma omp atomic compare%>

en: invalid form of %<#pragma omp atomic%>
de: ungültige Form von %<#pragma omp atomic%>

en: invalid form of %<pragma omp atomic compare%>
de: ungültige Form von %<#pragma omp atomic compare%>

en: invalid format for %<sve_width%>
de: ungültiges Format für %<sve_width%>

en: invalid format of %s
de: ungültiges Format von %s

en: invalid fp constant
de: ungültige Gleitkomma-Konstante

en: invalid fpu for target attribute or pragma %qs
de: ungültige FPU für Zielattribut oder -pragma %qs

en: invalid function in gimple call
de: ungültige Funktion in GIMPLE-Aufruf

en: invalid hard register usage between earlyclobber operand and input operand
de: ungültige Verwendung von festen Registern zwischen earlyclobber-Operand und Eingabeoperand

en: invalid hard register usage between output operand and matching constraint operand
de: ungültige Verwendung von festen Registern zwischen Ausgabeoperanden und dem zugehörigen Constraint-Operanden

en: invalid hard register usage between output operands
de: ungültige Verwendung von festen Registern zwischen Ausgabeoperanden

en: invalid header name %qs
de: ungültiger Headername %qs

en: invalid hex digit
de: ungültige Hexziffer

en: invalid id value for exception attribute
de: ungültiger ID-Wert für Attribut »exception«

en: invalid id value for interrupt attribute
de: ungültiger ID-Wert für Attribut »interrupt«

en: invalid id value for interrupt/exception attribute
de: ungültiger ID-Wert für Interrupt-/Exception-Attribut

en: invalid id value for reset attribute
de: ungültiger ID-Wert für »reset«-Attribut

en: invalid in-class initialization of static data member of non-integral type %qT
de: ungültige Initialisierung innerhalb der Klasse des statischen Datenelements vom nicht eingebauten Typen %qT

en: invalid increment expression
de: Erhöhungsausdruck ungültig

en: invalid initial value for member %qE
de: ungültiger Anfangswert für Element %qE

en: invalid initialization of non-const reference of type %qH from an rvalue of type %qI
de: ungültige Initialisierung einer nicht-konstanten Referenz des Typs %qH von rvalue des Typs %qI

en: invalid initialization of reference of type %qH from expression of type %qI
de: ungültige Initialisierung einer Referenz des Typs %qH von Ausdruck des Typs %qI

en: invalid initializer
de: ungültige Initialisierung

en: invalid initializer clause
de: ungültige Initialisierungsklausel

en: invalid initializer for %q#D
de: ungültige Initialisierung für %q#D

en: invalid initializer for array member %q#D
de: ungültige Initialisierung für Arrayelement %q#D

en: invalid initializer for member function %qD
de: ungültige Initialisierung für Elementfunktion %qD

en: invalid initializer for structured binding declaration
de: ungültige Initialisierung für strukturierte Bindungsdeklaration

en: invalid insn:
de: Ungültiger Befehl:

en: invalid iterating variable in fast enumeration
de: ungültiges Schleifenvariable in schneller Aufzählung

en: invalid jump function in LTO stream
de: ungültige Sprungfunktion in LTO-Datenstrom

en: invalid labels in gimple cond
de: Ungültiger Marken in GIMPLE-Bedingung

en: invalid left hand side of assignment
de: ungültige linke Seite einer Zuweisung

en: invalid line in the resolution file
de: ungültige Zeile in Auflösungsdatei

en: invalid linkage-specification
de: ungültige Bindungsspezifikation

en: invalid location for %<pragma %s%>, ignored
de: ungültiger Ort für %<pragma %s%>, ignoriert

en: invalid lvalue in %<asm%> output %d
de: ungültiger L-Wert in %<asm%>-Ausgabe %d

en: invalid map kind
de: ungültige Zuordnungsart

en: invalid mask
de: ungültige Maske

en: invalid mask type in %qs
de: ungültiger Maskentyp in %qs

en: invalid member template declaration %qD
de: ungültige Elementtemplatedeklaration %qD

en: invalid memory model %qs for %qD
de: ungültiges Speichermodell %qs für %qD

en: invalid memory model %wi for %qD
de: ungültiges Speichermodell %wi für %qD

en: invalid memory model argument %d of %qE
de: ungültiges Argument %d für Speichermodell von %qE

en: invalid module name %qs
de: ungültiger Modulname %qs

en: invalid name %qs in %<target("arch=")%> pragma or attribute
de: ungültiger Name %qs für Pragma oder Attribut %<target("arch=")%>

en: invalid name %qs in %<target("cpu=")%> pragma or attribute
de: ungültiger Name %qs für Pragma oder Attribut %<target("cpu=")%>

en: invalid name %qs in %<target("tune=")%> pragma or attribute
de: ungültiger Name %qs für Pragma oder Attribut %<target("tune=")%>

en: invalid new-expression of abstract class type %qT
de: ungültiger new-Ausdruck für abstrakte Klasse %qT

en: invalid nmi function for reset attribute
de: ungültige NMI-Funktion für »reset«-Attribut

en: invalid non-type template argument
de: ungültiges Templateargument ohne Typ

en: invalid non-vector operands to %qs
de: ungültige Nicht-Vektor-Operanden für %qs

en: invalid number in %<-mrgf-banked-regs=%s%> valid values are 0, 4, 8, 16, or 32
de: ungültige Anzahl in %<-mrgf-banked-regs=%s%>; gültige Werte sind 0, 4, 8, 16 und 32

en: invalid number of arguments for %<-falign-%s%> option: %qs
de: Falsche Anzahl der Argumente für Option %<-falign-%s%>: %qs

en: invalid offload table in %s
de: ungültige offload-Tabelle in %s

en: invalid offset operand in %qs
de: ungültiger Offset-Operand in %qs

en: invalid operand
de: ungültiger Operand

en: invalid operand %%xn code
de: ungültiger Code für Operand %%xn

en: invalid operand address
de: ungültige Operandenadresse

en: invalid operand code '%c'
de: ungültiger Operandencode »%c«

en: invalid operand for '%%%c'
de: ungültiger Operand für »%%%c«

en: invalid operand for 'A' modifier
de: ungültiger Operand für Modifizierer »A«

en: invalid operand for 'D' modifier
de: ungültiger Operand für Modifizierer »D«

en: invalid operand for 'H' modifier
de: ungültiger Operand für Modifizierer »H«

en: invalid operand for 'O' modifier
de: ungültiger Operand für Modifizierer »O«

en: invalid operand for 'T' modifier
de: ungültiger Operand für Modifizierer »T«

en: invalid operand for 'b' modifier
de: ungültiger Operand für Modifizierer »b«

en: invalid operand for 'e' modifier
de: ungültiger Operand für Modifizierer »e«

en: invalid operand for 'm' modifier
de: ungültiger Operand für Modifizierer »m«

en: invalid operand for 'o' modifier
de: ungültiger Operand für Modifizierer »o«

en: invalid operand for 'p' modifier
de: ungültiger Operand für Modifizierer »p«

en: invalid operand for 'r' specifier
de: ungültiger Operand für Spezifizierer »r«

en: invalid operand for 'z' modifier
de: ungültiger Operand für Modifizierer »z«

en: invalid operand for code '%c'
de: ungültiger Operand für Code »%c«

en: invalid operand in %qs
de: ungültiger Operand in %qs

en: invalid operand in return statement
de: ungültiger Operand in »return«-Anweisung

en: invalid operand in unary operation
de: ungültiger Operand in unärer Operation

en: invalid operand modifier letter
de: ungültiger Modifizierer-Buchstabe für Operand

en: invalid operand output code
de: ungültiger Operanden-Ausgabecode

en: invalid operand prefix
de: ungültiges Operandenpräfix

en: invalid operand prefix '%%%c'
de: ungültiger Operandenpräfix »%%%c«

en: invalid operand size for operand code 'O'
de: ungültige Operandengröße für Operandencode »O«

en: invalid operand size for operand code 'Z'
de: ungültige Operandengröße für Operandencode »Z«

en: invalid operand size for operand code 'z'
de: ungültige Operandengröße für Operandencode »z«

en: invalid operand to %%H/%%L code
de: ungültiger Operand für %%H/%%L-Code

en: invalid operand to %%M code
de: ungültiger Operand für Code %%M

en: invalid operand to %%N code
de: ungültiger Operand für Code %%N

en: invalid operand to %%O code
de: ungültiger Operand für Code %%O

en: invalid operand to %%R
de: ungültiger Operand für %%R

en: invalid operand to %%R code
de: ungültiger Operand für %%R-Code

en: invalid operand to %%S
de: ungültiger Operand für %%S

en: invalid operand to %%T/%%B code
de: ungültiger Operand für Code %%T/%%B

en: invalid operand to %%U code
de: ungültiger Operand für %%U-Code

en: invalid operand to %%V code
de: ungültiger Operand für %%V-Code

en: invalid operand to %%Z code
de: ungültiger Operand für Code %%Z

en: invalid operand to %%p code
de: ungültiger Operand für Code %%p

en: invalid operand to %%s code
de: ungültiger Operand für Code %%s

en: invalid operand to %%z code
de: ungültiger Operand für Code %%z

en: invalid operand to switch statement
de: ungültiger Operand für switch-Anweisung

en: invalid operand type %qT for %qs
de: ungültiger Operandentyp %qT für %qs

en: invalid operand type used with operand code 'Z'
de: ungültiger Operandentyp mit Operandencode »Z« verwendet

en: invalid operands in binary operation
de: ungültige Operanden in binärer Operation

en: invalid operands in gimple comparison
de: ungültige Operanden in GIMPLE-Vergleich

en: invalid operands in ternary operation
de: ungültige Operanden in ternärer Operation

en: invalid operands of types %qT and %qT to binary %qO
de: ungültige Operanden der Typen %qT und %qT für binäres %qO

en: invalid operands to %%c code
de: ungültige Operanden für Code %%c

en: invalid operands to %qs
de: ungültiger Operand für %qs

en: invalid operands to binary %s (have %qT and %qT)
de: Ungültige Operanden für binäres %s (haben %qT und %qT)

en: invalid operation
de: Interner Fehler: invalid operation

en: invalid operation (%s)
de: ungültige Operation (%s)

en: invalid operation on %<__fpreg%>
de: ungültige Operation auf %<__fpreg%>

en: invalid operator for %<#pragma omp atomic%>
de: ungültiger Operator für %<#pragma omp atomic%>

en: invalid order in asm node %i
de: ungültige Reihenfolge in asm-Knoten %i

en: invalid parameter combination for AltiVec intrinsic %qs
de: ungültige Parameterkombination für AltiVec-spezifisches intrinsisches %qs

en: invalid parameter combination for intrinsic %qs
de: ungültige Parameterkombination für intrinsisches %qs

en: invalid parameter type %qT
de: ungültiger Parametertyp %qT

en: invalid pass positioning operation
de: ungültige Durchlaufpositionierungsoperation

en: invalid pointer mode %qs
de: Ungültiger Zeigermodus %qs

en: invalid pointer to bit-field %qD
de: ungültiger Zeiger auf Bitfeld %qD

en: invalid position or size in %qs
de: ungültige Position oder Größe in %qs

en: invalid position or size operand to %qs
de: ungültiger Positions- oder Größenoperand für %qs

en: invalid private reduction on %qE
de: ungültige »private«-Reduktion auf %qE

en: invalid proc_bind kind
de: ungültige »proc_bind«-Art

en: invalid protection type %qs in %<target("branch-protection=")%> pragma or attribute
de: ungültiger Schutztyp %qs in Pragma oder Attribut %<target("branch-protection=")%>

en: invalid prototype for '%s'
de: ungültiger Prototyp für »%s«

en: invalid punctuation %qc in constraint
de: ungültiges Zeichen %qc in Bedingung

en: invalid pure const state for function
de: ungültiger »pure const«-Status für Funktion

en: invalid pure specifier (only %<= 0%> is allowed)
de: ungültige reine Spezifikation (nur %<= 0%> ist erlaubt)

en: invalid qualifiers on non-member function type
de: ungültige Qualifizierer an Nicht-Element-Funktionstyp

en: invalid qualifying scope in pseudo-destructor name
de: ungültiger angegebener Gültigkeitsbereich in Pseudodestruktor-Name

en: invalid receive on send-only channel
de: ungültiges Empfangen auf Nur-Sende-Kanal

en: invalid receiver type %qs
de: ungültiger Empfängertyp %qs

en: invalid reduction-identifier
de: ungültiger reduction-identifier

en: invalid reference for 'J' output modifier
de: ungültige Referenz für Ausgabemodifizierer »J«

en: invalid register name for %q+D
de: ungültiger Registername für %q+D

en: invalid regular expression %qs in %qs
de: ungültiger regulärer Ausdruck %qs in %qs

en: invalid relocation
de: ungültige Adressverschiebung

en: invalid resolution in the resolution file
de: ungültige Auflösung in Auflösungsdatei

en: invalid return type %qT of %<constexpr%> function %q+D
de: ungültiger Rückgabetyp %qT der %<constexpr%>-Funktion %q+D

en: invalid rtl sharing found in the insn
de: ungültige gemeinsame rtl-Verwendung in Befehl gefunden

en: invalid schedule kind
de: ungültige Ablaufart

en: invalid second argument to %<__builtin_prefetch%>; using zero
de: Ungültiges zweites Argument für %<__builtin_prefetch%>; es wird 0 verwendet

en: invalid send on receive-only channel
de: ungültiges »send« auf Nur-Empfangs-Kanal

en: invalid setter, it must have one argument
de: ungültiger Setter, muss ein Argument haben

en: invalid shift operand
de: ungültiger Schiebeoperand

en: invalid source block specification
de: Interner Fehler: invalid source block specification

en: invalid static chain in gimple call
de: ungültige statische Kette in GIMPLE-Aufruf

en: invalid storage class for function %qE
de: ungültige Speicherklasse für Funktion %qE

en: invalid target memregs value %<%d%>
de: ungültiger Wert %<%d%> für Ziel-memregs

en: invalid template declaration of %qD
de: ungültige Templatedeklaration von %qD

en: invalid template non-type parameter
de: ungültiger Nicht-Typ-Parameter für Template

en: invalid template-argument-list
de: ungültige template-argument-list

en: invalid template-id
de: ungültige Template-ID

en: invalid third argument to %<__builtin_prefetch%>; using zero
de: Ungültiges drittes Argument für %<__builtin_prefetch%>; es wird 0 verwendet

en: invalid type %<void%> for %<new%>
de: ungültiger Typ %<void%> für %<new%>

en: invalid type %qT as initializer for a vector of type %qT
de: Ungültiger Typ %qT als Initialisierung für einen Vektor des Typs %qT

en: invalid type %qT declared %<friend%>
de: ungültiger Typ %qT als %<friend%> deklariert

en: invalid type argument (have %qT)
de: ungültiger Typ %qT

en: invalid type argument of %<->%> (have %qT)
de: ungültiger Typ %qT für %<->%>

en: invalid type argument of %<->*%> (have %qT)
de: ungültiger Typ %qT für %<->*%>

en: invalid type argument of array indexing (have %qT)
de: ungültiger Typ %qT für Arrayindex

en: invalid type argument of implicit conversion (have %qT)
de: ungültiger Argumenttyp %qT für implizite Umwandlung

en: invalid type argument of unary %<*%> (have %qT)
de: ungültiger Typ %qT für unäres %<*%>

en: invalid type for %<asm%> flag output
de: ungültiger Typ für %<asm%>-Schalter-Ausgabe

en: invalid type for _Literal with constructor
de: Interner Fehler: invalid type for _Literal with constructor

en: invalid type for instance variable
de: ungültiger Typ für Instanzvariable

en: invalid type for iteration variable %qE
de: ungültiger Typ für Schleifenvariable %qE

en: invalid type for make function
de: ungültiger Typ für »make«-Funktion

en: invalid type for parameter %d of %<constexpr%> function %q+#D
de: ungültiger Typ für Parameter %d der %<constexpr%>-Funktion %q+#D

en: invalid type for property
de: ungültiger Typ für Eigenschaft

en: invalid type of %<__MEM%> operand
de: Interner Fehler: invalid type of %<__MEM%> operand

en: invalid type of argument %u of type-generic function
de: ungültiger Typ für Argument %u der typgenerischen Funktion

en: invalid type-generic return type for argument %u of %<__builtin_tgmath%>
de: ungültiger typgenerischer Rückgabetyp für Argument %u von %<__builtin_tgmath%>

en: invalid type-generic type for argument %u of argument %u of %<__builtin_tgmath%>
de: ungültiger typgenerischer Typ für Argument %u von Argument %u von %<__builtin_tgmath%>

en: invalid types %<%T[%T]%> for array subscript
de: ungültige Typen %<%T[%T]%> für Feldindex

en: invalid types for %qs
de: ungültiger Typen für %qs

en: invalid types in address space conversion
de: ungültige Typen in Adressraumumwandlung

en: invalid types in conversion to floating-point
de: ungültige Typen in Umwandlung zu Gleitkomma

en: invalid types in conversion to integer
de: ungültige Typen in Umwandlung in Ganzzahl

en: invalid types in fixed-point conversion
de: ungültige Typen Festkomma-Umwandlung

en: invalid types in nop conversion
de: ungültige Typen in NOP-Umwandlung

en: invalid use of %%d, %%x, or %%X
de: ungültige Verwendung von %%d, %%x oder %%X

en: invalid use of %<...%> calling non-variadic function
de: ungültige Verwendung von %<...%> bei Aufruf einer nicht-variadischen Funktion

en: invalid use of %<...%> with builtin function
de: ungültige Verwendung von %<...%> mit eingebauter Funktion

en: invalid use of %<...%> with non-slice
de: ungültige Verwendung von %<...%> mit Nicht-Slice

en: invalid use of %<::%>
de: ungültige Verwendung von %<::%>

en: invalid use of %<__builtin_va_arg_pack ()%>
de: ungültige Verwendung von %<__builtin_va_arg_pack ()%>

en: invalid use of %<__builtin_va_arg_pack_len ()%>
de: ungültige Verwendung von %<__builtin_va_arg_pack_len ()%>

en: invalid use of %<auto%> in conversion operator
de: ungültige Verwendung von %<auto%> in Umwandlungsoperator

en: invalid use of %<auto%> in default template argument
de: ungültige Verwendung von %<auto%> in Default-Templateargument

en: invalid use of %<auto%> in exception-specification
de: ungültige Verwendung von %<auto%> in Ausnahmespezifikation

en: invalid use of %<auto%> in template argument
de: ungültige Verwendung von %<auto%> in Templateargument

en: invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type
de: ungültige Verwendung von %<const_cast%> mit Typ %qT, der ein Zeiger oder Referenz auf Funktionstyp ist

en: invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type
de: ungültige Verwendung von %<const_cast%> mit Typ %qT, der weder Zeiger, Referenz, noch Zeiger auf ein Datenelement ist

en: invalid use of %<decltype(auto)%>
de: ungültige Verwendung von %<decltype(auto)%>

en: invalid use of %<extern%> variable %qD in %<#pragma acc declare%>
de: ungültige Verwendung der %<extern%>-Variable %qD in %<#pragma acc declare%>

en: invalid use of %<global%> variable %qD in %<#pragma acc declare%>
de: ungültige Verwendung der %<global%>-Variable %qD in %<#pragma acc declare%>

en: invalid use of %<restrict%>
de: Ungültige Verwendung von %<restrict%>

en: invalid use of %<this%> at top level
de: ungültige Verwendung von %<this%> auf höchster Ebene

en: invalid use of %<this%> in non-member function
de: ungültige Verwendung von %<this%> in Nicht-Element-Funktion

en: invalid use of %q#T with a flexible array member in %q#T
de: ungültige Verwendung von %q#T mit flexiblem Arrayelement in %q#T

en: invalid use of %q#T with a zero-size array in %q#D
de: ungültige Verwendung von %q#T mit Array der Größe 0 in %q#D

en: invalid use of %qD
de: ungültige Verwendung von %qD

en: invalid use of %qD in linkage specification
de: ungültige Verwendung von %qD in Spezifizierung der Bindung

en: invalid use of %qE to form a pointer-to-member-function
de: ungültige Verwendung von %qE um Zeiger auf Elementfunktion zu erzeugen

en: invalid use of %qT
de: ungültige Verwendung von %qT

en: invalid use of %qT in template argument
de: ungültige Verwendung von %qT in Templateargument

en: invalid use of '%%%c'
de: ungültige Verwendung von »%%%c«

en: invalid use of MMA operand of type %qs as a function parameter
de: ungültige Verwendung des MMA-Operanden vom Typ %qs als Parameter einer Funktion

en: invalid use of MMA type %qs as a function return value
de: ungültige Verwendung des MMA-Typs %qs als Rückgabetyp einer Funktion

en: invalid use of a pointer to an incomplete type in pointer arithmetic
de: ungültige Verwendung eines Zeigers auf einen unvollständigen Typen in Zeigerarithmetik

en: invalid use of array indexing on pointer to member
de: ungültige Verwendung von Arrayindizierung bei Zeiger auf Element

en: invalid use of array with unspecified bounds
de: falsche Verwendung eines Arrays mit unbekannten Grenzen

en: invalid use of asm flag output
de: ungültige Verwendung der asm-Schalter-Ausgabe

en: invalid use of attribute %<fallthrough%>
de: ungültige Verwendung des Attributs %<fallthrough%>

en: invalid use of attributes in empty declaration
de: ungültige Verwendung von Attributen in leerer Deklaration

en: invalid use of brace-enclosed initializer list
de: ungültige Verwendung von geschweift geklammerter Initialisierungsliste

en: invalid use of constructor as a template
de: ungültige Verwendung des Konstruktors als Template

en: invalid use of cv-qualified type %qT in parameter declaration
de: ungültige Verwendung von cv-qualifiziertem Typ %qT in Parameterdeklaration

en: invalid use of dependent type %qT
de: ungültige Verwendung des abhängigen Typen %qT

en: invalid use of destructor %qD as a type
de: ungültige Verwendung des Destruktors %qD als Typ

en: invalid use of destructor %qE as a type
de: ungültige Verwendung des Destruktors %qE als Typ

en: invalid use of flexible array member
de: falsche Verwendung eines flexiblen Arrayelements

en: invalid use of implicit conversion on pointer to member
de: ungültige Verwendung impliziter Umwandlung bei Zeiger auf Element

en: invalid use of incomplete type %q#T
de: falsche Verwendung des unvollständigen Typs %q#T

en: invalid use of incomplete typedef %qT
de: falsche Verwendung des unvollständigen typedef %qT

en: invalid use of member %qD (did you forget the %<&%> ?)
de: ungültige Verwendung des Elements %qD (%<&%> vergessen?)

en: invalid use of member %qD in static member function
de: ungültige Verwendung des Elementes %qD in statischer Elementfunktion

en: invalid use of member function %qD (did you forget the %<()%> ?)
de: ungültige Verwendung von Elementfunktion %qD (%<()%> vergessen?)

en: invalid use of method value as argument of Offsetof
de: ungültige Verwendung eines Methodenwerts als Argument von Offsetof

en: invalid use of non-lvalue array
de: ungültige Verwendung eines Nicht-L-Wert-Arrays

en: invalid use of non-static data member %qD
de: ungültige Verwendung des nicht-statischen Datenelementes %qD

en: invalid use of non-static data member %qE
de: ungültige Verwendung des nicht-statischen Datenelements %qE

en: invalid use of non-static member function %qD
de: ungültige Verwendung der nicht-statischen Elementfunktion %qD

en: invalid use of non-static member function of type %qT
de: ungültige Verwendung der nicht-statischen Elementfunktion vom Typ %qT

en: invalid use of pack expansion %qT
de: falsche Verwendung von %<pack expansion%> %qT

en: invalid use of pack expansion expression
de: falsche Verwendung eines Packauflösungs-Ausdruckes

en: invalid use of placeholder %qT
de: ungültige Verwendung des Platzhalters %qT

en: invalid use of pointers to arrays with different qualifiers in ISO C before C2X
de: ungültige Verwendung von Zeigern auf Arrays mit unterschiedlichen Qualifizierern in ISO C vor C2X

en: invalid use of qualified-name %<%D::%D%>
de: ungültige Verwendung des qualifizierten Namens %<%D::%D%>

en: invalid use of qualified-name %<%T::%D%>
de: ungültige Verwendung des qualifizierten Namens %<%T::%D%>

en: invalid use of qualified-name %<::%D%>
de: ungültige Verwendung des qualifizierten Namens %<::%D%>

en: invalid use of register '%s'
de: Ungültige Verwendung von Register »%s«

en: invalid use of structure with flexible array member
de: ungültige Verwendung einer Struktur mit flexiblem Arrayelement

en: invalid use of template template parameter %qT
de: ungültige Verwendung des Parameters %qT für Template-Templateparameter

en: invalid use of template type parameter %qT
de: ungültige Verwendung des Parameters %qT für Templatetyp

en: invalid use of template-id %qD in declaration of primary template
de: ungültige Verwendung der Template-ID %qD in Deklaration des ursprünglichen Templates

en: invalid use of template-name %qE without an argument list
de: ungültige Verwendung des Template-Namens %qE ohne eine Argumentliste

en: invalid use of type
de: ungültige Typ-Verwendung

en: invalid use of type %<void%> in parameter declaration
de: ungültige Verwendung von Typ %<void%> in Parameterdeklaration

en: invalid use of type %qT as a default value for a template template-parameter
de: ungültige Verwendung des Typs %qT als Standardwert für einen Template-Templateparameter

en: invalid use of unary %<*%> on pointer to member
de: ungültige Verwendung des unären %<*%> bei Zeiger auf Element

en: invalid use of undefined type %qT
de: falsche Verwendung des undefinierten Typs %qT

en: invalid use of void expression
de: falsche Verwendung eines void-Ausdruckes

en: invalid use of volatile lvalue inside %<transaction_safe%> function
de: in %<transaction_safe%>-Funktion ist kein volatile lvalue erlaubt

en: invalid use of volatile lvalue inside transaction
de: ungültige Verwendung eines volative lvalue innerhalb einer Transaktion

en: invalid user-defined conversion from %qH to %qI
de: ungültige benutzerdefinierte Umwandlung von %qH in %qI

en: invalid value-initialization of reference type
de: ungültige Wert-Initialisierung von Referenztyp

en: invalid vector comparison resulting type
de: ungültiger Ergebnistyp in Vektorvergleich

en: invalid vector constant
de: ungültige Vektorkonstante

en: invalid vector immediate
de: ungültiger Vektordirektwert

en: invalid vector type for attribute %qE
de: Ungültiger Vektortyp für Attribut %qE

en: invalid vector types in nop conversion
de: ungültige Vektortypen in NOP-Umwandlung

en: invalid version number %qs
de: ungültige Versionsnummer %qs

en: invalid warm function for reset attribute
de: ungültige »warm«-Funktion für »reset«-Attribut

en: invalid zero extract
de: ungültige null-Extraktion

en: inverted slice range
de: umgekehrter Scheibenbereich

en: ipa inline summary is missing in input file
de: IPA-Inline-Zusammenfassung fehlt in Eingabedatei

en: ipa reference summary is missing in ltrans unit
de: IPA-Referenzzusammenfassung fehlt in ltrans-Einheit

en: is hidden by %qs
de: wird von %qs versteckt

en: it is defined as a pointer in different address space in another translation unit
de: er ist in einer anderen Übersetzungseinheit als Zeiger in unterschiedlichem Adressraum definiert

en: it is defined as a pointer to different type in another translation unit
de: er ist in einer anderen Übersetzungseinheit als Zeiger auf einen anderen Typen definiert

en: it must be a pointer-to-member of the form %<&X::Y%>
de: es muss ein Zeiger auf ein Element der Form %<&X::Y%> sein

en: it must be the address of a function with external linkage
de: es muss die Adresse einer Funktion mit externer Bindung sein

en: it must be the name of a function with external linkage
de: es muss der Name einer Funktion mit externer Bindung sein

en: it was later defined here
de: es wurde später hier definiert

en: item in READ
de: Element in READ

en: iterating variable in fast enumeration is not an object
de: Zählvariable in schneller Aufzählung ist kein Objekt

en: iteration %s invokes undefined behavior
de: Durchlauf %s führt zu undefiniertem Verhalten

en: iteration variable %qD should not be firstprivate
de: Schleifenvariable %qD sollte nicht »firstprivate« sein

en: iteration variable %qD should not be reduction
de: Schleifenvariable %qD sollte keine Reduktion sein

en: iteration variable %qE is predetermined linear
de: Iterationsvariable %qE ist vorbestimmt linear

en: iteration variable %qE should be private
de: Schleifenvariable %qE sollte »private« sein

en: iteration variable %qE should not be firstprivate
de: Schleifenvariable %qE sollte nicht »firstprivate« sein

en: iteration variable %qE should not be linear
de: Iterationsvariable %qE sollte nicht »linear« sein

en: iteration variable %qE should not be reduction
de: Schleifenvariable %qE sollte nicht Reduktion sein

en: iterator %qD has %<_Atomic%> qualified type
de: Iterator %qD hat %<_Atomic%>-qualifizierten Typ

en: iterator %qD has const qualified type
de: Iterator %qD hat %<const%>-qualifizierten Typ

en: iterator %qD has neither integral nor pointer type
de: Typ des Iterators %qD ist weder ganzzahlig noch ein Zeiger

en: iterator %qD has zero step
de: Iterator %qD hat Schrittweite 0

en: iterator step with non-integral type
de: Iterator-Schrittweite mit nichtganzzahligem Typ

en: iterator variable
de: Iteratorvariable

en: its dest_idx should be %d, not %d
de: Interner Fehler: its dest_idx should be %d, not %d

en: its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags
de: der Wert kann zwischen Compiler-Versionen oder mit verschiedenen %<-mtune%> oder %<-mcpu%> Flags variieren

en: ivar %qs used by %<@synthesize%> declaration must be an existing ivar
de: von %<@synthesize%>-Deklaration verwendete ivar %qs muss eine existierende ivar sein

en: iwmmxt abi requires an iwmmxt capable cpu
de: iwmmxt ABI erfordert eine iwmmxt-fähige CPU

en: iwmmxt requires an AAPCS compatible ABI for proper operation
de: iwmmxt erfordert ein AAPCS-kompatibles ABI für den richtigen Einsatz

en: jump into scope of identifier with variably modified type
de: in Gültigkeitsbereich des Bezeichners mit variabel modifiziertem Typen springen

en: jump into statement expression
de: Sprung in Anweisungs-Ausdruck

en: jump skips variable initialization
de: Sprung lässt Variableninitialisierung aus

en: jump to case label
de: Sprung zur case-Marke

en: jump to label %qD
de: Sprung zur Marke %qD

en: junk at end of %<#pragma %s%>
de: Ausschuss am Ende von %<#pragma %s%>

en: junk at end of %<#pragma ADDRESS%>
de: Ausschuss am Ende von %<#pragma ADDRESS%>

en: junk at end of %<#pragma CTABLE_ENTRY%>
de: Ausschuss am Ende von %<#pragma CTABLE_ENTRY%>

en: junk at end of %<#pragma GCC memregs%> [0-16]
de: Ausschuss am Ende von %<#pragma GCC memregs%> [0-16]

en: junk at end of %<#pragma GCC visibility%>
de: Ausschuss am Ende von %<#pragma GCC visibility%>

en: junk at end of %<#pragma __nostandard%>
de: Ausschuss am Ende von %<#pragma __nostandard%>

en: junk at end of %<#pragma __standard%>
de: Ausschuss am Ende von %<#pragma __standard%>

en: junk at end of %<#pragma align%>
de: Ausschuss am Ende von %<#pragma align%>

en: junk at end of %<#pragma fini%>
de: Ausschuss am Ende von %<#pragma fini%>

en: junk at end of %<#pragma init%>
de: Ausschuss am Ende von %<#pragma init%>

en: junk at end of %<#pragma longcall%>
de: Ausschuss am Ende von %<#pragma longcall%>

en: junk at end of %<#pragma message%>
de: Ausschuss am Ende von %<#pragma message%>

en: junk at end of %<#pragma ms_struct%>
de: Ausschuss am Ende von %<#pragma ms_struct%>

en: junk at end of %<#pragma options%>
de: Ausschuss am Ende von %<#pragma options%>

en: junk at end of %<#pragma pack%>
de: Ausschuss am Ende von %<#pragma pack%>

en: junk at end of %<#pragma pop_options%>
de: Ausschuss am Ende von %<#pragma pop_options%>

en: junk at end of %<#pragma push_options%>
de: Ausschuss am Ende von %<#pragma push_options%>

en: junk at end of %<#pragma redefine_extname%>
de: Ausschuss am Ende von %<#pragma redefine_extname%>

en: junk at end of %<#pragma reset_options%>
de: Ausschuss am Ende von %<#pragma reset_options%>

en: junk at end of %<#pragma unused%>
de: Ausschuss am Ende von %<#pragma unused%>

en: junk at end of %<#pragma weak%>
de: Ausschuss am Ende von %<#pragma weak%>

en: junk at end of %<#pragma%> ghs endsda
de: Ausschuss am Ende von %<#pragma ghs endsda%>

en: junk at end of %<#pragma%> ghs endtda
de: Ausschuss am Ende von %<#pragma ghs endtda%>

en: junk at end of %<#pragma%> ghs endzda
de: Ausschuss am Ende von %<#pragma ghs endzda%>

en: junk at end of %<#pragma%> ghs interrupt
de: Ausschuss am Ende von %<#pragma ghs interrupt%>

en: junk at end of %<#pragma%> ghs section
de: Ausschuss am Ende von %<#pragma ghs section%>

en: junk at end of %<#pragma%> ghs startsda
de: Ausschuss am Ende von %<#pragma ghs startsda%>

en: junk at end of %<#pragma%> ghs starttda
de: Ausschuss am Ende von %<#pragma ghs starttda%>

en: junk at end of %<#pragma%> ghs startzda
de: Ausschuss am Ende von %<#pragma ghs startzda%>

en: junk at end of '#pragma extern_model'
de: Ausschuss am Ende von »#pragma extern_model«

en: keyword %<export%> is deprecated, and is ignored
de: das Schlüsselwort %<export%> ist veraltet und wird ignoriert

en: keyword %<export%> is enabled with %<-fmodules-ts%>
de: das Schlüsselwort %<export%> wird mit %<-fmodules-ts%> eingeschaltet

en: keyword %<export%> not implemented, and will be ignored
de: Schlüsselwort %<export%> nicht implementiert, und wird ignoriert

en: keyword %<template%> not allowed in class-head-name
de: Schlüsselwort %<template%> nicht innerhalb des Klassenkopfnamens erlaubt

en: keyword %<template%> not allowed in declarator-id
de: Schlüsselwort %<template%> nicht innerhalb der declarator-id erlaubt

en: keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)
de: Schlüsselwort %<typename%> in diesem Kontext nicht erlaubt (eine qualifizierte Elementinitialisierung ist implizit ein Typ)

en: keyword %<typename%> not allowed in this context (the base class is implicitly a type)
de: Schlüsselwort %<typename%> nicht erlaubt in diesem Kontext (die Basisklasse ist implizit ein Typ)

en: keyword %<typename%> not allowed outside of templates
de: Schlüsselwort %<typename%> nicht außerhalb von Templates erlaubt

en: label %q+D declared but not defined
de: Marke %q+D deklariert, aber nicht definiert

en: label %q+D defined but not used
de: Marke %q+D definiert, aber nicht verwendet

en: label %q+D used but not defined
de: Marke %q+D verwendet, aber nicht definiert

en: label %qD defined here
de: Marke %qD hier definiert

en: label %qD has incorrect context in bb %d
de: Interner Fehler: label %qD has incorrect context in bb %d

en: label %qD in the middle of basic block %d
de: Interner Fehler: label %qD in the middle of basic block %d

en: label %qD to block does not match in bb %d
de: Interner Fehler: label %qD to block does not match in bb %d

en: label %qE referenced outside of any function
de: Marke %qE außerhalb einer Funktion referenziert

en: label %s referenced outside of any function
de: die Sprungmarke %s wird außerhalb einer Funktion referenziert

en: label at end of compound statement
de: Marke am Ende einer Verbundanweisung

en: label context is not the current function declaration
de: der Label-Kontext ist nicht die aktuelle Funktionsdeklaration

en: label definition in %<constexpr%> function only available with %<-std=c++2b%> or %<-std=gnu++2b%>
de: Definition einer Sprungmarke innerhalb einer %<constexpr%>-Funktion ist erst ab %<-std=c++2b%> oder %<-std=gnu++2b%> verfügbar

en: lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>
de: Initialisierungen für Lambda-Captures sind nur mit %<-std=c++14%> oder %<-std=gnu++14%> verfügbar

en: lambda capture of %qE is not a constant expression
de: Lambda-Einfangen von %qE ist kein konstanter Ausdruck

en: lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>
de: Lambda-Ausdrücke nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: lambda in local class %q+T cannot capture variables from the enclosing context
de: Lambda in lokaler Klasse %q+T kann Variablen aus dem umschließenden Kontext nicht einfangen

en: lambda parameter %qD previously declared as a capture
de: Lambdaparameter %qD war vorher als Einfänger deklariert

en: lambda templates are only available with %<-std=c++14%> or %<-std=gnu++14%>
de: Lambda-Templates sind nur mit %<-std=c++14%> oder %<-std=gnu++14%> verfügbar

en: lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>
de: Lambda-Templates sind erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: lambda-expression in template parameter type
de: Lambda-Ausdruck in Template-Parameter-Typ

en: lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>
de: Lambda-Ausdruck in Template-Argument ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>
de: Lambda-Ausdruck in nicht evaluiertem Kontext ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: lambda-expression is not a constant expression before C++17
de: Lambda-Ausdruck ist erst ab C++17 ein konstanter Ausdruck

en: lambdas are implicitly %<constexpr%> only in C++17 and later
de: Lambdas sind erst ab C++17 implizit %<constexpr%>

en: lane %wd out of range %wd - %wd
de: Spur %wd ist außerhalb des Wertebereiches %wd bis %wd

en: lane index must be a constant immediate
de: Spurindex muss eine direkt angegebene Konstante sein

en: language %s not recognized
de: Sprache %s nicht erkannt

en: language dialect differs %qs, expected %qs
de: Sprachdialekt ist %qs, erwartet wird jedoch %qs

en: language string %<"%E"%> not recognized
de: Sprachen-Zeichenkette %<"%E"%> nicht erkannt

en: large fixed-point constant implicitly truncated to fixed-point type
de: große Festkommakonstante implizit auf Festkommatypen abgeschnitten

en: large return values not supported with %<-mabi=ti%> option
de: große Rückgabewerte werden mit der Option %<-mabi=ti%> nicht unterstützt

en: last argument must be an immediate
de: das letzte Argument muss ein Immediate sein

en: last argument of %qD is not integer constant between 0 and 3
de: letztes Argument von %qD ist keine Ganzzahlkonstante zwischen 0 und 3

en: last register name %s must be an odd register
de: Name des letzten Registers »%s« muss ein ungerades Register sein

en: ld returned %d exit status
de: ld gab %d als Ende-Status zurück

en: left argument must be a slice
de: linkes Argument muss eine Scheibe sein

en: left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT
de: linker Operand von %<->*%> muss Zeiger auf Klasse sein, ist aber ein Zeiger auf Element des Typs %qT

en: left operand of comma operator cannot resolve address of overloaded function
de: linker Operand des Komma-Operators kann die Adresse der überladenen Funktion nicht auflösen

en: left operand of comma operator has no effect
de: linker Operand des Komma-Operators hat keinen Effekt

en: left operand of comma operator is a reference, not call, to function %qE
de: linker Operand des Komma-Operators ist eine Referenz, kein Aufruf, zur Funktion %qE

en: left operand of shift expression %q+E is negative
de: linker Operand des Schiebeausdrucks %q+E ist negativ

en: left precision
de: linke Präzision

en: left precision in strfmon format
de: linke Präzision im strfmon-Format

en: left shift count >= width of type
de: Links-Schiebe-Weite >= Breite des Typs

en: left shift count >= width of vector element
de: Links-Schiebe-Weite >= Breite des Vektorelements

en: left shift count is negative
de: Links-Schiebe-Weite ist negativ

en: left-hand operand of comma expression has no effect
de: linker Operand des Komma-Ausdrucks hat keinen Effekt

en: left-hand side of assignment might be a candidate for a format attribute
de: linke Seite der Zuweisung könnte ein Kandidat für ein Formatattribut sein

en: len larger than cap
de: Länge größer als Kapazität

en: length %qE above array section size in %qs clause
de: Länge %qE geht über Abschnittsgröße in %qs-Klausel hinaus

en: length %qE of array section does not have integral type
de: Länge %qE des Arrayabschnitts muss Ganzzahltyp haben

en: length computed here
de: Länge wird hier berechnet

en: length modifier
de: Längenmodifizierer

en: length modifier in printf format
de: Längenmodifizierer im printf-Format

en: length modifier in scanf format
de: Längenmodifizierer im scanf-Format

en: length modifier in strfmon format
de: Längenmodifizierer im strfmon-Format

en: length required when allocating a slice
de: Bei Reservierung einer Scheibe wird Länge benötigt

en: letter %c was found & insn was not CONST_INT
de: Buchstabe %c gefunden und Befehl war nicht CONST_INT

en: libraries: %s
de: Bibliotheken: %s

en: library function %q#D redeclared as non-function %q#D
de: Bibliotheksfunktion %q#D als Nicht-Funktion %q#D redeklariert

en: library lib%s not found
de: Bibliothek lib%s nicht gefunden

en: limit is %wu bytes, but argument is %s
de: Grenze ist %wu Bytes, Argument hat jedoch %s Bytes

en: limit is %wu bytes, but argument may be as large as %s
de: Grenze ist %wu Bytes, Argument hat jedoch bis zu %s Bytes

en: linear clause applied to non-integral non-pointer variable with %qT type
de: »linear«-Klausel wird auf Variable vom Typ %qT angewandt, die weder ganzzahlig noch Zeiger ist

en: linear clause applied to non-integral non-pointer variable with type %qT
de: »linear«-Klausel auf Variable vom Typ %qT angewendet, die weder Ganzzahl noch Zeiger ist

en: linear clause with %qs modifier applied to non-reference variable with %qT type
de: »linear«-Klausel mit Modifizierer %qs wird auf Nicht-Referenz-Variable mit Typ %qT angewandt

en: linear step expression must be integral
de: Ausdruck für »linear«-Schrittweite muss ganzzahlig sein

en: list-initializer for non-class type must not be parenthesized
de: Listeninitialisierung für Nicht-Klassentyp darf nicht geklammert sein

en: listing the stack pointer register %qs in a clobber list is deprecated
de: Es ist veraltet, das Stapelzeiger-Register %qs in einer Überschreibungsliste anzugeben

en: literal operator %q#D conflicts with raw literal operator
de: Literaler Operator %q#D steht mit rohem Literaloperator in Konflikt

en: literal operator suffixes not preceded by %<_%> are reserved for future standardization
de: Literale Operator-Suffixe ohne vorangehendes %<_%> sind für zukünftige Standardisierungen reserviert

en: literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>
de: literales Operatortemplate %qD hat ungültige Parameterliste; Template für Nicht-Typ Argumentpack %<<char…>%> erwartet

en: literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type
de: literales Operatortemplate %qD hat ungültige Parameterliste; nicht-Typ Templateargumentpack %<<char…>%> oder einzelner Nicht-Typ-Parameter von Klassentyp erwartet

en: literal operator with C linkage
de: literaler Operator mit C-Bindung

en: live patching is not supported with LTO
de: Livepatchen in Kombination mit LTO wird nicht unterstützt

en: lo_sum not of register
de: lo_sum nicht von einem Register

en: local class %q#T shall not have static data member %q#D
de: lokale Klasse %q#T darf kein statisches Datenelement %q#D haben

en: local declaration of %qE hides instance variable
de: lokale Deklaration von %qE verdeckt Instanzvariable

en: local label %qE conflicts with existing label
de: lokale Sprungmarke %qE steht in Konflikt mit bestehender Sprungmarke

en: local member %q#D declared here
de: lokales Element %q#D ist hier deklariert

en: local method %q#D declared here
de: lokale Methode %q#D ist hier deklariert

en: local symbols must be defined
de: Interner Fehler: local symbols must be defined

en: local variable %qD may not appear in this context
de: lokale Variable %qD darf in diesem Kontext nicht auftauchen

en: local variable memory requirements exceed capacity
de: Lokale Variablenspeicheranforderungen überschreiten Kapazität

en: location of OpenACC %<kernels%>
de: Stelle des OpenACC-%<kernels%>

en: location of the previous clause in the same loop nest
de: Stelle der vorherigen Klausel in derselben Schleifenschachtelung

en: location of the previous reduction for %qE
de: Stelle der vorherigen Reduktion für %qE

en: logical %<and%> applied to non-boolean constant
de: logisches %<und%> auf nicht-boolesche Konstante angewendet

en: logical %<and%> of equal expressions
de: logisches %<und%> von gleichen Ausdrücken

en: logical %<and%> of mutually exclusive tests is always false
de: logisches %<und%> bei sich gegenseitig ausschließenden Tests ist immer »falsch«

en: logical %<or%> applied to non-boolean constant
de: Logisches %<or%> auf Nicht-Boolesche Konstante angewendet

en: logical %<or%> of collectively exhaustive tests is always true
de: logisches %<oder%> bei gemeinsam erschöpfenden Tests ist immer »wahr«

en: logical %<or%> of equal expressions
de: logisches %<oder%> von gleichen Ausdrücken

en: logical not is only applied to the left hand side of comparison
de: logisches Nicht bezieht sich nur auf die linke Seite des Vergleichs

en: lookup of %qT in %qT is ambiguous
de: Nachschlagen von %qT in %qT ist nicht eindeutig

en: loop %d%'s header does not belong directly to it
de: Interner Fehler: loop %d%'s header does not belong directly to it

en: loop %d%'s header does not have exactly 2 entries
de: Interner Fehler: loop %d%'s header does not have exactly 2 entries

en: loop %d%'s header is not a loop header
de: Interner Fehler: loop %d%'s header is not a loop header

en: loop %d%'s latch does not belong directly to it
de: Interner Fehler: loop %d%'s latch does not belong directly to it

en: loop %d%'s latch does not have an edge to its header
de: Interner Fehler: loop %d%'s latch does not have an edge to its header

en: loop %d%'s latch does not have exactly 1 successor
de: Interner Fehler: loop %d%'s latch does not have exactly 1 successor

en: loop %d%'s latch does not have header as successor
de: Interner Fehler: loop %d%'s latch does not have header as successor

en: loop %d%'s latch is marked as part of irreducible region
de: Interner Fehler: loop %d%'s latch is marked as part of irreducible region

en: loop %d%'s latch is not dominated by its header
de: Interner Fehler: loop %d%'s latch is not dominated by its header

en: loop %d%'s number of iterations %qE references the released SSA name %qE
de: die Anzahl der Iterationen der Schleife %d %qE verweist auf den freigegebenen SSA-Namen %qE

en: loop uses OpenACC parallelism disallowed by containing routine
de: Schleife verwendet OpenACC-Parallelismus, der von der umgebenden Routine verboten wurde

en: loop variable %qD creates a copy from type %qT
de: Schleifenvariable %qD erzeugt eine Kopie vom Typ %qT

en: loop variable %qD of type %qT binds to a temporary constructed from type %qT
de: Schleifenvariable %qD vom Typ %qT bindet an temporäres Objekt, das aus dem Typen %qT konstruiert wurde

en: loop verification on loop tree that needs fixup
de: Interner Fehler: loop verification on loop tree that needs fixup

en: loop with header %d marked for removal
de: Interner Fehler: loop with header %d marked for removal

en: loop with header %d not in loop tree
de: Interner Fehler: loop with header %d not in loop tree

en: looser exception specification on overriding virtual function %q+#F
de: lockerere Ausnahmespezifikation in der übersteuernden virtuellen Funktion %q+#F

en: low bound %qE above array section size in %qs clause
de: untere Grenze %qE geht über Abschnittsgröße in %qs-Klausel hinaus

en: low bound %qE of array section does not have integral type
de: Untere Grenze %qE des Arrayabschnitts muss Ganzzahltyp haben

en: lower value in case label range less than minimum value for type
de: Unterer Wert in case-Marken-Bereich ist kleiner als der Minimalwert des Typs

en: lseek failed while reading export data
de: lseek beim Lesen von Exportdaten gescheitert

en: lvalue required as decrement operand
de: Als Verringerungsoperand wird L-Wert erfordert

en: lvalue required as increment operand
de: Als Erhöhungsoperand wird L-Wert erfordert

en: lvalue required as left operand of assignment
de: Als linker Operand einer Zuweisung wird L-Wert erfordert

en: lvalue required as unary %<&%> operand
de: Als Operand für unäres %<&%> wird L-Wert erfordert

en: lvalue required in %<asm%> statement
de: die %<asm%>-Anweisung erfordert einen L-Wert

en: lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT
de: Umwandlung lvalue-in-rvalue eines volatile-lvalue %qE mit Typ %qT

en: machine independent builtin code out of range
de: maschinenunabhängiger eingebauter Code außerhalb des Wertebereiches

en: macro debug output may be incomplete with modules
de: Debug-Ausgabe von Makros kann bei Modulen unvollständig sein

en: macro definitions of %qE corrupted
de: Makrodefinitionen von %qE sind kaputt

en: macro expands to multiple statements
de: Makro expandiert zu mehreren Anweisungen

en: macro name missing after %qs
de: Makroname fehlt hinter %qs

en: main variant is not defined
de: Interner Compilerfehler: main variant is not defined

en: make_generic(): Cannot find generic symbol %qs
de: Interner Fehler: make_generic(): Cannot find generic symbol %qs

en: making multiple clones of %qD
de: mehrfache Kopien von %qD werden erzeugt

en: malformed %<#pragma %s%>, ignored
de: falsch geformtes %<#pragma %s%>, ignoriert

en: malformed %<#pragma %s%>, ignoring
de: falsch geformtes %<#pragma %s%>, wird ignoriert

en: malformed %<#pragma ADDRESS%> variable address
de: Falsch geformte Variablenadresse in %<#pragma ADDRESS%>

en: malformed %<#pragma CTABLE_ENTRY%> variable address
de: falsch geformte Variablenadresse bei %<#pragma CTABLE_ENTRY%>

en: malformed %<#pragma GCC pch_preprocess%>
de: falsch geformtes %<#pragma GCC pch_preprocess%>

en: malformed %<#pragma GCC visibility push%>
de: falsch geformtes %<#pragma GCC visibility push%>

en: malformed %<#pragma __extern_prefix%>, ignoring
de: falsch geformtes %<#pragma __extern_prefix%>, wird ignoriert

en: malformed %<#pragma align%>
de: Falsch geformtes %<#pragma align%>

en: malformed %<#pragma align%>, ignoring
de: Falsch geformtes %<#pragma align%> - ignoriert

en: malformed %<#pragma builtin%>
de: Falsch geformtes %<#pragma builtin%>

en: malformed %<#pragma extern_model%>, ignoring
de: Falsch geformtes %<#pragma extern_model%>, ignoriert

en: malformed %<#pragma fini%>
de: Falsch geformtes %<#pragma fini%>

en: malformed %<#pragma fini%>, ignoring
de: Falsch geformtes %<#pragma fini%>, ignoriert

en: malformed %<#pragma init%>
de: Falsch geformtes %<#pragma init%>

en: malformed %<#pragma init%>, ignoring
de: Falsch geformtes %<#pragma init%>', ignoriert

en: malformed %<#pragma member_alignment%>
de: Falsch geformtes %<#pragma member_alignment%>

en: malformed %<#pragma member_alignment%>, ignoring
de: Falsch geformtes %<#pragma member_alignment%>, wird ignoriert

en: malformed %<#pragma message%>, ignored
de: falsch geformtes %<#pragma message%>, ignoriert

en: malformed %<#pragma ms_struct {on|off|reset}%>, ignoring
de: Falsch geformtes %<#pragma ms_struct {on|off|reset}%>, ignoriert

en: malformed %<#pragma ms_struct%>, ignoring
de: Falsch geformtes %<#pragma ms_struct%>, wird ignoriert

en: malformed %<#pragma options align={mac68k|power|reset}%>, ignoring
de: Falsch geformtes %<#pragma options align={mac68k|power|reset}%>, wird ignoriert

en: malformed %<#pragma options%>, ignoring
de: Falsch geformtes %<#pragma options%>, wird ignoriert

en: malformed %<#pragma pack%> - ignored
de: falsch geformtes %<#pragma pack%> - ignoriert

en: malformed %<#pragma pack(pop[, id])%> - ignored
de: falsch geformtes %<#pragma pack(pop[, id])%> - ignoriert

en: malformed %<#pragma pack(push[, id][, <n>])%> - ignored
de: falsch geformtes %<#pragma pack(push[, id][, <n>])%> - ignoriert

en: malformed %<#pragma redefine_extname%>, ignored
de: falsch geformtes %<#pragma redefine_extname%>, wird ignoriert

en: malformed %<#pragma weak%>, ignored
de: falsch geformtes %<#pragma weak%>, wird ignoriert

en: malformed %<#pragma%> ghs section
de: falsch geformtes %<#pragma ghs section%>

en: malformed %<COLLECT_GCC_OPTIONS%>
de: ungültige %<COLLECT_GCC_OPTIONS%>

en: malformed %<target("%s")%> pragma or attribute
de: falsch geformtes Pragma oder Attribut %<target("%s")%>

en: malformed %<target()%> pragma or attribute
de: falsch geformtes Pragma oder Attribut %<target()%>

en: malformed option %<-fplugin-arg-%s%>: missing %<-<key>[=<value>]%>
de: falsche Option %<-fplugin-arg-%s%>: fehlendes %<-<Schlüssel>[=<Wert>]%>

en: malformed ptx file
de: kaputte PTX-Datei

en: malformed spec function arguments
de: schlechte Argumente für Spezifikationsfunktion

en: malformed spec function name
de: schlechter Name für Spezifikationsfunktion

en: malloc attribute should be used for a function that returns a pointer
de: Attribut %<malloc%> ist nur an Funktionen sinnvoll, die einen Zeiger zurückgeben

en: mangled name for %qD will change in C++17 because the exception specification is part of a function type
de: gemangelter Name für %qD wird sich ich C++17 ändern, da die Exceptionangabe Teil des Funktionstyps ist

en: mangling %<__underlying_type%>
de: mangling %<__unterliegender_Typ%>

en: mangling %<typeof%>, use %<decltype%> instead
de: mangling %<typeof%>, verwenden Sie stattdessen %<decltype%>

en: mangling %C
de: %C wird gemangelt

en: mangling of %q#D as %qE conflicts with a previous mangle
de: Mangeln von %q#D als %qE steht mit einer vorherigen Mangelung in Konflikt

en: mangling unknown fixed point type
de: unbekannter Festkommatyp wird vernichtet

en: map can only be compared to nil
de: Abbildung kann nur mit nil verglichen werden

en: mapper died by signal %s
de: Mapper wurde mit Signal %s beendet

en: mapper exit status %d
de: Mapper mit Status %d beendet

en: mapping field %qE of variable length structure
de: Feld %qE der Struktur variabler Länger wird zugeordnet

en: mask must be an immediate
de: Maske muss »immediate« sein

en: matching constraint does not allow a register
de: dazu passende Bedingung erlaubt kein Register

en: matching constraint not valid in output operand
de: dazu passende Bedingung in Ausgabeoperanden ungültig

en: matching constraint references invalid operand number
de: dazu passende Bedingung referenziert ungültige Operandennummer

en: maximal number of LTO partitions streamed in parallel.
de: Höchstzahl der LTO-Partitionen, die parallel gestreamt werden.

en: maximum limit of %d namespaces searched for %qE
de: obere Grenze von %d Namensräumen für %qE durchsucht

en: maximum number of LRA assignment passes is achieved (%d)
de: Höchstzahl der Durchläufe für LRA-Bedingungen ist erreicht (%d)

en: maximum number of generated reload insns per insn achieved (%d)
de: Höchstzahl der erzeugten Neuladebefehle pro Befehl ist erreicht (%d)

en: may access %E byte in a region of size %E
de: Code greift möglicherweise auf %E Byte in einer Region der Größe %E zu

en: may access %E bytes in a region of size %E
de: Code greift möglicherweise auf %E Bytes in einer Region der Größe %E zu

en: may access %E or more bytes in a region of size %E
de: Code greift möglicherweise auf %E oder mehr Bytes in einer Region der Größe %E zu

en: may access between %E and %E bytes in a region of size %E
de: greift möglicherweise auf zwischen %E und %E Bytes in einer Region der Größe %E zu

en: may not use both -EB and -EL
de: »-EB« und »-EL« dürfen nicht gleichzeitig verwendet werden

en: may not use both -m32 and -m64
de: »-m32« und »-m64« dürfen nicht zusammen angegeben werden

en: may read %E byte from a region of size %E
de: Code liest möglicherweise %E Byte aus einer Region der Größe %E

en: may read %E bytes from a region of size %E
de: Code liest möglicherweise %E Bytes aus einer Region der Größe %E

en: may read %E or more bytes from a region of size %E
de: Code liest möglicherweise %E oder mehr Bytes aus einer Region der Größe %E

en: may read between %E and %E bytes from a region of size %E
de: Code liest möglicherweise zwischen %E und %E Bytes aus einer Region der Größe %E

en: may write %E byte into a region of size %E
de: Code schreibt möglicherweise %E Byte in eine Region der Größe %E

en: may write %E bytes into a region of size %E
de: Code schreibt %E Bytes in eine Region der Größe %E

en: may write %E or more bytes into a region of size %E
de: Code schreibt %E oder mehr Bytes in eine Region der Größe %E

en: may write between %E and %E bytes into a region of size %E
de: Code schreibt möglicherweise zwischen %E und %E Bytes in eine Region der Größe %E

en: mduc registers only saved for G13 target
de: mdoc-Register werden nur für G13-Ziel gesichert

en: media functions are not available unless %<-mmedia%> is used
de: Medienfunktionen sind nur mit %<-mmedia%> verfügbar

en: mem-initializer for %qD follows constructor delegation
de: Speicherinitialisierung für %qD folgt Konstruktordelegation

en: member %q+#D with constructor not allowed in anonymous aggregate
de: Element %q+#D mit Konstruktor in anonymem Aggregat nicht erlaubt

en: member %q+#D with constructor not allowed in union
de: Element %q+#D mit Konstruktor nicht erlaubt in Union

en: member %q+#D with copy assignment operator not allowed in anonymous aggregate
de: Element %q+#D mit Zuweisungsoperator ist in anonymem Aggregt nicht erlaubt

en: member %q+#D with copy assignment operator not allowed in union
de: Element %q+#D mit Copy-Zuweisungsoperator ist nicht erlaubt in Union

en: member %q+#D with destructor not allowed in anonymous aggregate
de: Element %q+#D mit Destruktor in anonymem Aggregat nicht erlaubt

en: member %q+#D with destructor not allowed in union
de: Element %q+#D mit Destruktor nicht erlaubt in Union

en: member %q+D cannot be declared as a %<mutable%> reference
de: Element %q+D darf nicht als %<mutable%>-Referenz deklariert sein

en: member %q+D cannot be declared both %<const%> and %<mutable%>
de: Element %q+D darf nicht gleichzeitig als %<const%> und %<mutable%> deklariert sein

en: member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>
de: Element %qD kann erst mit %<-std=c++20%> oder %<-std=gnu++20%> gleichzeitig %<virtual%> und %<constexpr%> sein

en: member %qD cannot be declared both %<virtual%> and %<static%>
de: Element %qD kann nicht gleichzeitig %<virtual%> und %<static%> sein

en: member %qD declared as friend before type %qT defined
de: Element %qD als »friend« deklariert, bevor Typ %qT definiert wurde

en: member %qD in read-only object used as %<asm%> output
de: Element %qD in schreibgeschütztem Objekt als %<asm%>-Ausgabe verwendet

en: member %qD is uninitialized reference
de: Element %qD ist nicht initialisierte Referenz

en: member %qD is used uninitialized
de: Mitglied %qD ist nicht initialisiert, wird aber benutzt

en: member %qD must be initialized by mem-initializer in %<constexpr%> constructor
de: Element %qD in %<constexpr%> muss von »mem-initializer« initialisiert werden

en: member %qD with uninitialized reference fields
de: Element %qD mit nicht initialisierten Feldern

en: member functions are implicitly friends of their class
de: Elementfunktionen sind implizite »friends« ihrer Klasse

en: member template %qD may not have virt-specifiers
de: Element-Template %qD darf keine virt-Spezifizierer haben

en: member variables cannot have SVE type %qT
de: Membervariablen können nicht vom SVE-Typ %qT sein

en: members of an explicitly specialized class are defined without a template header
de: Elemente einer explizit spezialisierten Klasse sind ohne Templateheader definiert

en: memory allocation failed while reading export data
de: Speicherreservierung beim Lesen der Export-Daten gescheitert

en: memory input %d is not directly addressable
de: Speichereingabe %d ist nicht direkt adressierbar

en: memory layout mismatch
de: unverträgliches Speicherlayout

en: memory reference expected for 'S' output modifier
de: Speicherreferenz für Ausgabemodifizierer »S« erwartet

en: method %<%c%E%> declared %<@optional%> and %<@required%> at the same time
de: Methode %<%c%E%> gleichzeitig als %<@optional%> und %<@required%> deklariert

en: method %s%s%s is marked go:nointerface
de: Methode %s%s%s ist als go:nointerface gekennzeichnet

en: method %s%s%s requires a pointer receiver
de: Methode %s%s%s erfordert einen Zeigerempfänger

en: method argument attributes are not available in Objective-C 1.0
de: in Objective-C 1.0 gibt es keine Attribute für Methodenargumente

en: method attributes are not available in Objective-C 1.0
de: in Objective-C 1.0 gibt es keine Methodenattribute

en: method attributes cannot be specified in @implementation context
de: Methodenattribute können nicht im @implementation-Kontext angegeben werden

en: method attributes must be specified at the end
de: Methodenattribute müssen am Ende angegeben werden

en: method attributes must be specified at the end only
de: Methodenattribute dürfen nur am Ende angegeben werden

en: method declaration not in @interface context
de: Methodendeklaration nicht im @interface-Kontext

en: method declared %qE overriding %qE method
de: als %qE deklarierte Methode überschreibt Methode %qE

en: method definition for %<%c%E%> not found
de: Methodendefinition für %<%c%E%> nicht gefunden

en: method definition not in @implementation context
de: Methodendefinition nicht im @implementation-Kontext

en: method overrides both %<transaction_pure%> and %qE methods
de: Methode überschreibt Methoden %<transaction_pure%> und %qE

en: method possibly missing a [super dealloc] call
de: In Methode fehlt möglicherweise ein [super dealloc]-Aufruf

en: method type does not match object type
de: Methodentyp passt nicht zum Objekttyp

en: min partition size cannot be greater than max partition size
de: Mindestgröße der Partition darf nicht größer als Höchstgröße der Partition sein

en: mips16 function profiling
de: Profiling für mips16-Funktionen

en: mismatch between declaration %qE size (%wd) and its initializer size (%wd)
de: Unstimmigkeit zwischen der Größe der Deklaration %qE (%wd) und der Größe ihres Initialisierers (%wd)

en: mismatch in argument %u type of built-in function %qD; expected %qT
de: Unstimmigkeit im Typ von Argument %u der eingebauten Funktion %qD; erwartet wurde %qT

en: mismatch in bound %Z of argument %u declared as %s | mismatch in bounds %Z of argument %u declared as %s
de[0]: Abweichung in Grenze %Z von Argument %u, deklariert als %s
de[1]: Abweichung in Grenzen %Z von Argument %u, deklariert als %s

en: mismatch in number of arguments for builtin %qF. Expected: %d got %d
de: Konflikt in Anzahl der Argumente für eingebautes %qF. %d erwartet, %d bekommen

en: mismatch in return type of built-in function %qD; expected %qT
de: Unstimmigkeit im Rückgabetyp der eingebauten Funktion %qD; erwartet wurde %qT

en: mismatched argument pack lengths while expanding %qE
de: Argumentpacklängen passen nicht bei Expansion von %qE

en: mismatched argument pack lengths while expanding %qT
de: Argumentpacklängen passen nicht bei Expansion von %qT

en: mismatched declarations during linktime optimization
de: Unpassende Deklarationen während Linkzeit-Optimierung

en: mismatched operator in fold-expression
de: unpassender Operator in Faltungsausdruck

en: mismatching comparison operand types
de: Vergleichsoperandentypen passen nicht

en: mismatching definition
de: abweichende Definition

en: mismatching parens
de: unpassende Klammern

en: misplaced %<@%D%> Objective-C++ construct
de: unpassendes Objective-C++-Konstrukt %<@%D%>

en: missing $ operand number in format
de: fehlende $-Operandennummer im Format

en: missing %<(%> after %<#pragma GCC visibility push%> - ignored
de: %<(%> hinter %<#pragma GCC visibility push%> fehlt - ignoriert

en: missing %<(%> after %<#pragma pack%> - ignored
de: fehlendes %<(%> hinter %<#pragma pack%> - ignoriert

en: missing %<(%> after %<#pragma unused%>, ignoring
de: Fehlendes %<(%> hinter %<#pragma unused%>, wird ignoriert

en: missing %<)%> after %<#pragma unused%>, ignoring
de: Fehlendes %<)%> hinter %<#pragma unused%>, wird ignoriert

en: missing %<PHI%> def
de: fehlende %<PHI%>-Definition

en: missing %<big-endian%>, %<little-endian%>, or %<default%> after %<#pragma scalar_storage_order%>
de: fehlendes %<big-endian%>, %<little-endian%> oder %<default%> hinter %<#pragma scalar_storage_order%>

en: missing %<error%>, %<warning%>, %<ignored%>, %<push%>, %<pop%>, or %<ignored_attributes%> after %<#pragma GCC diagnostic%>
de: fehlendes %<error%>, %<warning%>, %<ignored%>, %<push%>, %<pop%>, oder %<ignored_attributes%> nach %<#pragma GCC diagnostic%>

en: missing %<target%> attribute for multi-versioned %qD
de: Attribut %<target%> fehlt für multiversioniertes %qD

en: missing %qs clause when applying %<%s%> to %qD, which has already been marked with an OpenACC 'routine' directive
de: fehlende %qs-Klausel bei Anwendung von %<%s%> auf %qD, die bereits mit einer OpenACC-»routine«-Direktive markiert wurde

en: missing REG_EH_REGION note at the end of bb %i
de: Interner Fehler: missing REG_EH_REGION note at the end of bb %i

en: missing additional %<requires%> to start a requires-expression
de: Fehlendes zusätzliches %<requries%>, um eine requires-expression zu beginnen

en: missing arch name in %<-march=%s%>
de: fehlender Architekturname in %<-march=%s%>

en: missing argument for %<-mbranch-protection=%>
de: fehlendes Argument für %<-mbranch-protection=%>

en: missing argument to %<#pragma GCC diagnostic ignored_attributes%>
de: Argument für %<#pragma GCC diagnostic ignored_attributes%> fehlt

en: missing argument to %<target("branch-protection=")%> pragma or attribute
de: fehlendes Argument für Pragma oder Attribut %<target("branch-protection=")%>

en: missing argument to %qs
de: fehlendes Argument für %qs

en: missing attribute name after %<#pragma GCC diagnostic ignored_attributes%>
de: Attributname hinter %<#pragma GCC diagnostic ignored_attributes%> fehlt

en: missing barrier after block %i
de: Interner Fehler: missing barrier after block %i

en: missing braces around initializer
de: geschweifte Klammern fehlen um Initialisierung

en: missing braces around initializer for %qT
de: geschweifte Klammern fehlen um Initialisierung für %qT

en: missing callgraph edge for call stmt:
de: Interner Fehler: missing callgraph edge for call stmt:

en: missing close brace for named operand
de: schließende geschweifte Klammer für benannten Operanden fehlt

en: missing close paren
de: Fehlende schließende Klammer

en: missing collection in fast enumeration
de: die Sammlung in schneller Aufzählung fehlt

en: missing controlling predicate
de: Steuerprädikat fehlt

en: missing cpu name in %<-mcpu=%s%>
de: fehlender CPU-Name in %<-mcpu=%s%>

en: missing cpu name in %<-mtune=%s%>
de: fehlender CPU-Name in %<-mtune=%s%>

en: missing dash
de: fehlender Bindestrich

en: missing definition
de: fehlende Definition

en: missing device or architecture after %qs
de: fehlendes Gerät oder Architektur hinter %qs

en: missing edge %i->%i
de: Interner Fehler: missing edge %i->%i

en: missing filename after %qs
de: fehlender Dateiname hinter %qs

en: missing fill character at end of strfmon format
de: fehlendes Füllzeichen am Ende des strfmon-Formates

en: missing header name
de: fehlender Headername

en: missing increment expression
de: Erhöhungsausdruck fehlt

en: missing indirect call in speculative call sequence
de: fehlender indirekter Aufruf in der Folge der spekulativen Aufrufe

en: missing initializer for field %qD of %qT
de: fehlende Initialisierung für Feld %qD von %qT fehlt

en: missing initializer for member %qD
de: Initialisierung für Element %qD fehlt

en: missing loop condition in loop with %<GCC ivdep%> pragma
de: fehlende Schleifenbedingung in Schleife mit %<GCC ivdep%>-Pragma

en: missing loop condition in loop with %<GCC unroll%> pragma
de: fehlende Schleifenbedingung in Schleife mit %<GCC unroll%>-Pragma

en: missing makefile target after %qs
de: fehlendes Makefile-Ziel hinter %qs

en: missing mapper
de: fehlende Zuordnung

en: missing method %s%s%s
de: fehlende Methode %s%s%s

en: missing module name
de: fehlender Modulname

en: missing name in %<target("arch=")%> pragma or attribute
de: fehlender Name für Pragma oder Attribut %<target("arch=")%>

en: missing name in %<target("cpu=")%> pragma or attribute
de: fehlender Name für Pragma oder Attribut %<target("cpu=")%>

en: missing number
de: Fehlende Zahl

en: missing open paren
de: öffnende Klammer fehlt

en: missing operand
de: fehlender Operand

en: missing option after %<#pragma GCC diagnostic%> kind
de: Option hinter %<#pragma GCC diagnostic%>-Variante fehlt

en: missing or corrupt object.d
de: fehlende oder beschädigte object.d

en: missing origin for a node in a nested list
de: fehlender Ursprung für einen Knoten in einer verschachtelten Liste

en: missing path after %qs
de: fehlender Pfad hinter %qs

en: missing primary template attribute %s
de: fehlendes primäres Templateattribut %s

en: missing primary template attributes %s
de: fehlende primäre Templateattribute %s

en: missing property attribute
de: Eigenschaftsattribut fehlt

en: missing resolution data for %s
de: fehlende Auflösungsdaten für %s

en: missing sentinel in function call
de: Wächter in Funktionsaufruf fehlt

en: missing template arguments
de: fehlende Templateargumente

en: missing template arguments after %qT
de: fehlende Templateargumente nach %qT

en: missing terminating %c character
de: fehlendes abschließendes Zeichen %c

en: missing type-name in typedef-declaration
de: fehlender Typname in typedef-Deklaration

en: missing value in %<target()%> pragma or attribute
de: fehlender Wert für Pragma oder Attribut %<target()%>

en: misspelled term %<%.*s%> in format; use %<%s%s%> instead
de: falsch geschriebener Begriff %<%.*s%> im Format; verwenden Sie stattdessen %<%s%s%>

en: mixing OpenMP directives with attribute and pragma syntax on the same declaration
de: Vermischung von OpenMP-Direktiven mit Attribut- und Pragma-Syntax in derselben Deklaration

en: mixing OpenMP directives with attribute and pragma syntax on the same statement
de: Vermischung von OpenMP-Direktiven mit Attribut- und Pragma-Syntax in ein und derselben Anweisung

en: mixing declarations and function-definitions is forbidden
de: Vermischung von Deklarationen und Funktionsdefinitionen ist verboten

en: mixing different types of symbol in same comdat groups is not supported
de: Interner Fehler: mixing different types of symbol in same comdat groups is not supported

en: mode %qs applied to inappropriate type
de: Modus %qs auf unpassenden Typen angewendet

en: mode size of non-integral result does not match field size of %qs
de: Betriebsart-Größe des nicht-ganzzahligen Ergebnisses passt nicht zur Feldgröße von %qs

en: modification of %qE is not a constant expression
de: Modifikation von %qE ist kein konstanter Ausdruck

en: modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs
de: Modifizierer sollte an %<simd%>- oder %<for%>-Konstrukten nicht in %<linear%>-Klausel angegeben werden

en: modifying a const object %qE is not allowed in a constant expression
de: in einem konstanten Ausdruck ist es nicht erlaubt, das %<const%>-Objekt %qE zu verändern

en: module %qs CRC mismatch
de: CRC-Fehler in Modul %qs

en: module %qs declared here
de: das Modul %qs ist hier deklariert

en: module %qs expected, header module found
de: Modul %qs erwartet, Headermodul gefunden

en: module %qs found
de: Modul %qs gefunden

en: module %qs imported here
de: das Modul %qs wurde hier importiert

en: module already declared
de: das Modul wurde bereits deklariert

en: module already imported
de: das Modul wurde bereits importiert

en: module contains OpenMP, use %<-fopenmp%> to enable
de: Modul enthält OpenMP, verwenden Sie %<-fopenmp%>, um es einzuschalten

en: module dependencies require preprocessing
de: Modulabhängigkeiten erfordern Vorverarbeitung

en: module nature in USE statement at %C
de: Modul-Eigenschaft in USE-Anweisung bei %C

en: module-declaration not permitted in header-unit
de: %<module-declaration%> ist innerhalb von %<header-unit%> nicht erlaubt

en: module-declaration only permitted as first declaration, or ending a global module fragment
de: Modul-Deklaration ist nur als erste Deklaration erlaubt, oder wenn sie das global-module-fragment beendet

en: more than %d operands in %<asm%>
de: mehr als %d Operanden in %<asm%>

en: more than one %<atomic_default_mem_order%> clause in a single compilation unit
de: mehr als eine %<atomic_default_mem_order%>-Klausel in einer einzigen Übersetzungseinheit

en: more than one %<depend%> clause with %<source%> modifier on an %<ordered%> construct
de: mehr als eine %<depend%>-Klausel mit %<source%>-Modifizierer an einem %<ordered%>-Konstrukt

en: more than one 'crtl' directive
de: mehr als eine »crtl«-Direktiven

en: more than one access specifier in base-specifier
de: mehr als ein Zugriff in Basisspezifikation angegeben

en: more than one locator in %<depend%> clause on %<depobj%> construct
de: mehr als eine Ortsangabe in %<depend%>-Klausel in einem %<depobj%>-Konstrukt

en: moving a local object in a return statement prevents copy elision
de: das Verschieben eines lokalen Objekts in einer return-Anweisung verhindert das Einsparen der Kopie

en: mpfr not configured to handle all floating modes
de: mpfr ist nicht so konfiguriert, dass alle Gleitkommamodi verarbeitet werden können

en: multi-source compilation not implemented for C++
de: Compilieren von mehreren Quellen ist für C++ nicht implementiert

en: multidimensional array must have bounds for all dimensions except the first
de: multidimensionales Feld muss für alle Dimensionen außer der ersten Grenzen haben

en: multilib exclusion %qs is invalid
de: Multilib-Ausschluss %qs ist ungültig

en: multilib exclusions %qs is invalid
de: Multilib-Ausschlüsse %qs sind ungültig

en: multilib select %qs %qs is invalid
de: Multilib-select %qs %qs ist ungültig

en: multilib select %qs is invalid
de: Multilib-select %qs ist ungültig

en: multilib spec %qs is invalid
de: Multilib-Spezifikation %qs ist ungültig

en: multiple %<-mcpu=%> options specified
de: mehrere %<-mcpu=%>-Optionen angegeben

en: multiple %<default%> targets were set
de: Mehrere %<default%>-Ziele wurden festgelegt

en: multiple EH personalities are supported only with assemblers supporting %<.cfi_personality%> directive
de: Mehrere EH-Persönlichkeiten werden nur mit Assemblern unterstützt, die die Direktive %<.cfi_personality%> unterstützen

en: multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>
de: mehrere OpenMP-»standalone«-Direktiven unter den %<omp::directive%>-Attributen müssen sich alle innerhalb derselben %<omp::sequence%> befinden

en: multiple declarations in range-based %<for%> loop
de: mehrere Deklarationen in bereichsbasierter %<for%>-Schleife

en: multiple default labels in one switch
de: Mehrere Standardmarken in einem »switch«

en: multiple definition of %q#T
de: mehrfache Definition von %q#T

en: multiple fast interrupt routines seen: %qE and %qE
de: mehrere schnelle Interruptroutinen gefunden: %qE und %qE

en: multiple fields in union %qT initialized
de: in Union %qT werden mehrere Felder initialisiert

en: multiple function type attributes specified
de: mehrere Funktionstypattribute angegeben

en: multiple hot/cold transitions found (bb %i)
de: Interner Fehler: multiple hot/cold transitions found (bb %i)

en: multiple initializations given for %qD
de: mehrere Initialisierungen für %qD angegeben

en: multiple initializations given for base %qT
de: mehrere Initialisierungen für Basis %qT angegeben

en: multiple inline callers
de: Interner Fehler: multiple inline callers

en: multiple interrupt attributes not allowed
de: mehrere Interruptattribute sind nicht erlaubt

en: multiple interrupt attributes to function %qD
de: mehrere Interruptattribute für Funktion %qD

en: multiple iterating variables in fast enumeration
de: mehrere Schleifenvariablen in schneller Aufzählung

en: multiple methods named %<%c%E%> found
de: mehrere Methoden namens %<%c%E%> gefunden

en: multiple nested types attributes to function %qD
de: mehrere Attribute für geschachtelte Typen für Funktion %qD

en: multiple parameters named %qD
de: mehrere Parameter wurden %qD genannt

en: multiple prevailing defs for %qE
de: mehrere vorherrschende Definitionen für %qE

en: multiple property %qE methods specified, the latest one will be used
de: mehrere Methoden für Eigenschaft %qE angegeben, die letzte von denen wird verwendet

en: multiple ref-qualifiers
de: mehrere ref-qualifier

en: multiple save register attributes to function %qD
de: mehrere Registerspeicher-Attribute für Funktion %qD

en: multiple selectors named %<%c%E%> found
de: mehrere Selektoren namens %<%c%E%> gefunden

en: multiple storage classes in declaration of %qs
de: mehrere Speicherklassen in Deklaration von %qs

en: multiple storage classes in declaration specifiers
de: mehrere Speicherklassen in Deklaration

en: multiple types in one declaration
de: mehrere Typen in einer Deklaration

en: multiple-value argument in single-value context
de: Funktionsaufruf mit mehreren Werten in Kontext mit einem Wert

en: multiple-value function call in single-value context
de: Funktionsaufruf mit mehreren Werten in Kontext mit einem Wert

en: multiply option implies r%d is fixed
de: Multiplizieroption bringt mit sich, dass r%d festgelegt ist

en: multiversioning needs %<ifunc%> which is not supported on this target
de: Multiversionierung erfordert %<ifunc%>, was auf diesem Ziel nicht unterstützt wird

en: must %<#include <typeinfo>%> before using %<typeid%>
de: vor Verwendung von %<typeid%> muss %<#include <typeinfo>%> angegeben werden

en: must be declared with %<noexcept(true)%>
de: muss mit %<noexcept(true)%> deklariert werden

en: must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>
de: %<.*%> oder %<->*%> muss verwendet werden, um Zeiger auf Element als Funktion in %<%E (...)%> aufzurufen, z.B. %<(... ->* %E) (...)%>

en: mutable %qD is not usable in a constant expression
de: veränderliches %qD ist in konstantem Ausdruck nicht verwendbar

en: naked attribute only applies to functions
de: nacktes Attribut bezieht sich nur auf Funktionen

en: name %qD used in a GNU-style designated initializer for an array
de: Name %qD in benannter Initialisierung im GNU-Stil für ein Array verwendet

en: name %qT has incomplete type
de: Name %qT hat unvollständigen Typen

en: name %qs differs from name %qs defined in another translation unit
de: der Name %qs unterscheidet sich vom Namen %qs, der in einer anderen Übersetzungseinheit definiert ist

en: name %qs is defined as %u-bit while another translation unit defines it as %u-bit
de: Name %qs ist als %u-Bit definiert, in einer anderen Übersetzungseinheit jedoch als %u-Bit

en: name %qs is defined to %wd while another translation unit defines it as %wd
de: Name %qs ist als %wd definiert, in einer anderen Übersetzungseinheit jedoch als %wd

en: name %qs is defined to different value in another translation unit
de: Name %qs wird in einer anderen Übersetzungseinheit mit unterschiedlichem Wert definiert

en: name missing for member function
de: Name der Elementfunktion fehlt

en: name of class shadows template template parameter %qD
de: Name der Klasse verdeckt Template-Templateparameter %qD

en: name used in a GNU-style designated initializer for an array
de: Name in benannter Initialisierung im GNU-Stil für ein Array verwendet

en: named return values are no longer supported
de: benannte Rückgabewerte werden nicht mehr unterstützt

en: namespace %qD entered
de: Namensbereich %qD betreten

en: namespace alias %qD not allowed here, assuming %qD
de: Namensbereich-Alias %qD ist hier nicht erlaubt, %qD angenommen

en: namespace name required
de: Name eines Namensraums erwartet

en: namespace-scope anonymous aggregates must be static
de: anonymes Aggregat im Gültigkeitsbereich eines Namespace muss statisch sein

en: narrowing conversion of %qE from %qH to %qI
de: verengende Umwandlung von %qE von %qH nach %qI

en: narrowing conversion of %qE from %qH to %qI is ill-formed in C++11
de: verengende Umwandlung von %qE von %qH nach %qI ist in C++11 ungültig

en: need %<this%> to access member %qE
de: Zugriff auf das Member %qE erfordert %<this%>

en: need %<this%> to access member %qs
de: für den Zugriff auf Member %qs wird %<this%> benötigt

en: need %<typename%> before %<%T::%D::%E%> because %<%T::%D%> is a dependent scope
de: vor %<%T::%D::%E%> ist %<typename%> erforderlich, da %<%T::%D%> ein abhängiger Gültigkeitsbereich ist

en: need %<typename%> before %<%T::%E%> because %qT is a dependent scope
de: vor %<%T::%E%> ist %<typename%> erforderlich, da %qT ein abhängiger Gültigkeitsbereich ist

en: need %<typename%> before %qE because %qT is a dependent scope
de: %<typename%> vor %qE erforderlich, da %qT ein abhängiger Gültigkeitsbereich ist

en: need explicit conversion
de: ausdrückliche Umwandlungen erforderlich

en: need explicit conversion; missing method %s%s%s
de: explizite Umwandlung nötig; Methode %s%s%s fehlt

en: negative insn length
de: negative Befehlslänge

en: negative length in array section in %qs clause
de: Arrayabschnitt mit negativer Länge in %qs-Klausel

en: negative low bound in array section in %qs clause
de: negative untere Grenze in Arrayabschnitt in %qs-Klausel

en: negative nesting depth of region %i
de: negative Verschachtelungstiefe der Region %i

en: negative shift count
de: negative Schiebeweite

en: negative width in bit-field %q+D
de: negative Breite in Bitfeld %q+D

en: negative width in bit-field %qs
de: Negative Breite in Bitfeld %qs

en: neither branch of %<if%> is a constant expression
de: keiner der Zweige des %<if%> ist ein Konstantenausdruck

en: neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined
de: weder der Destruktor noch der klassenspezifische %<operator delete%> wird aufgerufen, auch wenn sie bei der Klassendefinition deklariert werden

en: neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined
de: weder der Destruktor noch der klassenspezifische %<operator delete []%> wird aufgerufen, auch wenn sie bei der Klassendefinition deklariert werden

en: nested assembly dialect alternatives
de: geschachtelte Assemblerdialekt-Alternativen

en: nested extern declaration of %qD
de: Geschachtelte extern-Deklaration von %qD

en: nested function %q+D declared but never defined
de: Geschachtelte Funktion %q+D deklariert, aber nirgendwo definiert

en: nested function %qE declared %<extern%>
de: geschachtelte Funktion %qE als %<extern%> deklariert

en: nested function %qs declared %<extern%>
de: geschachtelte Funktion %qs als %<extern%> deklariert

en: nested function missing body
de: die geschachtelte Funktion muss einen Rumpf haben

en: nested function trampolines not supported on GCN5 due to non-executable stacks
de: geschachtelte Funktionstrampoline werden auf GCN5 aufgrund nicht ausführbarer Stacks nicht unterstützt

en: nested function trampolines not supported on this target
de: -ffunction-sections wird für dieses Ziel nicht unterstützt

en: nested functions cannot be profiled with %<-mfentry%> on s390
de: auf s390 können geschachtelte Funktionen mit %<-mfentry%> nicht im Profiling verwendet werden

en: nested functions not supported on this target
de: geschachtelte Funktionen werden auf diesem Ziel nicht unterstützt

en: nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>
de: verschachtelte inline-Namensraumdefinitionen sind erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: nested loop in reduction needs reduction clause for %qE
de: geschachtelte Schleife in Reduktion benötigt Reduktionsklausel für %qE

en: nested name specifier %qT for enum declaration does not name a class or namespace
de: geschachtelter Namensgeber %qT für enum-Deklaration benennt weder Klasse noch Namensraum

en: nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>
de: verschachtelte Namensraumdefinitionen sind nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar

en: nested namespace name required
de: Name eines geschachtelten Namensraums erwartet

en: nested quoting directive
de: geschachtelte q-Direktiven

en: nested redefinition of %<enum %E%>
de: Verschachtelte Redefinition von %<enum %E%>

en: nested redefinition of %<struct %E%>
de: Verschachtelte Redefinition von %<struct %E%>

en: nested redefinition of %<union %E%>
de: Verschachtelte Redefinition von %<union %E%>

en: nested requirement %qE is not satisfied
de: die verschachtelte Anforderung %qE ist nicht erfüllt

en: nested requirement %qE is not satisfied, because
de: die verschachtelte Anforderung %qE ist nicht erfüllt, da

en: new cannot be applied to a function type
de: »new« kann nicht auf Funktionstyp angewendet werden

en: new cannot be applied to a reference type
de: »new« kann nicht auf Referenztyp angewendet werden

en: new declaration %q#D ambiguates built-in declaration %q#D
de: neue Deklaration %q#D macht eingebaute Deklaration %q#D mehrdeutig

en: new in Fortran 2003
de: neu in Fortran 2003

en: new in Fortran 2008
de: neu in Fortran 2008

en: new in Fortran 2018
de: neu in Fortran 2018

en: new in Fortran 95
de: neu in Fortran 95

en: new types may not be defined in a return type
de: neue Typen dürfen nicht in einem Rückgabetyp definiert werden

en: next member %q#D declared here
de: nächstes Feld %q#D hier deklariert

en: no %<%D(int)%> declared for postfix %qs
de: kein %<%D(int)%> für Suffix %qs deklariert

en: no %<%D(int)%> declared for postfix %qs, trying prefix operator instead
de: kein %<%D(int)%> für Suffix %qs deklariert, stattdessen wird Präfixoperator versucht

en: no %<%c%E%> method found
de: keine Methode %<%c%E%> gefunden

en: no %<FUNCTION_PROFILER%> for CRIS
de: kein %<FUNCTION_PROFILER%> für CRIS

en: no %q#D member function declared in class %qT
de: keine Elementfunktion %q#D in Klasse %qT deklariert

en: no %qs getter found
de: kein %qs-Getter gefunden

en: no FPX/FPU mixing allowed
de: Mischen von FPX/FPU ist nicht erlaubt

en: no LTRANS output list filename provided
de: kein Dateiname für LTRANS-Ausgabeliste angegeben

en: no arguments
de: Keine Argumente

en: no arguments for spec function
de: keine Argumente für Spezifikationsfunktion

en: no attribute can be applied to an explicit instantiation
de: auf explizite Instanziierung kann kein Attribut angewendet werden

en: no class name specified with %qs
de: kein Klassenname mit %qs angegeben

en: no class template named %q#T in %q#T
de: kein Klassentemplate namens %q#T in %q#T

en: no closing %<]%> for %<%%[%> format
de: kein schließendes %<]%> für %<%%[%>-Format

en: no closing brace
de: fehlende schließende geschweifte Klammer

en: no constructors
de: keine Konstruktoren

en: no context to resolve type of %qE
de: kein Kontext, um Typ von %qE aufzulösen

en: no conversion operators declared
de: keine Umwandlungsoperatoren deklariert

en: no corresponding deallocation function for %qD
de: keine passende Freigabefunktion für %qD

en: no data type for mode %qs
de: Kein Datentyp für Zustand %qs

en: no declaration matches %q#D
de: keine Deklaration passt zu %q#D

en: no declaration of property %qs found in the interface
de: keine Deklaration der in der Schnittstelle gefundenen Eigenschaft %qs

en: no default argument for %qD
de: kein Standard-Argument für %qD

en: no destructors
de: keine Destruktoren

en: no dispatcher found for the versioning attributes
de: kein Dispatcher für versionierte Attribute gefunden

en: no dispatcher found for the versioning attributes: %s
de: Kein Dispatcher für Versionierungsattribute gefunden: %s

en: no field %qD found in union being initialized
de: kein Feld %qD in initialisierter Union gefunden

en: no functions named %qD
de: keine Funktionen namens %qD

en: no immediate_use list
de: Keine Liste zur sofortigen Verwendung

en: no input files
de: keine Eingabedateien

en: no input files; unwilling to write output files
de: keine Eingabedateien; es werden keine Ausgabedateien geschrieben

en: no integral type can represent all of the enumerator values for %qT
de: kein Ganzzahltyp kann alle Aufzählungswerte für %qT darstellen

en: no low registers available for popping high registers
de: keine unteren Register für das Hervorholen der hohen Register verfügbar

en: no match for
de: keine Übereinstimmung für

en: no match for call to %<%T::operator[] (%A)%>
de: keine Übereinstimmung für den Aufruf von %<%T::operator[] (%A)%>

en: no match for call to %<(%T) (%A)%>
de: keine Übereinstimmung für Aufruf von %<(%T) (%A)%>

en: no matches converting function %qD to type %q#T
de: bei der Umwandlung der Funktion %qD in den Typ %q#T gab es keine Übereinstimmungen

en: no matching concept for template-introduction
de: kein passendes Konzept für template-introduction

en: no matching concepts for %qE
de: keine passenden Konzepte für %qE

en: no matching fixed-point overload found for %qs
de: keine passende Festkomma-Überladung für %qs gefunden

en: no matching function for call to %<%D(%A)%>
de: keine passende Funktion für Aufruf von %<%D(%A)%>

en: no matching function for call to %<%T::%s%E(%A)%#V%>
de: keine passende Funktion für Aufruf von %<%T::%s%E(%A)%#V%>

en: no matching function for call to %<%T::operator %T(%A)%#V%>
de: keine passende Funktion für Aufruf von %<%T::operator %T(%A)%#V%>

en: no matching function for call to %<%s(%A)%>
de: keine passende Funktion für Aufruf von %<%s(%A)%>

en: no matching function for type-generic call
de: keine passende Funktion für typgenerischen Aufruf

en: no matching push for %<#pragma GCC visibility pop%>
de: kein passendes push für %<#pragma GCC visibility pop%>

en: no matching template for %qD found
de: kein passendes Template für %qD gefunden

en: no member function %qD declared in %qT
de: keine Elementfunktion %qD in %qT deklariert

en: no member named %qE in %qT
de: kein Mitglied namens %qE in %qT

en: no multilib-enabled ABI (%qs) can be implemented with instruction set %qs, falling back to %qs
de: keine Multilib-fähige ABI %qs kann mit dem Befehlssatz %qs implementiert werden, stattdessen wird %qs verwendet

en: no operand of the disjunction is satisfied
de: kein Operand der Disjunktion ist erfüllt

en: no post-decrement operator for type
de: kein Postdekrementoperator für Typ

en: no post-increment operator for type
de: kein Postinkrementoperator für Typ

en: no pre-decrement operator for type
de: kein Prädekrementoperator für Typ

en: no pre-increment operator for type
de: kein Präinkrementoperator für Typ

en: no previous declaration for %qD
de: keine vorherige Deklaration für %qD

en: no previous prototype for %qD
de: kein vorheriger Prototyp für %qD

en: no processor type specified for linking
de: kein Prozessortyp zum Binden angegeben

en: no profiling of 64-bit code for this ABI
de: kein Profiling von 64-bit-Code für dieses ABI

en: no register in address
de: Kein Register in Adresse

en: no return statement in %<constexpr%> function returning non-void
de: eine %<constexpr%>-Funktion, die etwas Anderes als %<void%> zurückgibt, muss eine return-Anweisung enthalten

en: no return statement in function returning non-void
de: keine return-Anweisung in nicht void zurückgebender Funktion

en: no return statements in function returning %qT
de: keine return-Anweisungen in %qT zurückgebender Funktion

en: no semicolon at end of struct or union
de: kein Semikolon am Ende von »struct« oder »union«

en: no suitable %<operator %s%> for %qT
de: kein geeignetes %<operator %s%> für %qT

en: no suitable %qD found in class %qT
de: Kein passendes %qD in Klasse %qT gefunden

en: no super class declared in @interface for %qE
de: keine Basisklasse im @interface für %qE deklariert

en: no super class declared in interface for %qE
de: keine Basisklasse in Schnittstelle für %qE deklariert

en: no suspend point info for %qD
de: keine Informationen zum Aufschiebepunkt für %qD

en: no type named %q#T in %q#T
de: kein Typ namens %q#T in %q#T

en: no type or storage class may be specified here,
de: hier darf kein Typ oder Speicherklasse angegeben werden,

en: no unexpanded parameter packs in binary fold
de: keine unexpandierten Parameterpackungen in binärer Faltung

en: no unique final overrider for %qD in %qT
de: %qD wurde nicht eindeutig und endgültig in %qT überschrieben

en: no valid clauses specified in %<#pragma acc declare%>
de: keine gültigen Klauseln in %<#pragma acc declare%> angegeben

en: node differs from node->decl->decl_with_vis.symtab_node
de: Interner Fehler: node differs from node->decl->decl_with_vis.symtab_node

en: node has body_removed but is definition
de: Interner Fehler: node has body_removed but is definition

en: node has invalid order %i
de: Knoten hat ungültige Reihenfolge %i

en: node has unknown type
de: Interner Fehler: node has unknown type

en: node is alias but not definition
de: Interner Fehler: node is alias but not definition

en: node is alias but not implicit alias
de: Interner Fehler: node is alias but not implicit alias

en: node is alone in a comdat group
de: Interner Fehler: node is alone in a comdat group

en: node is analyzed but it is not a definition
de: Interner Fehler: node is analyzed but it is not a definition

en: node is in same_comdat_group list but has no comdat_group
de: Interner Fehler: node is in same_comdat_group list but has no comdat_group

en: node is symver but not alias
de: Interner Fehler: node is symver but not alias

en: node is transparent_alias but not an alias
de: Interner Fehler: node is transparent_alias but not an alias

en: node is weakref but not an transparent_alias
de: Interner Fehler: node is weakref but not an transparent_alias

en: node not found in symtab assembler name hash
de: Interner Fehler: node not found in symtab assembler name hash

en: node not found node->decl->decl_with_vis.symtab_node
de: Interner Fehler: node not found node->decl->decl_with_vis.symtab_node

en: nodes with unreleased memory found
de: Knoten mit nicht freigegebenem Speicher gefunden

en: noexcept-expression evaluates to %<false%> because of a call to %qD
de: noexcept-Ausdruck wird wegen Aufruf von %qD zu %<false%> ausgewertet

en: non 32 bit register operand for '%%%c'
de: Operand für »%%%c« muss ein 32-Bit-Register sein

en: non double precision REAL argument to %s intrinsic at %L
de: REAL-Argument ohne doppelte Genauigkeit für intrinsisches %s bei %L

en: non-%<consteval%> function %q+D overriding %<consteval%> function
de: nicht-%<consteval%>-Funktion %q+D übersteuert %<consteval%>-Funktion

en: non-AAPCS derived PCS variant
de: von nicht-AAPCS abgeleitete PCS-Variante

en: non-ASCII character in CFString literal
de: Nicht-ASCII-Zeichen in CFString-Literal

en: non-NULL pointer initialization at %C
de: Nicht-NULL-Zeigerinitialisierung bei %C

en: non-OpenACC construct inside of OpenACC region
de: Nicht-OpenACC-Konstrukt innerhalb einer OpenACC-Region

en: non-OpenACC construct inside of OpenACC routine
de: Nicht-OpenACC-Konstrukt innerhalb einer OpenACC-Routine

en: non-array deallocation of object allocated with array allocation
de: Nicht-Array-Deallokation eines Objekts, das mit Array-Allokation allokiert wurde

en: non-call exception handling mismatch
de: Fehlzuordnung bei Ausnahmebehandlung ohne Aufruf

en: non-class, non-variable partial specialization %qE is not allowed
de: Teilspezialisierung %qE ist nur für Klassen und Variablen erlaubt

en: non-cold basic block %d reachable only by paths crossing the cold partition
de: Interner Fehler: non-cold basic block %d reachable only by paths crossing the cold partition

en: non-const integer argument %u in call to function %qE
de: Nicht-konstantes Ganzzahl-Argument %u in Aufruf von Funktion %qE

en: non-constant argument 0 to %qs
de: Nicht konstantes Argument 0 für %qs

en: non-constant argument 1 to %qs
de: Nicht konstantes Argument 1 für %qs

en: non-constant array in DATA statement %L
de: Nichtkonstantes Feld in DATA-Anweisung %L

en: non-constant array initialization
de: nicht konstante Arrayinitialisierung

en: non-constant array new length must be specified directly, not by %<typedef%>
de: nichtkonstante Länge für neues Array muss direkt angegeben werden, nicht über %<typedef%>

en: non-constant array new length must be specified without parentheses around the type-id
de: Nichtkonstante Länge in Array-new muss ohne Klammern um die Typ-ID angegeben werden

en: non-constant compound literals cannot appear in a constant-expression
de: nicht-konstantes zusammengesetztes Literal kann nicht in einem Konstanten-Ausdruck auftreten

en: non-constant condition for static assertion
de: Nicht-konstante Bedingung für statische Behauptung

en: non-constant expression %qs
de: nicht konstanter Ausdruck %qs

en: non-constant in-class initialization invalid for non-inline static member %qD
de: Initialisierung des nicht konstanten statischen Elements %qD in der Klasse ist ungültig

en: non-constant in-class initialization invalid for static member %qD
de: Initialisierung des nicht konstanten statischen Elements %qD in der Klasse ist ungültig

en: non-constant initialization expression at %L
de: Nicht-konstanter Initialisierungsausdruck bei %L

en: non-deducible template %qT used without template arguments
de: nicht herleitbares Templates %qT wird ohne Template-Argumente verwendet

en: non-default INTEGER kind argument to %s intrinsic at %L
de: Nicht-Standard Argument der Art INTEGER für intrinsisches »%s« bei %L

en: non-delegitimized UNSPEC %s (%d) found in variable location
de: Nicht-Delegitimiertes UNSPEC %s (%d) am Variablenort gefunden

en: non-deleted function %q+D overriding deleted function
de: nicht gelöschte Funktion %q+D übersteuert gelöschte Funktion

en: non-floating-point argument in call to function %qE
de: Nicht-Gleitkomma-Argument in Aufruf von Funktion %qE

en: non-floating-point arguments in call to function %qE
de: Nicht-Gleitkomma-Argumente in Aufruf von Funktion %qE

en: non-function %qD declared as implicit template
de: Nicht-Funktion %qD als implizites Template deklariert

en: non-function alias definitions not supported in this configuration
de: Alias-Definitionen werden in dieser Konfiguration nur für Funktionen unterstützt

en: non-function in gimple call
de: Nicht-Funktion in GIMPLE-Aufruf

en: non-integer argument 1 to %qs
de: Nicht ganzzahliges Argument 1 für %qs

en: non-integer argument 3 in call to function %qE
de: Nicht-Ganzzahl-Argument 3 in Aufruf von Funktion %qE

en: non-integer memory model argument %d of %qE
de: Nicht-Ganzzahlargument %d für Speichermodell von %qE

en: non-integer operand used with operand code %<z%>
de: Nicht-Ganzzahl-Operand mit Operandencode %<z%> verwendet

en: non-integral type switch statement
de: switch-Anweisung ohne eingebauten Typ

en: non-local lambda expression cannot have a capture-default
de: nicht-lokaler Lambdaausdruck kann keinen »capture-default« haben

en: non-local variable %qD declared %<__thread%> has a non-trivial destructor
de: nicht-lokale %<__thread%>-Variable %qD hat einen nicht-trivialen Destruktor

en: non-local variable %qD declared %<__thread%> needs dynamic initialization
de: nicht-lokale %<__thread%>-Variable %qD erfordert dynamische Initialisierung

en: non-loop with header %d not marked for removal
de: Interner Fehler: non-loop with header %d not marked for removal

en: non-lvalue array in conditional expression
de: Nicht-L-Wert-Array in bedingtem Ausdruck

en: non-member %qs cannot be declared %<mutable%>
de: Nicht-Element %qs kann nicht als %<mutable%> deklariert sein

en: non-member function %qD cannot have cv-qualifier
de: Nicht-Elementfunktion %qD kann nicht CV-Qualifizierer haben

en: non-member function %qD cannot have ref-qualifier
de: Nicht-Elementfunktion %qD kann keinen ref-Qualifizierer haben

en: non-member using-declaration names constructor of %qT
de: eine Using-Deklaration, die nicht-Member ist, benennt den Konstruktor von %qT

en: non-member-template declaration of %qD
de: Nichtelement-Templatedeklaration von %qD

en: non-memory input %d must stay in memory
de: Eingabe von Nicht-Speicher %d muss im Speicher bleiben

en: non-memory output %d must stay in memory
de: Nicht-Speicher-Ausgabe %d muss im Speicher bleiben

en: non-nested function with variably modified type
de: nicht geschachtelte Funktion mit variabel modifiziertem Typen

en: non-object member %qs cannot be declared %<mutable%>
de: Nicht-Objekt-Element %qs kann nicht als %<mutable%> deklariert sein

en: non-objective-c type %qT cannot be caught
de: Nicht-Objective-C-Typ %qT kann nicht aufgefangen werden

en: non-parameter %qs cannot be a parameter pack
de: Nicht-Parameter %qs kann kein Parameterpack sein

en: non-pointer argument to %<__builtin_launder%>
de: Argument, das kein Zeiger ist, in %<__builtin_launder%>

en: non-register as LHS of binary operation
de: Nicht-Register als LHS von binärer Operation

en: non-register as LHS of ternary operation
de: Nicht-Register als LHS von ternärer Operation

en: non-register as LHS of unary operation
de: Nicht-Register als LHS von unärer Operation

en: non-scalar %qs
de: nicht-skalares %qs

en: non-scalar type
de: nicht-skalarer Typ

en: non-scalar variable %qD in conditional %<lastprivate%> clause
de: nichtskalare Variable %qD in bedingter %<lastprivate%>-Klausel

en: non-standard suffix on floating constant
de: Nicht-Standard-Suffix an Gleitkommakonstante

en: non-static const member %q#D in class without a constructor
de: nicht-statisches const-Element %q#D in Klasse ohne einen Konstruktor

en: non-static const member %q#D, cannot use default assignment operator
de: nicht-statisches konstantes Element %q#D, Standard-Zuweisungsoperator kann nicht verwendet werden

en: non-static data member %q+D in a union may not have reference type %qT
de: nicht-statisches Datenelement %q+D in einer Union darf keinen Referenztypen %qT haben

en: non-static data member %qE declared %qs
de: nicht-statisches Datenelement %qE als %qs deklariert

en: non-static data member declared with placeholder %qT
de: nicht-statisches Datenelement mit Platzhalter %qT deklariert

en: non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>
de: nicht-statische Initialisierungen für Datenelemente nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: non-static declaration of %q+D follows static declaration
de: Nicht-statische Deklaration von %q+D folgt statischer Deklaration

en: non-static initialization of a flexible array member
de: nicht-statische Initialisierung eines flexiblen Arrayelements

en: non-static reference %q#D in class without a constructor
de: nicht-statische Referenz %q#D in Klasse ohne Konstruktor

en: non-static reference member %q#D, cannot use default assignment operator
de: nicht-statisches Referenzelement %q#D, Standard-Zuweisungsoperator kann nicht verwendet werden

en: non-template %qD used as template
de: Nicht-Template %qD als Template verwendet

en: non-template type %qT used as a template
de: Nicht-Template-Typ %qT als Template verwendet

en: non-thread-local declaration of %q#D follows thread-local declaration
de: Nicht-Thread-lokale Deklaration von %q#D folgt Thread-lokaler Deklaration

en: non-thread-local declaration of %q+D follows thread-local declaration
de: Nicht-Thread-lokale Deklaration von %q+D folgt Thread-lokaler Deklaration

en: non-top-level %qs
de: nicht-Top-Level %qs

en: non-trivial conversion in %qs
de: nicht-triviale Umwandlung in %qs

en: non-trivial conversion in unary operation
de: nicht-triviale Umwandlung in unärer Operation

en: non-trivial designated initializers not supported
de: nicht-trivial markierte Initialisierungen nicht unterstützt

en: non-type partial specialization %qE is not allowed
de: Nichttyp-Teilspezialisierung %qE ist nicht erlaubt

en: non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>
de: Nichttypen-Templateparameter von Klassentyp sind nur mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>
de: Nichttypen-Templateparameter von hergeleitetem Klassentyp sind erst ab %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: non-variable %qD in declaration with more than one declarator with placeholder type
de: Nicht-Variable %qD in Deklaration mit mehr als einem Deklarator mit Platzhaltertyp

en: non-vector %qs with elements
de: %qs mit Elementen ist kein Vektor

en: non-vector operands in vector comparison
de: Nicht-Vektoroperanden in Vektorvergleich

en: nonconstant array index in initializer
de: nichtkonstanter Arrayindex in Initialisierung

en: nonempty exits list of loop %d, but exits are not recorded
de: Interner Fehler: nonempty exits list of loop %d, but exits are not recorded

en: nonlocal label %qD is not first in a sequence of labels in bb %d
de: Interner Fehler: nonlocal label %qD is not first in a sequence of labels in bb %d

en: nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds
de: Arrayindex %qE ist ungleich 0 und wird mit Array %qD vom Typ %qT mit unbekannten Grenzen verwendet

en: nonzero array subscript %qE is used with array of type %qT with unknown bounds
de: Arrayindex %qE ist ungleich 0 und wird mit Array vom Typ %qT mit unbekannten Grenzen verwendet

en: normalization cannot co-exist with scaling
de: Normalisierung kann nicht gleichzeitig mit Skalierung aktiv sein

en: not Encapsulated Lazy Records of Named Declarations
de: Datei fängt nicht mit dem magischen \x7FELF an

en: not allowed type combination in %qs
de: unerlaubte Typkombination in %qs

en: not configured with sysroot headers suffix
de: nicht mit sysroot-Header-Suffix konfiguriert

en: not enough DO loops for %s !$ACC LOOP at %L
de: zu wenige DO-Schleifen für »%s !$ACC LOOP« bei %L

en: not enough DO loops for collapsed %s at %L
de: zu wenige DO-Schleifen für zusammengefallenes %s bei %L

en: not enough arguments
de: Nicht genug Argumente

en: not enough arguments to return
de: Nicht genug Argumente für Rückgabe

en: not enough for loops to collapse
de: zu wenige for-Schleifen um sie einzuklappen

en: not enough perfectly nested loops
de: nicht genügend perfekt geschachtelte Schleifen

en: not enough type information
de: zu wenig Typinformationen

en: not enough variable arguments to fit a sentinel
de: Zu wenige variable Argumente, um zu einem Wächter zu passen

en: not exporting %<#define %E%> as it is a keyword
de: %<#define %E%> wird nicht exportiert, da es ein Schlüsselwort ist

en: not generating patch area, nops not supported
de: Patchbereich wird nicht angelegt, da NOPs nicht unterstützt werden

en: not support %<-fpic%> option for v3m toolchain
de: die Option %<-fpic%> nicht für die v3m-Toolchain unterstützen

en: not writing module %qs due to errors
de: Modul %qs kann aufgrund von Fehlern nicht geschrieben werden

en: note
de: Hinweis

en: note:
de: Anmerkung:

en: null destination pointer
de: Zielzeiger ist NULL

en: null format string
de: NULL-Formatzeichenkette

en: null pointer
de: Null-Zeiger

en: null pointer dereference
de: Dereferenzierung eines Nullzeigers

en: nullability specifier %qE cannot be applied to multi-level pointer type %qT
de: Nullbarkeits-Angabe %qE kann nicht auf Zeigertyp %qT angewendet werden, da dieser mehrere Ebenen von Zeigern hat

en: nullability specifier %qE cannot be applied to non-pointer type %qT
de: Nullbarkeits-Angabe %qE ist nur auf Zeigertypen anwendbar, nicht auf %qT

en: number must be 0 or 1
de: Zahl muss 0 oder 1 sein

en: number of arguments doesn%'t match built-in prototype
de: Anzahl der Argumente passt nicht zum eingebauten Prototypen

en: number of arguments doesn%'t match prototype
de: Anzahl der Argumente passt nicht zum Prototypen

en: number of bb notes in insn chain (%d) != n_basic_blocks (%d)
de: Interner Fehler: number of bb notes in insn chain (%d) != n_basic_blocks (%d)

en: number of components of vector not a power of two
de: Komponentenanzahl des Vektors ist keine Zweierpotenz

en: number of counters in profile data for function %qD does not match its profile data (counter %qs, expected %i and have %i)
de: Anzahl der Zähler in den Profilingdaten für Funktion %qD passt nicht zu deren Profilingdaten (Zähler %qs, %i erwartet aber %i gefunden)

en: number of results does not match number of values
de: Anzahl der Ergebnisse passt nicht zur Anzahl der Werte

en: number of speculative targets %i mismatched with num_speculative_call_targets %i
de: Anzahl der spekulativen Ziele %i stimmt nicht mit num_speculative_call_targets %i überein

en: number of variables in %<depend%> clause with %<sink%> modifier does not match number of iteration variables
de: Anzahl der Variablen in %<depend%>-Klausel mit %<sink%>-Modifizierer passt nicht zur Anzahl der Iterationsvariablen

en: number of vector components %wu exceeds %d
de: Komponentenanzahl des Vektors %wu übersteigt %d

en: number of vector components %wu not a power of two
de: Komponentenanzahl des Vektors %wu ist keine Zweierpotenz

en: numeric argument of %qE attribute must be in range [0-63]
de: numerisches Argument des Attributs %qE muss im Bereich von 0 bis 63 liegen

en: objc++-cpp-output is deprecated; please use objective-c++-cpp-output instead
de: objc++-cpp-output ist veraltet; bitte stattdessen objective-c++-cpp-output verwenden

en: objc-cpp-output is deprecated; please use objective-c-cpp-output instead
de: objc-cpp-output ist veraltet; bitte stattdessen objective-c-cpp-output verwenden

en: object %qE of size %s
de: Objekt %qE der Größe %s

en: object is not a method
de: Objekt ist keine Methode

en: object missing in use of %qE
de: bei Verwendung von %qE fehlt Objekt

en: object of size %s allocated by %qE
de: Objekt der Größe %s, alloziert durch %qE

en: object property %qD has no %<assign%>, %<retain%> or %<copy%> attribute; assuming %<assign%>
de: Objekt-Eigenschaft %qD hat kein Attribut %<assign%>, %<retain%> oder %<copy%>; es wird %<assign%> angenommen

en: object type %qT does not match destructor name ~%qT
de: Objekttyp %qT passt nicht zum Destruktornamen ~%qT

en: object with variably modified type must have no linkage
de: Objekt mit variabel geändertem Typ darf keine Bindung haben

en: objective-c method declaration is expected
de: Methodendeklaration in Objective-C erwartet

en: objective-c++ message argument(s) are expected
de: Objective-C++ Nachrichtenargument(e) erwartet

en: objective-c++ message receiver expected
de: Objective-C++-Nachrichtenempfänger erwartet

en: objective-c++ method declaration is expected
de: Objective-C++ Methodendeklaration erwartet

en: obsolescent in Fortran 95
de: ausgedient in Fortran 95

en: obsolete Maverick format code '%c'
de: veralteter Maverick-Formatcode »%c«

en: obsolete option %<-I-%> used, please use %<-iquote%> instead
de: veraltete Option %<-I-%> verwendet, bitte stattdessen %<-iquote%> verwenden

en: obsolete use of designated initializer with %<:%>
de: veraltete Verwendung einer bestimmten Initialisierung mit %<:%>

en: obsolete use of designated initializer without %<=%>
de: veraltete Verwendung einer bestimmten Initialisierung ohne %<=%>

en: obtained here
de: von hier erhalten

en: odr-used inline variable %qD is not defined
de: odr-verwendete Inline-Variable %qD ist nicht definiert

en: of module
de: von Modul

en: offload compiler %s not found
de: Offload-Compiler %s nicht gefunden

en: offload compiler %s not found (consider using %<-B%>)
de: Offload-Compiler %s nicht gefunden (erwägen Sie %<-B%>)

en: offload dimension out of range (%d)
de: Auslagerungsdimension %d liegt außerhalb des Wertebereiches

en: offset %qwi outside bounds of constant string
de: Offset %qwi ist außerhalb der Grenzen der konstanten Zeichenkette

en: offset exceeds 16 bytes
de: Offset überschreitet 16 Bytes

en: offset of %qD for %<-std=c++14%> and up changes in %<-fabi-version=17%> (GCC 12)
de: Offset von %qD für %<-std=c++14%> und höher ändert sich in %<-fabi-version=17%> (GCC 12)

en: offset of %qD is not ABI-compliant and may change in a future version of GCC
de: Offset von %qD ist ABI-unverträglich und kann sich in zukünftigen GCC-Versionen ändern

en: offset of %qT base class for %<-std=c++14%> and up changes in %<-fabi-version=17%> (GCC 12)
de: Offset der Basisklasse %qT für %<-std=c++14%> und höher ändert sich in %<-fabi-version=17%> (GCC 12)

en: offset of packed bit-field %qD has changed in GCC 4.4
de: Offset des gepackten Bitfeldes %qD hat sich in GCC 4.4 geändert

en: old declaration %q#D
de: alte Deklaration %q#D

en: old-style function definition
de: Funktionsdefinition im alten Stil

en: old-style parameter declarations in prototyped function definition
de: Parameterdeklarationen alten Stils in Prototyp-Funktionsdeklaration

en: omitted middle operand to %<?:%> operand cannot be mangled
de: ausgelassener mittlerer Operand für Operator %<?:%> kann nicht verarbeitet werden

en: one field is a bitfield while the other is not
de: ein Feld ist ein Bitfeld, das andere jedoch nicht

en: one of the initializer call arguments should be %<&omp_priv%>
de: eins der Argumente für den Initialisierungsaufruf sollte %<&omp_priv%> sein

en: one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>
de: eins der Aufrufargumente für die Initialisierung sollte %<omp_priv%> oder %<&omp_priv%> sein

en: one type needs to be constructed while the other does not
de: ein Typ muss konstruiert sein, der andere nicht

en: only %<distribute%>, %<parallel%> or %<loop%> regions are allowed to be strictly nested inside %<teams%> region
de: nur %<distribute%>-, %<parallel%>- und %<loop%>-Regionen dürfen innerhalb einer %<teams%>-Region streng geschachtelt sein

en: only %<inbranch%> and %<notinbranch%> flags are allowed for %<__simd__%> attribute
de: nur die Schalter %<inbranch%> und %<notinbranch%> sind für das %<__simd__%>-Attribut erlaubt

en: only %u name provided for structured binding | only %u names provided for structured binding
de[0]: nur %u Name für strukturelle Bindung angegeben
de[1]: nur %u Namen für strukturelle Bindung angegeben

en: only 0.0 can be loaded as an immediate
de: nur 0.0 kann als Immediate geladen werden

en: only 32-bit access is supported for %<__regio_symbol%> address space
de: für den Adressraum %<__regio_symbol%> wird nur der 32-Bit-Zugriff unterstützt

en: only DWARF debug format is supported for interrupt service routine
de: Nur das DWARF-Debugformat ist für Interrupt-Service-Routinen unterstützt

en: only Objective-C object types can be qualified with a protocol
de: nur Objective-C-Objekttypen können mit Protokoll qualifiziert werden

en: only attribute %<fallthrough%> can be applied to a null statement
de: Nur das Attribut %<fallthrough%> kann auf eine leere Anweisung angewendet werden

en: only constructors take member initializers
de: nur Konstruktoren nehmen Elementinitialisierungen

en: only declarations of constructors and conversion operators can be %<explicit%>
de: nur Deklarationen von Konstruktoren und Umwandlungsoperatoren können %<explicit%> sein

en: only here as a %<friend%>
de: sondern nur hier als %<friend%>

en: only plain %<auto%> return type can be deduced to %<void%>
de: nur einfacher Rückgabetyp %<auto%> kann zu %<void%> hergeleitet werden

en: only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20
de: in einer %<constexpr%>-Funktion in C++20 darf Inline-Assemblercode nur vorkommen, wenn er nicht im Auswertungspfad liegt

en: only uninitialized variables can be placed in a %<.bss%> section
de: Nur uninitialisierte Variablen können in einem %<.bss%>-Abschnitt platziert werden

en: only uninitialized variables can be placed in the %<.noinit%> section
de: Nur uninitialisierte Variablen können im %<.noinit%>-Bereich platziert werden

en: only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range
de: nur die Werte 12 (4 kB) und 16 (64 kB) werden für die Wächtergröße unterstützt. Der angegebene Wert %d (%llu kB) liegt außerhalb des gültigen Bereichs

en: only weak aliases are supported in this configuration
de: in dieser Konfiguration werden nur schwache Aliase unterstützt

en: only zero initializers are allowed in section %qs
de: In Abschnitt %qs sind nur 0-Initialisierungen erlaubt

en: opaque vector types cannot be initialized
de: opake Vektortypen können nicht initialisiert werden

en: opaque-enum-declaration here
de: opaque-enum-declaration ist hier

en: opaque-enum-specifier must use a simple identifier
de: intransparente Enum-Spezifikation muss einfachen Bezeichner verwenden

en: opaque-enum-specifier without name
de: intransparente Enum-Spezifikation ohne Namen

en: open %s failed: %s
de: »%s« kann nicht geöffnet werden: %s

en: open /dev/zero: %m
de: /dev/zero kann nicht geöffnet werden: %m

en: opening LTRANS output list %s: %m
de: LTRANS-Ausgabeliste »%s« kann nicht geöffnet werden: %m

en: opening dependency file %s: %m
de: Abhängigkeitsdatei »%s« kann nicht geöffnet werden: %m

en: opening json file %s: %m
de: Fehler beim Öffnen der JSON-Datei %s: %m

en: opening mixin file %s: %m
de: Fehler beim Öffnen der Mixin-Datei %s: %m

en: opening output file %qs: %s
de: Ausgabedatei %qs wird geöffnet: %s

en: opening output file %s: %m
de: Ausgabedatei »%s« kann nicht geöffnet werden: %m

en: operand %%xn code invalid for QImode
de: Operandencode %%xn ist für QImode ungültig

en: operand %d should be a 3 bit unsigned immediate
de: Operand %d sollte eine vorzeichenlose 3-Bit-Konstante sein

en: operand %d should be a 6 bit unsigned immediate
de: Operand %d sollte eine vorzeichenlose 6-Bit-Konstante sein

en: operand %d should be a 8 bit unsigned immediate
de: Operand %d sollte eine vorzeichenlose 8-Bit-Konstante sein

en: operand 1 should be an unsigned 3-bit immediate
de: Operand 1 sollte eine vorzeichenlose 3-Bit-Konstante sein

en: operand 1 should be an unsigned 3-bit value (I0-I7)
de: Operand 1 sollte ein vorzeichenloser 3-Bit-Wert sein (I0–I7)

en: operand 2 should be an even 3-bit value (subreg 0,2,4,6)
de: Operand 2 sollte ein gerader 3-Bit-Wert sein (subreg 0,2,4,6)

en: operand 2 should be an unsigned 3-bit value (I0-I7)
de: Operand 2 sollte ein vorzeichenloser 3-Bit-Wert sein (I0–I7)

en: operand 2 should be an unsigned 3-bit value (subreg 0-7)
de: Operand 2 sollte ein vorzeichenloser 3-Bit-Wert sein (subreg 0–7)

en: operand 2 should be an unsigned 8-bit value
de: Operand 2 sollte ein vorzeichenloser 8-Bit-Wert sein

en: operand 3 should be an unsigned 3-bit value (I0-I7)
de: Operand 3 sollte ein vorzeichenloser 3-Bit-Wert sein (I0–I7)

en: operand 3 should be an unsigned 8-bit value
de: Operand 3 sollte ein vorzeichenloser 8-Bit-Wert sein

en: operand 4 should be an unsigned 8-bit value (0-255)
de: Operand 4 sollte ein vorzeichenloser 8-Bit-Wert sein (0–255)

en: operand constraint contains incorrectly positioned %<+%> or %<=%>
de: Operandenbedingung enthält falsch positioniertes %<+%> oder %<=%>

en: operand constraints for %<asm%> differ in number of alternatives
de: Operandenbedingungen für %<asm%> unterscheiden sich in der Anzahl der Alternativen

en: operand is not a condition code, invalid operand code '%c'
de: Operand ist kein Bedingungscode, ungültiger Operandencode »%c«

en: operand is not a condition code, invalid operand code 'D'
de: Operand ist kein Bedingungscode, ungültiger Operandencode »D«

en: operand is not a condition code, invalid operand code 'Y'
de: Operand ist kein Bedingungscode, ungültiger Operandencode »Y«

en: operand is not a specific integer, invalid operand code 'R'
de: Operand ist keine bestimmte Ganzzahl, ungültiger Operandencode »R«

en: operand is not a specific integer, invalid operand code 'r'
de: Operand ist keine bestimmte Ganzzahl, ungültiger Operandencode »r«

en: operand is not an integer, invalid operand code 'K'
de: Operand ist keine Ganzzahl, ungültiger Operandencode »K«

en: operand is not an integer, invalid operand code 'R'
de: Operand ist keine Ganzzahl, ungültiger Operandencode »R«

en: operand is not an offsettable memory reference, invalid operand code 'H'
de: Operand ist keine ausgleichbare Speicherreferenz, ungültiger Operandencode »H«

en: operand must be an immediate of the right size
de: Operand muss »immediate« mit korrekter Größe sein

en: operand number missing after %%-letter
de: Operandennummer fehlt hinter %%-Buchstabe

en: operand number out of range
de: Operandennummer außerhalb des Wertebereiches

en: operand number out of range in format
de: Operandennummer außerhalb des Wertebereiches im Format

en: operand number specified for format taking no argument
de: Operandennummer für Format ohne Argumente angegeben

en: operand number specified with suppressed assignment
de: Operandennummer mit unterdrückter Zuweisung angegeben

en: operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand
de: Operand von %<?:%> wechselt das Vorzeichen von %qT nach %qT, aufgrund der Vorzeichenlosigkeit des anderen Operanden

en: operand of fold expression has no unexpanded parameter packs
de: Operand des Faltungsausdrucks hat keine unexpandierten Parameterpackungen

en: operand type %qT is incompatible with argument %d of %qE
de: Operandentyp %qT ist inkompatibel mit Argument %d von %qE

en: operand types are %qT and %qT
de: Operandentypen sind %qT und %qT

en: operands to %<?:%> have different types %qT and %qT
de: Operanden für %<?:%> haben unterschiedliche Typen %qT und %qT

en: operands to %T/%t must be reg + const_int:
de: Operanden für %T/%t müssen reg + const_int sein:

en: operation not permitted on type %<bfloat16_t%>
de: Operation nicht erlaubt auf Typ %<bfloat16_t%>

en: operation on %qE may be undefined
de: Operation auf %qE könnte undefiniert sein

en: optimization attribute on %qD follows definition but the attribute doesn%'t match
de: Optimierungsattribut von %qD folgt auf die Definition, aber die Attribute passen nicht zusammen

en: optimization level attribute mismatch
de: Fehlzuordnung von Optimierungsstufenattribut

en: optimization may eliminate reads and/or writes to register variables
de: Optimierung kann Lese- und/oder Schreiboperationen auf Registervariablen entfernen

en: option %<%s%> requires %<-mlong-double-128%>
de: Option %<%s%> erfordert %<-mlong-double-128%>

en: option %<%s=%s%> is not available for %qs CPU
de: Option %<%s=%s%> ist für die CPU %qs nicht verfügbar

en: option %<-mdouble=32%> is only available if configured %<--with-double={32|32,64|64,32}%>
de: die Option %<-mdouble=32%> ist nur verfügbar, wenn %<--with-double={32|32,64|64,32}%> konfiguriert ist

en: option %<-mdouble=64%> is only available if configured %<--with-double={64|64,32|32,64}%>
de: die Option %<-mdouble=64%> ist nur verfügbar, wenn %<--with-double={64|64,32|32,64}%> konfiguriert ist

en: option %<-mirq-ctrl-saved%> valid only for ARC v2 processors
de: die Option %<-mirq-ctrl-saved%> ist nur für ARC-v2-Prozessoren gültig

en: option %<-mlong-double=32%> is only available if configured %<--with-long-double={32|32,64|64,32}%>, or %<--with-long-double=double%> together with %<--with-double={32|32,64|64,32}%>
de: die Option %<-mlong-double=32%> ist nur verfügbar, wenn %<--with-long-double={32|32,64|64,32}%>, oder %<--with-long-double=double%> zusammen mit %<--with-double={32|32,64|64,32}%> konfiguriert ist

en: option %<-mlong-double=64%> is only available if configured %<--with-long-double={64|64,32|32,64}%>, or %<--with-long-double=double%> together with %<--with-double={64|64,32|32,64}%>
de: die Option %<-mlong-double=64%> ist nur verfügbar, wenn %<--with-long-double={64|64,32|32,64}%>, oder %<--with-long-double=double%> zusammen mit %<--with-double={64|64,32|32,64}%> konfiguriert ist

en: option %<-mrgf-banked-regs%> valid only for ARC v2 processors
de: die Option %<-mrgf-banked-regs%> ist nur für ARC-v2-Prozessoren gültig

en: option %<-mstructure-size-boundary%> is deprecated
de: option %<-mstructure-size-boundary%> ist veraltet

en: option %qs is ignored, the default value %qs is considered for %qs CPU
de: Option %qs wird ignoriert, der Vorgabewert %qs wird für die CPU %qs verwendet

en: option %qs is not available for %qs CPU
de: Option %qs ist für die CPU %qs nicht verfügbar

en: option %qs is valid for %s but not for %s
de: Option %qs ist gültig für %s, aber nicht für %s

en: option %qs with mismatching values (%s, %s)
de: Option %qs mit abweichenden Werten (%s, %s)

en: option %s is not supported together with %<-fopenacc%>
de: Option »%s« wird zusammen mit %<-fopenacc%> nicht unterstützt

en: option %s not used consistently in all LTO input files
de: Option %s nicht konsistent in allen LTO-Eingabedateien verwendet

en: option %s with different values
de: Option %s mit unterschiedlichen Werten

en: optional argument
de: optionales Argument

en: optional class parameter
de: optionaler Klassenparameter

en: options or targets=options missing after %qs
de: Optionen oder Zielarchitekturen=Optionen fehlen hinter %qs

en: optype_msgid overflow: %d
de: Interner Fehler: optype_msgid overflow: %d

en: or replace parentheses with braces to aggregate-initialize a variable
de: oder ersetzen Sie die Klammern durch geschweifte Klammern, um die Variable als Aggregat zu initialisieren

en: or replace parentheses with braces to value-initialize a variable
de: oder ersetzen Sie die Klammern durch geschweifte Klammern, um die Variable mit einem einzelnen Wert zu initialisieren

en: or use %<j%> instead of %<i%> for the GNU built-in suffix
de: oder nutzen Sie %<j%> statt %<i%> für das in GNU eingebaute Suffix

en: ordered argument needs positive constant integer expression
de: Argument für %<ordered%> muss ein positiver, ganzzahliger Ausdruck sein

en: ordered comparison of pointer with integer zero
de: geordneter Vergleich von Zeiger mit Ganzzahlnull

en: ordered comparison of pointer with integer zero (%qT and %qT)
de: geordneter Vergleich von Zeiger mit der Zahl 0 (%qT und %qT)

en: ordered comparison of pointer with null pointer
de: geordneter Vergleich von Zeiger mit Null-Zeiger

en: original %<default%> is here
de: das ursprüngliche %<default%> ist hier

en: original declaration appeared here
de: ursprüngliche Deklaration trat hier auf

en: original definition appeared here
de: ursprüngliche Definition trat hier auf

en: original not compressed with zstd
de: Original ist nicht mit zstd komprimiert

en: original size unknown
de: Originalgröße unbekannt

en: original template declaration here
de: ursprüngliche Deklaration des Templates ist hier

en: originally declared %<const%> here
de: wurde ursprünglich hier als %<const%> deklariert

en: originally defined here
de: ursprünglich hier definiert

en: originally indirect function call not considered for inlining
de: ursprünglich indirekter Funktionsaufruf kommt nicht als »inline« in Betracht

en: originally specified here
de: ursprüngliche hier spezifiziert

en: orphaned %qs construct
de: verwaistes %qs-Konstrukt

en: other match is here
de: andere Fundstelle ist hier

en: ought to match virtual method %qD but does not
de: sollte der virtuellen Methode %qD entsprechen, tut es aber nicht

en: outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>
de: äußeres %<__transaction_cancel%> nicht innerhalb des äußeren %<__transaction_atomic%>

en: outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function
de: Funktionsaufruf von %<__transaction_cancel%> nicht innerhalb von äußerer %<__transaction_atomic%>- oder %<transaction_may_cancel_outer%>-Funktion

en: outer block of region %i is wrong
de: äußerer Block der Region %i ist falsch

en: outer iteration variable %qD addend expression %qE is not integral
de: die äußere Iterationsvariable %qD hat einen Summandenausdruck %qE, der nicht ganzzahlig ist

en: outer iteration variable %qD multiplier expression %qE is not integral
de: die äußere Iterationsvariable %qD hat einen Faktorausdruck %qE, der nicht ganzzahlig ist

en: outer iteration variable %qD used in condition expression has type other than %qT
de: die äußere Iterationsvariable %qD, die im Bedingungsausdruck verwendet wird, ist von einem anderen Typen als %qT

en: outer iteration variable %qD used in initializer expression has type other than %qT
de: die äußere Iterationsvariable %qD, die im Initialisierungsausdruck verwendet wird, ist von einem anderen Typen als %qT

en: outer transaction in %<transaction_may_cancel_outer%> function
de: äußere Transaktion in %<transaction_may_cancel_outer%>-Funktion

en: outer transaction in %<transaction_safe%> function
de: äußere Transaktion in %<transaction_safe%>-Funktion

en: outer transaction in transaction
de: äußere Transaktion in Transaktion

en: output constraint %d cannot be specified together with %qs clobber
de: Ausgabebedingung %d kann nicht zusammen mit %qs angegeben werden

en: output constraint %d must specify a single register
de: Ausgabebedingung %d muss ein einzelnes Register angeben

en: output constraint %qc for operand %d is not at the beginning
de: Ausgabebedingung %qc für Operand %d steht nicht am Anfang

en: output file %s already exists in folder %s
de: Ausgabedatei %s existiert bereits in Ordner %s

en: output file not specified
de: keine Ausgabedatei angegeben

en: output filename may not be empty
de: Name der Ausgabedatei darf nicht leer sein

en: output filename specified twice
de: Ausgabedatei doppelt angegeben

en: output number %d not directly addressable
de: Ausgabezahl %d nicht direkt adressierbar

en: output operand %d must use %<&%> constraint
de: Ausgabeoperand %d muss %<&%>-Bedingung verwenden

en: output operand constraint lacks %<=%>
de: Bedingung des Ausgabeoperanden erfordert %<=%>

en: output operand is constant in %<asm%>
de: Ausgabeoperand ist in %<asm%> konstant

en: output registers must be grouped at top of stack
de: Ausgaberegister müssen oben auf dem Stapel gruppiert werden

en: overflow in array dimension
de: Überlauf in Arraygröße

en: overflow in constant expression
de: Überlauf in Konstanten-Ausdruck

en: overflow in conversion from %qT to %qT changes the value of %qE
de: Überlauf in Umwandlung von %qT nach %qT ändert den Wert von %qE

en: overflow in conversion from %qT to %qT changes value from %qE to %qE
de: Überlauf in Umwandlung von %qT nach %qT ändert den Wert von %qE in %qE

en: overflow in enumeration values
de: Überlauf in Aufzählungswerten

en: overflow in enumeration values at %qD
de: Überlauf in Aufzählungswerten bei %qD

en: overflowed output argument list for %qs
de: übergelaufene Ausgabeargumentliste für %qs

en: overlapping initializer for field %qT.%qD
de: überlappender Initialisierer für das Feld %qT.%qD

en: overloaded builtin %qs is implemented by builtin %qs
de: überladene eingebaute Funktion %qs ist durch die eingebaute Funktion %qs umgesetzt

en: overloaded function name %qE in clause %qs
de: überladener Funktionsname %qE in Klausel %qs

en: overloaded function with no contextual type information
de: überladene Funktion ohne Typinformationen aus Kontext

en: overridden function is %q#D
de: übersteuerte Funktion ist %q#D

en: overridden function is %q#F
de: übersteuerte Funktion ist %q#F

en: overridden function is %qD
de: übersteuerte Funktion ist %qD

en: override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>
de: Überschreibsteuerung (override/final) nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: overriding %qD declared %<transaction_safe%>
de: übersteuert %qD, was als %<transaction_safe%> deklariert ist

en: pack expansion argument for non-pack parameter %qD of alias template %qD
de: gepacktes Expansionsargument für Parameter %qD ohne »pack« von Alias-Template %qD

en: pack expansion argument for non-pack parameter %qD of concept %qD
de: gepacktes Expansionsargument für Parameter %qD ohne »pack« von Konzept %qD

en: pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>
de: Pack-Expansion in using-Deklaration ist nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar

en: pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>
de: %<pack init-capture%> ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: packed attribute causes inefficient alignment
de: gepacktes Attribut führt zu ineffizienter Ausrichtung

en: packed attribute causes inefficient alignment for %q+D
de: gepacktes Attribut verursacht ineffiziente Ausrichtung für %q+D

en: packed attribute causes inefficient alignment for %qE
de: gepacktes Attribut verursacht ineffiziente Ausrichtung für %qE

en: packed attribute is unnecessary
de: gepacktes Attribut ist unnötig

en: packed attribute is unnecessary for %q+D
de: gepacktes Attribut ist unnötig für %q+D

en: packed attribute is unnecessary for %qE
de: gepacktes Attribut ist für %qE unnötig

en: packed layout
de: Gepacktes Layout

en: padding struct size to alignment boundary
de: struct wird bis zur Ausrichtungsgrenze aufgefüllt

en: padding struct to align %q+D
de: struct wird aufgefüllt, um %q+D auszurichten

en: parameter %P has incomplete type %qT
de: Parameter %P hat unvollständigen Typen %qT

en: parameter %P of %qD has incomplete type %qT
de: Parameter %P von %qD hat unvollständigen Typen %qT

en: parameter %q+D declared %<_Noreturn%>
de: Parameter %q+D als %<_Noreturn%> deklariert

en: parameter %q+D declared %<inline%>
de: Parameter %q+D als %<inline%> deklariert

en: parameter %q+D has just a forward declaration
de: Parameter %q+D hat nur eine Vorwärtsdeklaration

en: parameter %qD declared with void type
de: Parameter %qD als void deklariert

en: parameter %qD has incomplete type
de: Parameter %qD hat unvollständigen Typen

en: parameter %qD includes pointer to array of unknown bound %qT
de: Parameter %qD bezieht Zeiger auf Feld mit unbekannter Grenze %qT ein

en: parameter %qD includes reference to array of unknown bound %qT
de: Parameter %qD bezieht Referenz auf Feld mit unbekannter Grenze %qT ein

en: parameter %qD invalidly declared method type
de: Parameter %qD deklariert ungültigerweise Methodentyp

en: parameter %qD is initialized
de: Parameter %qD ist initialisiert

en: parameter %qD may not appear in this context
de: Parameter %qD darf in diesem Kontext nicht auftauchen

en: parameter %qD set but not used
de: Parameter %qD gesetzt, jedoch nicht verwendet

en: parameter %qP of %qD might be a candidate for a format attribute
de: Parameter %qP von %qD könnte Kandidat für Formatattribut sein

en: parameter %u (%q+D) has incomplete type
de: Parameter %u (%q+D) hat unvollständigen Typen

en: parameter %u (%q+D) has void type
de: Parameter %u (%q+D) hat void-Typen

en: parameter %u has incomplete type
de: Parameter %u hat unvollständigen Typen

en: parameter %u has void type
de: Parameter %u hat void-Typen

en: parameter declaration before lambda declaration specifiers only optional with %<-std=c++2b%> or %<-std=gnu++2b%>
de: Parameterdeklaration vor Lambdadeklarationsangaben ist erst ab %<-std=c++2b%> oder %<-std=gnu++2b%> optional

en: parameter declaration before lambda exception specification only optional with %<-std=c++2b%> or %<-std=gnu++2b%>
de: Parameterdeklaration vor einer Lambda-Exception-Angabe ist erst ab %<-std=c++2b%> oder %<-std=gnu++2b%> optional

en: parameter declaration before lambda trailing return type only optional with %<-std=c++2b%> or %<-std=gnu++2b%>
de: Parameterdeklaration vor einem abschließenden Rückgabetyp ist erst ab %<-std=c++2b%> oder %<-std=gnu++2b%> optional

en: parameter declaration before lambda transaction qualifier only optional with %<-std=c++2b%> or %<-std=gnu++2b%>
de: Parameterdeklaration vor einem Lambda-Transaktions-Qualifizierer ist erst ab %<-std=c++2b%> oder %<-std=gnu++2b%> optional

en: parameter declared %<auto%>
de: Parameter als %<auto%> deklariert

en: parameter may not have variably modified type %qT
de: Parameter darf nicht variabel modifizierten Typ %qT haben

en: parameter might be a candidate for a format attribute
de: Parameter könnte ein Kandidat für ein Formatattribut sein

en: parameter name missing from parameter list
de: Parametername fehlt in Parameterliste

en: parameter names (without types) in function declaration
de: Parameternamen (ohne Typen) in Funktionsdeklaration

en: parameter pack %<__bases%> only valid in template declaration
de: Parameterpack %<__bases%> ist nur in Templatedeklaration gültig

en: parameter pack %q+D must be at the end of the template parameter list
de: Parameterpack %q+D muss am Ende der Templateparameterliste sein

en: parameter pack %qD cannot have a default argument
de: Parameterpack %qD kann kein Standardargument haben

en: parameter pack argument %qE must be at the end of the template argument list
de: Argument %qE für Parameterpack muss am Ende der Templateargumentliste sein

en: parameter pack argument %qT must be at the end of the template argument list
de: Argument %qT für Parameterpack muss am Ende der Templateargumentliste sein

en: parameter pack cannot have a default argument
de: Parameterpack kann kein Standardargument haben

en: parameter packs not expanded with %<...%>:
de: Parameterbündel nicht mit %<...%> aufgelöst:

en: parameter passing for argument of type %qT changed %{in GCC 12.1%}
de: die Parameterübergabe für das Argument vom Typ %qT hat sich %{mit GCC 12.1%} geändert

en: parameter passing for argument of type %qT changed in GCC 7.1
de: die Parameterübergabe für das Argument vom Typ %qT hat sich in GCC 7.1 geändert

en: parameter passing for argument of type %qT changed in GCC 9.1
de: die Parameterübergabe für das Argument vom Typ %qT hat sich in GCC 9.1 geändert

en: parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}
de: die Parameterübergabe für das Argument vom Typ %qT hat sich, sofern C++17 aktiviert ist, so geändert, dass es C++14 %{in GCC 10.1%} entspricht

en: parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}
de: die Parameterübergabe für das Argument vom Typ %qT mit %<[[no_unique_address]]%>-Elementen hat sich %{in GCC 10.1%} geändert

en: parameter passing for argument of type %qT with zero-width bit fields members changed in GCC 12
de: die Parameterübergabe für das Argument vom Typ %qT mit Bitfeldern der Breite 0 hat sich in GCC 12 geändert

en: parameter to builtin must be a string constant or literal
de: Parameter für eingebaute Funktion muss Zeichenkettenkonstante oder Literal sein

en: parameter to builtin not valid: %s
de: Parameter für eingebaute Funktion ist ungültig: %s

en: parametrized derived type argument
de: parametrisiertes abgeleitetes Typargument

en: parent subprogram cannot be inlined
de: Eltern-Unterprogramm kann nicht geinlinet werden

en: parentheses around %qE cannot be used to form a pointer-to-member-function
de: Klammern um %qE können nicht verwendet werden, einen Zeiger auf Elementfunktion zu erzeugen

en: parentheses must be omitted if %qE attribute argument list is empty
de: Klammern müssen weggelassen werden, wenn die Argumentliste des %qE-Attributs leer ist

en: parentheses must be omitted if attribute argument list is empty
de: Klammern müssen weggelassen werden, wenn die Argumentenliste des Attributs leer ist

en: parentheses required around this composite literal to avoid parsing ambiguity
de: Um dieses zusammengesetzte Literal sind Klammern erforderlich, um Mehrdeutigkeit zu vermeiden

en: parentheses were disambiguated as a function declaration
de: Klammern waren mehrdeutig und wurden als Funktionsdeklaration angesehen

en: parenthesized initialization is not allowed in OpenMP %<for%> loop
de: geklammerte Initialisierung ist in OpenMP-%<for%>-Schleife nicht erlaubt

en: parenthesized initializer in array new
de: geklammerte Initialisierung in Array-»new«

en: parse error in SELECT RANK statement at %C
de: Syntaxfehler in SELECT-RANK-Anweisung bei %C

en: parse error in SELECT TYPE statement at %C
de: Syntaxfehler in »SELECT TYPE«-Anweisung bei %C

en: parse error in template argument list
de: Syntaxfehler in Templateargumentliste

en: part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object
de: part-ref mit Zeigerattribut bei %L ist nicht das rechteste part-ref des data-stmt-objects

en: partial specialization %q+D does not specialize any template arguments and is not more constrained than the primary template; to define the primary template, remove the template argument list
de: Teilspezialisierung %q+D spezialisiert keine Templateargumente und ist nicht eingeschränkter als das primäre Template; um das primäre Template zu definieren, entfernen Sie die Templateargumentliste

en: partial specialization %q+D does not specialize any template arguments; to define the primary template, remove the template argument list
de: Teilspezialisierung %q+D spezialisiert keine Templateargumente; um das primäre Template zu definieren, entfernen Sie die Templateargumentliste

en: partial specialization %qD is not more specialized than
de: Teilspezialisierung %qD ist nicht spezialisierter als

en: partial specialization %qT declared %<friend%>
de: Teilspezialisierung %qT als %<friend%> deklariert

en: partial specialization is not more specialized than the primary template because it replaces multiple parameters with a pack expansion
de: partielle Spezialisierung ist nicht näher spezialisiert als das ursprüngliche Template, da es mehrere Parameter mit einer »pack«-Erweiterung ersetzt

en: partial specialization of %qD after instantiation of %qD
de: teilweise Spezialisierung von %qD nach Instanziierung von %qD

en: partition found but function partition flag not set
de: Interner Fehler: partition found but function partition flag not set

en: pass %qs not found but is referenced by new pass %qs
de: Durchlauf %qs nicht gefunden, wird jedoch von neuem Durchlauf %qs referenziert

en: passing %qT as %<this%> argument discards qualifiers
de: Die Übergabe von %qT als %<this%>-Argument streicht Qualifizierer

en: passing %qT chooses %qT over %qT
de: Übergabe von %qT wählt %qT statt %qT

en: passing %qT instead of the expected %qT to argument %d of %qE, after passing %qT to argument %d
de: Übergabe von %qT anstelle des erwarteten %qT an Argument %d von %qE, nachdem %qT an Argument %d übergeben wurde

en: passing %qT to argument %d of %qE, but %qT is not a valid SVE element type
de: Übergabe von %qT an Argument %d von %qE, aber %qT ist kein gültiger SVE-Elementtyp

en: passing %qT to argument %d of %qE, but argument %d had type %qT
de: Übergabe von %qT an Argument %d von %qE, aber Argument %d hatte den Typ %qT

en: passing %qT to argument %d of %qE, but its %qT form does not accept scalars
de: Übergabe von %qT an Argument %d von %qE, das jedoch in der %qT-Form keine Skalare akzeptiert

en: passing %qT to argument %d of %qE, but previous arguments had type %qT
de: Übergabe von %qT an Argument %d von %qE, aber vorherige Argumente waren vom Typ %qT

en: passing %qT to argument %d of %qE, which expects %qT
de: Übergabe von %qT an Argument %d von %qE, das jedoch %qT erwartet

en: passing %qT to argument %d of %qE, which expects %qs
de: Übergabe von %qT an das Argument %d von %qE, das jedoch %qs erwartet

en: passing %qT to argument %d of %qE, which expects %qs or %qs
de: Übergabe von %qT an Argument %d von %qE, das jedoch %qs oder %qs erwartet

en: passing %qT to argument %d of %qE, which expects a 32-bit or 64-bit integer type
de: Übergabe von %qT an Argument %d von %qE, das jedoch einen Ganzzahltyp von 32 oder 64 Bits erwartet

en: passing %qT to argument %d of %qE, which expects a pointer to 32-bit or 64-bit elements
de: Übergabe von %qT an Argument %d von %qE, das jedoch einen Zeiger auf Elemente erwartet, die 32 oder 64 Bit groß sind

en: passing %qT to argument %d of %qE, which expects a pointer type
de: Übergabe von %qT an Argument %d von %qE, das jedoch einen Zeigertyp erwartet

en: passing %qT to argument %d of %qE, which expects a scalar element
de: Übergabe von %qT an Argument %d von %qE, das jedoch ein skalares Element erwartet

en: passing %qT to argument %d of %qE, which expects a scalar integer
de: Übergabe von %qT an Argument %d von %qE, das jedoch eine Ganzzahl erwartet

en: passing %qT to argument %d of %qE, which expects a scalar pointer
de: Übergabe von %qT an Argument %d von %qE, das jedoch einen Zeiger auf einen skalaren Typen erwartet

en: passing %qT to argument %d of %qE, which expects a single SVE vector rather than a tuple
de: Übergabe von %qT an Argument %d von %qE, das jedoch einen einzelnen SVE-Vektor statt eines Tupels erwartet

en: passing %qT to argument %d of %qE, which expects a vector of %d-bit elements
de: Übergabe von %qT an Argument %d von %qE, das jedoch einen Vektor von Elementen erwartet, die %d Bit groß sind

en: passing %qT to argument %d of %qE, which expects a vector of %d-bit integers
de: Übergabe von %qT an Argument %d von %qE, das jedoch einen Vektor von Ganzzahlen mit %d Bits erwartet

en: passing %qT to argument %d of %qE, which expects a vector of 32-bit or 64-bit elements
de: Übergabe von %qT an Argument %d von %qE, das jedoch einen Vektor von Elementen der Größe 32 oder 64 Bit erwartet

en: passing %qT to argument %d of %qE, which expects a vector of 32-bit or 64-bit integers
de: Übergabe von %qT an Argument %d von %qE, das jedoch einen Vektor von Ganzzahlen mit Größe 32 oder 64 Bits erwartet

en: passing %qT to argument %d of %qE, which expects a vector of integers
de: Übergabe von %qT an Argument %d von %qE, das jedoch einen Vektor von Ganzzahlen erwartet

en: passing %qT to argument %d of %qE, which expects a vector of signed integers
de: Übergabe vom %qT an Argument %d von %qE, das jedoch einen Vektor von vorzeichenbehafteten Ganzzahlen erwartet

en: passing %qT to argument %d of %qE, which expects a vector of unsigned integers
de: Übergabe von %qT an Argument %d von %qE, das jedoch einen Vektor vorzeichenloser Ganzzahlen erwartet

en: passing %qT to argument %d of %qE, which expects a vector or pointer base address
de: Übergabe von %qT an Argument %d von %qE, das jedoch einen Vektor oder eine Zeiger-Basisadresse erwartet

en: passing %qT to argument %d of %qE, which expects a vector or scalar type
de: Übergabe von %qT an Argument %d von %qE, das jedoch einen Vektor oder einen skalaren Typen erwartet

en: passing %qT to argument %d of %qE, which expects an SVE tuple type
de: Übergabe von %qT an Argument %d von %qE, das jedoch einen SVE-Tupeltyp erwartet

en: passing %qT to argument %d of %qE, which expects an SVE vector type
de: Übergabe von %qT an Argument %d von %qE, das jedoch einen SVE-Vektortyp erwartet

en: passing %qT to argument %d of %qE, which when loading %qT expects a vector of %d-bit integers
de: Übergabe von %qT an Argument %d von %qE, das jedoch beim Laden von %qT einen Vektor von Ganzzahlen mit %d Bits erwartet

en: passing %qT to argument %d of %qE, which when storing %qT expects a vector of %d-bit integers
de: Übergabe von %qT an Argument %d von %qE, das jedoch beim Speichern von %qT einen Vektor von Ganzzahlen mit %d Bits erwartet

en: passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd
de: Übergabe von %wd an Argument %d von %qE, das jedoch entweder %wd, %wd, %wd oder %wd erwartet

en: passing %wd to argument %d of %qE, which expects a valid %qT value
de: Übergabe von %wd an Argument %d von %qE, das jedoch einen gültigen %qT-Wert erwartet

en: passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]
de: Übergabe von %wd an das Argument %d von %qE, das einen Wert im Bereich [%wd, %wd] erwartet

en: passing %wd to argument %d of %qE, which expects either %wd or %wd
de: Übergabe von %wd an Argument %d von %qE, das jedoch entweder %wd oder %wd erwartet

en: passing NULL to non-pointer argument %P of %qD
de: Übergabe von NULL an Nicht-Zeiger-Argument %P von %qD

en: passing argument %d of %qE as %<float%> rather than %<double%> due to prototype
de: Übergabe des Arguments %d von %qE als %<float%> statt %<double%> aufgrund des Prototyps

en: passing argument %d of %qE as %qT rather than %qT due to prototype
de: Übergabe des Arguments %d von %qE als %qT statt %qT aufgrund des Prototyps

en: passing argument %d of %qE as complex rather than floating due to prototype
de: Übergabe des Arguments %d von %qE als komplex statt Gleitkomma aufgrund des Prototyps

en: passing argument %d of %qE as complex rather than integer due to prototype
de: Übergabe des Arguments %d von %qE als komplex statt Ganzzahl aufgrund des Prototyps

en: passing argument %d of %qE as floating rather than complex due to prototype
de: Übergabe des Arguments %d von %qE als Gleitkomma statt komplex aufgrund des Prototyps

en: passing argument %d of %qE as floating rather than integer due to prototype
de: Übergabe des Arguments %d von %qE als Gleitkomma statt Ganzzahl aufgrund des Prototyps

en: passing argument %d of %qE as integer rather than complex due to prototype
de: Übergabe des Arguments %d von %qE als Ganzzahl statt komplex aufgrund des Prototyps

en: passing argument %d of %qE as integer rather than floating due to prototype
de: Übergabe des Arguments %d von %qE als Ganzzahl statt Gleitkomma aufgrund des Prototyps

en: passing argument %d of %qE as signed due to prototype
de: Übergabe des Arguments %d von %qE als vorzeichenbehaftet aufgrund des Prototyps

en: passing argument %d of %qE as unsigned due to prototype
de: Übergabe des Arguments %d von %qE als vorzeichenlos aufgrund des Prototyps

en: passing argument %d of %qE discards %qs qualifier from pointer target type
de: Übergabe des Arguments %d von %qE entfernt Kennzeichner %qs von Zeiger-Zieltyp

en: passing argument %d of %qE discards %qv qualifier from pointer target type
de: Übergabe des Arguments %d von %qE entfernt Kennzeichner %qv von Zeiger-Ziel-Typ

en: passing argument %d of %qE from distinct Objective-C type
de: Übergabe des Arguments %d von %qE von anderem Objective-C-Typ

en: passing argument %d of %qE from incompatible pointer type
de: Übergabe des Arguments %d von %qE von inkompatiblem Zeigertyp

en: passing argument %d of %qE from incompatible scalar storage order
de: Übergabe des Arguments %d von %qE von inkompatibler Speicherreihenfolge für Skalare

en: passing argument %d of %qE from pointer to non-enclosed address space
de: Übergabe des Arguments %d von %qE von Zeiger auf nicht eingeschlossenen Adressbereich

en: passing argument %d of %qE makes %q#v qualified function pointer from unqualified
de: Übergabe des Arguments %d von %qE erzeugt aus unqualifiziertem einen qualifizierten Funktionszeiger %q#v

en: passing argument %d of %qE makes integer from pointer without a cast
de: Übergabe des Arguments %d von %qE wandelt eine Zahl in einen Zeiger um, ohne explizite Typkonvertierung

en: passing argument %d of %qE makes pointer from integer without a cast
de: Übergabe des Arguments %d von %qE wandelt eine Zahl in einen Zeiger um, ohne explizite Typkonvertierung

en: passing argument %d of %qE with different width due to prototype
de: Übergabe des Arguments %d von %qE mit anderer Breite aufgrund des Prototyps

en: passing argument %i to %qs-qualified parameter aliases with argument %Z | passing argument %i to %qs-qualified parameter aliases with arguments %Z
de[0]: Argument %i wird an den mit %qs qualifizierten Parameter übergeben, dadurch wird es zum Alias für Argument %Z
de[1]: Argument %i wird an den mit %qs qualifizierten Parameter übergeben, dadurch wird es zum Alias für die Argumente %Z

en: passing arguments to ellipsis of inherited constructor %qD
de: Argumente werden an Auslassungspunkte des geerbten Konstruktors %qD übergeben

en: passing objects of non-trivially-copyable type %q#T through %<...%> is conditionally supported
de: Das Übergeben des nicht trivial-kopierbaren Typs %q#T über %<...%> ist »conditionally-supported« ([expr.call] 5.2.2/7)

en: passing too large argument on stack
de: Übergabe von zu großem Argument auf dem Stapel

en: patchable function entry %wu exceeds size %wu
de: patchbarer Funktionseintrag %wu überschreitet die Größe %wu

en: path:
de: Pfad:

en: pedwarn
de: Ped. Warnung

en: pedwarn:
de: Ped. Warnung:

en: perhaps %<#include <coroutine>%> is missing
de: möglicherweise fehlt %<#include <Koroutine>%>

en: perhaps insert a line break, or other disambiguation, to prevent this being considered a module control-line
de: vielleicht hilft ein Zeilenumbruch oder eine andere Kenntlichmachung, damit dies nicht mehr als Modul-Steuerzeile angesehen wird

en: perhaps you need explicit template arguments in your nested-name-specifier
de: vielleicht brauchen Sie explizite Templateargumente im »nested-name-specifier«

en: perhaps you want to explicitly add %<%T::%>
de: Sie könnten ein explizites %<%T::%> hinzufügen

en: permerror
de: Perm. Fehler

en: permerror:
de: Perm. Fehler:

en: placeholder constraints not satisfied
de: Platzhalter-Beschränkungen nicht erfüllt

en: placeholder type not allowed in this context
de: Platzhaltertyp ist in diesem Kontext nicht erlaubt

en: placement new constructing an array of objects of type %qT and size %qwu in a region of type %qT and size %qwi
de: Placement-New erzeugt ein Array von Objekten vom Typ %qT mit Größe %qwu in einer Region von Typ %qT mit Größe %qwi

en: placement new constructing an array of objects of type %qT and size %qwu in a region of type %qT and size at most %qwu
de: Placement-New erzeugt ein Array von Objekten vom Typ %qT mit Größe %qwu in einer Region vom Typ %qT mit Maximalgröße %qwu

en: placement new constructing an object of type %<%T [%wu]%> and size %qwu in a region of type %qT and size %qwi
de: Placement-New erzeugt ein Objekt vom Typ %<%T [%wu]%> mit Größe %qwu in einer Region von Typ %qT mit Größe %qwi

en: placement new constructing an object of type %<%T [%wu]%> and size %qwu in a region of type %qT and size at most %qwu
de: Placement-New erzeugt ein Objekt vom Typ %<%T [%wu]%> mit Größe %qwu in einer Region vom Typ %qT mit Maximalgröße %qwu

en: placement new constructing an object of type %qT and size %qwu in a region of type %qT and size %qwi
de: Placement-New erzeugt ein Objekt vom Typ %qT mit Größe %qwu in einer Region von Typ %qT mit Größe %qwi

en: placement new constructing an object of type %qT and size %qwu in a region of type %qT and size at most %qwu
de: Placement-New erzeugt ein Objekt vom Typ %qT mit Größe %qwu in einer Region vom Typ %qT mit Maximalgröße %qwu

en: please use an explicit cpu name; valid cpu names are: %s
de: bitte geben Sie den CPU-Namen explizit an. Gültige CPU-Namen sind: %s

en: plugin %qs was specified with different paths: %qs and %qs
de: Plugin %qs wurde mit anderen Pfaden angegeben: %qs und %qs

en: plugin %s is not licensed under a GPL-compatible license
    %s
de: Plugin %s ist nicht unter einer GPL-kompatiblen Lizenz lizenziert
    %s

en: plugin %s is not licensed under a GPL-compatible license %s
de: Plugin %s ist nicht unter einer GPL-kompatiblen Lizenz lizenziert: %s

en: plugin %s registered a null callback function for event %s
de: Plugin %s hat eine Null-Callback-Funktion für Ereignis %s registriert

en: plugin %s should be specified before %<-fplugin-arg-%s%> in the command line
de: Plugin %s sollte vor %<-fplugin-arg-%s%> in der Kommandozeile angegeben werden

en: plugin cannot register a missing pass
de: Plugin kann keinen fehlenden Durchlauf registrieren

en: plugin cannot register an unnamed pass
de: Plugin kann keinen unbenannten Durchlauf registrieren

en: plugin cannot register pass %qs without reference pass name
de: Plugin kann keinen Durchlauf %qs ohne Referenzdurchlaufnamen registrieren

en: plugin support is disabled; configure with %<--enable-plugin%>
de: Plugin-Unterstützung ist ausgeschaltet; mit %<--enable-plugin%> konfigurieren

en: pointer
de: Zeiger

en: pointer %qE may be used after %qD
de: Zeiger %qE wird möglicherweise nach %qD verwendet

en: pointer %qE used after %qD
de: Zeiger %qE wird nach %qD verwendet

en: pointer argument
de: Zeigerargument

en: pointer arithmetic for garbage-collected objects not allowed
de: Zeigerarithmetik für Objekte mit Garbage-Collection ist nicht erlaubt

en: pointer assignment
de: Zeigerzuweisung

en: pointer may be used after %qD
de: Zeiger wird möglicherweise nach %qD verwendet

en: pointer member %q+D declared here
de: das Zeigerelement %q+D wurde hier deklariert

en: pointer of type %<void *%> used in arithmetic
de: Zeiger auf Typen %<void *%> in Arithmetik verwendet

en: pointer of type %<void *%> used in subtraction
de: Zeiger des Typs %<void *%> in Subtraktion verwendet

en: pointer offset from symbol maybe incorrect
de: Zeigeroffset von Symbol könnte falsch sein

en: pointer or allocatable result
de: Zeiger oder allozierbares Resultat

en: pointer target types incompatible in C++
de: Zeiger-Zieltypen sind in C++ inkompatibel

en: pointer targeting address space %qs must be const in %qT
de: Zeiger auf Adressraum %qs muss in %qT konstant sein

en: pointer targeting address space %qs must be const in %s %q+D
de: Zeiger auf Adressraum %qs muss in %s %q+D konstant sein

en: pointer targets in assignment from %qT to %qT differ in signedness
de: Zeigerziele in Zuweisung von %qT nach %qT unterscheiden sich im Vorzeichenbesitz

en: pointer targets in initialization of %qT from %qT differ in signedness
de: Zeigerziele in Initialisierung von %qT nach %qT unterscheiden sich im Vorzeichenbesitz

en: pointer targets in passing argument %d of %qE differ in signedness
de: Zeigerziele bei Übergabe des Arguments %d von %qE unterscheiden sich im Vorzeichenbesitz

en: pointer targets in returning %qT from a function with return type %qT differ in signedness
de: Zeigerziele in Rückgabe von %qT aus einer Funktion mit Rückgabetyp %qT unterscheiden sich im Vorzeichenbesitz

en: pointer to a function used in arithmetic
de: Zeiger auf Funktion in Arithmetik verwendet

en: pointer to a function used in subtraction
de: Zeiger auf eine Funktion in Subtraktion verwendet

en: pointer to array loses qualifier in conditional expression
de: Zeiger auf Array verliert durch den Bedingungsausdruck Qualifizierer

en: pointer to array loses qualifier in conditional expression in ISO C before C2X
de: Zeiger auf Array verliert durch den Bedingungsausdruck Qualifizierer, in ISO C vor C2X

en: pointer to interface type has no methods
de: Zeiger auf Schnittstellentyp hat keine Methoden

en: pointer to member conversion via virtual base %qT
de: Umwandlung in Zeiger auf Element über virtuelle Basis %qT

en: pointer to member type %qT incompatible with object type %qT
de: Zeiger auf Elementtyp %qT mit Objekttyp %qT inkompatibel

en: pointer type mismatch between %qT and %qT of %qD and %qD in conditional expression
de: unverträgliche Zeigertypen %qT und %qT von %qD und %qD in bedingtem Ausdruck

en: pointer type mismatch in conditional expression
de: Zeigertyp passt nicht in bedingtem Ausdruck

en: pointer used after %qD
de: Zeiger wird nach %qD verwendet

en: pointer value used where a complex was expected
de: Zeigerwert verwendet, wo »complex« erwartet wurde

en: pointer value used where a floating-point was expected
de: Zeigerwert verwendet, wo Gleitkommawert erwartet wurde

en: pointer-to-member function %qE cannot be called without an object; consider using %<.*%> or %<->*%>
de: Zeiger auf Elementfunktion %qE kann nicht ohne Objekt aufgerufen werden; verwenden Sie beispielsweise %<.*%> oder %<->*%>

en: pointer-to-member-function type %qT requires an lvalue
de: Typ für Zeiger auf Elementfunktion %qT braucht einen lvalue

en: pointer-to-member-function type %qT requires an lvalue before C++20
de: Zeiger-auf-Element-Funktions-Typ %qT braucht vor C++20 einen lvalue

en: pointer-to-member-function type %qT requires an rvalue
de: Typ für Zeiger auf Elementfunktion %qT braucht einen rvalue

en: pointer/integer type mismatch in conditional expression
de: Zeiger-/Ganzzahltyp passt nicht in bedingtem Ausdruck

en: pointers are not permitted as case values
de: Zeiger sind nicht als case-Werte zugelassen

en: pointers to %<__regio_symbol%> address space are prohibited
de: Zeiger auf den Adressraum %<__regio_symbol%> sind verboten

en: pointers to disjoint address spaces used in conditional expression
de: Zeiger auf disjunkte Adressräume in bedingtem Ausdruck verwendet

en: polymorphic argument
de: polymorphes Argument

en: position plus size exceeds size of referenced object in %qs
de: Position plus Größe überschreitet die Größe des referenzierten Objekts in %qs

en: position-independent code requires %qs
de: lageunabhängiger Code erfordert %qs

en: position-independent code requires the Linux ABI
de: lageunabhängiger Code erfordert das Linux-ABI

en: positional initialization of field in %<struct%> declared with %<designated_init%> attribute
de: positionelle Initialisierung eines Feldes in %<struct%>, die mit dem %<designated_init%>-Attribut deklariert wurde

en: positive width required at %L
de: Positive Breite benötigt bei %L

en: possible problem detected in invocation of %<operator delete%>
de: mögliches Problem bei Aufruf von %<operator delete%> erkannt

en: possible problem detected in invocation of operator %<delete []%>
de: mögliches Problem bei Aufruf von %<operator delete []%> erkannt

en: post-increment address is not a register
de: Post-Increment-Adresse ist kein Register

en: post-module-declaration imports must be contiguous
de: post-module-declarations müssen zusammenhängend sein

en: post-module-declaration imports must not be from header inclusion
de: %<post-module-declaration%>-Importe dürfen nicht aus Header-Einbindung stammen

en: post-module-declaration imports must not be include-translated
de: %<post-module-declaration%>-Importe dürfen nicht %<include-translated%> sein

en: postfix %qD must have %<int%> as its argument
de: Suffix-%qD muss %<int%> als sein Argument nehmen

en: postfix %qD must have %<int%> as its second argument
de: Suffix-%qD muss %<int%> als sein zweites Argument nehmen

en: postfix %qD should return %qT
de: Suffix-%qD sollte %qT zurückgeben

en: potential null pointer dereference
de: Mögliche Dereferenzierung eines Nullzeigers

en: power9 target option is incompatible with %<%s=<xxx>%> for <xxx> less than power9
de: power9-Zieloption ist mit %<%s=<xxx>%> für <xxx> kleiner als power9 inkompatibel

en: pragma or attribute %<target("%s")%> does not accept an argument
de: Pragma oder Attribut %<target("%s")%> akzeptiert keine Argumente

en: pragma or attribute %<target("%s")%> does not allow a negated form
de: Pragma oder Attribut %<target("%s")%> erlaubt keine negierte Form

en: pragma or attribute %<target("%s")%> is not valid
de: Pragma oder Attribut %<target("%s")%> ist nicht gültig

en: pragma or attribute %<target("%s=%s")%> is not valid
de: Pragma oder Attribut %<target("%s=%s")%> ist nicht gültig

en: pragma(%s) not implemented
de: pragma(%s) ist nicht implementiert

en: pre-decrement address is not a register
de: Pre-Decrement-Adresse ist kein Register

en: pre-increment address is not a register
de: Pre-Increment-Adresse ist kein Register

en: precision
de: Genauigkeit

en: precision in printf format
de: Genauigkeit im printf-Format

en: predeclared arithmetic type %qT in %<#pragma omp declare reduction%>
de: vordeklarierter arithmetischer Typ %qT in %<#pragma omp declare reduction%>

en: predeclared arithmetic type in %<#pragma omp declare reduction%>
de: vordefinierter arithmetischer Typ in %<#pragma omp declare reduction%>

en: predicated Thumb instruction
de: bedingter Thumb-Befehl

en: predicated instruction in conditional sequence
de: bedingter Befehl in bedingter Sequenz

en: prefix %qD should return %qT
de: Präfix-%qD sollte %qT zurückgeben

en: prefix attributes are ignored before %<@%D%>
de: Präfix-Attribute vor %<@%D%> werden ignoriert

en: prefix attributes are ignored for implementations
de: Präfixattribute werden für Implementierungen ignoriert

en: prefix attributes are ignored for methods
de: Präfixattribute werden für Methoden ignoriert

en: prev_bb of %d should be %d, not %d
de: Interner Fehler: prev_bb of %d should be %d, not %d

en: previous %<#pragma omp declare reduction%>
de: vorheriges %<#pragma omp declare reduction%>

en: previous %<pragma omp declare reduction%> declaration
de: vorherige Deklaration von %<pragma omp declare reduction%>

en: previous declaration
de: vorherige Deklaration

en: previous declaration %q#D
de: vorherige Deklaration von %q#D

en: previous declaration %q#D here
de: vorherige Deklaration von %q#D ist hier

en: previous declaration %qD
de: vorherige Deklaration %qD

en: previous declaration %qD used %d template parameter | previous declaration %qD used %d template parameters
de[0]: vorherige Deklaration %qD verwendete %d Template-Parameter
de[1]: vorherige Deklaration %qD verwendete %d Template-Parameter

en: previous declaration as %q#D
de: bisherige Deklaration als %q#D

en: previous declaration here
de: vorherige Deklaration hier

en: previous declaration of %<%c%E%>
de: vorherige Deklaration von %<%c%E%>

en: previous declaration of %<%c%E%> as %<@optional%>
de: vorherige Deklaration von %<%c%E%> als %<@optional%>

en: previous declaration of %<%c%E%> as %<@required%>
de: vorherige Deklaration von %<%c%E%> als %<@required%>

en: previous declaration of %<%c%s%>
de: vorherige Deklaration von %<%c%s%>

en: previous declaration of %q#D
de: vorherige Deklaration von %q#D

en: previous declaration of %q+D
de: vorherige Deklaration von %q+D

en: previous declaration of %q+D with type %qT
de: vorherige Deklaration von %qD vom Typ %qT

en: previous declaration of %qD
de: vorherige Deklaration von %qD

en: previous declaration of %qD here
de: vorherige Deklaration von %qD war hier

en: previous declaration of %qE
de: vorherige Deklaration von %qE

en: previous declaration with %qL linkage
de: bisherige Deklaration mit %qL-Bindung

en: previous definition here
de: vorherige Definition hier

en: previous definition of %q#T
de: vorherige Definition von %q#T

en: previous definition of %q+D with type %qT
de: vorherige Definition von %q+D vom Typ %qT

en: previous definition of %qD here
de: vorherige Definition von %qD war hier

en: previous implicit declaration of %q+D with type %qT
de: vorherige implizite Deklaration von %q+D vom Typ %qT

en: previous label
de: vorherige Sprungmarke

en: previous mangling %q#D
de: vorherige Mangelung von %q#D

en: previous non-prototype definition here
de: vorherige Nicht-Prototyp-Definition hier

en: previous specification
de: vorherige Angabe

en: previous specification in %q#D here
de: bisherige Spezifikation in %q+#D hier

en: previously declared as %s
de: vorher als %s deklariert

en: previously declared as %s with %u unspecified variable bound | previously declared as %s with %u unspecified variable bounds
de[0]: war vorher als %s mit %u unspezifizierten Variablengrenze deklariert
de[1]: war vorher als %s mit %u unspezifizierten Variablengrenzen deklariert

en: previously declared as %s with %u variable bound | previously declared as %s with %u variable bounds
de[0]: war vorher als %s mit %u Variablengrenze deklariert
de[1]: war vorher als %s mit %u Variablengrenzen deklariert

en: previously declared as %s with bound %<%s%>
de: war vorher als %s deklariert, mit Grenze %qs

en: previously declared as %s with bound %qs
de: war vorher als %s deklariert, mit Grenze %qs

en: previously declared as %s with bound argument %E
de: war vorher als %s deklariert, mit Grenzargument %E

en: previously declared as a pointer %s
de: war vorher als Zeiger %s deklariert

en: previously declared as a variable length array %s
de: war vorher als Array variabler Länge %s deklariert

en: previously declared as an array %s
de: war vorher als Array %s deklariert

en: previously declared as an ordinary array %s
de: war vorher als gewöhnliches Array %s deklariert

en: previously declared here
de: vorher hier deklariert

en: previously defined here
de: vorher hier definiert

en: previously defined here as %s
de: vorher hier als %s definiert

en: previously used here
de: Bereits hier verwendet

en: primary template %qD
de: primäres Template %qD

en: primary template here
de: ursprüngliches Template hier

en: private member %q#D in anonymous union
de: privates Element %q#D in anonymer Union

en: private module fragment
de: private-module-fragment

en: private module fragment only permitted in purview of module interface or partition
de: %<private-module-fragment%> ist nur im Zuständigkeitsbereich eines Modulinterfaces oder einer Partition zulässig

en: probability %qE is outside the range [0.0, 1.0]
de: Wahrscheinlichkeit %qE liegt außerhalb des Bereichs [0.0, 1.0]

en: probability %qE must be constant floating-point expression
de: Wahrscheinlichkeit %qE muss eine konstanter Gleitkommaausdruck sein

en: problem with building target image for %s
de: Problem beim Erstellen des Zielabbilds für %s

en: product %<%E * %E%> of arguments %i and %i exceeds %<SIZE_MAX%>
de: Produkt %<%E * %E%> der Argumente %i und %i überschreitet %<SIZE_MAX%>

en: product %<%E * %E%> of arguments %i and %i exceeds maximum object size %E
de: Produkt %<%E * %E%> der Argumente %i und %i überschreitet maximale Objektgröße %E

en: profile data for function %u is corrupted
de: Profildaten für Funktion %u sind beschädigt

en: profile for function %qD not found in profile data
de: Profil für Funktion %qD nicht in Profilingdaten gefunden

en: profiler support for CR16
de: Profilerunterstützung für CR16

en: profiler support for VxWorks
de: Profilerunterstützung für VxWorks

en: profiling %<-mcmodel=large%> with PIC is not supported
de: Profiling von %<-mcmodel=large%> wird mit PIC nicht unterstützt

en: profiling is not yet implemented for this architecture
de: Profiling ist für dieses Ziel noch nicht implementiert

en: profiling not supported with -mg
de: Profiling wird mit »-mg« nicht unterstützt

en: programs: %s
de: Programme: %s

en: promoted argument %qD doesn%'t match built-in prototype
de: weitergegebenes Argument %qD passt nicht zu eingebautem Prototypen

en: promoted argument %qD doesn%'t match prototype
de: weitergegebenes Argument %qD passt nicht zum Prototypen

en: promoted bitwise complement of an unsigned value is always nonzero
de: das beförderte (promoted) bitweise Komplement eines vorzeichenlosen Wertes ist immer ungleich Null, da die höchstwertigen Bits 1 sind

en: properties for %<simd%> selector may not be specified in %<metadirective%>
de: Eigenschaften für %<simd%>-Selektor dürfen nicht in %<metadirective%> angegeben werden

en: properties must be named
de: Eigenschaften müssen benannt sein

en: property %qs already specified in %<@dynamic%>
de: Eigenschaft %qs ist bereits in %<@dynamic%> festgelegt

en: property %qs already specified in %<@synthesize%>
de: Eigenschaft %qs ist bereits in %<@synthesize%> festgelegt

en: property %qs is using instance variable %qs of incompatible type
de: Eigenschaft %qs verwendet Instanzvariable %qs unverträglichen Typs

en: property %qs is using the same instance variable as property %qs
de: Eigenschaft %qs verwendet dieselbe Instanzvariable wie die Eigenschaft %qs

en: property cannot be a bit-field
de: Eigenschaft kann kein Bitfeld sein

en: property cannot be an array
de: Eigenschaft kann kein Array sein

en: property declaration not in %<@interface%>, %<@protocol%> or %<category%> context
de: Eigenschaftsdeklaration nicht im Kontext von %<@interface%>, %<@protocol%> oder %<category%>

en: property must be constant integer expression
de: Eigenschaft muss ein konstanter ganzzahliger Ausdruck sein

en: property must be constant integer expression or string literal
de: Eigenschaft muss ein konstanter ganzzahliger Ausdruck oder ein Zeichenkettenliteral sein

en: property must be constant integer expression or string literal at %C
de: Eigenschaft bei %C muss ein konstanter ganzzahliger Ausdruck oder ein Zeichenkettenliteral sein

en: property must be constant integer or logical expression at %C
de: Eigenschaft bei %C muss ein konstanter ganzzahliger oder logischer Ausdruck sein

en: protected member %q#D in anonymous union
de: geschütztes Element %q#D in anonymer Union

en: protected visibility attribute not supported in this configuration; ignored
de: geschützte Sichtbarkeitsattribute werden in dieser Konfiguration nicht unterstützt; ignoriert

en: protocol %qE has circular dependency
de: Protokoll %qE hat ringförmige Abhängigkeit

en: protocol %qE is deprecated
de: Protokoll %qE ist veraltet

en: protocol %qE is unavailable
de: Protokoll %qE ist nicht verfügbar

en: protocol attributes are not available in Objective-C 1.0
de: Protokoll-Attribute sind in Objective-C 1.0 nicht verfügbar

en: prototype declaration
de: Prototyp-Deklaration

en: prototype declared here
de: der Prototyp wurde hier deklariert

en: prototype for %q+D declares argument %d with incompatible type
de: Prototyp für %q+D deklariert Argument %d mit inkompatiblem Typen

en: prototype for %q+D declares fewer arguments than previous old-style definition
de: Prototyp für %q+D deklariert weniger Argumente als vorherige Definition im alten Stil

en: prototype for %q+D declares more arguments than previous old-style definition
de: Prototyp für %q+D deklariert mehr Argumente als vorherige Definition im alten Stil

en: prototype for %q+D follows non-prototype definition
de: Prototyp für %q+D folgt einer Nicht-Prototyp-Definition

en: prototype for '%s' has required operands after optional operands
de: Prototyp für »%s« hat Pflichtoperanden hinter optionalen Operanden

en: prototype specified for %q#D
de: Prototyp für %q#D angegeben

en: provided for %qD
de: für %qD bereitgestellt

en: pseudo-destructor is not called
de: Pseudo-Destruktor wird nicht aufgerufen

en: pure virtual %q#D called from constructor
de: pure virtuelle %q#D aus Konstruktor heraus aufgerufen

en: pure virtual %q#D called from destructor
de: pure virtuelle %q#D aus Destruktor heraus aufgerufen

en: pure virtual %q#D called from non-static data member initializer
de: pure virtuelle %q#D aus nichtstatischem Datenelement-Initialisierer heraus aufgerufen

en: pure-specifier on function-definition
de: reiner Spezifizierer bei Funktionsdefinition

en: q/Q modifiers invalid for symbol references
de: q/Q-Modifizierer für Symbolreferenzen ungültig

en: qsort checking failed
de: Überprüfung für qsort-Vergleichsfunktion fehlgeschlagen

en: qsort comparator non-negative on sorted output: %d
de: Vergleichsfunktion für qsort liefert nicht-negatives Ergebnis für sortierte Ausgabe: %d

en: qsort comparator not anti-symmetric: %d, %d
de: Vergleichsfunktion für qsort ist nicht antisymmetrisch: %d, %d

en: qsort comparator not transitive: %d, %d, %d
de: Vergleichsfunktion für qsort ist nicht transitiv: %d, %d, %d

en: qualified name does not name a class
de: qualifizierter Name benennt keine Klasse

en: qualified type %qT does not match destructor name ~%qT
de: qualifizierter Typ %qT passt nicht zum Destruktornamen ~%qT

en: qualified-id in declaration
de: qualified-id in Deklaration

en: qualifiers are not allowed on constructor declaration
de: Qualifizierer sind bei Konstruktordeklarationen nicht erlaubt

en: qualifiers are not allowed on declaration of %<operator %T%>
de: Qualifizierer sind bei Deklaration von %<operator %T%> nicht erlaubt

en: qualifiers are not allowed on declaration of deduction guide
de: Qualifizierer sind bei Deklaration von Herleitungshinweis nicht erlaubt

en: qualifiers are not allowed on destructor declaration
de: Qualifizierer sind bei Destruktordeklarationen nicht erlaubt

en: qualifying type %qT does not match destructor name ~%qT
de: qualifizierender Typ %qT passt nicht zum Destruktornamen ~%qT

en: quoted %qs directive in format
de: %qs innerhalb von Anführungszeichen im Format

en: quoted %qs directive in format; use %qs instead
de: %qs-Direktive innerhalb von Anführungszeichen im Format; verwenden Sie stattdessen %qs

en: r0 needs to be available as a call-clobbered register
de: r0 muss als aufrufzerstörtes Register verfügbar sein

en: range clause must have array, slice, string, map, or channel type
de: Bereichsklausel muss vom Typ Array, Scheibe, Zeichenkette, Map oder Kanal sein

en: range expressions in switch statements are non-standard
de: Wertebereichsausdrücke in switch-Anweisungen sind nicht standardkonform

en: range-based %<for%> expression of type %qT has incomplete type
de: bereichsbasierter %<for%>-Ausdruck mit Typ %qT hat unvollständigen Typ

en: range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>
de: Bereichsbasierte %<for%>-Schleifen sind nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>
de: Bereichsbasierte %<for%>-Schleifen mit Initialisierer sind erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar

en: rank + corank of %qs exceeds %d at %C
de: Rang + Korang von %qs übersteigt %d bei %C

en: raw literal operator %q#D conflicts with literal operator template
de: roher Literaloperator %q#D steht mit literalem Operatortemplate in Konflikt

en: rdynamic is not supported
de: rdynamic wird nicht unterstützt

en: re-initialization of %qs at %L
de: Reinitialisierung von %qs bei %L

en: reachable %s definition here
de: Erreichbarkeitsdefinition %s ist hier

en: read failed while reading export data
de: Lesen der Export-Daten gescheitert

en: read-only location %qE used as %<asm%> output
de: schreibgeschützte Stelle %qE als %<asm%>-Ausgabe verwendet

en: read-only member %qD used as %<asm%> output
de: schreibgeschütztes Element %qD als %<asm%>-Ausgabe verwendet

en: read-only named return value %qD used as %<asm%>output
de: schreibgeschützter benannter Rückgabewert %qD als %<asm%>-Ausgabe verwendet

en: read-only parameter %qD use as %<asm%> output
de: schreibgeschützter Parameter %qD als %<asm%>-Ausgabe verwendet

en: read-only reference %qD used as %<asm%> output
de: schreibgeschützte Referenz %qD als %<asm%>-Ausgabe verwendet

en: read-only variable %qD used as %<asm%> output
de: schreibgeschützte Variable %qD als %<asm%>-Ausgabe verwendet

en: reading %E byte from a region of size %E
de: Code liest %E Byte aus einer Region der Größe %E

en: reading %E bytes from a region of size %E
de: Code liest %E Bytes aus einer Region der Größe %E

en: reading %E or more bytes from a region of size %E
de: Code liest %E oder mehr Bytes aus einer Region der Größe %E

en: reading CMI %qs
de: CMI %qs wird gelesen

en: reading between %E and %E bytes from a region of size %E
de: Code liest zwischen %E und %E Bytes aus einer Region der Größe %E

en: reading input file
de: Eingabedatei wird gelesen

en: reading through null pointer (argument %d)
de: Lesen über Null-Zeiger (Argument %d)

en: receiving objects of non-trivially-copyable type %q#T through %<...%> is conditionally-supported
de: Das Übergeben des nicht trivial-kopierbaren Typs %q#T über %<...%> ist »conditionally-supported« ([expr.call] 5.2.2/7)

en: recompiling with %<-fcompare-debug%>
de: Neuübersetzung mit %<-fcompare-debug%>

en: recursive call
de: rekursiver Aufruf

en: recursive evaluation of default argument for %q#D
de: rekursive Auswertung des Standardarguments für %q#D

en: recursive inlining
de: rekursives Inlining

en: recursive instantiation of default member initializer for %qD
de: rekursive Instanziierung von Vorgabeinitialisierer für Element %qD

en: recursive lazy load
de: rekursives verzögertes Laden

en: recursive reference %qs
de: rekursive Referenz %qs

en: recursive type %qT undefined
de: rekursiver Typ %qT nicht definiert

en: recursively required by substitution of %qS
de: rekursiv erforderlich durch Ersetzung von %qS

en: recursively required from %q#D
de: rekursiv erfordert von %q#D

en: recursively required from here
de: rekursiv erfordert von hier

en: redeclaration %q#D with different constraints
de: Redeklaration %q#D mit unterschiedlichen Constraints

en: redeclaration %qD differs in %qs from previous declaration
de: Redeklaration %qD unterscheidet sich in %qs von vorheriger Deklaration

en: redeclaration of %<enum %E%>
de: Redeklaration von %<enum %E%>

en: redeclaration of %<pragma omp declare reduction%>
de: Redeklaration von %<pragma omp declare reduction%>

en: redeclaration of %q#D
de: Redeklaration von %q#D

en: redeclaration of %q#D may not have default arguments
de: Redeklaration von %q#D hat möglicherweise keine Default-Argumente

en: redeclaration of %q#D with different template parameters
de: Neudeklaration von %q#D mit unterschiedlichen Templateparametern

en: redeclaration of %q+D with different visibility (old visibility preserved)
de: Redeklaration von %q+D mit anderer Sichtbarkeit (alte Sichtbarkeit beibehalten)

en: redeclaration of %q+D with no linkage
de: Redeklaration von %q+D ohne Bindung

en: redeclaration of %qD adds abi tag %qE
de: Redeklaration von %qD fügt ABI-Marke %qE hinzu

en: redeclaration of %qT as a non-template
de: Redeklaration von %qT als Nicht-Template

en: redeclaration of %qs %<#pragma omp declare reduction%> for type %qT
de: Redeklaration von %qs %<#pragma omp declare reduction%> für Typ %qT

en: redeclaration of C++ built-in type %qT
de: Redeklaration des eingebauten C++-Typs %qT

en: redeclaration of Objective-C class %qs
de: Redeklaration der Objective-C-Klasse %qs

en: redeclaration of enumerator %q+D
de: Redeklaration von Aufzählung %q+D

en: redeclaration of friend %q#D may not have default template arguments
de: Redeklaration des »friend« %q#D kann keine Standardtemplateargumente haben

en: redeclaration of property %qD
de: Redeklaration der Eigenschaft %qD

en: redeclared here
de: hier erneut deklariert

en: redeclared here as %q#D
de: hier als %q#D redeklariert

en: redeclared with %d template parameter | redeclared with %d template parameters
de[0]: mit %d Template-Parameter redeklariert
de[1]: mit %d Template-Parametern redeklariert

en: redefined extern inline functions are not considered for inlining
de: redefinierte »extern inline«-Funktionen kommen nicht als »inline« in Betracht

en: redefinition of %<CTABLE_ENTRY %
de: N/A

en: redefinition of %<struct %E%>
de: Redefinition von %<struct %E%>

en: redefinition of %<union %E%>
de: Redefinition von %<union %E%>

en: redefinition of %q#D
de: Redefinition von %q#D

en: redefinition of %q#T
de: Redefinition von %q#T

en: redefinition of %q+D
de: Redefinition von %q+D

en: redefinition of default argument for %q+#D
de: Neudefinition des Standardarguments für %q+#D

en: redefinition of parameter %q+D
de: Redefinition des Parameters %q+D

en: redefinition of typedef %q+D
de: Redefinition des typedef %q+D

en: redefinition of typedef %q+D with different type
de: Redefinition des typedef %q+D mit anderem Typ

en: redefinition of typedef %q+D with variably modified type
de: Redefinition des typedef %q+D mit variabel modifiziertem Typ

en: redundant class-key %qs in reference to %q#T
de: redundanter Klassenschlüssel %qs in Verweis auf %q#T

en: redundant enum-key %<enum%s%> in reference to %q#T
de: redundanter Aufzählungsschlüssel %<enum%s%> in Bezug auf %q#T

en: redundant move in return statement
de: redundantes Verschieben in Rückgabeanweisung

en: redundant redeclaration of %<constexpr%> static data member %qD
de: redundante Redeklaration von %<constexpr%>static-Datenmember %qD

en: redundant redeclaration of %q+D
de: Redundante Redeklaration von %q+D

en: redundant redeclaration of %qD in same scope
de: redundante Redeklaration von %qD im selben Gültigkeitsbereich

en: ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>
de: ref-Qualifizierer sind nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: reference %<dynamic_cast%> failed
de: %<dynamic_cast%> auf Referenz fehlgeschlagen

en: reference %qD is initialized with itself
de: Referenz %qD wird mit sich selbst initialisiert

en: reference %qD is not yet bound to a value when used here
de: die Referenz %qD ist noch nicht an einen Wert gebunden, wenn sie hier verwendet wird

en: reference %qs cannot be declared %<mutable%>
de: Referenz %qs kann nicht als %<mutable%> deklariert sein

en: reference has both stmt and lto_stmt_uid set
de: Verweis hat sowohl stmt als auch lto_stmt_uid gesetzt

en: reference to %<%T::%D%> is ambiguous
de: Referenz auf %<%T::%D%> ist mehrdeutig

en: reference to %qD is ambiguous
de: Referenz auf %qD ist mehrdeutig

en: reference to dead statement
de: Interner Fehler: reference to dead statement

en: reference to local variable %qD returned
de: Referenz auf lokale Variable %qD zurückgegeben

en: reference type %qT in %<#pragma omp declare reduction%>
de: Referenztyp %qT in %<#pragma omp declare reduction%>

en: referenced argument declared here
de: das referenzierte Argument wird hier deklariert

en: referenced symbol declared here
de: das referenzierte Symbol wird hier deklariert

en: referencing argument %u of type %qT
de: das verweisende Argument %u vom Typ %qT

en: region contains %s partitioned code but is not %s partitioned
de: Region enthält mit %s partitionierten Code, ist aber nicht mit %s partitioniert

en: region is %s partitioned but does not contain %s partitioned code
de: Region ist mit %s partitioniert, enthält aber keinen mit %s partitionierten Code

en: region of lp %i is wrong
de: Region von lp %i ist falsch

en: register name %<%s%> not recognized in %<__regio_symbol%> address space
de: Registername %qs ist im Adressraum %<__regio_symbol%> unbekannt

en: register name given for non-register variable %q+D
de: Registername für Nicht-Registervariable %q+D angegeben

en: register name not specified for %q+D
de: für %q+D wurde kein Registername angegeben

en: register number must be a compile-time constant.  Try giving higher optimization levels
de: Registernummer muss bereits zur Kompilierzeit eine Konstante sein. Probieren Sie eine stärkere Optimierungsstufe

en: register number must be in range 0-31 for %s
de: Registernummer für %s muss im Bereich von 0 bis 31 liegen

en: register of %qD used for multiple global register variables
de: Register von %qD für mehrere globale Registervariablen verwendet

en: register or memory expression expected for 'M' output modifier
de: Register oder Speicherausdruck für Ausgabemodifizierer »M« erwartet

en: register or memory expression expected for 'N' output modifier
de: Register oder Speicherausdruck für Ausgabemodifizierer »N« erwartet

en: register specified for %q+D is an internal GCC implementation detail
de: für %q+D angegebenes Register ist ein GCC-internes Implementierungsdetail

en: register specified for %q+D isn%'t suitable for data type
de: für %q+D angegebenes Register eignet sich nicht für Datentyp

en: register variable %qD used in nested function
de: Register-Variable %qD in verschachtelter Funktion verwendet

en: regparam and thiscall attributes are not compatible
de: Attribute regparam und thiscall sind nicht verträglich

en: regparm nested function not supported with %<__builtin_eh_return%>
de: geschachtelte Funktion mit regparm wird mit %<__builtin_eh_return%> nicht unterstützt

en: reimplementation of class %qE
de: Reimplementation der Klasse %qE

en: relaxed transaction in %<transaction_safe%> function
de: entspannte Transaktion in %<transaction_safe%>-Funktion

en: relaxed transaction in atomic transaction
de: entspannte Transaktion in atomarer Transaktion

en: remove %<std::move%> call
de: entfernen Sie den Aufruf von %<std::move%>

en: remove %<{ }%> around initializer
de: entfernen Sie die %<{ }%> um den Initialisierer

en: remove parentheses
de: entfernen Sie die Klammern

en: remove parentheses to default-initialize a variable
de: entfernen Sie die Klammern, um stattdessen eine Variable mit ihrem Vorgabewert zu initialisieren

en: remove the class-key or replace it with %qs
de: entfernen Sie den Klassenschlüssel oder ersetzen Sie ihn durch %qs

en: removed loop %d in loop tree
de: Interner Fehler: removed loop %d in loop tree

en: rename spec %s to %s
de: Spezifikation wird von %s nach %s umbenannt

en: repeated %<@%> before Objective-C string
de: wiederholtes %<@%> vor Objective-C-Zeichenkette

en: repeated %s in format
de: wiederholtes %s im Format

en: replace parentheses with braces to declare a variable
de: ersetzen Sie die Klammern durch geschweifte Klammern, um eine Variable zu deklarieren

en: replace the class-key with %qs
de: Klassenschlüssel durch %qs ersetzen

en: request for implicit conversion from %qT to %qT not permitted in C++
de: Anfrage zur impliziten für Umwandlung von %qT in %qT ist in C++ nicht erlaubt

en: request for member %qD in %qE, which is of non-class type %qT
de: Abfrage des Elementes %qD in %qE, das vom Nicht-Klassentyp %qT ist

en: request for member %qD in %qE, which is of pointer type %qT (maybe you meant to use %<->%> ?)
de: Anforderung des Elements %qD in %qE, das vom Zeigertyp %qT ist (vielleicht war %<->%> gemeint?)

en: request for member %qD is ambiguous
de: Abfrage des Elementes %qD ist mehrdeutig

en: request for member %qD is ambiguous in multiple inheritance lattice
de: Abfrage des Elementes %qD ist im Gitter der Mehrfachvererbung mehrdeutig

en: request for member %qE in non-class type %qT
de: Abfrage des Elementes %qE in Nicht-Klassentyp %qT

en: request for member %qE in something not a structure or union
de: Anfrage nach Element %qE in etwas, was keine Struktur oder Variante ist

en: requested %<init_priority%> %i is out of range [0, %i]
de: angeforderte %<init_priority%> %i liegt außerhalb des Bereichs [0, %i]

en: requested %<init_priority%> %i is reserved for internal use
de: angeforderte %<init_priority%> %i ist für interne Verwendung reserviert

en: requested %<init_priority%> is not an integer constant
de: angeforderte %<init_priority%> muss ganzzahlig und konstant sein

en: requested %qE attribute is not a comma separated pair of non-negative integer constants or too large (max. %d)
de: das angeforderte %qE-Attribut ist kein kommaseparierter Paar von nichtnegativen ganzzahligen Konstanten, oder es ist zu groß (maximal %d)

en: requested ABI requires %<-march%> to subsume the %qc extension
de: die angeforderte ABI erfordert %<-march%>, um die %qc-Erweiterung zu ermitteln

en: requested alignment %qE exceeds maximum %u
de: verlangte Ausrichtung %qE übersteigt den Höchstwert %u

en: requested alignment %qE exceeds object file maximum %u
de: verlangte Ausrichtung %qE ist größer als die maximale Dateigröße %u

en: requested alignment %qE is not a positive power of 2
de: Verlangte Ausrichtung %qE ist keine positive Zweierpotenz

en: requested alignment for %q+D is greater than implemented alignment of %wu
de: angeforderte Ausrichtung für %q+D ist größer als die implementierte Ausrichtung von %wu

en: requested alignment is not an integer constant
de: Verlangte Ausrichtung ist keine Ganzzahlkonstante

en: requested position is less than zero
de: Angeforderte Position ist kleiner als Null

en: requested position is not an integer constant
de: Angeforderte Position ist keine Ganzzahlkonstante

en: require id argument in the string
de: Zeichenkette erfordert ID-Argument

en: required by substitution of %qS
de: erforderlich durch Ersetzung von %qS

en: required from %q#D
de: erfordert durch %q#D

en: required from here
de: von hier erfordert

en: requires
de: erfordert

en: requires-clause on declaration of non-function type %qT
de: »requires«-Klausel in Deklaration von Nichtfunktionstyp %qT

en: requires-clause on return type
de: »requires«-Klausel für Rückgabetyp

en: requires-clause on type-id
de: requires-clause an type-id

en: requires-clause on typedef
de: requires-clause an Typedef

en: resolution sub id %wx not in object file
de: Auflösungs-Sub-ID %wx nicht in Objekt-Datei

en: resolve_function(): bad function type
de: Interner Fehler: resolve_function(): bad function type

en: resolver indirect function declared here
de: Auflöser-indirekte Funktion ist hier deklariert

en: result of %<operator->()%> yields non-pointer result
de: Ergebnis von %<operator->()%> ergibt Nicht-Zeiger-Ergebnis

en: result of %qE requires %u bits to represent, but %qT only has %u bits
de: Ergebnis von %qE erfordert %u Bits, aber %qT hat nur %u Bits

en: result type is not a plain type-constraint
de: Rückgabetyp ist keine einfache Typ-Einschränkung

en: result with non-constant character length
de: Resultat mit nicht konstanter Zeichenlänge

en: return address signing is only supported for %<-mabi=lp64%>
de: Signieren der Rückgabeadresse wird nur für %<-mabi=lp64%> unterstützt

en: return discards %qv qualifier from pointer target type
de: return streicht Qualifizierer %qv von Zeiger-Zieltyp

en: return edge does not point to exit in bb %d
de: Interner Fehler: return edge does not point to exit in bb %d

en: return from pointer to non-enclosed address space
de: Rückgabe von Pointer auf nicht enthaltenen Adressraum

en: return makes %q#v qualified function pointer from unqualified
de: return erzeugt aus unqualifiziertem einen qualifizierten Funktionszeiger %q#v

en: return not followed by barrier
de: »return« nicht gefolgt von Sperre

en: return type %q#T is incomplete
de: Rückgabetyp %q#T ist unvollständig

en: return type defaults to %<int%>
de: Rückgabetyp ist auf %<int%> voreingestellt

en: return type is an incomplete type
de: Rückgabetyp ist unvollständig

en: return type might be a candidate for a format attribute
de: Rückgabetyp könnte Kandidat für Formatattribut sein

en: return type of %qD is not %<int%>
de: Rückgabetyp von %qD ist nicht %<int%>

en: return type of %qD is not %qs
de: Rückgabetyp von %qD ist nicht %qs

en: return type of function
de: Rückgabetyp für Funktion

en: return type specification for constructor invalid
de: Angabe des Rückgabetyps für Konstruktor ist ungültig

en: return type specification for destructor invalid
de: Angabe des Rückgabetyps für Destruktor ist ungültig

en: return type specified for %<operator %T%>
de: Rückgabetyp für %<operator %T%> angegeben

en: return type specified for deduction guide
de: Rückgabetyp für Herleitungshinweis angegeben

en: return value type mismatch
de: unverträgliche Rückgabetypen

en: return with value in function with no return type
de: Rückgabe eines Wertes in Funktion ohne Rückgabetyp

en: return-statement with a value, in function returning %qT
de: Return-Anweisung mit Wert, in Funktion mit Rückgabetyp %qT

en: return-statement with no value, in function returning %qT
de: Return-Anweisung ohne Wert, in %qT zurückgebender Funktion

en: return-type-requirement is not a type-constraint
de: %<return-type-requirement%> ist keine Typ-Einschränkung

en: returned from %qD
de: zurückgegeben von %qD

en: returned from %qT
de: zurückgegeben von %qT

en: returning %qT from a function with incompatible return type %qT
de: Rückgabe von %qT aus einer Funktion mit inkompatiblem Rückgabetyp %qT

en: returning %qT from a function with return type %qT makes integer from pointer without a cast
de: Rückgabe von %qT aus einer Funktion mit Rückgabetyp %qT wandelt einen Zeiger in eine Zahl um, ohne explizite Typkonvertierung

en: returning %qT from a function with return type %qT makes pointer from integer without a cast
de: Rückgabe von %qT aus einer Funktion mit Rückgabetyp %qT wandelt eine Zahl in einen Zeiger um, ohne explizite Typkonvertierung

en: returning %qT from pointer type with incompatible scalar storage order %qT
de: Rückgabe von %qT von Zeigertyp %qT mit inkompatibler Speicherreihenfolge für Skalare

en: returning a value from a constructor
de: Rückgabe eines Wertes von einem Konstruktor

en: returning a value from a destructor
de: Wert von Destruktor zurückgegeben

en: returning initializer list
de: Initialisierungsliste wird zurückgegeben

en: returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array
de: das Zurückgeben der lokalen %<initializer_list%>-Variable %qD verlängert nicht die Lebenszeit des zugrundeliegenden Arrays

en: returning pointer to %qD of type %qT from a function with incompatible type %qT
de: Rückgabe von Zeiger auf %qD vom Typ %qT aus einer Funktion mit inkompatiblem Rückgabetyp %qT

en: returning reference to temporary
de: Referenz auf temporären Wert wird zurückgegeben

en: returning temporary %<initializer_list%> does not extend the lifetime of the underlying array
de: das Zurückgeben einer temporären %<initializer_list%> verlängert nicht die Lebenszeit des zugrundeliegenden Arrays

en: returning to the gate for a mechanical issue
de: Zurück auf Los? (siehe https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104552#c26)

en: reverse floating-point scalar storage order
de: umgekehrte Speicherreihenfolge für Gleitkommaskalare

en: reverse scalar storage order
de: umgekehrte Speicherreihenfolge für Skalare

en: reverse storage order for %smode
de: umgekehrte Speicherreihenfolge für »%smode«

en: right operand of comma operator cannot resolve address of overloaded function
de: rechter Operand des Komma-Operators kann die Adresse der überladenen Funktion nicht auflösen

en: right operand of comma operator has no effect
de: rechter Operand des Komma-Operators hat keinen Effekt

en: right operand of comma operator is a reference, not call, to function %qE
de: rechter Operand des Komma-Operators ist eine Referenz, kein Aufruf, zur Funktion %qE

en: right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand
de: rechter Operand des Schiebeausdrucks %q+E ist mindestens so groß wie die Genauigkeit %wu des linken Operanden

en: right operand of shift expression %q+E is negative
de: rechter Operand des Schiebeausdrucks %q+E ist negativ

en: right precision
de: rechte Präzision

en: right precision in strfmon format
de: rechte Präzision im strfmon-Format

en: right shift count >= width of type
de: Rechts-Schiebe-Weite >= Breite des Typs

en: right shift count >= width of vector element
de: Rechts-Schiebe-Weite >= Breite des Vektorelements

en: right shift count is negative
de: Rechts-Schiebe-Weite ist negativ

en: right-hand operand of comma expression has no effect
de: rechter Operand des Komma-Ausdrucks hat keinen Effekt

en: rounding mode not supported for VAX floats
de: Rundungsmodus für VAX-Floats nicht unterstützt

en: rounding result will always be 0
de: Rundungsergebnis wird immer 0 sein

en: rounding to %d bits has no effect for fixed-point value with %d fractional bits
de: Rundung auf %d Bits hat keinen Effekt für Festkommawert mit %d Bit Nachkommaanteil

en: routine %qD declared here
de: Routine %qD ist hier deklariert

en: routine call uses OpenACC parallelism disallowed by containing routine
de: Unterprogrammaufruf verwendet OpenACC-Parallelismus, der von der umgebenden Routine verboten wurde

en: routine call uses same OpenACC parallelism as containing loop
de: Unterprogrammaufruf verwendet denselben OpenACC-Parallelismus wie enthaltende Schleife

en: rv32e requires ilp32e ABI
de: rv32e erfordert die ilp32e-ABI

en: rx100 cpu does not have FPU hardware
de: CPU rx100 hat keine FPU-Hardware

en: rx200 cpu does not have FPU hardware
de: CPU rx200 hat keine FPU-Hardware

en: same canonical type node for different types %qT and %qT
de: selber kanonischer Typknoten für die unterschiedlichen Typen %qT und %qT

en: same variable used in %<firstprivate%> and %<lastprivate%> clauses on %<distribute%> construct
de: selbe Variable wird in %<firstprivate%>- und %<lastprivate%>-Klauseln am %<distribute%>-Konstrukt

en: same version was previously defined here
de: dieselbe Version wurde zuvor hier definiert

en: same_comdat_group is not a circular list
de: Interner Fehler: same_comdat_group is not a circular list

en: same_comdat_group list across different groups
de: Interner Fehler: same_comdat_group list across different groups

en: sanitizer function attribute mismatch
de: Fehlzuordnung von Attributen der Bereinigungsfunktion

en: satisfaction of atomic constraint %qE depends on itself
de: die Erfüllung der atomaren Einschränkung %qE hängt von sich selbst ab

en: satisfaction value first evaluated to %qE from here
de: der Erfüllungswert der wurde zuerst hier als %qE ausgewertet

en: satisfaction value of atomic constraint %qE changed from %qE to %qE
de: der Erfüllungswert der atomaren Einschränkung %qE ändert sich von %qE nach %qE

en: saturation bit range must be a constant immediate
de: Bitbereich der Sättigung muss eine direkt angegebene Konstante sein

en: saturation bit range must be in the range [%wd, %wd]
de: Bitbereich der Sättigung muss im Bereich [%wd, %wd] liegen

en: saw %d %<template<>%>, need %d for specializing a member function template
de: %d %<template<>%> gefunden, %d werden für Spezialisierung eines Elementfunktionstemplates benötigt

en: say %<typename %E%> if a type is meant
de: %<typename %E%> sagen, wenn ein Typ gemeint ist

en: scalar object %qD requires one element in initializer
de: skalares Objekt %qD erfordert ein Element in Initialisierung

en: scale needs to be non-negative
de: Skalierung muss nichtnegativ sein

en: scaling cannot co-exist with normalization, skipping
de: Skalierung und Normalisierung können nicht gleichzeitig aktiv sein; wird übersprungen

en: schedule %<auto%> does not take a %<chunk_size%> parameter
de: Ablauf %<auto%> akzeptiert keinen Parameter %<chunk_size%>

en: schedule %<runtime%> does not take a %<chunk_size%> parameter
de: Ablauf %<runtime%> akzeptiert keinen Parameter %<chunk_size%>

en: schedule chunk size expression must be integral
de: Plan-Teilgrößenausdruck muss bestimmt sein

en: scope %qT before %<~%> is not a class-name
de: Bereich %qT vor %<~%> ist kein Klassenname

en: scoped enum %qT passed through %<...%> as %qT before %<-fabi-version=6%>, %qT after
de: enum %qT mit eingeschränkter Sichtbarkeit wird vor %<-fabi-version=6%> als Typ %qT, später jedoch als %qT durch %<...%> übergeben

en: scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>
de: enums mit Gültigkeitsbereich nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: scoped/unscoped mismatch in enum %q#T
de: falsche Zuordnung zwischen innerhalb und außerhalb eines Gültigkeitsbereiches in enum %q#T

en: score argument must be constant integer expression
de: das Score-Argument muss ein konstanter ganzzahliger Ausdruck sein

en: score argument must be constant integer expression at %C
de: das Score-Argument bei %C muss ein konstanter ganzzahliger Ausdruck sein

en: score argument must be non-negative
de: das Score-Argument darf nicht negativ sein

en: score argument must be non-negative at %C
de: das Score-Argument bei %C darf nicht negativ sein

en: second argument must be slice or string
de: zweites Argument muss eine Scheibe oder Zeichenkette sein

en: second argument of %q+D should be %<char **%>
de: zweites Argument von %q+D sollte %<char **%> sein

en: second argument to %<__builtin_call_with_static_chain%> must be a pointer type
de: Zweites Argument für %<__builtin_call_with_static_chain%> muss ein Zeigertyp sein

en: second argument to %<__builtin_prefetch%> must be a constant
de: Zweites Argument für %<__builtin_prefetch%> muss eine Konstante sein

en: second argument to %<va_arg%> is a function type %qT
de: zweites Argument für %<va_arg%> ist ein Funktionstyp %qT

en: second argument to %<va_arg%> is of incomplete type %qT
de: zweites Argument für %<va_arg%> ist vom unvollständigen Typ %qT

en: second argument to function %qE must be a constant integer power of 2 between %qi and %qu bits
de: zweites Argument für Funktion %qE muss eine konstante Zweierpotenz zwischen %qi und %qu Bits sein

en: second operand of conditional expression cannot resolve address of overloaded function
de: zweiter Operand des bedingten Ausdrucks kann die Adresse der überladenen Funktion nicht auflösen

en: second operand of conditional expression has no effect
de: zweiter Operand des bedingten Ausdrucks hat keinen Effekt

en: second operand of conditional expression is a reference, not call, to function %qE
de: zweiter Operand des bedingten Ausdrucks ist eine Referenz, kein Aufruf, zur Funktion %qE

en: second operand to the conditional operator is of type %<void%>, but the third operand is neither a throw-expression nor of type %<void%>
de: zweiter Operand für Bedingungsoperator ist vom Typ %<void%>, aber der dritte Operand ist weder ein Throw-Ausdruck noch vom Typ %<void%>

en: second parameter of %<va_start%> not last named argument
de: Zweiter Parameter von %<va_start%> ist nicht letztgenanntes Argument

en: section #%u is missing or corrupted
de: Abschnitt #%u fehlt oder ist beschädigt

en: section %qs is missing or corrupted
de: Abschnitt %qs fehlt oder ist beschädigt

en: section already exists: %qs
de: Abschnitt existiert bereits: %qs

en: section anchors must be disabled when toplevel reorder is disabled
de: Abschnittsanker müssen ausgeschaltet sein, wenn Toplevel-Neuordnung ausgeschaltet ist

en: section anchors must be disabled when unit-at-a-time is disabled
de: Abschnittsanker müssen ausgeschaltet sein, wenn »unit-at-a-time« ausgeschaltet ist

en: section attribute argument not a string constant
de: Argument des Abschnittsattributs ist keine Zeichenkettenkonstante

en: section attribute cannot be specified for local variables
de: Abschnitts-Attribut kann nicht für lokale Variablen angegeben werden

en: section attribute not allowed for %q+D
de: Abschnitts-Attribut nicht erlaubt für %q+D

en: section attributes are not supported for this target
de: Abschnitts-Attribute werden für dieses Ziel nicht unterstützt

en: section of %q+D cannot be overridden
de: Abschnitt von %q+D kann nicht aufgehoben werden

en: section of %q+D conflicts with previous declaration
de: Abschnitt von %q+D in Konflikt mit vorheriger Deklaration

en: section of alias %q+D must match section of its target
de: Abschnitt des Aliases %q+D muss zum Abschnitt seines Ziels passen

en: section type conflict
de: Abschnittstypkonflikt

en: section type conflict with %qD
de: Abschnittstypkonflikt mit %qD

en: segmentation fault
de: Speicherzugriffsverletzung

en: segmentation fault (code)
de: Speicherzugriffsverletzung (Code)

en: selected fp16 options are incompatible
de: die ausgewählten fp16-Optionen sind inkompatibel

en: selector %qs does not accept any properties
de: Selektor %qs akzeptiert keine Eigenschaften

en: selector %qs not allowed for context selector set %qs
de: Selektor %qs nicht erlaubt für Kontext-Selektorsatz %qs

en: selector %qs specified more than once in set %qs
de: Selektor %qs mehr als einmal im Satz %qs angegeben

en: selector '%s' does not accept any properties at %C
de: Selektor »%s« bei %C akzeptiert keine Eigenschaften

en: selector '%s' not allowed for context selector set '%s' at %C
de: Selektor »%s« ist für den Kontext-Selektorsatz »%s« nicht erlaubt, bei %C

en: selector must be an immediate
de: Wähler muss »immediate« sein

en: selector must be an integer constant in the range [0, %wi]
de: Selektor muss eine Ganzzahlkonstante im Bereich [0, %wi] sein

en: selector set %qs specified more than once
de: Selektorsatz %qs mehr als einmal angegeben

en: self-comparison always evaluates to false
de: Vergleich mit sich selbst ergibt immer »false«

en: self-comparison always evaluates to true
de: Vergleich mit sich selbst ergibt immer »true«

en: self-tests are not enabled in this build
de: Selbsttests sind in diesem Build nicht eingeschaltet

en: self-tests incompatible with %<-E%>
de: Selbsttests sind unverträglich mit %<-E%>

en: semantic interposition mismatch
de: Fehlzuordnung von semantischer Einlagerung

en: set %qs to at least %d for more detail
de: legen Sie %qs auf mindestens %d fest, um mehr Details zu sehen

en: setjmp/longjmp inside %<simd%> construct
de: setjmp/longjmp innerhalb %<simd%>-Konstrukts

en: setter method names must terminate with %<:%>
de: Methodennamen von Settern müssen mit %<:%> aufhören

en: setting core file size limit to maximum: %m
de: Kern-Dateigrößenlimit kann nicht gesetzt werden: %m

en: shadowed declaration is here
de: verdeckte Deklaration ist hier

en: shadowing built-in function %q#D
de: eingebaute Funktion %q#D wird überdeckt

en: shadowing library function %q#D
de: Bibliotheksfunktion %q#D wird überdeckt

en: shadowing previous type declaration of %q#D
de: vorherige Typdeklaration von %q#D wird überschattet

en: shared SSA name info
de: Gemeinsam genutzte SSA-Namen-Info

en: shared and mdll are not compatible
de: shared und mdll sind unverträglich

en: shared call_stmt:
de: Interner Fehler: shared call_stmt:

en: shared is not supported
de: shared wird nicht unterstützt

en: shared rtx
de: Gemeinsames rtx

en: shared-memory region overflow
de: Überlauf der Shared-Memory-Region

en: shift count not integer
de: Schiebeweite ist keine Ganzzahl

en: shift expression %q+E overflows
de: Schiebeausdruck %q+E läuft über

en: shift of non-integer operand
de: Schiebeoperation eines Nicht-Ganzzahloperanden

en: short read while reading export data
de: zu wenig Export-Daten gelesen

en: show_array_ref(): Unknown array reference
de: Interner Fehler: show_array_ref(): Unknown array reference

en: show_array_spec(): Unhandled array shape type.
de: Interner Fehler: show_array_spec(): Unhandled array shape type.

en: show_code_node(): Bad statement code
de: Interner Fehler: show_code_node(): Bad statement code

en: show_expr(): Bad intrinsic in expression
de: Interner Fehler: show_expr(): Bad intrinsic in expression

en: show_expr(): Don't know how to show expr
de: Interner Fehler: show_expr(): Don't know how to show expr

en: show_ref(): Bad component code
de: Interner Fehler: show_ref(): Bad component code

en: sibcall edges for non-call insn in bb %i
de: Interner Fehler: sibcall edges for non-call insn in bb %i

en: side effects not recomputed when %<ADDR_EXPR%> changed
de: Seiteneffekte werden bei %<ADDR_EXPR%>-Änderung nicht neu berechnet

en: signed conversion from %qT to %qT changes the value of %qE
de: Vorzeichenbehaftete Umwandlung von %qT nach %qT ändert den Wert von %qE

en: signed conversion from %qT to %qT changes value from %qE to %qE
de: Vorzeichenbehaftete Umwandlung von %qT nach %qT ändert den Wert von %qE nach %qE

en: signedness of type and machine mode %qs don%'t match
de: Vorzeicheneigenschaft des Typen und Maschinenmodus %qs passen nicht zusammen

en: simple IF
de: einfaches IF

en: single %<target_clones%> attribute is ignored
de: einzelnes %<target_clones%>-Attribut wird ignoriert

en: size %qE of array %qE exceeds maximum object size %qE
de: Größe %qE des Arrays %qE übersteigt maximale Objektgröße %E

en: size %qE of array %qE is negative
de: Größe %qE des Arrays %qE ist negativ

en: size %qE of array exceeds maximum object size %qE
de: Größe %qE des Arrays überschreitet maximale Objektgröße %qE

en: size %qE of array is negative
de: Größe %qE des Arrays ist negativ

en: size in array new must have integral type
de: Größe des Arrays bei »new« muss Ganzzahltyp haben

en: size is too large
de: Größe ist zu groß

en: size mismatch in argument %d of %qE
de: Unpassende Größe in Argument %d von %qE

en: size of %q+D %E bytes exceeds maximum object size %wu
de: Größe von %q+D überschreitet mit %E Bytes die maximale Objektgröße %wu

en: size of %qD differ from the size of original declaration
de: Größe von %qD passt nicht zur ursprünglichen Deklaration

en: size of array %qD has non-integral type %qT
de: Arraygröße von %qD hat nicht-ganzzahligen Typen %qT

en: size of array %qD is not an integral constant-expression
de: Größe des Arrays %qD ist kein konstanter Ganzzahlausdruck

en: size of array %qE exceeds maximum object size %qE
de: Größe des Arrays %qE übersteigt maximale Objektgröße %E

en: size of array %qE has incomplete type
de: Arraygröße von %qE hat unvollständigen Typ

en: size of array %qE has non-integer type
de: Arraygröße von %qE hat Nicht-Ganzzahltyp

en: size of array %qE is negative
de: Größe des Arrays %qE ist negativ

en: size of array %qE is not a constant expression
de: Größe des Arrays %qE ist kein konstanter Ausdruck

en: size of array %qE is too large
de: Arraygröße von %qE ist zu groß

en: size of array element is not a multiple of its alignment
de: Größe des Arrayelements ist kein Vielfaches seiner Ausrichtung

en: size of array exceeds maximum object size %qE
de: Größe des Arrays übersteigt maximale Objektgröße %qE

en: size of array has non-integral type %qT
de: Arraygröße hat nicht-ganzzahligen Typen %qT

en: size of array is not a constant expression
de: Größe des Arrays ist kein konstanter Ausdruck

en: size of array is not an integral constant-expression
de: Größe des Arrays ist kein konstanter Ganzzahlausdruck

en: size of array is too large
de: Arraygröße ist zu groß

en: size of loop %d should be %d, not %d
de: Interner Fehler: size of loop %d should be %d, not %d

en: size of return value of %q+D is %u bytes
de: Größe des Rückgabewertes von %q+D ist %u Bytes

en: size of return value of %q+D is larger than %wu bytes
de: Größe des Rückgabewertes von %q+D ist größer als %wu Bytes

en: size of string literal is too large
de: Größe des Zeichenkettenliterals ist zu groß

en: size of type %qT is too large (%qE bytes)
de: Größe des Typs %qT ist zu groß (%qE Bytes)

en: size of unnamed array has incomplete type
de: Größe eines unbenannten Arrays hat unvollständigen Typ

en: size of unnamed array has non-integer type
de: Größe eines unbenannten Arrays hat Nicht-Ganzzahltyp

en: size of unnamed array is negative
de: Größe des unbenannten Arrays ist negativ

en: size of unnamed array is too large
de: Größe des unbenannten Arrays ist zu groß

en: size of variable %q+D is too large
de: Größe der Variablen %q+D ist zu hoch

en: size ranges of option %qs should be increasing
de: Größenbereiche der Option %qs sollten aufsteigend sein

en: sizeof(long double) is 12.
de: sizeof(long double) ist 12.

en: sizeof(long double) is 16.
de: sizeof(long double) ist 16.

en: slice can only be compared to nil
de: Ausschnitt kann nur mit nil verglichen werden

en: slice capacity must be integer
de: Scheibenkapazität muss ganzzahlig sein

en: slice end must be integer
de: Scheibenende muss eine Ganzzahl sein

en: slice of unaddressable value
de: Scheibe ohne adressierbaren Wert

en: so any instantiation with a non-empty parameter pack would be ill-formed
de: jegliche Instanziierung mit nichtleerer Parameterpackung wäre unzulässig

en: soft-float and long-double-128 are incompatible
de: soft-float und long-double-128 sind unverträglich

en: some parts of macro expansion are not guarded by this %qs clause
de: Einige Teile des expandierten Makros sind nicht von diesem %qs-Konstrukt erfasst

en: sorry, unimplemented
de: nicht implementiert

en: sorry, unimplemented:
de: nicht implementiert:

en: sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)
de: Entschuldigung: Semantik von static-Variable %q#D in inline-Funktion ist falsch (mehrere Kopien wären die Folge)

en: sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)
de: Entschuldigung: Semantik der Inline-Variable %q#D ist falsch (mehrere Kopien wären die Folge)

en: source is a pointer to incomplete type
de: Quelle ist ein Zeiger auf unvollständigen Typen

en: source is not a pointer
de: Quelle ist kein Zeiger

en: source is not a pointer to class
de: Quelle ist kein Zeiger auf Klasse

en: source is not of class type
de: Quelle hat nicht Klassentypen

en: source is of incomplete class type
de: Quelle hat unvollständigen Klassentypen

en: source locations for function %qD have changed, the profile data may be out of date
de: Quellorte für Funktion %qD haben sich geändert, Profilingdaten möglicherweise veraltet

en: source object %qE of size %s
de: Quellobjekt %qE der Größe %s

en: source object allocated here
de: Quellobjekt wird hier alloziert

en: source object of size %s allocated by %qE
de: Quellobjekt der Größe %s, alloziert durch %qE

en: source type is not polymorphic
de: Quellentyp ist nicht polymorph

en: space followed by punctuation character %<%c%>
de: Leerzeichen gefolgt von Satzzeichen %<%c%>

en: spec %qs has invalid %<%%0%c%>
de: Spezifikation %qs hat ungültiges %<%%0%c%>

en: spec %qs has invalid %<%%@%c%>
de: Spezifikation %qs hat ungültiges %<%%@%c%>

en: spec %qs has invalid %<%%W%c%>
de: Spezifikation %qs hat ungültiges %<%%W%c%>

en: spec %qs has invalid %<%%x%c%>
de: Spezifikation %qs hat ungültiges %<%%x%c%>

en: spec %qs invalid
de: Spezifikation %qs ist ungültig

en: spec failure: %<%%*%> has not been initialized by pattern match
de: Spezifikationsfehler: %<%%*%> wurde nicht durch Mustererkennung initialisiert

en: spec failure: more than one argument to %<SYSROOT_HEADERS_SUFFIX_SPEC%>
de: Spezifikationsfehler: mehr als ein Argument für %<SYSROOT_HEADERS_SUFFIX_SPEC%>

en: spec failure: more than one argument to %<SYSROOT_SUFFIX_SPEC%>
de: Spezifikationsfehler: mehr als ein Argument für %<SYSROOT_SUFFIX_SPEC%>

en: spec failure: unrecognized spec option %qc
de: Spezifikationsfehler: nicht erkannte Spezifikationsoption %qc

en: spec file has no spec for linking
de: Spezifikationsdatei hat keine Spezifikation zum Binden

en: spec is '%s'
de: Spezifikation ist '%s'

en: spec-generated switch is just %<-%>
de: aus Spezifikation erzeugtes switch ist nur %<-%>

en: specialization %qT after instantiation %qT
de: Spezialisierung %qT hinter Instanziierung %qT

en: specialization of %qD after instantiation
de: Spezialisierung von %qD nach Instanziierung

en: specialization of %qD in different namespace
de: Spezialisierung von %qD in anderem Namensbereich

en: specialization of %qD must appear at namespace scope
de: Spezialisierung von %qD muss im Gültigkeitsbereich des Namensbereiches auftreten

en: specialization of %qT after instantiation
de: Spezialisierung von %qT hinter Instanziierung

en: specialization of alias template %qD
de: Spezialisierung des Alias-Template %qD

en: specialization of implicitly-declared special member function
de: Spezialisierung der implizit deklarierten speziellen Elementfunktion

en: specialization of variable concept %q#D
de: Spezialisierung des Variablenkonzepts %q#D

en: specialization of variable template %qD declared as function
de: Spezialisierung des Variablentemplates %qD als Funktion deklariert

en: specializing member %<%T::%E%> requires %<template<>%> syntax
de: spezialisierendes Element %<%T::%E%> erfordert Syntax %<template<>%>

en: specified bound %E exceeds destination size %E
de: angegebene Grenze %E überschreitet die Größe %E des Zielobjekts

en: specified bound %E exceeds maximum object size %E
de: angegebene Grenze %E überschreitet die maximale Objektgröße %E

en: specified bound %E exceeds source size %E
de: angegebene Grenze %E überschreitet die Größe %E des Quellobjekts

en: specified bound %E may exceed destination size %E
de: angegebene Grenze %E überschreitet möglicherweise die Größe %E des Zielobjekts

en: specified bound %E may exceed maximum object size %E
de: angegebene Grenze %E überschreitet möglicherweise die maximale Objektgröße %E

en: specified bound %E may exceed source size %E
de: angegebene Grenze %E überschreitet möglicherweise die Größe %E des Quellobjekts

en: specified bound %wu exceeds %<INT_MAX%>
de: angegebene Grenze %wu überschreitet %<INT_MAX%>

en: specified bound %wu exceeds maximum object size %wu
de: angegebene Grenze %wu überschreitet maximale Objektgröße %wu

en: specified bound %wu exceeds the size %wu of the destination object
de: angegebene Grenze %wu überschreitet die Größe %wu des Zielobjekts

en: specified bound [%E, %E] exceeds destination size %E
de: angegebene Grenze [%E, %E] überschreitet die Größe %E des Zielobjekts

en: specified bound [%E, %E] exceeds maximum object size %E
de: angegebene Grenze [%E, %E] überschreitet die maximale Objektgröße %E

en: specified bound [%E, %E] exceeds source size %E
de: angegebene Grenze [%E, %E] überschreitet die Größe %E des Quellobjekts

en: specified bound [%E, %E] may exceed maximum object size %E
de: angegebene Grenze [%E, %E] überschreitet möglicherweise die maximale Objektgröße %E

en: specified bound [%E, %E] may exceed source size %E
de: angegebene Grenze [%E, %E] überschreitet möglicherweise die Größe %E des Quellobjekts

en: specified bound range [%wu, %wu] exceeds %<INT_MAX%>
de: angegebene Bereichsgrenze [%wu, %wu] überschreitet %<INT_MAX%>

en: specified mode too small for enumerated values
de: angegebener Modus zu klein für Aufzählungswerte

en: specified option %qs more than once
de: Option %qs wurde mehrmals angegeben

en: specified size %E exceeds maximum object size %E
de: angegebene Größe %E überschreitet die maximale Objektgröße %E

en: specified size %E may exceed maximum object size %E
de: angegebene Größe %E überschreitet möglicherweise die maximale Objektgröße %E

en: specified size between %E and %E exceeds maximum object size %E
de: angegebene Größe zwischen %E und %E überschreitet die maximale Objektgröße %E

en: specified size between %E and %E may exceed maximum object size %E
de: angegebene Größe zwischen %E und %E überschreitet möglicherweise die maximale Objektgröße %E

en: specify a system register with a small string length
de: Systemregister mit einem kurzem Namen angeben

en: specifying vector types with %<__attribute__ ((mode))%> is deprecated
de: Angabe von Vektortypen mit %<__attribute__ ((mode))%> ist veraltet

en: specs %%include syntax malformed after %ld characters
de: falsche %%include-Syntax für Spezifikationen nach %ld Zeichen

en: specs %%rename syntax malformed after %ld characters
de: falsche %%rename-Syntax für Spezifikationen nach %ld Zeichen

en: specs %s spec was not found to be renamed
de: keine %s-Spezifikation zum Umbenennen gefunden

en: specs file malformed after %ld characters
de: Fehler in Spezifikationsdatei nach %ld Zeichen

en: specs unknown %% command after %ld characters
de: Spezifikation: unbekannter %%-Befehl nach %ld Zeichen

en: speculative edges are not adjacent
de: spekulative Kanten sind nicht benachbart

en: spurious %<>>%>, use %<>%> to terminate a template argument list
de: falsches %<>>%>; %<>%> verwenden, um eine Templateargumentliste zu beenden

en: spurious leading punctuation sequence %<%.*s%> in format
de: verdächtige Folge von Satzzeichen %<%.*s%> am Anfang des Formats

en: spurious trailing %<%%%> in format
de: störendes letztes %<%%%> im Format

en: spurious trailing punctuation sequence %<%.*s%> in format
de: verdächtige Folge von Satzzeichen %<%.*s%> am Ende des Formats

en: spurious trailing space in format
de: überzähliges Leerzeichen am Ende des Formats

en: stack clash guard size %<%d%> must be equal to probing interval %<%d%>
de: Größe des Stapelkollisionswächters %d muss gleich dem Sondierungsintervall %d sein

en: stack frame must be smaller than 64K
de: Stapelrahmen muss kleiner als 64k sein

en: stack frame not a multiple of 8 bytes: %wd
de: Interner Fehler: stack frame not a multiple of 8 bytes: %wd

en: stack frame not a multiple of octabyte: %wd
de: Interner Fehler: stack frame not a multiple of octabyte: %wd

en: stack frame too large
de: Stapelrahmen zu groß

en: stack guard value must be an exact power of 2
de: Stapel-Überwachungswert muss eine exakte Zweierpotenz sein

en: stack limit expression is not supported
de: Ausdruck der Stapelgrenze wird nicht unterstützt

en: stack limits not supported on this target
de: Stapelgrenzen nicht für dieses Ziel unterstützt

en: stack probes for SVE frames
de: Stapelsonde für SVE-Rahmen

en: stack probing requires %<-maccumulate-outgoing-args%> for correctness
de: Stapel-Überprüfung erfordert %<-maccumulate-outgoing-args%> für Korrektheit

en: stack probing requires %<target("accumulate-outgoing-args")%> for correctness
de: Stapel-Überprüfung erfordert %<target("accumulate-outgoing-args")%> für Korrektheit

en: stack protector not protecting function: all local arrays are less than %d bytes long
de: Stapelschutz schützt nicht Funktion: Alle lokalen Arrays sind kleiner als %d Bytes

en: stack protector not protecting local variables: variable length buffer
de: Stapelschutz schützt nicht lokale Variablen: Puffer variabler Größe

en: stack register used for global register variable
de: Stapelregister für globale Registervariable verwendet

en: stack size must be an exact power of 2
de: Stapelgröße muss eine exakte Zweierpotenz sein

en: stack size must be greater than the stack guard value
de: Stapelgröße muss größer als der Stapel-Überwachungswert sein

en: stack size must not be greater than 64k
de: Stapelgröße darf nicht größer als 64k sein

en: stack usage computation not supported for this target
de: Stapelverbrauchsberechnung wird für dieses Ziel nicht unterstützt

en: stack usage is %wu bytes
de: Stapelverbrauch ist %wu Bytes

en: stack usage might be %wu bytes
de: Stapelverbrauch könnte %wu Bytes sein

en: stack usage might be unbounded
de: Stapelverbrauch möglicherweise unbegrenzt

en: stackframe too big: %d bytes
de: Stapelrahmen zu groß: %d Bytes

en: standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement
de: OpenMP-»standalone«-Direktiven im Attribut %<omp::directive%> können nur in einer leeren Anweisung vorkommen

en: standard attributes in middle of decl-specifiers
de: Standardattribute inmitten von Deklarationssymbolen

en: standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type
de: Standardattribute müssen vor den Deklarationsspezifizierern stehen, um für die Deklaration zu gelten, oder ihnen folgen, um für den Typ zu gelten

en: standard attributes on namespaces must precede the namespace name
de: Standardattribute für Namensräume müssen vor dem Namen des Namensraums stehen

en: start of implied-do loop at %L could not be simplified to a constant value
de: Anfang der Implied-do-Schleife bei %L konnte nicht zu einem konstanten Wert vereinfacht werden

en: start/end of RTL fragment are in different files
de: Anfang/Ende von RTL-Fragment sind in verschiedenen Dateien

en: statement cannot resolve address of overloaded function
de: Anweisung kann die Adresse der überladenen Funktion nicht auflösen

en: statement has no effect
de: Anweisung hat keinen Effekt

en: statement is a reference, not call, to function %qE
de: Anweisung ist eine Referenz, kein Aufruf, zur Funktion %qE

en: statement is not a constant expression
de: Anweisung ist kein Konstantenausdruck

en: statement marked for throw in middle of block
de: Anweisung inmitten eines Blocks für throw markiert

en: statement marked for throw, but doesn%'t
de: Anweisung für throw markiert, wirft jedoch nichts

en: statement uses released SSA name
de: Anweisung verwendet freigegebenen SSA-Namen

en: statement volatile flag not up to date
de: volatile-Kennzeichen für Anweisung nicht aktuell

en: statement will never be executed
de: Anweisung wird niemals ausgeführt

en: statement with no effect
de: Anweisung ohne Effekt

en: statement-expression in a constant expression
de: Anweisungs-Ausdruck in konstantem Ausdruck

en: statement-expressions are not allowed outside functions nor in template-argument lists
de: Anweisungs-Ausdrücke sind weder außerhalb von Funktionen noch in Template-Argumenten erlaubt

en: static IO declaration for %q+D needs an address
de: »static IO«-Deklaration von %q+D erfordert eine Adresse

en: static assertion failed
de: statische Behauptung gescheitert

en: static assertion failed: %E
de: statische Behauptung gescheitert: %E

en: static assertion failed: %s
de: statische Erklärung gescheitert: %s

en: static chain with function that doesn%'t use one
de: statische Kette mit Funktion, die keine verwendet

en: static data member %qD in unnamed class
de: statisches Datenelement %qD in unbenannter Klasse

en: static data member %qE declared %qs
de: statisches Datenelement %qE als %qs deklariert

en: static declaration of %q+D follows non-static declaration
de: Statische Deklaration von %q+D folgt nicht-statischer Deklaration

en: static field %qD is not mappable
de: statisches Feld %qD ist nicht zuordenbar

en: static initialization of variable %q+D in %<.shared%> memory is not supported
de: statische Initialisierung der Variablen %q+D in %<.shared%>-Speicher wird nicht unterstützt

en: static is not supported on TPF-OS
de: static wird auf TPF-OS nicht unterstützt

en: static member %qD cannot be a bit-field
de: statisches Element %qD kann kein Bitfeld sein

en: static member %qD declared %<register%>
de: statisches Element %qD als %<register%> deklariert

en: static member function %q#D declared with type qualifiers
de: statische Elementfunktion %q#D mit Typqualifizierern deklariert

en: static member function %qD cannot have cv-qualifier
de: statische Elementfunktion %qD kann nicht CV-Qualifizierer haben

en: static member function %qD cannot have ref-qualifier
de: statische Elementfunktion %qD kann keinen ref-Qualifizierer haben

en: static or type qualifiers in non-parameter array declarator
de: »static« oder Typkennzeichner in Nicht-Parameter-Arraydeklarator

en: static type %qT of its operand is a non-public base class of dynamic type %qT
de: der statische Typ %qT des Operanden ist eine nicht öffentliche Basisklasse des dynamischen Typs %qT

en: statically allocated instance of Objective-C class %qE
de: statisch reservierte Instanz der Objective-C-Klasse %qE

en: stdcall and cdecl attributes are not compatible
de: Attribute stdcall und cdecl sind nicht verträglich

en: stdcall and fastcall attributes are not compatible
de: Attribute stdcall und fastcall sind nicht verträglich

en: stdcall and thiscall attributes are not compatible
de: Attribute stdcall und thiscall sind nicht verträglich

en: step expression refers to outer iterator %qD
de: Ausdruck für die Schrittweite verweist auf äußeren Iterator %qD

en: step of implied-do loop at %L could not be simplified to a constant value
de: Schritt der Implied-do-Schleife bei %L konnte nicht zu einem konstanten Wert vereinfacht werden

en: step of implied-do loop at %L shall not be zero
de: Schrittweite der implied-do-Schleife bei %L darf nicht 0 sein

en: stmt (%p) marked modified after optimization pass:
de: Anweisung (%p) nach Optimierungsdurchgang als geändert markiert:

en: stmts without block
de: Interner Fehler: stmts without block

en: storage class %<__thread%> invalid for function %qs
de: Speicherklasse %<__thread%> ungültig für Funktion %qs

en: storage class %<auto%> invalid for function %qs
de: Speicherklasse %<auto%> ungültig für Funktion %qs

en: storage class %<register%> invalid for function %qs
de: Speicherklasse %<register%> ungültig für Funktion %qs

en: storage class %<thread_local%> invalid for function %qs
de: Speicherklasse %<thread_local%> ungültig für Funktion %qs

en: storage class %qD applied to template instantiation
de: Speicherklasse %qD auf Templateinstanziierung angewendet

en: storage class specified for %qs
de: Speicherklasse %qs angegeben

en: storage class specified for parameter %qE
de: Speicherklasse für Parameter %qE angegeben

en: storage class specified for parameter %qs
de: Speicherklasse für Parameter %qs angegeben

en: storage class specified for structure field
de: Speicherklasse für Strukturfeld angegeben

en: storage class specified for structure field %qE
de: Speicherklasse für Strukturfeld %qE angegeben

en: storage class specified for template parameter %qs
de: Speicherklasse für Template-Parameter %qs angegeben

en: storage class specified for typename
de: Speicherklasse für Typnamen angegeben

en: storage class specified for unnamed parameter
de: Speicherklasse für unbenannten Parameter angegeben

en: storage class specifiers invalid in friend function declarations
de: Speicherklassenangaben sind in friend-Funktionsdeklarationen ungültig

en: storage size of %q+D isn%'t constant
de: Speichergröße von %q+D ist nicht konstant

en: storage size of %q+D isn%'t known
de: Speichergröße von %q+D ist unbekannt

en: storage size of %qD isn%'t constant
de: Speichergröße von %qD ist nicht konstant

en: storage size of %qD isn%'t known
de: Speichergröße von %qD ist unbekannt

en: storing the address of local variable %qD in %qE
de: Adresse der lokalen Variable %qD wird in %qE gespeichert

en: strange device name %qs after %qs: bad character %qc
de: Merkwürdiger Gerätename %qs nach %qs: falsches Zeichen %qc

en: strategy name %qs specified for option %qs not supported for 32-bit code
de: Strategiename %qs für Option %qs angegeben, wird jedoch für 32-Bit-Code nicht unterstützt

en: stray %<,%> at end of member declaration
de: überflüssiges %<,%> am Ende der Elementdeklaration

en: stray %<@%> in program
de: verirrtes %<@%> im Programm

en: stray %<\%o%> in program
de: verirrtes %<\%o%> im Programm

en: stray %qc in program
de: verirrtes %qc im Programm

en: stray %qs between Objective-C++ methods
de: überflüssiges %qs zwischen Objective-C++ Methoden

en: stray %qs in program
de: verirrtes %qs im Programm

en: streaming subprocess failed
de: Streaming-Kindprozess fehlgeschlagen

en: streaming subprocess was killed by signal
de: Der Streaming-Kindprozess wurde durch ein Signal beendet

en: strftime formats cannot format arguments
de: strftime-Formate können keine Argumente formatieren

en: string length %qd is greater than the length %qd ISO C%d compilers are required to support
de: Zeichenkettenlänge %qd ist größer als die Länge %qd, die von ISO-C%d-Compilern unterstützt werden muss

en: strong-cast assignment has been intercepted
de: Zuweisung mit starker Typumwandlung wurde abgefangen

en: strong-cast may possibly be needed
de: Möglicherweise wird starke Typumwandlung benötigt

en: struct defined here
de: »struct« wurde hier definiert

en: struct has no members
de: struct hat keine Elemente

en: struct has no named members
de: struct hat keine benannten Elemente

en: structure alignment must be a small power of two, not %wu
de: Strukturausrichtung muss eine kleine Zweierpotenz sein, nicht %wu

en: structure field
de: Strukturfeld

en: structure size boundary can only be set to 8 or 32
de: Grenze für Strukturgröße kann nur auf 8 oder 32 gesetzt werden

en: structure size boundary can only be set to 8, 32 or 64
de: Grenze für Strukturgröße kann nur auf 8, 32 oder 64 gesetzt werden

en: structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>
de: strukturierte Bindungsdeklarationen können erst ab %<-std=c++20%> oder %<-std=gnu++20%> %qs sein

en: structured binding declaration cannot be %qs
de: Deklaration für strukturierte Bindung darf nicht als %qs deklariert werden

en: structured binding declaration cannot be C++98 %<auto%>
de: Deklaration für strukturierte Bindung darf nicht als %<auto%> (C++98) deklariert werden

en: structured binding declaration cannot have type %qT
de: Deklaration für strukturierte Bindung darf nicht vom Typen %qT sein

en: structured binding declaration set but not used
de: Deklaration für strukturierte Bindung festgelegt, aber nicht verwendet

en: structured binding has incomplete type %qT
de: Strukturierte Bindung hat unvollständigen Typen %qT

en: structured binding refers to incomplete class type %qT
de: Strukturierte Bindung verweist auf unvollständigen Klassentypen %qT

en: structured binding refers to incomplete type %qT
de: Strukturierte Bindung verweist auf unvollständigen Typen %qT

en: structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>
de: strukturierte Bindungen sind nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar

en: subframework include %s conflicts with framework include
de: Unter-Framework-Include %s steht mit Framework-Include in Konflikt

en: subobject %qD declared here
de: Teilobjekt %qD ist hier deklariert

en: subprogram %q+F not marked %<Inline%>
de: Unterprogramm %q+F nicht als %<Inline%> markiert

en: subprogram %q+F not marked %<Inline_Always%>
de: Unterprogramm %q+F nicht als %<Inline_Always%> markiert

en: subscript missing in array reference
de: Index fehlt in Arrayreferenz

en: subscripted value is neither array nor pointer
de: indizierter Wert ist weder ein Array noch ein Zeiger

en: subscripted value is neither array nor pointer nor vector
de: indizierter Wert ist weder Array noch Zeiger noch Vektor

en: subscripted value is pointer to function
de: indizierter Wert ist Zeiger auf Funktion

en: subscripting array declared %<register%>
de: Indizierung eines als %<register%> deklarierten Arrays

en: subsequently declared as %s with %u unspecified variable bound | subsequently declared as %s with %u unspecified variable bounds
de[0]: war später als %s mit %u unspezifizierten Variablengrenze deklariert
de[1]: war später als %s mit %u unspezifizierten Variablengrenze deklariert

en: suggest braces around empty body in %<do%> statement
de: geschweifte Klammern um leeren Körper in %<do%>-Anweisung empfohlen

en: suggest braces around empty body in an %<else%> statement
de: geschweifte Klammern um leeren Körper in einer %<else%>-Anweisung empfohlen

en: suggest braces around empty body in an %<if%> statement
de: geschweifte Klammern um leeren Körper in einer %<if%>-Anweisung empfohlen

en: suggest explicit braces around empty body in %<do%> statement
de: es wird empfohlen, explizite geschweifte Klammern um leeren Körper in %<do%>-Anweisung zu setzen

en: suggest explicit braces to avoid ambiguous %<else%>
de: es wird empfohlen, explizite geschweifte Klammern zu setzen, um mehrdeutiges %<else%> zu vermeiden

en: suggest parentheses around %<&&%> within %<||%>
de: Klammern um %<&&%> innerhalb von %<||%> empfohlen

en: suggest parentheses around %<+%> in operand of %<&%>
de: Klammern um %<+%> in Operand von %<&%> empfohlen

en: suggest parentheses around %<+%> inside %<<<%>
de: Klammern um %<+%> innerhalb von %<<<%> empfohlen

en: suggest parentheses around %<+%> inside %<>>%>
de: Klammern um %<+%> innerhalb von %<>>%> empfohlen

en: suggest parentheses around %<-%> in operand of %<&%>
de: Klammern um %<-%> in Operand von %<&%> empfohlen

en: suggest parentheses around %<-%> inside %<<<%>
de: Klammern um %<-%> innerhalb von %<<<%>

en: suggest parentheses around %<-%> inside %<>>%>
de: Klammern um %<-%> innerhalb von %<>>%> empfohlen

en: suggest parentheses around %<>>%> expression
de: Klammern um %<>>%>-Ausdruck empfohlen

en: suggest parentheses around arithmetic in operand of %<^%>
de: Klammern um Arithmetik in Operand von %<^%> empfohlen

en: suggest parentheses around arithmetic in operand of %<|%>
de: Klammern um Arithmetik in Operand von %<|%> empfohlen

en: suggest parentheses around assignment used as truth value
de: Um Zuweisung, die als Wahrheitswert verwendet wird, werden Klammern empfohlen

en: suggest parentheses around comparison in operand of %<!=%>
de: Klammern um Vergleich in Operand von %<!=%> empfohlen

en: suggest parentheses around comparison in operand of %<&%>
de: Klammern um Vergleich in Operand von %<&%> empfohlen

en: suggest parentheses around comparison in operand of %<==%>
de: Klammern um Vergleich in Operand von %<==%> empfohlen

en: suggest parentheses around comparison in operand of %<^%>
de: Klammern um Vergleich in Operand von %<^%> empfohlen

en: suggest parentheses around comparison in operand of %<|%>
de: Klammern um Vergleich in Operand von %<|%> empfohlen

en: suggest parentheses around operand of %<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>
de: Klammern um Operand von %<!%> empfohlen, oder Änderung von %<&%> in %<&&%> oder %<!%> in %<~%>

en: suggest parentheses around operand of %<!%> or change %<|%> to %<||%> or %<!%> to %<~%>
de: Klammern um Operand von %<!%> empfohlen, oder Änderung von %<|%> in %<||%> oder %<!%> in %<~%>

en: suggested alternative: | suggested alternatives:
de[0]: empfohlene Alternative:
de[1]: empfohlene Alternativen:

en: support for mode %qs
de: Unterstützung für Modus %qs

en: supported core architectures:%s
de: Unterstützte Kernarchitekturen:%s

en: switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch
de: Schalter %<-mcpu=%s%> steht mit dem Schalter %<-march=%s%> in Konflikt

en: switch %<-mcpu=%s%> conflicts with switch %<-march=%s%>
de: Schalter %<-mcpu=%s%> steht mit dem Schalter %<-march=%s%> in Konflikt

en: switch %<-mcustom-%s%> conflicts with switch %<-mcustom-%s%>
de: Option %<-mcustom-%s%> steht mit Option %<-mcustom-%s%> in Konflikt

en: switch %<-mcustom-%s%> is required for double-precision floating-point
de: Option %<-mcustom-%s%> wird für doppeltgenaue Gleitkomma benötigt

en: switch %<-mcustom-%s%> value %d must be between 0 and 255
de: Wert %2$d für Schalter %<-mcustom-%1$s%> muss zwischen 0 und 255 liegen

en: switch %qs does not start with %<-%>
de: Schalter %qs beginnt nicht mit %<-%>

en: switch %qs is no longer supported
de: Schalter %qs wird nicht mehr unterstützt

en: switch condition has boolean value
de: switch-Bedingung hat booleschen Wert

en: switch jumps into statement expression
de: switch springt in Anweisungs-Ausdruck

en: switch jumps over variable initialization
de: switch springt über Variableninitialisierung

en: switch missing default case
de: Die Standardfallbehandlung in switch fehlt

en: switch quantity not an integer
de: switch-Größe ist keine Ganzzahl

en: switch starts here
de: switch beginnt hier

en: switch statement of size %lu entries too large
de: switch-Anweisung der Größe %lu Einträge ist zu groß

en: symbol %qD referenced by %qD declared here
de: Symbol %qD, das von %qD referenziert wird, wurde hier deklariert

en: symbol needs to be defined to have a version
de: Symbol muss definiert sein, um eine Version zu haben

en: symbol used as immediate operand
de: Zeichen als Immediate-Operand verwendet

en: symbol used with both base and indexed registers
de: Zeichen sowohl mit Basis- als auch Index-Registern verwendet

en: symbol with offset used in PIC mode
de: Symbol mit Offset im PIC-Modus verwendet

en: symbolic memory references are only supported on z10 or later
de: symbolische Speicherreferenzen werden nur auf z10 oder neuer unterstützt

en: symtab_node::verify failed
de: Interner Fehler: symtab_node::verify failed

en: symver attribute argument must have format %<name@nodename%>
de: Argument des Attributs »symver« muss das Format %<Name@Nodenname%> haben

en: symver is not exported with default visibility
de: Interner Fehler: symver is not exported with default visibility

en: symver is only supported on ELF platforms
de: %<symver%> wird nur auf ELF-Plattformen unterstützt

en: symver target is not exported with default visibility
de: Interner Fehler: symver target is not exported with default visibility

en: synthesized method %qD first required here
de: erzeugte Methode %qD zuerst hier erfordert

en: system path %qs is not absolute
de: System-Pfad %qs ist nicht absolut

en: taking address of an immediate function %qD
de: Adresse der direkten Funktion %qD wird genommen

en: taking address of constructor %qD
de: Adresse des Konstruktors %qD wird genommen

en: taking address of destructor %qD
de: Adresse des Destruktors %qD wird genommen

en: taking address of expression of type %<void%>
de: Adresse des Ausdrucks des Typs %<void%> wird genommen

en: taking address of packed member of %qT may result in an unaligned pointer value
de: Zugriff auf die Adresse des gepackten Elements von %qT führt möglicherweise zu einem nicht ausgerichteten Zeigerwert

en: taking address of rvalue
de: Adresse eines rvalues wird ermittelt

en: taking address of temporary array
de: Adresse eines temporären Wertes wird verwendet

en: taking the absolute value of unsigned type %qT has no effect
de: den Betrag des vorzeichenlosen Typs %qT zu berechnen, hat keine Auswirkung

en: taking the address of a label is non-standard
de: Das Ermitteln der Adresse einer Marke ist nicht standardkonform

en: target & host is %qs:%qs, expected %qs:%qs
de: Ziel und Gastgeber sind %qs:%qs, erwartet werden jedoch %qs:%qs

en: target CPU does not support ARM mode
de: Ziel-CPU unterstützt nicht ARM-Modus

en: target CPU does not support ARMv8-M Security Extensions
de: Ziel-CPU unterstützt keine ARMv8-M-Security-Erweiterungen

en: target CPU does not support THUMB instructions
de: Ziel-CPU unterstützt keine THUMB-Befehle

en: target CPU does not support interworking
de: Ziel-CPU unterstützt keine Zusammenarbeit

en: target CPU does not support unaligned accesses
de: Ziel-CPU unterstützt keine unausgerichteten Zugriffe

en: target OS does not support unaligned accesses
de: Ziel-Betriebssystem unterstützt keine unausgerichteten Zugriffe

en: target argument
de: Zielargument

en: target attribute is not supported on this machine
de: Ziel-Attribut wird auf dieser Maschine nicht unterstützt

en: target attribute or pragma changes %<long double%> size
de: Ziel-Attribut oder Pragma ändert Größe von %<long double%>

en: target attribute or pragma changes AltiVec ABI
de: Ziel-Attribut oder Pragma ändert AltiVec ABI

en: target attribute or pragma changes darwin64 ABI
de: Ziel-Attribut oder Pragma ändert darwin64 ABI

en: target does not support atomic profile update, single mode is selected
de: Ziel unterstützt kein Aktualisieren des atomaren Profils, einfacher Modus wird ausgewählt

en: target does not support function version dispatcher
de: Zielsystem unterstützt Funktionsversions-Dispatcher nicht

en: target format does not support infinity
de: Zielformat unterstützt nicht »unendlich«

en: target is not pointer or reference
de: Ziel ist kein Zeiger oder Referenz

en: target is not pointer or reference to class
de: Ziel ist kein Zeiger oder Referenz auf Klasse

en: target is not pointer or reference to complete type
de: Ziel ist kein Zeiger oder Referenz auf vollständigen Typen

en: target of conversion might be a candidate for a format attribute
de: Ziel der Umwandlung könnte Kandidat ein für ein Formatattribut sein

en: target of initialization might be a candidate for a format attribute
de: Ziel der Initialisierung könnte ein Kandidat für Formatattribut sein

en: target specific builtin not available
de: zielspezifische eingebaute Funktion ist nicht verfügbar

en: target specific option mismatch
de: Fehlzuordnung zielspezifischer Optionen

en: target system does not support debug output
de: Zielsystem unterstützt keine Testausgaben

en: target system does not support the %qs debug format
de: Zielsystem unterstützt nicht das Testformat %qs

en: targets missing after %qs
de: Zielarchitekturen fehlen hinter %qs

en: template %qD declared
de: Template %qD deklariert

en: template %qE in clause %qs
de: Template %qE in Klausel %qs

en: template argument %d is invalid
de: Templateargument %d ist ungültig

en: template argument %qE for type %qT not a compile-time constant
de: Templateargument %qE für Typ %qT ist keine Übersetzungszeit-Konstante

en: template argument for %qD uses local type %qT
de: Templateargument für %qD verwendet lokalen Typ %qT

en: template argument required for %<%s %T%>
de: Template-Argument für %<%s %T%> benötigt

en: template arguments to %qD do not match original template %qD
de: Template-Argumente für %qD passen nicht zum ursprünglichen Template %qD

en: template class without a name
de: Templateklasse ohne Namen

en: template constraint failure for %qD
de: Template-Einschränkung für %qD fehlgeschlagen

en: template declaration of %<typedef%>
de: Templatedeklaration von %<typedef%>

en: template declaration of %q#D
de: Templatedeklaration von %q#D

en: template definition of non-template %q#D
de: Template-Definition eines Nicht-Templates %q#D

en: template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)
de: Instanziierungstiefe für Templates überschreitet Höchstwert %d (%<-ftemplate-depth=%> verwenden, um dies zu erhöhen)

en: template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)
de: Instanziierungstiefe für Templates überschreitet Höchstwert %d beim Instanziieren von %q+D, möglicherweise wegen Generierung der virtuellen Tabelle (%<-ftemplate-depth=%> verwenden, um den Höchstwert zu erhöhen)

en: template parameter %q+#D
de: Template-Parameter %q+#D

en: template parameter %qD declared here
de: Templateparameter %qD hier deklariert

en: template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type
de: Templateparameter %qD vom Typ %qT ist in ganzzahligem Konstantenausdruck nicht erlaubt, da er nicht Ganzzahl- oder Aufzählungstyp hat

en: template parameter list used in explicit instantiation
de: Templateparameterliste in expliziter Instanziierung verwendet

en: template parameter lists provided don%'t match the template parameters of %qD
de: angegebene Template-Parameterlisten passen nicht zu Templateparametern von %qD

en: template parameter pack %qD cannot have a default argument
de: Templateparameterpack %qD kann kein Standardargument haben

en: template parameter pack cannot have a default argument
de: Templateparameterpack kann kein Standardargument haben

en: template parameter packs cannot have default arguments
de: Template-Parameterpacks können keine Standardargumente haben

en: template parameter type %qT declared %<friend%>
de: Template-Parameter-Typ %qT als %<friend%> deklariert

en: template parameters cannot be friends
de: Template-Parameter können keine »friends« sein

en: template parameters do not match template %qD
de: Template-Parameter passen nicht zum Template %qD

en: template parameters not deducible in partial specialization:
de: Templateparameter nicht in partieller Spezialisierung herleitbar:

en: template placeholder type %qT must be followed by a simple declarator-id
de: Template-Platzhaltertyp %qT muss von einer einfachen declarator-id gefolgt sein

en: template specialization of %qD not allowed by ISO C++
de: Templatespezialisierung von %qD durch ISO C++ nicht erlaubt

en: template specialization with C linkage
de: Templatespezialisierung mit C-Bindung angegeben

en: template specifiers not specified in declaration of %qD
de: keine Templatespezifizierer in Deklaration von %qD angegeben

en: template template parameter %qT in declaration of deduction guide
de: Template-Template-Parameter %qT in Deklaration von Ableitungshinweis

en: template type parameters must use the keyword %<class%> or %<typename%>
de: Templatetypparameter müssen das Schlüsselwort %<class%> oder %<typename%> verwenden

en: template with C linkage
de: Template mit C-Bindung

en: template-id %qD for %q+D does not match any template declaration
de: Template-ID %qD für %q+D passt zu keiner Templatedeklaration

en: template-id %qD used as a declarator
de: Template-ID %qD als Deklarator verwendet

en: template-id %qE in declaration of primary template
de: Template-ID %qE in Deklaration des ersten Templates

en: template-id not allowed for destructor
de: Template-ID ist für Destruktor nicht erlaubt

en: template-introductions are not part of C++20 concepts; use %qs to enable
de: Template-Einführungen sind nicht Teil der C++20-Konzepte; verwenden Sie %qs, um sie zu aktivieren

en: template-parameter-
de: Template-Parameter-

en: templates may not be %<virtual%>
de: Templates dürfen nicht %<virtual%> sein

en: temporary of non-literal type %qT in a constant expression
de: Zwischenergebnis des nicht-literalen Typs %qT in konstantem Ausdruck

en: ternary %<operator?:%>
de: ternärer %<operator?:%>

en: ternary %<operator?:%> in %<%E ? %E : %E%>
de: ternärer %<operator?:%> in %<%E ? %E : %E%>

en: testing if a concept-id is a valid expression; add %<requires%> to check satisfaction
de: Prüfung, ob eine Konzept-ID ein gültiger Ausdruck ist; fügen Sie %<requires%> hinzu, um die Erfüllung zu prüfen

en: the %<bool%> keyword is not allowed in a C++20 concept definition
de: das Schlüsselwort %<bool%> ist in einer Konzeptdefinition in C++20 nicht erlaubt

en: the %<device%> clause expression must evaluate to %<1%>
de: der Ausdruck der %<device%>-Klausel muss den Wert %<1%> haben

en: the %<device%> clause expression must evaluate to %<1%> at %C
de: der Ausdruck der %<device%>-Klausel bei %C muss den Wert %<1%> haben

en: the %<interrupt%> attribute requires a MIPS32r2 processor or greater
de: das %<interrupt%>-Attribut erfordert einen MIPS32r2-Prozessor oder neuer

en: the %qE attribute cannot be applied to an SVE function type
de: das Attribut %qE kann nicht auf einen SVE-Funktionstyp angewendet werden

en: the %qE attribute requires arguments
de: Attribut %qE erfordert Argumente

en: the %qs architecture does not support %<-m%s=2008%>
de: die Architektur %qs unterstützt %<-m%s=2008%>

en: the %qs architecture does not support %<-m%s=legacy%>
de: die Architektur %qs unterstützt %<-m%s=legacy%> nicht

en: the %qs architecture does not support %<-mfp32%>
de: die Architektur %qs unterstützt %<-mfp32%> nicht

en: the %qs architecture does not support DSP instructions
de: die Architektur %qs unterstützt keine DSP-Befehle

en: the %qs architecture does not support branch-likely instructions
de: die Architektur %qs unterstützt keine Befehle mit Sprungwahrscheinlichkeit

en: the %qs architecture does not support madd or msub instructions
de: die Architektur %qs unterstützt die Befehle »madd« und »msub« nicht

en: the %qs architecture does not support odd single-precision registers
de: die Architektur %qs unterstützt keine ungeraden Register für einfache Genauigkeit

en: the %qs architecture does not support paired-single instructions
de: die Architektur %qs unterstützt keine paarweisen Einzel-Befehle

en: the %qs architecture does not support the synci instruction
de: die Architektur %qs unterstützt nicht den synci-Befehl

en: the %qs debug info cannot be used with pre-compiled headers
de: die Debug-Informationen %qs kann nicht mit vorkompilierten Headern verwendet werden

en: the ' ' printf flag
de: das » «-printf-Kennzeichen

en: the '!' strfmon flag
de: das »!«-strfmon-Kennzeichen

en: the '#' printf flag
de: das »#«-printf-Kennzeichen

en: the '#' strftime flag
de: das »#«-strftime-Kennzeichen

en: the ''' printf flag
de: das »'«-printf-Kennzeichen

en: the ''' scanf flag
de: das »'«-scanf-Kennzeichen

en: the '(' strfmon flag
de: das »(«-strfmon-Kennzeichen

en: the '+' printf flag
de: das »+«-printf-Kennzeichen

en: the '+' strfmon flag
de: das »+«-strfmon-Kennzeichen

en: the '-' printf flag
de: das »-«-printf-Kennzeichen

en: the '-' strfmon flag
de: das »-«-strfmon-Kennzeichen

en: the '-' strftime flag
de: das »-«-strftime-Kennzeichen

en: the '0' printf flag
de: das »0«-printf-Kennzeichen

en: the '0' strftime flag
de: das »0«-strftime-Kennzeichen

en: the 'E' strftime modifier
de: der »E«-strftime-Modifizierer

en: the 'I' printf flag
de: das »I«-printf-Kennzeichen

en: the 'I' scanf flag
de: das »I«-scanf-Kennzeichen

en: the 'O' modifier
de: der »O«-Modifizierer

en: the 'O' strftime modifier
de: der »O«-strftime-Modifizierer

en: the '^' strfmon flag
de: das »^«-strfmon-Kennzeichen

en: the '^' strftime flag
de: das »^«-strftime-Kennzeichen

en: the '_' strftime flag
de: das »_«-strftime-Kennzeichen

en: the 'a' scanf flag
de: das »a«-scanf-Kennzeichen

en: the 'm' scanf flag
de: das »m«-scanf-Kennzeichen

en: the 'q' diagnostic flag
de: das »q«-Diagnose-Kennzeichen

en: the -shared option is not currently supported for VAX ELF
de: Die Option »-shared« wird derzeit nicht für VAX ELF unterstützt

en: the ABI for passing a value containing zero-width fields before an adjacent 64-bit floating-point field was changed in GCC %{12.1%}
de: die ABI für die Übergabe eines Wertes, der Felder mit Null-Breite vor einem benachbarten 64-Bit-Gleitkommafeld enthält, wurde %{mit GCC 12.1%} geändert

en: the ABI for passing parameters with %d-byte alignment has changed in GCC 4.6
de: Das ABI der Parameterübergabe mit %d-Byte-Ausrichtung hat sich in GCC 4.6 geändert

en: the ABI for returning a value containing zero-width bit-fields but otherwise an aggregate with only one or two floating-point fields was changed in GCC %{12.1%}
de: die ABI für die Rückgabe eines Wertes, der Bit-Felder mit der Breite Null enthält, aber ansonsten ein Aggregat mit nur einem oder zwei Fließkomma-Feldern ist, wurde %{mit GCC 12.1%} geändert

en: the ABI for returning a value with C++17 empty bases but otherwise an aggregate with only one or two floating-point fields was changed in GCC %{12.1%}
de: die ABI für die Rückgabe eines Wertes, der leere C++17-Basen enthält, aber ansonsten ein Aggregat mit nur einem oder zwei Fließkomma-Feldern ist, wurde %{mit GCC 12.1%} geändert

en: the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}
de: das ABI der C-Strukturübergabe mit Bitfeldern der Breite 0 hat sich in GCC %{12.1%} geändert

en: the ABI of passing struct with a flexible array member has changed in GCC 4.4
de: Das ABI der Struct-Übergabe mit einem flexiblen Arrayelement hat sich in GCC 4.4 geändert

en: the ABI of passing structure with %<complex float%> member has changed in GCC 4.4
de: das ABI der Strukturübergabe mit %<complex float%>-Element hat sich in GCC 4.4 geändert

en: the ABI of passing union with %<long double%> has changed in GCC 4.4
de: das ABI der Union-Übergabe mit %<long double%> hat sich in GCC 4.4 geändert

en: the ENI instruction operand must be either 0 or 1
de: Operand für den ENI-Befehl muss entweder 0 oder 1 sein

en: the RX100 cpu does not have FPU hardware
de: Die RX100-CPU hat keine FPU-Hardware

en: the RX200 cpu does not have FPU hardware
de: Die RX200-CPU hat keine FPU-Hardware

en: the address %qE will never be NULL
de: die Adresse %qE ist niemals NULL

en: the address of %qD is not a valid template argument
de: die Adresse von %qD ist kein gültiges Templateargument

en: the address of %qD is not a valid template argument because it does not have static storage duration
de: die Adresse von %qD ist kein gültiges Templateargument, weil sie keine statische Lebensdauer hat

en: the address of %qD will always evaluate as %<true%>
de: Die Adresse von %qD wird immer zu %<wahr%> auswerten

en: the address of %qD will never be %<null%>
de: die Adresse von %qD ist niemals %<null%>

en: the address of %qD will never be NULL
de: die Adresse von %qD ist niemals NULL

en: the address of a label cannot appear in a constant-expression
de: die Adresse einer Marke kann nicht in einem Konstanten-Ausdruck auftreten

en: the address of the %qT subobject of %qD is not a valid template argument
de: die Adresse des %qT-Teilobjekts von %qD ist kein gültiges Templateargument

en: the align argument to %<__builtin_coro_promise%> must be a constant
de: das align-Argument für %<__builtin_coro_promise%> muss eine Konstante sein

en: the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}
de: die Ausrichtung von %<_Atomic %T%>-Feldern wurde mit %{GCC 11.1%} geändert

en: the argument to %<xabort%> intrinsic must be an 8-bit immediate
de: Das Argument zum eingebauten %<xabort%> ein 8-Bit-Direktwert sein

en: the assignment suppression scanf feature
de: das scanf-Merkmal der Zuweisungsunterdrückung

en: the call requires %<ifunc%>, which is not supported by this target
de: der Aufruf erfordert %<ifunc%>, was von diesem Ziel nicht unterstützt wird

en: the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)
de: die Aufrufkonvention für %qT ändert sich mit %<-fabi-version=13%> (GCC 8.2)

en: the combination of %qs and %qs is incompatible with %qs
de: die Kombination von %qs und %qs ist mit %qs unverträglich

en: the comparison reduces to %qE
de: der Vergleich wird zu %qE reduziert

en: the comparison will always evaluate as %<false%> for the address of %qE will never be NULL
de: der Vergleich wird immer als %<false%> ausgewertet, da die Adresse von %qE niemals NULL sein wird

en: the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL
de: der Vergleich wird immer als %<false%> ausgewertet, da der Zeigeroperand in %qE nicht NULL sein darf

en: the comparison will always evaluate as %<true%> for the address of %qE will never be NULL
de: der Vergleich wird immer als %<true%> ausgewertet, da die Adresse von %qE niemals NULL sein wird

en: the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL
de: der Vergleich wird immer als %<true%> ausgewertet, da der Zeigeroperand in %qE nicht NULL sein darf

en: the compiler can assume that the address of %qD will always evaluate to %<true%>
de: der Compiler kann davon ausgehen, dass die Adresse von %qD immer zu %<true%> evaluiert

en: the compiler can assume that the address of %qD will never be NULL
de: der Compiler kann annehmen, dass die Adresse von %qD niemals NULL ist

en: the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L
de: Die Komponente %qs ist ein PRIVATE-Typ und kann nicht Komponente von %qs sein, die PUBLIC bei %L ist

en: the conflicting type defined in another translation unit
de: der in Konflikt stehende Typ aus der anderen Übersetzungseinheit

en: the conflicting type defined in another translation unit has virtual table of different size
de: die virtuelle Tabelle des in Konflikt stehenden Typs aus der anderen Übersetzungseinheit ist unterschiedlich groß

en: the conflicting type defined in another translation unit has virtual table with different contents
de: der in Konflikt stehende Typ aus der anderen Übersetzungseinheit hat virtuelle Tabelle mit unterschiedlichem Inhalt

en: the conflicting type defined in another translation unit has virtual table with more entries
de: der in Konflikt stehende Typ aus der anderen Übersetzungseinheit hat virtuelle Tabelle mit mehr Einträgen

en: the conflicting type defined in another translation unit with different RTTI information
de: der in Konflikt stehende Typ aus der anderen Übersetzungseinheit hat unterschiedliche RTTI-Information

en: the content of uninitialized storage is not usable in a constant expression
de: der Wert von uninitialisiertem Speicher ist in konstantem Ausdruck nicht verwendbar

en: the control flow of function %qD does not match its profile data (counter %qs)
de: Kontrollfluss der Funktion %qD passt nicht zu ihren Profilingdaten (Zähler %qs)

en: the coroutine promise type %qT declares both %<return_value%> and %<return_void%>
de: der Versprechens-Typ %qT der Koroutine deklariert sowohl %<return_value%> als auch %<return_void%>

en: the count should be no less than 0; please check the intrinsic %qs in code
de: der Zähler sollte nicht kleiner als 0 sein; bitte das intrinsische %qs im Code prüfen

en: the default value for the current CPU tuning is %d bytes
de: der Vorgabewert für die aktuelle CPU-Feineinstellung ist %d Bytes

en: the direction argument to %<__builtin_coro_promise%> must be a constant
de: das Richtungsargument für %<__builtin_coro_promise%> muss eine Konstante sein

en: the dot syntax is not available in Objective-C 1.0
de: in Objective-C 1.0 gibt es keine Dot-Syntax

en: the ellipsis in %qD is not inherited
de: die Auslassung in %qD wurde nicht vererbt

en: the event handle of a %<detach%> clause should not be in a data-sharing clause
de: das Ereignishandle einer %<detach%>-Klausel sollte nicht in einer data-sharing-Klausel sein

en: the expression %qE evaluated to %<false%>
de: der Ausdruck %qE wird zu %<false%> ausgewertet

en: the expression %qE is required to be non-throwing
de: der Ausdruck %qE darf keine Exception werfen

en: the extra base is defined here
de: die zusätzliche Basisklasse ist hier definiert

en: the fifth argument must be an 8-bit immediate
de: fünftes Argument muss ein 8-Bit-Immediate sein

en: the first argument of a %qs must be of a boolean vector type of the same number of elements as the result
de: das erste Argument eines %qs muss von booleschem Vektortyp sein und gleich viele Elemente wie das Ergebnis haben

en: the first difference of corresponding definitions is field %qD
de: der erste Unterschied der entsprechenden Definitionen ist Feld %qD

en: the first difference of corresponding definitions is method %qD
de: der erste Unterschied der entsprechenden Definitionen ist Methode %qD

en: the first parameter of %<operator new%> cannot have a default argument
de: der erste Parameter von %<operator new%> kann nicht das Standardargument haben

en: the forth argument must be scale 1, 2, 4, 8
de: Das vierte Argument muss Skalierung 1, 2, 4, 8 sein

en: the frame size of %wu bytes is larger than %wu bytes
de: die Rahmengröße von %wu Bytes überschreitet %wu Bytes

en: the immediate argument must be a 4-bit immediate
de: Der direkte Argument muss ein 4-Bit-Immediate sein

en: the immediate argument must be a 5-bit immediate
de: Das direkte Argument muss ein 5-Bit-Immediate sein

en: the immediate argument must be an 8-bit immediate
de: Das direkte Argument muss ein 8-Bit-Immediate sein

en: the incompatible type defined in another translation unit
de: der inkompatible Typ, der in einer anderen Übersetzungseinheit definiert ist

en: the incompatible type is defined here
de: der inkompatible Typ ist hier definiert

en: the lambda has no capture-default
de: das Lambda hat keinen »capture-default«

en: the last argument must be a 1-bit immediate
de: Das letzte Argument muss ein 1-Bit-Immediate sein

en: the last argument must be a 2-bit immediate
de: Das letzte Argument muss ein 2-Bit-Immediate sein

en: the last argument must be a 3-bit immediate
de: das letzte Argument muss ein 3-Bit-Immediate sein

en: the last argument must be a 32-bit immediate
de: Das letzte Argument muss ein 32-Bit-Immediate sein

en: the last argument must be a 4-bit immediate
de: Das letzte Argument muss ein 4-Bit-Immediate sein

en: the last argument must be a 5-bit immediate
de: Das letzte Argument muss ein 5-Bit-Immediate sein

en: the last argument must be an 1-bit immediate
de: Das letzte Argument muss ein 1-Bit-Immediate sein

en: the last argument must be an 8-bit immediate
de: Das letzte Argument muss ein 8-Bit-Immediate sein

en: the last argument must be scale 1, 2, 4, 8
de: Das letzte muss Skalierung 1, 2, 4, 8 sein

en: the m210 does not have little endian support
de: der m210 hat keine Little-Endian-Unterstützung

en: the macro %qs had not yet been defined
de: das Makro %qs war noch nicht definiert

en: the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)
de: der gemangelte Name von %qD hat sich zwischen %<%s=%d%> (%qD) und %<%s=%d%> (%qD) geändert

en: the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)
de: der gemangelte Name von %qD ändert sich zwischen %<%s=%d%> (%qD) und %<%s=%d%> (%qD)

en: the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>
de: der gemangelte Name von %qD ändert sich zwischen %<-fabi-version=%d%> und %<-fabi-version=%d%>

en: the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>
de: der gemangelte Name eines Thunks für %qD ändert sich zwischen %<-fabi-version=%d%> und %<-fabi-version=%d%>

en: the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>
de: der gemangelte Name der Initialisierungswächter-Variable für %qD ändert sich zwischen %<-fabi-version=%d%> und %<-fabi-version=%d%>

en: the max value for the last size range should be -1 for option %qs
de: der Maximalwert für den letzten Größenbereich sollte für Option %qs -1 sein

en: the message attached to %<unavailable%> is not a string
de: die an %<unavailable%> angehängte Nachricht ist keine Zeichenkette

en: the next to last argument must be an 8-bit immediate
de: Das vorletzte Argument muss ein 8-Bit-Immediate sein

en: the omitted middle operand in %<?:%> will always be %<true%>, suggest explicit middle operand
de: Der ausgelassene mittlere Operand in %<?:%> ist immer %<true%>; ausdrücklicher mittlerer Operand wird empfohlen

en: the operand %qE is unsatisfied because
de: der Operand %qE ist nicht erfüllt, da

en: the program should also define %qD
de: das Programm sollte auch %qD definieren

en: the range of count should be in 0 to 16; please check the intrinsic %qs in code
de: der Wertebereich des Zählers sollte im Bereich 0 bis 16 sein; bitte das intrinsische %qs im Code prüfen

en: the range of count should be in 0 to 32; please check the intrinsic %qs in code
de: der Wertebereich des Zählers sollte im Bereich 0 bis 32 sein; bitte das intrinsische %qs im Code prüfen

en: the range of count should be in 0 to 64; please check the intrinsic %qs in code
de: der Wertebereich des Zählers sollte im Bereich 0 bis 64 sein; bitte das intrinsische %qs im Code prüfen

en: the range of mask should be in 0 to 255
de: der Wertebereich der Maske ist 0 bis 255

en: the range of selector should be in 0 to 1
de: der Wertebereich des Selektors sollte 0 bis 1 sein

en: the range of selector should be in 0 to 3
de: der Wertebereich des Selektors sollte 0 bis 3 sein

en: the range of selector should be in 0 to 7
de: der Wertebereich des Selektors sollte 0 bis 7 sein

en: the register %qs cannot be clobbered in %<asm%> for the current target
de: das Register %qs kann in %<asm%> für das aktuelle Ziel nicht bestraft werden

en: the register specified for %q+D cannot be accessed by the current target
de: für %q+D angegebenes Register kann vom aktuellen Ziel nicht zugegriffen werden

en: the register specified for %q+D is not general enough to be used as a register variable
de: für %q+D angegebenes Register ist nicht allgemein genug, um als eine Registervariable verwendet zu werden

en: the required expression %qE is invalid
de: der erforderliche Ausdruck %qE ist ungültig

en: the required expression %qE is invalid, because
de: der erforderliche Ausdruck %qE ist ungültig, da

en: the required type %qT is invalid
de: der erforderliche Typ %qT ist ungültig

en: the required type %qT is invalid, because
de: der erforderliche Typ %qT ist ungültig, da

en: the result for the xxspltidp instruction is undefined for subnormal input values
de: das Ergebnis des Befehls xxspltidp ist für denormalisierte Eingabewerte undefiniert

en: the result of the conversion is unspecified because %qE is outside the range of type %qT
de: das Ergebnis der Umwandlung ist nicht spezifiziert, da %qE außerhalb des Wertebereichs des Typs %qT liegt

en: the same loop iteration variables %qD used in multiple associated loops
de: die selben Schleifen-Iterationsvariablen %qD werden in mehreren verknüpften Schleifen verwendet

en: the target does not support %<asm goto%> with outputs in %<asm%>
de: dieses Ziel unterstützt nicht %<asm goto%> mit Ausgaben in %<asm%>

en: the third argument must be an 8-bit immediate
de: drittes Argument muss ein 8-Bit-Immediate sein

en: the third argument must be comparison constant
de: das dritte Argument muss eine Vergleichskonstante sein

en: the type %qT of %<constexpr%> variable %qD is not literal
de: der Typ %qT der %<constexpr%>-Variable %qD ist kein Literal

en: the type being destroyed is %qT, but the destructor refers to %qT
de: der zerstörte Typ ist %qT, aber der Destruktor verweist auf %qT

en: the value of %qD is not usable in a constant expression
de: der Wert von %qD ist in konstantem Ausdruck nicht verwendbar

en: the value of the stack pointer after an %<asm%> statement must be the same as it was before the statement
de: Der Wert des Stapelzeigers muss nach einer %<asm%>-Anweisung derselbe sein wie vor der Anweisung

en: there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available
de: es gibt keine Argumente für %qD, die von einem Templateparameter abhängen, weshalb eine Deklaration von %qD verfügbar sein muss

en: third argument of %q+D should probably be %<char **%>
de: drittes Argument von %q+D sollte wahrscheinlich %<char **%> sein

en: third argument to %<__builtin_prefetch%> must be a constant
de: Drittes Argument für %<__builtin_prefetch%> muss eine Konstante sein

en: third argument to function %qE must be a constant integer
de: Drittes Argument für Funktion %qE muss eine konstante Ganzzahl sein

en: third operand of conditional expression cannot resolve address of overloaded function
de: dritter Operand des bedingten Ausdrucks kann die Adresse der überladenen Funktion nicht auflösen

en: third operand of conditional expression has no effect
de: dritter Operand des bedingten Ausdrucks hat keinen Effekt

en: third operand of conditional expression is a reference, not call, to function %qE
de: dritter Operand des bedingten Ausdrucks ist eine Referenz, kein Aufruf, zur Funktion %qE

en: third operand to the conditional operator is of type %<void%>, but the second operand is neither a throw-expression nor of type %<void%>
de: dritter Operand für Bedingungsoperator ist vom Typ %<void%>, aber der zweite Operand ist weder ein Throw-Ausdruck noch vom Typ %<void%>

en: this %qs clause does not guard...
de: diese %qs-Klausel beschützt nicht …

en: this built-in function is only available on the fr405 and fr450
de: diese eingebaute Funktion ist nur auf dem fr405 und fr450 verfügbar

en: this built-in function is only available on the fr450
de: diese eingebaute Funktion ist nur auf dem fr450 verfügbar

en: this built-in function is only available on the fr500 and fr550
de: diese eingebaute Funktion ist nur auf dem fr500 und fr550 verfügbar

en: this built-in function is only available on the v3f toolchain
de: diese eingebaute Funktion ist nur mit der Toolchain v3f verfügbar

en: this built-in function is only available on the v3s or v3f toolchain
de: diese eingebaute Funktion ist nur mit der Toolchain v3s oder v3f verfügbar

en: this built-in function not support on the v3m toolchain
de: diese eingebaute Funktion wird von der Toolchain v3m nicht unterstützt

en: this builtin is not supported for this target
de: diese eingebaute Funktion wird auf diesem Ziel nicht unterstützt

en: this compiler does not support %qs
de: dieser Compiler unterstützt %qs nicht

en: this compiler does not support PowerPC (%<-arch%> option ignored)
de: dieser Compiler unterstützt PowerPC nicht (%<arch%>-Option wird ignoriert)

en: this compiler does not support x86 (%<-arch%> option ignored)
de: dieser Compiler unterstützt x86 nicht (%<-arch%>-Option wird ignoriert)

en: this condition has identical branches
de: diese Bedingung hat identische Zweige

en: this decimal constant is unsigned only in ISO C90
de: diese Dezimalkonstante ist nur in ISO-C90 vorzeichenlos

en: this decimal constant would be unsigned in ISO C90
de: diese Dezimalkonstante wäre in ISO-C90 vorzeichenlos

en: this definition requires the MVE ISA extension
de: diese Definition erfordert die MVE-ISA-Erweiterung

en: this flexibility is deprecated and will be removed
de: diese Flexibilität ist veraltet und wird demnächst entfernt

en: this is a GCC bug that can be worked around by adding attribute used to function called
de: dies ist ein GCC-Bug; ein Workaround ist, die aufgerufene Funktion mit dem »used«-Attribut zu markieren

en: this is the first default label
de: Dies ist die erste Standardmarke

en: this is the first entry overlapping that value
de: Dies ist der erste Eintrag, der diesen Wert überschneidet

en: this is the insn:
de: dies ist der Befehl:

en: this media function is only available on the fr400 and fr550
de: diese Medienfunktion ist nur auf dem fr400 und fr550 verfügbar

en: this media function is only available on the fr500
de: diese Medienfunktion ist nur auf dem fr500 verfügbar

en: this operation requires the SVE ISA extension
de: diese Operation erfordert die SVE-ISA-Erweiterung

en: this statement may fall through
de: diese Anweisung könnte durchfallen

en: this target does not define a speculation barrier; your program will still execute correctly, but incorrect speculation may not be restricted
de: dieses Ziel definiert keine Spekulationsbarriere; das erzeugte Programm wird trotzdem korrekt laufen, aber irrige Spekulationen sind möglicherweise nicht eingeschränkt

en: this target does not support %qs
de: dieses Ziel unterstützt nicht %qs

en: this target is little-endian
de: Diese Zielarchitektur ist »Little Endian«

en: this target machine does not have delayed branches
de: diese Zielmaschine hat keine verzögerten Zweige

en: thread-local COMMON data not implemented
de: Thread-lokale COMMON-Daten nicht implementiert

en: thread-local declaration of %q#D follows non-thread-local declaration
de: Thread-lokale Deklaration von %q#D folgt nicht-Thread-lokaler Deklaration

en: thread-local declaration of %q+D follows non-thread-local declaration
de: Thread-lokale Deklaration von %q+D folgt nicht-Thread-lokaler Deklaration

en: threadprivate iteration variable %qD
de: threadprivate Iterationsvariable %qD

en: threadprivate variable %qE used in a region with %<order(concurrent)%> clause
de: threadprivate Variable %qE in Zielregion mit %<order(concurrent)%>-Klausel verwendet

en: threadprivate variable %qE used in target region
de: threadprivate Variable %qE in Zielregion verwendet

en: threadprivate variable %qE used in untied task
de: threadprivate Variable %qE in unverknüpfter Task verwendet

en: three-way comparison of %qD has type %qT, not a comparison category type
de: Dreiwege-Vergleich von %qD hat den Typ %qT, nicht den Vergleichskategorie-Typ

en: three-way comparison of %qD has type %qT, which does not convert to %qT
de: Dreiwege-Vergleich von %qD ist vom Typ %qT, der sich nicht in %qT umwandeln lässt

en: three-way comparison of vectors
de: Drei-Wege-Vergleich von Vektoren

en: throwing NULL, which has integral, not pointer type
de: wirft NULL, was ganzzahlig, aber kein Zeigertyp ist

en: thunk-inline is only supported with %<-mindirect-branch-jump%>
de: thunk-inline wird nur mit %<-mindirect-branch-jump%> unterstützt

en: to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified
de: zur Sicherheit müssen alle vorübergehenden Zeiger in Umwandlung von %qT in %qT mit %<const%> qualifiziert sein

en: to generate dependencies you must specify either %<-M%> or %<-MM%>
de: um Abhängigkeiten zu erzeugen, müssen Sie entweder %<-M%> oder %<-MM%> angeben

en: to match this %qs
de: andere Fundstelle von %qs ist hier

en: to refer to a type member of a template parameter, use %<typename %E%>
de: um auf ein Typelement eines Templateparameters zu verweisen, %<typename %E%> verwenden

en: toHash() must be declared as extern (D) size_t toHash() const nothrow @safe, not %s
de: toHash() muss als »extern (D) size_t toHash() const nothrow @safe« deklariert werden, nicht als %s

en: token %u has %<x-location == %u%>
de: Token %u hat %<x-location == %u%>

en: token %u has %<x-location == y-location == %u%>
de: Token %u hat %<x-location == y-location == %u%>

en: token %u has %<y-location == %u%>
de: Token %u hat %<y-location == %u%>

en: too few arguments to %%:version-compare
de: zu wenige Argumente für %%:version-compare

en: too few arguments to %<__builtin_tgmath%>
de: Zu wenige Argumente für %<__builtin_tgmath%>

en: too few arguments to built-in function %qE expecting %u
de: zu wenige Argumente für eingebaute Funktion %qE, %u erwartet

en: too few arguments to constructor %q#D
de: zu wenige Argumente für Konstruktor %q#D

en: too few arguments to function
de: zu wenige Argumente für Funktion

en: too few arguments to function %<va_start%>
de: Zu wenige Argumente für %<va_start%>

en: too few arguments to function %q#D
de: zu wenige Argumente für Funktion %q#D

en: too few arguments to function %qE
de: Zu wenige Argumente für Funktion %qE

en: too few arguments to member function %q#D
de: Zu wenige Argumente für Elementfunktion %q#D

en: too few arguments to method %q#D
de: zu wenige Argumente für Methode %q#D

en: too few expressions for struct
de: zu wenige Ausdrücke für Struktur

en: too few template parameter lists in declaration of %qD
de: zu wenige Templateparameterlisten in Deklaration von %qD

en: too few template-parameter-lists
de: zu wenige Templateparameterlisten

en: too late for # directive to set debug directory
de: zu spät für »#«-Direktive, um Debug-Verzeichnis festzulegen

en: too many %<#pragma options align=reset%>
de: zu viele %<#pragma options align=reset%>

en: too many %<...%> in lambda capture
de: zu viele %<...%> in Lambda-Capture

en: too many %<always%> modifiers
de: zu viele %<always%>-Modifizierer

en: too many %<always%> modifiers at %L
de: zu viele %<always%>-Modifizierer bei %L

en: too many %<close%> modifiers
de: zu viele %<close%>-Modifizierer

en: too many %<close%> modifiers at %L
de: zu viele %<close%>-Modifizierer bei %L

en: too many %<defaultmap%> clauses with %qs category
de: zu viele %<defaultmap%>-Klauseln mit %qs-Kategorie

en: too many %<defaultmap%> clauses with unspecified category
de: zu viele %<defaultmap%>-Klauseln mit nicht angegebener Kategorie

en: too many %<if%> clauses
de: zu viele %<if%>-Klauseln

en: too many %<if%> clauses with %qs modifier
de: zu viele %<if%>-Klauseln mit %qs-Modifizierer

en: too many %<if%> clauses without modifier
de: zu viele %<if%>-Klauseln ohne Modifizierer

en: too many %<static%> arguments
de: zu viele %<static%>-Argumente

en: too many %qs clauses
de: zu viele %qs-Klauseln

en: too many %qs clauses on a task construct
de: zu viele %qs-Klauseln an einem Task-Konstrukt

en: too many alternatives in %<asm%>
de: zu viele Alternativen in %<asm%>

en: too many arguments
de: zu viele Argumente

en: too many arguments for %%:dumps
de: zu viele Argumente für %%:dumps

en: too many arguments for format
de: zu viele Argumente für Format

en: too many arguments for partial specialization %qT
de: zu viele Argumente für teilweise Spezialisierung %qT

en: too many arguments passed in sgpr registers
de: zu viele Argumente, die in SGPR-Registern übergeben werden

en: too many arguments to %%:compare-debug-dump-opt
de: zu viele Argumente für %%:version-compare

en: too many arguments to %%:compare-debug-self-opt
de: zu viele Argumente für %%:compare-debug-self-opt

en: too many arguments to %%:version-compare
de: zu viele Argumente für %%:version-compare

en: too many arguments to built-in function %qE expecting %d
de: zu viele Argumente für eingebaute Funktion %qE, nur %d erwartet

en: too many arguments to constructor %q#D
de: zu viele Argumente für Konstruktor %q#D

en: too many arguments to function
de: zu viele Argumente für Funktion

en: too many arguments to function %q#D
de: zu viele Argumente für Funktion %q#D

en: too many arguments to function %qE
de: zu viele Argumente für Funktion %qE

en: too many arguments to make
de: zu viele Argumente für make

en: too many arguments to member function %q#D
de: zu viele Argumente für Elementfunktion %q#D

en: too many arguments to method %q#D
de: zu viele Argumente für Methode %q#D

en: too many arguments to method %qE
de: zu viele Argumente für Methode %qE

en: too many atomic clauses
de: zu viele atomare Klauseln

en: too many braces around initializer for %qT
de: zu viele geschweifte Klammern um Initialisierung für %qT

en: too many braces around scalar initializer for type %qT
de: zu viele geschweifte Klammern um skalare Initialisierung für Typ %qT

en: too many exception handling edges in bb %i
de: Interner Fehler: too many exception handling edges in bb %i

en: too many expressions for struct
de: zu viele Ausdrücke für Struktur

en: too many filenames given; type %<%s %s%> for usage
de: zu viele Dateinamen angegeben; geben Sie %<%s %s%> für das Aufrufformat ein

en: too many function arguments for eBPF
de: zu viele Funktionsargumente für eBPF

en: too many initializers for %qT
de: zu viele Initialisierer für %qT

en: too many input files
de: zu viele Eingabedateien

en: too many loop exits recorded
de: Interner Fehler: too many loop exits recorded

en: too many memory order clauses
de: zu viele Speicherreihenfolge-Klauseln

en: too many open parens
de: zu viele öffnende Klammern

en: too many outgoing branch edges from bb %i
de: Interner Fehler: too many outgoing branch edges from bb %i

en: too many size ranges specified in option %qs
de: zu viele Größenbereiche in Option %qs angegeben

en: too many template headers for %qD (should be %d)
de: zu viele Templateheader für %qD (sollten %d sein)

en: too many template parameter lists in declaration of %qD
de: zu viele Templateparameterlisten in Deklaration von %qD

en: too many template-parameter-lists
de: zu viele Templateparameterlisten

en: too many values in return statement
de: zu viele Werte in Rückgabeanweisung

en: too many variables for range clause with channel
de: zu viele Variablen in Bereichsklausel mit Kanal

en: too much stack space to dispose of: %d
de: Zu viel Stapelspeicher zu entsorgen: %d

en: too much stack space to prepare: %d
de: Zu viel Stapelspeicher vorzubereiten: %d

en: top-level comma expression in array subscript changed meaning in C++23
de: Komma-Ausdrücke auf höchster Ebene in einem Arrayindex haben seit C++23 eine andere Bedeutung

en: top-level comma expression in array subscript is deprecated
de: ungeklammerte Komma-Ausdrücke in Arrayindex-Ausdrücken sind veraltet

en: top-level declaration of %qs specifies %<auto%>
de: Deklaration höchster Ebene von %qs gibt %<auto%> an

en: toplevel reorder must be disabled when unit-at-a-time is disabled
de: Toplevel-Neuordnung muss ausgeschaltet sein, wenn »unit-at-a-time« ausgeschaltet ist

en: total size and element size must be a nonzero constant immediate
de: Gesamtgröße und Elementgröße müssen direkt angegebene Konstanten sein, beide ungleich null

en: total size of local objects %wu exceeds maximum %wu
de: Gesamtgröße der lokalen Objekte %wu überschreitet das Maximum %wu

en: total size of local objects exceeds maximum %wu
de: Gesamtgröße der lokalen Objekte überschreitet das Maximum %wu

en: total size of local objects is too large
de: Gesamtgröße der lokalen Objekte ist zu hoch

en: total size of local variables exceeds architecture limit
de: Gesamtgröße der lokalen Variablen übersteigt Grenze der Architektur

en: traditional C lacks a separate namespace for labels, identifier %qE conflicts
de: traditionelles C bietet keinen separaten Namensraum für Marken an, Bezeichner %qE steht in Konflikt

en: traditional C rejects ISO C style function definitions
de: traditionelles C weist Funktionsdefinitionen im ISO-C-Stil zurück

en: traditional C rejects automatic aggregate initialization
de: traditionelles C lehnt automatische Gesamt-Initialisierung ab

en: traditional C rejects initialization of unions
de: traditionelles C lehnt Initialisierung von unions ab

en: traditional C rejects string constant concatenation
de: traditionelles C weist Zeichenkettenkonstantenverkettung zurück

en: traditional C rejects the unary plus operator
de: traditionelles C weist den unären Plus-Operator zurück

en: trailing %<,%> in arguments for %<#pragma GCC diagnostic ignored_attributes%>
de: abschließendes %<,%> in Argumenten für %<#pragma GCC diagnostic ignored_attributes%>

en: trailing %<,%> in arguments for %<-Wno-attributes=%>
de: abschließendes %<,%> in Argumenten für %<-Wno-attributes=%>

en: trailing return type %qT of deduction guide is not a specialization of %qT
de: angehängter Rückgabetyp %qT den Ableitungshinweises ist keine Spezialisierung von %qT

en: trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>
de: nachgestellter Rückgabetyp nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: trampoline generated for nested function %qD
de: Trampolin für geschachtelte Funktion %qD erzeugt

en: transactional memory is not supported with %<-fsanitize=address%>
de: transaktionsbasierter Speicher wird von %<-fsanitize=address%> nicht unterstützt

en: transactional memory is not supported with %<-fsanitize=kernel-address%>
de: transaktionsbasierter Speicher wird von %<-fsanitize=kernel-address%> nicht unterstützt

en: transactional memory is not supported with non-call exceptions
de: transaktionsbasierter Speicher wird von Nicht-Aufruf-Ausnahmen nicht unterstützt

en: transformational intrinsic %qs at %L is not permitted in an initialization expression
de: Transformierende intrinsische Routine %qs bei %L ist in einem Initialisierungs-Ausdruck nicht erlaubt

en: trap mode not supported for VAX floats
de: Trap-Modus für VAX-Floats nicht unterstützt

en: tree code %qs is not supported in LTO streams
de: Baumcode %qs wird in LTO-Strömen nicht unterstützt

en: tree list ends on depth %i
de: Baumliste endet bei Tiefe %i

en: tried to perform floating-point modulo division on %qT
de: es wurde versucht, eine Gleitkommadivision mit Rest an %qT durchzuführen

en: true/false edge after a non-GIMPLE_COND in bb %d
de: Interner Fehler: true/false edge after a non-GIMPLE_COND in bb %d

en: try removing the parentheses around the type-id
de: Klammern um die Type-ID sollten entfernt werden

en: try using %qE instead
de: stattdessen %qE verwenden

en: trying to capture %qD in instantiation of generic lambda
de: Versuch, %qD in Instanziierung eines generischen Lambdas einzufangen

en: trying to encode non-integer type as a bit-field
de: es wird versucht, einen Nicht-Ganzzahltyp als Bitfeld zu kodieren

en: trying to finish struct, but kicked out due to previous parse errors
de: Lesen der struct konnte wegen Syntaxfehlern nicht beendet werden

en: trying to make class %qT a friend of global scope
de: Versuch, die Klasse %qT zu einem »friend« des globalen Gültigkeitsbereiches zu machen

en: tuning string missing in option (%s)
de: Tuning-Zeichenkette fehlt in Option »%s«

en: two consecutive %<[%> shall only introduce an attribute
de: zwei aufeinander folgende %<[%> dürfen nur ein Attribut einführen

en: two different outer iteration variables %qD and %qD used in a single loop
de: zwei unterschiedliche äußere Iterationsvariablen %qD und %qD werden in einer einzigen Schleife verwendet

en: two or more data types in declaration of %qs
de: zwei oder mehr Datentypen in Deklaration von %qs

en: two or more data types in declaration specifiers
de: zwei oder mehr Datentypen in Deklaration

en: two or more sections for %s
de: zwei oder mehr Abschnitte für %s

en: type %q#T argument given to %<delete%>, expected pointer
de: Argument vom Typ %q#T wurde an %<delete%> übergeben, Zeiger erwartet

en: type %qE has a user-defined constructor
de: Typ %qE hat einen benutzerdefinierten Konstruktor

en: type %qE has a user-defined destructor
de: Typ %qE hat einen benutzerdefinierten Destruktor

en: type %qE has no default constructor to call
de: Typ %qE hat keinen aufrufbaren Standard-Konstruktor

en: type %qE has virtual member functions
de: Typ %qE hat virtuelle Elementfunktionen

en: type %qT (typedef of %qT) violates the C++ One Definition Rule
de: Typ %qT (typedef von %qT) verletzt die One-Definition-Rule von C++

en: type %qT defined in anonymous namespace cannot match across the translation unit boundary
de: Typ %qT (in unbenanntem Namensraum definiert) kann nicht passen (über Grenzen von Übersetzungseinheiten hinaus)

en: type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary
de: Typ %qT (in unbenanntem Namensraum definiert) kann nicht zum Typ %qT passen (über Grenzen von Übersetzungseinheiten hinaus)

en: type %qT does not have a known size
de: Typ %qT hat keine bekannte Größe

en: type %qT for explicit instantiation %qD does not match declared type %qT
de: Typ %qT für explizite Instanziierung %qD passt nicht zum deklarierten Typ %qT

en: type %qT is not a base type for type %qT
de: Typ %qT ist kein Basistyp für Typ %qT

en: type %qT is not a direct base of %qT
de: Typ %qT ist keine direkte Basis von %qT

en: type %qT is not a direct or virtual base of %qT
de: Typ %qT ist keine direkte oder virtuelle Basis von %qT

en: type %qT is too large
de: Typ %qT ist zu groß

en: type %qT itself violates the C++ One Definition Rule
de: Typ %qT verletzt für sich genommen die One-Definition-Rule von C++

en: type %qT of template argument %qE depends on a template parameter | type %qT of template argument %qE depends on template parameters
de[0]: Typ %qT des Templatearguments %qE hängt von Templateparameter ab
de[1]: Typ %qT des Templatearguments %qE hängt von Templateparametern ab

en: type %qT should match type %qT
de: Typ %qT sollte Typ %qT entsprechen

en: type %qT violates the C++ One Definition Rule
de: Typ %qT verletzt die One-Definition-Rule von C++

en: type %qT with no linkage used to declare function %q#D with linkage
de: Typ %qT ohne Bindung für Funktionsdeklaration %q#D mit Bindung deklariert

en: type %qT with no linkage used to declare variable %q#D with linkage
de: Typ %qT ohne Bindung verwendet, um Variable %q#D mit Bindung zu deklarieren

en: type %qs does not conform to the %qE protocol
de: Typ %qs entspricht nicht dem Protokoll %qE

en: type %qs is not an expression
de: Typ %qs ist kein Ausdruck

en: type %qs violates the C++ One Definition Rule
de: Typ %qs verletzt die One-Definition-Rule von C++

en: type assertion only valid for interface types
de: Typbehauptung nur gültig für Schnittstellentypen

en: type attributes ignored after type is already defined
de: Typattribute ignoriert, nachdem Typ bereits definiert ist

en: type conversion result count mismatch
de: Unpassende Anzahl der Ergebniswerte bei Typumwandlung

en: type defaults to %<int%> in declaration of %qE
de: %<int%> ist Standardtyp in Deklaration von %qE

en: type defaults to %<int%> in type name
de: %<int%> ist Standardtyp in Typ-Deklaration

en: type has no methods
de: Typ hat keine Methoden

en: type is deprecated
de: Typ ist veraltet

en: type is deprecated: %s
de: Typ ist veraltet: %s

en: type is not compatible with its variant
de: Interner Compilerfehler: type is not compatible with its variant

en: type is unavailable
de: Typ ist nicht verfügbar

en: type is unavailable: %s
de: Typ ist nicht verfügbar: %s

en: type mismatch for case label in switch statement
de: unpassender Typ für »case«-Marke in switch-Anweisung

en: type mismatch in %qs
de: unverträgliche Typen in %qs

en: type mismatch in %qs expression
de: Typunverträglichkeit in %qs-Ausdruck

en: type mismatch in %qs reference
de: Typunverträglichkeit in %qs-Verweis

en: type mismatch in binary expression
de: Typ passt nicht in binärem Ausdruck

en: type mismatch in conditional expression
de: Typ passt nicht in bedingtem Ausdruck

en: type mismatch in parameter %i
de: unverträgliche Typen in Parameter %i

en: type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>
de: Typ muss cv-qualifizierter %<auto%> oder Referenz auf cv-qualifizierten %<auto%> sein

en: type name %qs should match type name %qs
de: Typname %qs sollte dem Typnamen %qs entsprechen

en: type name declared as function returning a function
de: Typname als Funktion, die eine Funktion zurückgibt, deklariert

en: type name declared as function returning an array
de: Typname als Funktion, die ein Array zurückgibt, deklariert

en: type of %<asm%> operand %qE could not be determined
de: Typ des %<asm%>-Operanden %qE konnte nicht ermittelt werden

en: type of %<depobj%> expression is not %<omp_depend_t%>
de: Typ des %<depobj%>-Ausdrucks ist nicht %<omp_depend_t%>

en: type of %qD defaults to %<int%>
de: Typ von %qD ist auf %<int%> voreingestellt

en: type of %qD does not match original declaration
de: Typ von %qD passt nicht zur ursprünglichen Deklaration

en: type of %qE is unknown
de: Typ von %qE ist unbekannt

en: type of array %q+D completed incompatibly with implicit initialization
de: Typ des Arrays %q+D vervollständigt Unverträglichkeit mit impliziter Initialisierung

en: type of bit-field %qs is a GCC extension
de: Typ des Bitfeldes %qs ist eine Erweiterung des GCC

en: type of formal parameter %d is incomplete
de: Typ des formalen Parameters %d ist unvollständig

en: type of iterator %qD refers to outer iterator %qD
de: Typ des Iterators %qD verweist auf äußeren Iterator %qD

en: type of property %qD conflicts with previous declaration
de: Typ der Eigenschaft %qD in Konflikt mit vorheriger Deklaration

en: type precision mismatch in switch statement
de: unpassende Präzision für Typ in switch-Anweisung

en: type punning toggles scalar storage order
de: Typumgehung schaltet die Reihenfolge der Skalarspeicherung um

en: type qualifiers ignored on cast result type
de: Typkennzeichner an Umwandlungs-Rückgabetyp ignoriert

en: type qualifiers ignored on function return type
de: Typkennzeichner an Funktions-Rückgabewert ignoriert

en: type to vector delete is neither pointer or array type
de: Typ für Vektor-»delete« ist weder Zeiger- noch Arraytyp

en: type transparent %q#T cannot be made transparent because the type of the first field has a different ABI from the class overall
de: typtransparentes %q#T kann nicht transparent gemacht werden, weil der Typ des ersten Feldes anderes ABI als gesamte Klasse hat

en: type transparent %q#T does not have any fields
de: typtransparentes %q#T hat keine Felder

en: type transparent class %qT has base classes
de: typtransparente Klasse %qT hat Basisklassen

en: type transparent class %qT has virtual functions
de: typtransparente Klasse %qT hat virtuelle Funktionen

en: type variant differs by %s
de: Interner Compilerfehler: type variant differs by %s

en: type variant has different %<TREE_TYPE%>
de: Interner Compilerfehler: type variant has different %<TREE_TYPE%>

en: type variant has different %<TYPE_BINFO%>
de: Interner Compilerfehler: type variant has different %<TYPE_BINFO%>

en: type variant has different %<TYPE_FIELDS%>
de: Interner Compilerfehler: type variant has different %<TYPE_FIELDS%>

en: type variant has different %<TYPE_SIZE_UNIT%>
de: Interner Compilerfehler: type variant has different %<TYPE_SIZE_UNIT%>

en: type variant has different %<TYPE_VFIELD%>
de: Interner Compilerfehler: type variant has different %<TYPE_VFIELD%>

en: type variant with %<TYPE_ALIAS_SET_KNOWN_P%>
de: Interner Compilerfehler: type variant with %<TYPE_ALIAS_SET_KNOWN_P%>

en: type variant%'s %<TREE_TYPE%>
de: Interner Compilerfehler: type variant%'s %<TREE_TYPE%>

en: type variant%'s %<TYPE_BINFO%>
de: Interner Compilerfehler: type variant%'s %<TYPE_BINFO%>

en: type variant%'s %<TYPE_SIZE_UNIT%>
de: Interner Compilerfehler: type variant%'s %<TYPE_SIZE_UNIT%>

en: type was previously declared %qE
de: Typ war vorher als %qE deklariert

en: type%'s %<TREE_TYPE%>
de: Interner Compilerfehler: type%'s %<TREE_TYPE%>

en: type%'s %<TYPE_BINFO%>
de: Interner Compilerfehler: type%'s %<TYPE_BINFO%>

en: type%'s %<TYPE_SIZE_UNIT%>
de: Interner Compilerfehler: type%'s %<TYPE_SIZE_UNIT%>

en: type-punning to incomplete type might break strict-aliasing rules
de: Type-Punning auf unvollständigen Typen kann strict-aliasing-Regeln verletzen

en: type-specifier invalid in lambda
de: type-specifier ist in Lambda ungültig

en: type/value mismatch at argument %d in template parameter list for %qD
de: Typ/Wert des Arguments %d passt nicht in Template-Parameterliste für %qD

en: typedef %q+D declared %<_Noreturn%>
de: typedef %q+D als %<_Noreturn%> deklariert

en: typedef %q+D declared %<inline%>
de: typedef %q+D als %<inline%> deklariert

en: typedef %qD is initialized (use %<__typeof__%> instead)
de: typedef %qD ist initialisiert (verwenden Sie stattdessen lieber %<__typeof__%>)

en: typedef %qD is initialized (use %qs instead)
de: typedef %qD ist initialisiert (stattdessen %qs verwenden)

en: typedef %qD locally defined but not used
de: typedef %qD lokal definiert, aber nicht verwendet

en: typedef declaration invalid in parameter declaration
de: »typedef«-Deklaration in Parameterdeklaration ungültig

en: typedef declared %<auto%>
de: »typedef« als %<auto%> deklariert

en: typedef may not be a function definition
de: mit %<typedef%> definierte Funktion darf keinen Rumpf %<{ … }%> haben

en: typedef may not be a member function definition
de: mit %<typedef%> definierte Elementfunktion darf keinen Rumpf %<{ … }%> haben

en: typedef name may not be a nested-name-specifier
de: typedef-Name darf kein Spezifizierer mit geschachteltem Namen sein

en: typedef-name %qD used as destructor declarator
de: typedef-Name %qD als Destruktor-Deklarator verwendet

en: types are not quite compatible
de: Typen nicht ganz kompatibel

en: types differ in signedness
de: Typen unterscheiden sich im Vorzeichenbesitz

en: types have different parameter counts
de: Typen haben unterschiedliche Anzahl von Parametern

en: types may not be defined in %<decltype%> expressions
de: Typen dürfen nicht in %<decltype%>-Ausdrücken definiert werden

en: types may not be defined in %<noexcept%> expressions
de: Typen dürfen nicht in %<noexcept%>-Ausdrücken definiert werden

en: types may not be defined in %qs expressions
de: Typen dürfen nicht in einem %qs-Ausdruck definiert werden

en: types may not be defined in a %<typeid%> expression
de: Typen dürfen nicht in einem %<typeid%>-Ausdruck definiert werden

en: types may not be defined in a conversion-type-id
de: Typen dürfen nicht in einem »conversion-type-id« definiert werden

en: types may not be defined in a for-range-declaration
de: in einer for-Bereichs-Deklaration dürfen keine Typen definiert werden

en: types may not be defined in a new-expression
de: Typen dürfen nicht in einem »new«-Ausdruck definiert werden

en: types may not be defined in a new-type-id
de: Typen dürfen nicht in einem »new-type-id« definiert werden

en: types may not be defined in alias template declarations
de: Typen dürfen nicht in Alias-Templatedeklarationen definiert werden

en: types may not be defined in an exception-specification
de: Typen dürfen nicht in einer Ausnahmespezifikation definiert werden

en: types may not be defined in casts
de: Typen dürfen nicht in Typumwandlungen definiert werden

en: types may not be defined in conditions
de: Typen dürfen nicht in Bedingungen definiert werden

en: types may not be defined in declare reduction type list
de: neue Typen dürfen nicht in einem Rückgabetyp definiert werden

en: types may not be defined in enum-base
de: Typen dürfen nicht in enum-base definiert werden

en: types may not be defined in exception-declarations
de: Typen dürfen nicht in Ausnahmedeklarationen definiert werden

en: types may not be defined in explicit-specifier
de: Typen dürfen nicht in explicit-specifier definiert werden

en: types may not be defined in iterator type
de: Typen dürfen nicht in Iteratortyp definiert werden

en: types may not be defined in parameter types
de: Typen dürfen nicht in Parametertypen definiert werden

en: types may not be defined in template arguments
de: in Template-Argumenten dürfen keine Typen definiert werden

en: types may not be defined within %<__builtin_offsetof%>
de: Typen dürfen nicht innerhalb von %<__builtin_offsetof%> definiert werden

en: typespec in ALLOCATE at %L
de: Typspezifikation in ALLOCATE bei %L

en: unable to compute real location of stacked parameter
de: Wirkliche Stelle des gestapelten Parameters kann nicht berechnet werden

en: unable to deduce %qT from %qE
de: %qT kann nicht aus %qE hergeleitet werden

en: unable to deduce lambda return type from %qE
de: Lambda-Rückgabewert von %qE kann nicht hergeleitet werden

en: unable to emulate %qs
de: %qs kann nicht emuliert werden

en: unable to find a register to spill
de: Kein Register zum Auslagern gefunden

en: unable to find a register to spill in class %qs
de: in Klasse %qs konnte kein Register für Überlauf gefunden werden

en: unable to find character literal operator %qD with %qT argument
de: Operator %qD für Zeichenliterale mit Argument %qT kann nicht gefunden werden

en: unable to find numeric literal operator %qD
de: numerischer literaler Operator %qD konnte nicht gefunden werden

en: unable to find string literal operator %qD with %qT, %qT arguments
de: literaler Operator für Zeichenketten %qD mit Argumenten %qT, %qT konnte nicht gefunden werden

en: unable to find the promise type for this coroutine
de: der Versprechens-Typ für diese Koroutine wurde nicht gefunden

en: unable to generate reloads for impossible constraints:
de: Neuladungen für unmögliche Einschränkungen konnten nicht generiert werden:

en: unable to generate reloads for:
de: Neuladungen konnten nicht generiert werden für:

en: unable to implement ABI %qs with instruction set %qs
de: ABI %qs kann nicht mit Befehlssatz %qs implementiert werden

en: unable to locate default linker script %qs in the library search paths
de: Standard-Linkerscript %qs kann nicht in den Bibliotheks-Suchpfaden gefunden werden

en: unable to open dynamic dependency %qs
de: dynamische Abhängigkeit %qs kann nicht geöffnet werden

en: unable to open file
de: Datei kann nicht geöffnet werden

en: unable to open log file %<vtv_class_set_sizes.log%>: %m
de: Logdatei %<vtv_class_set_sizes.log%> kann nicht geöffnet werden: %m

en: unable to open log file %<vtv_count_data.log%>: %m
de: Logdatei %<vtv_count_data.log%> kann nicht geöffnet werden: %m

en: unable to open log file %<vtv_set_ptr_data.log%>: %m
de: Logdatei %<vtv_set_ptr_data.log%> kann nicht geöffnet werden: %m

en: unable to print out operand yet; code == %d (%c)
de: Operand kann noch nicht ausgegeben werden; Code == %d (%c)

en: unable to register info for plugin %qs - plugin name not found
de: Informationen für Plugin %qs können nicht registriert werden: Pluginname nicht gefunden

en: unable to represent further imported source locations
de: weitere importierte Quellencodestellen können nicht dargestellt werden

en: unable to resolve forward reference in definition
de: die Vorwärtsreferenz in der Definition kann nicht aufgelöst werden

en: unable to use %qs for PIC register
de: %qs kann nicht als PIC-Register verwendet werden

en: unbalanced punctuation character %<%c%> in format
de: unausgeglichenes Satzzeichen %<%c%> im Format

en: unbalanced punctuation character %qc in format
de: unausgeglichenes Satzzeichen %qc im Format

en: unbounded use of %<alloca%>
de: unbegrenzte Verwendung von %<alloca%>

en: unbounded use of variable-length array
de: unbegrenzte Verwendung von Array mit variabler Länge

en: unconditional %2d never executed
de: unbedingtes %2d niemals ausgeführt

en: unconditional %2d taken %s
de: unbedingtes %2d, genommen: %s

en: undeclared selector %qE
de: nicht deklarierter Selektor %qE

en: undefined behavior when second parameter of %<va_start%> is declared with %<register%> storage
de: undefiniertes Verhalten, wenn zweiter Parameter von %<va_start%> mit %<register%>-Speicherklasse deklariert wird

en: undefined named operand %qs
de: benannter Operand %qs ist nicht definiert

en: underlying type %qT of %qT must be an integral type
de: zugrunde liegender Typ %qT von %qT muss ein ganzzahliger Typ sein

en: underlying type mismatch in enum %q#T
de: falsche Zuordnung des zugrunde liegenden Typs in enum %q#T

en: unexpanded parameter pack in enumerator in lambda
de: unexpandierte Parameterpackunge in Aufzählungskonstante in Lambda

en: unexpanded parameter pack in local class in lambda
de: unexpandiertes Parameterpack in lokaler Klasse in Lambda

en: unexpected !$OMP ATOMIC expression at %L
de: Unerwarteter »!$OMP ATOMIC«Ausdruck bei %L

en: unexpected %<%s%> after %<%s%>
de: unerwartetes %<%s%> nach %<%s%>

en: unexpected %<else%>
de: unerwartetes %<else%> gefunden

en: unexpected AST of kind %s
de: unerwarteter AST der Art %s

en: unexpected EOF
de: Unerwartetes Dateiende

en: unexpected RHS for assignment
de: unerwartete rechte Seite in Zuweisung

en: unexpected argument
de: unerwartetes Argument

en: unexpected argument to %<msp430_select_hwmult_lib%>: %s
de: unerwartetes Argument für %<msp430_select_hwmult_lib%>: %s

en: unexpected attribute
de: unerwartetes Attribut

en: unexpected base-type in cris_print_base
de: unerwarteter Basistyp in cris_print_base

en: unexpected encapsulation format or type
de: unerwartete Angaben im ELF-Header

en: unexpected error opening %<devices.csv%>
de: unerwarteter Fehler beim Öffnen von %<devices.csv%>

en: unexpected file name %s in linker resolution file. Expected %s
de: unerwarteter Dateiname %s in Linker-Auflösungsdatei. %s erwartet

en: unexpected first argument to %<msp430_select_hwmult_lib%>: %s
de: unerwartetes erstes Argument für %<msp430_select_hwmult_lib%>: %s

en: unexpected index-type in cris_print_index
de: unerwarteter Indextyp in cris_print_index

en: unexpected keyword; remove space between quotes and suffix identifier
de: unerwartetes Schlüsselwort; entfernen Sie Leerzeichen zwischen Anführungszeichen und Suffixbezeichner

en: unexpected multiplicative operand
de: unerwarteter multiplikativer Operand

en: unexpected offset
de: unerwarteter Offset

en: unexpected operand
de: unerwarteter Operand

en: unexpected operand: %d
de: unerwarteter Operand: %d

en: unexpected placeholder in constrained result type
de: unerwarteter Platzhalter in eingeschränktem Ergebnistyp

en: unexpected side-effects in address
de: unerwartete Seiteneffekte in Adresse

en: unexpected template-id %qE
de: unerwartete Template-ID %qE

en: unexpected text address:
de: unerwartete Textadresse:

en: unexpected type for array length: %qs
de: unerwarteter Typ für Array-Länge: %qs

en: unhandled alignment for %<#pragma nomember_alignment%>
de: unbehandelte Ausrichtung für %<#pragma nomember_alignment%>

en: unhandled arguments %qs and %qs to %<msp430_set_driver_var%>
de: unbehandelte Argumente %qs und %qs für %<msp430_set_driver_var%>

en: unhandled expression
de: unbehandelter Ausdruck

en: unhandled expression type
de: unbehandelter Ausdruckstyp

en: uninitialized %<const %D%>
de: nicht initialisiertes %<const %D%>

en: uninitialized %<const %D%> is invalid in C++
de: nicht initialisiertes %<const %qD%> ist in C++ ungültig

en: uninitialized const in %<new%> of %q#T
de: nicht initialisierte Konstante in %<new%> von %q#T

en: uninitialized const member in %q#T
de: nicht initialisiertes konstantes Element in %q#T

en: uninitialized const member in %q#T using %<new%> without new-initializer
de: nicht initialisiertes konstantes Element in %q#T verwendet %<new%> ohne new-Initialisierung

en: uninitialized const member in %qT is invalid in C++
de: nicht initialisiertes konstantes Element %qT ist in C++ ungültig

en: uninitialized const member in base %q#T of %q#T
de: nicht initialisiertes konstantes Element in Basis %q#T von %q#T

en: uninitialized const member in base %q#T of %q#T using %<new%> without new-initializer
de: nicht initialisiertes konstantes Element in Basis %q#T von %q#T verwendet %<new%> ohne new-Initialisierung

en: uninitialized reference member in %q#T
de: nicht initialisiertes Referenzelement in %q#T

en: uninitialized reference member in %q#T using %<new%> without new-initializer
de: nicht initialisiertes Referenzelement in %q#T verwendet %<new%> ohne new-Initialisierung

en: uninitialized reference member in base %q#T of %q#T
de: nicht initialisiertes Referenzelement in Basis %q#T von %q#T

en: uninitialized reference member in base %q#T of %q#T using %<new%> without new-initializer
de: nicht initialisiertes Referenzelement in Basis %q#T von %q#T verwendet %<new%> ohne new-Initialisierung

en: uninitialized variable %q+D put into program memory area
de: nicht initialisierte Variable %q+D in Programmspeicherbereich platziert

en: uninitialized variable %qD in %<constexpr%> context
de: uninitialisierte Variable %qD in %<constexpr%>-Kontext

en: uninitialized variable %qD in %<constexpr%> function
de: uninitialisierte Variable %qD in %<constexpr%>-Funktion

en: union cannot be made transparent
de: union kann nicht transparent gemacht werden

en: union defined here
de: »union« wurde hier definiert

en: union has no members
de: Union hat keine Elemente

en: union has no named members
de: Union hat keine benannten Elemente

en: union member %q+D with non-trivial %qD
de: Union-Element %q+D mit nichttrivialem %qD

en: unknown %<#pragma GCC aarch64%> option %qs
de: unbekannte Option %qs für %<#pragma GCC aarch64%>

en: unknown %<#pragma GCC arm%> option %qs
de: unbekannte Option %qs für %<#pragma GCC arm%>

en: unknown %<#pragma extern_model%> model %qs
de: unbekanntes Modell %qs für %<#pragma extern_model%>

en: unknown %<#pragma member_alignment%> name %s
de: unbekannter Name %qs für %<#pragma member_alignment%>

en: unknown %<-mdebug-%s%> switch
de: unbekannter Schalter %<-mdebug-%s%>

en: unknown %<asm%> flag output %qs
de: unbekannte Ausgabe %qs des %<asm%>-Schalters

en: unknown C++ standard %qs
de: unbekannter C++-Standard %qs

en: unknown CRIS cpu version specification in %<-mtune=%>: %s
de: unbekannte CRIS-CPU-Versionsangabe in %<-mtune=%>: %s

en: unknown CRIS version specification in %<-march=%> or %<-mcpu=%>: %s
de: unbekannte CRIS-Versionsangabe in %<-march=%> oder %<-mcpu=%>: %s

en: unknown Compiled Module Interface: %s
de: unbekannte Schnittstelle des compilierten Moduls (CMI): %s

en: unknown Control-Flow Protection Level %qs
de: Unbekannte Schutzstufe %qs für Kontrollfluss

en: unknown FPU type %<0x%x%>, %qs failed
de: unbekannter FPU-Typ %<0x%x%>, %qs fehlgeschlagen

en: unknown IRA algorithm %qs
de: unbekannter IRA-Algorithmus %qs

en: unknown IRA region %qs
de: unbekannte IRA-Region %qs

en: unknown LTO partitioning model %qs
de: Unbekanntes LTO-Partitionierungs-Modell %qs

en: unknown Live-Patching Level %qs
de: unbekannte Stufe %qs für Live-Patching

en: unknown OpenMP directive name in %<omp::directive%> attribute argument
de: unbekannter OpenMP-Direktiven-Name im Argument des Attributs %<omp::directive%>

en: unknown Stack Reuse Level %qs
de: Unbekannte Stufe %qs für Stapel-Wiederverwendung

en: unknown TLS model %qs
de: unbekanntes TLS-Modell %qs

en: unknown action %qE for %<#pragma pack%> - ignored
de: unbekannte Aktion %qE für %<#pragma pack%> - ignoriert

en: unknown alignment %qs specified for option %qs
de: unbekannte Ausrichtung %qs für Option %qs angegeben

en: unknown architecture specific memory model
de: Unbekanntes architekturspezifisches Speichermodell

en: unknown architecture specifier in memory model %wi for %qD
de: Unbekannte Architekturspezifikation in Speichermodell %wi für %qD

en: unknown array bounds setting %qs
de: unbekannte Einstellung %qs für Arraygrenzen

en: unknown array size in delete
de: unbekannte Arraygröße in »delete«

en: unknown attribute %qE
de: unbekanntes Attribut %qE

en: unknown attribute %qs
de: unbekanntes Attribut %qs

en: unknown base architecture %<0x%x%>, %qs failed
de: unbekannte Basisarchitektur %<0x%x%>, %qs fehlgeschlagen

en: unknown basic block reordering algorithm %qs
de: unbekannter Basisblock-Umsortierungs-Algorithmus %qs

en: unknown block specifier
de: Interner Fehler: unknown block specifier

en: unknown builtin immediate operand type for operand %d
de: unbekannter eingebauter direkter Operandentyp für Operand %d

en: unknown callback event registered by plugin %s
de: unbekanntes Callback-Ereignis von Plugin %s registriert

en: unknown checkaction setting %qs
de: unbekannte Einstellung %qs für Prüfaktion

en: unknown conversion type character %qc in format
de: unbekanntes Konvertierungstyp-Zeichen %qc im Format

en: unknown core architecture %qs specified with %qs
de: Unbekannte Kernarchitektur %qs in %qs angegeben

en: unknown cpu %qs for %<-mtune%>
de: unbekannte CPU %qs für %<-mtune%>

en: unknown demangling style %qs
de: unbekannter Entmangelstil %qs

en: unknown dest
de: unbekanntes Ziel

en: unknown error reading %s from %<devices.csv%>
de: unbekannter Fehler beim Lesen von %s aus %<devices.csv%>

en: unknown evrp mode %qs
de: unbekannter evrp-Modus %qs

en: unknown excess precision style %qs
de: unbekannte Art überschüssiger Genauigkeit %qs

en: unknown flag passed in %<-moverride=%s%> (%s)
de: unbekanntes Flag wurde in %<-moverride=%s%> übergeben (%s)

en: unknown floating point contraction style %qs
de: unbekannte Art der Gleitkomma-Kürzung %qs

en: unknown header kind %qs
de: unbekannte Header-Art %qs

en: unknown insn mode
de: unbekannter Befehlsmodus

en: unknown internal function %qE
de: Interner Fehler: unknown internal function %qE

en: unknown linker output %qs
de: unbekannte Linkerausgabe %qs

en: unknown machine mode %qE
de: Unbekannter Maschinenzustand %qE

en: unknown move insn:
de: Falscher Kopierbefehl:

en: unknown offload ABI %qs
de: Unbekannte Offload-ABI %qs

en: unknown operand letter: '%c'
de: unbekannter Operandenbuchstabe: »%c«

en: unknown operator %qs in %%:version-compare
de: unbekannter Operator %qs in %%:version-compare

en: unknown option %q.*s in %<-fopt-info-%s%>
de: unbekannte Option %q.*s in %<-fopt-info-%s%>

en: unknown option after %<#pragma GCC diagnostic%> kind
de: Option hinter %<#pragma GCC diagnostic%> Art unbekannt

en: unknown option for %<%s=%s%>
de: unbekannte Option für %<%s=%s%>

en: unknown option for %<-mrecip=%s%>
de: unbekannte Option für %<-mrecip=%s%>

en: unknown parameter to option %<-mtune-ctrl%>: %s
de: Unbekannter Parameter für Option %<-mtune-ctrl%>: %s

en: unknown pass %s specified in %<-fdisable%>
de: unbekannter Durchlauf %s in %<-fdisable%> angegeben

en: unknown pass %s specified in %<-fenable%>
de: unbekannter Durchlauf %s in %<-fenable%> angegeben

en: unknown pointer size model %qs
de: unbekanntes Zeigergrößenmodell %qs

en: unknown processor ID %<0x%x%>, some tuning parameters will fall back to default
de: unbekannte Prozessor-ID %<0x%x%>, einige Tuning-Parameter werden auf die Standardwerte zurückgesetzt

en: unknown profile quality
de: Unbekannte Profil-Qualität

en: unknown profile reproducibility method %qs
de: Unbekannte Profil-Reproduzierbarkeitsstufe %qs

en: unknown profile update method %qs
de: Unbekannte Profil-Aktualisierungs-Methode %qs

en: unknown property %qE of %qs selector
de: unbekannte Eigenschaft %qE des %qs-Selektors

en: unknown property %qs of %qs selector
de: unbekannte Eigenschaft %qs des %qs-Selektors

en: unknown property attribute
de: unbekanntes Eigenschaftsattribut

en: unknown property attribute %<%s%s%>
de: unbekanntes Eigenschaftsattribut %<%s%s%>

en: unknown property attribute %qE
de: unbekanntes Eigenschaftsattribut %qE

en: unknown punctuation '%c'
de: unbekanntes Zeichen »%c«

en: unknown ranger debug mode %qs
de: unbekannter Ranger-Debug-Modus %qs

en: unknown register name %qs in %<asm%>
de: unbekannter Registername %qs in %<asm%>

en: unknown register name: %s
de: unbekannter Registername: %s

en: unknown relocation unspec
de: unbekannte Adressverschiebungs-Unspec

en: unknown spec function %qs
de: unbekannte Spezifikationsfunktion %qs

en: unknown specification for the set of FLT_EVAL_METHOD values to permit %qs
de: unbekannte Spezifikation für die Menge der FLT_EVAL_METHOD-Werte, um %qs zu erlauben

en: unknown specifier %qs in %<amdgpu_hsa_kernel%> attribute
de: unbekannte Angabe %<%qs%> in Attribut %<amdgpu_hsa_kernel%>

en: unknown src
de: unbekannte Quelle

en: unknown stack check parameter %qs
de: unbekannter Stapel-Überprüfungsparameter %qs

en: unknown switch %<-mlong-double-%s%>
de: unbekannter Schalter %<-mlong-double-%s%>

en: unknown target attribute or pragma %qs
de: Unbekanntes Zielattribut oder -pragma %qs

en: unknown threader debug mode %qs
de: unbekannter Threader-Debug-Modus %qs

en: unknown tuning option (%s)
de: unbekannte Tuning-Option »%s«

en: unknown type %<%T%> found during Objective-C encoding
de: unbekannter Typ %<%T%> bei Objective-C-Kodierung gefunden

en: unknown type name %qE
de: unbekannter Typname: %qE

en: unknown type name %qE; did you mean %qs?
de: Unbekannter Typname %qE; meinten Sie %qs?

en: unknown type name %qE; use %<enum%> keyword to refer to the type
de: unbekannter Typname %qE; verwenden Sie das %<enum%>-Schlüsselwort, um auf den Typ zu verweisen

en: unknown type name %qE; use %<struct%> keyword to refer to the type
de: unbekannter Typname %qE; verwenden Sie das %<struct%>-Schlüsselwort, um auf den Typ zu verweisen

en: unknown type name %qE; use %<union%> keyword to refer to the type
de: unbekannter Typname %qE; verwenden Sie das %<union%>-Schlüsselwort, um auf den Typ zu verweisen

en: unknown value %qs for %<-march%>
de: unbekannter Wert %qs für %<-march%>

en: unknown value %qs for %<-mcpu%>
de: unbekannter Wert %qs für %<-mcpu%>

en: unknown value %qs for %<-mtune%>
de: unbekannter Wert %qs für %<-mtune%>

en: unknown value %qs of %<-mmacosx-version-min%>
de: unbekannter Wert %qs von %<-mmacosx-version-min%>

en: unknown vectorization library ABI type in %<-mveclibabi=%s%>
de: unbekannter ABI-Typ für Vektorisierungsbibliothek in %<-mveclibabi=%s%>

en: unknown vectorizer cost model %qs
de: unbekanntes Vektorisierer-Kostenmodell %qs

en: unknown vrp mode %qs
de: unbekannter vrp-Modus %qs

en: unknown vtable verify initialization priority %qs
de: unbekannte Initialisierungspriorität %qs für VTable-Verifikation

en: unmatched color reset directive
de: Alleinstehende Farbrücksetz-Direktive

en: unmatched quoting directive
de: Alleinstehende q-Direktive

en: unnamed class defined here
de: unbenannte Klasse wurde hier definiert

en: unnamed field has incomplete type
de: unbenanntes Feld hat unvollständigen Typen

en: unnamed field is neither function nor member function; cannot be declared friend
de: unbenanntes Feld ist weder eine Funktion noch Elementfunktion; kann nicht als %<friend%> deklariert werden

en: unnamed initializer for %qT, which has no base classes
de: unbenannte Initialisierung für %qT, das keine Basisklassen hat

en: unnamed initializer for %qT, which uses multiple inheritance
de: unbenannte Initialisierung für %qT, das Mehrfachvererbung verwendet

en: unnamed scoped enum is not allowed
de: unbenanntes »enum« mit Gültigkeitsbereich ist nicht erlaubt

en: unnamed struct/union that defines no instances
de: Unbenannte struct/union, die keine Instanzen definiert

en: unnamed temporary defined here
de: unbenanntes temporäres Objekt wird hier definiert

en: unnamed type with no linkage used to declare function %q#D with linkage
de: unbenannter Typ ohne Bindung wird verwendet, um Funktion %q#D mit Bindung zu deklarieren

en: unnamed type with no linkage used to declare variable %q#D with linkage
de: unbenannter Typ ohne Bindung wird verwendet, um Variable %q#D mit Bindung zu deklarieren

en: unnamed variable or field declared void
de: unbenannte Variable oder Feld als »void« deklariert

en: unnecessary parentheses in declaration of %qs
de: unnötige Klammern in Deklaration von %qs

en: unordered comparison on non-floating-point argument
de: ungeordneter Vergleich mit Nicht-Gleitkomma-Argument

en: unquoted attribute in format
de: Attribut außerhalb von Anführungszeichen im Format

en: unquoted control character %qc in format
de: Steuerzeichen %qc außerhalb von Anführungszeichen im Format

en: unquoted control characters in format
de: Steuerzeichen außerhalb von Anführungszeichen im Format

en: unquoted identifier or keyword %<%.*s%> in format
de: Bezeichner oder Schlüsselwort außerhalb von Anführungszeichen %<%.*s%> im Format

en: unquoted keyword %<%.*s%> in format
de: Schlüsselwort %<%.*s%> außerhalb von Anführungszeichen im Format

en: unquoted name of built-in function %<%.*s%> in format
de: Name der eingebauten Funktion %<%.*s%> außerhalb von Anführungszeichen im Format

en: unquoted non-graph character %qc in format
de: nicht-grafisches Zeichen %qc außerhalb von Anführungszeichen im Format

en: unquoted non-graph characters in format
de: nicht-grafische Zeichen außerhalb von Anführungszeichen im Format

en: unquoted operator %<%.*s%> in format
de: Operator %<%.*s%> außerhalb von Anführungszeichen im Format

en: unquoted option name %<%.*s%> in format
de: Optionsname %<%.*s%> außerhalb von Anführungszeichen im Format

en: unquoted preprocessing directive %<%.*s%> in format
de: Vorverarbeitungsdirektive %<%.*s%> außerhalb von Anführungszeichen im Format

en: unquoted sequence of %i consecutive punctuation characters %q.*s in format
de: Folge von %i aufeinanderfolgenden Satzzeichen %q.*s außerhalb von Anführungszeichen im Format

en: unquoted sequence of %i consecutive space characters in format
de: %i aufeinanderfolgende Leerzeichen außerhalb von Anführungszeichen im Format

en: unquoted type name %<%.*s%> in format
de: Typname %<%.*s%> außerhalb von Anführungszeichen im Format

en: unquoted whitespace character %qc in format
de: Leerzeichen %qc außerhalb von Anführungszeichen im Format

en: unreachable
de: Nicht erreichbar

en: unrecognizable argument of option
de: nicht erkanntes Kommandozeilenargument von Option

en: unrecognizable insn:
de: unerkennbarer Befehl:

en: unrecognized %<-mfpu%> target: %s
de: unbekanntes Ziel für %<-mfpu%>: %s

en: unrecognized %<hwmpy%> field in %<hard_msp430_mcu_data[%d]%>: %qd
de: unbekanntes Feld %<hwmpy%> in %<hard_msp430_mcu_data[%d]%>: %qd

en: unrecognized %<include_flags 0x%x%> passed to %<print_specific_help%>
de: nicht erkanntes %<include_flags 0x%x%> an %<print_specific_help%> weitergegeben

en: unrecognized %<revision%> field in %<hard_msp430_mcu_data[%d]%>: %qd
de: unbekanntes Feld %<revision%> in %<hard_msp430_mcu_data[%d]%>: %qd

en: unrecognized %qE attribute argument %qs
de: Attribut %qE hat unbekanntes Argument %qs

en: unrecognized %s target: %s
de: unbekanntes Ziel für %s: %s

en: unrecognized MCU name %qs, assuming that it has no hardware multiply; use the %<-mhwmult%> option to set this explicitly
de: unbekannter MCU-Name %qs, daher wird angenommen, dass er keine Hardware-Multiplikation kann; verwenden Sie die Option %<-mhwmult%>, um diese explizit einzustellen

en: unrecognized MCU name %qs, assuming that it is just a MSP430X with no hardware multiply; use the %<-mcpu%> and %<-mhwmult%> options to set these explicitly
de: unbekannter MCU-Name %qs, daher wird angenommen, dass es ein MSP430X ohne Hardware-Multiplikation ist; verwenden Sie die Optionen %<-mcpu%> und %<-mhwmult%>, um diese explizit einzustellen

en: unrecognized MCU name %qs, assuming that it just supports the MSP430X ISA; use the %<-mcpu%> option to set the ISA explicitly
de: unbekannter MCU-Name %qs, daher wird angenommen, dass er lediglich das MSP430X-ISA unterstützt; verwenden Sie die Option %<-mcpu%>, um dieses explizit einzustellen

en: unrecognized address
de: unerkannte Adresse

en: unrecognized argument in option %qs
de: nicht erkanntes Kommandozeilenargument in Option %qs

en: unrecognized argument to %<--help=%> option: %q.*s
de: Argument %q.*s für Option %<--help=%> nicht erkannt

en: unrecognized argument to %<-f%ssanitize%s=%> option: %q.*s
de: unbekanntes Argument für Option %<-f%ssanitize%s=%>: %q.*s

en: unrecognized argument to %<-f%ssanitize%s=%> option: %q.*s; did you mean %qs?
de: unbekanntes Argument für Option %<-f%ssanitize%s=%>: %q.*s; meinten Sie %qs?

en: unrecognized argument to %<-flto=%> option: %qs
de: Argument %qs für Option %<-flto=%> nicht erkannt

en: unrecognized argument to %<-fzero-call-used-regs=%>: %qs
de: Argument für Option %<-fzero-call-used-regs=%> nicht erkannt: %qs

en: unrecognized automatic variable initialization type %qs
de: nicht erkannter Initialisierungstyp %qs für automatische Variable

en: unrecognized btf debug output level %qs
de: Unbekannte BTF-Debugausgabestufe %qs

en: unrecognized command-line option %<-%s%>
de: unbekannte Kommandozeilenoption %<-%s%>

en: unrecognized command-line option %<-%s%>; did you mean %<-%s%>?
de: unbekannte Kommandozeilenoption %<-%s%>; meinten Sie %<-%s%>?

en: unrecognized command-line option %<-fdump-%s%>
de: nicht erkannte Kommandozeilenoption %<-fdump-%s%>

en: unrecognized command-line option %<-fdump-%s%>; did you mean %<-fdump-%s%>?
de: unbekannte Kommandozeilenoption %<-fdump-%s%>; meinten Sie %<-fdump-%s%>?

en: unrecognized command-line option %<-fopt-info-%s%>
de: nicht erkannte Kommandozeilenoption %<-fopt-info-%s%>

en: unrecognized command-line option %qs
de: nicht erkannte Kommandozeilenoption %qs

en: unrecognized command-line option %qs may have been intended to silence earlier diagnostics
de: Unbekannte Kommandozeilenoption %qs könnte den Zweck haben, bisherige Diagnosemeldungen zu unterdrücken

en: unrecognized control register number: %d - using %<psw%>
de: unbekannte Steuerregisternummer %d; %<psw%> wird verwendet

en: unrecognized debug output level %qs
de: Unbekannte Debugausgabestufe %qs

en: unrecognized edge flag: %qs
de: unbekannter Kantenschalter: %qs

en: unrecognized enum value: %qs
de: unbekannter enum-Wert: %qs

en: unrecognized format specifier
de: unerkannte Formatangabe

en: unrecognized gcc debugging option: %c
de: GCC-Debuggingoption nicht erkannt: %c

en: unrecognized interrupt vector argument of %qE attribute
de: unbekanntes Interrupt-Vektor-Argument für Attribut %qE

en: unrecognized ivar visibility value %qs
de: unbekannter ivar-Sichtbarkeitswert %qs

en: unrecognized operand to %%:%<asm_auto_mfpu%>
de: unbekannter Operand für %%:%<asm_auto_mfpu%>

en: unrecognized operand to %%:%<canon_for_mlib%>
de: unbekannter Operand für %%:%<canon_for_mlib%>

en: unrecognized option %<-fdisable%>
de: unbekannte Option %<-fdisable%>

en: unrecognized option %<-fenable%>
de: unbekannte Option %<-fenable%>

en: unrecognized option passed to %%:%<target_mode_check%>
de: unbekannte Option an %%:%<target_mode_check%> weitergegeben

en: unrecognized register name %qs
de: unbekannter Registername %qs

en: unrecognized scalar storage order value %qs
de: unbekannter Wert %qs für Speicherreihenfolge von Skalaren

en: unrecognized section name %qE
de: nicht erkannter Abschnittsname %qE

en: unrecognized shadow offset %qs
de: unerkannter Schatten-Adressoffset %qs

en: unrecognized string escape
de: unbekanntes Escapezeichen in Zeichenkette

en: unrecognized supposed constant
de: unerkannte vermutete Konstante

en: unrecognized visibility value %qs
de: unbekannter Sichtbarkeitswert %qs

en: unrecoverable error
de: nicht behebbarer Fehler

en: unresolved overloaded builtin
de: unaufgelöste überladene eingebaute Funktion

en: unrestricted unions only available with %<-std=c++11%> or %<-std=gnu++11%>
de: uneingeschränkte »Unions« sind nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: unsafe function call %qD within %<transaction_safe%> function
de: unsicherer Funktionsaufruf %qD innerhalb von %<transaction_safe%>-Funktion

en: unsafe function call %qD within atomic transaction
de: unsicherer Funktionsaufruf %qD innerhalb von atomarer Transaktion

en: unsafe function call %qE within %<transaction_safe%> function
de: unsicherer Funktionsaufruf %qE innerhalb von %<transaction_safe%>-Funktion

en: unsafe function call %qE within atomic transaction
de: unsicherer Funktionsaufruf %qE innerhalb von atomarer Transaktion

en: unsafe indirect function call within %<transaction_safe%> function
de: unsicherer indirekter Funktionsaufruf innerhalb von %<transaction_safe%>-Funktion

en: unsafe indirect function call within atomic transaction
de: unsicherer indirekter Funktionsaufruf innerhalb von atomarer Transaktion

en: unset option %qs is ignored, it is always enabled for %qs CPU
de: nicht gesetzte Option %qs wird ignoriert, für CPU %qs ist sie stets eingeschaltet

en: unsigned conversion from %qT to %qT changes the value of %qE
de: Vorzeichenlose Umwandlung von %qT nach %qT ändert den Wert von %qE

en: unsigned conversion from %qT to %qT changes value from %qE to %qE
de: Vorzeichenlose Umwandlung von %qT nach %qT ändert den Wert von %qE nach %qE

en: unsuffixed floating constant
de: Gleitkommakonstante ohne Suffix

en: unsupported SVE vector size
de: nicht unterstützte SVE-Vektorgröße

en: unsupported argument to %qD
de: nicht unterstütztes Argument für %qD

en: unsupported argument type %qT for simd
de: nicht unterstützter Argumenttyp %qT für SIMD

en: unsupported argument type to builtin function
de: nicht unterstützter Argumenttyp für eingebaute Funktion

en: unsupported code '%c' for fixed-point:
de: Code »%c« für Festkomma nicht unterstützt:

en: unsupported combination: %qs %s
de: nicht unterstützte Kombination: %qs %s

en: unsupported combination: %qs%s %s
de: nicht unterstützte Kombination: %qs%s %s

en: unsupported combination: %s
de: nicht unterstützte Kombination: %s

en: unsupported constant address:
de: nicht unterstützte konstante Adresse:

en: unsupported cpu name returned from kernel for %<-mcpu=native%>: %s
de: der Kernel hat einen nicht unterstützten CPU-Namen für %<-mcpu=native%> zurückgegeben: %s

en: unsupported fixed-point conversion
de: Festkommaumwandlung nicht unterstützt

en: unsupported memory expression:
de: nicht unterstützter Speicherausdruck:

en: unsupported non-standard concatenation of string literals
de: nicht unterstützte Nicht-Standard-Verkettung von Zeichenkettenliteralen

en: unsupported non-standard suffix on floating constant
de: nicht unterstützter Nicht-Standard-Suffix an Gleitkommakonstante

en: unsupported operand
de: nicht unterstützter Operand

en: unsupported operand %s for code '%c'
de: nicht unterstützter Operand %s für Code »%c«

en: unsupported operand for code '%c'
de: Operand für Code »%c« nicht unterstützt

en: unsupported operand size for extended register
de: nicht unterstützte Operandengröße für erweitertes Register

en: unsupported operation or type for vector comparison returning a boolean
de: In booleschem Vektorvergleich ist die Operation oder der Typ nicht unterstützt

en: unsupported return type %qT for %<simd%> functions
de: nicht unterstützter Rückgabetyp %qT für %<simd%>-Funktionen

en: unsupported return type %qT for simd
de: nicht unterstützter Rückgabetyp %qT für SIMD

en: unsupported simdlen %wd
de: nicht unterstützte simdlen %wd

en: unsupported size for integer register
de: nicht unterstützte Größe für Ganzzahlregister

en: unterminated assembly dialect alternative
de: unbeendete Assemblerdialekt-Alternative

en: unterminated color directive
de: unbeendete Farbdirektive

en: unterminated format string
de: unbeendete Formatzeichenkette

en: unterminated quote character %<%c%> in format
de: unbeendetes Anführungszeichen %<%c%> im Format

en: unterminated quoting directive
de: unbeendete q-Direktive

en: unterminated string
de: unbeendete Zeichenkette

en: unused arguments in %<$%>-style format
de: unverwendete Argumente in %<$%>-Stil-Format

en: unused parameter %qD
de: unverwendeter Parameter %qD

en: unused structured binding declaration
de: ungenutzte Deklaration für strukturierte Bindung

en: unused variable %q+D
de: Variable %q+D wird nicht verwendet

en: unused variable %qD
de: Variable %qD wird nicht verwendet

en: unwind tables currently require either a frame pointer or %<-maccumulate-outgoing-args%> for correctness
de: Abwicklungstabellen erfordern derzeit entweder einen Rahmenzeiger oder %<-maccumulate-outgoing-args%> für Korrektheit

en: upper value in case label range exceeds maximum value for type
de: Oberer Wert in case-Marken-Bereich überschreitet den Maximalwert des Typs

en: use %<#include%> instead
de: verwenden Sie stattdessen %<#include%>

en: use %<%T::%D%> instead
de: stattdessen %<%T::%D%> verwenden

en: use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name
de: %<%T::%D%> statt %<%T::%D%> verwenden, um den Konstruktor mit qualifiziertem Namen zu benennen

en: use %<%T::template %D%> to indicate that it is a template
de: %<%T::template %D%> verwenden, um dies als Template zu kennzeichnen

en: use %<&%D[0] %s &%D[0]%> to compare the addresses
de: verwenden Sie %<&%D[0] %s &%D[0]%>, um die Adressen zu vergleichen

en: use %<-Winvalid-pch%> for more information
de: %<-Winvalid-pch%> für weitere Informationen verwenden

en: use %<-faligned-new%> to enable C++17 over-aligned new support
de: verwenden Sie %<-faligned-new%>, um die C++17-Unterstützung für überausgerichtetes New einzuschalten

en: use %<-fext-numeric-literals%> to enable more built-in suffixes
de: verwenden Sie %<-fext-numeric-literals%>, um weitere eingebaute Suffixe einzuschalten

en: use %<-flax-vector-conversions%> to permit conversions between vectors with differing element types or numbers of subparts
de: %<-flax-vector-conversions%> verwenden, um Umwandlung zwischen Vektoren mit unterschiedlichen Elementtypen oder Anzahl der Teile zu erlauben

en: use %<...%> to expand argument pack
de: %<...%> verwenden, um Argumentpack aufzulösen

en: use %<__attribute__ ((vector_size))%> instead
de: verwenden Sie stattdessen %<__attribute__ ((vector_size))%>

en: use %<__builtin_rx_mvtc (0, ... )%> to write arbitrary values to PSW
de: verwenden Sie %<__builtin_rx_mvtc (0, ...)%>, um beliebige Werte in PSW zu schreiben

en: use %<alias %s = %s.%s;%> to introduce base class overload set
de: verwenden Sie %<alias %s = %s.%s;%>, um eine Überladungsmenge der Basisklasse einzuführen

en: use %<auto%> for an abbreviated function template
de: verwenden Sie %<auto%> für ein abgekürztes Funktionstemplate

en: use %<template<>%> for an explicit specialization
de: verwenden Sie %<template<>%> für eine explizite Spezialisierung

en: use %<this->%D%> instead
de: stattdessen %<this->%D%> verwenden

en: use %qD directly instead
de: verwenden Sie stattdessen %qD

en: use %qs instead
de: verwenden Sie stattdessen %qs

en: use a cast to the expected type to disambiguate
de: nutzen Sie einen Cast auf den erwarteten Typen, um die Mehrdeutigkeit aufzulösen

en: use e.g. %<-Wabi=11%> to warn about changes from GCC 7
de: Verwenden Sie zum Beispiel %<-Wabi=11%>, um vor Änderungen von GCC 7 zu warnen

en: use non-reference type %qT to make the copy explicit or %qT to prevent copying
de: verwenden Sie den Nicht-Referenz-Typ %qT, um das Kopieren explizit zu machen, oder %qT um das Kopieren zu sparen

en: use of %<alloca%>
de: Verwendung von %<alloca%>

en: use of %<alloca%> within a loop
de: Verwendung von %<alloca%> innerhalb einer Schleife

en: use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>
de: Verwendung von %<auto%> in Lambda-Parameterdeklaration ist nur mit %<-std=c++14%> oder %<-std=gnu++14%> verfügbar

en: use of %<auto%> in member template conversion operator can never be deduced
de: Verwendung von %<auto%> in Umwandlungsoperator von Elementtemplate kann niemals hergeleitet werden

en: use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>
de: Verwendung von %<auto%> in Parameterdeklaration ist nur mit %<-std=c++14%> oder %<-std=gnu++14%> verfügbar

en: use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>
de: Verwendung von %<auto%> in Parameterdeklaration ist erst mit %<-std=c++20%> oder %<-fconcepts%> verfügbar

en: use of %<complex%> in AltiVec types is invalid
de: Verwendung von %<complex%> in AltiVec-Typen ist ungültig

en: use of %<double%> in AltiVec types is invalid without %qs
de: Verwendung von %<double%> in AltiVec-Typen ist ohne %qs ungültig

en: use of %<long double%> in AltiVec types is invalid
de: Verwendung von %<long double%> in AltiVec-Typen ist ungültig

en: use of %<long long%> in AltiVec types is invalid without %qs
de: Verwendung von %<long long%> in AltiVec-Typen ist ohne %qs ungültig

en: use of %<long%> in AltiVec types is deprecated; use %<int%>
de: Verwendung von %<long%> in AltiVec-Typen ist veraltet; %<int%> verwenden

en: use of %<long%> in AltiVec types is invalid for 64-bit code without %qs
de: Verwendung von %<long%> in AltiVec-Typen ist für 64-Bit-Code ohne %qs ungültig

en: use of %<this%> in a constant expression
de: Verwendung von %<this%> in Konstantenausdruck

en: use of %qD
de: Verwendung von %qD

en: use of %qD before deduction of %<auto%>
de: Verwendung von %qD vor Herleitung von %<auto%>

en: use of %qs
de: Verwendung von %qs

en: use of %qs in template
de: Verwendung von %qs in Template

en: use of %qs length modifier with %qc type character has either no effect or undefined behavior
de: Verwendung des %qs-Längenmodifizierers mit %qc-Typ-Zeichen hat entweder keine Auswirkung oder undefiniertes Verhalten

en: use of %s and %s together in %s format
de: gleichzeitige Verwendung von %s und %s im Format %s

en: use of %s and %s together with %<%%%c%> %s format
de: Verwendung von %s und %s zusammen mit Format %<%%%c%> für %s

en: use of allocated storage after deallocation in a constant expression
de: angeforderter Speicher wird in konstantem Ausdruck verwendet, nachdem er wieder freigegeben wurde

en: use of an operand of type %qT in %<operator++%> is deprecated
de: Verwendung eines Operanden vom Typ %qT in %<operator++%> ist veraltet

en: use of an operand of type %qT in %<operator++%> is forbidden in C++17
de: Verwendung eines Operanden vom Typ %qT in %<operator++%> ist in C++17 verboten

en: use of an operand of type %qT in %<operator--%> is forbidden
de: Verwendung eines Operanden vom Typ %qT in %<operator--%> ist verboten

en: use of boolean types in AltiVec types is invalid
de: Verwendung boolescher Typen in AltiVec-Typen ist ungültig

en: use of built-in parameter pack %qD outside of a template
de: Verwendung von eingebautem Parameterpack %qD außerhalb eines Templates

en: use of built-in trait %qE in function signature; use library traits instead
de: Verwendung der eingebauten Eigenschaft %qE in Funktionssignatur; stattdessen sollten Bibliothekseigenschaften verwendet werden

en: use of class template %qT as expression
de: Verwendung des Klassentemplates %qT als Ausdruck

en: use of decimal floating-point types in AltiVec types is invalid
de: Verwendung dezimaler Gleitkommatypen in AltiVec-Typen ist ungültig

en: use of deleted function %qD
de: gelöschte Funktion %qD wird verwendet

en: use of enum %q#D without previous declaration
de: Verwendung des enum %q#D ohne vorherige Deklaration

en: use of function %qD with unsatisfied constraints
de: Verwendung der Funktion %qD mit nicht erfüllten Einschränkungen

en: use of invalid variable template %qE
de: Verwendung des ungültigen Variablentemplates %qE

en: use of local variable with automatic storage from containing function
de: Verwendung lokaler Variable mit automatischer Speicherklasse aus enthaltender Funktion

en: use of multiversioned function without a default
de: Verwendung einer multiversionierten Funktion ohne Standardargument

en: use of old-style cast to %q#T
de: Verwendung einer Typumwandlung nach %q#T im alten Stil

en: use of parameter from containing function
de: Verwendung eines Parameters aus enthaltender Funktion

en: use of parameter outside function body
de: Verwendung eines Parameters außerhalb des Funktionskörpers

en: use of untyped nil
de: Verwendung von ungetyptem nil

en: use operand missing for statement
de: für die Anweisung fehlt der Verwendungs-Operand

en: use option %<-std=c99%>, %<-std=gnu99%>, %<-std=c11%> or %<-std=gnu11%> to compile your code
de: die Option %<-std=c99%>, %<-std=gnu99%>, %<-std=c11%> oder %<-std=gnu11%> verwenden, um den Code zu übersetzen

en: use reference type to prevent copying
de: verwenden Sie einen Referenztyp, um das Kopieren zu sparen

en: use the apostrophe directive %qs instead
de: verwenden Sie stattdessen die Apostroph-Direktive %qs

en: use unary %<+%> which decays operands to pointers or %<&%D[0] %s &%D[0]%> to compare the addresses
de: verwenden Sie das unäre %<+%>, das Operanden zu Zeigern degradiert, oder %<&%D[0] %s &%D[0]%>, um die Adressen zu vergleichen

en: used array that cannot be converted to pointer where scalar is required
de: Array, das nicht in Zeiger umgewandelt werden kann, anstelle des geforderten Skalars verwendet

en: used as rewritten candidate for comparison of %qT and %qT
de: als umgeschriebener Kandidat für den Vergleich von %qT und %qT verwendet

en: used struct type value where scalar is required
de: Wert eines struct-Typs anstelle des geforderten Skalars verwendet

en: used union type value where scalar is required
de: Wert eines union-Typs anstelle des geforderten Skalars verwendet

en: used vector type where scalar is required
de: Vektortyp verwendet, wo Skalars benötigt wird

en: useless %<_Alignas%> in empty declaration
de: nutzloses %<_Alignas%> in leerer Deklaration

en: useless %qs in empty declaration
de: nutzloses %qs in leerer Deklaration

en: useless cast to type %q#T
de: nutzlose Umwandlung in Typ %q#T

en: useless storage class specifier in empty declaration
de: Nutzlose Speicherklassenangabe in leerer Deklaration

en: useless type name in empty declaration
de: Nutzloser Typname in leerer Deklaration

en: useless type qualifier in empty declaration
de: Nutzloser Typqualifizierer in leerer Deklaration

en: user defined reduction lookup is ambiguous
de: benutzerdefinierte Reduktionsauflösung ist mehrdeutig

en: user defined reduction not found for %qE
de: benutzerdefinierte Reduktion für %qE nicht gefunden

en: user defined reduction with constructor initializer for base class %qT
de: benutzerdefinierte Reduktion mit Konstruktorinitialisierung für Basisklasse %qT

en: user-defined %qD always evaluates both arguments
de: benutzerdefiniertes %qD wertet immer beide Argumente aus

en: user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>
de: benutzerdefinierte Literale nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: uses %qD, which does not have an alignment parameter
de: verwendet %qD, das jedoch keinen Ausrichtungsparameter hat

en: using %<%c%s%>
de: %<%c%s%> wird verwendet

en: using %<num_workers (%d)%>, ignoring %d
de: %<num_workers (%d)%> wird verwendet, %d wird ignoriert

en: using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d
de: %<vector_length (%d)%> wird verwendet, da eine vektor-partitionierbare Routine aufgerufen wird, %d wird ignoriert

en: using %<vector_length (%d)%>, ignoring %d
de: %<vector_length (%d)%> wird verwendet, %d wird ignoriert

en: using %<vector_length (%d)%>, ignoring runtime setting
de: %<vector_length (%d)%> wird verwendet, Laufzeiteinstellung wird ignoriert

en: using %<vector_length (64)%>, ignoring %d
de: %<vector_length (64)%> wird verwendet, %d wird ignoriert

en: using %<vector_length (64)%>, ignoring runtime setting
de: %<vector_length (64)%> wird verwendet, Laufzeiteinstellung wird ignoriert

en: using %qs with unsigned type has no effect
de: Verwendung von %qs mit vorzeichenlosem Typ hat keinen Effekt

en: using a dangling pointer to %qD
de: baumelnder Zeiger auf %qD wird verwendet

en: using a dangling pointer to an unnamed temporary
de: baumelnder Zeiger auf ein unbenanntes temporäres Objekt wird verwendet

en: using alias template specialization %qT after %qs
de: Templatespezialisierung alias %qT hinter %qs wird verwendet

en: using complex absolute value function %qD when argument is of floating-point type %qT
de: die Funktion %qD berechnet den Betrag einer komplexen Zahl, bekommt hier jedoch ein Argument vom Gleitkommatyp %qT übergeben

en: using complex absolute value function %qD when argument is of integer type %qT
de: die Funktion %qD berechnet den Betrag einer komplexen Gleitkommazahl, bekommt hier jedoch ein Argument vom Ganzzahltyp %qT übergeben

en: using dangling pointer %qE to %qD
de: baumelnder Zeiger %qE auf %qD wird verwendet

en: using dangling pointer %qE to an unnamed temporary
de: baumelnder Zeiger %qE auf ein unbenanntes temporäres Objekt wird verwendet

en: using darwin64 ABI
de: darwin64-ABI wird verwendet

en: using decimal floating-point absolute value function %qD when argument is of complex type %qT
de: die Funktion %qD berechnet den Betrag einer dezimalen Gleitkommazahl, bekommt hier jedoch ein Argument vom komplexen Typ %qT übergeben

en: using decimal floating-point absolute value function %qD when argument is of floating-point type %qT
de: die Funktion %qD berechnet den Betrag einer dezimalen Gleitkommazahl, bekommt hier jedoch ein Argument vom binären Gleitkommatyp %qT übergeben

en: using decimal floating-point absolute value function %qD when argument is of integer type %qT
de: die Funktion %qD berechnet den Betrag einer dezimalen Gleitkommazahl, bekommt hier jedoch ein Argument vom Ganzzahltyp %qT übergeben

en: using floating-point absolute value function %qD when argument is of complex type %qT
de: die Funktion %qD berechnet den Betrag einer binären Gleitkommazahl, bekommt hier jedoch ein Argument vom komplexen Typ %qT übergeben

en: using floating-point absolute value function %qD when argument is of decimal floating-point type %qT
de: die Funktion %qD berechnet den Betrag einer binären Gleitkommazahl, bekommt hier jedoch ein Argument vom dezimalen Gleitkommatyp %qT übergeben

en: using floating-point absolute value function %qD when argument is of integer type %qT
de: die Funktion %qD berechnet den Betrag einer Gleitkommazahl, bekommt hier jedoch ein Argument vom Ganzzahltyp %qT übergeben

en: using integer absolute value function %qD when argument is of complex type %qT
de: die Funktion %qD berechnet den Betrag einer Ganzzahl, bekommt hier jedoch ein Argument vom komplexen Typ %qT übergeben

en: using integer absolute value function %qD when argument is of floating-point type %qT
de: die Funktion %qD berechnet den Betrag einer Ganzzahl, bekommt hier jedoch ein Argument vom Gleitkommatyp %qT übergeben

en: using invalid field %qD
de: ungültiges Feld %qD wird verwendet

en: using old darwin ABI
de: Altes darwin-ABI wird verwendet

en: using result of function returning %<void%>
de: Ergebnis einer %<void%> zurückgebenden Funktion verwendet

en: using rvalue as lvalue
de: rvalue wird als lvalue verwendet

en: using serial compilation of %d LTRANS jobs
de: %d LTRANS-Aufträge werden seriell compiliert

en: using simple load CSE after register allocation
de: Nach der Registerbelegung wird eine einfache CSE verwendet

en: using template type parameter %qT after %qs
de: Templatetyp-Parameter %qT wird nach %qs verwendet

en: using the range [%E, %E] for directive argument
de: das Intervall [%E, %E] wird für das Argument der Direktive verwendet

en: using typedef-name %qD after %qs
de: typedef-Name %qD wird nach %qs verwendet

en: using value of simple assignment with %<volatile%>-qualified left operand is deprecated
de: die Verwendung des Wertes der einfachen Zuweisung mit %<volatile%>-qualifiziertem linken Operand ist veraltet

en: using-declaration for member at non-class scope
de: %<using%>-Deklaration für Element außerhalb des Gültigkeitsbereichs der Klasse

en: using-declaration for non-member at class scope
de: »using«-Deklaration für Nicht-Element im Gültigkeitsbereich der Klasse

en: using-declaration may not name namespace %qD
de: %<using%>-Deklaration darf den Namensraum %qD nicht benennen

en: valid %<-foffload=%> arguments are: %s
de: gültige Argumente für %<-foffload=%> sind: %s

en: valid %<-foffload=%> arguments are: %s; did you mean %qs?
de: gültige Argumente für %<-foffload=%> sind: %s; meinten Sie %qs?

en: valid arguments are: %s
de: gültige Argumente sind: %s

en: valid arguments are: %s; did you mean %qs?
de: gültige Argumente sind: %s; meinten Sie %qs?

en: valid arguments to %<-march=%> switch are: %s
de: gültige Argumente für %<-march=%> sind: %s

en: valid arguments to %<-march=%> switch are: %s; did you mean %qs?
de: gültige Argumente für %<-march=%> sind: %s; meinten Sie %qs?

en: valid arguments to %<-mtune=%> switch are: %s
de: gültige Argumente für %<-mtune=%> sind: %s

en: valid arguments to %<-mtune=%> switch are: %s; did you mean %qs?
de: gültige Argumente für %<-mtune=%> sind: %s; meinten Sie %qs?

en: valid arguments to %<target("arch=")%> attribute are: %s
de: gültige Argumente für %<target("arch=")%> sind: %s

en: valid arguments to %<target("arch=")%> attribute are: %s; did you mean %qs?
de: gültige Argumente für %<target("arch=")%> sind: %s; meinten Sie %qs?

en: valid arguments to %<target("tune=")%> attribute are: %s
de: gültige Argumente für %<target("tune=")%> sind: %s

en: valid arguments to %<target("tune=")%> attribute are: %s; did you mean %qs?
de: gültige Argumente für %<target("tune=")%> sind: %s; meinten Sie %qs?

en: valid arguments to %qs are: %s
de: gültige Argumente für %qs sind: %s

en: valid arguments to %qs are: %s; did you mean %qs?
de: gültige Argumente für %qs sind: %s; meinten Sie %qs?

en: valid failure models are %qs, %qs, %qs, %qs
de: gültige Fehler-Modelle sind %qs, %qs, %qs, %qs

en: valid feature names are: %s
de: gültige Featurenamen sind: %s

en: valid feature names are: %s; did you mean %qs?
de: gültige Featurenamen sind: %s; meinten Sie %qs?

en: valid format is %<ns::attr%> or %<ns::%>
de: gültiges Format ist %<ns::attr%> oder %<ns::%>

en: valid models are %s
de: gültige Modelle sind %s

en: valid values for builtin %qF argument %d are 64, 128, 256, 512, 1024, 2048, and 4096
de: gültive Werte für eingebautes %qF, Argument %d, sind 64, 128, 256, 512, 1024, 2048, und 4096

en: value %qE of type %qT is not a constant expression
de: Wert %qE vom Typ %qT ist kein Konstantenausdruck

en: value %qs is not supported by attribute %<target%>
de: Wert %qs wird von Attribut %<target%> nicht unterstützt

en: value argument
de: Wertargument

en: value computed is not used
de: berechneter Wert ist unbenutzt

en: value of %<-mfixed-range%> must have form REG1-REG2
de: Wert von %<-mfixed-range%> muss die Form REG1-REG2 haben

en: value passed in %qs is too large
de: in %qs übergebener Wert ist zu groß

en: value-initialization of function type %qT
de: Wertinitialisierung des Funktionstypen %qT

en: value-initialization of incomplete type %qT
de: Wertinitialisierung des unvollständigen Typen %qT

en: value-initialization of reference type %qT
de: Wertinitialisierung des Referenztypen %qT

en: var-tracking-assignments changes selective scheduling
de: var-tracking-assignments ändert selektive Planung

en: variable
de: Variable

en: variable %q#D has initializer but incomplete type
de: Variable %q#D hat Initialisierung, aber unvollständigen Typ

en: variable %q+D declared %<_Noreturn%>
de: Variable %q+D als %<_Noreturn%> deklariert

en: variable %q+D declared %<inline%>
de: Variable %q+D als %<inline%> deklariert

en: variable %q+D definition is marked dllimport
de: Variablendefinition von %q+D ist als dllimport markiert

en: variable %q+D might be clobbered by %<longjmp%> or %<vfork%>
de: Variable %q+D könnte von %<longjmp%> oder %<vfork%> zerstört werden

en: variable %q+D must be const in order to be put into read-only section by means of %qs
de: Variable %q+D muss konstant sein, um mit %qs in Nur-Lese-Abschnitt gelegt zu werden

en: variable %q+D part of alias cycle
de: Variable %q+D Teil des Alias-Zyklus

en: variable %q+D with dynamic initialization put into program memory area
de: dynamisch initialisierte Variable %q+D in Programmspeicherbereich platziert

en: variable %qD adjusted for OpenACC privatization level: %qs
de: Variable %qD angepasst für OpenACC-Privatisierungsgrad: %qs

en: variable %qD has function type
de: Variable %qD hat Funktionstyp

en: variable %qD has initializer but incomplete type
de: Variable %qD hat Initialisierung, aber unvollständigen Typ

en: variable %qD of non-literal type %qT in %<constexpr%> function only available with %<-std=c++2b%> or %<-std=gnu++2b%>
de: variable %qD vom nicht-literalen Typ %qT in %<constexpr%>-Funktion ist erst mit %<-std=c++2b%> oder %<-std=gnu++2b%> verfügbar

en: variable %qD redeclared as function
de: Variable %qD als Funktion redeklariert

en: variable %qD set but not used
de: Variable %qD gesetzt, aber nicht verwendet

en: variable %qD used more than once with %<#pragma acc declare%>
de: Variable %qD wird in %<#pragma acc declare%> mehr als einmal verwendet

en: variable %qE declared in enclosing %<host_data%> region
de: Variable %qE in umgebender %<host_data%>-Region deklariert

en: variable %qE is not an iteration of outermost loop %d, expected %qE
de: Variable %qE ist keine Iteration der äußersten Schleife %d, jedoch %qE erwartet

en: variable %qE of incomplete type %qT will not be accessed in for increment expression
de: auf Variable %qE des unvollständigen Typs %qT wird in Erhöhungsausdruck nicht zugegriffen

en: variable %qE of incomplete type %qT will not be accessed in left operand of comma operator
de: auf Variable %qE des unvollständigen Typs %qT wird nicht im linken Operanden des Kommaoperators zugegriffen

en: variable %qE of incomplete type %qT will not be accessed in right operand of comma operator
de: auf Variable %qE des unvollständigen Typs %qT wird nicht im rechten Operanden des Kommaoperators zugegriffen

en: variable %qE of incomplete type %qT will not be accessed in second operand of conditional expression
de: auf Variable %qE des unvollständigen Typs %qT wird nicht im zweiten Operanden des bedingten Ausdrucks zugegriffen

en: variable %qE of incomplete type %qT will not be accessed in statement
de: auf Variable %qE des unvollständigen Typs %qT wird in Anweisung nicht zugegriffen

en: variable %qE of incomplete type %qT will not be accessed in third operand of conditional expression
de: auf Variable %qE des unvollständigen Typs %qT wird nicht im dritten Operanden des bedingten Ausdrucks zugegriffen

en: variable %qs has been referenced in offloaded code but hasn%'t been marked to be included in the offloaded code
de: Variable %qs wurde in ausgelagertem Code referenziert, wurde aber nicht markiert, dass sie im ausgelagerten Code enthalten sein dürfte

en: variable concept has no initializer
de: Variablenkonzept hat keine Initialisierung

en: variable length array %qD is used
de: Array %qD variabler Länge wird verwendet

en: variable length array is used
de: Array variabler Größe wird verwendet

en: variable length arrays are not yet supported in coroutines
de: Arrays mit variabler Länge werden in Koroutinen noch nicht unterstützt

en: variable length element type in array %<reduction%> clause
de: Elementtyp variabler Länge in %<reduction%>-Klausel eines Arrays

en: variable of same assembler name as the virtual table is defined in another translation unit
de: Variable mit demselben Assemblernamen wie die virtuelle Tabelle ist in anderer Übersetzungseinheit definiert

en: variable or field %qE declared void
de: Variable oder Feld %qE als »void« deklariert

en: variable or field declared void
de: Variable oder Feld als »void« deklariert

en: variable previously declared %<static%> redeclared %<extern%>
de: als %<extern%> redeklarierte Variable war bereits als %<static%> deklariert

en: variable sized type %qT in %<reduction%> clause
de: Typ %qT mit variabler Länge in %<reduction%>-Klausel

en: variable sized type %qT in %qs clause
de: Typ %qT mit variabler Größe in %qs-Klausel

en: variable symbol is not variable
de: Interner Fehler: variable symbol is not variable

en: variable template declared here
de: Variablentemplate hier deklariert

en: variable template-id %qD in nested-name-specifier
de: Bezeichner %qD für Variablentemplate ist geschachteltem Namens-Spezifizierer

en: variable templates only available with %<-std=c++14%> or %<-std=gnu++14%>
de: variable Templates sind nur mit %<-std=c++14%> oder %<-std=gnu++14%> verfügbar

en: variable tracking requested, but not supported by this debug format
de: Variablenverfolgung angefordert, jedoch nicht von diesem Debug-Format unterstützt

en: variable tracking requested, but useless unless producing debug info
de: Variablenverfolgung angefordert, jedoch nutzlos ohne Debug-Info

en: variable tracking size limit exceeded
de: Grenze zur Variablenverfolgung überschritten

en: variable tracking size limit exceeded with %<-fvar-tracking-assignments%>, retrying without
de: Obere Größengrenze zur Variablenverfolgung mit %<-fvar-tracking-assignments%> überschritten; neuer Versuch ohne

en: variable-length array of %<auto%>
de: Array variabler Größe von %<auto%>

en: variable-sized compound literal
de: zusammengesetztes Literal variabler Größe

en: variable-sized object may not be initialized
de: Objekt variabler Größe darf nicht initialisiert werden

en: variables in %<__regio_symbol%> address space cannot be declared %<register%>
de: Variablen im Adressraum %<__regio_symbol%> können nicht als %<register%> deklariert werden

en: variables in %<__regio_symbol%> address space cannot have initial value
de: Variablen im Adressraum %<__regio_symbol%> können keinen Anfangswert haben

en: variables in %<__regio_symbol%> address space must be declared %<extern%>
de: Variablen im Adressraum %<__regio_symbol%> müssen als %<extern%> deklariert werden

en: variables in %<__regio_symbol%> address space must be declared %<volatile%>
de: Variablen im Adressraum %<__regio_symbol%> müssen als %<volatile%> deklariert werden

en: variables of type %qT cannot have thread-local storage duration
de: Variablen vom Typ %qT können keine thread-lokale Speicherdauer haben

en: variably modified %qE at file scope
de: variabel modifiziertes %qE im Dateibereich

en: variably modified field at file scope
de: variabel modifiziertes Feld im Dateibereich

en: variably modified type not allowed in new-expression
de: im »new«-Ausdruck ist kein variabel modifizierter Typ erlaubt

en: variadic functions must use the base AAPCS variant
de: variadische Funktionen müssen die AAPCS-Basisvariante verwenden

en: variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>
de: variadische Templates nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar

en: variadic thunk call
de: variadischer Thunk-Aufruf

en: variant %qD and base %qD have incompatible types
de: Variante %qD und Basis %qD haben unverträgliche Typen

en: variant %qD is a built-in
de: die Variante %qD ist eine eingebaute

en: variant %qD is not a function
de: Variante %qD ist keine Funktion

en: variant %qs and base %qs at %L have incompatible types: %s
de: Die Variante %qs und die Basis %qs bei %L haben inkompatible Typen: %s

en: variant %qs at %L is not a function or subroutine
de: Die Variante %qs bei %L muss eine Funktion oder Unterroutine sein

en: vector %qs element is not a GIMPLE value
de: %qs-Element des Vektors ist kein GIMPLE-Wert

en: vector %qs with non-NULL element index
de: Vektor-%qs mit Elementindex, der nicht NULL ist

en: vector argument passed to unprototyped function
de: Vektor-Argument an Funktion ohne Prototyp übergeben

en: vector condition will be expanded piecewise
de: Vektorbedingung wird stückweise ausgeweitet

en: vector operation will be expanded in parallel
de: Vektoroperation wird parallel ausgeweitet

en: vector operation will be expanded piecewise
de: Vektoroperation wird stückweise ausgeweitet

en: vector operation will be expanded with a single scalar operation
de: Vektoroperation wird mit einzelner skalarer Operation ausgeweitet

en: vector overflow in expression %qE of type %qT results in %qE
de: Vektorüberlauf in Ausdruck %qE des Typs %qT ergibt %qE

en: vector overflow in expression of type %qT results in %qE
de: Vektorüberlauf in Ausdruck des Typs %qT ergibt %qE

en: vector shuffling operation will be expanded piecewise
de: Vektorumverteilungsoperation wird stückweise ausgeweitet

en: vector size not an integral multiple of component size
de: Vektorgröße kein ganzzahliges Vielfaches der Komponentengröße

en: vector type expected in %qs
de: Vektortypen erwartet in %qs

en: vector types expected in %qs
de: Vektortypen erwartet in %qs

en: vectorization did not happen for a simd loop
de: Vektorisierung für eine SIMD-Schleife nicht durchgeführt

en: vectors with different element number found in %qs
de: Vektoren unterschiedlicher Elementanzahl in %qs gefunden

en: verify_cgraph_node failed
de: Interner Fehler: verify_cgraph_node failed

en: verify_flow_info failed
de: Interner Fehler: verify_flow_info failed

en: verify_flow_info: Basic block %d succ edge is corrupted
de: Interner Fehler: verify_flow_info: Basic block %d succ edge is corrupted

en: verify_flow_info: Block %i has loop_father, but there are no loops
de: Interner Fehler: verify_flow_info: Block %i has loop_father, but there are no loops

en: verify_flow_info: Block %i lacks loop_father
de: Interner Fehler: verify_flow_info: Block %i lacks loop_father

en: verify_flow_info: Duplicate edge %i->%i
de: Interner Fehler: verify_flow_info: Duplicate edge %i->%i

en: verify_flow_info: Incorrect blocks for fallthru %i->%i
de: Interner Fehler: verify_flow_info: Incorrect blocks for fallthru %i->%i

en: verify_flow_info: Incorrect fallthru %i->%i
de: Interner Fehler: verify_flow_info: Incorrect fallthru %i->%i

en: verify_flow_info: Missing count of block %i
de: Interner Fehler: verify_flow_info: Missing count of block %i

en: verify_flow_info: REG_BR_PROB does not match cfg %i %i
de: Interner Fehler: verify_flow_info: REG_BR_PROB does not match cfg %i %i

en: verify_flow_info: REG_BR_PROB is set but cfg probability is not
de: Interner Fehler: verify_flow_info: REG_BR_PROB is set but cfg probability is not

en: verify_flow_info: Wrong count of block %i
de: Interner Fehler: verify_flow_info: Wrong count of block %i

en: verify_flow_info: Wrong probability of edge %i->%i
de: Interner Fehler: verify_flow_info: Wrong probability of edge %i->%i

en: verify_flow_info: unallocated edge flag set on %d -> %d
de: Interner Fehler: verify_flow_info: unallocated edge flag set on %d -> %d

en: verify_flow_info: unallocated flag set on BB %d
de: Interner Fehler: verify_flow_info: unallocated flag set on BB %d

en: verify_ssa failed
de: verify_ssa gescheitert

en: version attribute is not a string
de: Versionsattribut ist keine Zeichenkette

en: version control conflict marker in file
de: Konfliktmarker für Versionskontrolle in Datei

en: version inherited from %qT declared here
de: von %qT geerbte Version ist hier deklariert

en: version of %<g%> will be omitted, please specify version for individual extension
de: Version von %<g%> wird weggelassen, bitte geben Sie die Version für die individuelle Erweiterung an

en: versioned symbol must be public
de: das versionierte Symbol muss %<public%> sein

en: versioned symbol must have default visibility
de: versioniertes Symbol muss standardmäßige Sichtbarkeit haben

en: virt-specifiers in %qs not allowed outside a class definition
de: virt-Spezifikation in %qs ist außerhalb einer Klassendefinition nicht erlaubt

en: virtual base %qT inaccessible in %qT due to ambiguity
de: virtuelle Basis %qT ist in %qT durch Mehrdeutigkeit unzugänglich

en: virtual def operand missing for statement
de: für Anweisung fehlt virtueller Definitions-Operand

en: virtual definition of statement not up to date
de: virtuelle Definition der Anweisung nicht aktuell

en: virtual function %q+D overriding final function
de: virtuelle Funktion %q+D übersteuert final-Funktion

en: virtual function cannot have deduced return type
de: virtuelle Funktionen kann keinen hergeleiteten Rückgabetyp haben

en: virtual function multiversioning not supported
de: Multiversionierung virtueller Funktionen wird nicht unterstützt

en: virtual functions cannot be %<constexpr%> before C++20
de: virtuelle Funktionen können erst mit C++20 %<constexpr%> sein

en: virtual functions cannot be friends
de: virtuelle Funktionen können keine friends sein

en: virtual method %qD
de: virtuelle Methode %qD

en: virtual non-class function %qs
de: virtuelle Nicht-Klassen-Funktion %qs

en: virtual table of type %qD contains RTTI information
de: virtuelle Tabelle des Typs %qD enthält RTTI-Information

en: virtual table of type %qD violates one definition rule
de: virtuelle Tabelle des Typs %qD verletzt die One-Definition-Rule

en: virtual table pointer is used uninitialized
de: Zeiger auf Virtuelle Tabelle wird uninitialisiert verwendet

en: virtual use of statement not up to date
de: virtuelle Verwendung von Anweisung nicht aktuell

en: virtual use operand missing for statement
de: für die Anweisung fehlt der virtuelle Verwendungs-Operand

en: visibility argument not a string
de: Sichtbarkeitsargument ist keine Zeichenkette

en: visibility attribute not supported in this configuration; ignored
de: Sichtbarkeitsattribute werden in dieser Konfiguration nicht unterstützt; ignoriert

en: vms '#pragma __message' is ignored
de: vms »#pragma __message« wird ignoriert

en: void value not ignored as it ought to be
de: void-Wert nicht ignoriert wie es sein sollte

en: volatile argument
de: flüchtiges Argument

en: vtable for
de: vtable für

en: vtable verification is not supported with LTO
de: Vtable-Verifikation wird in Kombination mit LTO nicht unterstützt

en: waitpid failed
de: waitpid gescheitert

en: warning:
de: Warnung:

en: warning: consider linking with '-static' as system libraries with
de: Warnung: Evtl. mit »-static« linken, da Systembibliotheken mit

en: was expecting `%s'
de: »%s« wurde erwartet

en: weak %q+D cannot be defined %qE
de: schwaches %q+D kann nicht als %qE definiert werden

en: weak alias definitions not supported in this configuration
de: schwache Alias-Definitionen werden in dieser Konfiguration nicht unterstützt

en: weak aliases are not supported
de: schwache Aliase werden nicht unterstützt

en: weak declaration of %q+D being applied to a already existing, static definition
de: schwache Deklaration von %q+D wird auf bereits existierende »static«-Definition angewandt

en: weak declaration of %q+D must be public
de: schwache Deklaration von %q+D muss öffentlich sein

en: weak declaration of %q+D not supported
de: schwache Deklaration von %q+D wird nicht unterstützt

en: weights need to be non-negative
de: Gewichte müssen nichtnegativ sein

en: when storing %qT, %qE requires a vector base and a scalar index
de: beim Speichern von %qT erfordert %qE eine Vektorbasis und einen skalaren Index

en: when writing output to %s: %m
de: beim Schreiben der Ausgabe nach %s: %m

en: while %qT decomposes into %E elements
de: während %qT in %E Elemente zerlegt wird

en: while %qT decomposes into %wu element | while %qT decomposes into %wu elements
de[0]: während %qT in %wu Element zerlegt wird
de[1]: während %qT in %wu Elemente zerlegt wird

en: while referencing %qD
de: beim Referenzieren von %qD

en: width of %qD exceeds its type
de: Breite von %qD übersteigt seinen Typen

en: width of %qs exceeds its type
de: Breite von %qs überschreitet dessen Typen

en: width of bit-field %qD has non-integral type %qT
de: Breite des Bit-Feldes %qD hat Nicht-Ganzzahl-Typ %qT

en: with
de: mit

en: with %<ancestor%>, only the %<device%>, %<firstprivate%>, %<private%>, %<defaultmap%>, and %<map%> clauses may appear on the construct
de: mit %<ancestor%> dürfen nur die Klauseln %<device%>, %<firstprivate%>, %<private%>, %<defaultmap%> und %<map%> in dem Konstrukt erscheinen

en: within this loop
de: innerhalb dieser Schleife

en: without %<-gdwarf-5%>, %<-gvariable-location-views=incompat5%> is equivalent to %<-gvariable-location-views%>
de: ohne %<-gdwarf-5%> ist %<-gvariable-location-views=incompat5%> gleichbedeutend mit %<-gvariable-location-views%>

en: work-sharing region may not be closely nested inside of work-sharing, %<loop%>, %<critical%>, %<ordered%>, %<master%>, %<masked%>, explicit %<task%> or %<taskloop%> region
de: arbeitsteilende Region darf nicht innerhalb einer Region eng geschachtelt sein, die arbeitsteilend, %<loop%>, %<critical%>, %<ordered%>, %<master%>, %<masked%>, explizit %<task%> oder %<taskloop%> ist

en: write of %wu-bit data outside the bound of destination object, data truncated into %wu-bit
de: Schreiben von %wu Bit Daten außerhalb der Grenzen des Zielobjekts, Daten wurden auf %wu Bit abgeschnitten

en: writing %E byte into a region of size %E overflows the destination
de: Code schreibt %E Byte in eine Region der Größe %E und bringt dadurch das Zielobjekt zum Überlaufen

en: writing %E bytes into a region of size %E overflows the destination
de: Code schreibt %E Bytes in eine Region der Größe %E und bringt dadurch das Zielobjekt zum Überlaufen

en: writing %E or more bytes into a region of size %E overflows the destination
de: Code schreibt %E oder mehr Bytes in eine Region der Größe %E und bringt dadurch die Zielregion zum Überlaufen

en: writing %wu byte into a region of size %wu | writing %wu bytes into a region of size %wu
de[0]: Schreiben von %wu Byte in eine Region der Größe %wu
de[1]: Schreiben von %wu Bytes in eine Region der Größe %wu

en: writing %wu byte into a region of size between %wu and %wu | writing %wu bytes into a region of size between %wu and %wu
de[0]: Schreiben von %wu Byte in eine Region der Größe zwischen %wu und %wu
de[1]: Schreiben von %wu Bytes in eine Region der Größe zwischen %wu und %wu

en: writing CMI %qs
de: CMI %qs wird geschrieben

en: writing between %E and %E bytes into a region of size %E overflows the destination
de: Code schreibt zwischen %E und %E Bytes in eine Region der Größe %E und bringt dadurch das Zielobjekt zum Überlaufen

en: writing between %wu and %wu bytes into a region of size %wu
de: Schreiben von %wu bis %wu Bytes in eine Region der Größe %wu

en: writing between %wu and %wu bytes into a region of size between %wu and %wu
de: %wu bis %wu Bytes werden in eine Region der Größe zwischen %wu und %wu geschrieben

en: writing into constant object (argument %d)
de: Schreiben in konstantes Objekt (Argument %d)

en: writing one too many bytes into a region of a size that depends on %<strlen%>
de: ein Byte zu viel wird in eine Region geschrieben, deren Größe von %<strlen%> abhängt

en: writing output file
de: Ausgabedatei wird geschrieben

en: writing through null pointer (argument %d)
de: Schreiben über Null-Zeiger (Argument %d)

en: writing to LTRANS output list %s: %m
de: beim Schreiben in LTRANS-Ausgabeliste %s: %m

en: writing to address space %qs not supported
de: Schreibzugriff auf Adressraum %qs wird nicht unterstützt

en: wrong %<TYPE_CACHED_VALUES%> entry
de: Interner Compilerfehler: wrong %<TYPE_CACHED_VALUES%> entry

en: wrong amount of branch edges after conditional jump in bb %i
de: Interner Fehler: wrong amount of branch edges after conditional jump in bb %i

en: wrong amount of branch edges after unconditional jump %i
de: Interner Fehler: wrong amount of branch edges after unconditional jump %i

en: wrong argument %qs to option %qs
de: falsches Argument %qs für Option %qs

en: wrong argument to ignored attributes
de: falsches Argument für ignorierte Attribute

en: wrong edge %d->%d for PHI argument
de: Falsche Kante %d->%d für PHI-Argument

en: wrong entry in %<TYPE_ARG_TYPES%> list
de: Interner Compilerfehler: wrong entry in %<TYPE_ARG_TYPES%> list

en: wrong immediate use list
de: Falsche Liste zur sofortigen Verwendung

en: wrong insn in the fallthru edge
de: falscher Befehl in »fallthru«-Kante

en: wrong list of exited loops for edge %d->%d
de: falsche Liste der verlassenen Schleifen für Kante %d->%d

en: wrong number of arguments specified for %qE attribute
de: Falsche Anzahl an Argumenten für das Attribut %qE angegeben

en: wrong number of arguments to %%:debug-level-gt
de: falsche Anzahl der Argumente für %%:debug-level-gt

en: wrong number of arguments to %%:dwarf-version-gt
de: falsche Anzahl von Argumenten für %%:dwarf-version-gt

en: wrong number of arguments to %<__builtin_addressof%>
de: falsche Anzahl von Argumenten für %<__builtin_addressof%>

en: wrong number of arguments to %<__builtin_assoc_barrier%>
de: falsche Anzahl von Argumenten für %<__builtin_assoc_barrier%>

en: wrong number of arguments to %<__builtin_call_with_static_chain%>
de: falsche Anzahl der Argumente für %<__builtin_call_with_static_chain%>

en: wrong number of arguments to %<__builtin_choose_expr%>
de: falsche Anzahl der Argumente für %<__builtin_choose_expr%>

en: wrong number of arguments to %<__builtin_complex%>
de: falsche Anzahl der Argumente für %<__builtin_complex%>

en: wrong number of arguments to %<__builtin_convertvector%>
de: falsche Anzahl von Argumenten für %<__builtin_convertvector%>

en: wrong number of arguments to %<__builtin_launder%>
de: falsche Anzahl von Argumenten für %<__builtin_launder%>

en: wrong number of arguments to %<__builtin_shuffle%>
de: falsche Anzahl der Argumente für %<__builtin_shuffle%>

en: wrong number of arguments to %<__builtin_shufflevector%>
de: falsche Anzahl der Argumente für %<__builtin_shufflevector%>

en: wrong number of arguments to function %<__builtin_next_arg%>
de: falsche Anzahl der Argumente für Funktion %<__builtin_next_arg%>

en: wrong number of arguments to function %<va_start%>
de: falsche Anzahl der Argumente für Funktion %<va_start%>

en: wrong number of branch edges after unconditional jump in bb %i
de: Interner Fehler: wrong number of branch edges after unconditional jump in bb %i

en: wrong number of template arguments (%d, should be %d)
de: falsche Anzahl der Templateargumente (%d, sollte %d sein)

en: wrong number of template arguments (%d, should be at least %d)
de: falsche Anzahl der Templateargumente (%d, sollte mindestens %d sein)

en: wrong outgoing edge flags at end of bb %d
de: Interner Fehler: wrong outgoing edge flags at end of bb %d

en: wrong strategy name %qs specified for option %qs
de: falscher Strategiename %qs für Option %qs angegeben

en: wrong tree in %<TYPE_FIELDS%> list
de: Interner Compilerfehler: wrong tree in %<TYPE_FIELDS%> list

en: wrong type argument to %s
de: Argument falschen Typs für %s

en: wrong type argument to abs
de: Argument falschen Typs für abs

en: wrong type argument to absu
de: falsches Typargument für »absu«

en: wrong type argument to bit-complement
de: Argument falschen Typs für Bit-Komplement

en: wrong type argument to conjugation
de: Argument falschen Typs für Konjugation

en: wrong type argument to decrement
de: Argument falschen Typs für Dekrementierung

en: wrong type argument to increment
de: Argument falschen Typs für Inkrementierung

en: wrong type argument to unary exclamation mark
de: Argument falschen Typs für unäres Ausrufungszeichen

en: wrong type argument to unary minus
de: Argument falschen Typs für unäres Minus

en: wrong type argument to unary plus
de: Argument falschen Typs für unäres Plus

en: wrong type of argument %s
de: Argument falschen Typs für »%s«

en: x87 register return with x87 disabled
de: x87-Registerrückgabe mit ausgeschaltetem x87

en: xstormy16_print_operand: unknown code
de: xstormy16_print_operand: unbekannter Code

en: you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma
de: Sie können %qs mit der Befehlszeilenoption %<-march%> einschalten, oder mit dem Attribut %<target%> oder Pragma

en: you can enable SVE using the command-line option %<-march%>, or by using the %<target%> attribute or pragma
de: Sie können SVE mit der Befehlszeilenoption %<-march%>, oder mit dem Attribut %<target%> oder Pragma aktivieren

en: you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>
de: Sie können diesen Wert mit %<--param hardware_destructive_interference_size=%d%> stabilisieren, oder diese Warnung mit %<-Wno-interference-size%> deaktivieren

en: you can use an inline namespace instead
de: Sie können stattdessen einen inline-Namensraum verwenden

en: you can work around this by removing the initializer
de: dies kann durch das Löschen der Initialisierung umgangen werden

en: you cannot take the address of a nested function if you use the %qs option
de: Bei Verwendung der Option %qs kann die Adresse von geschachtelten Funktionen nicht verwendet werden

en: you should use the %<-%s%> option
de: Sie sollten die Option %<-%s%> verwenden

en: your native CPU architecture (%qs) does not support %qs ABI, falling back to %<-m%s=%s%>
de: Ihre native CPU-Architektur %qs unterstützt die ABI %qs nicht, stattdessen wird %<-m%s=%s%> verwendet

en: z/Architecture.
de: z/Architektur.

en: zero as null pointer constant
de: Null als Nullzeigerkonstante

en: zero length array section in %qs clause
de: Arrayabschnitt der Länge 0 in %qs-Klausel

en: zero or negative size array %q+D
de: Arraygröße von %q+D ist null oder negativ

en: zero sized type %qT in %<reduction%> clause
de: Typ %qT mit Größe 0 in %<reduction%>-Klausel

en: zero sized type %qT in %qs clause
de: Typ %qT mit Größe 0 in %qs-Klausel

en: zero vector size
de: Vektorgröße Null

en: zero width for bit-field %q+D
de: Breite Null für Bitfeld %q+D

en: zero width for bit-field %qs
de: Breite Null für Bitfeld %qs

en: zero width in %s format
de: Breite null im Format %s

en: zero-length %s format string
de: Format-Zeichenkette %s der Länge null

en: zero-size array %qD
de: Array %qD der Größe null

en: zero-size array %qT
de: Array %qT der Größe null

en: zero-size array member %qD in an otherwise empty %q#T
de: Arrayelement %qD mit Länge 0 in ansonsten leerem %q#T

en: zero-size array member %qD not at end of %q#T
de: Arrayelement %qD mit Länge 0 befindet sich nicht am Ende von %q#T

en: {anonymous}
de: {anonym}

en: {erroneous}
de: {fehlerhaft}
