gas 2.43.90 - en to ro translation catalogue (4872 entries)

en: 			  TI CodeComposer Studio syntax compatibility mode
ro: 			  modul de compatibilitate cu sintaxa TI CodeComposer Studio

en: 			[default is %d]
ro: 			[valoarea implicită este %d]

en: 			[default is %s]
ro: 			[valoarea implicită este %s]

en: 		            Default: %s
ro:                           Valoarea implicită: %s

en: 
    			specify variant of SPARC architecture
    -bump			warn when assembler switches architectures
    -sparc			ignored
    --enforce-aligned-data	force .long, etc., to be aligned correctly
    -relax			relax jumps and branches (default)
    -no-relax		avoid changing any jumps and branches
ro: 
                    specifică varianta de arhitectură SPARC
    -bump           avertizează atunci când asamblorul schimbă arhitectura
    -sparc          ignorată
    --enforce-aligned-data
                    forțează .long, etc., să fie aliniate corect
    -relax          relaxează salturile și ramurile (implicit)
    -no-relax       evită modificarea oricăror salturi și ramuri

en: 
     NDS32-specific assembler options:
ro: 
     Opțiuni de asamblare specifice NDS32:

en: 
     input file    	: %s
ro: 
     fișierul de intrare : %s

en: 
     options passed	:
ro: 
     opțiuni pasate      :

en: 
     output file   	: %s
ro: 
     fișierul de ieșire  : %s

en: 
     target        	: %s
ro: 
     țintă               : %s

en: 
     time stamp    	: %s
ro: 
     marcajul de timp    : %s

en: 
    -no-relax		don't relax relocations
ro: 
    -no-relax		nu relaxează realocările

en: 
    BPF options:
ro: 
    Opțiuni BPF:

en: 
    CPU model options:
      -march=CPU[+EXT...][-EXT...]
    			  generate code for CPU, where CPU is one of:
ro: 
    Opțiuni model CPU:
      -march=CPU[+EXT...][-EXT...]
                  generează cod pentru CPU, unde CPU este unul dintre:

en: 
    Compatibility options:
      -local-prefix=TEXT	  treat labels prefixed by TEXT as local
      -colonless		  permit colonless labels
      -sdcc			  accept SDCC specific instruction syntax
      -fp-s=FORMAT		  set single precision FP numbers format
      -fp-d=FORMAT		  set double precision FP numbers format
    Where FORMAT one of:
      ieee754		  IEEE754 compatible (depends on directive)
      half			  IEEE754 half precision (16 bit)
      single		  IEEE754 single precision (32 bit)
      double		  IEEE754 double precision (64 bit)
      zeda32		  Zeda z80float library 32 bit format
      math48		  48 bit format from Math48 library
    
    Default: -march=z80+xyhl+infc
ro: 
    Opțiuni de compatibilitate:
      -local-prefix=TEXT	  tratează etichetele prefixate cu TEXT ca fiind locale
      -colonless		  permite etichete fără două puncte(„:”)
      -sdcc			  acceptă sintaxa instrucțiunilor specifice SDCC
      -fp-s=FORMAT		  stabilește formatul numerelor FP cu precizie simplă
      -fp-d=FORMAT		  stabilește formatul numerelor FP de precizie dublă
    Unde FORMAT este unul dintre:
      ieee754		  compatibil IEEE754 (depinde de directivă)
      half			  semiprecizie IEEE754 (16 biți)
      single		  precizie simplă IEEE754 (32 biți)
      double		  precizie dublă IEEE754 (64 biți)
      zeda32		  formatul de 32 de biți al bibliotecii Zeda z80float
      math48		  formatul de 48 de biți din biblioteca Math48
    
    Implicit: -march=z80+xyhl+infc

en: 
    D30V options:
    -O                      Make adjacent short instructions parallel if possible.
    -n                      Warn about all NOPs inserted by the assembler.
    -N                      Warn about NOPs inserted after word multiplies.
    -c                      Warn about symbols whose names match register names.
    -C                      Opposite of -C.  -c is the default.
ro: 
    Opțiuni D30V:
    -O                      face ca instrucțiunile scurte adiacente să fie paralele,
                            dacă este posibil
    -n                      avertizează cu privire la toate NOP-urile inserate de
                            către asamblor
    -N                      avertizează cu privire la NOP-urile inserate după
                            multiplicarea cuvintelor
    -c                      avertizează cu privire la simbolurile ale căror nume se
                            potrivesc cu numele registrelor
    -C                      opusul lui „-c”; „-c” este opțiunea implicită

en: 
    TIC4X options:
      -mcpu=CPU  -mCPU        select architecture variant. CPU can be:
                                30 - TMS320C30
                                31 - TMS320C31, TMS320LC31
                                32 - TMS320C32
                                33 - TMS320VC33
                                40 - TMS320C40
                                44 - TMS320C44
      -mrev=REV               set cpu hardware revision (integer numbers).
                              Combinations of -mcpu and -mrev will enable/disable
                              the appropriate options (-midle2, -mlowpower and
                              -menhanced) according to the selected type
      -mbig                   select big memory model
      -msmall                 select small memory model (default)
      -mregparm               select register parameters (default)
      -mmemparm               select memory parameters
      -midle2                 enable IDLE2 support
      -mlowpower              enable LOPOWER and MAXSPEED support
      -menhanced              enable enhanced opcode support
ro: 
    Opțiuni TIC4X:
      -mcpu=CPU  -mCPU        selectează varianta de arhitectură. CPU poate fi:
                                30 - TMS320C30
                                31 - TMS320C31, TMS320LC31
                                32 - TMS320C32
                                33 - TMS320VC33
                                40 - TMS320C40
                                44 - TMS320C44
      -mrev=REV               stabilește revizuirea hardware a cpu-ului (numere
                              întregi); combinațiile de „-mcpu” și „-mrev” vor
                              activa/dezactiva opțiunile corespunzătoare („-midle2”,
                              „-mlowpower” și „-menhanced”) în funcție de tipul selectat
      -mbig                   selectează modelul de memorie mare
      -msmall                 selectează modelul de memorie mică (implicit)
      -mregparm               selectează parametrii registrului (implicit)
      -mmemparm               selectează parametrii de memorie
      -midle2                 activează suportul IDLE2
      -mlowpower              activează suportul LOPOWER și MAXSPEED
      -menhanced              activează suportul pentru cod operațional îmbunătățit

en: 
    s12z options:
ro: 
    Opțiuni s12z:

en:                                          constraint violations
ro:                                         încălcarea constrângerilor

en:                                          for constraint violations
ro:                                         pentru încălcarea constrângerilor

en:                                          instructions might violate constraints
ro:                                         paralele ar putea încălca constrângerile

en:                                          might violate constraints
ro:                                         paralele ar putea încălca constrângerile

en:                           EXTENSION is combination of (possibly "no"-prefixed):
ro:                           EXTENSIE este o combinație de (eventual cu prefixul „no”-):

en:                           Registers will not need any prefix.
ro:                           Registrele nu vor avea nevoie de niciun prefix.

en:                           Registers will require a `$'-prefix.
ro:                           Registrele vor avea nevoie de un prefix „$”.

en:                           check TLS relocation
ro:                           verifică realocarea TLS

en:                           emulate output (default %s)
ro:                           emulează ieșirea (implicit %s)

en:                           generate ELF common symbols with STT_COMMON type
ro:                           generează simboluri comune ELF cu tipul STT_COMMON

en:                           generate GNU Build notes if none are present in the input
ro:                           generează note GNU Build dacă nu sunt prezente în datele de intrare

en:                           generate relax relocations
ro:                           generează realocări relaxate

en:                           generate x86 used ISA and feature properties
ro:                           generează proprietățile ISA utilizate de x86 și
                              proprietățile caracteristice

en:                           use AT&T/Intel mnemonic (AT&T syntax only)
ro:                           utilizează mnemonica AT&T/Intel (numai pentru sintaxa AT&T)

en:                 Record the cpu type
ro:                 înregistrează tipul de cpu

en:         -EB		assemble code for a big-endian cpu
ro:         -EB		asamblează codul pentru un cpu big-endian

en:         -EL		assemble code for a little-endian cpu
ro:         -EL		asamblează codul pentru un cpu little-endian

en:         -FIXDD		fix data dependencies
ro:         -FIXDD		corectează dependențele de date

en:         -G gpnum	assemble code for setting gpsize, default is 8 bytes
ro:         -G gpnum	asamblează codul pentru definirea gpsize dată, implicit 8 octeți

en:         -KPIC		generate PIC
ro:         -KPIC		generează codul PIC

en:         -NWARN		do not print warning message when fixing data dependencies
ro:         -NWARN		nu afișează un mesaj de avertizare atunci când corectează dependențele de date

en:         -O0		do not perform any optimizations
ro:         -O0		nu efectuează nicio optimizare

en:         -SCORE3		assemble code for target SCORE3
ro:         -SCORE3		asamblează codul pentru ținta SCORE3

en:         -SCORE5		assemble code for target SCORE5
ro:         -SCORE5		asamblează codul pentru ținta SCORE5

en:         -SCORE5U	assemble code for target SCORE5U
ro:         -SCORE5U	asamblează codul pentru ținta SCORE5U

en:         -SCORE7		assemble code for target SCORE7 [default]
ro:         -SCORE7		asamblează codul pentru ținta SCORE7 [implicit]

en:         -USE_R1		assemble code for no warning message when using temp register r1
ro:         -USE_R1		asamblează codul pentru lipsa mesajului de avertizare la utilizarea registrului temp r1

en:         -V 		Sunplus release version
ro:         -V 		versiunea de lansare a Sunplus

en:         -march=score3	assemble code for target SCORE3
ro:         -march=score3	asamblează codul pentru ținta SCORE3

en:         -march=score7	assemble code for target SCORE7 [default]
ro:         -march=score7	asamblează codul pentru ținta SCORE7 [implicilt]

en:     ops were:
ro:     operațiile au fost:

en:    did you mean this?
ro:    ați vrut să spuneți asta?

en:    other valid variant(s):
ro:    altă(e) variantă(e) validă(e):

en:   --32/--64               generate 32bit/64bit object
ro:   --32/--64               generează un obiect pe 32 biți/64 biți

en:   --32/--64/--x32         generate 32bit/64bit/x32 object
ro:   --32/--64/--x32         generează un obiect pe 32 biți/64 biți/x32

en:   --MD FILE               write dependency information in FILE (default none)
ro:   --MD FIȘIER             scrie informațiile despre dependență în FIȘIER (implicit niciunul)

en:   --alternate             initially turn on alternate macro syntax
ro:   --alternate             activează inițial sintaxa alternativă a macrocomenzilor

en:   --compress-debug-sections[={none|zlib|zlib-gnu|zlib-gabi|zstd}]
                              compress DWARF debug sections
ro:   --compress-debug-sections=[none|zlib|zlib-gnu|zlib-gabi|zstd]
                              comprimă secțiunile de depanare DWARF
                              Valoarea implicită: zlib

en:   --debug-prefix-map OLD=NEW
                              map OLD to NEW in debug information
ro:   --debug-prefix-map VECHI=NOU
                              înlocuiește VECHI cu NOU în informațiile de depanare

en:   --defsym SYM=VAL        define symbol SYM to given value
ro:   --defsym SIM=VAL        definește simbolul SIM la valoarea dată

en:   --disp-size-default-22    branch displacement with unknown size is 22 bits (default)
ro:   --disp-size-default-22    deplasarea ramurii cu dimensiune necunoscută este de 22 biți (implicit)

en:   --disp-size-default-32    branch displacement with unknown size is 32 bits
ro:   --disp-size-default-32    deplasarea ramurii cu dimensiune necunoscută este de 32 de biți

en:   --divide                do not treat `/' as a comment character
ro:   --divide                nu tratează „/” drept un caracter de comentariu

en:   --divide                ignored
ro:   --divide                ignorată

en:   --dump-config           display how the assembler is configured and then exit
ro:   --dump-config           afișează modul în care este configurat asamblorul și apoi iese

en:   --execstack             require executable stack for this object
ro:   --execstack             necesită stivă executabilă pentru acest obiect

en:   --fatal-warnings        treat warnings as errors
ro:   --fatal-warnings        tratează avertismentele ca erori

en:   --fdpic                 generate an FDPIC object file
ro:   --fdpic                 generează un fișier obiect FDPIC

en:   --fix-v4bx              Allow BX in ARMv4 code
ro:   --fix-v4bx              permite BX în codul ARMv4

en:   --gcodeview             generate CodeView debugging information
ro:   --gcodeview             generează informații de depanare CodeView

en:   --gdwarf-<N>            generate DWARF<N> debugging information. 2 <= <N> <= 5
ro:   --gdwarf-<N>            generează informații de depanare DWARF<N>. 2 <= <N> <= 5

en:   --gdwarf-cie-version=<N> generate version 1, 3 or 4 DWARF CIEs
ro:   --gdwarf-cie-version=<N> generează CIE-uri DWARF versiunea 1, 3 sau 4

en:   --gdwarf-sections       generate per-function section names for DWARF line information
ro:   --gdwarf-sections       generează nume de secțiuni pentru fiecare funcție în parte
                              pentru informațiile de linie DWARF

en:   --gsframe               generate SFrame stack trace information
ro:   --gsframe               generează informații de urmărire a stivei SFrame

en:   --gstabs                generate STABS debugging information
ro:   --gstabs                generează informații de depanare STABS

en:   --gstabs+               generate STABS debug info with GNU extensions
ro:   --gstabs+               generează informații de depanare STABS cu extensii GNU

en:   --hash-size=<N>         ignored
ro:   --hash-size=<N>         ignorată

en:   --help                  show all assembler options
ro:   --help                  afișează toate opțiunile asamblorului

en:   --info                  don't suppress information messages
ro:   --info                  nu suprimă mesajele informative

en:   --itbl INSTTBL          extend instruction set to include instructions
                              matching the specifications defined in file INSTTBL
ro:   --itbl INSTTBL          extinde setul de instrucțiuni pentru a include instrucțiuni
                              care corespund specificațiilor definite în fișierul INSTTBL

en:   --listing-cont-lines    set the maximum number of continuation lines used
                              for the output data column of the listing
ro:   --listing-cont-lines    stabilește numărul maxim de linii de continuare utilizate pentru
                              coloana de date de ieșire a listării

en:   --listing-lhs-width     set the width in words of the output data column of
                              the listing
ro:   --listing-lhs-width     stabilește lățimea în cuvinte a coloanei de date de ieșire din listare

en:   --listing-lhs-width2    set the width in words of the continuation lines
                              of the output data column; ignored if smaller than
                              the width of the first line
ro:   --listing-lhs-width2    stabilește lățimea în cuvinte a liniilor de continuare a coloanei de
                              date de ieșire; ignorată dacă este mai mică decât lățimea primei linii

en:   --listing-rhs-width     set the max width in characters of the lines from
                              the source file
ro:   --listing-rhs-width     stabilește lățimea maximă în caractere a liniilor din fișierul sursă

en:   --m32bit-doubles  [default]
ro:   --m32bit-doubles  [implicit]

en:   --m32bit-doubles [default]
ro:   --m32bit-doubles [implicit]

en:   --m64bit-doubles  Source code uses 64-bit doubles
ro:   --m64bit-doubles  codul sursă utilizează dubluri pe 64 de biți

en:   --march=<arch>		Generate code for <arch>.  Valid choices for <arch>
    				are v0_v10, v10, v32 and common_v10_v32.
ro:   --march=<arch>		generează cod pentru <arch>; alegerile valide pentru
    				<arch> sunt v0_v10, v10, v32 și common_v10_v32.

en:   --mg10            Enable support for G10 variant
ro:   --mg10            activează suportul pentru varianta G10

en:   --mg13            Selects the G13 core.
ro:   --mg13            selectează nucleul G13

en:   --mg14            Selects the G14 core [default]
ro:   --mg14            selectează nucleul G14 [implicit]

en:   --mint-register=<value>
ro:   --mint-register=<valoare>

en:   --mlittle-endian-data [default]
ro:   --mlittle-endian-data [implicit]

en:   --mrelax          Enable link time relaxation
ro:   --mrelax          activează relaxarea timpului de legătură

en:   --mrl78           Alias for --mg14
ro:   --mrl78           alias pentru „--mg14”

en:   --multibyte-handling=<method>
                              what to do with multibyte characters encountered in the input
ro:   --multibyte-handling=<metoda>
                              ce trebuie făcut cu caracterele multi-octet întâlnite la intrare

en:   --muse-renesas-section-names [default]
ro:   --muse-renesas-section-names [implicit]

en:   --no-info               suppress information messages
ro:   --no-info               suprimă mesajele informative

en:   --no-underscore         User symbols do not have any prefix.
ro:   --no-underscore         simbolurile de utilizator nu au niciun prefix

en:   --nocompress-debug-sections
                              don't compress DWARF debug sections
ro:   --nocompress-debug-sections
                              nu comprimă secțiunile de depanare DWARF

en:   --noexecstack           don't require executable stack for this object
ro:   --noexecstack           nu necesită stivă executabilă pentru acest obiect

en:   --pic			Enable generation of position-independent code.
ro:   --pic			activează generarea de cod independent de poziție

en:   --reduce-memory-overheads ignored
ro:   --reduce-memory-overheads ignorată

en:   --scfi=experimental     Synthesize DWARF CFI for hand-written asm
                              (experimental support)
ro:   --scfi=experimental     sintetizează DWARF CFI pentru asm scris manual
                              (suport experimental)

en:   --sectname-subst        enable section name substitution sequences
ro:   --sectname-subst        activează secvențele de substituție a numelui secțiunii

en:   --size-check=[error|warning]
    			  ELF .size directive check (default --size-check=error)
ro:   --size-check=[error|warning]
    			  verifică directiva ELF .size (implicit --size-check=error)

en:   --statistics            print various measured statistics from execution
ro:   --statistics            afișează diverse statistici măsurate în urma execuției

en:   --strip-local-absolute  strip local absolute symbols
ro:   --strip-local-absolute  înlătură simbolurile absolute locale

en:   --target-help           show target specific options
ro:   --target-help           afișează opțiunile specifice țintei

en:   --traditional-format    Use same format as native assembler when possible
ro:   --traditional-format    utilizează același format ca și asamblorul nativ atunci când este posibil

en:   --underscore            User symbols are normally prepended with underscore.
ro:   --underscore            simbolurile utilizatorului sunt în mod normal precedate
                              cu liniuță de subliniere

en:   --version               print assembler version number and exit
ro:   --version               afișează numărul de versiune al asamblorului și iese

en:   --warn                  don't suppress warnings
ro:   --warn                  nu suprimă avertismentele

en:   -D                      produce assembler debugging messages
ro:   -D                      generează mesajele de depanare ale asamblorului

en:   -EB                     assemble code for a big-endian cpu
ro:   -EB                     asamblează codul pentru un cpu big-endian

en:   -EB                     assemble for a big endian system (default)
      -EL                     assemble for a little endian system
ro:   -EB                     asamblează pentru un sistem big endian (implicit)
      -EL                     asamblează pentru un sistem little endian

en:   -EB  -mbig-endian		generate big-endian output
ro:   -EB  -mbig-endian		generează cod big-endian

en:   -EB,-big                produce big endian code and data
ro:   -EB,-big                produce coduri și date big endian

en:   -EL                     assemble code for a little-endian cpu
ro:   -EL                     asamblează codul pentru un cpu little-endian

en:   -EL  -mlittle-endian		generate little-endian output
ro:   -EL  -mlittle-endian		generează cod little-endian

en:   -EL, -mel or -little    Produce little endian output
      -EB, -meb or -big       Produce big endian output
      -mpic			  Generate PIC
      -mno-fp-as-gp-relax	  Suppress fp-as-gp relaxation for this file
      -mb2bb-relax		  Back-to-back branch optimization
      -mno-all-relax	  Suppress all relaxation for this file
ro:   -EL, -mel or -little    produce ieșire little endian
      -EB, -meb or -big       produce ieșire big endian
      -mpic                   generează PIC
      -mno-fp-as-gp-relax     suprimă relaxarea fp-as-gp pentru acest fișier
      -mb2bb-relax            optimizează ramificațiile back-to-back
      -mno-all-relax          suprimă toate relaxările pentru acest fișier

en:   -EL,-little             produce little endian code and data
ro:   -EL,-little             produce coduri și date little endian

en:   -I DIR                  add DIR to search list for .include directives
ro:   -I DIR                  adaugă DIR la lista de căutare pentru directivele .include

en:   -Ip                     synonym for -ignore-parallel-conflicts
ro:   -Ip                     sinonim cu „-ignore-parallel-conflicts”

en:   -J                      don't warn about signed overflow
ro:   -J                      nu avertizează cu privire la depășirile semnate

en:   -K                      warn when differences altered for long displacements
ro:   -K                      avertizează atunci când diferențele se alterează pentru
                              deplasări lungi

en:   -KPIC                   generate PIC
ro:   -KPIC                   generează codul PIC

en:   -L, --keep-locals       keep local symbols (e.g. starting with `L')
ro:   -L, --keep-locals       păstrează simbolurile locale (de exemplu, cele care încep cu „L”)

en:   -M, --mri               assemble in MRI compatibility mode
ro:   -M, --mri               asamblează în modul de compatibilitate RMN

en:   -N                      Warn when branches are expanded to jumps.
ro:   -N                      avertizează atunci când ramurile sunt extinse la salturi

en:   -O                      try to optimize code.  Implies -parallel
ro:   -O                      încearcă să optimizeze codul.; implică „-parallel”

en:   -O1,			  Optimize for performance
      -Os			  Optimize for space
ro:   -O1,			  optimizează pentru performanță
      -Os			  optimizează pentru spațiu

en:   -Q                      ignored
ro:   -Q                      ignorată

en:   -Q                      ignored
      -V                      print assembler version number
ro:   -Q                      ignorată
      -V                      imprimă numărul versiunii asamblatorului

en:   -Q                      ignored
      -V                      print assembler version number
      -EB/-EL                 generate big-endian/little-endian code
      --32/--64               generate 32bit/64bit code
ro:   -Q                      ignorată
      -V                      imprimă numărul versiunii asamblatorului
      -EB/-EL                 generează cod big-endian/little-endian
      --32/--64               generează cod de 32 biți/64 biți

en:   -Qy, -Qn                ignored
      -V                      print assembler version number
      -k                      ignored
ro:   -Qy, -Qn                ignorată
      -V                      afișează numărul de versiune al asamblorului
      -k                      ignorată

en:   -R                      fold data section into text section
ro:   -R                      pliază secțiunea de date în secțiunea de text

en:   -V                      print assembler version number
      -Qy, -Qn                ignored
ro:   -V                      afișează numărul versiunii asamblorului
      -Qy, -Qn                ignorată

en:   -W, --no-warn           suppress warnings
ro:   -W, --no-warn           suprimă avertismentele

en:   -Wnp                    synonym for -no-warn-explicit-parallel-conflicts
ro:   -Wnp                    sinonim cu „-no-warn-explicit-parallel-conflicts”\n

en:   -Wnuh                   synonym for -no-warn-unmatched-high
ro:   -Wnuh                   sinonim cu „-no-warn-unmatched-high”

en:   -Wp                     synonym for -warn-explicit-parallel-conflicts
ro:   -Wp                     sinonim cu „-warn-explicit-parallel-conflicts”

en:   -Wuh                    synonym for -warn-unmatched-high
ro:   -Wuh                    sinonim cu „-warn-unmatched-high”

en:   -X                      ignored
ro:   -X                      ignorată

en:   -Z                      generate object file even after errors
ro:   -Z                      generează fișierul obiect chiar și după erori

en:   -c                      print a warning if a comment is found
ro:   -c                      afișează un avertisment dacă se găsește un comentariu

en:   -f                      skip whitespace and comment preprocessing
ro:   -f                      omite spațiile albe și preprocesarea comentariilor

en:   -fixed-special-register-names
                              Allow only the original special register names.
ro:   -fixed-special-register-names
                              permite numai numele originale ale registrului special

en:   -force2bsr  -mforce2bsr	transform jbsr to bsr
ro:   -force2bsr  -mforce2bsr	transformă jbsr în bsr

en:   -fpic  -pic			generate position-independent code
ro:   -fpic  -pic			generează cod independent de poziție

en:   -g, --gen-debug         generate debugging information
ro:   -g, --gen-debug         generează informații de depanare

en:   -globalize-symbols      Make all symbols global.
ro:   -globalize-symbols      face ca toate simbolurile să fie globale

en:   -gnu-syntax             Turn off mmixal syntax compatibility.
ro:   -gnu-syntax             dezactivează compatibilitatea sintaxei mmixal

en:   -h, -H                  Don't execute, print this help text.  Deprecated.
ro:   -h, -H                  nu execută, afișează acest text de ajutor; depreciat

en:   -h-tick-hex              Support H'00 style hex constants
ro:   -h-tick-hex              acceptă constantele hexazecimale de tip H'00

en:   -ignore-parallel-conflicts            do not check parallel instructions
ro:   -ignore-parallel-conflicts            nu verifică instrucțiunile paralele

en:   -jsri2bsr  -mjsri2bsr		transform jsri to bsr
ro:   -jsri2bsr  -mjsri2bsr		transformă jsri în bsr

en:   -linker-allocated-gregs If there's no suitable GREG definition for the                          operands of an instruction, let the linker resolve.
ro:   -linker-allocated-gregs dacă nu există o definiție GREG adecvată pentru
                              operanzii unei instrucțiuni, lasă editorul de
                              legături să rezolve acest lucru

en:   -m32r                   disable support for the m32rx instruction set
ro:   -m32r                   dezactivează suportul pentru setul de instrucțiuni m32rx

en:   -m32r2                  support the extended m32r2 instruction set
ro:   -m32r2                  oferă suport pentru setul extins de instrucțiuni m32r2

en:   -m32rx                  support the extended m32rx instruction set
ro:   -m32rx                  oferă suport pentru setul extins de instrucțiuni m32rx

en:   -m4byte-align             Mark the binary as using 32-bit alignment (default)
ro:   -m4byte-align             marchează binarul ca folosind alinierea pe 32 de biți (implicit)

en:   -m8byte-align             Mark the binary as using 64-bit alignment
ro:   -m8byte-align             marchează binarul ca utilizând alinierea pe 64 de biți

en:   -mN - do not insert NOPs after changing interrupts (default)
ro:   -mN - nu inserează NOP-uri după schimbarea întreruperilor (implicit)

en:   -mQ - enable relaxation at assembly time. DANGEROUS!
      -mP - enable polymorph instructions
ro:   -mQ - activează relaxarea în timpul asamblării. PERICULOS!
      -mP - activează instrucțiunile de polimorfe

en:   -mU - for an instruction which changes interrupt state, but where it is not
            known how the state is changed, do not warn/insert NOPs
ro:   -mU - pentru o instrucțiune care modifică starea întreruperii, dar pentru care
            nu se știe cum se modifică starea, nu avertizează/ inserează NOP-uri

en:   -mY - do not warn about missing NOPs after changing interrupts
ro:   -mY - nu avertizează cu privire la lipsa NOP-urilor după schimbarea întreruperilor

en:   -m[no-]%-17sEnable/Disable %s
ro:   -m[no-]%-17sactivează/dezactivează %s

en:   -mach=<name>             Set the H8300 machine type to one of:
                               h8300h, h8300hn, h8300s, h8300sn, h8300sx, h8300sxn
ro:   -mach=<nume>             stabilește tipul de mașină H8300 la unul dintre următoarele:
                               h8300h, h8300hn, h8300s, h8300sn, h8300sx, h8300sxn

en:   -madd-bnd-prefix        add BND prefix for all valid branches
ro:   -madd-bnd-prefix        adaugă prefixul BND pentru toate ramurile valide

en:   -malign-branch-boundary=NUM (default: 0)
                              align branches within NUM byte boundary
ro:   -malign-branch-boundary=NUM (implicit: 0)
                              aliniază ramurile în interiorul limitei de octeți NUM

en:   -malign-branch-prefix-size=NUM (default: 5)
                              align branches with NUM prefixes per instruction
ro:   -malign-branch-prefix-size=NUM (implicit: 5)
                              aliniază ramurile cu NUM prefixe pe instrucțiune

en:   -malign-branch=TYPE[+TYPE...] (default: jcc+fused+jmp)
                              TYPE is combination of jcc, fused, jmp, call, ret,
                               indirect
                              specify types of branches to align
ro:   -malign-branch=TIP[+TIP...] (implicit: jcc+fused+jmp)
                              TIP este o combinație de jcc, fused, jmp, call, ret,
                              indirect
                              specifică tipurile de ramuri care trebuie aliniate

en:   -mall-ext		  Turn on all extensions and instructions support
ro:   -mall-ext		  activează suportul pentru toate extensiile și instrucțiunile

en:   -mall-opcodes    accept all AVR opcodes, even if not supported by MCU
      -mno-skip-bug    disable warnings for skipping two-word instructions
                       (default for avr4, avr5)
      -mno-wrap        reject rjmp/rcall instructions with 8K wrap-around
                       (default for avr3, avr5)
      -mrmw            accept Read-Modify-Write instructions
      -mlink-relax     generate relocations for linker relaxation (default)
      -mno-link-relax  don't generate relocations for linker relaxation.
      -mgcc-isr        accept the __gcc_isr pseudo-instruction.
      -mno-dollar-line-separator
                       do not treat the $ character as a line separator.
ro:   -mall-opcodes    acceptă toate codurile operaționale AVR, chiar dacă nu sunt
                       acceptate de MCU
      -mno-skip-bug    dezactivează avertismentele pentru omiterea instrucțiunilor
                       de două cuvinte (implicit pentru avr4, avr5)
      -mno-wrap        respinge instrucțiunile rjmp/rcall cu înfășurare de 8K
                       (implicit pentru avr3, avr5)
      -mrmw            acceptă instrucțiuni de citire-modificare-scriere
      -mlink-relax     generează realocări pentru relaxarea editorului de legături
                       (implicit)
      -mno-link-relax  nu generează realocări pentru relaxarea editorului de legături
      -mgcc-isr        acceptă pseudo-instrucțiunea __gcc_isr
      -mno-dollar-line-separator
                       nu tratează caracterul $ ca un separator de linie

en:   -mamd64                 accept only AMD64 ISA [default]
ro:   -mamd64                 acceptă doar ISA AMD64 [implicit]

en:   -march=ARCH			select architecture ARCH:
ro:   -march=ARCH			selectează arhitectura ARCH:

en:   -march=ARCH             enable instructions from architecture ARCH
ro:   -march=ARHITECTURA      activează instrucțiunile din arhitectura ARHITECTURA

en:   -march=CPU[,+EXTENSION...]
                              generate code for CPU and EXTENSION, CPU is one of:
ro:   -march=CPU[,+EXTENSIE...]
                              generează codul pentru CPU și EXTENSIE, CPU este unul dintre:

en:   -march=ms1-16-002         allow ms1-16-002 instructions (default)
ro:   -march=ms1-16-002         permite instrucțiuni ms1-16-002 (implicit))

en:   -march=ms1-16-003         allow ms1-16-003 instructions
ro:   -march=ms1-16-003         permite instrucțiuni ms1-16-003

en:   -march=ms1-64-001         allow ms1-64-001 instructions
ro:   -march=ms1-64-001         permite instrucțiuni ms1-64-001

en:   -march=ms2                allow ms2 instructions
ro:   -march=ms2                permite instrucțiuni ms2

en:   -mavxscalar=[128|256] (default: 128)
                              encode scalar AVX instructions with specific vector
                               length
ro:   -mavxscalar=[128|256] (implicit: 128)
                              codifică instrucțiunile scalare AVX cu lungimea
                              specificată a vectorului

en:   -mbig-endian            generate big-endian code
ro:   -mbig-endian            generează cod big-endian

en:   -mbig-obj               generate big object files
ro:   -mbig-obj               generează fișiere de obiecte mari

en:   -mbranch-stub			enable branch stubs for PC-relative calls
ro:   -mbranch-stub			activează cioturile de ramificare pentru apelurile
                            relative la PC

en:   -mbranches-within-32B-boundaries
                              align branches within 32 byte boundary
ro:   -mbranches-within-32B-boundaries
                              aliniază ramurile în interiorul limitei de 32 de octeți

en:   -mcache			enable cache prefetch instruction
ro:   -mcache			activează instrucțiunea de pre-achiziționare a datelor din cache

en:   -mcp				enable coprocessor instructions
ro:   -mcp				activează instrucțiunile co-procesorului

en:   -mcpu=<cpu[-sirevision]> specify the name of the target CPU
ro:   -mcpu=<cpu[-sirevision]> specifică numele CPU-ului țintă

en:   -mcpu=CPU			select processor CPU:
ro:   -mcpu=CPU			selectează procesorul CPU:

en:   -mdata-region={none|lower|upper|either} - select region data will be
        placed in.
ro:   -mdata-region={none|lower|upper|either} - selectează regiunea în care vor fi
        plasate datele

en:   -mdollar-hex            the prefix '$' instead of '0x' is used to indicate literal hexadecimal constants
ro:   -mdollar-hex            prefixul „$” în loc de „0x” este utilizat pentru a indica constante literal hexazecimale

en:   -mdsbt                  code uses DSBT addressing
ro:   -mdsbt                  codul utilizează adresarea DSBT

en:   -mdsp				enable DSP instructions
ro:   -mdsp				activează instrucțiunile DSP

en:   -medsp			enable enhanced DSP instructions
ro:   -medsp			activează instrucțiunile DSP îmbunătățite

en:   -melrw			enable extended lrw (CK800 only)
ro:   -melrw			activează lrw extins (numai pentru CK800)

en:   -mevexlig=[128|256|512] (default: 128)
                              encode scalar EVEX instructions with specific vector
                               length
ro:   -mevexlig=[128|256|512] (implicit: 128)
                              codifică instrucțiunile scalare AVX cu lungimea
                              specificată a vectorului

en:   -mevexrcig=[rne|rd|ru|rz] (default: rne)
                              encode EVEX instructions with specific EVEX.RC value
                               for SAE-only ignored instructions
ro:   -mevexrcig=[rne|rd|ru|rz] (implicit: rne)
                              codifică instrucțiunile EVEX cu o valoare specificată
                              EVEX.RC pentru instrucțiunile ignorate doar de SAE

en:   -mevexwig=[0|1] (default: 0)
                              encode EVEX instructions with specific EVEX.W value
                               for EVEX.W bit ignored instructions
ro:   -mevexwig=[0|1] (implicit: 0)
                              codifică instrucțiunile EVEX cu o valoare EVEX.W
                              specificată pentru instrucțiunile EVEX.W cu bit ignorat

en:   -mextension               enable extension opcode support
ro:   -mextension               activează suportul pentru codul operațional de extensie

en:   -mfdpic                  assemble for the FDPIC ABI
ro:   -mfdpic                  asamblează pentru ABI FDPIC

en:   -mfence-as-lock-add=[no|yes] (default: no)
                              encode lfence, mfence and sfence as
                               lock addl $0x0, (%%{re}sp)
ro:   -mfence-as-lock-add=[no|yes] (implicit: no)
                              codifică lfence, mfence și sfence ca
                              blocare addl $0x0, (%%{re}sp)

en:   -mfloat-abi=ABI		select float ABI:
ro:   -mfloat-abi=ABI		selectează un ABI pentru pentru a lucra cu numere
                            în virgulă mobilă:

en:   -mgcc-abi                 Mark the binary as using the old GCC ABI
ro:   -mgcc-abi                 marchează binarul ca folosind vechiul ABI GCC

en:   -mhard-float			enable hard float instructions
ro:   -mhard-float			activează instrucțiunile în virgulă mobilă hardware

en:   -mhard-float              Mark the binary as using FP insns (default for e2v3 and up)
ro:   -mhard-float              marchează binarul ca folosind instrucțiuni FP (implicit pentru e2v3 și ulterioare)

en:   -mindex-reg             support pseudo index registers
ro:   -mindex-reg             acceptă registrele de pseudo-indexare

en:   -mintel64               accept only Intel64 ISA
ro:   -mintel64               acceptă doar ISA Intel64

en:   -mip2022               restrict to IP2022 insns
ro:   -mip2022               restricționează la instrucțiunile IP2022

en:   -mip2022ext            permit extended IP2022 insn
ro:   -mip2022ext            permite instrucțiuni IP2022 extinse

en:   -mistack			enable interrupt stack instructions
ro:   -mistack			activează instrucțiunile stivei de întreruperi

en:   -ml - enable large code model
ro:   -ml - activează modelul de cod mare

en:   -mlabr  -mliterals-after-br	emit literals after branch instructions
ro:   -mlabr  -mliterals-after-br	emite literali după instrucțiunile de ramificare

en:   -mlaf  -mliterals-after-func	emit literals after each function
ro:   -mlaf  -mliterals-after-func	emite literali după fiecare funcție

en:   -mlfence-after-load=[no|yes] (default: no)
                              generate lfence after load
ro:   -mlfence-after-load=[no|yes] (implicit: no)
                              generează lfence după încărcare

en:   -mlfence-before-indirect-branch=[none|all|register|memory] (default: none)
                              generate lfence before indirect near branch
ro:   -mlfence-before-indirect-branch=[none|all|register|memory] (implici: none)
                              generează lfence înainte de ramura apropiată indirectă

en:   -mlfence-before-ret=[none|or|not|shl|yes] (default: none)
                              generate lfence before ret
ro:   -mlfence-before-ret=[none|or|not|shl|yes] (implicit: none)
                              generează lfence înainte de ret

en:   -mlittle-endian         generate little-endian code
ro:   -mlittle-endian         generează cod little-endian

en:   -mljump			transform jbf, jbt, jbr to jmpi (CK800 only)
ro:   -mljump			transformă jbf, jbt, jbr în jmpi (numai pentru CK800)

en:   -mmp				enable multiprocessor instructions
ro:   -mmp				activează instrucțiunile multiprocesor

en:   -mn - insert a NOP after changing interrupts
ro:   -mn - inserează NOP-uri după schimbarea întreruperilor

en:   -mnaked-reg             don't require `%%' prefix for registers
ro:   -mnaked-reg             nu necesită prefixul „%%” pentru registre

en:   -mno-bcond17		  disable b<cond> disp17 instruction
ro:   -mno-bcond17              dezactivează instrucțiunea b<cond> disp17

en:   -mno-dsbt               code does not use DSBT addressing
ro:   -mno-dsbt               codul nu utilizează adresarea DSBT

en:   -mno-fdpic/-mnopic       disable -mfdpic
ro:   -mno-fdpic/-mnopic       dezactivează -mfdpic

en:   -mno-pic                code addressing is position-dependent
ro:   -mno-pic                adresarea codului este dependentă de poziție

en:   -mno-stld23		  disable st/ld offset23 instruction
ro:   -mno-stld23               dezactivează instrucțiunea st/ld offset23

en:   -mnolrw  -mno-lrw		implement lrw as movih + ori
ro:   -mnolrw  -mno-lrw		implementează lrw ca movih + ori

en:   -momit-lock-prefix=[no|yes] (default: no)
                              strip all lock prefixes
ro:   -momit-lock-prefix=[no|yes] (implicit: no)
                              înlătură toate prefixele de blocare

en:   -moperand-check=[none|error|warning] (default: warning)
                              check operand combinations for validity
ro:   -moperand-check=[none|error|warning] (implicit: warning)
                              verifică validitatea combinațiilor de operanzi

en:   -mpic                   code addressing is position-independent
ro:   -mpic                   adresarea codului este independentă de poziție

en:   -mpid=far               code uses position-independent data addressing,
                                GOT accesses use far DP addressing
ro:   -mpid=far               codul utilizează adresarea datelor independentă de poziție,
                              accesările GOT utilizează adresarea DP îndepărtată

en:   -mpid=near              code uses position-independent data addressing,
                                GOT accesses use near DP addressing
ro:   -mpid=near              codul utilizează adresarea datelor independentă de poziție,
                              accesările GOT utilizează adresarea DP apropiată

en:   -mpid=no                code uses position-dependent data addressing
ro:   -mpid=no                codul utilizează adresarea datelor dependentă de poziție

en:   -mreg-prefix=PREFIX     set a prefix used to indicate register names (default none)
ro:   -mreg-prefix=PREFIX     stabilește un prefix utilizat pentru a indica numele registrelor (implicit niciunul)

en:   -mrelax                   Enable relaxation
ro:   -mrelax                   activează relaxarea

en:   -mrelax                 enable relaxation
ro:   -mrelax                 activează relaxarea

en:   -mrh850-abi               Mark the binary as using the RH850 ABI (default)
ro:   -mrh850-abi               marchează binarul ca utilizând ABI RH850 (implicit)

en:   -msecurity			enable security instructions
ro:   -msecurity			activează instrucțiunile de securitate

en:   -mshared                disable branch optimization for shared code
ro:   -mshared                dezactivează optimizarea ramificării pentru codul partajat

en:   -msilicon-errata=<name>[,<name>...] - enable fixups for silicon errata
      -msilicon-errata-warn=<name>[,<name>...] - warn when a fixup might be needed
       supported errata names: cpu4, cpu8, cpu11, cpu12, cpu13, cpu19
ro:   -msilicon-errata=<nume>[,<nume>...] - activează corecțiile pentru eratele de siliciu
      -msilicon-errata-warn=<nume>[,<nume>...] - avertizează când ar putea fi necesară o corecție
       numele eratelor acceptate: cpu4, cpu8, cpu11, cpu12, cpu13, cpu19

en:   -msoft-float              Mark the binary as not using FP insns (default for pre e2v3)
ro:   -msoft-float              marchează binarul ca neutilizând instrucțiuni FP (implicit pentru procesoare e2v3)

en:   -msse-check=[none|error|warning] (default: none)
                              check SSE instructions
ro:   -msse-check=[none|error|warning] (implicit: none)
                              verifică instrucțiunile SSE

en:   -msse2avx               encode SSE instructions with VEX prefix
ro:   -msse2avx               codifică instrucțiunile SSE cu prefix VEX

en:   -msyntax=[att|intel] (default: att)
                              use AT&T/Intel syntax
ro:   -msyntax=[att|intel] (implicit: att)
                              utilizează sintaxa AT&T/Intel

en:   -mthin-add-sub	  Convert a pair of R_LARCH_ADD32/64 and R_LARCH_SUB32/64 to
    			  R_LARCH_32/64_PCREL as much as possible
    			  The option does not affect the generation of R_LARCH_32_PCREL
    			  relocations in .eh_frame
      -mignore-start-align	  Ignore .align if it is at the start of a section. This option
    			  can't be used when partial linking (ld -r).
ro:   -mthin-add-sub	  convertește o pereche de R_LARCH_ADD32/64 și R_LARCH_SUB32/64
    			  în R_LARCH_32/64_PCREL cât mai mult posibil; opțiunea nu afectează
    			  generarea realocărilor R_LARCH_32_PCREL în .eh_frame
      -mignore-start-align	  ignoră .align dacă este la începutul unei secțiuni;
    			  această opțiune nu poate fi utilizată la legarea parțială (ld -r).

en:   -mtrust			enable trust instructions
ro:   -mtrust			activează instrucțiunile de confianță

en:   -mtune=CPU              optimize for CPU, CPU is one of:
ro:   -mtune=CPU              optimizează pentru CPU, CPU este unul dintre:

en:   -mu - for an instruction which changes interrupt state, but where it is not
            known how the state is changed, warn/insert NOPs (default)
            -mn and/or -my are required for this to have any effect
ro:   -mu - pentru o instrucțiune care modifică starea întreruperii, dar pentru care
            nu se știe cum se modifică starea, avertizează/ inserează NOP-uri (implicit)
            „-mn” și/sau „-my” sunt necesare pentru ca acest lucru să aibă vreun efect

en:   -muse-unaligned-vector-move
                              encode aligned vector move as unaligned vector move
ro:   -muse-unaligned-vector-move
                              codifică mutarea vectorului aliniat ca mutare a vectorului nealiniat

en:   -mv850                    The code is targeted at the v850
ro:   -mv850                    codul vizează v850

en:   -mv850e                   The code is targeted at the v850e
ro:   -mv850e                   codul vizează v850e

en:   -mv850e1                  The code is targeted at the v850e1
ro:   -mv850e1                  codul vizează v850e1

en:   -mv850e2                  The code is targeted at the v850e2
ro:   -mv850e2                  codul vizează v850e2

en:   -mv850e2v3                The code is targeted at the v850e2v3
ro:   -mv850e2v3                codul vizează v850e2v3

en:   -mv850e2v4                Alias for -mv850e3v5
ro:   -mv850e2v4                alias pentru „-mv850e3v5”

en:   -mv850e3v5                The code is targeted at the v850e3v5
ro:   -mv850e3v5                codul vizează v850e3v5

en:   -mvdsp			enable vector DSP instructions
ro:   -mvdsp			activează instrucțiunile DSP vectoriale

en:   -mvexwig=[0|1] (default: 0)
                              encode VEX instructions with specific VEX.W value
                               for VEX.W bit ignored instructions
ro:   -mvexwig=[0|1] (implicit: 0)
                              codifică instrucțiunile VEX cu o valoare VEX.W
                              specificată pentru instrucțiunile VEX.W cu bit ignorat

en:   -mwarn-signed-overflow    Warn if signed immediate values overflow
ro:   -mwarn-signed-overflow    avertizează dacă valorile imediate cu semn sunt depășite

en:   -mwarn-unsigned-overflow  Warn if unsigned immediate values overflow
ro:   -mwarn-unsigned-overflow  avertizează dacă valorile imediate fără semn sunt depășite

en:   -my - warn about missing NOPs after changing interrupts (default)
ro:   -my - avertizează cu privire la lipsa NOP-urilor după schimbarea întreruperilor (implicit)

en:   -n                      do not optimize code alignment
      -O{012s}                attempt some code optimizations
      -q                      quieten some warnings
ro:   -n                      nu optimizează alinierea codului
      -O{012s}                încearcă unele optimizări de cod
      -q                      elimină unele avertismente

en:   -nIp                    synonym for -no-ignore-parallel-conflicts
ro:   -nIp                    sinonim cu „-no-ignore-parallel-conflicts”

en:   -no-bitinst             disallow the M32R2's extended bit-field instructions
ro:   -no-bitinst             nu permite instrucțiunile cu câmp de biți extins M32R2

en:   -no-expand              Do not expand GETA, branches, PUSHJ or JUMP
                              into multiple instructions.
ro:   -no-expand              nu expandează GETA, ramuri, PUSHJ sau JUMP
                              în mai multe instrucțiuni

en:   -no-ignore-parallel-conflicts         check parallel instructions for
ro:   -no-ignore-parallel-conflicts         verifică instrucțiunile paralele pentru

en:   -no-merge-gregs         Do not merge GREG definitions with nearby values.
ro:   -no-merge-gregs         nu fuzionează definițiile GREG cu valori apropiate

en:   -no-pad-sections        do not pad the end of sections to alignment boundaries
ro:   -no-pad-sections        nu se completează sfârșitul secțiunilor până la limitele de aliniere

en:   -no-parallel            disable -parallel
ro:   -no-parallel            dezactivează combinarea instrucțiunilor în paralel

en:   -no-predefined-syms     Do not provide mmixal built-in constants.
                              Implies -fixed-special-register-names.
ro:   -no-predefined-syms     nu furnizează constante încorporate mmixal;
                              implică „-fixed-special-register-names”

en:   -no-warn-explicit-parallel-conflicts  do not warn when parallel
ro:   -no-warn-explicit-parallel-conflicts  nu avertizează atunci când instrucțiunile

en:   -no-warn-unmatched-high do not warn about missing low relocs
ro:   -no-warn-unmatched-high nu avertizează cu privire la lipsa realocărilor scăzute

en:   -nocpp                  ignored
ro:   -nocpp                  ignorată

en:   -nosched                  disable scheduling restrictions
ro:   -nosched                  dezactivează restricțiile de planificare

en:   -o OBJFILE              name the object-file output OBJFILE (default a.out)
ro:   -o FIȘIER_OBIECT        numele fișierului obiect de ieșire FIȘIER_OBIECT (implicit „a.out”)

en:   -parallel               try to combine instructions in parallel
ro:   -parallel               încearcă să combine instrucțiunile în paralel

en:   -relax                  Create linker relaxable code.
ro:   -relax                  creează cod relaxabil pentru editorul de legături

en:   -s                      ignored
ro:   -s                      ignorată

en:   -w                      ignored
ro:   -w                      ignorată

en:   -warn-explicit-parallel-conflicts     warn when parallel instructions
ro:   -warn-explicit-parallel-conflicts     avertizează atunci când instrucțiunile

en:   -warn-unmatched-high    warn when an (s)high reloc has no matching low reloc
ro:   -warn-unmatched-high    avertizează atunci când o realocare ridicată nu are o
                              realocare scăzută corespunzătoare

en:   -x                      Do not warn when an operand to GETA, a branch,
                              PUSHJ or JUMP is not known to be within range.
                              The linker will catch any errors.  Implies
                              -linker-allocated-gregs.
ro:   -x                      nu avertizează atunci când un operand pentru GETA,
                              o ramificare, PUSHJ sau JUMP nu este cunoscut ca fiind
                              în interval; editorul de legături va detecta orice eroare;
                              implică „-linker-allocated-gregs”

en:   -xauto		  automagically remove dependency violations (default)
      -xnone		  turn off dependency violation checking
      -xdebug		  debug dependency violation checker
      -xdebugn		  debug dependency violation checker but turn off
    			  dependency violation checking
      -xdebugx		  debug dependency violation checker and turn on
    			  dependency violation checking
ro:   -xauto		  elimină automat încălcările dependenței (implicit)
      -xnone		  dezactivează verificarea încălcărilor de dependențe
      -xdebug		  depanarea verificatorului de încălcare a dependențelor
      -xdebugn		  depanarea verificatorului de încălcare a dependențelor, dar
    			  dezactivează verificarea încălcării dependențelor
      -xdebugx		  depanarea verificatorului de încălcare a dependențelor și
    			  activează verificarea încălcării dependențelor

en:   @FILE                   read options from FILE
ro:   @FIȘIER                 citește opțiunile din FIȘIER

en:  (default)
ro:  (implicit)

en:  *input_line_pointer == '%c' 0x%02x
ro:  *input_line_pointer == „%c” 0x%02x

en:  AArch64-specific assembler options:
ro:  Opțiuni de asamblare specifice AArch64:

en:  ARM-specific assembler options:
ro:  Opțiuni de asamblare specifice ARM:

en:  Blackfin specific assembler options:
ro:  Opțiuni specifice asamblorului Blackfin:

en:  FR30 specific command line options:
ro:  Opțiuni de linie de comandă specifice FR30:

en:  GNU assembler version %s (%s)
    	 using BFD version %s.
ro:  Asamblorul GNU versiunea %s (%s)
    	 folosind versiunea BFD %s.

en:  H8300-specific assembler options:
ro:  Opțiuni de asamblare specifice H8300:

en:  M32C specific command line options:
ro:  Opțiuni de linie de comandă specifice M32C:

en:  M32R specific command line options:
ro:  Opțiuni de linie de comandă specifice M32R:

en:  MMIX-specific command line options:
ro:  Opțiuni de linie de comandă specifice MMIX:

en:  Meta specific command line options:
ro:  Opțiuni de linie de comandă specifice meta:

en:  MicroBlaze specific assembler options:
ro:  Opțiuni de asamblare specifice MicroBlaze:

en:  RL78 specific command line options:
ro:  Opțiuni de linie de comandă specifice RL80:

en:  RX specific command line options:
ro:  Opțiuni de linie de comandă specifice RX:

en:  Score-specific assembler options:
ro:  Opțiuni de asamblare specifice Score:

en:  V850 options:
ro:  Opțiuni V850:

en:  XSTORMY16 specific command line options:
ro:  Opțiuni specifice liniei de comandă XSTORMY16:

en:  Z8K options:
      -z8001                  generate segmented code
      -z8002                  generate unsegmented code
      -linkrelax              create linker relaxable code
ro:  Opțiuni Z8K:
      -z8001                  generează cod segmentat
      -z8002                  generează cod nesegmentat
      -linkrelax              creează cod relaxabil pentru editorul de legături

en:  branch relocation truncate (0x%x)  [-2^9 ~ 2^9-1]
ro:  trunchiere realocare ramură (0x%x)  [-2^9 ~ 2^9-1]

en:  branch relocation truncate (0x%x) [-2^19 ~ 2^19-1]
ro:  trunchiere realocare ramură (0x%x) [-2^19 ~ 2^19-1]

en:  branch relocation truncate (0x%x) [-2^9 ~ 2^9-1]
ro:  trunchiere realocare ramură (0x%x) [-2^9 ~ 2^9-1]

en: !%s does not use a sequence number
ro: !%s nu utilizează un număr de secvență

en: !samegp reloc against symbol without .prologue: %s
ro: realocare !samegp față de simbolul fără .prologue: %s

en: "%u" (instance number %u of a %s label)
ro: „%u” (numărul de instanță %u al unei etichete %s)

en: ".else" without matching ".if"
ro: „.else” fără „.if” corespondent

en: ".elseif" after ".else"
ro: „.elseif” după „.else”

en: ".elseif" without matching ".if"
ro: „.elseif” fără „.if” corespondent

en: ".endif" without ".if"
ro: „.endif” fără „.if”

en: # Example of `%s' instructions
    	.sect .text
    _start:
ro: # Exemplu de instrucțiuni „%s”
    	.sect .text
    _start:

en: # bars register
ro: # registru de bare

en: # conflicts length
ro: # conflicte cu lungimea

en: #4 not valid on H8/300.
ro: nr.4 nu este valabil pentru H8/300.

en: #<mask>
ro: #<masca>

en: $DPR_BYTE not supported in this context
ro: $DPR_BYTE nu este acceptat în acest context

en: $DPR_GOT not supported in this context
ro: $DPR_GOT nu este acceptat în acest context

en: $DPR_HWORD not supported in this context
ro: $DPR_HWORD nu este acceptat în acest context

en: $DPR_WORD not supported in this context
ro: $DPR_WORD nu este acceptat în acest context

en: $DSBT_INDEX must be used with __c6xabi_DSBT_BASE
ro: $DSBT_INDEX trebuie utilizat cu __c6xabi_DSBT_BASE

en: $DSBT_INDEX not supported in this context
ro: $DSBT_INDEX nu este acceptat în acest context

en: $GOT not supported in this context
ro: $GOT nu este acceptat în acest context

en: $PCR_OFFSET not supported in this context
ro: $PCR_OFFSET nu este acceptat în acest context

en: $dbg and $depc are disabled when DEBUG is off
ro: $dbg și $depc sunt dezactivate atunci când DEBUG este oprit

en: $hi and $lo are disabled when MUL and DIV are off
ro: $hi și $lo sunt dezactivate atunci când MUL și DIV sunt oprite

en: $mb0, $me0, $mb1, and $me1 are disabled when COP is off
ro: $mb0, $me0, $mb1 și $me1 sunt dezactivate atunci când COP este oprit

en: %% operator needs absolute expression
ro: operatorul %% necesită o expresie absolută

en: %%%s() must be outermost term in expression
ro: %%%s() trebuie să fie termenul cel mai îndepărtat din expresie

en: %%hi16/%%lo16 only applies to .short or .hword
ro: %%hi16/%%lo16 se aplică numai la .short sau .hword

en: %%hi8 only applies to .byte
ro: %%hi8 se aplică numai la .byte

en: %d error | %d errors
ro[0]: %d eroare
ro[1]: %d erori
ro[2]: %d de erori

en: %d warning | %d warnings
ro[0]: %d avertisment
ro[1]: %d avertismente
ro[2]: %d de avertismente

en: %d-bit overflow (%+ld)
ro: depășire de %d biți (%+ld)

en: %d-bit overflow (%+lld)
ro: depășire de %d biți (%+lld)

en: %s -- `%s'
ro: %s - „%s”

en: %s -- statement `%s' ignored
ro: %s -- declarația „%s” este ignorată

en: %s NOP inserted
ro: %s NOP inserat

en: %s `%s' already has an alias `%s'
ro: %s „%s” are deja un alias „%s”

en: %s argument must be a string
ro: argumentul %s trebuie să fie un șir

en: %s at operand %d -- `%s'
ro: %s la operandul %d -- „%s”

en: %s directive has no name
ro: directiva %s nu are un nume

en: %s for `%s'
ro: %s pentru „%s”

en: %s for instruction '%s'
ro: %s pentru instrucțiunea „%s”

en: %s howto doesn't match size/pcrel in gas
ro: %s howto nu corespunde dimensiunii/pcrel în «gas»

en: %s instruction does not accept a .b suffix
ro: instrucțiunea %s nu acceptă un sufix .b

en: %s instruction, operand %d doesn't match
ro: instrucțiunea %s, operandul %d nu se potrivește

en: %s is enabled by vle flag
ro: %s este activat de fanionul „vle”

en: %s is not used for the selected target
ro: %s nu este utilizat pentru ținta selectată

en: %s may not occupy the delay slot of another branch insn.
ro: %s nu poate ocupa intervalul de întârziere al unei alte instrucțiuni de ramificare.

en: %s must be %d at operand %d -- `%s'
ro: %s trebuie să fie %d la operandul %d -- „%s”

en: %s must have a constant value
ro: %s trebuie să aibă o valoare constantă

en: %s not disabled by vle flag
ro: %s nu este dezactivat de fanionul „vle”

en: %s not supported in MIPS16 mode
ro: %s nu este acceptat în modul MIPS16

en: %s offset %d out of range %d to %d
ro: %s decalajul %d în afara intervalului de la %d la %d

en: %s out of domain (%ld is not a multiple of %ld)
ro: %s este în afara domeniului (%ld nu este un multiplu de %ld)

en: %s out of domain (%lld is not a multiple of %lld)
ro: %s este în afara domeniului (%lld nu este un multiplu de %lld)

en: %s out of range %d to %d at operand %d -- `%s'
ro: %s în afara intervalului de la %d la %d la operandul %d -- „%s”

en: %s out of range (%ld is not between %ld and %ld)
ro: %s este în afara intervalului (%ld nu este între %ld și %ld)

en: %s out of range (%lld is not between %lld and %lld)
ro: %s este în afara intervalului (%lld nu este între %lld și %lld)

en: %s out of range (0x%llx is not between 0x%llx and 0x%llx)
ro: %s este în afara intervalului (0x%llx nu este între 0x%llx și 0x%llx)

en: %s out of range (0x%lx is not between 0x%lx and 0x%lx)
ro: %s este în afara intervalului (0x%lx nu este între 0x%lx și 0x%lx)

en: %s register same as write-back base
ro: registrul %s este același cu baza de scriere-înapoi

en: %s relocations do not fit in %d byte | %s relocations do not fit in %d bytes
ro[0]: %s realocări nu încap în %d octet
ro[1]: %s realocări nu încap în %d octeți
ro[2]: %s realocări nu încap în %d de octeți

en: %s relocations do not fit in %u byte | %s relocations do not fit in %u bytes
ro[0]: %s realocări nu încap în %u octet
ro[1]: %s realocări nu încap în %u octeți
ro[2]: %s realocări nu încap în %u de octeți

en: %s requires value 0-2 as operand 1
ro: %s necesită valoarea 0-2 ca operand 1

en: %s second argument cannot be a negative number %d
ro: al doilea argument %s nu poate fi un număr negativ %d

en: %s section is supported only by GNU and FreeBSD targets
ro: secțiunea %s este acceptată doar de țintele GNU și FreeBSD

en: %s symbol recursion stopped at second appearance of '%s'
ro: Recursiunea simbolului %s s-a oprit la a doua apariție a „%s”

en: %s unsupported
ro: %s neacceptat

en: %s unsupported as instruction fixup
ro: %s nu este acceptat ca instrucțiune de remediere

en: %s unsupported on this instruction
ro: %s nu este acceptat pe această instrucțiune

en: %s used for a symbol not defined in the same file
ro: %s utilizat pentru un simbol care nu este definit în același fișier

en: %s without %s
ro: %s fără %s

en: %s%d-%s%d expected at operand %d -- `%s'
ro: %s%d-%s%d așteptat la operandul %d -- „%s”

en: %s, %s, generating bad object file
ro: %s, %s, generează un fișier obiect greșit

en: %s, treating warnings as errors
ro: %s, tratează avertismentele ca erori

en: %s: attempt to rotate the PC register
ro: %s: încercare de rotire a registrului PC

en: %s: global symbols not supported in common sections
ro: %s: simbolurile globale nu sunt acceptate în secțiunile comune

en: %s: no such section
ro: %s: nu există o astfel de secțiune

en: %s: output of 1st instruction is the same as an input to 2nd instruction - is this intentional ?
ro: %s: ieșirea primei instrucțiuni este aceeași cu o intrare pentru a doua instrucțiune - este acest lucru intenționat?

en: %s: output of 2nd instruction is the same as an input to 1st instruction - is this intentional ?
ro: %s: ieșirea celei de-a doua instrucțiuni este aceeași cu o intrare pentru prima instrucțiune - este acest lucru intenționat?

en: %s: total time in assembly: %ld.%06ld
ro: %s: timpul total de asamblare: %ld.%06ld

en: %s: unexpected function type: %d
ro: %s: tip de funcție neașteptat: %d

en: %s: unrecognized processor name
ro: %s: nume de procesor nerecunoscut

en: %s: would close weakref loop: %s
ro: %s: ar închide bucla weakref: %s

en: %s:%u: add %d%s at 0x%llx to align %s within %d-byte boundary
ro: %s:%u: adaugă %d%s la 0x%llx pentru a alinia %s în interiorul limitei de %d octeți

en: %s:%u: add %d%s-byte nop at 0x%llx to align %s within %d-byte boundary
ro: %s:%u: adaugă %d%s octeți nop la 0x%llx pentru a alinia %s în interiorul limitei de %d octeți

en: %s:%u: add additional %d%s at 0x%llx to align %s within %d-byte boundary
ro: %s:%u: adaugă un %d%s suplimentar la 0x%llx pentru a alinia %s în interiorul limitei de %d octeți

en: %s:%u: bad return from bfd_install_relocation: %x
ro: %s:%u: returnare greșită de la bfd_install_relocation: %x

en: %s; using default for `%s'
ro: %s; se utilizează valoarea implicită pentru „%s”

en: %u-byte relocation cannot be applied to %u-byte field
ro: realocarea de %u-octeți nu poate fi aplicată la câmpul de %u-octeți

en: '%.*s' instruction not at start of execute packet
ro: instrucțiunea „%.*s” nu se află la începutul pachetului de execuție

en: '%.*s' instruction not in a software pipelined loop
ro: instrucțiunea „%.*s” nu se află într-o buclă în conductă prin software

en: '%.*s' instruction not supported on this architecture
ro: instrucțiunea „%.*s” nu este acceptată pe această arhitectură

en: '%.*s' instruction not supported on this functional unit
ro: instrucțiunea „%.*s” nu este acceptată pe această unitate funcțională

en: '%.*s' instruction not supported on this functional unit for this architecture
ro: instrucțiunea „%.*s” nu este acceptată pe această unitate funcțională pentru această arhitectură

en: '%s' can't be a weak_definition (currently only supported in sections of type coalesced)
ro: „%s” nu poate fi o weak_definition (în prezent este acceptată numai în secțiunile de tip coalescent)

en: '%s' can't be a weak_definition (since it is undefined)
ro: „%s” nu poate fi o weak_definition (deoarece este nedefinită)

en: '%s' is not repeatable. Resulting behavior is undefined.
ro: „%s” nu este repetabil. Comportamentul rezultant este nedefinit.

en: '%s' is only available in DD2.0 or higher.
ro: „%s” este disponibil numai în DD2.0 sau într-o versiune superioară.

en: '%s' may not be bundled with other instructions.
ro: „%s” nu poate fi împachetat cu alte instrucțiuni.

en: '%s' only supports RIP-relative address
ro: „%s” acceptă doar adresa relativă RIP

en: '%s' previously declared as '%s'.
ro: „%s” declarat anterior ca „%s”.

en: '%s': only the NOP instruction can be issued in parallel on the m32r
ro: „%s": numai instrucțiunea NOP poate fi emisă în paralel pe m32r

en: ')' required
ro: „)” este necesară

en: ',' expected
ro: se aștepta „,”

en: 'APSR', 'CPSR' or 'SPSR' expected
ro: se aștepta „APSR”, „CPSR” sau „SPSR”

en: 'ASR' required
ro: se necesită „ASR”

en: 'H' modifier only valid for accumulator registers
ro: modificatorul „H” este valabil numai pentru registrele de acumulator

en: 'L' modifier not valid for this instruction
ro: modificatorul „L” nu este valabil pentru această instrucțiune

en: 'LSL' or 'ASR' required
ro: se necesită „LSL” sau „ASR”

en: 'LSL' required
ro: se necesită „LSL”

en: 'MFC_RdTagMask' (channel 12) is only available in DD2.0 or higher.
ro: „MFC_RdTagMask” (canalul 12) este disponibil numai în DD2.0 sau într-o versiune superioară.

en: 'P', 'N' or 'Z' flags may only be specified when accumulating
ro: fanioanele „P”, „N” sau „Z” pot fi specificate numai atunci când se acumulează

en: 'ROR' shift is not permitted
ro: deplasarea „ROR” nu este permisă

en: 'SPU_RdEventMask' (channel 11) is only available in DD2.0 or higher.
ro: „SPU_RdEventMask” (canalul 11) este disponibil numai în DD2.0 sau într-o versiune superioară.

en: 'UXTW' not allowed here
ro: „UXTW” nu este permis aici

en: 'UXTW' required
ro: se necesită „UXTW”

en: '[' expected
ro: se aștepta „[”

en: '[' expected after PLD mnemonic
ro: se aștepta „[” după codul mnemonic PLD

en: '[' expected after PLI mnemonic
ro: se aștepta „[” după codul mnemonic PLI

en: '\%c' in quoted symbol name; behavior may change in the future
ro: „\%c” în numele simbolului între ghilimele; comportamentul se poate schimba în viitor

en: ']' expected
ro: se aștepta „]”

en: 'd' register must be in range 0-15
ro: registrul „d” trebuie să fie în intervalul 0-15

en: 'q' register must be in range 0-7
ro: registrul „q” trebuie să fie în intervalul 0-7

en: 'rsp' register cannot be used
ro: registrul „rsp” nu poate fi utilizat

en: 's' register must be in range 0-31
ro: registrul „s” trebuie să fie în intervalul 0-31

en: '||' after predicate
ro: „||” după predicat

en: '||' not followed by instruction
ro: „||” nu este urmat de o instrucțiune

en: '||^' without previous SPMASK
ro: „||^” fără SPMASK anterior

en: '}' expected at end of 'option' field
ro: se aștepta „}” la sfârșitul câmpului „option”

en: (PC)+ unpredictable
ro: (PC)+ imprevizibil

en: (Requires %s; requested architecture is %s.)
ro: (Necesită %s; arhitectura solicitată este %s.)

en: (default: att)
ro: (implicit: att)

en: (default: intel)
ro: (implicit: intel)

en: (default: no)
ro: (implicit: „no”)

en: (default: yes)
ro: (implicit: „yes”)

en: (plt) is only valid on branch targets
ro: (plt) este valabilă numai pentru țintele de ramificare

en: (unknown)
ro: (necunoscut)

en: -%s conflicts with the other architecture options, which imply -%s
ro: „-%s” intră în conflict cu celelalte opțiuni de arhitectură, care implică „-%s”

en: -(PC) unpredictable
ro: -(PC) imprevizibil

en: -- unterminated string
ro: -- șir neterminat

en: --absolute-literals option not supported in this Xtensa configuration
ro: opțiunea „--absolute-literals” nu este acceptată în această configurație Xtensa

en: --compress-debug-sections=%s is unsupported
ro: argumentul opțiunii --compress-debug-sections=%s nu este acceptat

en: --compress-debug-sections=zstd: gas is not built with zstd support
ro: „--compress-debug-sections=zstd”: «gas» nu este construit cu suport pentru «zstd»

en: --density option is ignored
ro: opțiunea „--density” este ignorată

en: --fdpic			generate an FDPIC object file
ro: --fdpic			generează un fișier obiect FDPIC

en: --generics is deprecated; use --transform instead
ro: opțiunea „--generics” este depreciată; utilizați în schimb opțiunea „--transform”

en: --gstabs is not supported for ia64
ro: opțiunea „--gstabs” nu este acceptată pentru ia64

en: --no-density option is ignored
ro: opțiunea „--no-density” este ignorată

en: --no-generics is deprecated; use --no-transform instead
ro: opțiunea „--no-generics” este depreciată; utilizați în schimb opțiunea „--no-transform”

en: --no-relax is deprecated; use --no-transform instead
ro: opțiunea „--no-relax” este depreciată; utilizați în schimb opțiunea „--no-transform”

en: --no-underscore is invalid with a.out format
ro: „--no-underscore” nu este validă cu formatul a.out

en: --nops needs a numeric argument
ro: „--nops” necesită un argument numeric

en: --pic is invalid for this object format
ro: „--pic” nu este validă pentru acest format de obiect

en: --relax is deprecated; use --transform instead
ro: opțiunea „--relax” este depreciată; utilizați în schimb opțiunea „--transform”

en: -32			create 32 bit object file
    -64			create 64 bit object file
ro: -32			creează un fișier obiect pe 32 de biți
    -64			creează un fișier obiect pe 64 de biți

en: -32			create o32 ABI object file%s
ro: -32			creează fișierul obiect ABI o32%s

en: -64			create 64 ABI object file%s
ro: -64			creează fișierul obiect ABI 64%s

en: -EL			generate code for a little endian machine
    -EB			generate code for a big endian machine
    --little-endian-data	generate code for a machine having big endian
                            instructions and little endian data.
ro: -EL			generează cod pentru o mașină little endian
    -EB			generează cod pentru o mașină big endian
    --little-endian-data	generează cod pentru o mașină cu instrucțiuni
                            big endian și date little endian

en: -G may not be used in position-independent code
ro: „-G” nu poate fi utilizată în codul independent de poziție

en: -G may not be used with SVR4 PIC code
ro: „-G” nu poate fi utilizată cu codul PIC SVR4

en: -G may not be used with abicalls
ro: „-G” nu poate fi utilizată cu apelurile abi (abicalls)

en: -G n            Put data <= n bytes in the small data area
ro: -G n            pune datele <= n octeți în zona de date mici

en: -G not supported in this configuration
ro: „-G” nu este acceptată în această configurație

en: -K PIC                  set EF_PPC_RELOCATABLE_LIB in ELF flags
ro: -K PIC                  activează EF_PPC_RELOCATABLE_LIB în fanioanele ELF

en: -KPIC			generate PIC
    -V			print assembler version number
    -undeclared-regs	ignore application global register usage without
    			appropriate .register directive (default)
    -no-undeclared-regs	force error on application global register usage
    			without appropriate .register directive
    --dcti-couples-detect	warn when an unpredictable DCTI couple is found
    -q			ignored
    -Qy, -Qn		ignored
    -s			ignored
ro: -KPIC             generează cod PIC
    -V                afișează numărul versiunii asamblorului
    -undeclared-regs  ignoră utilizarea registrului global al aplicației fără
                      directiva .register corespunzătoare (implicit)
    -no-undeclared-regs
                      forțează apariția unei erori la utilizarea registrului global
                      al aplicației fără directiva .register corespunzătoare
    --dcti-couples-detect
                      avertizează atunci când este găsit un cuplu DCTI imprevizibil
    -q                ignorată
    -Qy, -Qn          ignorată
    -s                ignorată

en: -KPIC, -call_shared	generate SVR4 position independent code
    -call_nonpic		generate non-PIC code that can operate with DSOs
    -mvxworks-pic		generate VxWorks position independent code
    -non_shared		do not generate code that can operate with DSOs
    -xgot			assume a 32 bit GOT
    -mpdr, -mno-pdr		enable/disable creation of .pdr sections
    -mshared, -mno-shared   disable/enable .cpload optimization for
                            position dependent (non shared) code
    -mabi=ABI		create ABI conformant object file for:
ro: -KPIC, -call_shared     generează cod SVR4 independent de poziție
    -call_nonpic            generează cod non-PIC care poate opera cu DSO-uri
    -mvxworks-pic           generează cod independent de poziție VxWorks
    -non_shared             nu generează cod care poate opera cu DSO-uri
    -xgot                   presupune un GOT pe 32 de biți
    -mpdr, -mno-pdr         activează/dezactivează crearea de secțiuni .pdr
    -mshared, -mno-shared   dezactivează/activează optimizarea .cpload pentru
                            codul dependent de poziție (nepartajat)
    -mabi=ABI               creează un fișier obiect conform ABI pentru:

en: -Qy, -Qn                ignored
ro: -Qy, -Qn                ignorată

en: -R option not supported on this target.
ro: Opțiunea „-R” nu este acceptată pe această țintă.

en: -TSO			use Total Store Ordering
    -PSO			use Partial Store Ordering
    -RMO			use Relaxed Memory Ordering
ro: -TSO			utilizează ordonarea totală a stocării
    -PSO			utilizează ordonarea parțială a stocării
    -RMO			utilizează ordonarea relaxată a memoriei

en: -V                      print assembler version number
ro: -V                      afișează numărul versiunii asamblorului

en: -a32                    generate ELF32/XCOFF32
ro: -a32                    generează ELF32/XCOFF32

en: -a64                    generate ELF64/XCOFF64
ro: -a64                    generează ELF64/XCOFF64

en: -l			use 1 word for refs to undefined symbols [default 2]
    -pic, -k		generate position independent code
    -S			turn jbsr into jsr
    --pcrel                 never turn PC-relative branches into absolute jumps
    --register-prefix-optional
    			recognize register names without prefix character
    --bitwise-or		do not treat `|' as a comment character
    --base-size-default-16	base reg without size is 16 bits
    --base-size-default-32	base reg without size is 32 bits (default)
    --disp-size-default-16	displacement with unknown size is 16 bits
    --disp-size-default-32	displacement with unknown size is 32 bits (default)
ro: -l                      utilizează 1 cuvânt pentru referințele la simboluri
                            nedefinite [implicit 2]
    -pic, -k                generează cod independent de poziție
    -S                      convertește jbsr în jsr
    --pcrel                 nu convertește niciodată ramurile relative la PC în
                            salturi absolute
    --register-prefix-optional
                            recunoaște numele registrelor fără caracter de prefix
    --bitwise-or            nu tratează „|” ca pe un caracter de comentariu
    --base-size-default-16	registrul de bază fără dimensiune este de 16 biți
    --base-size-default-32	registrul de bază fără dim. este de 32 biți (implicit)
    --disp-size-default-16	deplasarea cu dimensiune necunoscută este de 16 biți
    --disp-size-default-32	deplasarea cu dim. necunoscută este de 32 biți (implicit)

en: -m403                   generate code for PowerPC 403
ro: -m403                   generează cod pentru PowerPC 403

en: -m405                   generate code for PowerPC 405
ro: -m405                   generează cod pentru PowerPC 405

en: -m440                   generate code for PowerPC 440
ro: -m440                   generează cod pentru PowerPC 440

en: -m464                   generate code for PowerPC 464
ro: -m464                   generează cod pentru PowerPC 464

en: -m476                   generate code for PowerPC 476
ro: -m476                   generează cod pentru PowerPC 476

en: -m601                   generate code for PowerPC 601
ro: -m601                   generează cod pentru PowerPC 601

en: -m7400, -m7410, -m7450, -m7455
                            generate code for PowerPC 7400/7410/7450/7455
ro: -m7400, -m7410, -m7450, -m7455
                            generează cod pentru PowerPC 7400/7410/7450/7455

en: -m750cl, -mgekko, -mbroadway
                            generate code for PowerPC 750cl/Gekko/Broadway
ro: -m750cl, -mgekko, -mbroadway
                            generează cod pentru PowerPC 750cl/Gekko/Broadway

en: -m821, -m850, -m860     generate code for PowerPC 821/850/860
ro: -m821, -m850, -m860     generează cod pentru PowerPC 821/850/860

en: -mCPU			equivalent to -march=CPU -mtune=CPU. Deprecated.
    -no-mCPU		don't generate code specific to CPU.
    			For -mCPU and -no-mCPU, CPU must be one of:
ro: -mCPU                   echivalent cu -march=CPU -mtune=CPU; depreciat
    -no-mCPU                nu generează cod specific pentru CPU
                            Pentru -mCPU și -no-mCPU, CPU trebuie să fie unul dintre:

en: -mPIC           Mark generated file as using large position independent code
ro: -mPIC           marchează fișierul generat ca utilizând un cod mare independent de poziție

en: -m[no-]%-16s enable/disable %s architecture extension
ro: -m[no-]%-16s activează/dezactivează extensia arhitecturii %s

en: -ma2                    generate code for A2 architecture
ro: -ma2                    generează cod pentru A2 architecture

en: -maltivec               generate code for AltiVec
ro: -maltivec               generează cod pentru AltiVec

en: -many                   generate code for any architecture (PWR/PWRX/PPC)
ro: -many                   generează cod pentru orice arhitectură (PWR/PWRX/PPC)

en: -march=%s is not compatible with the selected ABI
ro: „-march=%s” nu este compatibilă cu ABI-ul selectat

en: -march=<arch>		set architecture
    -mcpu=<cpu>		set cpu [default %s]
ro: -march=<arch>		stabilește arhitectura
    -mcpu=<cpu>		stabilește cpu-ul [implicit %s]

en: -mbig, -mbig-endian, -be
                            generate code for a big endian machine
ro: -mbig, -mbig-endian, -be
                            generează cod pentru o mașină big endian

en: -mbooke                 generate code for 32-bit PowerPC BookE
ro: -mbooke                 generează cod pentru 32-bit PowerPC BookE

en: -mcell                  generate code for Cell Broadband Engine architecture
ro: -mcell                  generează cod pentru arhitectura Cell Broadband Engine

en: -mcom                   generate code for Power/PowerPC common instructions
ro: -mcom                   generează cod pentru instrucțiunile comune Power/PowerPC

en: -mcpu=<CPU version>       Specify the CPU version
ro: -mcpu=<versiunea CPU>     specifică versiunea CPU

en: -mcrc			generate CRC instructions
    -mno-crc		do not generate CRC instructions
ro: -mcrc                   generează instrucțiuni CRC
    -mno-crc                nu generează instrucțiuni CRC

en: -mdialect=%s is not valid.  Expected normal or pseudoc
ro: -mdialect=%s nu este valid. Se aștepta normal sau pseudoc

en: -mdouble        Mark generated file as using double precision FP insns
ro: -mdouble        marchează fișierul generat ca utilizând instrucțiuni FP de dublă precizie

en: -mdsp			generate DSP instructions
    -mno-dsp		do not generate DSP instructions
ro: -mdsp                   generează instrucțiuni DSP
    -mno-dsp                nu generează instrucțiuni DSP

en: -mdspr2			generate DSP R2 instructions
    -mno-dspr2		do not generate DSP R2 instructions
ro: -mdspr2                 generează instrucțiuni DSP R2
    -mno-dspr2              nu  generează instrucțiuni DSP R2

en: -mdspr3			generate DSP R3 instructions
    -mno-dspr3		do not generate DSP R3 instructions
ro: -mdspr3                 generează instrucțiuni DSP R3
    -mno-dspr3              nu  generează instrucțiuni DSP R3

en: -mdword         Mark generated file as using a 8-byte stack alignment
ro: -mdword         marchează fișierul generat ca utilizând o aliniere a stivei de 8 octeți

en: -me <filename>            Redirect errors to a file
ro: -me <nume-fișier>         redirecționează erorile către un fișier

en: -me300                  generate code for PowerPC e300 family
ro: -me300                  generează cod pentru familia PowerPC e300

en: -me500, -me500x2        generate code for Motorola e500 core complex
ro: -me500, -me500x2        generează cod pentru nucleul complex Motorola e500

en: -me500mc,               generate code for Freescale e500mc core complex
ro: -me500mc,               generează cod pentru nucleul complex Freescale e500mc

en: -me500mc64,             generate code for Freescale e500mc64 core complex
ro: -me500mc64,             generează cod pentru nucleul complex Freescale e500mc64

en: -me5500,                generate code for Freescale e5500 core complex
ro: -me5500,                generează cod pentru nucleul complex Freescale e5500

en: -me6500,                generate code for Freescale e6500 core complex
ro: -me6500,                generează cod pentru nucleul complex Freescale e6500

en: -memb                   set PPC_EMB bit in ELF flags
ro: -memb                   activează bitul PPC_EMB în fanioanele ELF

en: -merrors-to-file <filename>
ro: -merrors-to-file <nume-fișier>

en: -mfar-mode | -mf          Use extended addressing
ro: -mfar-mode | -mf          utilizează adresarea extinsă

en: -mfdpic         Assemble for the FDPIC ABI
ro: -mfdpic         asamblează pentru FDPIC ABI

en: -mfix-loongson2f-jump	work around Loongson2F JUMP instructions
    -mfix-loongson2f-nop	work around Loongson2F NOP errata
    -mfix-loongson3-llsc	work around Loongson3 LL/SC errata
    -mno-fix-loongson3-llsc	disable work around Loongson3 LL/SC errata
    -mfix-vr4120		work around certain VR4120 errata
    -mfix-vr4130		work around VR4130 mflo/mfhi errata
    -mfix-24k		insert a nop after ERET and DERET instructions
    -mfix-cn63xxp1		work around CN63XXP1 PREF errata
    -mfix-r5900		work around R5900 short loop errata
    -mgp32			use 32-bit GPRs, regardless of the chosen ISA
    -mfp32			use 32-bit FPRs, regardless of the chosen ISA
    -msym32			assume all symbols have 32-bit values
    -O0			do not remove unneeded NOPs, do not swap branches
    -O, -O1			remove unneeded NOPs, do not swap branches
    -O2			remove unneeded NOPs and swap branches
    --trap, --no-break	trap exception on div by 0 and mult overflow
    --break, --no-trap	break exception on div by 0 and mult overflow
ro: -mfix-loongson2f-jump   corectează instrucțiunile Loongson2F JUMP
    -mfix-loongson2f-nop    corectează erorile din erata Loongson2F NOP
    -mfix-loongson3-llsc    corectează erorile din erata Loongson3 LL/SC
    -mno-fix-loongson3-llsc dezactivează corectarea erorilor din erata Loongson3 LL/SC
    -mfix-vr4120            corectează erorile din anumite erate VR4120
    -mfix-vr4130            corectează erorile din erata VR4130 mflo/mfhi
    -mfix-24k               inserează un nop după instrucțiunile ERET și DERET
    -mfix-cn63xxp1          corectează erorile din erata CN63XXP1 PREF
    -mfix-r5900             corectează erorile din erata R5900 privind bucla scurtă
    -mgp32                  utilizează GPR pe 32 de biți, indiferent de ISA ales
    -mfp32                  utilizează FPR-uri pe 32 de biți, indiferent de ISA ales
    -msym32                 presupune că toate simbolurile au valori pe 32 de biți
    -O0                     nu elimină NOP-urile nenecesare, nu interschimbă ramurile
    -O, -O1                 elimină NOP-urile nenecesare, nu interschimbă ramurile
    -O2                     elimină NOP-urile nenecesare și interschimbă ramurile
    --trap, --no-break	    capturează excepția la împărțirea la 0 și la depășirea „mult”
    --break, --no-trap      întrerupe excepția la împărțirea la 0 și la depășirea „mult”

en: -mfix-loongson3-llsc	work around Loongson3 LL/SC errata
    -mno-fix-loongson3-llsc	disable work around Loongson3 LL/SC errata, default
ro: -mfix-loongson3-llsc    rezolvă erorile din erata Loongson3 LL/SC
    -mno-fix-loongson3-llsc dezactivează rezolvarea erorile din erata Loongson3 LL/SC, implicit

en: -mfix-loongson3-llsc	work around Loongson3 LL/SC errata, default
    -mno-fix-loongson3-llsc	disable work around Loongson3 LL/SC errata
ro: -mfix-loongson3-llsc    rezolvă erorile din erata Loongson3 LL/SC, implicit
    -mno-fix-loongson3-llsc dezactivează rezolvarea erorile din erata Loongson3 LL/SC

en: -mfpr-32        Mark generated file as only using 32 FPRs
ro: -mfpr-32        marchează fișierul generat ca utilizând doar 32 de FPR-uri

en: -mfpr-64        Mark generated file as using all 64 FPRs
ro: -mfpr-64        marchează fișierul generat ca utilizând toate cele 64 de FPR-uri

en: -mfuture                generate code for 'future' architecture
ro: -mfuture                generează cod pentru arhitectura „viitoare”

en: -mginv			generate Global INValidate (GINV) instructions
    -mno-ginv		do not generate Global INValidate instructions
ro: -mginv                  generează instrucțiuni Global INValidate (GINV)
    -mno-ginv               nu generează instrucțiuni Global INValidate (GINV)

en: -mgpr-32        Mark generated file as only using 32 GPRs
ro: -mgpr-32        marchează fișierul generat ca utilizând doar 32 de GPR-uri

en: -mgpr-64        Mark generated file as using all 64 GPRs
ro: -mgpr-64        marchează fișierul generat ca utilizând toate cele 64 de GPR-uri

en: -mhard-float		allow floating-point instructions
    -msoft-float		do not allow floating-point instructions
    -msingle-float		only allow 32-bit floating-point operations
    -mdouble-float		allow 32-bit and 64-bit floating-point operations
    --[no-]construct-floats	[dis]allow floating point values to be constructed
    --[no-]relax-branch	[dis]allow out-of-range branches to be relaxed
    -mignore-branch-isa	accept invalid branches requiring an ISA mode switch
    -mno-ignore-branch-isa	reject invalid branches requiring an ISA mode switch
    -mnan=ENCODING		select an IEEE 754 NaN encoding convention, either of:
ro: -mhard-float            permite instrucțiuni în virgulă mobilă
    -msoft-float            nu permite instrucțiuni în virgulă mobilă
    -msingle-float          permite numai operații în virgulă mobilă pe 32 de biți
    -mdouble-floa           permite operații în virgulă mobilă pe 32 și 64 de biți
    --[no-]construct-floats [nu] permite construirea valorilor în virgulă mobilă
    --[no-]relax-branch     [nu] permite relaxarea ramurilor aflate în afara intervalului
    -mignore-branch-isa     acceptă ramuri nevalide care necesită o comutare a modului ISA
    -mno-ignore-branch-isa  respinge ramurile nevalide care necesită o comutare a modului ISA
    -mnan=CODIFICARE        selectează o convenție de codificare IEEE 754 NaN, oricare dintre:

en: -minsn32		only generate 32-bit microMIPS instructions
    -mno-insn32		generate all microMIPS instructions
ro: -minsn32                generează numai instrucțiuni microMIPS pe 32 de biți
    -mno-insn32             generează toate instrucțiunile microMIPS

en: -mips1			generate MIPS ISA I instructions
    -mips2			generate MIPS ISA II instructions
    -mips3			generate MIPS ISA III instructions
    -mips4			generate MIPS ISA IV instructions
    -mips5                  generate MIPS ISA V instructions
    -mips32                 generate MIPS32 ISA instructions
    -mips32r2               generate MIPS32 release 2 ISA instructions
    -mips32r3               generate MIPS32 release 3 ISA instructions
    -mips32r5               generate MIPS32 release 5 ISA instructions
    -mips32r6               generate MIPS32 release 6 ISA instructions
    -mips64                 generate MIPS64 ISA instructions
    -mips64r2               generate MIPS64 release 2 ISA instructions
    -mips64r3               generate MIPS64 release 3 ISA instructions
    -mips64r5               generate MIPS64 release 5 ISA instructions
    -mips64r6               generate MIPS64 release 6 ISA instructions
    -march=CPU/-mtune=CPU	generate code/schedule for CPU, where CPU is one of:
ro: -mips1                  generează instrucțiuni MIPS ISA I
    -mips2                  generează instrucțiuni MIPS ISA II
    -mips3                  generează instrucțiuni MIPS ISA III
    -mips4                  generează instrucțiuni MIPS ISA IV
    -mips5                  generează instrucțiuni MIPS ISA V
    -mips32                 generează instrucțiuni MIPS32 ISA
    -mips32r2               generează instrucțiuni MIPS32 versiunea 2 ISA
    -mips32r3               generează instrucțiuni MIPS32 versiunea 3 ISA
    -mips32r5               generează instrucțiuni MIPS32 versiunea 5 ISAs
    -mips32r6               generează instrucțiuni MIPS32 versiunea 6 ISA
    -mips64                 generează instrucțiuni MIPS64 ISA
    -mips64r2               generează instrucțiuni MIPS64 versiunea 2 ISA
    -mips64r3               generează instrucțiuni MIPS64 versiunea 3 ISA
    -mips64r5               generează instrucțiuni MIPS64 versiunea 5 ISA
    -mips64r6               generează instrucțiuni MIPS64 versiunea 6 ISA
    -march=CPU/-mtune=CPU   generează cod/planificare pentru CPU, unde CPU este unul dintre:

en: -mips16			generate mips16 instructions
    -no-mips16		do not generate mips16 instructions
ro: -mips16                 generează instrucțiuni mips16
    -no-mips16              nu generează instrucțiuni mips16

en: -mips16 cannot be used with -micromips
ro: „-mips16” nu poate fi utilizată cu „-micromips”

en: -misa-spec=%s is not valid.  Expected v1, v2, v3, v4 o xbpf
ro: -misa-spec=%s nu este valid. Se aștepta v1, v2, v3, v4 sau xbpf

en: -mlibrary-pic   Mark generated file as using position independent code for libraries
ro: -mlibrary-pic   marchează fișierul generat ca utilizând cod independent de poziție pentru biblioteci

en: -mlibresoc              generate code for Libre-SOC architecture
ro: -mlibresoc              generează cod pentru arhitectura Libre-SOC

en: -mlittle, -mlittle-endian, -le
                            generate code for a little endian machine
ro: -mlittle, -mlittle-endian, -le
                            generează cod pentru o mașină little endian

en: -mljump is ignored for ck801/ck802
ro: „-mljump” este ignorată pentru ck801/ck802

en: -mloongson-cam		generate Loongson Content Address Memory (CAM) instructions
    -mno-loongson-cam	do not generate Loongson Content Address Memory Instructions
ro: -mloongson-cam          generează instrucțiuni Loongson Content Address Memory (CAM)
    -mno-loongson-cam       nu generează instrucțiuni Loongson Content Address Memory (CAM)

en: -mloongson-ext		generate Loongson EXTensions (EXT) instructions
    -mno-loongson-ext	do not generate Loongson EXTensions Instructions
ro: -mloongson-ext          generează instrucțiuni Loongson EXTensions (EXT)
    -mno-loongson-ext       nu generează instrucțiuni Loongson EXTensions (EXT)

en: -mloongson-ext2		generate Loongson EXTensions R2 (EXT2) instructions
    -mno-loongson-ext2	do not generate Loongson EXTensions R2 Instructions
ro: -mloongson-ext2         generează instrucțiunile Loongson EXTensions R2 (EXT2)
    -mno-loongson-ext2      nu generează instrucțiunile Loongson EXTensions R2 (EXT2)

en: -mloongson-mmi		generate Loongson MultiMedia extensions Instructions (MMI) instructions
    -mno-loongson-mmi	do not generate Loongson MultiMedia extensions Instructions
ro: -mloongson-mmi          generează instrucțiuni pentru extensiile Loongson MultiMedia (MMI)
    -mno-loongson-mmi       nu generează instrucțiuni pentru extensiile Loongson MultiMedia (MMI)

en: -mmcu			generate MCU instructions
    -mno-mcu		do not generate MCU instructions
ro: -mmcu                   generează instrucțiuni MCU
    -mno-mcu                nu generează instrucțiuni MCU

en: -mmedia         Mark generated file as using media insns
ro: -mmedia         marchează fișierul generat ca utilizând instrucțiuni multimedia

en: -mmicromips		generate microMIPS instructions
    -mno-micromips		do not generate microMIPS instructions
ro: -mmicromips             generează instrucțiuni microMIPS
    -mno-micromips          nu generează instrucțiuni microMIPS

en: -mmicromips cannot be used with -mips16
ro: „-mmicromips” nu poate fi utilizată cu „-mips16”

en: -mmips16e2		generate MIPS16e2 instructions
    -mno-mips16e2		do not generate MIPS16e2 instructions
ro: -mmips16e2              generează instrucțiuni MIPS16e2
    -mno-mips16e2           nu generează instrucțiuni MIPS16e2

en: -mmsa			generate MSA instructions
    -mno-msa		do not generate MSA instructions
ro: -msa                    generează instrucțiuni MSA
    -mno-msa                nu generează instrucțiuni MSA

en: -mmt			generate MT instructions
    -mno-mt			do not generate MT instructions
ro: -mmt                    generează instrucțiuni MT
    -mno-mt                 nu generează instrucțiuni MT

en: -mmuladd        Mark generated file as using multiply add/subtract insns
ro: -mmuladd        marchează fișierul generat ca utilizând instrucțiuni de adunare/scădere multiple

en: -mno-dword      Mark generated file as using a 4-byte stack alignment
ro: -mno-dword      marchează fișierul generat ca utilizând o aliniere a stivei de 4 octeți

en: -mno-force2bsr is ignored for ck801/ck802
ro: „-mno-force2bsr” este ignorată pentru ck801/ck802

en: -mno-force2bsr is ignored with -mbranch-stub
ro: „-mno-force2bsr” este ignorată cu „-mbranch-stub”

en: -mno-pack       Do not allow instructions to be packed
ro: -mno-pack       nu permite ca instrucțiunile să fie împachetate

en: -mno-regnames           Do not allow symbolic names for registers
ro: -mno-regnames           nu permite nume simbolice pentru registre

en: -mno-solaris            do not generate code for Solaris
ro: -mno-solaris            nu generează cod pentru Solaris

en: -mnopic         Disable -mpic, -mPIC, -mlibrary-pic and -mfdpic
ro: -mnopic         dezactivează „-mpic”, „-mPIC”, „-mlibrary-pic” și „-mfdpic”

en: -mpack          Allow instructions to be packed
ro: -mpack          permite împachetarea instrucțiunilor

en: -mpic           Mark generated file as using small position independent code
ro: -mpic           marchează fișierul generat ca utilizând un cod mic independent de poziție

en: -mpower10, -mpwr10      generate code for Power10 architecture
ro: -mpower10, -mpwr10      generează cod pentru arhitectura Power10

en: -mpower11, -mpwr11      generate code for Power11 architecture
ro: -mpower11, -mpwr11      generează cod pentru arhitectura Power11

en: -mpower4, -mpwr4        generate code for Power4 architecture
ro: -mpower4, -mpwr4        generează cod pentru Power4 architecture

en: -mpower5, -mpwr5, -mpwr5x
                            generate code for Power5 architecture
ro: -mpower5, -mpwr5, -mpwr5x
                            generează cod pentru arhitectura Power5

en: -mpower6, -mpwr6        generate code for Power6 architecture
ro: -mpower6, -mpwr6        generează cod pentru arhitectura Power6

en: -mpower7, -mpwr7        generate code for Power7 architecture
ro: -mpower7, -mpwr7        generează cod pentru arhitectura Power7

en: -mpower8, -mpwr8        generate code for Power8 architecture
ro: -mpower8, -mpwr8        generează cod pentru arhitectura Power8

en: -mpower9, -mpwr9        generate code for Power9 architecture
ro: -mpower9, -mpwr9        generează cod pentru arhitectura Power9

en: -mppc, -mppc32, -m603, -m604
                            generate code for PowerPC 603/604
ro: -mppc, -mppc32, -m603, -m604
                            generează cod pentru PowerPC 603/604

en: -mppc64, -m620          generate code for PowerPC 620/625/630
ro: -mppc64, -m620          generează cod pentru PowerPC 620/625/630

en: -mppc64bridge           generate code for PowerPC 64, including bridge insns
ro: -mppc64bridge           generează cod pentru PowerPC 64, including bridge insns

en: -mpwr                   generate code for POWER (RIOS1)
ro: -mpwr                   generează cod pentru POWER (RIOS1)

en: -mpwrx, -mpwr2          generate code for POWER/2 (RIOS2)
ro: -mpwrx, -mpwr2          generează cod pentru POWER/2 (RIOS2)

en: -mregnames              Allow symbolic names for registers
ro: -mregnames              permite nume simbolice pentru registre

en: -mrelocatable           support for GCC's -mrelocatble option
ro: -mrelocatable           suport pentru opțiunea „-mrelocatble” a GCC

en: -mrelocatable-lib       support for GCC's -mrelocatble-lib option
ro: -mrelocatable-lib       suport pentru opțiunea „-mrelocatble-lib” a GCC

en: -msmartmips		generate smartmips instructions
    -mno-smartmips		do not generate smartmips instructions
ro: -msmartmips             generează instrucțiuni smartmips
    -mno-smartmips          nu generează instrucțiuni smartmips

en: -msoft-float    Mark generated file as using software FP
ro: -msoft-float    marchează fișierul generat ca utilizând software-ul FP

en: -msolaris               generate code for Solaris
ro: -msolaris               generează cod pentru Solaris

en: -mspe                   generate code for Motorola SPE instructions
ro: -mspe                   generează cod pentru instrucțiunile Motorola SPE

en: -mspe2                  generate code for Freescale SPE2 instructions
ro: -mspe2                  generează cod pentru instrucțiunile Freescale SPE2

en: -mtitan                 generate code for AppliedMicro Titan core complex
ro: -mtitan                 generează cod pentru nucleul complex AppliedMicro Titan

en: -mtomcat-debug  Debug tomcat workarounds
ro: -mtomcat-debug  depanarea rezolvărilor tomcat

en: -mtomcat-stats  Print out stats for tomcat workarounds
ro: -mtomcat-stats  afișează statisticile pentru rezolvările tomcat

en: -mvirt			generate Virtualization instructions
    -mno-virt		do not generate Virtualization instructions
ro: -mvirt                  generează instrucțiuni de virtualizare
    -mno-virt               nu generează instrucțiuni de virtualizare

en: -mvle                   generate code for Freescale VLE instructions
ro: -mvle                   generează cod pentru instrucțiunile Freescale VLE

en: -mvsx                   generate code for Vector-Scalar (VSX) instructions
ro: -mvsx                   generează cod pentru instrucțiunile Vector-Scalar (VSX)

en: -mxpa			generate eXtended Physical Address (XPA) instructions
    -mno-xpa		do not generate eXtended Physical Address (XPA) instructions
ro: -mxpa                   generează instrucțiuni de adresă fizică extinsă (XPA)
    -mno-xpa                nu generează instrucțiuni de adresă fizică extinsă (XPA)

en: -n32			create n32 ABI object file%s
ro: -n32			creează fișierul obiect ABI n32%s

en: -nops=count             when aligning, more than COUNT nops uses a branch
ro: -nops=număr            la aliniere, mai mult de NUMĂR nops utilizează o ramură

en: -ppc476-workaround      warn if emitting data to code sections
ro: -ppc476-workaround      avertizează în cazul emiterii de date către secțiunile de cod

en: -u                      ignored
ro: -u                      ignorată

en: .%s outside of %s
ro: .%s în afara lui %s

en: .COMMon length (%d.) < 0! Ignored.
ro: lungimea lui .COMMon (%d.) < 0! Se ignoră.

en: .COMMon length (%ld.) <0! Ignored.
ro: lungimea lui .COMMon (%ld.) <0! Se ignoră.

en: .COMMon length (%lu) out of range ignored
ro: lungimea .COMMon (%lu) este în afara intervalului, ignorată

en: .EQU must use a label
ro: .EQU trebuie să utilizeze o etichetă

en: .EXIT must appear within a procedure
ro: .EXIT trebuie să apară în cadrul unei proceduri

en: .REG expression must be a register
ro: expresia .REG trebuie să fie un registru

en: .REG must use a label
ro: .REG trebuie să utilizeze o etichetă

en: .SCOMMon length (%ld.) <0! Ignored.
ro: lungimea lui .SCOMMon (%ld.) <0! Se ignoră.

en: .abiversion expression does not evaluate to a constant
ro: expresia .abiversion nu se evaluează ca o constantă

en: .abort detected.  Abandoning ship.
ro: .abort detectat. Se abandonează nava.

en: .arch <arch> requires a matching --march=... option
ro: .arch <arch> necesită o opțiune --march=.... corespunzătoare

en: .arch stack is empty
ro: stiva .arch este goală

en: .arch: missing architecture name
ro: .arch: lipsește numele arhitecturii

en: .arch_extension: missing architecture extension
ro: .arch_extension: extensie de arhitectură lipsă

en: .asmfunc pseudo-op only available with -mccs flag.
ro: . pseudo-operatorul .asmfunc este disponibil numai cu fanionul „-mccs”.

en: .asmfunc repeated.
ro: .asmfunc repetat.

en: .asmfunc without function.
ro: .asmfunc fără funcție.

en: .base64 string must have a terminating double quote character
ro: șirul .base64 trebuie să aibă un caracter de ghilimele duble de terminare

en: .base64 string terminated early
ro: șir .base64 terminat mai devreme

en: .base64 string terminated unexpectedly
ro: șir .base64 terminat în mod neașteptat

en: .begin [no-]density is ignored
ro: .begin [no-]density este ignorată

en: .begin directive with no matching .end directive
ro: directivă .begin fără o directivă .end corespondentă

en: .begin directive without a preceding .ent directive
ro: directivă .begin fără o directivă precedentă .ent

en: .begin directive without a preceding .file directive
ro: directivă .begin fără o directivă .file anterioară

en: .begin literal is deprecated; use .literal instead
ro: .begin literal este depreciat; utilizați în schimb .literal

en: .begin/.bend in different segments
ro: .begin/.bend în diferite segmente

en: .bend directive names unknown symbol
ro: directiva .bend numește un simbol necunoscut

en: .bend directive without a preceding .ent directive
ro: directivă .bend fără o directivă precedentă .ent

en: .bend directive without a preceding .file directive
ro: directivă .bend fără o directivă precedentă .file

en: .bss size %d < 0!
ro: dimensiunea .bss %d < 0!

en: .bss size %ld < 0!
ro: dimensiunea .bss %ld < 0!

en: .bss size argument missing
ro: Lipsește argumentul privind dimensiunea .bss

en: .bundle_align_mode alignment too large (maximum %u)
ro: aliniere prea mare .bundle_align_mode (maxim %u)

en: .bundle_lock is meaningless without .bundle_align_mode
ro: .bundle_lock este lipsit de sens fără .bundle_align_mode

en: .bundle_lock sequence at %u bytes, but .bundle_align_mode limit is %u bytes
ro: secvență .bundle_lock la %u octeți, dar limita .bundle_align_mode este de %u octeți

en: .bundle_lock sequence is %u bytes, but bundle size is only %u bytes
ro: .secvența bundle_lock este de %u octeți, dar dimensiunea pachetului este de numai %u octeți

en: .bundle_lock with no matching .bundle_unlock
ro: .bundle_lock fără .bundle_unlock corespondent

en: .bundle_unlock without preceding .bundle_lock
ro: .bundle_unlock fără a fi precedat de .bundle_lock

en: .callinfo is not within a procedure definition
ro: .callinfo nu se află într-o definiție de procedură

en: .cfi_endproc without corresponding .cfi_startproc
ro: .cfi_endproc fără .cfi_startproc corespondent

en: .cfi_fde_data is not supported for this target
ro: .cfi_fde_data nu este acceptată pentru această țintă

en: .cfi_fde_data without corresponding .cfi_startproc
ro: .cfi_fde_data fără .cfi_startproc corespondent

en: .cfi_inline_lsda is not supported for this target
ro: .cfi_inline_lsda nu este acceptată pentru această țintă

en: .cfi_inline_lsda not valid for this frame
ro: .cfi_inline_lsda nu este valabilă pentru acest cadru

en: .cfi_inline_lsda seen for frame without .cfi_lsda
ro: .cfi_inline_lsda văzut pentru cadrul fără .cfi_lsda

en: .cfi_lsda requires encoding and symbol arguments
ro: .cfi_lsda necesită argumente de codificare și simbol

en: .cfi_personality requires encoding and symbol arguments
ro: .cfi_personality necesită argumente de codificare și simbol

en: .cfi_personality_id is not supported for this target
ro: .cfi_personality_id nu este acceptată pentru această țintă

en: .compiler directive missing language and version
ro: lipsește limba și versiunea directivei .compiler

en: .compiler directive missing version
ro: lipsește versiunea directivei .compiler

en: .cpload not in noreorder section
ro: .cpload nu este în secțiunea noreorder

en: .cpu: missing cpu name
ro: .cpu: lipsește numele CPU-ului

en: .cv_%ccomp operand is an undefined symbol: %s
ro: operandul .cv_%ccomp este un simbol nedefinit: %s

en: .def pseudo-op only available with -mccs flag.
ro: . pseudo-operatorul .def este disponibil numai cu fanionul „-mccs”.

en: .def pseudo-op used inside of .def/.endef: ignored.
ro: pseudo-operator .def utilizat în interiorul lui .def/.endef: se ignoră.

en: .def pseudo-op used inside of .def/.endef; ignored
ro: pseudo-operator .def utilizat în interiorul lui .def/.endef; se ignoră

en: .dim pseudo-op used outside of .def/.endef: ignored.
ro: pseudo-operator .dim utilizat în afara lui .def/.endef: se ignoră.

en: .dim pseudo-op used outside of .def/.endef; ignored
ro: pseudo-operator .dim utilizat în afara lui .def/.endef; se ignoră

en: .ef with no preceding .function
ro: .ef fără .function precedentă

en: .end [no-]density is ignored
ro: .end [no-]density este ignorată

en: .end directive has no name
ro: directiva .end nu are un nume

en: .end directive missing or unknown symbol
ro: directiva .end lipsește sau simbol necunoscut

en: .end directive names different symbol than .ent
ro: directiva .end numește un simbol diferit de cel al directivei .ent

en: .end directive names unknown symbol
ro: directiva .end numește un simbol necunoscut

en: .end directive without a preceding .ent directive
ro: directivă .end fără o directivă precedentă .ent

en: .end directive without a preceding .ent directive.
ro: directivă .end fără o directivă precedentă .ent.

en: .end directive without a preceding .file directive
ro: directivă .end fără o directivă precedentă .file

en: .end directive without matching .ent
ro: directivă .end fără corespondență cu o directivă .ent

en: .end not in text section
ro: .end nu este în secțiunea text

en: .end symbol does not match .ent symbol
ro: simbolul .end nu se potrivește cu simbolul .ent

en: .end symbol does not match .ent symbol.
ro: simbolul .end nu se potrivește cu simbolul .ent.

en: .end%c encountered without preceding %s
ro: .end%c întâlnit fără să fie precedat de %s

en: .end%s without preceding .%s
ro: .end%s fără a preceda .%s

en: .endasmfunc pseudo-op only available with -mccs flag.
ro: . pseudo-operatorul .endasmfunc este disponibil numai cu fanionul „-mccs”.

en: .endasmfunc without a .asmfunc.
ro: .endasmfunc fără un .asmfunc.

en: .endasmfunc without function.
ro: .endasmfunc fără funcție.

en: .endef pseudo-op used before .def; ignored
ro: pseudo-operator .endef utilizat înaintea lui .def; se ignoră

en: .endef pseudo-op used outside of .def/.endef: ignored.
ro: pseudo-operator .endef utilizat în afara lui .def/.endef: se ignoră.

en: .endfunc missing for previous .func
ro: .endfunc lipsește pentru .func anterioară

en: .endfunc missing for previous .proc
ro: .endfunc lipsește pentru .proc anterior

en: .ent directive has no name
ro: directiva .ent nu are un nume

en: .ent directive has no symbol
ro: directiva .ent nu are nici un simbol

en: .ent directive without matching .end
ro: directivă .ent fără corespondență cu o directivă .end

en: .ent or .aent not in text section
ro: .ent sau .aent nu se află în secțiunea text

en: .ent or .aent not in text section.
ro: .ent sau .aent nu se află în secțiunea text.

en: .err encountered
ro: .err întâlnită

en: .error directive invoked in source file
ro: directiva .error invocată în fișierul sursă

en: .es without preceding .bs
ro: .es fără .bs precedent

en: .fail %ld encountered
ro: .fail %ld întâlnită

en: .field count '%d' out of range (1 <= X <= 32)
ro: numărul de .field „%d” este în afara intervalului (1 <= X <= 32)

en: .fill size clamped to %d
ro: dimensiune .fill fixată la %d

en: .fmask outside of .ent
ro: .fmask în afara directivei .ent

en: .fnend directive without .fnstart
ro: directiva .fnend fără .fnstart

en: .fpu: missing fpu name
ro: .fpu: nume fpu lipsă

en: .frame outside of .ent
ro: .frame în afara directivei .ent

en: .gnu_attribute %d,%d is incompatible with `%s'
ro: .gnu_attribute %d,%d este incompatibil cu „%s”

en: .gnu_attribute %d,%d is no longer supported
ro: .gnu_attribute %d,%d nu mai este acceptat

en: .gnu_attribute %d,%d is not a recognized floating-point ABI
ro: .gnu_attribute %d,%d nu este un ABI în virgulă mobilă recunoscut

en: .gnu_attribute %d,%d requires `%s'
ro: .gnu_attribute %d,%d necesită „%s”

en: .handler directive has no name
ro: directiva .handler nu are un nume

en: .ifeqs syntax error
ro: eroare de sintaxă .ifeqs

en: .incbin count zero, ignoring `%s'
ro: numărătoarea .incbin este zero, se ignoră „%s”

en: .inst.n operand too big. Use .inst.w instead
ro: operandul .inst.n este prea mare. Utilizați .inst.w în schimb

en: .largecomm supported only in 64bit mode, producing .comm
ro: .largecomm acceptat doar în modul pe 64 de biți, producând .comm

en: .linkonce is not supported for this object file format
ro: .linkonce nu este acceptată pentru acest format de fișier obiect

en: .literal not allowed inside .begin literal region
ro: .literal nu este permis în interiorul regiunii literale .begin

en: .literal_position inside literal directive; ignoring
ro: .literal_position în interiorul directivei literale; se ignoră

en: .ln pseudo-op inside .def/.endef: ignored.
ro: .ln pseudo-operator în interiorul .def/.endef: se ignoră.

en: .loc before .file
ro: .loc înainte de .file

en: .loc outside of .text
ro: .loc în afara lui .text

en: .loc pseudo-op inside .def/.endef: ignored.
ro: pseudo-operator .loc în interiorul .def/.endef: se ignoră.

en: .localentry expression for `%s' does not evaluate to a constant
ro: expresia .localentry pentru „%s” nu se evaluează ca o constantă

en: .localentry expression for `%s' is not a valid power of 2
ro: expresia .localentry pentru „%s” nu este o putere a lui 2 valabilă

en: .longcall pseudo-op seen when not relaxing
ro: pseudo-operator .longcall văzut în afara unei relaxări

en: .longjump pseudo-op seen when not relaxing
ro: pseudo-operator .longjump văzut în afara unei relaxări

en: .machine stack overflow
ro: depășire a stivei .machine

en: .machine stack underflow
ro: depășire negativă a stivei .machine

en: .machinemode stack overflow
ro: depășirea stivei .machinemode

en: .machinemode stack underflow
ro: depășirea limitei inferioare a stivei .machinemode

en: .mask outside of .ent
ro: .mask în afara directivei .ent

en: .mask/.fmask outside of .ent
ro: .mask/.fmask în afara directivei .ent

en: .module is not permitted after generating code
ro: .module nu este permis după generarea codului

en: .module used with unrecognized symbol: %s
ro: .module utilizat cu un simbol nerecunoscut: %s

en: .name directive has no symbol
ro: directiva .name nu are nici un simbol

en: .name directive not in link (.link) section
ro: directiva .name nu se află în secțiunea de legături (.link)

en: .object_arch: missing architecture name
ro: .object_arch: nume de arhitectură lipsă

en: .option pic%d not supported
ro: .option pic%d nu este acceptată

en: .option pic%d not supported in VxWorks PIC mode
ro: .option pic%d nu este acceptată în modul VxWorks PIC

en: .option pop with no .option push
ro: .option pop fără .option push

en: .pdesc directive has no entry symbol
ro: directiva .pdesc nu are niciun simbol de intrare

en: .pdesc directive not in link (.link) section
ro: directiva .pdesc nu se află în secțiunea de legături (.link)

en: .pdesc doesn't match with last .ent
ro: .pdesc nu corespunde cu ultimul .ent

en: .pdesc has a bad entry symbol
ro: .pdesc are un simbol de intrare greșit

en: .popsection without corresponding .pushsection; ignored
ro: .popsection fără .pushsection corespondent; se ignoră

en: .previous without corresponding .section; ignored
ro: .previous fără .section corespondent; se ignoră

en: .profiler pseudo requires at least two operands.
ro: pseudo .profiler necesită cel puțin doi operanzi.

en: .prologue directive without a preceding .ent directive
ro: directivă .prologue fără o directivă precedentă .ent

en: .prologue within prologue
ro: .prolog în interiorul prologului

en: .ref outside .csect
ro: .ref în afara .csect

en: .ref pseudo-op only available with -mccs flag.
ro: . pseudo-operatorul .ref este disponibil numai cu fanionul „-mccs”.

en: .sblock may be used for initialized sections only
ro: .sblock poate fi utilizat numai pentru secțiunile inițializate

en: .scl pseudo-op used outside of .def/.endef: ignored.
ro: pseudo-operator .scl utilizat în afara lui .def/.endef: se ignoră.

en: .scl pseudo-op used outside of .def/.endef; ignored
ro: pseudo-operator .scl utilizat în afara lui .def/.endef; se ignoră

en: .sect: subsection name ignored
ro: .sect: numele subsecțiunii este ignorat

en: .set pop with no .set push
ro: .set pop fără .set push

en: .set syntax invalid
ro: sintaxă nevalidă pentru .set

en: .sframe not supported for target
ro: .sframe nu este acceptată pentru țintă

en: .size expression for %s does not evaluate to a constant
ro: expresia .size pentru %s nu este o constantă

en: .size pseudo-op used outside of .def/.endef: ignored.
ro: pseudo-operator .size utilizat în afara lui .def/.endef: se ignoră.

en: .size pseudo-op used outside of .def/.endef; ignored
ro: pseudo-operator .size utilizat în afara lui .def/.endef; se ignoră

en: .space repeat count is negative, ignored
ro: numărul de repetări .space este negativ, se ignoră

en: .space repeat count is zero, ignored
ro: numărul de repetări .space este zero, se ignoră

en: .space repeat count overflow, ignored
ro: depășirea numărului de repetări .space, se ignoră

en: .space, .nops or .fill specifies non-absolute value
ro: .space, .nops sau .fill specifică o valoare neabsolută

en: .space/.bes repeat count is negative, ignored
ro: Numărul de repetări .space/.bes este negativ, se ignoră

en: .space/.bes repeat count is zero, ignored
ro: Numărul de repetări .space/.bes este zero, se ignoră

en: .stab%c is not supported
ro: .stab%c nu este acceptată

en: .stab%c: description field '%x' too big, try a different debug format
ro: .stab%c: câmpul de descriere „%x” este prea mare, încercați un alt format de depanare

en: .stab%c: ignoring non-zero other field
ro: .stab%c: ignorarea altui câmp diferit de zero

en: .stab%c: missing comma
ro: .stab%c: lipsește virgula

en: .stab%c: missing string
ro: .stab%c: șir lipsă

en: .stabx of storage class stsym must be within .bs/.es
ro: .stabx din clasa de stocare stsym trebuie să fie în .bs/.es

en: .syntax %s requires command-line option `--no-underscore'
ro: .syntax %s necesită opțiunea de linie de comandă „--no-underscore”

en: .syntax %s requires command-line option `--underscore'
ro: .syntax %s necesită opțiunea de linie de comandă „--underscore”

en: .tag pseudo-op used outside of .def/.endef: ignored.
ro: pseudo-operator .tag utilizat în afara lui .def/.endef: se ignoră.

en: .tag pseudo-op used outside of .def/.endef; ignored
ro: pseudo-operator .tag utilizat în afara lui .def/.endef; se ignoră

en: .tag requires a structure tag
ro: .tag necesită o etichetă de structură

en: .tag target '%s' undefined
ro: ținta .tag „%s” nu este definită

en: .tc not in .toc section
ro: .tc nu este în secțiunea .toc

en: .tc with no label
ro: .tc fără etichetă

en: .tc with storage class %d not yet supported
ro: .tc cu clasa de stocare %d nu este acceptat încă

en: .type pseudo-op used outside of .def/.endef: ignored.
ro: pseudo-operator .type utilizat în afara lui .def/.endef: se ignoră.

en: .type pseudo-op used outside of .def/.endef; ignored
ro: pseudo-operator .type utilizat în afara lui .def/.endef; se ignoră

en: .uleb128 only supports constant or subtract expressions
ro: .uleb128 acceptă numai expresii constante sau de scădere

en: .unwind_save does not support this kind of register
ro: .unwind_save nu acceptă acest tip de registru

en: .usect: non-zero alignment flag ignored
ro: .usect: fanion de aliniere diferit de zero, ignorat

en: .usepv directive has no name
ro: directiva .usepv nu are un nume

en: .usepv directive has no type
ro: directiva .usepv nu are un tip

en: .uses does not refer to a local symbol in the same section
ro: .uses nu se referă la un simbol local din aceeași secțiune

en: .uses pseudo-op seen when not relaxing
ro: pseudo-operator .uses văzut atunci când nu se relaxează

en: .uses target does not refer to a local symbol in the same section
ro: ținta .uses nu se referă la un simbol local din aceeași secțiune

en: .val expression is too complex
ro: expresia .val este prea complexă

en: .val pseudo-op used outside of .def/.endef: ignored.
ro: pseudo-operator .val utilizat în afara lui .def/.endef: se ignoră.

en: .val pseudo-op used outside of .def/.endef; ignored
ro: pseudo-operator .val utilizat în afara lui .def/.endef; se ignoră

en: .var may only be used within a macro definition
ro: .var poate fi utilizat numai în cadrul unei definiții macro

en: .vframepsp is meaningless, assuming .vframesp was meant
ro: .vframepsp este lipsit de sens, presupunând că .vframesp a fost înțeles

en: .vliw unavailable when VLIW is disabled.
ro: .vliw nu este disponibilă atunci când VLIW este dezactivată.

en: .warning directive invoked in source file
ro: directiva .warning invocată în fișierul sursă

en: .word %s-%s+%s didn't fit
ro: .word %s-%s+%s nu a încăput

en: .word case-table handling failed: table too large
ro: gestionarea tabelului după majuscule-minuscule .word a eșuat: tabelul este prea mare

en: 0x%llx out of range of signed 32bit displacement
ro: 0x%llx în afara intervalului de deplasare cu semn pe 32 de biți

en: 0x%llx shortened to 0x%llx
ro: 0x%llx prescurtat la 0x%llx

en: 0x%lx out of range of signed 32bit displacement
ro: 0x%lx în afara intervalului de deplasare cu semn pe 32 de biți

en: 0x%lx shortened to 0x%lx
ro: 0x%lx prescurtat la 0x%lx

en: 0x%lx: "%s" type = %ld, class = %d, segment = %d
ro: 0x%lx: „%s” tip = %ld, clasă = %d, segment = %d

en: 128-bit-wide accsess not allowed on selected system register '%s'
ro: accesul pe 128 de biți nu este permis pentru registrul de sistem selectat „%s”

en: 16-bit address isn't allowed in MPX instructions
ro: Adresele pe 16 biți nu este permisă în instrucțiunile MPX.

en: 16-bit addressing unavailable for `%s'
ro: adresarea pe 16 biți nu este disponibilă pentru „%s”

en: 16-bit extension
ro: Extensie pe 16 biți

en: 16-bit instruction is disabled: %s.
ro: Instrucțiunea pe 16 biți este dezactivată: %s.

en: 16-bit jump out of range
ro: salt de 16 biți în afara intervalului

en: 16-bit overflow (%+ld)
ro: depășire pe 16 biți (%+ld)

en: 16-bit relocation used in 8-bit operand
ro: realocare pe 16 biți utilizată în operand pe 8 biți

en: 24-bit overflow (%+ld)
ro: depășire pe 24 de biți (%+ld)

en: 3-bit immediate out of range
ro: valoare imediată pe 3 biți în afara intervalului

en: 32-bit address isn't allowed in 64-bit MPX instructions.
ro: Adresele pe 32 de biți nu sunt permise în instrucțiunile MPX pe 64 de biți.

en: 32-bit conditional branch generated
ro: Ramificare condițională pe 32 de biți generată

en: 32-bit overflow (%+ld)
ro: depășire pe 32 de biți (%+ld)

en: 32bit mode not supported on `%s'.
ro: Modul pe 32 de biți nu este acceptat pe „%s”.

en: 6-bit displacement out of range
ro: deplasare pe 6 biți în afara intervalului

en: 6-bit immediate out of range
ro: valoare imediată pe 6 biți în afara intervalului

en: 62-bit relocation not yet implemented
ro: realocarea de 62 de biți nu este implementată încă

en: 64-bit operator src/dst register must be less than 15
ro: registrul sursă/destinație al operatorului pe 64 de biți trebuie să fie mai mic de 15

en: 64bit mode not supported on `%s'.
ro: Modul pe 64 de biți nu este acceptat pe „%s”.

en: 68040 and 68851 specified; mmu instructions may assemble incorrectly
ro: 68040 și 68851 specificate; instrucțiunile mmu pot asambla incorect

en: 8-bit displacement out of range
ro: deplasare pe 8 biți în afara intervalului

en: 8-bit immediate out of range
ro: valoare imediată pe 8 biți în afara intervalului

en: 8-bit overflow (%+ld)
ro: depășire pe 8 biți (%+ld)

en: 8-bit relocation used in 16-bit operand
ro: realocare pe 8 biți utilizată în operand pe 16 biți

en: 8-bit signed offset out of range (%+ld)
ro: decalaj cu semn pe 8 biți în afara intervalului (%+ld)

en: : Immediate value in cbcond is out of range.
ro: : valoarea imediată din cbcond este în afara intervalului.

en: : Instruction requires frs2 and frsd must be the same register
ro: : instrucțiunea necesită ca frs2 și frsd să fie același registru

en: : PC-relative operand can't be a constant
ro: : operandul PC-relativ nu poate fi o constantă

en: : TLS operand can't be a constant
ro: : operandul TLS nu poate fi o constantă

en: : There are only 32 f registers; [0-31]
ro: : există doar 32 de registre f; [0-31]

en: : There are only 32 single precision f registers; [0-31]
ro: : există doar 32 de registre f de precizie simplă; [0-31]

en: : There are only 64 f registers; [0-63]
ro: : există doar 64 de registre f; [0-63]

en: : asr number must be between 0 and 31
ro: : numărul asr trebuie să fie între 0 și 31

en: : crypto immediate must be between 0 and 31
ro: : crypto imediat trebuie să fie între 0 și 31

en: : expected register name ccr
ro: : se aștepta numele registrului ccr

en: : expected register name pc
ro: : se aștepta numele registrului pc

en: : expected register name r0-r7
ro: : se aștepta numele registrului r0-r7

en: : expecting %asrN
ro: : se aștepta %asrN

en: : expecting crypto immediate
ro: : se aștepta crypto imediat

en: : imm2 immediate operand out of range (0-3)
ro: : operand imediat imm2 în afara intervalului (0-3)

en: : invalid ASI expression
ro: : expresie ASI nevalidă

en: : invalid ASI name
ro: : nume ASI nevalid

en: : invalid ASI number
ro: : număr ASI nevalid

en: : invalid cpreg name
ro: : nume cpreg nevalid

en: : invalid membar mask expression
ro: : expresie de mască membar nevalidă

en: : invalid membar mask name
ro: : nume de mască membar nevalid

en: : invalid membar mask number
ro: : număr de mască membar nevalid

en: : invalid prefetch function expression
ro: : expresie nevalidă a funcției prefetch

en: : invalid prefetch function name
ro: : nume nevalid al funcției prefetch

en: : invalid prefetch function number
ro: : număr nevalid al funcției prefetch

en: : invalid siam mode expression
ro: : expresie nevalidă a modului siam

en: : invalid siam mode number
ro: : număr nevalid al modului siam

en: : non-immdiate imm2 operand
ro: : operand imm2 neimediat

en: : processing macro, real opcode handle not found in hash
ro: : se procesează macro, codul operațional real nu se găsește în hash

en: : unrecognizable ancillary state register
ro: : registru de stare ancilară nerecunoscut

en: : unrecognizable hyperprivileged register
ro: : registru hiperprivilegiat de nerecunoscut

en: : unrecognizable privileged register
ro: : registru privilegiat nerecunoscut

en: :b not permitted; defaulting to :w
ro: :b nu este permis; se trece implicit la :w

en: :lower16: not allowed in this instruction
ro: :lower16: nu este permis în această instrucțiune

en: :operand has too many bits
ro: :operandul are prea mulți biți

en: :operand value(%d) too big for constraint
ro: :valoarea operandului (%d) este prea mare pentru constrângere

en: :unknown relocation constraint size
ro: :dimensiune necunoscută a constrângerii de realocare

en: :upper16: not allowed in this instruction
ro: :upper16: nu este permis în această instrucțiune

en: <abi name>	  specify for ABI <abi name>
ro: <nume abi>	  specific pentru ABI <nume abi>

en: <abi>	          Specify a abi version
    			  <abi> could be v1, v2, v2fp, v2fpp
ro: <abi>	          Specifică o versiune abi
    			  <abi> poate fi v1, v2, v2fp, v2fpp

en: <abi>	  assemble for floating point ABI <abi>
ro: <abi>	  asamblează pentru ABI în virgulă mobilă <abi>

en: <arch name>	  Assemble for architecture <arch name>
    			  <arch name> could be
    			  v3, v3j, v3m, v3f, v3s, v2, v2j, v2f, v2s
ro: <nume-arhitectură>	  Asamblează pentru arhitectura <nume-arhitectură>
    			  <nume-arhitectură>poate fi
    			  v3, v3j, v3m, v3f, v3s, v2, v2j, v2f, v2s

en: <arch name>	  assemble for architecture <arch name>
ro: <nume arhi>	  asamblează pentru arhitectura <nume arhi>

en: <baseline>	  Assemble for baseline <baseline>
    			  <baseline> could be v2, v3, v3m
ro: <linia-bază>	  Asamblează pentru linia de bază <linia-bază>
    			  <linia-bază> poate fi v2, v3, v3m

en: <cpu name>	  assemble for CPU <cpu name>
ro: <nume cpu>	  asamblează pentru CPU-ul <nume cpu>

en: <dsp name>	  assemble for DSP architecture <dsp name>
ro: <nume dsp>	  asamblare pentru arhitectura DSP <nume dsp>

en: <fpu name>	  assemble for FPU architecture <fpu name>
ro: <nume fpu>	  asamblează pentru arhitectura FPU <nume fpu>

en: <freg>	  Specify a FPU configuration
    			  <freg>
    			  0:     8 SP /  4 DP registers
    			  1:    16 SP /  8 DP registers
    			  2:    32 SP / 16 DP registers
    			  3:    32 SP / 32 DP registers
ro: <freg>	  Specifică o configurație FPU
    			  <freg>
    			  0:    registre  8 SP /  4 DP
    			  1:    registre 16 SP /  8 DP
    			  2:    registre 32 SP / 16 DP
    			  3:    registre 32 SP / 32 DP

en: <gnu build note>
ro: <notă de construcție GNU>

en: <label>
ro: <etichetă>

en: <mode>	  controls implicit insertion of IT instructions
ro: <mod>	   controlează inserarea implicită a instrucțiunilor IT

en: <unknown>
ro: <necunoscută>

en: <ver>		  assemble for eabi version <ver>
ro: <ver>		  aasamblează pentru versiunea eabi <ver>

en: ? section flag ignored with G present
ro: fanionul de secțiune ? este ignorat dacă G este prezent

en: @%s is not a complex relocation.
ro: @%s nu este o realocare complexă.

en: @%s operator can be used with `%s', but format is wrong
ro: operatorul @%s poate fi utilizat cu „%s”, dar formatul este greșit

en: @%s operator cannot be used with `%s'
ro: operatorul @%s nu poate fi utilizat cu „%s”

en: @%s operator requires 32-bit base register
ro: operatorul @%s necesită un registru de bază pe 32 de biți

en: @%s operator requires 32-bit dest register
ro: operatorul @%s necesită un registru de destinație pe 32 de biți

en: @%s operator requires 32-bit or 64-bit dest register
ro: operatorul @%s necesită un registru de destinație pe 32 sau 64 de biți

en: @%s operator requires 64-bit dest register
ro: Operatorul @%s necesită un registru de destinație pe 64 de biți

en: @%s operator requires `%seax' as base register
ro: operatorul @%s necesită „%seax”s ca registru de bază

en: @%s operator requires `%seax' as dest register
ro: operatorul @%s necesită „%seax” ca registru de destinație

en: @%s operator requires `%seax/%srax' as base register
ro: operatorul @%s necesită „%seax/%srax” ca registru de bază

en: @%s operator requires `%sebx' as base register
ro: operatorul @%s necesită „%sebx” ca registru de bază

en: @%s operator requires `%sebx' as index register
ro: operatorul @%s necesită „%sebx” ca registru index

en: @%s operator requires `%srdi' as dest register
ro: operatorul @%s necesită „%srdi” ca registru de destinație

en: @%s operator requires `%srip' as base register
ro: operatorul @%s necesită „%srip” ca registru de bază

en: @%s operator requires base register
ro: operatorul @%s necesită registrul de bază

en: @%s operator requires no SIB
ro: operatorul @%s nu necesită SIB

en: @%s operator requires no base register
ro: operatorul @%s nu necesită registru de bază

en: @%s operator requires no base/index register
ro: operatorul @%s nu necesită un registru de bază/index

en: @%s operator requires scale factor of 1
ro: operatorul @%s necesită un factor de scară de 1

en: @%s reloc is not supported with %d-bit output format
ro: realocarea @%s nu este acceptată cu formatul de ieșire pe %d biți

en: @tls may not be used with "%s" operands
ro: @tls nu poate fi utilizat cu operanzi „%s”

en: @tls may only be used in last operand
ro: @tls poate fi utilizat numai în ultimul operand

en: A bignum/flonum may not be a displacement: 0x%llx used
ro: Un număr mare/de virgulă mobilă (bignum/flonum) nu poate fi o deplasare: se utilizează 0x%llx

en: A bignum/flonum may not be a displacement: 0x%lx used
ro: Un număr mare/de virgulă mobilă (bignum/flonum) nu poate fi o deplasare: se utilizează 0x%lx

en: A jump instruction with long immediate detected at the end of the ZOL label @%s
ro: O instrucțiune de salt cu o instrucțiune imediată lungă detectată la sfârșitul etichetei ZOL @%s

en: A non-constant expression is not permitted here
ro: O expresie neconstantă nu este permisă aici

en: A parameter named `%s' already exists for macro `%s'
ro: Un parametru numit „%s” există deja pentru macrocomanda „%s”

en: A status register or status bit name is required
ro: Este necesar un registru de stare sau un nume de bit de stare

en: A0.2,A0.3,A1.2,A1.3 required for QUICKRoT register
ro: A0.2,A0.3,A1.2,A1.3 necesare pentru registrul QUICKRoT

en: AAARG -> unhandled constant reloc: %d
ro: AAARG -> realocare de constantă negestionată: %d

en: ADL mode instruction
ro: instrucțiune pentru modul ADL

en: ADRL used for a symbol not defined in the same file
ro: ADRL utilizat pentru un simbol care nu este definit în același fișier

en: AR %d can only be accessed by %c-unit
ro: AR %d poate fi accesat numai de %c-unit

en: AR register not found in indirect reference
ro: Registrul AR nu se găsește în referința indirectă

en: ARC-specific assembler options:
ro: Opțiuni de asamblare specifice ARC:

en: ARM register expected
ro: se aștepta un registru ARM

en: AUDIO ISA extension
ro: extensie ISA AUDIO

en: AVR Assembler options:
      -mmcu=[avr-name] select microcontroller variant
                       [avr-name] can be:
                       avr1  - classic AVR core without data RAM
                       avr2  - classic AVR core with up to 8K program memory
                       avr25 - classic AVR core with up to 8K program memory
                               plus the MOVW instruction
                       avr3  - classic AVR core with up to 64K program memory
                       avr31 - classic AVR core with up to 128K program memory
                       avr35 - classic AVR core with up to 64K program memory
                               plus the MOVW instruction
                       avr4  - enhanced AVR core with up to 8K program memory
                       avr5  - enhanced AVR core with up to 64K program memory
                       avr51 - enhanced AVR core with up to 128K program memory
                       avr6  - enhanced AVR core with up to 256K program memory
                       avrxmega2 - XMEGA, > 8K, < 64K FLASH, < 64K RAM
                       avrxmega3 - XMEGA, RAM + FLASH < 64K, Flash visible in RAM
                       avrxmega4 - XMEGA, > 64K, <= 128K FLASH, <= 64K RAM
                       avrxmega5 - XMEGA, > 64K, <= 128K FLASH, > 64K RAM
                       avrxmega6 - XMEGA, > 128K, <= 256K FLASH, <= 64K RAM
                       avrxmega7 - XMEGA, > 128K, <= 256K FLASH, > 64K RAM
                       avrtiny   - AVR Tiny core with 16 gp registers
ro: Opțiuni ale asamblorului AVR:
      -mmcu=[nume-avr] selectează varianta microcontrolorului
                       [nume-avr] poate fi:
                       avr1  - nucleu AVR clasic fără RAM de date
                       avr2  - nucleu AVR clasic cu memorie de program de până la 8K
                       avr25 - nucleu AVR clasic cu memorie de program de până la 8K
                               plus instrucțiunea MOVW
                       avr3  - nucleu AVR clasic cu memorie de program de până la 64K
                       avr31 - nucleu AVR clasic cu memorie de program de până la 128K
                       avr35 - nucleu AVR clasic cu memorie de program de până la 64K
                               plus instrucțiunea MOVW
                       avr4  - nucleu AVR îmbunătățit cu o memorie de program de până la 8K
                       avr5  - nucleu AVR îmbunătățit cu o memorie de program de până la 64K
                       avr51 - nucleu AVR îmbunătățit cu o memorie de program de până la 128K
                       avr6  - nucleu AVR îmbunătățit cu o memorie de program de până la 256K
                       avrxmega2 - XMEGA, > 8K, < 64K FLASH, < 64K RAM
                       avrxmega3 - XMEGA, RAM + FLASH < 64K, Flash vizibilă în RAM
                       avrxmega4 - XMEGA, > 64K, <= 128K FLASH, <= 64K RAM
                       avrxmega5 - XMEGA, > 64K, <= 128K FLASH, > 64K RAM
                       avrxmega6 - XMEGA, > 128K, <= 256K FLASH, <= 64K RAM
                       avrxmega7 - XMEGA, > 128K, <= 256K FLASH, > 64K RAM
                       avrtiny   - nucleu AVR Tiny cu 16 registre gp

en: Aborting because statement has "%s"
ro: Se întrerupe deoarece declarația are „%s”

en: Absolute PC-relative value in relaxation code.  Assembler error.....
ro: Valoare absolută relativă la PC în codul de relaxare. Eroare de asamblare.....

en: Absolute value in relaxation code.  Assembler error.....
ro: Valoare absolută în codul de relaxare. Eroare de asamblare.....

en: Accessing `%s' as thread-local object
ro: Accesarea „%s” ca obiect thread-local

en: Accessing function `%s' as thread-local object
ro: Accesarea funcției „%s” ca obiect thread-local

en: Addend to unresolved symbol is not on word boundary.
ro: Adăugare la un simbol nerezolvat și nu la limita cuvântului.

en: Addend to unresolved symbol not on word boundary.
ro: Adăugare la un simbol nerezolvat și nu la limita cuvântului.

en: Address mode *+ARx is not allowed in memory-mapped register addressing.  Resulting behavior is undefined.
ro: Modul de adresare *+ARx nu este permis în adresarea registrelor cu memorie alocată. Comportamentul rezultat este nedefinit.

en: Address mode *+ARx is write-only. Results of reading are undefined.
ro: Modul de adresare *+ARx este numai-de-scriere. Rezultatele citirii sunt nedefinite.

en: Address of immediate operand
ro: Adresa operandului imediat

en: Addressing mode not implemented yet.
ro: Modul de adresare nu este încă implementat.

en: Adjusted signed .word (%#lx) overflows: `switch'-statement too large.
ro: Depășiri .word (%#lx) cu semn ajustate: instrucțiunea „switch” este prea mare.

en: Adjusted signed .word (%ld) overflows: `switch'-statement too large.
ro: Depășiri .word (%ld) cu semn ajustate: instrucțiunea „switch” este prea mare.

en: Alignment (%lu) too large: 15 assumed.
ro: Aliniere (%lu) prea mare: se presupune 15.

en: Alignment must be a power of 2
ro: Alinierea trebuie să fie o putere de 2

en: Alignment negative: 0 assumed
ro: Aliniere negativă: se consideră 0

en: Alignment negative: 0 assumed.
ro: Aliniere negativă: se consideră 0.

en: Alignment too large: %d assumed
ro: Aliniere prea mare: se presupune %d

en: Alignment too large: %d. assumed
ro: Aliniere prea mare: se presupune %d.

en: Alignment too large: %d. assumed.
ro: Aliniere prea mare: se presupune %d.

en: Alpha options:
    -32addr			treat addresses as 32-bit values
    -F			lack floating point instructions support
    -mev4 | -mev45 | -mev5 | -mev56 | -mpca56 | -mev6 | -mev67 | -mev68 | -mall
    			specify variant of Alpha architecture
    -m21064 | -m21066 | -m21164 | -m21164a | -m21164pc | -m21264 | -m21264a | -m21264b
    			these variants include PALcode opcodes
ro: Opțiuni alpha:
    -32addr			tratează adresele ca valori pe 32 de biți
    -F			fără suport pentru instrucțiuni în virgulă mobilă
    -mev4 | -mev45 | -mev5 | -mev56 | -mpca56 | -mev6 | -mev67 | -mev68 | -mall
    			specifică varianta de arhitectură alpha
    -m21064 | -m21066 | -m21164 | -m21164a | -m21164pc | -m21264 | -m21264a | -m21264b
    			aceste variante includ codul operațional PALcode

en: An IMM instruction should not be present in the .s file
ro: O instrucțiune IMM nu trebuie să fie prezentă în fișierul .s

en: An illegal use of delay slot detected at the end of the ZOL label @%s
ro: A fost detectată o utilizare ilegală a slotului de întârziere la sfârșitul etichetei ZOL @%s

en: An immediate value in a source operand is inappropriate
ro: O valoare imediată într-un operand sursă este inadecvată

en: And EXT is combination (+EXT - add, -EXT - remove) of:
ro: Iar EXT este o combinație (+EXT - adăugare, -EXT - eliminare) de:

en: Architecture mismatch on "%s %s".
ro: Nepotrivire de arhitectură pe „%s %s”.

en: Architecture variants are:
ro: Variantele de arhitectură sunt:

en: Argument of .vec_size is expected 4 or 16, actual: %d.
ro: Argumentul lui .vec_size este așteptat să fie 4 sau 16, în prezent: %d.

en: Argument of .vec_size is not a constant.
ro: Argumentul lui .vec_size nu este o constantă.

en: Argument to .BLOCK/.BLOCKZ must be between 0 and 0x3fffffff
ro: Argumentul pentru .BLOCK/.BLOCKZ trebuie să fie cuprins între 0 și 0x3fffffff

en: Argument to .even ignored
ro: Argumentul pentru .even este ignorat

en: Assembler messages:
ro: Mesaje asamblator:

en: At least one PR argument expected
ro: Se așteaptă cel puțin un argument PR

en: At least two PR arguments expected
ro: Se așteaptă cel puțin două argumente PR

en: Attempt to purge non-existing macro `%s'
ro: Încercare de purjare a macrocomenzii inexistente „%s”

en: Attempt to put a common symbol into set %s
ro: Încercare de a introduce un simbol comun în setul %s

en: Attempt to put an undefined symbol into set %s
ro: Încercare de a introduce un simbol nedefinit în setul %s

en: Attempt to redefine register set `%s'
ro: Încercare de redefinire a setului de registre „%s”

en: Attribute name not recognised: %s
ro: Nume de atribut nerecunoscut: %s

en: Auto increment/decrement offset '%ld' is out of range.
ro: Decalajul de incrementare/decrementare automată „%ld” este în afara intervalului.

en: Auxiliary register AR0--AR7 required for indirect
ro: Registrul auxiliar AR0--AR7 este necesar pentru înregistrarea indirectă

en: BAD MUL
ro: MUL GREȘIT

en: BALIGN immediate not 0, 1, 2 or 3 (%lu)
ro: BALIGN imediat nu este 0, 1, 2 sau 3 (%lu)

en: BFD is out of sync with GAS, unhandled well-known section type `%s'
ro: BFD nu este sincronizat cu GAS, tip de secțiune binecunoscut „%s” negestionat

en: BPF options:
      -EL                         generate code for a little endian machine
      -EB                         generate code for a big endian machine
      -mdialect=DIALECT           set the assembly dialect (normal, pseudoc)
      -misa-spec                  set the BPF ISA spec (v1, v2, v3, v4, xbpf)
      -mxbpf                      alias for -misa-spec=xbpf
ro: Opțiuni BPF:
      -EL                         generează cod pentru o mașină little endian
      -EB                         generează cod pentru o mașină big endian
      -mdialect=DIALECT           stabilește dialectul de asamblare (normal, pseudoc)
      -misa-spec                  stabilește specificațiile BPF ISA (v1, v2, v3, v4, xbpf)
      -mxbpf                      alias pentru -misa-spec=xbpf

en: BSPEC already active.  Nesting is not supported.
ro: BSPEC este deja activ. Imbricarea nu este acceptată.

en: BSPEC without ESPEC.
ro: BSPEC fără ESPEC.

en: BSS length (%d) < 0 ignored
ro: lungimea BSS (%d) < 0 este ignorată

en: BSS length (%d.) <0! Ignored.
ro: lungimea BSS (%d.) < 0! Este ignorată.

en: BYTE expression not a pure number
ro: expresia BYTE nu este un număr pur

en: BYTE expression not in the range 0..255
ro: expresia BYTE nu se află în intervalul 0..255

en: Bad .fmask directive
ro: Directivă .fmask greșită

en: Bad .frame directive 1./2. param
ro: Directivă .frame greșită, parametrul 1./2.

en: Bad .frame directive 3./4. param
ro: Directivă .frame greșită, parametrul 3./4.

en: Bad .mask directive
ro: Directivă .mask greșită

en: Bad COFF version '%s'
ro: Versiune COFF incorectă „%s”

en: Bad CPU version '%s'
ro: Versiune CPU incorectă „%s”

en: Bad RA (%d) register for .frame
ro: Registru RA (%d) greșit pentru .frame

en: Bad base register, using $%d.
ro: Registru de bază greșit, folosind $%d.

en: Bad call to MD_ATOF()
ro: Apel greșit la MD_ATOF()

en: Bad call to MD_NTOF()
ro: Apel greșit la MD_NTOF()

en: Bad call to md_atof ()
ro: Apel greșit la md_atof ()

en: Bad call to md_atof () - floating point formats are not supported
ro: Apel greșit la md_atof () - formatele cu virgulă mobilă nu sunt acceptate

en: Bad call to md_atof()
ro: Apel greșit la md_atof()

en: Bad cfg of ginsn of func '%s'
ro: cfg greșit al ginsn al funcției „%s”

en: Bad direct addressing construct %s
ro: Construcție de adresare directă greșită %s

en: Bad displacement %d (require 0--255)
ro: Deplasare greșită %d (necesită 0--255)

en: Bad expression: @%s + %s.
ro: Expresie greșită: @%s + %s.

en: Bad opcode table, broken assembler.
ro: Tabel de coduri operaționale greșite, asamblor defectuos.

en: Bad opcode-table-option, check in file ns32k-opcode.h
ro: Opțiune opcode-table-option greșită, verificați în fișierul ns32k-opcode.h

en: Bad operand
ro: Operand greșit

en: Bad operand for a load instruction: <%s>
ro: Operand greșit pentru o instrucțiune de încărcare: <%s>

en: Bad operand for a store instruction: <%s>
ro: Operand greșit pentru o instrucțiune de stocare: <%s>

en: Bad operand for constant offset
ro: Operand greșit pentru decalaj constant

en: Bad operand value: %s
ro: Valoare operand greșită: %s

en: Bad parameter list for macro `%s'
ro: Listă de parametri incorectă pentru macrocomanda „%s”

en: Bad register name
ro: Nume de registru greșit

en: Bad register name %s
ro: Nume de registru greșit %s

en: Bad register range
ro: Interval de registru incorect

en: Bad relocation fixup type (%d)
ro: Tip greșit de remediere a realocării (%d)

en: Bad relocation type: 0x%02x
ro: Tip de realocare greșit: 0x%02x

en: Bad segment (should be absolute).
ro: Segment greșit (trebuie să fie absolut).

en: Bad segment in expression.
ro: Segment greșit în expresie.

en: Bad sequence number: !%s!%s
ro: Număr de secvență greșit: !%s!%s

en: Bad shift *direction
ro: Deplasare incorectă a *direcției

en: Bad shift mode
ro: Mod de schimbare greșit

en: Bad size
ro: Dmensiune greșită

en: Bad suffix after ':' use {b|w|d} Defaulting to d
ro: Sufix greșit după „:” utilizați {b|w|d}. Se trece implicit la „d”

en: Bad suffix, defaulting to d
ro: Sufix greșit, se folosește valoarea implicită „d”

en: Badly formed address expression
ro: Expresie de adresă formată greșit

en: Banked registers are not available with this architecture.
ro: Registrele în bancuri nu sunt disponibile cu această arhitectură.

en: Big number is too big
ro: Numărul mare este prea mare

en: Bignum not permitted in short literal. Immediate mode assumed.
ro: Numărul mare (bignum) nu este permis în literal scurt (short). Se presupune modul imediat.

en: Bignum too big for %c format; truncated
ro: bignum este prea mare pentru formatul %c; s-a trunchiat

en: Bignum too big for long
ro: bignum este prea mare pentru un număr întreg lung

en: Bit field out of range
ro: Câmp de biți în afara intervalului

en: Both arguments must be substitution symbols
ro: Ambele argumente trebuie să fie simboluri de substituție

en: Both the_insn.HI and the_insn.LO are set : %s
ro: Atât the_insn.HI cât și the_insn.LO sunt activate : %s

en: Brackets in operand field incorrect
ro: Parantezele din câmpul operandului sunt incorecte

en: Branch to unaligned address
ro: Ramificare la o adresă nealiniată

en: Broken assembler.  No assembly attempted.
ro: Asamblor defect. Nu s-a încercat asamblarea.

en: Buggy opcode: `%s' "%s"
ro: Cod operațional cu erori: „%s” „%s”

en: C-SKY ABI v1 (ck510/ck610) does not support -mbranch-stub
ro: C-SKY ABI v1 (ck510/ck610) nu acceptă „-mbranch-stub”

en: C-SKY assembler options:
ro: Opțiunile asamblorului C-SKY:

en: C0 - C15 expected
ro: se aștepta C0 - C15

en: C0 - C7 expected
ro: se aștepta C0 - C7

en: C54x-specific command line options:
ro: Opțiuni de linie de comandă specifice C54x:

en: C8 - C9 expected
ro: se aștepta C8 - C9

en: CDE Coprocessor must be in range 0-7
ro: Coprocesorul CDE trebuie să fie în intervalul 0-7

en: CFI instruction used without previous .cfi_startproc
ro: instrucțiune CFI utilizată fără .cfi_startproc anterior

en: CFI is not supported for this target
ro: CFI nu este acceptată pentru această țintă

en: CFI state restore without previous remember
ro: restaurarea stării CFI fără reamintirea anterioară

en: CPU mode is unsupported by target
ro: modul CPU nu este acceptat de țintă

en: CPU version has already been set
ro: Versiunea CPU a fost deja stabilită

en: CPU11: PC is destination of SR altering instruction
ro: CPU11: PC este destinația instrucțiunii de modificare a SR

en: CPU12: CMP/BIT with PC destination ignores next instruction
ro: CPU12: CMP/BIT cu destinația PC ignoră următoarea instrucțiune

en: CPU13: SR is destination of SR altering instruction
ro: CPU13: SR este destinația instrucțiunii de modificare a SR

en: CPU19: Instruction setting CPUOFF must be followed by a NOP
ro: CPU19: Definirea instrucțiunii CPUOFF trebuie să fie urmată de un NOP

en: CPU8: Stack pointer accessed with an odd offset
ro: CPU8: indicator de stivă accesat cu un decalaj impar

en: CRIS-specific options:
ro: Opțiuni specifice CRIS:

en: C_EFCN symbol for %s out of scope
ro: simbol C_EFCN pentru %s în afara domeniului

en: Calling gen_cond_branch_32 for .arch common_v10_v32
ro: Se apelează gen_cond_branch_32 pentru .arch common_v10_v32

en: Can not do %d byte %srelocation
ro: Nu se poate face realocarea %2$s a octeților %1$d

en: Can not do %d byte pc-relative pic relocation
ro: Nu se poate face relocarea PIC relativă la PC de %d octeți

en: Can not do %d byte pc-relative relocation
ro: Nu se poate face realocarea relativă la PC de %d octeți

en: Can not do %d byte pc-relative relocation for storage type %d
ro: Nu se poate face realocarea de %d octeți relativă la PC pentru tipul de stocare %d

en: Can not do %d byte pic relocation
ro: Nu se poate face realocarea PIC de %d octeți

en: Can not do %d byte relocation
ro: Nu se poate face relocarea a %d octeți

en: Can not do %d byte relocation for storage type %d
ro: Nu se poate face realocarea a %d octeți pentru tipul de stocare %d

en: Can not find match relax hint.  Line: %d
ro: Nu se poate găsi un indiciu de relaxare.  Linia: %d

en: Can not represent %s relocation in this object file format
ro: Nu se poate reprezenta realocarea %s în acest format de fișier obiect

en: Can not set dlx_skip_hi16_flag
ro: Nu se poate stabili dlx_skip_hi16_flag

en: Can't add stop bit to mark end of instruction group
ro: Nu se poate adăuga bitul de oprire pentru a marca sfârșitul grupului de instrucțiuni

en: Can't change spaces within a procedure definition. Ignored
ro: Nu se pot modifica spațiile din cadrul unei definiții de procedură. Se ignoră

en: Can't change subspaces within a procedure definition. Ignored
ro: Nu se pot modifica subspațiile din cadrul unei definiții de procedură. Se ignoră

en: Can't deal with expression; defaulting to %ld
ro: Nu se poate trata expresia; implicit la %ld

en: Can't do flonum short literal: immediate mode used.
ro: Nu se poate utiliza un număr de virgulă mobilă (flonum) într-un literal scurt (short): se utilizează modul imediat.

en: Can't find opcode to match operands
ro: Nu se poate găsi codul operațional care să corespundă operanzilor

en: Can't handle O_big in s390_exp_compare
ro: Nu se poate gestiona O_big în s390_exp_compare

en: Can't redirect stderr to the file '%s'
ro: Nu se poate redirecționa ieșirea de eroare standard: către fișierul „%s”

en: Can't relax difference
ro: Nu se poate relaxa diferența

en: Can't relocate expression
ro: Nu se poate realoca expresia

en: Can't set GP value
ro: Nu se poate stabili valoarea GP

en: Can't set register masks
ro: Nu se pot stabili măștile de registru

en: Can't use long branches on this architecture
ro: Nu se pot folosi ramuri lungi pe această arhitectură

en: Can't work out size of operand.
ro: Nu se poate calcula dimensiunea operandului.

en: Cannot allocate unwind descriptor
ro: Nu se poate aloca descriptorul de derulare

en: Cannot assemble instruction
ro: Nu se poate asambla instrucțiunea

en: Cannot convert `%s' in 16-bit mode
ro: Nu se poate converti „%s” în modul pe 16 biți

en: Cannot convert `%s' with `-momit-lock-prefix=yes' in effect
ro: Nu se poate converti „%s” cu „-momit-lock-prefix=yes” în acțiune

en: Cannot define export symbol: %s
ro: Nu se poate defini simbolul de export: %s

en: Cannot define static symbol: %s
ro: Nu se poate defini un simbol static: %s

en: Cannot express %s%d%s relocation
ro: Nu se poate exprima realocarea %s%d%s

en: Cannot find relocation type for symbol %s, code %d
ro: Nu se poate găsi tipul de realocare pentru simbolul %s, cod %d

en: Cannot generate relocation type for symbol %s, code %s
ro: Nu se poate genera tipul de realocare pentru simbolul %s, cod %s

en: Cannot handle fixup
ro: Nu se poate gestiona corecția

en: Cannot make %s relocation PC relative
ro: Nu se poate face realocarea %s relativă la PC

en: Cannot represent %s relocation in object file
ro: Nu se poate reprezenta realocarea %s în fișierul obiect

en: Cannot represent exponent in %d bits
ro: Nu se poate reprezenta exponentul în %d biți

en: Cannot represent relocation type %s
ro: Nu se poate reprezenta tipul de realocare %s

en: Cannot use POPM to restore the SR register
ro: Nu se poate utiliza POPM pentru a restabili registrul SR

en: Cannot use special register with this instruction
ro: Nu se poate utiliza registrul special cu această instrucțiune

en: Case value %ld unexpected at line %d of file "%s"
ro: Valoarea cazului %ld neașteptată la linia %d a fișierului „%s”

en: Changing of CPU version on the fly not supported
ro: Schimbarea din mers a versiunii CPU nu este acceptată

en: Changing processor generation on fly not supported...
ro: Schimbarea din mers a generației procesorului nu este acceptată...

en: Chose GP value of %lx
ro: Alege valoarea GP de %lx

en: Closing bracket missing
ro: Lipsește paranteza de închidere

en: Comma and symbol expected for '.asg STRING, SYMBOL'
ro: Se așteptau virgulă și simbol pentru „.asg ȘIR, SIMBOL”

en: Comma and symbol expected for '.eval EXPR, SYMBOL'
ro: Se așteptau virgulă și simbol pentru „.eval EXPRESIE, SIMBOL”

en: Comma expected
ro: Se aștepta o virgulă

en: Comma expected
ro: Se aștepta o virgulă

en: Comma expected after section name
ro: Se aștepta o virgulă după numele secțiunii

en: Command-line value overrides ".cpu" directive
ro: Valoarea din linia de comandă suprascrie directiva „.cpu”

en: Common alignment negative; 0 assumed
ro: Aliniere comună negativă; se consideră 0

en: Common alignment not a power of 2
ro: Alinierea comună nu este o putere a lui 2

en: Complex expression not supported
ro: Expresia complexă nu este acceptată

en: Complicated LAPC target operand is not a multiple of two.  Use LAPC.D
ro: Operandul țintă LAPC complicat nu este un multiplu de doi. Utilizați LAPC.D

en: Condition "%s" does not match preceding group
ro: Condiția "%s" nu coincide cu grupul precedent

en: Condition "%s" uses a different accumulator from a preceding condition
ro: Condiția „%s” utilizează un acumulator diferit de o condiție anterioară

en: Condition <%c%c> in structured control directive can not be encoded correctly
ro: Condiția <%c%c> din directiva de control structurat nu poate fi codificată corect

en: Constant expression %d out of range, [%d, %d].
ro: Expresia constantă %d în afara intervalului, [%d, %d].

en: Conversion of PC relative BSR to absolute JSR
ro: Conversia BSR relativă la PC în JSR absolută

en: Conversion of PC relative branch to absolute jump
ro: Conversia BSR relativă la PC în salt (jump) absolut

en: Conversion of PC relative conditional branch to absolute jump
ro: Conversia ramurii condiționale relative la PC în salt absolut

en: Conversion of PC relative displacement to absolute
ro: Conversia deplasării relative la PC în absolută

en: Copyright (C) 2025 Free Software Foundation, Inc.
ro: Drepturi de autor © 2025 Free Software Foundation, Inc.

en: Could not set architecture and machine
ro: Nu s-a putut stabili arhitectura și mașina

en: Could not set architecture and machine.
ro: Nu s-a putut stabili arhitectura și mașina.

en: Couldn't generate extension instruction opcodes
ro: Nu s-au putut genera codurile operaționale ale instrucțiunilor de extensie

en: Creating sections with .xdataN/.xrealN/.xstringZ is deprecated.
ro: Crearea secțiunilor cu .xdataN/.xrealN/.xstringZ este depreciată.

en: Current section is uninitialized, section name required for .clink
ro: Secțiunea curentă este neinițializată, numele secțiunii este necesar pentru .clink

en: D register out of range for selected VFP version
ro: Registrul D este în afara intervalului pentru versiunea VFP selectată

en: D10V options:
    -O                      Optimize.  Will do some operations in parallel.
    --gstabs-packing        Pack adjacent short instructions together even
                            when --gstabs is specified.  On by default.
    --no-gstabs-packing     If --gstabs is specified, do not pack adjacent
                            instructions together.
ro: Opțiuni D10V:
    -O                      optimizează; va efectua unele operații în paralel
    --gstabs-packing        împachetează instrucțiunile scurte adiacente împreună
                            chiar și atunci când este specificată „--gstabs”;
                            activată în mod implicit
    --no-gstabs-packing     dacă este specificată „--gstabs”, nu împachetează
                            instrucțiunile adiacente împreună

en: DSP RAM pointer in incorrect unit
ro: indicator RAM DSP într-o unitate incorectă

en: DSP extension
ro: extensie DSP

en: Dangerous simultaneous use of `f%d' and `f%d'
ro: Utilizare simultană periculoasă a „f%d” și „f%d”

en: Default target `%s' is not supported.
ro: Ținta implicită „%s” nu este acceptată.

en: Delayed branches not available on SH1
ro: Ramurile întârziate nu sunt disponibile pe SH1

en: Deprecated S390 options:
      -Aesa                   assemble for processor IBM S/390 G5 (g5/arch3)
      -Aesame                 assemble for processor IBM zSeries 900 (z900/arch5)
ro: Opțiuni S390 depreciate:
      -Aesa                   asamblează pentru procesorul IBM S/390 G5 (g5/arch3)
      -Aesame                 asamblează pentru procesorul IBM zSeries 900 (z900/arch5)

en: Deprecated syntax.
ro: Sintaxă depreciată.

en: Destination accumulator for each part of this parallel instruction must be different
ro: Acumulatorul de destinație pentru fiecare parte a acestei instrucțiuni paralele trebuie să fie diferit

en: Destination register must be ARn
ro: Registrul de destinație trebuie să fie ARn

en: Destination register must be R0 or R1
ro: Registrul de destinație trebuie să fie R0 sau R1

en: Destination register must be R2 or R3
ro: Registrul de destinație trebuie să fie R2 sau R3

en: Destination registers may not be the same
ro: Registrele de destinație ar putea să nu fie aceleași

en: Different arguments of .vec_size are found, previous %d, current %d
ro: Sunt găsite argumente diferite ale .vec_size, anterior %d, actual %d

en: Direct value of %ld is not suitable
ro: Valoarea directă a %ld nu este adecvată

en: Directive invalid within a bundle
ro: Directivă nevalidă în cadrul unui pachet

en: Displacement length %s ignored!
ro: Lungimea de deplasare %s este ignorată!

en: Displacement too large for :d
ro: Deplasare prea mare pentru :d

en: Displacement value of %ld is too large
ro: Valoarea de deplasare a %ld este prea mare

en: Divide instructions support
ro: Suport pentru instrucțiuni de divizare

en: Don't know how to figure out width of %c in md_assemble()
ro: Nu se știe cum să se afle lățimea lui %c în md_assemble()

en: Don't know how to handle this field. %s
ro: Nu se știe cum să se gestioneze acest câmp. %s

en: Don't know how to relocate plain operands of type %s
ro: Nu se știe cum să se realoce operanzii simpli de tip %s

en: Dot Product instructions cannot be conditional,  the behaviour is UNPREDICTABLE
ro: Instrucțiunile scalare ale produsului nu pot fi condiționale, comportamentul este IMPREVIZIBIL

en: Duplicate %s conditional
ro: Condițional %s duplicat

en: Duplicate equal sign (=) in instruction
ro: Semnul egal (=) duplicat în instrucțiune

en: Duplicate predicate register ignored
ro: Registrul de predicat duplicat este ignorat

en: EBCDIC constants are not supported
ro: constantele EBCDIC nu sunt acceptate

en: ECOFF debugging is disabled.
ro: Depanarea ECOFF este dezactivată.

en: ELF options:
    -k -pic			enable PIC mode
    -Q[y|n]			ignored
ro: Opțiuni ELF:
    -k -pic         activează modul PIC
    -Q[y|n]         ignorată

en: ENDLOOP without corresponding LOOP
ro: ENDLOOP fără LOOP corespondent

en: EPIPHANY specific command line options:
ro: Opțiuni de linie de comandă specifice EPIPHANY:

en: ESPEC without preceding BSPEC
ro: ESPEC fără BSPEC precedent

en: Empty argument of .endp
ro: Argument gol în .endp

en: Empty argument of .proc
ro: Argument gol pentru .proc

en: Epilogue count of %lu exceeds number of nested prologues (%u)
ro: Numărul de epiloguri de %lu depășește numărul de prologuri imbricate (%u)

en: Equal parallel destination registers, one result will be discarded
ro: Registre de destinație paralele egale, un rezultat va fi eliminat

en: Error %s in %s
ro: Eroare %s în %s

en: Error in argument %d.  Expecting:  "%s"
ro: Eroare în argumentul %d. Se aștepta:  „%s”

en: Error in expression
ro: Eroare în expresie

en: Error in statement syntax
ro: Eroare în sintaxa declarației

en: Error setting flags for "%s": %s
ro: Eroare la stabilirea fanioanelor pentru „%s”: %s

en: Error:
ro: Eroare:

en: Even number required. Rounded to %d
ro: Se necesită un număr par. Se rotunjește la %d

en: Even register not allowed here
ro: Registrul par nu este permis aici

en: Executing %s in IU in reverse serial may not work
ro: Executarea lui %s în IU în serie inversă poate să nu funcționeze

en: Executing %s in IU may not work
ro: Executarea lui %s în IU poate să nu funcționeze

en: Executing %s in IU may not work in parallel execution
ro: Executarea lui %s în IU poate să nu funcționeze în execuție paralelă

en: Executing %s in reverse serial with %s may not work
ro: Executarea lui %s în serie inversă cu %s s-ar putea să nu funcționeze

en: Expected '('
ro: Se aștepta „(”

en: Expected ')'
ro: Se aștepta „)”

en: Expected ':'
ro: Se aștepta „:”

en: Expected '['
ro: Se aștepta „[”

en: Expected ']'
ro: Se aștepta „]”

en: Expected comma after common length
ro: Se aștepta o virgulă după lungimea comună

en: Expected comma after name
ro: Se aștepta virgulă după nume

en: Expected comma after name "%s"
ro: Se aștepta o virgulă după numele „%s”

en: Expected comma after symbol-name
ro: Se aștepta o virgulă după numele simbolului

en: Expected comma after symbol-name: rest of line ignored.
ro: Se aștepta virgulă după numele simbolului: restul rândului este ignorat.

en: Expected immediate expression
ro: Se aștepta o expresie imediată

en: Expected quoted string
ro: Se aștepta un șir între ghilimele

en: Expected register, got '%s'.
ro: Se aștepta registrul, dar s-a primit „%s”.

en: Expected separator `='
ro: Se aștepta separatorul „=”

en: Expected simple number.
ro: Se aștepta un număr simplu.

en: Expecting '%c'
ro: Se aștepta „%c”

en: Expecting a constant value
ro: Se așteaptă o valoare constantă

en: Expecting a register name
ro: Se așteaptă un nume de registru

en: Expecting a register.
ro: Se aștepta un registru.

en: Expecting character constant argument
ro: Se aștepta un argument de constantă a caracterului

en: Expecting comma after CPU errata name, not: %s
ro: Se aștepta virgulă după numele eratei CPU, nu: %s

en: Expecting operand after ','
ro: Se aștepta un operand după „,”

en: Expecting operand after ','; got nothing
ro: Se aștepta un operand după „,”; nu s-a primit nimic

en: Expecting operand before ','; got nothing
ro: Se aștepta un operand înainte de „,”; nu s-a primit nimic

en: Expecting register D for indexed indirect mode.
ro: Se aștepta registrul D pentru modul indirect indexat.

en: Expecting second argument
ro: Se așteaptă al doilea argument

en: Explicit stops are ignored in auto mode
ro: Opririle explicite sunt ignorate în modul automat

en: Expression Error for operand modifier %%hi/%%lo
ro: Eroare de expresie pentru modificatorul operandului %%hi/%%lo

en: Expression inside %%%s could not be parsed
ro: Expresia din %%%s nu a putut fi analizată

en: Expression out of range, using 0
ro: Expresie în afara intervalului, folosind 0

en: Extended addressing not supported on the specified CPU
ro: Adresarea extinsă nu este acceptată de CPU-ul specificat

en: Extra )
ro: „)” în plus

en: Extra junk in function call, expecting ')'
ro: Gunoaie extra în apelul funcției, se aștepta „)”

en: Extra junk on line
ro: Gunoaie suplimentare pe linie

en: FATAL: Attaching compiler header %s
ro: FATAL: Atașarea antetului compilatorului %s

en: FIRST not supported as a .SUBSPACE argument
ro: FIRST nu este acceptat ca argument .SUBSPACE

en: FP branch in delay slot
ro: ramură FP în intervalul de întârziere

en: FP branch preceded by FP compare; NOP inserted
ro: ramură FP precedată de compararea FP; NOP inserat

en: FPU DP extension
ro: extensie FPU DP

en: FPU SP extension
ro: extensie FPU SP

en: FPU fused-multiply-add instructions
ro: Instrucțiuni FPU de adunare-multiplicare fuzionată

en: FRAME parameter must be a multiple of 8: %d
ro: Parametrul FRAME trebuie să fie un multiplu de 8: %d

en: FRV specific command line options:
ro: Opțiuni de linie de comandă specifice FRV:

en: FT32 options:
ro: Opțiuni FT32:

en: Failed to create property section `%s'
ro: Nu s-a putut crea secțiunea de proprietate „%s”

en: Failed to find a valid mode for `%s'.
ro: Nu s-a reușit să se găsească un mod valid pentru „%s”.

en: Failed to find real start of function: %s
ro: Nu s-a reușit să se găsească începutul real al funcției: %s

en: Fatal error:
ro: Eroare fatală:

en: Field not properly aligned [%d] (%d).
ro: Câmpul nu este aliniat corespunzător [%d] (%d).

en: Field out of range [%d..%d] (%d).
ro: Câmp în afara intervalului [%d..%d] (%d).

en: File '%s' not in macro archive format
ro: Fișierul „%s” nu este în format de arhivă macro

en: First invalid token: "%s"
ro: Primul jeton nevalid: „%s”

en: First opcode is long.  Unable to mix instructions as specified.
ro: Primul cod operațional este lung. Nu se pot amesteca instrucțiunile specificate.

en: First operand to .%s must be a predicate
ro: Primul operand al .%s trebuie să fie un predicat

en: First operand to .%s not a register
ro: Primul operand pentru .%s nu este un registru

en: First operand to .%s not a valid register
ro: Primul operand pentru .%s nu este un registru valid

en: First operand to .altrp not a valid branch register
ro: Primul operand al .altrp nu este un registru de ramificare valid

en: First operand to .fframe must be a constant
ro: Primul operand al .fframe trebuie să fie o constantă

en: First operand to .prologue must be a positive 4-bit constant
ro: Primul operand din .prologue trebuie să fie o constantă pozitivă de 4 biți

en: First operand to .restore must be stack pointer (sp)
ro: Primul operand pentru .restore trebuie să fie un indicator de stivă („stack pointer”: sp)

en: First operand to .save not a register
ro: Primul operand pentru .save nu este un registru

en: First operand to .save not a valid register
ro: Primul operand pentru .save nu este un registru valid

en: First operand to .save.b must be a positive 5-bit constant
ro: Primul operand pentru .save.b trebuie să fie o constantă pozitivă de 5 biți

en: First operand to .save.g must be a positive 4-bit constant
ro: Primul operand pentru .save.g trebuie să fie o constantă pozitivă de 4 biți

en: First operand to .save.gf must be a non-negative 4-bit constant
ro: Primul operand al .save.gf trebuie să fie o constantă ne-negativă de 4 biți

en: First operand to .unwabi must be a constant
ro: Primul operand pentru .unwabi trebuie să fie o constantă

en: First operand to .vframe must be a general register
ro: Primul operand al .vframe trebuie să fie un registru general

en: Fix data dependency: %s %s -- %s %s (insert %d nop!/%d)
ro: Corectarea dependenței datelor: %s %s -- %s %s (inserează %d nop!/%d)

en: Fix data dependency: %s %s -- %s %s (insert 1 pflush/%d)
ro: Corectarea dependenței datelor: %s %s -- %s %s (inserează 1 pflush/%d)

en: Float AC not legal as integer operand
ro: AC de virgulă mobilă nu este legal ca operand de număr întreg

en: Floating point number not valid in expression
ro: Numărul în virgulă mobilă nu este valid în expresie

en: Floating point register in register list
ro: Registru cu virgulă mobilă în lista de registre

en: Forced short literal to immediate mode. now_seg=%s to_seg=%s
ro: Literal scurt forțat la modul imediat. now_seg=%s to_seg=%s

en: Forcing byte displacement
ro: Se forțează deplasarea octetului

en: Found '{' after explicit switch to automatic mode
ro: S-a găsit „{” după trecerea explicită la modul automat

en: Found '{' when already bundling.
ro: S-a găsit '{' atunci când împachetarea era deja începută.

en: Found '{' when manual bundling is already turned on
ro: S-a găsit „{” atunci când gruparea manuală este deja activată

en: Found '}' when manual bundling is off
ro: S-a găsit „}” atunci când gruparea manuală este oprită

en: Found '}' when not bundling.
ro: S-a găsit „}” atunci când nu se fac pachete.

en: Found use of non-canonical register name %s; use %s instead.
ro: S-a constatat utilizarea unui nume de registru necanonic %s; utilizați %s în schimb.

en: Freescale XGATE co-processor options:
      -mshort                 use 16-bit int ABI (default)
      -mlong                  use 32-bit int ABI
      -mshort-double          use 32-bit double ABI
      -mlong-double           use 64-bit double ABI (default)
      --mxgate                specify the processor variant [default %s]
      --print-insn-syntax     print the syntax of instruction in case of error
      --print-opcodes         print the list of instructions with syntax
      --generate-example      generate an example of each instruction
ro: Opțiuni coprocesor Freescale XGATE:
      -mshort                 utilizează ABI int pe 16 biți (implicit)
      -mlong                  utilizează ABI int pe 32 de biți
      -mshort-double          utilizează ABI dublu pe 32 de biți
      -mlong-double           utilizează ABI dublu pe 64 de biți (implicit)
      --mxgate                specifică varianta procesorului [implicit %s]
      --print-insn-syntax     afișează sintaxa instrucțiunii în caz de eroare
      --print-opcodes         afișează lista de instrucțiuni cu sintaxa
      --generate-example      generează un exemplu pentru fiecare instrucțiune

en: Function expects two arguments
ro: Funcția așteaptă două argumente

en: GAS auto-detection mode and -march=all is deprecated for MVE, please use a valid -march or -mcpu option.
ro: Modul de autodetecție GAS și „-march=all” sunt depreciate pentru MVE, vă rugăm să utilizați o opțiune validă „-march” sau „-mcpu”.

en: GINSN process for prev func not done
ro: procesul GINSN pentru funcția anterioară nu a fost finalizat

en: GINSN: found unreachable code in func '%s'
ro: GINSN: a fost găsit un cod inaccesibil în funcția „%s”

en: GNU assembler %s
ro: Asamblorul GNU %s

en: GNU assembler version %s (%s) using BFD version %s
ro: Asamblorul GNU versiunea %s (%s) folosind versiunea BFD %s

en: GOT already in symbol table
ro: GOT este deja în tabelul de simboluri

en: GOT already in the symbol table
ro: GOT se află deja în tabelul de simboluri

en: GOT bad expression with %s.
ro: expresie greșită GOT cu %s.

en: GP prologue size exceeds field size, using 0 instead
ro: dimensiunea prologului GP depășește dimensiunea câmpului, folosind 0 în schimb

en: Garbage at end of instruction
ro: Deșeuri la sfârșit de instrucțiune

en: Garbage at end of instruction: `%s'.
ro: Deșeuri la sfârșitul instrucțiunii „%s”.

en: Gas failure, reloc type #%i
ro: Eșec de «gas», tip de realocare #%i

en: Gas failure, reloc type %s
ro: Eșec de «gas», tip de realocare %s

en: Gas failure, reloc value %d
ro: Eșec de «gas», valoare de realocare %d

en: General register not legal as float operand
ro: Registrul general nu este legal ca operand de virgulă mobilă

en: Group section `%s' has no group signature
ro: Secțiunea de grup „%s” nu are o semnătură de grup

en: HI/LO registers should be specified together
ro: Registrele HI/LO trebuie să fie specificate împreună

en: HI/LO registers should be specified without additional registers
ro: Registrele HI/LO trebuie să fie specificate fără registre suplimentare

en: Hardware capability "%s" not enabled for "%s".
ro: Capacitatea hardware „%s” nu este activată pentru „%s”.

en: Hi-register ADD, MOV, CMP using pc
ro: Registru superior ADD, MOV, CMP folosind pc

en: Hi-register ADD, MOV, CMP, BX, BLX using pc
ro: Registru superior ADD, MOV, CMP, BX, BLX folosind pc

en: I don't need or use temp. file "%s".
ro: Nu am nevoie de, sau nu utilizez, fișierul temporar "%s".

en: I don't use an interpass file! -V ignored
ro: Nu se utilizează un fișier intermediar! „-V” este ignorată

en: IA-64 options:
      --mconstant-gp	  mark output file as using the constant-GP model
    			  (sets ELF header flag EF_IA_64_CONS_GP)
      --mauto-pic		  mark output file as using the constant-GP model
    			  without function descriptors (sets ELF header flag
    			  EF_IA_64_NOFUNCDESC_CONS_GP)
      -milp32|-milp64|-mlp64|-mp64	select data model (default -mlp64)
      -mle | -mbe		  select little- or big-endian byte order (default -mle)
      -mtune=[itanium1|itanium2]
    			  tune for a specific CPU (default -mtune=itanium2)
      -munwind-check=[warning|error]
    			  unwind directive check (default -munwind-check=warning)
      -mhint.b=[ok|warning|error]
    			  hint.b check (default -mhint.b=error)
      -x | -xexplicit	  turn on dependency violation checking
ro: IA-64 options:
      --mconstant-gp	  marchează fișierul de ieșire ca utilizând modelul GP-constant
    			  (activează fanionul de antet ELF EF_IA_64_CONS_GP)
      --mauto-pic		  marchează fișierul de ieșire ca utilizând modelul GP-constant
    			  fără descriptori de funcții ( activează fanionul de
    			  antet ELF EF_IA_64_NOFUNCDESC_CONS_GP)
      -milp32|-milp64|-mlp64|-mp64	selectează modelul de date (implicit „-mlp64”)
      -mle | -mbe		  selectează ordinea octeților little- sau big-endian (implicit -mle)
      -mtune=[itanium1|itanium2]
    			  ajustează pentru un anumit CPU (implicit -mtune=itanium2)
      -munwind-check=[warning|error]
    			  verificarea directivei de desfășurare (implicit -munwind-check=warning)
      -mhint.b=[ok|warning|error]
    			  verificarea hint.b (implicit -mhint.b=error)
      -x | -xexplicit	  activează verificarea încălcării dependențelor

en: IP2K specific command line options:
ro: Opțiuni de linie de comandă specifice IP2K:

en: IT blocks containing 16-bit Thumb instructions of the following class are performance deprecated in ARMv8-A and ARMv8-R: %s
ro: Blocurile IT care conțin instrucțiuni Thumb pe 16 biți din următoarea clasă sunt depreciate din punct de vedere al performanței în ARMv8-A și ARMv8-R: %s

en: IT blocks containing 32-bit Thumb instructions are performance deprecated in ARMv8-A and ARMv8-R
ro: Blocurile IT care conțin instrucțiuni Thumb pe 32 de biți sunt depreciate din punct de vedere al performanței în ARMv8-A și ARMv8-R

en: IT blocks containing more than one conditional instruction are performance deprecated in ARMv8-A and ARMv8-R
ro: Blocurile IT care conțin mai mult de o instrucțiune condițională sunt depreciate din punct de vedere al performanței în ARMv8-A și ARMv8-R

en: IT falling in the range of a previous IT block
ro: IT care cade în intervalul unui bloc IT anterior

en: IU instruction may not be in the left container
ro: Este posibil ca instrucțiunea IU să nu se afle în containerul din stânga

en: Ignoring attempt to re-define symbol
ro: Se ignoră încercarea de a redefini simbolul

en: Ignoring attempt to re-define symbol %s
ro: Se ignoră încercarea de a redefini simbolul %s

en: Ignoring attempt to re-define symbol `%s'.
ro: Se ignoră încercarea de a redefini simbolul „%s”.

en: Ignoring attempt to spill beyond end of region
ro: Se ignoră încercarea de depășire a limitelor regiunii

en: Ignoring changed section attributes for %s
ro: Se ignoră atributele modificate ale secțiunii pentru %s

en: Ignoring statement due to "%s"
ro: Se ignoră declarația din cauza „%s”

en: Illegal 32 bit - processor register (`%s') in Instruction: `%s'
ro: Registru de procesor pe 32 de biți ilegal („%s”) în instrucțiunea: „%s”

en: Illegal AR register in indirect reference
ro: Registru AR ilegal în referința indirectă

en: Illegal Scale - `%d'
ro: Scară ilegală - „%d”

en: Illegal `cinv' parameter: `%c'
ro: Parametru „cinv” ilegal: „%c”

en: Illegal `mask16' operand, operation is undefined - `%s'
ro: Operand „mask16” ilegal, operația este nedefinită - „%s”

en: Illegal co-processor register in instruction `%s'
ro: Registru de co-procesor ilegal în instrucțiunea „%s”

en: Illegal co-processor special register in instruction `%s'
ro: Registru special de co-procesor ilegal în instrucțiunea „%s”

en: Illegal combination of relocation functions
ro: Combinație ilegală de funcții de realocare

en: Illegal emulated instruction
ro: Instrucțiune emulată ilegală

en: Illegal index register pair (`%s') in Instruction: `%s'
ro: Pereche de registre de index ilegală („%s”) în instrucțiunea: „%s”

en: Illegal instruction or not implemented opcode.
ro: Instrucțiune ilegală sau cod operațional neimplementat.

en: Illegal operand (arg %d)
ro: Operand ilegal (arg %d)

en: Illegal operand separator `%c'
ro: Separator de operanzi ilegal „%c”

en: Illegal operand.
ro: Operand ilegal.

en: Illegal operands
ro: Operanzi ilegali

en: Illegal operands (whitespace): `%s'
ro: Operanzi ilegali (spații albe): „%s”

en: Illegal operands%s
ro: Operanzi ilegali%s

en: Illegal operands: %%%s can be only used with call __tls_get_addr
ro: Operanzi ilegali: %%%s poate fi utilizat numai cu apelul __tls_get_addr

en: Illegal operands: %%%s cannot be used together with other relocs in the insn ()
ro: Operanzi ilegali: %%%s nu poate fi utilizat împreună cu alte realocări în insn ()

en: Illegal operands: %%%s requires arguments in ()
ro: Operanzi ilegali: %%%s necesită argumente în ()

en: Illegal operands: %%r_%s%d requires arguments in ()
ro: Operanzi ilegali: %%r_%s%d necesită argumente în ()

en: Illegal operands: %%r_plt in %d-byte data field
ro: Operanzi ilegali: %%r_plt în câmpul de date de %d-octeți

en: Illegal operands: %%r_tls_dtpoff in %d-byte data field
ro: Operanzi ilegali: %%r_tls_dtpoff în câmpul de date de %d octeți

en: Illegal operands: Can't add non-constant expression to %%%s()
ro: Operanzi ilegali: nu se poate adăuga o expresie neconstantă la %%%s()

en: Illegal operands: Can't do arithmetics involving %%%s() of a relocatable symbol
ro: Operanzi ilegali: nu se pot efectua calcule aritmetice care implică %%%s() al unui simbol realocabil

en: Illegal operands: Can't do arithmetics other than + and - involving %%%s()
ro: Operanzi ilegali: nu se pot efectua alte operații aritmetice decât + și - care implică %%%s()

en: Illegal operands: Only %%r_%s%d allowed in %d-byte data fields
ro: Operanzi ilegali: doar %%r_%s%d este permis în câmpuri de date de %d-octeți

en: Illegal operands: garbage after %%r_%s%d()
ro: Operanzi ilegali: gunoi după %%r_%s%d()

en: Illegal processor register (`%s') in Instruction: `%s'
ro: Registru de procesor ilegal („%s”) în instrucțiunea: „%s”

en: Illegal register (`%s') in Instruction: `%s'
ro: Registru ilegal („%s”) în instrucțiunea: „%s”

en: Illegal register (`%s') in instruction: `%s'
ro: Registru ilegal („%s”) în instrucțiunea: „%s”

en: Illegal register `%s' in Instruction `%s'
ro: Registru ilegal „%s” în instrucțiunea „%s”

en: Illegal register `%s' in cop-register list
ro: Registru ilegal „%s” în lista de registre a co-procesorului

en: Illegal register `%s' in cop-special-register list
ro: Registru ilegal „%s” în lista de registre speciale a co-procesorului

en: Illegal register `%s' in instruction `%s'
ro: Registru ilegal „%s” în instrucțiunea „%s”

en: Illegal register `%s' in register list
ro: Registru ilegal „%s” în lista de registre

en: Illegal register `%s' in user register list
ro: Registru ilegal „%s” în lista de registre a utilizatorului

en: Illegal register pair (`%s') in Instruction: `%s'
ro: Pereche de registre ilegală („%s”) în instrucțiunea: „%s”

en: Illegal register pair `%s' in Instruction `%s'
ro: Pereche de registre ilegală „%s” în instrucțiunea „%s”

en: Illegal section name `%s' (causes unwind section name clash)
ro: Numele ilegal al secțiunii „%s” (provoacă un conflict cu numele secțiunii de desfășurare)

en: Illegal type of operand (arg %d)
ro: Tip ilegal de operand (arg %d)

en: Immediate operand %ld is inappropriate for size of instruction
ro: Operandul imediat %ld este inadecvat pentru dimensiunea instrucțiunii

en: Immediate operand is not allowed for operand %d.
ro: Operandul direct(immediate) nu este permis pentru operandul %d.

en: Immediate overflow.
    format: %c%c%s
    arg: %s
ro: Depășire imediată.
    format: %c%c%s
    argument: %s

en: Immediate value %ld is out of range for instruction %s
ro: Valoarea imediată %ld este în afara intervalului pentru instrucțiunea %s

en: Immediate value %ld too large
ro: Valoarea imediată %ld este prea mare

en: Immediate value for mbar > 32. using <value %% 32>
ro: Valoare imediată pentru mbar > 32. Se utilizează <valoarea %% 32>

en: Immediate value not in 16 bit range: %ld
ro: Valoarea imediată nu se află în intervalul de 16 biți: %ld

en: Immediate value not in 16 bit signed range: %ld
ro: Valoarea imediată nu se află în intervalul de 16 biți cu semn: %ld

en: Immediate value not in 16 bit unsigned range: %ld
ro: Valoarea imediată nu se află în intervalul de 16 biți fără semn: %ld

en: Immediate value not in 4 bit unsigned range: %ld
ro: Valoarea imediată nu se află în intervalul de 4 biți fără semn: %ld

en: Immediate value not in 5 bit unsigned range: %ld
ro: Valoarea imediată nu se află în intervalul de 5 biți fără semn: %ld

en: Immediate value not in 6 bit range: %ld
ro: Valoarea imediată nu se află în intervalul de 6 biți: %ld

en: Immediate value not in 6 bit unsigned range: %ld
ro: Valoarea imediată nu se află în intervalul de 6 biți fără semn: %ld

en: Immediate value not in 8 bit range: %ld
ro: Valoarea imediată nu se află în intervalul de 8 biți: %ld

en: Immediate value not in 8 bit signed range: %ld
ro: Valoarea imediată nu se află în intervalul de 8 biți cu semn: %ld

en: Immediate value not in 8 bit unsigned range: %ld
ro: Valoarea imediată nu se află în intervalul de 8 biți fără semn: %ld

en: Immediate value of %ld is too large
ro: Valoarea imediată a lui %ld este prea mare

en: Immediate value of %ld is too large for ldf
ro: Valoarea imediată a %ld este prea mare pentru ldf

en: Immediates %d and %d will give undefined behavior.
ro: Valorile imediate %d și %d vor avea un comportament nedefinit.

en: Improper bs immediate (%lu)
ro: Imediat bs necorespunzător (%lu)

en: Improper rnum immediate (%lu)
ro: Imediat rnum necorespunzător (%lu)

en: Improper use of OP1_IMM_IMPLIED
ro: Utilizare necorespunzătoare a OP1_IMM_IMPLIED

en: Improper use of OP1_MUST_BE_IMM
ro: Utilizare necorespunzătoare a OP1_MUST_BE_IMM

en: Incompatible first and second operands in instruction
ro: Primul și al doilea operand din instrucțiune sunt incompatibili

en: Incorrect fr_opcode value in frag.  Internal error.....
ro: Valoare fr_opcode incorectă în frag. Eroare internă.....

en: Incorrect number of operands
ro: Număr incorect de operanzi

en: Incorrect number of operands given
ro: Număr incorect de operanzi dat

en: Incorrect syntax, %s.
ro: Sintaxă incorectă, %s.

en: Increment/decrement value is out of range: `%ld'.
ro: Valoarea incrementală/decrementală este în afara intervalului: „%ld”.

en: Index can only be applied to rotating or indirect registers
ro: Indexul poate fi aplicat numai registrelor rotative sau indirecte

en: Index must be a general register
ro: Indexul trebuie să fie un registru general

en: Index one must be [2,3] and index two must be two less than index one.
ro: Indexul unu trebuie să fie [2,3], iar indexul doi trebuie să fie cu doi mai mic decât indexul unu.

en: Index out of range 0..%u
ro: Index în afara intervalului 0..%u

en: Index register IR0,IR1 required for displacement
ro: Registrul index IR0, IR1 este necesar pentru deplasare

en: Indexed indirect mode is not allowed for movb/movw.
ro: Modul indirect indexat nu este permis pentru movb/movw.

en: Indirect indexed addressing is not valid for 68HC11.
ro: Adresarea indexată indirectă nu este valabilă pentru 68HC11.

en: Indirect register index must be a general register
ro: Indexul registrului indirect trebuie să fie un registru general

en: Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s
ro: Bucla infinită întâlnită în timpul încercării de a calcula adresele simbolurilor din secțiunea %s

en: Infinities are not supported by this target
ro: Infinitele nu sunt acceptate de această țintă

en: Info:
ro: Informații:

en: Initial .body should precede any instructions
ro: .body inițial trebuie să preceadă orice instrucțiuni

en: Initial .prologue should precede any instructions
ro: .prologue inițial trebuie să preceadă orice instrucțiuni

en: Insn %s has a jump/branch instruction %s in its delay slot.
ro: Instrucțiunea %s are o instrucțiune de salt/ramificare %s în slotul său de întârziere.

en: Insn %s has an instruction %s with limm in its delay slot.
ro: Instrucțiunea %s are o instrucțiune %s cu limm în slotul de întârziere.

en: Insn slot not set in unwind record.
ro: Slotul instrucțiunii nu este definit în înregistrarea de desfășurare.

en: Instruction %s not allowed in a delay slot.
ro: Instrucțiunea %s nu este permisă într-un slot de întârziere.

en: Instruction %s not supported in the baseline.
ro: Instrucțiunea %s nu este acceptată în linia-bază.

en: Instruction '%s' requires an LP cpu version
ro: Instrucțiunea „%s” necesită o versiune cpu LP

en: Instruction '%s' requires far mode addressing
ro: Instrucțiunea „%s” necesită adresarea în modul de la distanță

en: Instruction `%s' is not recognized.
ro: Instrucțiunea „%s” nu este recunoscută.

en: Instruction does not fit in available delay slots (%d-word insn, %d slot left) | Instruction does not fit in available delay slots (%d-word insn, %d slots left)
ro[0]: Instrucțiunea nu se încadrează în sloturile de întârziere disponibile (instrucțiunea %d cuvânt/cuvinte, %d slot rămas).
ro[1]: Instrucțiunea nu se încadrează în sloturile de întârziere disponibile (instrucțiunea %d cuvânt/cuvinte, %d sloturi rămase).
ro[2]: Instrucțiunea nu se încadrează în sloturile de întârziere disponibile (instrucțiunea %d cuvânt/cuvinte, %d de sloturi rămase).

en: Instruction does not fit in available delay slots (%d-word insn, %d slot left). Resulting behavior is undefined. | Instruction does not fit in available delay slots (%d-word insn, %d slots left). Resulting behavior is undefined.
ro[0]: Instrucțiunea nu se încadrează în sloturile de întârziere disponibile (instrucțiunea %d cuvânt/cuvinte, %d slot rămas). Comportamentul rezultant este nedefinit.
ro[1]: Instrucțiunea nu se încadrează în sloturile de întârziere disponibile (instrucțiunea %d cuvânt/cuvinte, %d sloturi rămase). Comportamentul rezultant este nedefinit.
ro[2]: Instrucțiunea nu se încadrează în sloturile de întârziere disponibile (instrucțiunea %d cuvânt/cuvinte, %d de sloturi rămase). Comportamentul rezultant este nedefinit.

en: Instruction does not support =N addresses
ro: Instrucțiunea nu acceptă adrese =N

en: Instruction form not available on this architecture.
ro: Formă de instrucțiune nedisponibilă pe această arhitectură.

en: Instruction formats for `%s':
ro: Formate de instrucțiuni pentru „%s”:

en: Instruction in R container is squashed by flow control instruction in L container.
ro: Instrucțiunea din containerul R este strivită de instrucțiunea de control al fluxului din containerul L.

en: Instruction must be executed in parallel
ro: Instrucțiunea trebuie să fie executată în paralel

en: Instruction must be executed in parallel with another instruction.
ro: Instrucțiunea trebuie să fie executată în paralel cu o altă instrucțiune.

en: Instruction not permitted on this architecture
ro: Instrucțiune nepermisă pe această arhitectură

en: Instruction not supported by this architecture
ro: Instrucțiune neacceptată de această arhitectură

en: Instruction uses long version, so it cannot be mixed as specified
ro: Instrucțiunea utilizează versiunea lungă, deci nu poate fi amestecată așa cum este specificat

en: Instructions do not use parallel execution pipelines.
ro: Instrucțiunile nu utilizează conducte „pipelines” de execuție paralele.

en: Instructions may not be executed in parallel
ro: Instrucțiunile nu pot fi executate în paralel

en: Instructions share the same execution pipeline
ro: Instrucțiunile împart aceeași conductă „pipeline” de execuție

en: Instructions using long offset modifiers or absolute addresses are not repeatable. Resulting behavior is undefined.
ro: Instrucțiunile care utilizează modificatori de decalaj lung sau adrese absolute nu sunt repetabile. Comportamentul rezultant este nedefinit.

en: Instructions which cause PC discontinuity are not allowed in a delay slot. Resulting behavior is undefined.
ro: Instrucțiunile care cauzează discontinuitatea PC nu sunt permise într-un slot de întârziere. Comportamentul rezultant este nedefinit.

en: Intel MCU doesn't support `%s' architecture
ro: Intel MCU nu acceptă arhitectura „%s”

en: Intel MCU is 32bit ELF only
ro: Intel MCU este doar ELF pe 32 de biți

en: Intel MCU is 32bit only
ro: Intel MCU este doar pe 32 de biți

en: Internal Error: Can't find %s in hash table
ro: Eroare internă: nu se poate găsi %s în tabelul de sume de control

en: Internal bug. Try to use 0(r%d) instead of @r%d
ro: Eroare internă. Încercați să utilizați 0(r%d) în loc de @r%d

en: Internal consistency error.  check ns32k-opcode.h
ro: Eroare de consistență internă. Verificați ns32k-opcode.h

en: Internal error (%s).
ro: Eroare internă (%s).

en: Internal error at %s:%d.
ro: Eroare internă la %s:%d.

en: Internal error found in md_convert_frag: offset %ld.  Please report this.
ro: Eroare internă găsită în md_convert_frag: offset %ld. Vă rugăm să raportați acest lucru.

en: Internal error in %s at %s:%d.
ro: Eroare internă în %s, la %s:%d.

en: Internal error: .relax_hint KEY is not a number!
ro: Eroare internă: CHEIA .relax_hint nu este un număr!

en: Internal error: Range error. %s
ro: Eroare internă: eroare de interval. %s

en: Internal error: Relax hint (%s) error. %s: %s (%x)
ro: Eroare internă: eroare de indiciu de relaxare (%s). %s: %s (%x)

en: Internal error: Unable to find containing space for %s.
ro: Eroare internă: Imposibil de găsit spațiul care conține %s.

en: Internal error: Unknown fixup type %d (`%s')
ro: Eroare internă: tip de remediere necunoscut %d („%s”)

en: Internal error: can't find opcode `%s' for `%s'
ro: Eroare internă: nu se poate găsi codul operațional: „%s” pentru „%s”

en: Internal error: don't know how to force %s to end of instruction group
ro: Eroare internă: nu se știe cum să se forțeze %s la sfârșitul grupului de instrucțiuni

en: Internal error: losing opcode: `%s' "%s"
ro: Eroare internă: pierderea codului operațional: „%s” „%s”

en: Internal error: not support relax now
ro: Eroare internă: nu se acceptă relaxarea acum

en: Internal logic error in iif.iifP[].type
ro: Eroare logică internă în iif.iifP[].type

en: Internal logic error in iif.iifP[n].type
ro: Eroare logică internă în iif.iifP[n].type

en: Internal logic error.  Line %d, file: "%s"
ro: Eroare logică internă. Linia %d, fișier: „%s”

en: Internal logic error. line %d, file "%s"
ro: Eroare logică internă; linia %d, fișierul „%s”

en: Invalid --compress-debug-sections option: `%s'
ro: Opțiune nevalidă „--compress-debug-sections”: „%s”

en: Invalid --elf-stt-common= option: `%s'
ro: Opțiune --elf-stt-common= nevalidă: „%s”

en: Invalid --gdwarf-cie-version `%s'
ro: Opțiune --gdwarf-cie-version „%s”nevalidă

en: Invalid --generate-missing-build-notes option: `%s'
ro: Opțiune --generate-missing-build-notes= nevalidă: „%s”

en: Invalid --scfi= option: `%s'; suggested option: experimental
ro: Opțiune nevalidă --scfi=: „%s”; opțiune sugerată: experimental

en: Invalid --size-check= option: `%s'
ro: Opțiune --size-check= nevalidă: „%s”

en: Invalid .CALL argument: %s
ro: Argument .CALL nevalid: %s

en: Invalid .CALLINFO argument: %s
ro: Argument .CALLINFO nevalid: %s

en: Invalid .SPACE argument
ro: Argument .SPACE nevalid

en: Invalid .SUBSPACE argument
ro: Argument .SUBSPACE nevalid

en: Invalid .insn format
ro: Format .insn nevalid

en: Invalid Add Condition: %s
ro: Condiție de adăugare nevalidă: %s

en: Invalid Add and Branch Condition
ro: Condiție de adăugare și ramificare nevalidă

en: Invalid Branch On Bit Condition: %c
ro: Condiție incorectă de ramificare pe bit: %c

en: Invalid COPR identifier
ro: Identificator COPR  nevalid

en: Invalid CPU is specified: %s
ro: Este specificat un CPU nevalid: %s

en: Invalid CST4 operand value (arg %d)
ro: Valoare nevalidă a operandului CST4 (arg %d)

en: Invalid Compare and Branch Condition
ro: Condiție de comparare și ramificare nevalidă

en: Invalid Compare/Subtract Condition
ro: Condiție de comparație/scădere nevalidă

en: Invalid Compare/Subtract Condition: %s
ro: Condiție de comparație/scădere nevalidă: %s

en: Invalid DISPU4 operand value (arg %d)
ro: Valoare nevalidă a operandului DISPU4 (arg %d)

en: Invalid EXTENSION is specified: %s
ro: Este specificată o EXTENSIE nevalidă: %s

en: Invalid FP Compare Condition: %s
ro: Condiție de comparare FP nevalidă: %s

en: Invalid FP Operand Format: %3s
ro: Format nevalid al operandului FP: %3s

en: Invalid FTEST completer: %s
ro: Completător FTEST nevalid: %s

en: Invalid Floating Point Operand Format.
ro: Format de operand în virgulă mobilă nevalid.

en: Invalid Indexed Load Completer Syntax.
ro: Sintaxa completării de încărcare indexată nu este validă.

en: Invalid Indexed Load Completer.
ro: Completare de încărcare indexată nevalidă.

en: Invalid Logical Instruction Condition.
ro: Condiție de instrucțiune logică nevalidă.

en: Invalid Nullification: (%c)
ro: Anulare nevalidă: (%c)

en: Invalid PIC expression.
ro: Expresie PIC nevalidă.

en: Invalid SFU identifier
ro: Identificator SFU nevalid

en: Invalid Shift/Extract/Deposit Condition.
ro: Stare de deplasare/extragere/depozitare nevalidă.

en: Invalid Short Load/Store Completer.
ro: Completare de încărcare/stocare scurtă nevalidă.

en: Invalid Store Bytes Short Completer
ro: Completare scurtă de octeți de stocare nevalidă

en: Invalid Unit Instruction Condition.
ro: Condiție de instrucțiune unitară nevalidă.

en: Invalid accumulator register.
ro: Registru acumulator nevalid.

en: Invalid argument %d to .prologue.
ro: Argument nevalid %d pentru .prologue.

en: Invalid argument description: %d
ro: Descriere nevalidă a argumentului: %d

en: Invalid argument location: %s
ro: Locație nevalidă a argumentului: %s

en: Invalid argument to --isa option: %s
ro: Argument nevalid pentru opțiunea „--isa”: %s

en: Invalid argument to --mach option: %s
ro: Argument nevalid pentru opțiunea --mach: %s

en: Invalid auxiliary register (use AR0-AR7)
ro: Registru auxiliar nevalid (utilizați AR0-AR7)

en: Invalid character %s before %s operand
ro: Caracter nevalid %s înainte de operandul %s

en: Invalid character %s in %s operand
ro: Caracter nevalid %s în operandul %s

en: Invalid character %s in opcode
ro: Caracter nevalid %s în codul operațional

en: Invalid combination of instructions for bundle.
ro: Combinație de instrucțiuni nevalabilă pentru pachet.

en: Invalid default architecture, broken assembler.
ro: Arhitectură implicită nevalidă, asamblor defect.

en: Invalid destination register for this instruction, use 'tfr'.
ro: Registru de destinație nevalid pentru această instrucțiune, utilizați „tfr”.

en: Invalid destination register.
ro: Registru de destinație nevalid.

en: Invalid directive
ro: Directivă nevalidă.

en: Invalid displacement in indirect reference
ro: Deplasare nevalidă în referința indirectă

en: Invalid dmad syntax '%s'
ro: Sintaxă dmad nevalidă „%s

en: Invalid duplicate use of `%c%d'
ro: Utilizare duplicată nevalidă a „%c%d”

en: Invalid expression after # number
ro: Expresie nevalidă după # numărul

en: Invalid expression after %%%%
ro: Expresie nevalidă după %%%%

en: Invalid expression.
ro: Expresie nevalidă.

en: Invalid field selector.  Assuming F%%.
ro: Selector de câmp nevalid. Se presupune F%%.

en: Invalid field size, must be from 1 to 32
ro: Dimensiunea câmpului nu este valabilă, trebuie să fie de la 1 la 32

en: Invalid floating point number
ro: Număr în virgulă flotantă nevalid

en: Invalid immediate write operand.
ro: Operand de scriere imediată nevalid.

en: Invalid indexed indirect mode.
ro: Mod indirect indexat nevalid.

en: Invalid indexed register, expecting register X.
ro: Registru indexat nevalid, se aștepta registrul X.

en: Invalid indexed register, expecting register Y.
ro: Registru indexat nevalid, se aștepta registrul Y.

en: Invalid indexed register.
ro: Registru indexat nevalid.

en: Invalid indirect addressing mode
ro: Mod de adresare indirectă nevalid

en: Invalid indirect addressing mode displacement %d
ro: Deplasare a modului de adresare indirectă %d nevalidă

en: Invalid instruction %s
ro: Instrucțiune nevalidă %s

en: Invalid instruction: "%s"
ro: Instrucțiune nevalidă „%s”

en: Invalid label '%s'
ro: Etichetă nevalidă „%s”

en: Invalid left/right combination completer
ro: Completare combinație stânga/dreapta nevalidă

en: Invalid length (use 0 to %d)
ro: Lungime nevalidă (utilizați între 0 și %d)

en: Invalid mnemonic '%s'
ro: Mnemonic nevalid „%s”

en: Invalid mode: %s
ro: Mod nevalid: %s

en: Invalid number
ro: Număr nevalid

en: Invalid offset value for %s
ro: Valoare nevalidă a decalajului pentru %s

en: Invalid opcode/operands
ro: Coduri operaționale sau operanzi nevalizi

en: Invalid operand (s) for parallel instruction "%s"
ro: Operand (s) nevalid pentru instrucțiunea paralelă „%s”

en: Invalid operand (use 1, 2, or 3)
ro: Operand nevalid (utilizați 1, 2 sau 3)

en: Invalid operand for `%s'
ro: Operand nevalid pentru „%s”

en: Invalid operand for register offset
ro: Operand nevalid pentru decalajul registrului

en: Invalid operand: immediate value used as address.
ro: Operand nevalid: valoare imediată utilizată ca adresă.

en: Invalid operand: immediate value used as base address.
ro: Operand nevalid: valoare imediată utilizată ca adresă de bază.

en: Invalid operands
ro: Operanzi nevalabili

en: Invalid operands %s
ro: Operanzi nevalabili %s

en: Invalid operands for %s
ro: Operanzi nevalabili pentru %s

en: Invalid operation on symbol
ro: Operație nevalidă asupra simbolului

en: Invalid operator for operand.
ro: Operator nevalid pentru operand.

en: Invalid or illegal addressing mode combined with scaled-index
ro: Mod de adresare nevalid sau ilegal combinat cu index-scalat

en: Invalid pc-relative relocation
ro: Realocare relativă la PC nevalidă

en: Invalid permutation completer
ro: Completare de permutare nevalidă

en: Invalid record type for P3 format.
ro: Tip de înregistrare nevalid pentru formatul P3.

en: Invalid record type for format B1
ro: Tip de înregistrare nevalid pentru formatul B1.

en: Invalid record type for format P6
ro: Tip de înregistrare nevalid pentru formatul P6.

en: Invalid record type for format X1
ro: Tip de înregistrare nevalid pentru formatul X1.

en: Invalid record type for format X3
ro: Tip de înregistrare nevalid pentru formatul X3.

en: Invalid register for dbcc/tbcc instruction.
ro: Registru nevalid pentru instrucțiunea dbcc/tbcc.

en: Invalid register for post/pre increment.
ro: Registru nevalid pentru post/pre incrementare.

en: Invalid register for postdecrement operation
ro: Registru nevalid pentru operația postdecrement

en: Invalid register for predecrement operation
ro: Registru nevalid pentru operația de predecrementare

en: Invalid register for preincrement operation
ro: Registru nevalid pentru operația de preincrementare

en: Invalid register for single precision fmpyadd or fmpysub
ro: Registru nevalid pentru precizie simplă fmpyadd sau fmpysub

en: Invalid register in register list
ro: Registru nevalid în lista de registre

en: Invalid register list for ldm/stm
ro: Listă de registre nevalidă pentru ldm/stm

en: Invalid register number at '%.6s'
ro: Număr de registru nevalid la „%.6s”

en: Invalid register specification.
ro: Specificație de registru nevalidă.

en: Invalid register.
ro: Registru nevalid.

en: Invalid register: 'r%d'
ro: Registru nevalid: „r%d”

en: Invalid register: r0 and r15 illegal
ro: Registru nevalid: r0 și r15 ilegale

en: Invalid scaled-indexed mode, use (b,w,d,q)
ro: Mod indexat-scalat nevalid, utilizați (b,w,d,q)

en: Invalid simultaneous use of `f%d' and `f%d'
ro: Utilizare simultană nevalidă a „f%d” și „f%d”

en: Invalid source register for this instruction, use 'tfr'.
ro: Registru sursă nevalid pentru această instrucțiune, utilizați „tfr”.

en: Invalid source register.
ro: Registru sursă nevalid.

en: Invalid status register "%s"
ro: Registru de stare nevalid „%s”

en: Invalid subscript (use 1 to %d)
ro: Indice nevalid (utilizați de la 1 la %d)

en: Invalid suffix for literal pool entry
ro: Sufix nevalid pentru intrarea din fondul literal

en: Invalid syntax in External addressing mode
ro: Sintaxă nevalidă în modul de adresare externă

en: Invalid syntax in Memory Relative addressing mode
ro: Sintaxă nevalidă în modul de adresare relativă a memoriei

en: Invalid syntax in PC-relative addressing mode
ro: Sintaxă nevalidă în modul de adresare relativă la PC

en: Invalid use of `%c%d' as output operand
ro: Utilizare nevalidă a lui „%c%d” ca operand de ieșire

en: Invalid use of `r%d' as base update address operand
ro: Utilizare nevalidă a lui „r%d” ca operand de actualizare a adresei de bază

en: Invalid use of parallelization operator.
ro: Utilizare nevalidă a operatorului de paralelizare.

en: Invalid width value for %s
ro: Valoare nevalidă a lățimii pentru %s

en: JALX to a symbol in the same ISA mode
ro: JALX la un simbol din același mod ISA

en: Jump/Branch instruction detected at the end of the ZOL label @%s
ro: Instrucțiune de salt/ramificare a fost detectată la sfârșitul etichetei ZOL @%s

en: Junk after '}': '%s'
ro: Deșeuri după „}”: „%s”

en: Junk at end of line, %s.
ro: Gunoi la sfârșit de linie, %s.

en: Kernel instruction detected at the end of the ZOL label @%s
ro: Instrucțiune de nucleu detectată la sfârșitul etichetei ZOL @%s

en: Known MCU names:
ro: Nume MCU cunoscute:

en: LARCH options:
ro: Opțiuni LARCH:

en: LDP instruction needs a 24-bit operand
ro: instrucțiunea LDP are nevoie de un operand pe 24 de biți

en: LOC expression stepping backwards is not supported
ro: expresia LOC pas cu pas înapoi nu este acceptată

en: LOC to section unknown or indeterminable at first pass
ro: directivă LOC în secțiunea necunoscută sau indeterminabilă la prima trecere

en: LR and PC should not both be in register list
ro: LR și PC nu ar trebui să fie amândouă în lista de registre

en: Label "$%d" redefined
ro: Eticheta „$%d” a fost redefinită

en: Label "%s" matches a CPU register name
ro: Eticheta „%s” corespunde unui nume de registru CPU

en: Label must be first in a bundle
ro: Eticheta trebuie să fie prima într-un pachet

en: Label required for .tag
ro: Este necesară o etichetă pentru .tag

en: Leading plus sign not allowed in core mode
ro: Semnul plus nu este permis în modul core

en: Length of .comm "%s" is already %ld. Not changed to %d.
ro: Lungimea .comm „%s” este deja %ld. Nu se modifică la %d.

en: Length of .comm "%s" is already %ld. Not changed to %ld.
ro: Lungimea .comm „%s” este deja %ld. Nu se modifică la %ld.

en: Length of .lcomm "%s" is already %ld. Not changed to %ld.
ro: Lungimea lui .lcomm „%s” este deja %ld. Nu se modifică la %ld.

en: Length of .scomm "%s" is already %ld. Not changed to %ld.
ro: Lungimea .scomm „%s” este deja %ld. Nu se modifică la %ld.

en: Length specification ignored. Address mode 9F used
ro: Specificația privind lungimea este ignorată. Se utilizează modul de adresare 9F

en: Line %d: unknown relocation type: 0x%x.
ro: Linia %d: tip de realocare necunoscut: 0x%x.

en: Line numbers must be positive integers
ro: Numerele de linie trebuie să fie numere întregi pozitive

en: Literal loads
ro: Încărcări literale

en: Long instructions may not be combined.
ro: Instrucțiunile lungi nu pot fi combinate.

en: Low order bits truncated in immediate float operand
ro: Biți de ordin inferior trunchiați în operandul de virgulă mobilă imediat

en: M340 specific opcode used when assembling for M210
ro: Cod operațional specific M340 utilizat la asamblarea pentru M210

en: MCORE specific options:
      -{no-}jsri2bsr	  {dis}able jsri to bsr transformation (def: dis)
      -{no-}sifilter	  {dis}able silicon filter behavior (def: dis)
      -cpu=[210|340]          select CPU type
      -EB                     assemble for a big endian system (default)
      -EL                     assemble for a little endian system
ro: Opțiuni specifice MCORE:
      -{no-}jsri2bsr	  {dez}activează transformarea jsri în bsr (def: dis)
      -{no-}sifilter	  {dez}activează comportamentul filtrului de siliciu (def: dis)
      -cpu=[210|340]          selectează tipul de CPU
      -EB                     asamblează pentru un sistem big endian (implicit)
      -EL                     asamblează pentru un sistem little endian

en: MCU option requires a name
ro: Opțiunea MCU necesită un nume

en: MDRD value must be between 1 and 8
ro: valoarea MDRD trebuie să fie între 1 și 8

en: MIPS PIC call to register other than $25
ro: apel MIPS PIC la un registru, altul decât $25

en: MIPS options:
    -EB			generate big endian output
    -EL			generate little endian output
    -g, -g2			do not remove unneeded NOPs or swap branches
    -G NUM			allow referencing objects up to NUM bytes
    			implicitly with the gp register [default 8]
ro: Opțiuni MIPS:
    -EB                     generează ieșire big endian
    -EL                     generează ieșire little endian
    -g, -g2                 nu elimină NOP-urile nenecesare sau ramurile swap
    -G NUM                  permite referirea implicită la obiecte de până la
                            NUM octeți cu ajutorul registrului gp [implicit 8]

en: MN10200 options:
    none yet
ro: MN10200 opțiuni:
    niciuna încă

en: MN10300 assembler options:
    none yet
ro: Opțiuni de asamblare MN10300:
    niciuna încă

en: MRI style ORG pseudo-op not supported
ro: pseudo-operatorul ORG în stilul MRI nu este acceptat

en: MSP430 options:
      -mmcu=<msp430-name>     - select microcontroller type
      -mcpu={430|430x|430xv2} - select microcontroller architecture
ro: Opțiuni MSP430:
      -mmcu=<msp430-name>     - selectează tipul de microcontroler
      -mcpu={430|430x|430xv2} - selectează arhitectura microcontrolerului

en: MT specific command line options:
ro: Opțiuni de linie de comandă specifice MT:

en: MU instruction may not be in the right container
ro: Este posibil ca instrucțiunea MU să nu se afle în containerul din dreapta

en: MVE vector or ARM register expected
ro: se aștepta un vector MVE sau un registru ARM

en: MVE vector register Q[0..7] expected
ro: registru vectorial MVE Q[0..7] așteptat

en: MVE vector register expected
ro: se aștepta un registru vectorial MVE

en: MVE vector register in the range [Q0..Q7] expected
ro: se aștepta un registru vectorial MVE în intervalul [Q0..Q7]

en: Macro `%s' was already defined
ro: Macrocomanda „%s” a fost deja definită

en: Macro nesting is too deep
ro: Imbricarea macrocomenzii este prea profundă

en: Maximum %d bits may be set in `mask16' operand
ro: Maxim %d biți pot fi definiți în operandul „mask16”.

en: MeP specific command line options:
      -EB                     assemble for a big endian system
      -EL                     assemble for a little endian system (default)
      -mconfig=<name>         specify a chip configuration to use
      -maverage -mno-average -mmult -mno-mult -mdiv -mno-div
      -mbitops -mno-bitops -mleadz -mno-leadz -mabsdiff -mno-absdiff
      -mminmax -mno-minmax -mclip -mno-clip -msatur -mno-satur -mcop32
                              enable/disable the given opcodes
    
      If -mconfig is given, the other -m options modify it.  Otherwise,
      if no -m options are given, all core opcodes are enabled;
      if any enabling -m options are given, only those are enabled;
      if only disabling -m options are given, only those are disabled.
ro: Opțiuni de linie de comandă specifice MeP:
      -EB                     asamblează pentru un sistem big endianm
      -EL                     asamblează pentru un sistem little endian (implicit)
      -mconfig=<nume>         specifică o configurație de cip de utilizat
      -maverage -mno-average -mmult -mno-mult -mdiv -mno-div
      -mbitops -mno-bitops -mleadz -mno-leadz -mabsdiff -mno-absdiff
      -mminmax -mno-minmax -mclip -mno-clip -msatur -mno-satur -mcop32
                              activează/dezactivează codurile operaționale date
    
      Dacă este dată opțiunea „-mconfig”, celelalte opțiuni „-m” o modifică.  Altfel,
      dacă nu sunt date opțiuni „-m”, toate codurile operaționale de bază sunt activate;
      dacă sunt date opțiuni „-m” de activare, numai acestea sunt activate;
      dacă sunt indicate numai opțiuni „-m” de dezactivare, numai acestea sunt dezactivate.

en: Memory mapped register "%s" out of range
ro: Registrul cartografiat în memorie „%s” este în afara intervalului

en: Miscellaneous 16-bit instructions
ro: Diverse instrucțiuni pe 16 biți

en: Misplaced .entry. Ignored.
ro: .entry plasată greșit. Se ignoră.

en: Missing '(' after substitution symbol function
ro: Lipsește „(” după funcția simbol de substituție

en: Missing ')'
ro: Lipsește „)”

en: Missing ')' in subscripted substitution symbol expression
ro: Lipsește „)” în expresia simbolului de substituție indice

en: Missing ','
ro: Lipsește „,”

en: Missing '}' at end of file
ro: Lipsește „}” la sfârșitul fișierului

en: Missing '}': '%s'
ro: Lipsește „}”: „%s”

en: Missing )
ro: „)” lipsește

en: Missing ) in ra(rb)
ro: Lipsește „)” în ra(rb)

en: Missing .EXIT for a .ENTRY
ro: Lipsește .EXIT pentru un .ENTRY

en: Missing .callinfo
ro: Lipsește .callinfo

en: Missing .callinfo for this procedure
ro: Lipsește .callinfo pentru această procedură

en: Missing .callinfo.
ro: Lipsește .callinfo.

en: Missing .endp after previous .proc
ro: Lipsește .endp după .proc anterior

en: Missing .exit
ro: .exit lipsește

en: Missing .label_state %ld
ro: Lipsește .label_state %ld

en: Missing .procend
ro: .procend lipsește

en: Missing Branch On Bit Condition
ro: Lipsește condiția de ramificare pe bit

en: Missing `]' to close indexed-indirect mode.
ro: Lipsește „]” pentru a închide modul indexat-indirect.

en: Missing `]' to close register indirect operand.
ro: Lipsește „]” pentru a închide registrul operand indirect.

en: Missing forced substitution terminator ':'
ro: Lipsește terminatorul de substituție forțată „:”

en: Missing function name for .PROC
ro: Lipsește numele funcției pentru .PROC

en: Missing function name for .PROC (corrupted label chain)
ro: Lipsește numele funcției pentru .PROC (lanț de etichete corupt)

en: Missing label name on .LABEL
ro: Lipsește numele etichetei în .LABEL

en: Missing macro name
ro: Lipsește numele macrocomenzii

en: Missing matching brackets : `%s'
ro: Lipsesc parantezele pereche : „%s”

en: Missing operand
ro: Operand lipsă

en: Missing operand.
ro: Operand lipsă.

en: Missing parameter qualifier for `%s' in macro `%s'
ro: Lipsește calificativul parametrului pentru „%s” în macrocomanda „%s”

en: Missing predicate relation type
ro: Lipsește tipul de relație predicat

en: Missing second register for indexed-indirect mode.
ro: Lipsește al doilea registru pentru modul indexat-indirect.

en: Missing second register or offset for indexed-indirect mode.
ro: Lipsește al doilea registru sau decalaj pentru modul indexat-indirect.

en: Missing size argument
ro: Lipsește argumentul dimensiunii

en: Missing symbol name in directive
ro: Lipsește numele simbolului din directivă

en: Missing value for required parameter `%s' of macro `%s'
ro: Lipsește valoarea pentru parametrul necesar „%s” din macrocomenzii „%s”

en: Mixing of normal and extended addressing not supported
ro: Combinarea adresării normale și a adresării extinse nu este acceptată

en: Mixing register syntax, with and without '$'.
ro: Se amestecă sintaxa registrului, cu și fără „$”.

en: More than one AR register found in indirect reference
ro: Mai mult de un registru AR găsit în referința indirectă

en: More than one displacement found in indirect reference
ro: Mai mult de o deplasare găsită în referința indirectă

en: More than one relocation op per insn
ro: Mai mult de o operație de realocare per instrucțiune

en: Motorola 68HC11/68HC12/68HCS12 options:
      -m68hc11 | -m68hc12 |
      -m68hcs12 | -mm9s12x |
      -mm9s12xg               specify the processor [default %s]
      -mshort                 use 16-bit int ABI (default)
      -mlong                  use 32-bit int ABI
      -mshort-double          use 32-bit double ABI
      -mlong-double           use 64-bit double ABI (default)
      --force-long-branches   always turn relative branches into absolute ones
      -S,--short-branches     do not turn relative branches into absolute ones
                              when the offset is out of range
      --strict-direct-mode    do not turn the direct mode into extended mode
                              when the instruction does not support direct mode
      --print-insn-syntax     print the syntax of instruction in case of error
      --print-opcodes         print the list of instructions with syntax
      --xgate-ramoffset       offset ram addresses by 0xc000
      --generate-example      generate an example of each instruction
                              (used for testing)
ro: Opțiuni Motorola 68HC11/68HC12/68HCS12:
      -m68hc11 | -m68hc12 |
      -m68hcs12 | -mm9s12x |
      -mm9s12xg               specifică procesorul [implicit %s]
      -mshort                 utilizează ABI int pe 16 biți (implicit)
      -mlong                  utilizează ABI int pe 32 de biți
      -mshort-double          utilizează ABI dublu pe 32 de biți
      -mlong-double           utilizează ABI dublu pe 64 de biți (implicit)
      --force-long-branches   transformă întotdeauna ramurile relative în ramuri
                              absolute
      -S,--short-branches     nu transformă ramurile relative în ramuri absolute
                              atunci când decalajul este în afara intervalului
      --strict-direct-mode    nu transformă modul direct în modul extins atunci
                              când instrucțiunea nu acceptă modul direct
      --print-insn-syntax     imprimă sintaxa instrucțiunii în caz de eroare
      --print-opcodes         afișează lista de instrucțiuni cu sintaxa
      --xgate-ramoffset       decalarea adreselor ram cu 0xc000
      --generate-example      generează un exemplu pentru fiecare instrucțiune
                              (utilizată pentru testare)

en: Multiple .cpu directives found
ro: Multiple directive .cpu găsite

en: Multiple BFD_RELOC_NDS32_PTR_RESOLVED patterns are not supported yet!
ro: Modelele multiple BFD_RELOC_NDS32_PTR_RESOLVED nu sunt acceptate încă!

en: Multiply instructions support
ro: Suport pentru instrucțiuni de multiplicare

en: Must be in a space before changing or declaring subspaces.
ro: Trebuie să se afle într-un spațiu înainte de a modifica sau declara subspații.

en: NOTE: Such forms are deprecated and will be rejected by a future version of the assembler
ro: NOTĂ: Astfel de formate sunt depreciate și vor fi respinse de o versiune viitoare a asamblatorului

en: NS32K options:
    -m32032 | -m32532	select variant of NS32K architecture
    --disp-size-default=<1|2|4>
ro: Opțiuni NS32K:
    -m32032 | -m32532	selectează varianta de arhitectură NS32K
    --disp-size-default=<1|2|4>

en: NaN flavors are not supported by this target
ro: variantele de tip NaN nu sunt acceptate de această țintă

en: NaNs are not supported by this target
ro: NaN-urile nu sunt acceptate de această țintă

en: Name   # Modes  Min ops  Max ops  Modes mask  # Used
ro: Nume   Nr-moduri Min ops Max ops Mască moduri Nr-utilizat

en: Nan, using zero.
ro: Nan, se folosește zero.

en: Need #1 or #2 here
ro: Se necesită nr. 1 sau nr. 2 aici

en: Neon double or quad precision register expected
ro: se aștepta un registru de precizie dublă sau cuadruplă Neon

en: Neon quad precision register expected
ro: se aștepta un registru de precizie cuadruplă Neon

en: Neon single or double precision register expected
ro: se aștepta un registru de precizie simplă sau dublă Neon

en: Nested procedures
ro: Proceduri imbricate

en: No !literal!%ld was found
ro: Nu a fost găsit nici un !literal!%ld

en: No !tlsgd!%ld was found
ro: Nu a fost găsit nici un !tlsgd!%ld

en: No !tlsldm!%ld was found
ro: Nu a fost găsit nici un !tlsldm!%ld

en: No .ENTRY for this .EXIT
ro: Nu există .ENTRY pentru acest .EXIT

en: No addend allowed in @fptr() relocation
ro: Nu este permisă addenda în realocarea @fptr()

en: No comma after .pdesc <entryname>
ro: Fără virgulă după .pdesc <entryname>

en: No compiled in support for %d bit object file format
ro: Nu există suport compilat pentru formatul de fișier obiect de %d biți

en: No current frame
ro: Fără cadru curent

en: No instruction found
ro: Nu s-au găsit instrucțiuni

en: No instruction or missing opcode.
ro: Nicio instrucțiune sau codul operațional lipsește.

en: No lda !gpdisp!%ld was found
ro: Nu a fost găsit niciun lda !gpdisp!%ld

en: No ldah !gpdisp!%ld was found
ro: Nu a fost găsit nici un ldah !gpdisp!%ld

en: No operator
ro: Fără operator

en: No relocation operand
ro: Fără operand de realocare

en: No such entry in list. (cpu/mmu register)
ro: Nu există o astfel de intrare în listă. (registru cpu/mmu)

en: No such opcode
ro: Nu există un astfel de cod operațional

en: No symbol after .code_address
ro: Nici un simbol după .code_address

en: No symbol after .linkage
ro: Niciun simbol după .linkage

en: No valid label relocation operand
ro: Nici un operand de realocare a etichetei valid

en: Non-absolute symbol: '%s'.
ro: Simbol non-absolut: „%s”.

en: Non-constant symbols not allowed
ro: Simbolurile neconstante nu sunt permise

en: Non-global symbol: '%s' can't be a weak_definition.
ro: Simbol non-global: „%s” nu poate fi o weak_definition.

en: Not a defined coldfire architecture
ro: Nu este definită o arhitectură coldfire

en: Not a function type
ro: Nu este un tip de funcție

en: Not a symbolic expression
ro: Nu este o expresie simbolică

en: Not enough operands
ro: Nu sunt destui operanzi

en: Not in a space.
ro: Nu este într-un spațiu.

en: Not in a subspace.
ro: Nu este într-un subspațiu.

en: Not support instruction %s in verbatim.
ro: Nu există suport pentru instrucțiunea %s „în verbatim” cuvânt cu cuvânt.

en: Number of elements must be positive
ro: Numărul de elemente trebuie să fie pozitiv

en: Number too large
ro: Numărul este prea mare

en: OPF immediate operand out of range (0-0x1ff)
ro: operand imediat OPF în afara intervalului (0-0x1ff)

en: Odd numbered register used as target of multi-register instruction
ro: Registru cu număr impar utilizat ca țintă a unei instrucțiuni multiregistru

en: Odd register not allowed here
ro: Registrul impar nu este permis aici

en: Offset is outside of 15 bit range
ro: Decalajul este în afara intervalului de 15 biți

en: Offset on nested structures is ignored
ro: Decalajul pe structurile imbricate este ignorat

en: Offset out of 16-bit range for movw/movb insn: %ld
ro: Decalaj în afara intervalului de 16 biți pentru instrucțiunea movw/movb: %ld

en: Offset out of 16-bit range: %ld.
ro: Decalaj în afara intervalului de 16 biți: %ld.

en: Offset out of 5-bit range for movw/movb insn: %ld
ro: Decalaj în afara intervalului de 5 biți pentru instrucțiunea movw/movb: %ld

en: Offset out of 5-bit range for movw/movb insn: %ld.
ro: Decalaj în afara intervalului de 5 biți pentru insn movw/movb: %ld.

en: Offset out of 9-bit range for movw/movb insn: %ld
ro: Decalaj în afara intervalului de 9 biți pentru instrucțiunea movw/movb: %ld

en: One of these instructions may not be executed in parallel.
ro: Una dintre aceste instrucțiuni nu poate fi executată în paralel.

en: Only constant offsets are supported
ro: Sunt acceptate numai decalaje constante

en: Only constant space allocation is supported
ro: Este acceptată numai alocarea constantă a spațiului

en: Only one .compiler pseudo-op per file!
ro: Doar un singur pseudo-operator .compiler per fișier!

en: Only one .copyright pseudo-op per file!
ro: Doar un singur pseudo-operator .copyright per fișier!

en: Only one .version pseudo-op per file!
ro: Doar un singur pseudo-operator .version per fișier!

en: Only one comparison conditional allowed
ro: Este permisă o singură comparație condițională

en: Only one overflow conditional allowed
ro: Este permisă o singură depășire condițională

en: Only the first path encountering the conflict is reported
ro: Doar prima rută unde se întâlnește conflictul este raportată

en: Opcode %s not available in this mode
ro: Codul operațional %s nu este disponibil în acest mod

en: Opcode `%s' is not recognized.
ro: Codul operațional „%s” nu este recunoscut.

en: Opcode `%s' with these operand types not available in %s mode
ro: Codul operațional „%s” cu aceste tipuri de operanzi nu este disponibil în modul %s

en: Opcode `%s' with these operand types not available in H8/300 mode
ro: Codul operațional „%s” cu aceste tipuri de operanzi nu este disponibil în modul H8/300

en: Opcode `%s' with these operand types not available in H8/300H mode
ro: Codul operațional „%s” cu aceste tipuri de operanzi nu este disponibil în modul H8/300H

en: Opcode `%s' with these operand types not available in H8/300S mode
ro: Codul operațional „%s” cu aceste tipuri de operanzi nu este disponibil în modul H8/300S

en: Opcode(%d.%s):
ro: Cod operațional extins(%d.%s)

en: Operand "%s" out of range (use 1 or 2)
ro: Operand „%s” în afara intervalului (utilizați 1 sau 2)

en: Operand %d to .%s must be a constant
ro: Operandul %d pentru .%s trebuie să fie o constantă

en: Operand %d to .%s must be a preserved register
ro: Operandul %d al .%s trebuie să fie un registru conservat

en: Operand %d to .%s must be a writable register
ro: Operandul %d al .%s trebuie să fie un registru inscriptibil

en: Operand %u of `%s' should be %s
ro: Operandul %u din „%s” ar trebui să fie %s

en: Operand '%s' out of range (%d <= x <= %d)
ro: Operandul „%s” este în afara intervalului (%d <= x <= %d)

en: Operand `%x' not recognized in fixup16.
ro: Operandul „%x” nu este recunoscut în fixup16.

en: Operand `%x' not recognized in fixup8.
ro: Operandul „%x” nu este recunoscut în fixup8.

en: Operand has odd displacement (arg %d)
ro: Operandul are o deplasare impară (arg %d)

en: Operand is not a constant. `%s'
ro: Operandul nu este o constantă. „%s”

en: Operand mismatch
ro: Nepotrivire de operanzi

en: Operand of .vframe contradicts .prologue
ro: Operandul din .vframe contrazice .prologue

en: Operand out of 16-bit range: `%ld'.
ro: Operand în afara intervalului de 16 biți: „%ld”.

en: Operand out of 16-bit range: `%lld'.
ro: Operand în afara intervalului de 16 biți: „%lld”.

en: Operand out of 8-bit range: `%ld'.
ro: Operand în afara intervalului de 8 biți: „%ld”.

en: Operand out of 8-bit range: `%lld'.
ro: Operand în afara intervalului de 8 biți: „%lld”.

en: Operand out of range (arg %d)
ro: Operand în afara intervalului (arg %d)

en: Operand out of range for a relative branch: `%ld'
ro: Operand în afara intervalului pentru o ramură relativă: „%ld”

en: Operand out of range, %s.
ro: Operand în afara intervalului, %s.

en: Operand to .copy_state must be a constant
ro: Operandul pentru .copy_state trebuie să fie o constantă

en: Operand to .label_state must be a constant
ro: Operandul pentru .label_state trebuie să fie o constantă

en: Operand to .save.f must be a positive 20-bit constant
ro: Operandul pentru .save.f trebuie să fie o constantă pozitivă de 20 de biți

en: Operand to .spill must be a constant
ro: Operandul pentru .spill trebuie să fie o constantă

en: Operand to .vframesp must be a constant (sp-relative offset)
ro: Operandul pentru .vframesp trebuie să fie o constantă (deplasare relativă la sp)

en: Operand value is not within upper 64 KB (arg %d)
ro: Valoarea operandului nu este în limita superioară de 64 Ko (arg %d)

en: Operands to .save.gf may not be both zero
ro: Operanzii pentru .save.gf nu pot fi amândoi zero

en: Operator may only be applied to symbols.
ro: Operatorul poate fi aplicat numai simbolurilor.

en: Option -b is depreciated, please use -mbig
ro: Opțiunea „-b” este depreciată, vă rugăm să utilizați opțiunea „-mbig”

en: Option -p is depreciated, please use -mmemparm
ro: Opțiunea „-p” este depreciată, vă rugăm să utilizați opțiunea „-mmemparm”

en: Option -r is depreciated, please use -mregparm
ro: Opțiunea „-r” este depreciată, vă rugăm să utilizați opțiunea „-mregparm”

en: Option -s is depreciated, please use -msmall
ro: Opțiunea „-s” este depreciată, vă rugăm să utilizați opțiunea „-msmall”

en: Option `%s' is not recognized.
ro: Opțiunea „%s” nu este recunoscută.

en: Options:
      -a[sub-option...]	  turn on listings
                          	  Sub-options [default hls]:
                          	  c      omit false conditionals
                          	  d      omit debugging directives
                          	  g      include general info
                          	  h      include high-level source
                          	  i      include ginsn and synthesized CFI info
                          	  l      include assembly
                          	  m      include macro expansions
                          	  n      omit forms processing
                          	  s      include symbols
                          	  =FILE  list to FILE (must be last sub-option)
ro: Opțiuni:
      -a[sub-opțiune...]      activează listările
                              Sub-opțiuni [implicit hls]:
                              c        omite condiționalele false
                              d        omite directivele de depanare
                              g        include informații generale
                              h        include sursa de nivel înalt
                              l        include codul de asamblare
                              m        include expansiuni macro
                              n        omite procesarea formularelor
                              s        include simboluri
                              =FIȘIER  listează în FIȘIER (trebuie să fie ultima subopțiune)

en: Out-of-range .word offset handling is not implemented for .arch common_v10_v32
ro: Gestionarea decalajelor în afara intervalului .word nu este implementată pentru .arch common_v10_v32

en: Overflow in expression, truncated to 16 bits
ro: Depășire în expresie, trunchiată la 16 biți

en: Overflow in expression, truncated to 8 bits
ro: Depășire în expresie, trunchiată la 8 biți

en: Overwrite explicitly set Tag_ARC_ABI_rf16 to full register file
ro: Suprascrie definiția explicită a Tag_ARC_ABI_rf16 în întregul fișier de registru

en: Overwrite explicitly set Tag_ARC_CPU_base
ro: Suprascrie definiția explicită a  Tag_ARC_CPU_base

en: PC not allowed in register list
ro: PC nu este permis în lista de registre

en: PC part of operand unpredictable
ro: partea PC a operandului este imprevizibilă

en: PC relative branch to label %s which is not in the instruction space
ro: Ramificare relativă la PC la eticheta %s care nu se află în spațiul de instrucțiuni

en: PC relative relocation not allowed for (internal) type %d
ro: Nu este permisă realocarea relativă la PC pentru tipul (intern) %d

en: PC used as an argument to RPT
ro: PC utilizat ca argument pentru RPT

en: PC, CT, TR and TT are treated as if they are a single unit but operands must be in different units
ro: PC, CT, TR și TT sunt tratate ca și cum ar fi o singură unitate, dar operanzii trebuie să fie în unități diferite

en: PC-relative access out of range
ro: acces relativ la PC în afara intervalului

en: PC-relative access to misaligned address (%lx)
ro: acces relativ la PC la o adresă prost aliniată (%lx)

en: PC-relative access using misaligned offset (%lx)
ro: acces relativ la PC utilizând un decalaj prost aliniat (%lx)

en: PC-relative access using misaligned symbol (%lx)
ro: acces relativ la PC utilizând un simbol prost aliniat (%lx)

en: PC-relative offset not 4-byte-aligned
ro: decalajul relativ la PC nu este aliniat la 4 octeți

en: PC-relative offset out of range
ro: decalajul relativ la pc este în afara intervalului

en: PC-relative reference to a different section
ro: Referință relativă la PC la o secțiune diferită

en: PC-relative relocation must be trivially resolved
ro: Realocarea relativă la PC trebuie să fie rezolvată trivial

en: PIC code offset overflow (max 16 signed bits)
ro: depășirea decalajului codului PIC (max 16 biți cu semn)

en: PIC code offset overflow (max 32 signed bits)
ro: depășirea decalajului codului PIC (max 32 biți cu semn)

en: PIC relocation size does not match operand size
ro: Dimensiunea realocării PIC nu se potrivește cu dimensiunea operandului

en: PJ options:
    -little			generate little endian code
    -big			generate big endian code
ro: Opțiuni PJ:
    -little			generează cod little endian
    -big			generează cod big endian

en: PRU options:
      -mlink-relax     generate relocations for linker relaxation (default).
      -mno-link-relax  don't generate relocations for linker relaxation.
ro: Opțiuni PRU:
      -mlink-relax     generează realocări pentru relaxarea editorului de legături (implicit)
      -mno-link-relax  nu generează realocări pentru relaxarea editorului de legături

en: Parallel opcode cannot contain more than two instructions
ro: Codul operațional paralel nu poate conține mai mult de două instrucțiuni

en: Parameter named `%s' does not exist for macro `%s'
ro: Parametrul numit „%s” nu există pentru macrocomanda „%s”

en: Parameters of an existing subspace can't be modified
ro: Parametrii unui subspațiu existent nu pot fi modificați

en: Parse failed.
ro: Analizarea a eșuat.

en: Performance extension
ro: Extensie de performanță

en: Performance extension 2
ro: Extensie de performanță 2

en: Perhaps you are missing %%tpoff()?
ro: Poate că lipsește %%tpoff()?

en: Please report this bug.
ro: Raportați această eroare.

en: Please use --help to see usage and options for this assembler.
ro: Utilizați „--help” pentru a vedea modul de utilizare și opțiunile pentru acest asamblor.

en: Pointless default value for required parameter `%s' in macro `%s'
ro: Valoare implicită fără sens pentru parametrul necesar „%s” în macrocomanda „%s”

en: Pointless use of p0 as first operand to .%s
ro: Utilizarea inutilă a lui p0 ca prim operand la .%s

en: Pointless use of zero first operand to .prologue
ro: Utilizarea inutilă a primului operand zero pentru .prolog

en: Post-decrement mode is not valid for 68HC11.
ro: Modul post-decrement nu este valabil pentru 68HC11.

en: Post-increment mode is not valid for 68HC11.
ro: Modul post-increment nu este valabil pentru 68HC11.

en: PowerPC options:
ro: Opțiuni PowerPC:

en: Pre-increment mode is not valid for 68HC11
ro: Modul de pre-incrementare nu este valabil pentru 68HC11

en: Predicate register expected
ro: Se aștepta un registru de predicat

en: Predicate source and target required
ro: Sunt necesare sursa și ținta predicatului

en: Premature end of suffix -- Defaulting to d
ro: Sfârșitul prematur al sufixului -- Se trece implicit la „d”

en: Previous .save incomplete
ro: Precedentul .save incomplet

en: Processor variants are:
ro: Variantele de procesor sunt:

en: Prohibited register used for reduced-register, %s.
ro: Registru interzis utilizat pentru registrul redus, %s.

en: Pseudo register expected
ro: Se aștepta un pseudoregistru

en: Pseudocode already used %s
ro: Pseudocod deja utilizat %s

en: Pseudodirective .file is only valid when generating ELF
ro: Pseudodirectiva .file este valabilă numai atunci când se generează ELF

en: Pseudodirective .loc is only valid when generating ELF
ro: Pseudodirectiva .loc este valabilă numai atunci când se generează ELF

en: QUICKRoT 64-bit extension not applicable to this instruction
ro: extensia QUICKRoT pe 64 de biți nu se aplică la această instrucțiune

en: QUICKRoT extension requires 4 registers
ro: extensia QUICKRoT necesită 4 registre

en: Qualifying predicate expected
ro: Se aștepta un predicat calificativ

en: RA register is saved twice.
ro: Registrul RA este salvat de două ori.

en: REX prefix invalid with `%s'
ro: prefixul REX nu este valid cu „%s”

en: RISC-V options:
      -fpic or -fPIC              generate position-independent code
      -fno-pic                    don't generate position-independent code (default)
      -march=ISA                  set the RISC-V architecture
      -misa-spec=ISAspec          set the RISC-V ISA spec (2.2, 20190608, 20191213)
      -mpriv-spec=PRIVspec        set the RISC-V privilege spec (1.10, 1.11, 1.12)
      -mabi=ABI                   set the RISC-V ABI
      -mrelax                     enable relax (default)
      -mno-relax                  disable relax
      -march-attr                 generate RISC-V arch attribute
      -mno-arch-attr              don't generate RISC-V arch attribute
      -mcsr-check                 enable the csr ISA and privilege spec version checks
      -mno-csr-check              disable the csr ISA and privilege spec version checks (default)
      -mbig-endian                assemble for big-endian
      -mlittle-endian             assemble for little-endian
ro: Opțiuni RISC-V:
      -fpic sau -fPIC             generează cod independent de poziție
      -fno-pic                    nu generează cod independent de poziție (implicit)
      -march=ISA                  stabilește arhitectura RISC-V
      -misa-spec=ISAspec          stabilește specificația ISA RISC-V (2.2, 20190608, 20191213)
      -mpriv-spec=PRIVspec        stabilește specificația de privilegii RISC-V (1.10, 1.11, 1.12)
      -mabi=ABI                   stabilește ABI RISC-V
      -mrelax                     activează relaxarea (implicit)
      -mno-relax                  dezactivează relaxarea
      -march-attr                 generează atributul de arhitectură RISC-V
      -mno-arch-attr              nu generează atributul de arhitectură RISC-V
      -mcsr-check                 activează verificările versiunii ISA csr și ale specificațiilor
                                  privind privilegiile
      -mno-csr-check              dezactivează verificările versiunii ISA csr și ale specificațiilor
                                  privind privilegiile (implicit)
      -mbig-endian                asamblează pentru big-endian
      -mlittle-endian             asamblează pentru little-endian

en: R_TLSML relocation doesn't target a TOC entry named "_$TLSML": %s
ro: realocarea R_TLSML nu vizează o intrare TOC numită „_$TLSML”: %s

en: Radix `%s' unsupported or invalid
ro: Baza „%s” nu este acceptată sau nu este validă

en: Rd and Rm should be different in mla
ro: Rd și Rm trebuie să fie diferite în mla

en: Rd and Rm should be different in mul
ro: Rd și Rm trebuie să fie diferite în mul

en: Reduced Register configuration (GPR16) option
ro: Opțiune de configurare a registrului redus (GPR16)

en: Redundant `#' suffix operators
ro: Operatori de sufix „#” redundanți

en: Reg not valid for H8/300
ro: Registrul nu este valabil pentru H8/300

en: Register must be R0--R7
ro: Registrul trebuie să fie R0--R7

en: Register must be Rn
ro: Registrul trebuie să fie Rn

en: Register must be address register
ro: Registrul trebuie să fie un registru de adrese

en: Register must be an even register between r0-r10.
ro: Registrul trebuie să fie un registru par între r0-r10.

en: Register must be ivtp or tvtp
ro: Registrul trebuie să fie ivtp sau tvtp

en: Register must be r0-r14 except r13, or APSR_nzcv.
ro: Registrul trebuie să fie r0-r14, cu excepția r13, sau APSR_nzcv.

en: Register name %s conflicts with symbol of the same name
ro: Numele registrului %s intră în conflict cu simbolul cu același nume

en: Register name expected
ro: Se aștepta un nume de registru

en: Register number (R%ld) for double word access must be even.
ro: Numărul registrului (R%ld) pentru accesul la cuvânt dublu (double word) trebuie să fie par.

en: Register number must be EVEN
ro: Numărul registrului trebuie să fie PAR

en: Register number out of range 0..%u
ro: Număr de registru în afara intervalului 0..%u

en: Register symbol %s already defined.
ro: Simbolul de registru %s este deja definit.

en: Register value annotation ignored
ro: Adnotarea valorii registrului este ignorată

en: Registers cannot be used as a prefix of indexed expression [%s]
ro: Registrele nu pot fi utilizate ca prefix al expresiei indexate [%s]

en: Registers cannot be used within absolute expression [%s]
ro: Registrele nu pot fi utilizate în cadrul expresiei absolute [%s]

en: Registers cannot be used within immediate expression [%s]
ro: Registrele nu pot fi utilizate în cadrul expresiei imediate [%s]

en: Relaxation should never occur
ro: Relaxarea nu ar trebui să apară niciodată

en: Relaxation to long branches for .arch common_v10_v32 not implemented
ro: Relaxarea la ramificările lungi pentru .arch common_v10_v32 nu este implementată

en: Reloc %d not supported by object file format
ro: Realocarea %d nu este acceptată de formatul de fișier obiect

en: Relocatable values require at least WORD storage
ro: Valorile realocabile necesită cel puțin o stocare WORD

en: Relocation %d is not supported by object file format.
ro: Realocarea %d nu este acceptată de formatul de fișier obiect.

en: Relocation %s is not safe for %s
ro: Realocarea %s nu este sigură pentru %s

en: Relocation against a constant
ro: Realocare în raport cu o constantă

en: Relocation against a constant.
ro: Realocare în raport cu o constantă.

en: Relocation doesn't fit. (relocation value = 0x%lx)
ro: Realocarea nu se încadrează. (valoarea realocării = 0x%lx)

en: Relocation supported only in FDPIC mode
ro: Realocarea este acceptată numai în modul FDPIC

en: Report bugs to %s
ro: Raportați erorile la %s

en: Reserved word `%s' used as parameter in macro `%s'
ro: Cuvântul rezervat „%s” utilizat ca parametru în macrocomanda „%s”

en: Rn must not overlap other operands
ro: Rn nu trebuie să se suprapună peste alți operanzi

en: Rotating register index must be a non-negative constant
ro: Indicele registrului rotativ trebuie să fie o constantă ne-negativă

en: S+core co-processor register expected
ro: se aștepta un registru de co-procesor S+core

en: S+core register expected
ro: se aștepta un registru S+core

en: S+core special-register expected
ro: se aștepta registrul special S+core

en: S390 options:
      -m31                    generate 31-bit file format (31/32 bit word size)
      -m64                    generate 64-bit file format (64 bit word size)
      -mesa                   assemble for Enterprise System Architecture/390
      -mzarch                 assemble for z/Architecture
      -march=<processor>      assemble for processor <processor>
      -mregnames              allow symbolic names for registers
      -mno-regnames           do not allow symbolic names for registers
      -mwarn-areg-zero        warn about base/index register zero
      -mwarn-regtype-mismatch=strict
                              warn about register name type mismatches
      -mwarn-regtype-mismatch=relaxed
                              warn about register name type mismatches,
                              but allow FPR and VR to be used interchangeably
      -mno-warn-regtype-mismatch
                              do not warn about register name type mismatches
ro: Opțiuni S390:
      -m31                    generează format de fișier pe 31 de biți (dimensiunea
                              cuvântului pe 31/32 de biți)
      -m64                    generează format de fișier pe 64 de biți (dimensiunea
                              cuvântului pe 64 de biți)
      -mesa                   asamblează pentru Enterprise System Architecture/390
      -mzarch                 asamblează pentru z/Architecture
      -march=<procesor>       asamblează pentru procesorul <procesor>
      -mregnames              permite nume simbolice pentru registre
      -mno-regnames           nu permite nume simbolice pentru registre
      -mwarn-areg-zero        avertizează cu privire la registrul de bază/index zero
      -mwarn-regtype-mismatch=strict
                              avertizează cu privire la nepotrivirile tipului de nume
                              de registru
      -mwarn-regtype-mismatch=relaxed
                              avertizează cu privire la nepotrivirile între tipurile
                              de nume de registru, dar permite ca FPR și VR să fie
                              utilizate în mod interschimbabil
      -mno-warn-regtype-mismatch
                              nu avertizează cu privire la nepotrivirile de tip de
                              nume de registru

en: SCFI ignores most user-specified CFI directives
ro: SCFI ignoră majoritatea directivelor CFI specificate de utilizator

en: SCFI is not supported for this ABI
ro: SCFI nu este acceptat pentru această ABI

en: SCFI: Bad CFI propagation perhaps
ro: SCFI: probabil propagare CFI proastă

en: SCFI: Invalid DWARF CFI opcode data
ro: SCFI: date de cod operațional DWARF CFI nevalide

en: SCFI: asymetrical register restore
ro: SCFI: restaurarea registrului asimetric

en: SCFI: backward pass failed for func '%s'
ro: SCFI: trecerea înapoi a eșuat pentru funcția „%s”

en: SCFI: bad ginsn for func '%s'
ro: SCFI: ginsn greșit pentru funcția „%s”

en: SCFI: forward pass failed for func '%s'
ro: SCFI: trecerea înainte a eșuat pentru funcția „%s”

en: SCFI: hand-crafting instructions not supported
ro: SCFI: instrucțiunile create manual nu sunt acceptate

en: SCFI: missing previous SCFI endproc marker
ro: SCFI: lipsește marcajul endproc SCFI anterior

en: SCFI: unsupported for target
ro: SCFI: fără suport pentru țintă

en: SCFI: unsupported stack manipulation pattern
ro: SCFI: model de manipulare a stivei neacceptat

en: SCFI: usage of REG_FP as scratch not supported
ro: SCFI: utilizarea REG_FP ca valoare inițială nu este acceptată

en: SFrame unsupported offset value
ro: valoarea decalajului SFrame nu este acceptată

en: SH options:
    --little		generate little endian code
    --big			generate big endian code
    --relax			alter jump instructions for long displacements
    --renesas		disable optimization with section symbol for
    			compatibility with Renesas assembler.
    --small			align sections to 4 byte boundaries, not 16
    --dsp			enable sh-dsp insns, and disable floating-point ISAs.
    --allow-reg-prefix	allow '$' as a register name prefix.
    --isa=[any		use most appropriate isa
        | dsp               same as '-dsp'
        | fp
ro: SH options:
    --little             generează cod little endian
    --big                generează cod big endian
    --relax              modifică instrucțiunile de salt pentru deplasările lungi
    --renesas            dezactivează optimizarea cu simbolul secțiunii pentru
                         compatibilitatea cu asamblorul Renesas
    --small              aliniază secțiunile la limitele de 4 octeți, nu 16
    --dsp                activează instrucțiunile sh-dsp și dezactivează ISA-urile
                         în virgulă mobilă.
    --allow-reg-prefix   permite „$” ca prefix al numelui de registru
    --isa=[any           utilizează cea mai adecvată isa
        | dsp            la fel ca „-dsp”
        | fp

en: SHF_ALLOC isn't set for GNU_MBIND section: %s
ro: SHF_ALLOC nu este definit pentru secțiunea GNU_MBIND: %s

en: SMC is not permitted on this architecture
ro: SMC nu este permis pe această arhitectură

en: SP and PC not permitted in .unwind_movsp directive
ro: SP și PC nu sunt permise în directiva .unwind_movsp

en: SP not allowed in register list
ro: SP nu este permis în lista de registre

en: SPARC options:
ro: Opțiuni SPARC

en: SPU options:
      --apuasm		  emulate behaviour of apuasm
ro: Opțiuni SPU:
      --apuasm		  emulează comportamentul de apuasm

en: SRS base register must be r13
ro: registrul de bază SRS trebuie să fie r13

en: SSE instruction `%s' is used
ro: este folosită instrucțiunea SSE „%s”

en: SVC is not permitted on this architecture
ro: SVC nu este permis pe această arhitectură

en: SYMBOL TABLE not implemented
ro: SYMBOL TABLE nu este implementat

en: S^# may only read-access
ro: S^# poate avea acces numai-de-citire

en: S^# needs expression
ro: S^# necesită o expresie

en: Same src/dest register is used (`r%d'), result is undefined
ro: Este utilizat același registru sursă/destinație („r%d”), rezultatul este nedefinit

en: Same src/dest register is used (`r%d'),result is undefined
ro: Este utilizat același registru sursă/destinație („r%d”), rezultatul este nedefinit

en: Scaled-indexed addressing mode combined with scaled-index
ro: Mod de adresare cu indexare-scalară combinat cu index-scalat

en: Second operand of .save contradicts .prologue
ro: Al doilea operand al .save contrazice .prologue

en: Second operand to .%s not a constant
ro: Al doilea operand al .%s nu este o constantă

en: Second operand to .prologue must be a general register
ro: Al doilea operand al .prologue trebuie să fie un registru general

en: Second operand to .prologue must be the first of %d general registers
ro: Al doilea operand pentru .prologue trebuie să fie primul din %d registre generale

en: Second operand to .restore must be a constant >= 0
ro: Al doilea operand pentru .restore trebuie să fie o constantă >= 0

en: Second operand to .save not a valid register
ro: Al doilea operand pentru .save nu este un registru valid

en: Second operand to .save.b must be a general register
ro: Al doilea operand al .save.b trebuie să fie un registru general

en: Second operand to .save.b must be the first of %d general registers
ro: Al doilea operand pentru .save.b trebuie să fie primul din %d registre generale

en: Second operand to .save.g must be a general register
ro: Al doilea operand al .save.g trebuie să fie un registru general

en: Second operand to .save.g must be the first of %d general registers
ro: Al doilea operand pentru .save.g trebuie să fie primul din %d registre generale

en: Second operand to .save.gf must be a non-negative 20-bit constant
ro: Al doilea operand pentru .save.gf trebuie să fie o constantă ne-negativă de 20 de biți

en: Second operand to .unwabi must be a constant
ro: Al doilea operand al .unwabi trebuie să fie o constantă

en: Section switching in code is not supported.
ro: Comutarea secțiunilor în cod nu este acceptată.

en: Semantics error.  This type of operand can not be relocated, it must be an assembly-time constant
ro: Eroare de semantică. Acest tip de operand nu poate fi realocat, trebuie să fie o constantă în timp de asamblare.

en: Shift value > 32. using <value %% 32>
ro: Valoare de deplasare > 32. Se utilizează <valoare %% 32>

en: Shift value greater than 32. using <value %% 32>
ro: Valoarea de deplasare mai mare de 32. Se utilizează <valoarea %% 32>

en: Shift value should be in the range [0,31]
ro: Valoarea deplasării trebuie să fie în intervalul [0,31]

en: Short branches, Undefined, SVC, LDM/STM
ro: Ramificații scurte, nedefinite, SVC, LDM/STM

en: Short literal overflow(%ld.), immediate mode assumed.
ro: Depășirea literalului scurt (%ld.), se presupune modul imediat.

en: Signed immediate value %ld too large
ro: Valoarea imediată cu semn %ld este prea mare

en: Size of frame exceeds maximum of 96 registers
ro: Dimensiunea cadrului depășește numărul maxim de 96 de registre

en: Size of rotating registers exceeds frame size
ro: Dimensiunea registrelor de rotație depășește dimensiunea cadrului

en: Something forgot to clean up
ro: Ceva a uitat să curețe

en: Source and destination register should not be equal
ro: Registrul sursă și registrul destinație nu trebuie să fie egale

en: Source register for %s is no larger than the destination register
ro: Registrul sursă pentru %s nu este mai mare decât registrul destinație

en: Source registers must be in the same unit
ro: Registrele sursă trebuie să fie în aceeași unitate

en: Spurious `,' or bad indirect register addressing mode.
ro: Falsă „,” sau mod de adresare a registrului indirect greșit.

en: Spurious operands; (%d operands/instruction max)
ro: Operanzi nepotriviți; (%d operanzi/instrucțiune max)

en: Standalone `#' is illegal
ro: Un „#” singur este ilegal

en: String extension
ro: Extensie șir

en: Substitution symbols must begin with a letter
ro: Simbolurile de substituție trebuie să înceapă cu o literă

en: Subtype %d is not recognized.
ro: Subtipul %d nu este recunoscut.

en: Support for 64-bit arithmetic not compiled in.
ro: Suportul pentru aritmetica pe 64 de biți nu este compilat.

en: Supported ARCH values are:
ro: Valorile acceptate pentru ARHITECTURĂ sunt:

en: Swapping instruction order
ro: Schimbarea ordinii instrucțiunilor

en: Symbol %s used as immediate operand in PIC mode.
ro: Simbol %s utilizat ca operand imediat în modul PIC.

en: Symbol '%s' could not be created.
ro: Simbolul „%s” nu a putut fi creat.

en: Symbol `%s' can not be both weak and common
ro: Simbolul „%s” nu poate fi atât slab, cât și comun

en: Symbol expected
ro: Se aștepta un simbol

en: Symbol missing
ro: Lipsește simbolul

en: Symbol missing for .set/.equ
ro: Lipsește simbolul pentru .set/.equ

en: Symbol used as immediate for mbar instruction
ro: Simbol utilizat ca imediat pentru instrucțiunea mbar

en: Symbol used as immediate for shift instruction
ro: Simbol utilizat ca imediată pentru instrucțiunea de deplasare (shift)

en: Symbol used as immediate shift value for bit field instruction
ro: Simbol utilizat ca valoare de deplasare imediată pentru instrucțiunea de câmp de biți

en: Symbol used as immediate value for msrset/msrclr instructions
ro: Simbol utilizat ca valoare imediată pentru instrucțiunile msrset/msrclr

en: Symbol used as immediate width value for bit field instruction
ro: Simbol utilizat ca valoare a lățimii imediate pentru instrucțiunea câmpului de biți

en: Syntax in scaled-indexed mode, use [Rn:m] where n=[0..7] m={b,w,d,q}
ro: Sintaxă în modul indexat-scalat, utilizați [Rn:m] unde n=[0..7] m={b,w,d,q}

en: TLS relocation against a constant
ro: Realocare TLS față de o constantă

en: TLS relocation not allowed in FLIX bundle
ro: realocarea TLS nu este permisă în pachetul FLIX

en: TLS relocation size does not match operand size
ro: Dimensiunea realocării TLS nu se potrivește cu dimensiunea operandului

en: TLS_*_S9 relocs are not supported yet
ro: Relocările TLS_*_S9 nu sunt încă acceptate

en: TMS320C6000 options:
ro: Opțiuni TMS320C6000:

en: TOC section size exceeds 64k
ro: dimensiunea secțiunii TOC depășește 64k

en: TOKEN TRACE not implemented
ro: TOKEN TRACE nu este implementat

en: Tag must come before qualifying predicate.
ro: Eticheta trebuie să vină înaintea predicatului de calificare.

en: Tag name expected
ro: Se aștepta numele etichetei

en: Tags on unwind pseudo-ops aren't supported, yet
ro: Etichetele pe pseudo-ops de desfășurare nu sunt acceptate, încă

en: Target processor does not support this instruction.
ro: Procesorul țintă nu acceptă această instrucțiune.

en: The ".%s" pseudo-op is not implemented
ro: Pseudo-operatorul „.%s” nu este implementat

en: The %s operand doesn't match
ro: Operandul %s nu se potrivește

en: The .BTEQU pseudo-op is not implemented.
ro: Pseudo-operatorul .BTEQU nu este implementat.

en: The .DEFINE pseudo-op is not implemented
ro: Pseudo-operatorul .DEFINE nu este implementat

en: The .ENTER pseudo-op is not supported
ro: Pseudo-operatorul .ENTER nu este acceptat

en: The .LEAVE pseudo-op is not supported
ro: Pseudo-operatorul .LEAVE nu este acceptat

en: The .MACRO pseudo-op is not implemented
ro: Pseudo-operatorul .MACRO nu este implementat

en: The 64-bit file format is used without z/Architecture instructions.
ro: Formatul de fișier pe 64 de biți este utilizat fără instrucțiuni pentru arhitectura z/Architecture.

en: The destination and source registers are identical
ro: Registrele sursă și destinație sunt identice

en: The following ARC-specific assembler options are deprecated and are accepted
    for compatibility only:
ro: Următoarele opțiuni de asamblare specifice ARC sunt depreciate și sunt acceptate
    numai pentru compatibilitate:

en: The input '%s' and output '%s' files are the same
ro: Fișierele de intrare „%s” și de ieșire „%s” sunt aceleași

en: The option "--no-allow-flix" prohibits multi-slot flix.
ro: Opțiunea "--no-allow-flix" interzice flix-ul multi-slot.

en: The trap id must be a constant.
ro: Id-ul capturii trebuie să fie o constantă.

en: This architecture doesn't support atomic instruction
ro: Această arhitectură nu acceptă instrucțiuni atomice

en: This architecture doesn't support mmu
ro: Această arhitectură nu acceptă mmu

en: This assembler does not support processor generation %ld
ro: Acest asamblor nu acceptă generația de procesoare %ld

en: This assembler was configured for a target of `%s' and default,
    cpu type `%s'.
ro: Acest asamblor a fost configurat pentru o țintă de „%s” și implicit,
    tipul de CPU „%s”.

en: This assembler was configured for a target of `%s'.
ro: Acest asamblor a fost configurat pentru o țintă de „%s”.

en: This coprocessor register access is deprecated in ARMv8
ro: Acest acces la registrele coprocesorului este depreciat în ARMv8

en: This instruction may be unpredictable if executed on M-profile cores with interrupts enabled.
ro: Această instrucțiune poate fi imprevizibilă dacă este executată pe nuclee cu profil M cu întreruperi activate.

en: This is the location of the conflicting usage
ro: Aceasta este locația utilizării aflate în conflict

en: This label shouldn't be with addend.
ro: Această etichetă nu ar trebui să fie cu addenda.

en: This operator only produces two byte values.
ro: Acest operator produce doar două valori de octeți.

en: This program is free software; you may redistribute it under the terms of
    the GNU General Public License version 3 or later.
    This program has absolutely no warranty.
ro: Acest program este software liber; îl puteți redistribui în conformitate
    cu termenii Licenței Publice Generale GNU versiunea 3 sau ulterioară.
    Acest program nu are absolut nicio garanție.

en: Thumb does not support NOP with hints
ro: thumb nu acceptă NOP cu indicii

en: Thumb does not support conditional execution
ro: thumb nu acceptă execuția condițională

en: Thumb does not support negative register indexing
ro: thumb nu acceptă indexarea negativă a registrelor

en: Thumb does not support register indexing with writeback
ro: thumb nu acceptă indexarea registrelor cu scriere-înapoi

en: Thumb does not support register post-indexing
ro: thumb nu acceptă post-indexarea registrelor

en: Thumb does not support the 2-argument form of this instruction
ro: thumb nu acceptă forma cu 2 argumente a acestei instrucțiuni

en: Thumb does not support this addressing mode
ro: thumb nu acceptă acest mod de adresare

en: Thumb encoding does not support an immediate here
ro: codificarea thumb nu acceptă o imediată aici

en: Thumb encoding does not support rotation
ro: codificarea thumb nu acceptă rotația

en: Thumb load/store multiple does not support {reglist}^
ro: încărcarea/stocarea multiplă a thumb nu acceptă {reglist}^

en: Thumb supports only LSL in shifted register indexing
ro: thumb acceptă doar LSL în indexarea registrelor decalate

en: Thumb-2 MUL must not set flags
ro: MUL thumb-2 nu trebuie să activeze fanioane

en: Thumb-2 instruction only valid in unified syntax
ro: instrucțiunea thumb-2 este valabilă numai în sintaxa unificată

en: Thumb2 branch out of range
ro: ramificarea Thumb2 este în afara intervalului

en: Too few operands to '%s'.
ro: Prea puțini operanzi pentru „%s”.

en: Too many argument. `%s'
ro: Prea multe argumente. „%s”

en: Too many instructions for bundle.
ro: Prea multe instrucțiuni pentru pachet.

en: Too many operands
ro: Prea mulți operanzi

en: Too many operands passed to instruction
ro: Prea mulți operanzi trecuți în instrucțiune

en: Too many operands scanned
ro: Prea mulți operanzi scanați

en: Too many operands: %s
ro: Prea mulți operanzi: %s

en: Too many registers popped
ro: Prea multe registre scoase

en: Trap id `%ld' is out of range.
ro: Id-ul capturii „%ld” este în afara intervalului.

en: Trap id `%lld' is out of range.
ro: Id-ul capturii „%lld” este în afara intervalului.

en: Trap id must be within [0x30..0x39] or [0x40..0xff].
ro: Id-ul capturii trebuie să fie între [0x30..0x39] sau [0x40..0xff].

en: Treating '%-*s' as a symbol.
ro: Se tratează „%-*s” ca un simbol.

en: Tried to .set unrecognized mode `%s'
ro: S-a încercat .set pentru modul nerecunoscut „%s”

en: Tried to convert PC relative branch to absolute jump
ro: S-a încercat convertirea ramurii relative PC în salt absolut

en: Two IU instructions may not be executed in parallel
ro: Două instrucțiuni IU nu pot fi executate în paralel

en: Two MU instructions may not be executed in parallel
ro: Două instrucțiuni MU nu pot fi executate în paralel

en: Two instructions in the same bundle both write to register %s, which is not allowed.
ro: Două instrucțiuni din același pachet scriu ambele în registrul %s, ceea ce nu este permis.

en: Type is not allowed for this instruction
ro: Tipul nu este permis pentru această instrucțiune

en: Unable to allocate memory for new instructions
ro: Nu se poate aloca memorie pentru instrucțiuni noi

en: Unable to determine default target processor from string: %s
ro: Nu se poate determina procesorul țintă implicit din șirul: %s

en: Unable to find %s relocation for instruction %s
ro: Nu se poate găsi realocarea %s pentru instrucțiunea %s

en: Unable to generate `%s' compliant code without mthc1
ro: Imposibil de generat cod conform „%s” fără mthc1

en: Unable to mix instructions as specified
ro: Nu se pot amesteca instrucțiunile conform specificațiilor

en: Unable to parse TLS base: %s
ro: Nu se poate analiza baza TLS: %s

en: Unable to process relocation for thumb opcode: %lx
ro: Nu se poate procesa realocarea pentru codul operațional thumb: %lx

en: Unable to produce reloc against symbol '%s'
ro: Imposibil de produs realocarea în raport cu simbolul „%s”

en: Unable to use @pcl relocation for insn %s
ro: Nu se poate utiliza realocarea @pcl pentru instrucțiunea %s

en: Unable to use @plt relocation for insn %s
ro: Nu se poate utiliza realocarea @plt pentru instrucțiunea %s

en: Unaligned operand. Needs to be 16bit aligned
ro: Operand nealiniat. Trebuie să fie aliniat pe 16 de biți.

en: Unaligned operand. Needs to be 32bit aligned
ro: Operand nealiniat. Trebuie să fie aliniat pe 32 de biți.

en: Unary operator %c ignored because bad operand follows
ro: Operatorul unar %c ignorat deoarece urmează un operand greșit

en: Unbalanced parenthesis in %s operand.
ro: Paranteză nepereche în operandul %s.

en: Unbalanced parenthesis in operand %d
ro: Paranteză dezechilibrată(fără pereche) în operandul %d

en: Undefined .EXPORT/.IMPORT argument (ignored): %s
ro: Argument .EXPORT/.IMPORT nedefinit (ignorat): %s

en: Undefined absolute constant: '%s'.
ro: Constantă absolută nedefinită: „%s”.

en: Undefined register: '%s'.
ro: Registru nedefinit: „%s”.

en: Undefined space: '%s' Assuming space number = 0.
ro: Spațiu nedefinit: „%s” Presupunând că numărul spațiului = 0.

en: Undefined substitution symbol '%s'
ro: Simbol de substituție nedefinit „%s”

en: Unexpected branch conversion with `%x'
ro: Conversie neașteptată a ramurii cu „%x”

en: Unexpected character '%c' after operand %d to %s.
ro: Caracter neașteptat „%c” după operandul %d la %s.

en: Unexpected reference to a symbol in a non-code section
ro: Referință neașteptată la un simbol într-o secțiune fără cod

en: Unhandled dependency %s for %s (%s), note %d
ro: Dependență nesoluționată %s pentru %s (%s), nota %d

en: Unhandled reloc type
ro: Tip de realocare negestionat

en: Unimplemented register `%s' specified
ro: Registru neimplementat „%s” specificat

en: Unknown .syntax operand
ro: Operand .syntax necunoscut

en: Unknown CPU identifier `%s'
ro: Identificator CPU necunoscut „%s”

en: Unknown TMS320C30 instruction: %s
ro: Instrucțiune necunoscută TMS320C30: %s

en: Unknown cpu -mcpu=%s
ro: Cpu necunoscut -mcpu=%s

en: Unknown exception: `%s'
ro: Excepție necunoscută: „%s”

en: Unknown extension
ro: Extensie necunoscută

en: Unknown indirect addressing mode
ro: Mod de adresare indirectă necunoscut

en: Unknown instruction '%s'
ro: Instrucțiune necunoscută „%s”

en: Unknown instruction `%s'
ro: Instrucțiune necunoscută „%s”

en: Unknown opcode `%.*s'.
ro: Cod operațional necunoscut: „%.*s”.

en: Unknown opcode `%s'
ro: Cod operațional necunoscut „%s”

en: Unknown opcode `%s'.
ro: Cod operațional necunoscut „%s”.

en: Unknown opcode: `%s'
ro: Cod operațional necunoscut: „%s”

en: Unknown operator
ro: Operator necunoscut

en: Unknown processor register (32 bit) : `%d'
ro: Registru de procesor necunoscut (32 biți) : „%d”

en: Unknown processor register : `%d'
ro: Registru de procesor necunoscut : „%d”

en: Unknown psr option `%s'
ro: Opțiune psr necunoscută „%s”

en: Unknown register no. encountered: %d
ro: Număr de registru necunoscut întâlnit: %d

en: Unknown register pair - index relative mode: `%d'
ro: Pereche de registre necunoscută - modul de indexare relativ: „%d”

en: Unknown register pair: `%d'
ro: Pereche de registre necunoscută: „%d”

en: Unknown register: `%d'
ro: Registru necunoscut: „%d”

en: Unknown reloc in md_apply_fix: %s
ro: Realocare necunoscută în md_apply_fix: %s

en: Unknown relocation encountered in md_apply_fix.
ro: Realocare necunoscută întâlnită în md_apply_fix.

en: Unknown relocation operand: !%s
ro: Operand de realocare necunoscut: !%s

en: Unknown relocation operand: @%s
ro: Operand de realocare necunoscut: @%s

en: Unknown segment type
ro: Tip de segment necunoscut

en: Unknown size of floating point registers
ro: Dimensiune necunoscută a registrelor în virgulă mobilă

en: Unknown type
ro: Tip necunoscut

en: Unknown type %c
ro: Tip necunoscut „%c”

en: Unknown visibility field in .comm
ro: Câmp de vizibilitate necunoscut în .comm

en: Unknown visibility field in .extern
ro: Câmp de vizibilitate necunoscut în .extern

en: Unknown visibility field in .globl
ro: Câmp de vizibilitate necunoscut în .globl

en: Unknown visibility field in .weak
ro: Câmp de vizibilitate necunoscut în .weak

en: Unmatched high relocation
ro: Realocare înaltă fără coincidență

en: Unmatched high/shigh reloc
ro: Realocare înaltă/super-înaltă fără coincidență

en: Unrecognised CPU errata name starting here: %s
ro: Numele eratei CPU-ului nerecunoscut începe aici: %s

en: Unrecognised option: -hidden
ro: Opțiune nerecunoscută: „-hidden”

en: Unrecognized .LEVEL argument
ro: Argument .LEVEL nerecunoscut

en: Unrecognized .type argument
ro: Argument .type nerecunoscut

en: Unrecognized condition code "%s"
ro: Cod de condiție nerecunoscut „%s”

en: Unrecognized dependency specifier %d
ro: Specificator de dependență nerecunoscut %d

en: Unrecognized field type '%c'
ro: Tip de câmp nerecunoscut „%c”

en: Unrecognized indirect address format "%s"
ro: Format de adresă indirectă nerecunoscut „%s”

en: Unrecognized instruction "%s"
ro: Instrucțiune nerecunoscută „%s”

en: Unrecognized opcode format: `%s'
ro: Format de cod operațional nerecunoscut: „%s”

en: Unrecognized opcode, %s.
ro: Cod operațional nerecunoscut, %s.

en: Unrecognized opcode: `%s'
ro: Cod operațional nerecunoscut: „%s”

en: Unrecognized operand list '%s' for instruction '%s'
ro: Listă de operanzi nerecunoscută „%s” pentru instrucțiunea „%s”

en: Unrecognized operand/register, %s.
ro: Operand/registru nerecunoscut, %s.

en: Unrecognized option '-x%s'
ro: Opțiune nerecunoscută „-x%s”

en: Unrecognized option following -K
ro: Opțiune nerecunoscută după „-K”

en: Unrecognized or unsupported floating point constant
ro: Constantă în virgulă mobilă nerecunoscută sau neacceptată

en: Unrecognized parallel instruction "%s"
ro: Instrucțiune paralelă nerecunoscută „%s”

en: Unrecognized parallel instruction '%s'
ro: Instrucțiune paralelă nerecunoscută „%s”

en: Unrecognized parallel instruction combination "%s || %s"
ro: Combinație de instrucțiuni paralele nerecunoscută „%s || %s”

en: Unrecognized predicate relation type
ro: Tip de relație predicat nerecunoscut

en: Unrecognized section '%s'
ro: Secțiune nerecunoscută „%s”

en: Unrecognized status bit "%s"
ro: Bit de stare nerecunoscut „%s”

en: Unrecognized struct/union tag '%s'
ro: Etichetă struct/union „%s” nerecunoscută

en: Unrecognized substitution symbol function
ro: Funcție simbol de substituție nerecunoscută

en: Unrecognized vector size specifier
ro: Specificator de dimensiune a vectorului nerecunoscut

en: Unrecognized vector size specifier ignored
ro: Specificator de dimensiune a vectorului nerecunoscut ignorat

en: Unrecognized version '%s'
ro: Versiune nerecunoscută „%s”

en: Unsigned immediate value %ld too large
ro: Valoarea imediată fără semn %ld este prea mare

en: Unsupported broadcast: `%s'
ro: Difuzare neacceptată: „%s”

en: Unsupported fixup size %d
ro: Dimensiune de remediere neacceptată: %d

en: Unsupported instruction set extension: %s
ro: Extensie neacceptată a setului de instrucțiuni: %s

en: Unsupported operation on reloc
ro: Operație neacceptată la realocare

en: Unsupported processor generation %d
ro: Generație de procesor %d neacceptată

en: Unsupported relocation size %d
ro: Dimensiune de realocare neacceptată %d

en: Unsupported use of %s
ro: Utilizare neadmisă a %s

en: Unsupported use of .gpword
ro: Utilizare neadmisă a .gpword

en: Unsupported use of sp
ro: Utilizare neacceptată a sp

en: Unterminated string after absolute expression
ro: Șir neterminat după expresia absolută

en: Unwind directive not followed by an instruction.
ro: Directiva de derulare nu este urmată de o instrucțiune.

en: Usage: %s [option...] [asmfile...]
ro: Utilizare: %s [opțiune...] [fișier-limbaj-asamblare...]

en: Use of .def/.ref is deprecated.  Use .global instead
ro: Utilizarea .def/.ref este depreciată. Utilizați în schimb .global

en: Use of PC here is UNPREDICTABLE
ro: Utilizarea lui PC aici este IMPREVIZIBILĂ

en: Use of PC here is deprecated
ro: Utilizarea lui PC aici este depreciată

en: Use of an RX string instruction detected in a file being assembled without string instruction support
ro: Utilizarea unei instrucțiuni de șir RX detectată într-un fișier asamblat fără suport pentru instrucțiuni de șir

en: Use of p0 is not valid in this context
ro: Utilizarea lui p0 nu este valabilă în acest context

en: Use of r%u as a source register is deprecated when r%u is the destination register.
ro: Utilizarea lui r%u ca registru sursă nu mai este necesară atunci când r%u este registrul destinație.

en: Use the .mmregs directive to use memory-mapped register names such as '%s'
ro: Utilizați directiva .mmregs pentru a utiliza nume de registre cu alocare de memorie, cum ar fi „%s”

en: Used $at without ".set noat"
ro: S-a utilizat $at fără „.set noat”

en: Used FPU instructions requires enabling FPU extension
ro: Instrucțiunile FPU utilizate necesită activarea extensiei FPU

en: Used more than the available 48 rotating registers
ro: S-a utilizat mai mult decât cele 48 de registre rotative disponibile

en: Used more than the available 96 rotating registers
ro: S-a utilizat mai mult decât cele 96 de registre rotative disponibile

en: Used more than the declared %d rotating registers
ro: Au fost utilizate mai multe registre rotative decât cele declarate %d

en: Using ENTRY rather than CODE in export directive for %s
ro: Se utilizează ENTRY în loc de CODE în directiva de export pentru %s

en: Using a constant as second operand to .prologue is deprecated
ro: Utilizarea unei constante ca al doilea operand în .prologue este depreciată

en: Using old style, %%hi(expr), please change to PPC style, expr@h.
ro: Se utilizează stilul vechi, %%hi(expr), vă rugăm să treceți la stilul PPC, expr@h.

en: Using old style, %%lo(expr), please change to PPC style, expr@l.
ro: Se utilizează stilul vechi, %%lo(expr), vă rugăm să treceți la stilul PPC, expr@l.

en: Using temp register (r1)
ro: Se utilizează registrul temp (r1)

en: Using temp register(r1)
ro: Se utilizează registrul temp(r1)

en: VAX options:
    -d LENGTH		ignored
    -J			ignored
    -S			ignored
    -t FILE			ignored
    -T			ignored
    -V			ignored
ro: Opțiuni VAX:\n"
    -d LUNGIME                se ignoră
    -J                        se ignoră
    -S                        se ignoră
    -t FIȘIER                 se ignoră
    -T                        se ignoră
    -V                        se ignoră

en: VFP registers must be adjacent
ro: registrele VFP trebuie să fie adiacente

en: VFP single or double precision register expected
ro: se aștepta un registru de precizie simplă sau dublă VFP

en: VFP single precision register expected
ro: se aștepta un registru de precizie simplă VFP

en: VFP single precision register or VPR expected
ro: se aștepta un registru de precizie simplă VFP sau VPR

en: VFP single, double or MVE vector register expected
ro: se aștepta un registru de precizie simplă sau dublă VFP sau un registru vectorial MVE

en: VFP single, double or Neon quad precision register expected
ro: se aștepta un registru de precizie simplă, dublă VFP sau cuadruplă Neon

en: VFP system register expected
ro: se aștepta un registru de sistem VFP

en: VFP/Neon double precision register expected
ro: se aștepta un registru de precizie dublă VFP/Neon

en: VFP/Neon double precision register or VPR expected
ro: se aștepta un registru de precizie dublă VFP/Neon sau VPR

en: VLIW packing constraint violation
ro: Încălcarea constrângerii de împachetare VLIW

en: VLIW packing used for -mno-pack
ro: Împachetarea VLIW utilizată pentru „-mno-pack”

en: VMS options:
    -+			encode (don't truncate) names longer than 64 characters
    -H			show new symbol after hash truncation
    -replace/-noreplace	enable or disable the optimization of procedure calls
ro: Opțiuni VMS:
    -+			codifică (nu trunchiază) numele mai lungi de 64 de caractere
    -H			afișează noul simbol după trunchierea hash
    -replace/-noreplace	activează sau dezactivează optimizarea apelurilor de procedură

en: VPR expected last
ro: se aștepta ca VPR să fie ultimul

en: VSIB unavailable with legacy encoding
ro: VSIB nu este disponibil cu codificarea veche

en: Value %d and %d out of range
ro: Valorile %d și %d sunt în afara intervalului

en: Value %d doesn't fit in signed %d-bit field
ro: Valoarea %d nu se încadrează în câmpul cu semn de %d biți

en: Value %d doesn't fit in unsigned %d-bit field
ro: Valoarea %d nu se încadrează în câmpul fără semn de %d biți

en: Value %ld not aligned by 2 for 10-bit PC-relative branch.
ro: Valoarea %ld nu este aliniată cu 2 pentru ramificarea relativă la PC pe 10 biți.

en: Value %ld not aligned by 2 for 9-bit PC-relative branch.
ro: Valoarea %ld nu este aliniată cu 2 pentru ramificarea relativă la PC pe 9 biți.

en: Value %ld too large for 10-bit PC-relative branch.
ro: Valoarea %ld este prea mare pentru ramura relativă la PC pe 10 biți.

en: Value %ld too large for 8-bit PC-relative branch.
ro: Valoarea %ld este prea mare pentru ramura relativă la PC pe 8 biți.

en: Value %ld too large for 9-bit PC-relative branch.
ro: Valoarea %ld este prea mare pentru ramura relativă la PC pe 9 biți.

en: Value for ENTRY_FR must be in the range 12..21
ro: Valoarea pentru ENTRY_FR trebuie să fie cuprinsă în intervalul 12...21

en: Value for ENTRY_GR must be in the range 3..18
ro: Valoarea pentru ENTRY_GR trebuie să fie cuprinsă în intervalul 3...18

en: Value for ENTRY_SR must be 3
ro: Valoarea pentru ENTRY_SR trebuie să fie 3

en: Value for parameter `%s' of macro `%s' was already specified
ro: Valoarea pentru parametrul „%s” al macrocomenzii „%s” a fost deja specificată

en: Value not in 16 bit range: %ld
ro: Valoarea nu se află în intervalul de 16 biți: %ld

en: Value not in 16 bit signed range: %ld
ro: Valoarea nu se află în intervalul de 16 biți cu semn: %ld

en: Value not in 4 bit unsigned range: %ld
ro: Valoarea nu se află în intervalul de 4 biți fără semn: %ld

en: Value not in 5 bit unsigned range: %ld
ro: Valoarea nu se află în intervalul de 5 biți fără semn: %ld

en: Value not in 6 bit range: %ld
ro: Valoarea nu se află în intervalul de 6 biți: %ld

en: Value not in 6 bit unsigned range: %ld
ro: Valoarea nu se află în intervalul de 6 biți fără semn: %ld

en: Value not in 8 bit range: %ld
ro: Valoarea nu se află în intervalul de 8 biți: %ld

en: Value not in 8 bit signed range: %ld
ro: Valoarea nu se află în intervalul de 8 biți cu semn: %ld

en: Value out of 16-bit range.
ro: Valoare în afara intervalului de 16 biți.

en: Value out of 3-bit range.
ro: Valoare în afara intervalului de 3 biți.

en: Value out of 4-bit range.
ro: Valoare în afara intervalului de 4 biți.

en: Value out of 5-bit range.
ro: Valoare în afara intervalului de 5 biți.

en: Value truncated to 62 bits
ro: Valoare trunchiată la 62 de biți

en: Variable is accessed using small data read only anchor, but it is not in the small data read only section
ro: Variabila este accesată utilizând ancorarea numai-citire pentru date mici, dar nu se află în secțiunea numa-citire pentru date mici

en: Variable is accessed using small data read write anchor, but it is not in the small data read write section
ro: Variabila este accesată utilizând ancorarea de citire și scriere a datelor mici, dar nu este în secțiunea de citire și scriere a datelor mici

en: Very short instr to option, ie you can't do it on a NULLstr
ro: Instrucțiune foarte scurtă pentru opțiune, adică nu o puteți face pe un NULLstr

en: Warning:
ro: Atenție:

en: Warning: 32-bit element size and same destination and source operands makes instruction UNPREDICTABLE
ro: Atenție: dimensiunea elementului pe 32 de biți și aceiași operanzi destinație și sursă fac ca instrucțiunea să fie IMPREDICTIBILĂ

en: Warning: 32-bit element size and same first and third operand makes instruction UNPREDICTABLE
ro: Atenție: dimensiunea elementului pe 32 de biți și același prim și al treilea operand fac ca instrucțiunea să fie IMPREVIZIBILĂ

en: Warning: 64-bit element size and same destination and source operands makes instruction UNPREDICTABLE
ro: Atenție: dimensiunea elementului pe 64 de biți și aceiași operanzi destinație și sursă fac ca instrucțiunea să fie IMPREDICTIBILĂ

en: Warning: conditional outside an IT block for Thumb.
ro: Atenție: condițional în afara unui bloc IT pentru Thumb.

en: Warning: duplicated register (r%d) in register list
ro: Atenție: registru duplicat (r%d) în lista de registre

en: Warning: instruction is UNPREDICTABLE in a VPT block
ro: Avertisment: instrucțiunea este IMPREDICTIBILĂ într-un bloc VPT

en: Warning: instruction is UNPREDICTABLE in an IT block
ro: Avertisment: instrucțiunea este IMPREDICTIBILĂ într-un bloc IT

en: Warning: instruction is UNPREDICTABLE with PC operand
ro: Avertisment: instrucțiunea este IMPREDICTIBILĂ cu operandul PC

en: Warning: instruction is UNPREDICTABLE with SP operand
ro: Avertisment: instrucțiunea este IMPREDICTIBILĂ cu operandul SP

en: Warning: internal error: forgetting to set endndx of %s
ro: Avertisment: eroare internă: s-a uitat să se stabilească endndx din %s

en: Warning: register list not in ascending order
ro: Avertisment: lista de registre nu este în ordine crescătoare

en: Warning: register range not in ascending order
ro: Atenție: intervalul de registre nu este în ordine crescătoare

en: Width value + shift value must not be greater than 32
ro: Valoarea lățimii + valoarea deplasării nu trebuie să fie mai mare de 32

en: Width value must be less than 32
ro: Valoarea lățimii trebuie să fie mai mică de 32

en: Writes to register '%s' are not allowed.
ro: Scrierile în registrul „%s” nu sunt permise.

en: Wrong displacement %d
ro: Deplasare greșită %d

en: Wrong number of input operands
ro: Număr greșit de operanzi de intrare

en: Wrong number of operands
ro: Număr greșit de operanzi

en: Wrong number of output operands
ro: Număr greșit de operanzi de ieșire

en: Wrong numbers of operands in default, check ns32k-opcodes.h
ro: Număr greșit de operanzi în mod implicit, verificați ns32k-opcodes.h

en: Wrong register in floating-point reglist
ro: Registru greșit în lista de registre în virgulă mobilă

en: Wrong register in register indirect mode.
ro: Registru greșit în modul registru indirect.

en: Wrong size pointer register for architecture.
ro: Registru indicator de dimensiune greșită pentru arhitectură.

en: XScale accumulator register expected
ro: se aștepta un registru acumulator XScale

en: Xtensa absolute literals option not supported; ignored
ro: Opțiunea literale absolute a Xtensa nu este acceptată; se ignoră

en: ZA tile masks do not operate at .Q granularity
ro: măștile de piese ZA nu funcționează la granularitatea .Q

en: ZA tile number out of range
ro: numărul de piese ZA este în afara intervalului

en: ZR register expected
ro: se aștepta un registru ZR

en: [-mwarn-syms]: Assignment makes a symbol match an ARM instruction: %s
ro: [-mwarn-syms]: Asignarea face ca un simbol să corespundă unei instrucțiuni ARM: %s

en: [0-9]H labels do not mix with dot-pseudos
ro: etichetele [0-9]H nu pot fi amestecate cu dot-pseudos

en: [0-9]H labels may not appear alone on a line
ro: etichetele [0-9]H nu pot apărea singure pe o linie

en: [PC] index banned
ro: index [PC] interzis

en: []index same as ()+register: unpredictable
ro: []index la fel ca ()+registru: imprevizibil

en: []index same as -()register: unpredictable
ro: []index la fel ca -()registru: imprevizibil

en: [ieee|alternative]
                              set the encoding for half precision floating point numbers to IEEE
                              or Arm alternative format.
ro: [ieee|alternative]
                              stabilește codificarea numerelor în virgulă mobilă de
                              semiprecizie la IEEE sau formatul alternativ Arm.

en: [no-]generics is deprecated; use [no-]transform instead
ro: [no-]generics este depreciată; utilizați în schimb [no-]transform

en: [no-]relax is deprecated; use [no-]transform instead
ro: [no-]relax este depreciată; utilizați în schimb [no-]transform

en: `%s %d' after `%s %d' from %s:%u
ro: „%s %d” după „%s %d” din %s:%u

en: `%s %d' but no chunk open yet
ro: „%s %d”, dar niciun fragment nu este deschis încă

en: `%s%c' is not supported in 64-bit mode
ro: „%s%c” nu este acceptat în modul pe 64 de biți

en: `%s%c' is only supported in 64-bit mode
ro: „%s%c” este acceptat numai în modul pe 64 de biți

en: `%s%s' can't be used for write mask
ro: „%s%s” nu poate fi utilizat pentru masca de scriere

en: `%s%s' cannot be used here
ro: „%s%s” nu poate fi utilizat aici

en: `%s%s' not allowed with `%s%c'
ro: „%s%s” nu este permis cu „%s%c”

en: `%s' Illegal count-register combination.
ro: „%s” Combinație de registru-contorizare ilegală.

en: `%s' Illegal use of register.
ro: „%s” Utilizare ilegală a registrului.

en: `%s' Illegal use of registers.
ro: „%s” Utilizare ilegală a registrelor.

en: `%s' and `%s' can't be undefined in `%s' - `%s'
ro: „%s” și „%s” nu pot fi nedefinite în „%s” - „%s”

en: `%s' can't be equated to common symbol `%s'
ro: „%s” nu poate fi echivalat cu simbolul comun „%s”

en: `%s' can't be undefined in `%s' - `%s' {%s section}
ro: „%s” nu poate fi nedefinit în „%s” - „%s” {secțiunea %s}

en: `%s' can't be undefined in `%s' {%s section} - `%s'
ro: „%s” nu poate fi nedefinit în „%s” {secțiunea %s} - „%s”

en: `%s' can't be versioned to common symbol '%s'
ro: „%s” nu poate fi versiunea la simbolul comun „%s”

en: `%s' can't go in %s of %s template
ro: „%s” nu poate merge în %s din șablonul %s

en: `%s' cannot be predicated
ro: „%s” nu poate fi predicat

en: `%s' cannot be used here
ro: „%s” nu poate fi utilizat aici

en: `%s' cannot be used with `%s'
ro: „%s” nu poate fi utilizat cu „%s”

en: `%s' does not fit into %s template
ro: „%s” nu se încadrează în șablonul %s

en: `%s' does not fit into bundle
ro: „%s” nu se încadrează în pachet

en: `%s' does not support legacy NaN
ro: „%s” nu acceptă vechiul (legacy) NaN

en: `%s' has undefined result
ro: „%s” are un rezultat nedefinit

en: `%s' invalid when little-endian
ro: „%s” nu este valid când este little-endian

en: `%s' is already the alias of %s `%s'
ro: „%s” este deja alias al %s „%s”

en: `%s' is deprecated, use `%s'
ro: „%s” este depreciat, utilizați „%s”

en: `%s' is not a valid %s expression
ro: „%s” nu este o expresie %s validă

en: `%s' is not a valid parameter qualifier for `%s' in macro `%s'
ro: „%s” nu este un calificativ de parametru valid pentru „%s” în macrocomanda „%s”

en: `%s' is not supported in 64-bit mode
ro: „%s” nu este acceptat în modul pe 64 de biți

en: `%s' is not supported on `%s%s'
ro: „%s” nu este acceptat pe „%s%s”

en: `%s' is not supported on `%s'
ro: „%s” nu este acceptat pe „%s”

en: `%s' is not valid here (expected `%c%s%s%c')
ro: „%s” nu este valid aici (se aștepta „%c%s%s%c”)

en: `%s' is only supported in 64-bit mode
ro: „%s” este acceptat numai în modul pe 64 de biți

en: `%s' must be last in bundle
ro: „%s” trebuie să fie ultimul din pachet

en: `%s' must be last in instruction group
ro: „%s” trebuie să fie ultima în grupul de instrucțiuni

en: `%s' operand %u must use `%ses' segment
ro: operandul „%s” %u trebuie să utilizeze segmentul „%ses”

en: `%s' should be an operand to this .endp
ro: „%s” ar trebui să fie un operand pentru acest .endp

en: `%s' symbol without preceding function
ro: simbol „%s” fără o funcție precedentă

en: `%s' was already defined
ro: „%s” este deja definit

en: `%s' was already used as parameter (or another local) name
ro: „%s” a fost deja utilizat ca parametru (sau alt nume local)

en: `%s' was not defined within procedure
ro: „%s” nu a fost definit în cadrul procedurii

en: `%s' was not specified with previous .proc
ro: „%s” nu a fost specificat cu .proc anterior

en: `%s': RC/SAE operand must follow immediate operands
ro: „%s”: operandul RC/SAE trebuie să urmeze operanzii imediați

en: `%s': misplaced `%s'
ro: „%s”: „%s” plasat greșit

en: `%s': misplaced `{%s}'
ro: „%s”: „{%s}” plasat greșit

en: `%s` changes flags which would affect control flow behavior
ro: „%s” modifică fanioanele care ar afecta comportamentul fluxului de control

en: `%s` skips -malign-branch-boundary on `%s`
ro: „%s” omite -malign-branch-boundary pe „%s”

en: `%s` skips -mlfence-before-indirect-branch on `%s`
ro: „%s” omite -mlfence-before-indirect-branch pe „%s”

en: `%s` skips -mlfence-before-ret on `%s`
ro: „%s” omite -mlfence-before-ret pe „%s”

en: `&' serial number operator is not supported
ro: operatorul de număr de serie „&” nu este acceptat

en: `)' required
ro: „)” este necesară

en: `,' required
ro: „,” este necesară

en: `.noopt' arguments ignored
ro: argumentele „.noopt” sunt ignorate.

en: `\' at end of line/statement; ignored
ro: „\” la sfârșitul liniei/declarației; este ignorat

en: `af' must appear alone
ro: „af” trebuie să apară singur

en: `fp=32' used with a 64-bit ABI
ro: „fp=32” utilizat cu un ABI pe 64 de biți

en: `fp=32' used with a MIPS R6 cpu
ro: „fp=32” utilizat cu un cpu MIPS R6

en: `fp=64' used with a 32-bit ABI
ro: „fp=64” utilizat cu un ABI pe 32 de biți

en: `fp=64' used with a 32-bit fpu
ro: „fp=64” utilizat cu o unitate fpu pe 32 de biți

en: `fp=xx' cannot be used with `singlefloat'
ro: „fp=xx” nu poate fi utilizat cu „singlefloat”

en: `fp=xx' used with a cpu lacking ldc1/sdc1 instructions
ro: „fp=xx” utilizat cu un cpu fără instrucțiuni ldc1/sdc1

en: `gp=32' used with a 64-bit ABI
ro: „gp=32” utilizat cu un ABI pe 64 de biți

en: `gp=64' used with a 32-bit ABI
ro: „gp=64” utilizat cu un ABI pe 32 de biți

en: `gp=64' used with a 32-bit processor
ro: „gp=64” utilizat cu un procesor pe 32 de biți

en: `nooddspreg` cannot be used with a 64-bit ABI
ro: „nooddspreg” nu poate fi utilizat cu un ABI pe 64 de biți

en: `noreorder' must be set before `nomacro'
ro: „noreorder” trebuie să fie definit înainte de „nomacro”

en: a bignum with underscores may not have more than 8 hex digits in any word
ro: un număr mare (bignum) cu sublinieri nu poate avea mai mult de 8 cifre hexazecimale în orice cuvânt

en: a bignum with underscores must have exactly 4 words
ro: un număr mare (bignum) cu sublinieri trebuie să aibă exact 4 cuvinte

en: a destination register must be supplied
ro: trebuie furnizat un registru de destinație

en: a different %s was already specified, is now %s
ro: un %s diferit a fost deja specificat, este acum %s

en: a register has no address
ro: un registru nu are adresă

en: a reloc on this operand implies an overflow
ro: o realocare pe acest operand implică o depășire

en: a string must follow the .base64 pseudo-op
ro: un șir trebuie să fie urmat de pseudo-operatorul .base64

en: access register
ro: registru de acces

en: accessing MVE system register without MVE is UNPREDICTABLE
ro: accesarea registrului de sistem MVE fără MVE este IMPREDICTIBILĂ

en: accumulator not a valid destination
ro: acumulatorul nu este o destinație validă

en: addend used with $DSBT_INDEX
ro: addenda utilizată cu $DSBT_INDEX

en: address calculation needs a strongly defined nearby symbol
ro: calculul adreselor are nevoie de un simbol apropiat bine definit

en: address offset must be half word alignment
ro: decalajul adresei trebuie să fie aliniat la jumătate de cuvânt

en: address offset must be word alignment
ro: decalajul adresei trebuie să fie aliniat la cuvânt

en: address override not allowed with `%s'
ro: suprascrierea adresei nu este permisă cu „%s”

en: address prohibits #
ro: adresa interzice #

en: address prohibits ()
ro: adresa interzice ()

en: address prohibits ()+
ro: adresa interzice ()+

en: address prohibits -()
ro: adresa interzice -()

en: address prohibits @
ro: adresa interzice @

en: address prohibits []
ro: adresa interzice []

en: address prohibits displacement length specifier
ro: adresa interzice specificarea lungimii deplasării

en: address prohibits register
ro: adresa interzice registrul

en: address too high for vector table jmp/jsr
ro: adresă prea mare pentru tabelul vectorial jmp/jsr

en: address units must be one of %s
ro: unitățile de adresă trebuie să fie una dintre %s

en: addressing mode not supported
ro: modul de adresare nu este acceptat

en: align value not recognized, using size
ro: valoare de aliniere nerecunoscută, se folosește dimensiunea

en: alignment is not a positive number
ro: alinierea nu este un număr pozitiv

en: alignment is not a power of 2
ro: alinierea nu este o putere a lui 2

en: alignment must be constant
ro: alinierea trebuie să fie constantă

en: alignment negative, 0 assumed
ro: aliniere negativă, se consideră 0

en: alignment negative; 0 assumed
ro: aliniere negativă: se consideră 0

en: alignment not a power of 2
ro: alinierea nu este o putere a lui 2

en: alignment padding (%lu byte) not a multiple of %ld | alignment padding (%lu bytes) not a multiple of %ld
ro[0]: alinierea de umplere (%lu octet) nu este un multiplu de %ld
ro[1]: alinierea de umplere (%lu octeți) nu este un multiplu de %ld
ro[2]: alinierea de umplere (%lu de octeți) nu este un multiplu de %ld

en: alignment too large, %d assumed
ro: aliniere prea mare, se presupune %d

en: alignment too large: %u assumed
ro: aliniere prea mare: se presupune %u

en: alignment too large; %d assumed
ro: aliniere prea mare: se presupune %d

en: alignments greater than %d bytes not supported in .text sections.
ro: alinierile mai mari de %d octeți nu sunt acceptate în secțiunile .text.

en: all tmm registers must be distinct
ro: toate registrele tmm trebuie să fie distincte

en: already assembled instructions
ro: instrucțiuni deja asamblate

en: ambiguous broadcast for `%s', using %u-bit form
ro: difuzare ambiguă pentru „%s”, folosind forma %u-bit

en: ambiguous flags combination - '.profiler' directive ignored.
ro: combinație ambiguă de fanioane - directiva „.profiler” este ignorată.

en: ambiguous operand size
ro: dimensiune ambiguă a operandului

en: ambiguous operand size for `%s'
ro: dimensiune ambiguă a operandului pentru „%s”

en: an .indirect_symbol must be in a symbol pointer or stub section.
ro: un .indirect_symbol trebuie să fie într-un indicator de simbol sau într-o secțiune ciot „stub”.

en: architectural extension `%s' is not allowed for the current base architecture
ro: extensia arhitecturală „%s” nu este permisă pentru arhitectura de bază curentă

en: architectural extensions must be specified in alphabetical order
ro: extensiile de arhitectură trebuie să fie specificate în ordine alfabetică

en: architecture `%s' unrecognized
ro: arhitectura „%s” nu este recunoscută

en: architecture bumped from "%s" to "%s" on "%s"
ro: architecture a sărit de la „%s” la „%s” pe „%s”

en: architecture elf attributes must set before any instructions
ro: atributele elf de arhitectură trebuie definite înainte de orice instrucțiuni

en: architecture features both enabled and disabled
ro: caracteristici de arhitectură activate și dezactivate

en: architecture variant invalid
ro: varianta de arhitectură nu este validă

en: assemble Thumb code
ro: asamblează codul Thumb

en: assemble for a big endian cpu
ro: asamblează pentru un cpu big endian

en: assemble for a little endian cpu
ro: asamblează pentru un cpu little endian

en: assemble for big-endian
ro: asamblare pentru big-endian

en: assemble for little-endian
ro: asamblare pentru little-endian

en: assembly 0x%08x, expected %s
ro: asamblare 0x%08x, așteptată %s

en: assembly state not set for first frag in section %s
ro: starea de asamblare nu este definită pentru primul fragment din secțiunea %s

en: assignment expected
ro: se aștepta o alocare

en: assuming %s on symbol
ro: presupunând %s pe simbol

en: assuming all members of group `%s' are COMDAT
ro: presupunând că toți membrii grupului „%s” sunt COMDAT

en: at most %d displacement operands are allowed
ro: sunt permiși cel mult %d operanzi de deplasare

en: at most %d immediate operands are allowed
ro: sunt permiși cel mult %d operanzi imediați

en: atomic memory operations insns require rd != rj && rd != rk when rd isn't r0
ro: instrucțiunile operațiilor atomice de memorie necesită rd != rj && rd != rk când rd nu este r0

en: attaching copyright header %s: %s
ro: atașarea antetului de drepturi de autor %s: %s

en: attaching version header %s: %s
ro: atașarea antetului de versiune %s: %s

en: attempt to .org/.space/.nops backwards? (%ld)
ro: încercare de .org/.space/.nops invers? (%ld)

en: attempt to .space/.bes backwards? (%ld)
ro: încercare de rulare a .space/.bes înapoi? (%ld)

en: attempt to add an indirect_symbol to a stub or reference section with a zero-sized element at %s
ro: încercare de adăugare a unui indirect_symbol la o secțiune ciot „stub” sau de referință cu un element de dimensiune zero la %s

en: attempt to allocate data in absolute section
ro: încercare de alocare a datelor în secțiunea absolută

en: attempt to allocate data in common section
ro: încercare de alocare a datelor în secțiunea comună

en: attempt to fill absolute section with non-zero value
ro: încercare de a umple secțiunea absolută cu o valoare diferită de zero

en: attempt to fill section `%s' with non-zero value
ro: încercare de a umple secțiunea „%s” cu o valoare diferită de zero

en: attempt to get value of unresolved symbol `%s'
ro: încercare de a obține valoarea simbolului nerezolvat „%s”

en: attempt to move .org backwards
ro: încercare de a muta .org înapoi

en: attempt to re-define symbol `%s'
ro: încercare de redefinire a simbolului „%s”

en: attempt to recreate an unwind entry
ro: încercare de a recrea o intrare de desfășurare

en: attempt to redefine `%s' with a different length
ro: încercarea de a redefini „%s” cu o lungime diferită

en: attempt to redefine pseudo-op `%s' ignored
ro: încercare de redefinire a pseudo-operatorului „%s” ignorată

en: attempt to redefine symbol
ro: încercare de redefinire a simbolului

en: attempt to redefine typed alias
ro: încercare de redefinire a unui alias tipizat

en: attempt to store float in absolute section
ro: încercare de stocare a unui număr în virgulă mobilă în secțiunea absolută

en: attempt to store float in section `%s'
ro: încercare de stocare a unui număr în virgulă mobilă în secțiunea „%s”

en: attempt to store non-empty string in section `%s'
ro: încercare de stocare a unui șir nevid în secțiunea „%s”

en: attempt to store non-zero value in section `%s'
ro: încercare de a stoca o valoare diferită de zero în secțiunea „%s”

en: attempt to store value in absolute section
ro: încercare de stocare a valorii în secțiunea absolută

en: attempt to use an ARM instruction on a Thumb-only processor -- `%s'
ro: s-a încercat utilizarea unei instrucțiuni ARM pe un procesor ce utilizează doar instrucțiuni Thumb -- „%s”

en: backward ref to unknown label "%d:"
ro: referință înapoi la eticheta necunoscută "%d:"

en: bad .common segment %s
ro: segment .common greșit %s

en: bad .fmask directive
ro: directivă .fmask greșită

en: bad .frame directive
ro: directivă .frame greșită

en: bad .longcall format
ro: format .longcall greșit

en: bad .mask directive
ro: directivă .mask greșită

en: bad .mask/.fmask directive
ro: directivă .mask/.fmask greșită

en: bad .nan directive
ro: directivă .nan incorectă

en: bad .relax format
ro: format .relax greșit

en: bad .reserve segment -- expected BSS segment
ro: segment .reserve incorect -- se aștepta un segment BSS

en: bad .section directive: want a,e,v,w,x,M,S,G,T in string
ro: directivă .bad greșită: se vrea a,e,v,w,x,M,S,G,T, în șir

en: bad .section directive: want a,l,w,x,M,S,G,T in string
ro: directivă .section greșită: se vrea a,l,w,x,M,S,G, în șir

en: bad .section directive: want a,o,s,w,x,M,S,G,T in string
ro: directivă .section greșită: se vrea a,o,s,w,x,M,S,G,T, în șir

en: bad .section directive: want a,s,w,x,M,S,G,T in string
ro: directivă .section greșită: se vrea a,s,w,x,M,S,G,T în șir

en: bad .section directive: want a,v,w,x,M,S in string
ro: directivă .section greșită: se vrea a,v,w,x,M,S în șir

en: bad .section directive: want a,w,x,M,S,G,T in string
ro: directivă .section greșită: se vrea a,w,x,M,S,G,T în șir

en: bad .uses format
ro: format .uses greșit

en: bad .weakext directive
ro: directivă .weakext greșită

en: bad COFF debugging information
ro: informații de depanare COFF greșite

en: bad alignment
ro: aliniere greșită

en: bad argument to %s_check directive.
ro: argument greșit pentru directiva %s_check.

en: bad argument to syntax directive.
ro: argument greșit pentru directiva de sintaxă.

en: bad arguments "%s" and/or "%s" in %s directive
ro: argumente greșite „%s” și/sau „%s” în directiva %s

en: bad arguments to instruction
ro: argumente greșite pentru instrucțiune

en: bad base register: must be r0
ro: registru de bază greșit: trebuie să fie r0

en: bad bitmask specified after APSR
ro: mască de biți greșită specificată după APSR

en: bad call to MD_ATOF()
ro: apel greșit la MD_ATOF()

en: bad call to md_atof
ro: apel greșit la md_atof

en: bad combined pmuls output operand
ro: operand de ieșire pmuls combinat greșit

en: bad coprocessor id
ro: id de co-procesor greșit

en: bad defsym; format is --defsym name=value
ro: defsym incorect; formatul este --defsym name=valoare

en: bad element type for instruction
ro: tip de element greșit pentru instrucțiune

en: bad escaped character in string
ro: caracter eludat greșit în șir

en: bad expression
ro: expresie greșită

en: bad expression syntax
ro: sintaxă greșită a expresiei

en: bad fli constant operand, supported constants must be in decimal or hexadecimal floating-point literal form
ro: operand de constantă „fli” greșit, constantele acceptate trebuie să fie în formă literală în virgulă mobilă zecimală sau hexazecimală

en: bad floating literal: %s
ro: literal în virgulă mobilă eronat: %s

en: bad floating-point constant: exponent overflow
ro: constantă în virgulă mobilă greșită: depășirea exponentului

en: bad floating-point constant: unknown error code=%d
ro: constantă în virgulă mobilă greșită: cod de eroare necunoscut=%d

en: bad format for ifc or ifnc
ro: format greșit pentru ifc sau ifnc

en: bad format of OPT NEST=depth
ro: format greșit al OPT NEST=depth

en: bad frag at %p : fix %ld addr %ld %ld
ro: fragment incorect la %p : corectare %ld adresa %ld %ld

en: bad functional unit for operand %u of '%.*s'
ro: unitate funcțională greșită pentru operandul %u din „%.*s”

en: bad immediate value for 8-bit offset (%ld)
ro: valoare imediată greșită pentru decalajul pe 8 biți (%ld)

en: bad immediate value for offset (%ld)
ro: valoare imediată greșită pentru decalajul (%ld)

en: bad instruction `%s'
ro: instrucțiune greșită „%s”

en: bad instruction format
ro: format de instrucțiune greșit

en: bad instruction syntax
ro: sintaxă greșită a instrucțiunii

en: bad list length
ro: lungime de listă greșită

en: bad list length for table lookup
ro: lungime de listă eronată pentru căutarea în tabel

en: bad list type for instruction
ro: tip de listă necorespunzător pentru instrucțiune

en: bad memory operand `%s'
ro: operand de memorie greșit „%s”

en: bad number of operands to '%.*s'
ro: număr greșit de operanzi pentru „%.*s”

en: bad offset 0x%08lX (must be an 8-bit number of words)
ro: decalaj greșit 0x%08lX (trebuie să fie un număr de cuvinte pe 8 biți)

en: bad offset 0x%08lX (must be word-aligned)
ro: decalaj greșit 0x%08lX (trebuie să fie aliniat la cuvânt)

en: bad offset 0x%08lX (only 12 bits available for the magnitude)
ro: decalaj greșit 0x%08lX (numai 12 biți disponibili pentru magnitudine)

en: bad offset 0x%08lX (only 8 bits available for the magnitude)
ro: decalaj greșit 0x%08lX (numai 8 biți disponibili pentru magnitudine)

en: bad opcode or operands
ro: cod operațional sau operanzi greșiți

en: bad operand %u of '%.*s'
ro: operandul %u din „%.*s” este greșit

en: bad operand combination for '%.*s'
ro: combinație greșită de operanzi pentru „%.*s”

en: bad or irreducible absolute expression
ro: expresie absolută greșită sau ireductibilă

en: bad or irreducible absolute expression; zero assumed
ro: expresie absolută greșită sau ireductibilă; se presupune zero

en: bad or irreducible expression for paper width
ro: expresie greșită sau ireductibilă pentru lățimea hârtiei

en: bad or missing co-processor number
ro: număr de co-procesor greșit sau lipsă

en: bad or unhandled relocation type: 0x%02x
ro: tip de realocare greșit sau negestionat: 0x%02x

en: bad personality routine number
ro: număr de rutină de personalitate greșit

en: bad predicate '%s'
ro: predicat eronat „%s”

en: bad range in register list
ro: interval greșit în lista de registre

en: bad register expression
ro: expresie de registru greșită

en: bad register for mrs
ro: registru greșit pentru mrs

en: bad register for operand %u of '%.*s'
ro: registru greșit pentru operandul %u din „%.*s”

en: bad register for post-index
ro: registru greșit pentru post-index

en: bad register in []
ro: registru greșit în []

en: bad register list
ro: listă de registre greșită

en: bad register list: %s
ro: listă de registre greșită: %s

en: bad register name `%s'
ro: nume de registru greșit „%s”

en: bad register name: %s
ro: nume de registru greșit: %s

en: bad register number: %s
ro: număr de registru greșit: %s

en: bad register or register pair for operand %u of '%.*s'
ro: registru sau pereche de registre greșite pentru operandul %u din „%.*s”

en: bad register pair for operand %u of '%.*s'
ro: pereche de registre eronată pentru operandul %u din „%.*s”

en: bad register range
ro: interval de registru greșit

en: bad relaxation state
ro: stare de relaxare inadecvată

en: bad reloc expression
ro: expresie de realocare greșită

en: bad relocation expression for '%s'
ro: expresie de realocare greșită pentru „%s”

en: bad relocation fixup type (%d)
ro: tip de corecție a relocării greșit (%d)

en: bad segment
ro: segment incorect

en: bad size %d in type specifier
ro: dimensiune greșită %d în specificatorul de tip

en: bad size %d in vector width specifier
ro: dimensiune greșită %d în specificatorul de lățime a vectorului

en: bad starting register: r0 and r15 invalid
ro: registru de pornire incorect: r0 și r15 nu sunt valide

en: bad string constant
ro: constantă de șir greșită

en: bad symbol suffix
ro: sufix de simbol greșit

en: bad type for register
ro: tip greșit pentru registru

en: bad type for scalar
ro: tip greșit pentru scalar

en: bad type in SIMD instruction
ro: tip greșit în instrucțiunea SIMD

en: bad value (%s) for %s
ro: valoare greșită (%s) pentru %s

en: bad value for <bit-%s-%s> field, value must be 0...%d
ro: valoare greșită pentru câmpul <bit-%s-%s>, valoarea trebuie să fie 0...%d

en: bad value for compressed funct2 field, value must be 0...3
ro: valoare greșită pentru câmpul funct2 comprimat, valoarea trebuie să fie 0...3

en: bad value for compressed funct3 field, value must be 0...7
ro: valoare greșită pentru câmpul funct3 comprimat, valoarea trebuie să fie 0...7

en: bad value for compressed funct4 field, value must be 0...15
ro: valoare greșită pentru câmpul funct4 comprimat, valoarea trebuie să fie 0...15

en: bad value for compressed funct6 field, value must be 0...63
ro: valoare greșită pentru câmpul funct6 comprimat, valoarea trebuie să fie 0...63

en: bad value for funct2 field, value must be 0...3
ro: valoare greșită pentru câmpul funct2, valoarea trebuie să fie 0...3

en: bad value for funct3 field, value must be 0...7
ro: valoare greșită pentru câmpul funct3, valoarea trebuie să fie 0...7

en: bad value for funct7 field, value must be 0...127
ro: valoare greșită pentru câmpul funct7, valoarea trebuie să fie 0...127

en: bad value for opcode field, value must be 0...127 and lower 2 bits must be 0x3
ro: valoare greșită pentru câmpul de cod operațional, valoarea trebuie să fie 0...127 și cei 2 biți inferiori trebuie să fie 0x3

en: bad value for opcode field, value must be 0...2
ro: valoare greșită pentru câmpul de cod operațional, valoarea trebuie să fie 0...2

en: bad value for th.vsetvli immediate field, value must be 0..2047
ro: valoare greșită pentru câmpul imediat th.vsetvli, valoarea trebuie să fie 0..2047

en: bad value for vector immediate field, value must be -15...16
ro: valoare greșită pentru câmpul vectorial imediat, valoarea trebuie să fie -15...16

en: bad value for vector immediate field, value must be -16...15
ro: valoare greșită pentru câmpul vectorial imediat, valoarea trebuie să fie -16...15

en: bad value for vector immediate field, value must be 0...31
ro: valoare greșită pentru câmpul vectorial imediat, valoarea trebuie să fie 0...31

en: bad value for vector immediate field, value must be 0...63
ro: valoare greșită pentru câmpul vectorial imediat, valoarea trebuie să fie 0...63

en: bad value for vsetivli immediate field, value must be 0..1023
ro: valoare greșită pentru câmpul imediat vsetivli, valoarea trebuie să fie 0..1023

en: bad value for vsetvli immediate field, value must be 0..2047
ro: valoare greșită pentru câmpul imediat vsetvli, valoarea trebuie să fie 0..2047

en: bad vector arrangement type
ro: tip de aranjament vectorial greșit

en: bad/missing psr specifier
ro: specificator psr greșit/lipsă

en: badly formed .dim directive
ro: directivă .dim prost formată

en: badly formed .dim directive ignored
ro: directivă .dim prost formată, se ignoră

en: badly formed .size directive
ro: directivă .size prost formată

en: badly formed .weak directive ignored
ro: directivă .weak prost formată, se ignoră

en: badly formed expression near %s
ro: expresie prost formată lângă %s

en: base and offset must be from the same unit
ro: baza și decalajul trebuie să fie din aceeași unitate

en: base register
ro: registru de bază

en: base register expected
ro: se aștepta un registru de bază

en: base register written back, and overlaps one of transfer registers
ro: registrul de bază este scris-înapoi și se suprapune peste unul dintre registrele de transfer

en: base register written back, and overlaps second transfer register
ro: registrul de bază este scris-înapoi și se suprapune peste cel de-al doilea registru de transfer

en: base unit must be either A0 or A1
ro: unitatea de bază trebuie să fie A0 sau A1

en: base unit must be one of %s
ro: unitatea de bază trebuie să fie una dintre %s

en: base64 strings must be placed into a section
ro: șirurile base64 trebuie să fie plasate într-o secțiune

en: bfd-target = %s
ro: țintă-bfd = %s

en: bignum invalid
ro: bignum nu este valid

en: bignum invalid; zero assumed
ro: bignum nu este valid; se presupune zero

en: bignum truncated to %d byte | bignum truncated to %d bytes
ro[0]: bignum trunchiat la %d octet
ro[1]: bignum trunchiat la %d octeți
ro[2]: bignum trunchiat la %d de octeți

en: bit-field extends past end of register
ro: câmpul de biți se extinde dincolo de finalul registrului

en: blx to '%s' an ARM ISA state function changed to bl
ro: blx la „%s” o funcție de stare ARM ISA schimbată în bl

en: blx to Thumb func '%s' from Thumb ISA state changed to bl
ro: blx la funcția Thumb „%s” din starea Thumb ISA schimbată în bl

en: bogus SHF_MERGE / SHF_STRINGS for SHT_NOBITS section
ro: SHF_MERGE / SHF_STRINGS false pentru secțiunea SHT_NOBITS

en: both insns for !gpdisp!%ld must be in the same section
ro: ambele instrucțiuni pentru !gpdisp!%ld trebuie să fie în aceeași secțiune

en: br_gr record before region record!
ro: înregistrarea br_gr înainte de înregistrarea regiunii!

en: br_mem record before region record!
ro: înregistrarea br_mem înainte de înregistrarea regiunii!

en: bra or bsr with undefined symbol.
ro: bra sau bsr cu simbol nedefinit.

en: branch %s is always true
ro: ramura %s este întotdeauna adevărată, „true”

en: branch address range overflow (0x%lx)
ro: depășirea intervalului de adrese de ramificare (0x%lx)

en: branch must be last instruction in IT block
ro: ramificarea trebuie să fie ultima instrucțiune din blocul IT

en: branch operand has odd offset (%lx)
ro: operandul de ramificare are un decalaj impar (%lx)

en: branch out of range
ro: ramură în afara intervalului

en: branch out of range or not a multiple of 2
ro: ramificare în afara intervalului sau nu este un multiplu de 2

en: branch relaxation is not supported in `%s'
ro: relaxarea ramurii nu este acceptată în „%s”

en: branch target frequency must be greater than 0
ro: frecvența țintă a ramificării trebuie să fie mai mare decât 0

en: branch target not word aligned
ro: ținta ramurii nu este aliniată la cuvânt

en: branch to a symbol in another ISA mode
ro: ramificație la un simbol într-un alt mod ISA

en: branch to misaligned address (0x%lx)
ro: ramificare la adresa prost aliniată (0x%lx)

en: branching or jumping to a loop end may trigger hardware errata
ro: ramificarea sau saltul la sfârșitul unei bucle poate declanșa erori hardware

en: break outside of structured loop
ro: „break” în afara buclei structurate

en: broadcast is needed for operand of such type
ro: difuzarea este necesară pentru un operand de acest tip

en: broken assembler, no assembly attempted
ro: asamblor defect, nu se încearcă asamblarea

en: bstr(ins|pick).[wd] require msbd >= lsbd
ro: bstr(ins|pick).[wd] necesită msbd >= lsbd

en: byte count constant %ld is out of range [1..%d]
ro: constanta numărului de octeți %ld este în afara intervalului [1..%d]

en: byte displacement out of range
ro: deplasarea octetului în afara intervalului

en: byte or halfword not valid for base register
ro: octet sau jumătate de cuvânt nevalabil pentru registrul de bază

en: call target address 0x%08x out of range 0x%08x to 0x%08x
ro: apel la adresa țintă 0x%08x în afara intervalului 0x%08x la 0x%08x

en: call to md_convert_frag
ro: apel la md_convert_frag

en: call to md_convert_frag
ro: apel la md_convert_frag

en: call to md_estimate_size_before_relax
ro: apel la md_estimate_size_before_relax

en: call to md_estimate_size_before_relax
ro: apel la md_estimate_size_before_relax

en: call to tc_aout_fix_to_chars
ro: apel la tc_aout_fix_to_chars

en: can not do %d byte pc-relative relocation
ro: nu se poate face realocarea relativă la pc de %d octeți

en: can not do %d byte relocation
ro: nu se poate face realocarea de %d octeți

en: can not resolve expression
ro: nu se poate rezolva expresia

en: can not shift offsets when accessing less than half-word
ro: nu poate deplasa decalajele atunci când accesează mai puțin de jumătate de cuvânt

en: can only load two consecutive registers
ro: se pot încărca doar două registre consecutive

en: can only store two consecutive registers
ro: se pot stoca doar două registre consecutive

en: can only transfer two consecutive registers
ro: se pot transfera doar două registre consecutive

en: can't []index a register, because it has no address
ro: nu se poate []indexa un registru, deoarece acesta nu are adresă

en: can't change index for operand
ro: nu se poate schimba indexul pentru operand

en: can't close %s: %s
ro: nu se poate închide %s: %s

en: can't close `%s'
ro: nu se poate închide „%s”

en: can't create %s: %s
ro: nu se poate crea %s: %s

en: can't create group: %s
ro: nu se poate crea grupul: %s

en: can't create relocation
ro: nu se poate crea realocarea

en: can't create section %s
ro: nu se poate crea secțiunea „%s”

en: can't encode register '%s%s' in an instruction requiring %s prefix
ro: nu se poate codifica registrul „%s%s” într-o instrucțiune care necesită prefixul %s

en: can't encode register '%s%s' with VEX/XOP/EVEX
ro: nu se poate codifica registrul „%s%s” cu VEX/XOP/EVEX

en: can't extend frag
ro: nu se poate extinde fragmentul

en: can't extend frag %lu char | can't extend frag %lu chars
ro[0]: nu se poate extinde fragmentul %lu caracter
ro[1]: nu se poate extinde fragmentul %lu caractere
ro[2]: nu se poate extinde fragmentul %lu de caractere

en: can't fill %ld byte in section %s of %s: '%s' | can't fill %ld bytes in section %s of %s: '%s'
ro[0]: nu se poate completa cu %ld octet în secțiunea %s din %s: „%s”
ro[1]: nu se poate completa cu %ld octeți în secțiunea %s din %s: „%s”
ro[2]: nu se poate completa cu %ld de octeți în secțiunea %s din %s: „%s”

en: can't find fixup pointed to by .uses
ro: nu se poate găsi corecția indicată de .uses

en: can't find opcode
ro: nu se poate găsi codul operațional

en: can't find opcode
ro: nu se poate găsi codul operațional

en: can't find previous opcode
ro: nu se poate găsi codul operațional anterior

en: can't handle expression
ro: nu se poate gestiona expresia

en: can't handle generation of literal/labels yet
ro: nu se poate gestiona încă generarea de literale/etichete

en: can't handle undefined OP TYPE
ro: nu se poate gestiona OP TYPE nedefinit

en: can't have relocation for ipush
ro: nu se poate avea realocare pentru ipush

en: can't make global register symbol `%s'
ro: nu se poate face simbolul de registru global „%s”

en: can't make register symbol global
ro: nu se poate face simbolul de registru global

en: can't make section symbol global
ro: nu se poate face simbolul secțiunii global

en: can't mix positional and keyword arguments
ro: nu se pot amesteca argumentele poziționale și cuvintele cheie

en: can't mix relocation modifier with explicit shift
ro: nu se poate amesteca modificatorul de realocare cu deplasarea explicită

en: can't open %s for reading: %s
ro: nu se poate deschide %s pentru citire: %s

en: can't open %s: %s
ro: nu se poate deschide %s: %s

en: can't open `%s' for writing
ro: nu se poate deschide „%s” pentru scriere

en: can't open a bfd on stdout %s
ro: nu se poate deschide un bfd la ieșirea standard %s

en: can't open macro library file '%s' for reading: %s
ro: nu se poate deschide fișierul de bibliotecă macro „%s” pentru citire: %s

en: can't predecrement
ro: nu se poate pre-decrementa

en: can't read from %s: %s
ro: nu se poate citi din %s: %s

en: can't redefine the index of a scalar alias
ro: nu se poate redefini indexul unui alias scalar

en: can't redefine the type of a register alias
ro: nu se poate redefini tipul unui alias de registru

en: can't redefine type for operand
ro: nu se poate redefini tipul pentru operand

en: can't represent relocation type %s
ro: nu se poate reprezenta tipul de realocare %s

en: can't resolve %s - %s
ro: nu se poate rezolva %s - %s

en: can't resolve value for symbol `%s'
ro: nu se poate rezolva valoarea pentru simbolul „%s”

en: can't set section flags for section %s
ro: nu se pot defini fanioanele de secțiune pentru secțiunea %s

en: can't start writing .mdebug section: %s
ro: nu se poate începe scrierea secțiunii .mdebug: %s

en: can't use Neon quad register here
ro: nu se poate utiliza un registru cuadruplu Neon aici

en: can't use R0 here
ro: nu se poate utiliza R0 aici

en: can't use alignment with this instruction
ro: nu se poate utiliza alinierea cu această instrucțiune

en: can't use high part of register in operand %d
ro: nu se poate utiliza partea superioară a registrului în operandul %d

en: can't write %ld byte to section %s of %s: '%s' | can't write %ld bytes to section %s of %s: '%s'
ro[0]: nu se poate scrie %ld octet în secțiunea %s din %s: „%s”
ro[1]: nu se pot scrie %ld octeți în secțiunea %s din %s: „%s”
ro[2]: nu se pot scrie %ld de octeți în secțiunea %s din %s: „%s”

en: cannot assemble DSP instruction, DSP option not set: %s
ro: nu se poate asambla instrucțiunea DSP, opțiunea DSP nu este definită: %s

en: cannot assemble FPU instruction, FPU option not set: %s
ro: nu se poate asambla instrucțiunea FPU, opțiunea FPU nu este definită: %s

en: cannot assemble into a literal fragment
ro: nu se poate asambla într-un fragment literal

en: cannot both predecrement and postincrement
ro: nu se poate pre-decrementa și post-incrementa în același timp

en: cannot branch to odd address
ro: nu se poate ramifica la adresa impară

en: cannot change .bundle_align_mode inside .bundle_lock
ro: nu se poate modifica .bundle_align_mode în interiorul .bundle_lock

en: cannot change section or subsection inside .bundle_lock
ro: nu se poate modifica secțiunea sau subsecțiunea în interiorul .bundle_lock

en: cannot change type of common symbol '%s'
ro: nu se poate schimba tipul simbolului comun „%s”

en: cannot combine index with option
ro: nu se poate combina „index” cu „option”

en: cannot combine pre- and post-indexing
ro: nu se pot combina pre- și post-indexarea

en: cannot convert expression symbol %s to complex relocation
ro: nu se poate converti simbolul expresiei %s în realocare complexă

en: cannot create 64-bit relocation
ro: nu se poate crea realocarea pe 64 de biți

en: cannot create floating-point number
ro: nu se poate crea numărul în virgulă mobilă

en: cannot define symbol `%s' in absolute section
ro: nu se poate defini simbolul „%s” în secțiunea absolută

en: cannot determine Thumb instruction size. Use .inst.n/.inst.w instead
ro: nu poate determina dimensiunea instrucțiunii Thumb. Folosiți .inst.n/.inst.w în schimb

en: cannot do %s %u byte relocation
ro: nu se poate face realocarea de %s %u octeți

en: cannot do %u byte pc-relative relocation
ro: nu se poate face realocarea relativă la pc de %u octeți

en: cannot do %u-byte relocation
ro: nu se poate face realocarea de %u-octeți

en: cannot emit PC relative %s relocation%s%s
ro: nu se poate emite realocarea %s relativă la PC%s%s

en: cannot encode misaligned addend in the relocatable field (0x%lx)
ro: nu se poate codifica addenda prost aliniată în câmpul realocabil (0x%lx)

en: cannot encode opcode "%s"
ro: nu se poate codifica codul operațional „%s”

en: cannot encode opcode "%s" in the given format "%s"
ro: nu se poate codifica codul operațional „%s” în formatul dat „%s”

en: cannot find `}' for cm.push/cm.pop
ro: nu se poate găsi „}” pentru cm.push/cm.pop

en: cannot find suitable trampoline
ro: nu se poate găsi o trambulină potrivită

en: cannot generate relocation type for symbol %s, code %s
ro: nu se poate genera tipul de realocare pentru simbolul %s, cod %s

en: cannot honor width suffix
ro: nu se poate onora sufixul de lățime

en: cannot honor width suffix -- `%s'
ro: nu se poate onora sufixul de lățime -- „%s”

en: cannot make a relative jump to an absolute location
ro: nu se poate face un salt relativ la o locație absolută

en: cannot mask instruction using no functional unit
ro: nu se poate masca instrucțiunea care nu utilizează nicio unitate funcțională

en: cannot override zerofill section type for `%s,%s'
ro: nu se poate suprascrie tipul de secțiune zerofill pentru „%s,%s”

en: cannot pack %s and %s together
ro: nu se pot împacheta %s și %s împreună

en: cannot pack %s and %s together with a 16-bit insn
ro: nu se poate împacheta %s și %s împreună cu o instrucțiune pe 16 biți

en: cannot pack %s into slot P1
ro: nu se poate împacheta %s în slotul P1

en: cannot pack %s with a 16-bit insn
ro: nu se poate împacheta %s cu o instrucțiune pe 16 biți

en: cannot represent %s relocation in object file
ro: nu se poate reprezenta realocarea %s în fișierul obiect

en: cannot represent %s relocation in this object file format
ro: nu se poate reprezenta realocarea %s în acest format de fișier obiect

en: cannot represent %s relocation in this object file format1
ro: nu se poate reprezenta realocarea %s în acest format1 de fișier obiect

en: cannot represent `%s' relocation in object file
ro: nu se poate reprezenta realocarea „%s” în fișierul obiect

en: cannot represent relocation type %s
ro: nu se poate reprezenta tipul de realocare %s

en: cannot represent relocation type %s in x32 mode
ro: nu se poate reprezenta tipul de realocare %s în modul x32

en: cannot resolve @slotcount parameter
ro: nu se poate rezolva parametrul @slotcount

en: cannot set literal_prefix inside literal fragment
ro: nu se poate defini literal_prefix în interiorul fragmentului literal

en: cannot use `%s' in this section
ro: nu se poate utiliza „%s” în această secțiune

en: cannot use indirect addressing with the PC
ro: nu se poate utiliza adresarea indirectă cu PC-ul

en: cannot use partial register %s for addressing
ro: nu se poate utiliza registrul parțial %s pentru adresare

en: cannot use post-indexing with PC-relative addressing
ro: nu se poate utiliza post-indexarea cu adresarea relativă la PC

en: cannot use post-indexing with this instruction
ro: nu se poate utiliza post-indexarea cu această instrucțiune

en: cannot use register index with PC-relative addressing
ro: nu se poate utiliza indexul registrului cu adresarea relativă la PC

en: cannot use register index with this instruction
ro: nu se poate utiliza indexul registrului cu această instrucțiune

en: cannot use writeback with PC-relative addressing
ro: nu se poate utiliza scrierea-înapoi cu adresarea relativă la PC

en: cannot use writeback with this instruction
ro: nu se poate utiliza scrierea-înapoi cu această instrucțiune

en: changed section attributes for %s
ro: s-au schimbat atributele secțiunii pentru %s

en: changed section entity size for %s
ro: s-a modificat dimensiunea entității secțiunii pentru %s

en: changed section type for %s
ro: s-a schimbat tipul de secțiune pentru %s

en: character constant too large
ro: constantă de caractere prea lungă

en: character following name is not '#'
ro: caracterul care urmează după nume nu este „#”

en: cmpu doesn't support condition code %s
ro: cmpu nu acceptă codul de condiție %s

en: co-processor offset out of range
ro: decalaj al coprocesorului în afara intervalului

en: co-processor register expected
ro: se aștepta un registru de co-procesor

en: code is ATPCS conformant
ro: codul este conform cu ATPCS

en: code uses 26-bit program counter
ro: codul utilizează un contor de program pe 26 de biți

en: code uses 32-bit program counter
ro: codul utilizează un contor de program pe 32 de biți

en: comma expected between operands
ro: se aștepta o virgulă între operanzi

en: comma is  expected
ro: se aștepta o virgulă

en: comma missing in .xstabs
ro: lipsește virgula în .xstabs

en: common alignment not a power of 2
ro: alinierea comună nu este o putere a lui 2

en: comparison must be with register or #0
ro: comparația trebuie să fie cu registrul sau #0

en: condition code %s value (%d) too large
ro: valoarea codului de condiție %s (%d) este prea mare

en: condition code invalid for jr
ro: cod de condiție nevalid pentru jr

en: condition code register should be 0 or 4 for %s, was %d
ro: registrul codului de condiție ar trebui să fie 0 sau 4 pentru %s, a fost %d

en: condition code register should be even for %s, was %d
ro: registrul codului de condiție ar trebui să fie egal pentru %s, a fost %d

en: condition not followed by conditionalizable insn
ro: condiția nu este urmată de o insn condiționabilă

en: condition required
ro: se necesită o condiție

en: condition sa cannot be used here
ro: condiția sa nu poate fi utilizată aici

en: conditional branch or jal insn's operand references R%ld of previous arithmetic or logic insn.
ro: operandul instrucțiunii de ramificare condițională sau al instrucțiunii jal face trimitere la R%ld al instrucțiunii aritmetice sau logice anterioare.

en: conditional branch out of range
ro: ramură condițională în afara intervalului

en: conditional branch target not word aligned
ro: ținta ramurii condiționale nu este aliniată la cuvânt

en: conditional infixes are deprecated in unified syntax
ro: infixele condiționale sunt depreciate în sintaxa unificată

en: conditional instruction cannot use B flag
ro: instrucțiunea condiționată nu poate utiliza fanionul B

en: conditional instruction cannot use G flag
ro: instrucțiunea condiționată nu poate utiliza fanionul G

en: conditional instruction cannot use R flag
ro: instrucțiunea condiționată nu poate utiliza fanionul R

en: conflicting .insn operands
ro: operanzi .insn în conflict

en: conflicting ISA extension attributes.
ro: atribute de extensie ISA conflictuale.

en: conflicting use of `data16' prefix
ro: utilizare conflictuală a prefixului „data16”

en: confusing relocation expressions
ro: expresii de realocare confuze

en: confusion in formal parameters
ro: confuzie în parametrii de formă

en: constant doesn't fit in %d bits
ro: constanta nu încape în %d biți

en: constant doesn't fit in 4 bits
ro: constanta nu încape în 4 biți

en: constant expression expected
ro: expresie constantă așteptată

en: constant expression not supported
ro: expresia constantă nu este acceptată

en: constant expression or register list expected
ro: se aștepta o expresie constantă sau o listă de registre

en: constant expression required
ro: se necesită o expresie constantă

en: constant generator destination register found in %s
ro: registrul de destinație al generatorului de constante găsit în %s

en: constant generator source register found in %s
ro: registrul sursă al generatorului de constante găsit în %s

en: constant offset required
ro: este necesar un decalaj constant

en: constant out of 8-bit range: %d
ro: constantă în afara intervalului de 8 biți: %d

en: constant shift amount required
ro: se necesită o valoare de deplasare constantă

en: constant too big to fit into instruction
ro: constantă prea mare pentru a încăpea în instrucțiune

en: constant value required
ro: se necesită o valoare constantă

en: control register
ro: registru de control

en: control register '%s' not supported on this architecture
ro: registrul de control „%s” nu este acceptat pe această arhitectură

en: control register expected, but saw '%.6s'
ro: se aștepta un registru de control, dar a apărut „%.6s”

en: coprocessor for insn is not enabled for cde
ro: co-procesorul pentru instrucțiune nu este activat pentru cde

en: core and copro insn lengths must total 32 bits.
ro: lungimea totală a instrucțiunilor core și copro trebuie să fie de 32 de biți.

en: core and copro insn lengths must total 64 bits.
ro: lungimea totală a instrucțiunilor core și copro trebuie să fie de 64 de biți.

en: core register %s value (%d) too large
ro: valoarea registrului nucleului %s (%d) este prea mare

en: could not assemble: %s
ro: nu s-a putut asambla: %s

en: could not build transition for %s => %s
ro: nu s-a putut construi tranziția pentru %s => %s

en: could not open %s for reading
ro: nu s-a putut deschide %s pentru citire

en: could not parse INSN_PATTERN '%s'
ro: nu s-a putut analiza INSN_PATTERN „%s”

en: could not parse INSN_REPL '%s'
ro: nu s-a putut analiza NSN_REPL „%s”

en: could not parse template definition
ro: nu s-a putut analiza definiția șablonului

en: could not set architecture and machine
ro: nu s-a putut stabili arhitectura și mașina

en: could not skip to %ld in file `%s'
ro: nu s-a putut trece la %ld în fișierul „%s

en: could not update architecture and machine
ro: nu s-a putut actualiza arhitectura și mașina

en: could not write .mdebug section: %s
ro: nu s-a putut scrie secțiunea .mdebug: %s

en: couldn't find a valid instruction format
ro: nu s-a putut găsi un format de instrucțiune valid

en: couldn't find relocation to use
ro: nu s-a putut găsi o realocare de utilizat

en: cpu `%s' unrecognized
ro: cpu-ul „%s” nu este recunoscut

en: cpu-type = %s
ro: tip-cpu = %s

en: cpu4: not converting PUSH #4 to shorter form
ro: cpu4: nu convertește PUSH #4 în forma mai scurtă

en: cpu4: not converting PUSH #8 to shorter form
ro: cpu4: nu convertește PUSH #8 în forma mai scurtă

en: cr%d is a reserved control register
ro: cr%d este un registru de control rezervat

en: ctoff() is not supported by the rh850 ABI. Use -mgcc-abi instead
ro: ctoff() nu este acceptată de ABI-ul rh850. Utilizați în schimb „-mgcc-abi”

en: ctoff() relocation used on an instruction which does not support it
ro: realocarea ctoff() utilizată pe o instrucțiune care nu o acceptă

en: cx1d requires consecutive destination registers.
ro: cx1d necesită registre de destinație consecutive.

en: cx2d requires consecutive destination registers.
ro: cx2d necesită registre de destinație consecutive.

en: cx3d requires consecutive destination registers.
ro: cx3d necesită registre de destinație consecutive.

en: d0/d1 registers
ro: registre d0/d1

en: dangerous MULS/MULU location; give it higher alignment
ro: locație periculoasă pentru MULS/MULU; se va acorda o aliniere mai mare

en: dangling `__gcc_isr %d'
ro: „__gcc_isr %d” suspendat

en: dangling `__gcc_isr'
ro: „__gcc_isr” suspendat

en: data dependency: %s %s -- %s %s (%d/%d bubble)
ro: dependență de date: %s %s -- %s %s (bula %d/%d)

en: data in executable section
ro: date în secțiunea executabilă

en: data item with alignment larger than location
ro: element de date cu aliniere mai mare decât locația

en: data size prefix invalid with `%s'
ro: prefixul dimensiunii datelor nu este valid cu „%s”

en: data transfer register cannot be halfword
ro: registrul de transfer de date nu poate fi jumătate de cuvânt

en: default mask isn't allowed
ro: masca implicită nu este permisă

en: dest and source1 must be the same register
ro: destinația și sursa1 trebuie să fie același registru

en: dest must overlap one source register
ro: destinația trebuie să se suprapună peste un registru sursă

en: destination
ro: destinația

en: destination and source registers must be distinct
ro: registrele destinație și sursă trebuie să fie distincte

en: destination for add/subtract can only be R2 or R3
ro: destinația pentru adăugare/scădere poate fi doar R2 sau R3

en: destination for multiply can only be R0 or R1
ro: destinația pentru multiplicare poate fi doar R0 sau R1

en: destination operand must be 16 bit register
ro: operandul de destinație trebuie să fie un registru pe 16 biți

en: destination operand must be 16bit absolute address
ro: operandul de destinație trebuie să fie o adresă absolută pe 16 biți

en: destination operand must be 8 bit register
ro: operandul de destinație trebuie să fie un registru pe 8 biți

en: destination register and offset register may not be the same
ro: este posibil ca registrul de destinație și registrul de deplasare să nu fie același

en: destination register is same for parallel insns
ro: registrul de destinație este același pentru instrucțiunile paralele

en: destination register modified by displacement-post-modified address
ro: registrul de destinație modificat prin deplasarea-post-modificare a adresei

en: destination register must be full-word
ro: registrul de destinație trebuie să fie un cuvânt întreg

en: destination register must be r1
ro: registrul de destinație trebuie să fie r1

en: destination register same as write-back base
ro: registrul de destinație este identic cu baza de scriere-înapoi

en: destination register should be even numbered
ro: registrul de destinație trebuie să fie numerotat par

en: destination unit must be RD
ro: unitatea de destinație trebuie să fie RD

en: detected global register use not covered by .register pseudo-op
ro: s-a detectat utilizarea globală a registrelor, neacoperită de pseudo-operatorul .register

en: difference of two symbols only supported with .long, .short, or .byte
ro: diferența a două simboluri, acceptată numai cu .long, .short sau .byte

en: directive %s cannot be negated
ro: directiva %s nu poate fi negată

en: directive .big encountered when option -big required
ro: directivă .big întâlnită atunci când este necesară opțiunea „-big”

en: directive .little encountered when option -little required
ro: directivă .little întâlnită atunci când este necesară opțiunea „-little”

en: directive LOC from within a BSPEC/ESPEC pair is not supported
ro: directiva LOC din interiorul unei perechi BSPEC/ESPEC nu este acceptată

en: directive LOCAL must be placed in code or data
ro: directiva LOCAL trebuie să fie plasată în cod sau în date

en: directives are not valid inside bundles
ro: directivele nu sunt valabile în interiorul pachetelor

en: disable warnings about symobls that match instructions
ro: dezactivează avertismentele despre simbolurile care corespund instrucțiunilor

en: discriminator less than zero
ro: discriminator mai mic decât zero

en: displacement
ro: deplasare

en: displacement is too large
ro: deplasamentul este prea mare

en: displacement must be an unsigned 8-bit number
ro: deplasarea trebuie să fie un număr de 8 biți fără semn

en: displacement overflows 12-bit field
ro: deplasarea depășește câmpul de 12 biți

en: displacement overflows 8-bit field
ro: deplasarea depășește câmpul de 8 biți

en: displacement to defined symbol %s overflows 12-bit field
ro: deplasarea la simbolul definit %s depășește câmpul de 12 biți

en: displacement to defined symbol %s overflows 8-bit field
ro: deplasarea la simbolul definit %s depășește câmpul pe 8 biți

en: displacement to undefined symbol %s overflows 12-bit field
ro: deplasarea la simbolul nedefinit %s depășește câmpul de 12 biți

en: displacement to undefined symbol %s overflows 8-bit field
ro: deplasarea la simbolul nedefinit %s depășește câmpul de 8 biți

en: displacement too large (%d)
ro: deplasare prea mare (%d)

en: displacement too large for this architecture; needs 68020 or higher
ro: deplasare prea mare pentru această arhitectură; necesită 68020 sau o versiune superioară

en: div / mul are reserved instructions
ro: div / mul sunt instrucțiuni rezervate

en: divide by zero
ro: împărțit la zero

en: division by zero
ro: împărțire la zero

en: division by zero when setting `%s'
ro: împărțirea la zero la definirea „%s”

en: dla used to load 32-bit register; recommend using la instead
ro: „dla” utilizat pentru a încărca registrul pe 32 de biți; se recomandă utilizarea a „la” în locul acestuia

en: do not output verbose error messages
ro: nu afișează mesaje detaliate de eroare

en: do not warn on use of deprecated feature
ro: nu avertizează cu privire la utilizarea unei funcții depreciate

en: does not match begin %s%s at %s:%d
ro: nu se potrivește cu începutul %s%s la %s:%d

en: don't use Rn-Rm syntax with non-unit stride
ro: nu folosiți sintaxa Rn-Rm cu un pas neunitar

en: dsp immediate shift value not constant
ro: valoarea deplasării imediate a dsp nu este o constantă

en: duplicate !tlsgd!%ld
ro: !tlsgd!%ld duplicat

en: duplicate !tlsldm!%ld
ro: !tlsldm!%ld duplicat

en: duplicate ".else"
ro: duplicat „.else”

en: duplicate %s
ro: „%s” duplicat

en: duplicate .fnstart directive
ro: directiva .fnstart este duplicată

en: duplicate .handlerdata directive
ro: directiva .handlerdata este duplicată

en: duplicate .personality directive
ro: directivă .personality duplicată

en: duplicate .personalityindex directive
ro: directivă .personalityindex duplicată

en: duplicate aux register %s
ro: registru auxiliar duplicat %s

en: duplicate entry hint %s
ro: indiciu de intrare duplicat %s

en: duplicated `%s'
ro: „%s” duplicat

en: duplicated `{%s}'
ro: „{%s}” duplicat

en: duplicated psr bit specifier
ro: specificator de bit psr duplicat

en: eGPR use conflicts with encoding specifier
ro: utilizarea eGPR intră în conflict cu specificatorul de codificare

en: elements must be smaller than reversal region
ro: elementele trebuie să fie mai mici decât regiunea de inversare

en: else without matching if
ro: „else” fără corespondentul „if”

en: emit_one_bundle: unexpected dynamic op
ro: emit_one_bundle: operand dinamic neașteptat

en: empty label field for IS
ro: câmp de etichetă gol pentru IS

en: empty symbol name in .def; ignored
ro: nume de simbol gol în .def; se ignoră

en: empty vector register list
ro: listă de registre vectoriale goală

en: emulations not handled in this configuration
ro: emulări care nu sunt gestionate în această configurație

en: end of file after a one-character quote; \0 inserted
ro: sfârșit de fișier după o ghilimea de un caracter; \0 inserat

en: end of file in comment; newline inserted
ro: sfârșit de fișier în comentariu; se introduce o nouă linie

en: end of file in escape character
ro: sfârșit de fișier în caracter de eludare

en: end of file in multiline comment
ro: sfârșit de fișier în comentariu pe mai multe linii

en: end of file in string; '%c' inserted
ro: sfârșit de fișier în șir; „%c” a fost inserat

en: end of file inside conditional
ro: sfârșit de fișier în interiorul condiționalului

en: end of file not at end of a line; newline inserted
ro: sfârșitul fișierului nu se află la sfârșitul unei linii; se introduce o nouă linie

en: end of line encountered inside .base64 string
ro: sfârșit de linie întâlnit în interiorul șirului .base64

en: end of macro inside conditional
ro: sfârșit de macro în interiorul condiționalului

en: end of vector register list not found
ro: sfârșitul listei de registre vectoriale nu a fost găsit

en: end on line error
ro: eroare la sfârșitul liniei

en: endf without for
ro: „endf” fără „if”

en: endi without matching if
ro: „endi” fără corespondentul „if”

en: ending register must be r15
ro: registrul final trebuie să fie r15

en: endw without while
ro: „endw” fără „while”

en: entity size for SHF_MERGE / SHF_STRINGS not specified
ro: dimensiunea entității pentru SHF_MERGE / SHF_STRINGS nu este specificată

en: entry instruction with stack decrement < 16
ro: instrucțiune de intrare cu decrement de stivă < 16

en: equals character only allowed at end of .base64 string
ro: caracterul egal este permis numai la sfârșitul șirului .base64

en: error adding attribute: %s
ro: eroare la adăugarea atributului: %s

en: error constructing %s pseudo-op table
ro: eroare de construcție a tabelului pseudo-operatorilor %s

en: error parsing element/structure list
ro: eroare la analizarea listei de elemente/structuri

en: error setting flags for "%s": %s
ro: eroare la stabilirea fanioanelor pentru „%s”: %s

en: error setting flags for ".sbss": %s
ro: eroare la stabilirea fanioanelor pentru „.sbss”: %s

en: error: unsupported #foo() directive used on symbol
ro: eroare: directivă #foo() neacceptată utilizată pe un simbol

en: estimate size
ro: dimensiunea estimată

en: estimate_size_before_relax called
ro: estimate_size_before_relax a fost apelat

en: even register number required
ro: un număr de registru par este necesar

en: even register required
ro: se necesită un registru par

en: excess operands: '%s'
ro: operanzi în exces: „%s”

en: excessive count %zu for %s - ignored
ro: număr excesiv %zu pentru %s - este ignorat

en: expected #constant
ro: se aștepta #constantă

en: expected #n as first argument of %s
ro: se aștepta ca #n să fie primul argument al %s

en: expected %c
ro: se aștepta=%c

en: expected ',' after section name
ro: se aștepta „,” după numele secțiunii

en: expected ',' after symbol name
ro: se aștepta „,” după numele simmbolului

en: expected ',' after symbol size
ro: se aștepta „,” după dimensiunea simbolului

en: expected '['
ro: se aștepta „[”

en: expected ']'
ro: se aștepta „]”

en: expected ']', not %c in %s
ro: se aștepta „]”, nu %c în %s

en: expected 'za' rather than a ZA tile at operand %d
ro: se aștepta „za” în loc de o piesă ZA la operandul %d

en: expected '{'
ro: se aștepta „{”

en: expected '{' at operand %d
ro: se aștepta „{” la operandul %d

en: expected '}'
ro: se aștepta „}”

en: expected '}' after ZT0
ro: se aștepta „}” după ZT0

en: expected .L, .W or .B for register in indexed addressing mode
ro: se aștepta .L, .W sau .B pentru registrul în modul de adresare indexată

en: expected 0 operands for generated label
ro: se așteptau 0 operanzi pentru eticheta generată

en: expected 0 or 1
ro: se aștepta 0 sau 1

en: expected <Rm> or <Dm> or <Qm> operand
ro: se aștepta un operand <Rm>, <Dm> sau <Qm>

en: expected <nn>
ro: se aștepta <nn>

en: expected <offset>, <opcode>
ro: se aștepta <decalaj>, <cod operațional>

en: expected <reg>, <reg>
ro: se aștepta <reg>, <reg>

en: expected <tag> , <value>
ro: se aștepta <etichetă> , <valoare>

en: expected @(exp, reg16)
ro: se aștepta @(exp, reg16)

en: expected ARM or MVE vector register
ro: se aștepta un registru vectorial ARM sau MVE

en: expected EP register
ro: se aștepta un registru EP

en: expected LR
ro: se aștepta LR

en: expected MVE register [q0..q7]
ro: se aștepta registrul MVE [q0..q7]

en: expected SM or ZA operand
ro: se aștepta un operand SM sau ZA

en: expected ZT0 or a ZA mask at operand %d
ro: se aștepta o mască ZT0 sau o mască ZA la operandul %d

en: expected `%s' to have already been set for .vtable_inherit
ro: se aștepta ca „%s” să fi fost deja definit pentru .vtable_inherit

en: expected a %s name followed by a `,'
ro: se aștepta un nume %s urmat de o „,”

en: expected a 32-bit selection register
ro: se aștepta un registru de selecție pe 32 de biți

en: expected a 64-bit base register
ro: se aștepta un registru de bază pe 64 de biți

en: expected a 64-bit integer register at operand %d
ro: se aștepta un registru întreg de 64 de biți la operandul %d

en: expected a ZA array vector at operand %d
ro: se aștepta un vector matrice ZA la operandul %d

en: expected a ZA tile at operand %d
ro: se aștepta o piesă ZA la operandul %d

en: expected a ZA tile slice at operand %d
ro: se aștepta o felie de piesă ZA la operandul %d

en: expected a base register
ro: se aștepta un registru de bază

en: expected a constant immediate offset
ro: se aștepta un decalaj imediat constant

en: expected a list of %d or %d registers at operand %d -- `%s'
ro: se aștepta o listă de registre %d sau %d la operandul %d -- „%s”

en: expected a list of %d registers at operand %d -- `%s'
ro: se aștepta o listă de %d registre la operandul %d -- „%s”

en: expected a predicate-as-counter rather than predicate-as-mask register at operand %d
ro: se aștepta un registru predicat-ca-numărător în loc de predicat-ca-mască la operandul %d

en: expected a predicate-as-mask rather than predicate-as-counter register at operand %d
ro: se aștepta un registru predicat-ca-mască în loc de predicat-ca-numărător la operandul %d

en: expected a register at operand %d
ro: se aștepta un registru la operandul %d

en: expected a register or register list at operand %d
ro: se aștepta un registru sau o listă de registre la operandul %d

en: expected a scalar SIMD or floating-point register at operand %d
ro: se aștepta un registru scalar SIMD sau cu virgulă mobilă la operandul %d

en: expected a single-register list at operand %d -- `%s'
ro: se aștepta o listă cu un singur registru la operandul %d -- „%s”

en: expected a vector or predicate register at operand %d
ro: se aștepta un registru vector sau un registru predicat la operandul %d

en: expected a vector register at operand %d
ro: se aștepta un registru vectorial la operandul %d

en: expected address expression
ro: se aștepta o expresie de adresă

en: expected alignment after size
ro: aliniere așteptată după dimensiune

en: expected an Advanced SIMD vector register at operand %d
ro: se aștepta un registru vectorial SIMD avansat la operandul %d

en: expected an SVE predicate register at operand %d
ro: se aștepta un registru de predicat SVE la operand %d

en: expected an SVE predicate-as-counter register at operand %d
ro: se aștepta un registru de predicat-ca-numărător SVE la operandul %d

en: expected an SVE vector or predicate register at operand %d
ro: se aștepta un vector SVE sau un registru de predicat la operandul %d

en: expected an SVE vector register at operand %d
ro: se aștepta un registru vectorial SVE la operandul %d

en: expected an SVE vector register or ZA tile slice at operand %d
ro: se aștepta un registru vectorial SVE sau o felie de piesă ZA la operandul %d

en: expected an integer or predicate register at operand %d
ro: se aștepta un registru de număr întreg sau de predicat la operandul %d

en: expected an integer or stack pointer register at operand %d
ro: se aștepta un registru număr întreg sau un registru indicator de stivă la operandul %d

en: expected an integer or vector register at operand %d
ro: se aștepta un registru de număr întreg sau vectorial la operandul %d

en: expected an integer or zero register at operand %d
ro: se aștepta un registru număr întreg sau zero la operandul %d

en: expected an integer register or Advanced SIMD vector register at operand %d
ro: se aștepta un registru de număr întreg sau un registru vectorial SIMD avansat la operandul %d

en: expected an integer register or SVE vector register at operand %d
ro: se aștepta un registru de număr întreg sau un registru vectorial SVE la operandul %d

en: expected an integer, vector or predicate register at operand %d
ro: se aștepta un registru de număr întreg, vector sau predicat la operandul %d

en: expected an unsuffixed ZA tile at operand %d
ro: se aștepta o piesă ZA fără sufix la operandul %d

en: expected closing paren
ro: se aștepta o paranteză de închidere

en: expected comma
ro: se aștepta o virgulă

en: expected comma after "%s"
ro: se aștepta o virgulă după „%s”

en: expected comma after instruction name
ro: se aștepta virgulă după numele instrucțiunii

en: expected comma after major opcode
ro: se aștepta o virgulă după codul operațional major

en: expected comma after name
ro: se aștepta virgulă după nume

en: expected comma after name "%s"
ro: se aștepta o virgulă după numele „%s”

en: expected comma after name `%s' in .localentry directive
ro: virgulă așteptată după numele „%s” în directiva .localentry

en: expected comma after name `%s' in .size directive
ro: virgulă așteptată după numele „%s” în directiva .size

en: expected comma after name in .symver
ro: se aștepta o virgulă după numele din .symver

en: expected comma after name in .vtable_entry
ro: se aștepta o virgulă după numele din .vtable_entry

en: expected comma after name in .vtable_inherit
ro: se aștepta o virgulă după numele din .vtable_inherit

en: expected comma after register mode
ro: se aștepta o virgulă după modul de registru

en: expected comma after register number
ro: se aștepta o virgulă după numărul de registru

en: expected comma after symbol name
ro: se aștepta o virgulă după numele simbolului

en: expected comma after symbol-name: rest of line ignored.
ro: se aștepta virgulă după numele simbolului: restul rândului este ignorat.

en: expected comma or colon after symbol name; rest of line ignored
ro: se aștepta virgulă sau două puncte după numele simbolului; restul liniei este ignorat

en: expected comma separator
ro: se aștepta o virgulă ca separator

en: expected constant expression as first argument of %s
ro: se aștepta o expresie constantă ca prim argument al %s

en: expected constant expression, got %s
ro: se aștepta o expresie constantă, s-a obținut %s

en: expected constant in the range 2..16
ro: se aștepta o constantă în intervalul 2..16

en: expected constant or register name as argument to RPT insn
ro: se aștepta o constantă sau un nume de registru ca argument pentru instrucțiunea RPT

en: expected constant value as argument to RPT
ro: se astepta o valoare constantă ca argument pentru RPT

en: expected double quote enclosed string as argument to .base64 pseudo-op
ro: se aștepta ca șirul să fie încadrat în ghilimele duble ca argument pentru pseudo-operatorul .base64

en: expected element type rather than vector type
ro: se aștepta un tip de element și nu un tip de vector

en: expected expression
ro: se aștepta o expresie

en: expected expression, got %s
ro: se aștepta o expresie, dar s-a primit %s

en: expected fill pattern missing
ro: modelul de umplere așteptat lipsește

en: expected first argument of %s to be in the range 1-4
ro: se aștepta ca primul argument al %s să fie în intervalul 1-4

en: expected index
ro: index așteptat

en: expected numeric constant
ro: constantă numerică așteptată

en: expected one operand for generated literal
ro: se aștepta un operand pentru literalul generat

en: expected quoted string
ro: se aștepta un șir între ghilimele

en: expected register
ro: se aștepta un registru

en: expected register as second argument of %s
ro: registru așteptat ca al doilea argument al %s

en: expected register list
ro: se aștepta o listă de registre

en: expected register name or constant as first argument of %s
ro: se aștepta un nume de registru sau o constantă ca prim argument al %s

en: expected simple number
ro: se aștepta un număr simplu

en: expected symbol
ro: se aștepta un simbol

en: expected symbol name
ro: se aștepta un nume de simbol

en: expected valid addressing mode for mova: "@(disp, ea.sz),ERn"
ro: se aștepta un mod de adresare valid pentru mova: "@(disp, ea.sz),ERn

en: expected value of first argument of %s to fit into 20-bits
ro: se astepta ca valoarea primului argument al %s sa se încadreze în 20 de biți

en: expected }
ro: se aștepta „}”

en: expecting %c near %s
ro: se aștepta %c lângă %s

en: expecting )
ro: se aștepta „)”

en: expecting ]
ro: se aștepta „]”

en: expecting `)' after scale factor in `%s'
ro: se aștepta „,” sau „)” după factorul de scalare din „%s”

en: expecting `,' or `)' after base register in `%s'
ro: se aștepta „,” sau „)” după registrul de bază din „%s”

en: expecting `,' or `)' after index register in `%s'
ro: se aștepta „,” sau „)” după registrul index din „%s”

en: expecting comma delimited operands
ro: se așteptau operanzi delimitați prin virgule

en: expecting comma delimited register operands
ro: se așteptau operanzi de registru delimitați prin virgulă

en: expecting either ON or OFF after .list
ro: se aștepta să fie ON sau OFF după .list

en: expecting index register or scale factor after `,'; got '%c'
ro: se aștepta un registru index sau un factor de scalare după „,”; s-a primit „%c”

en: expecting indirect branch instruction after `notrack'
ro: se așteaptă o instrucțiune de ramificare indirectă după „notrack”

en: expecting indirect register `($rA)'
ro: se aștepta un registru indirect „($rA)”

en: expecting indirect register `($rX)'
ro: se aștepta registrul indirect „($rX)”

en: expecting lockable instruction after `lock'
ro: se așteaptă instrucțiuni blocabile după „locK”

en: expecting mnemonic; got nothing
ro: se aștepta un mnemonic; nu s-a primit nimic

en: expecting opcode string in self test mode
ro: se aștepta un șir de cod operațional în modul de autotestare

en: expecting operand after ','; got nothing
ro: se aștepta un operand după „.”; nu s-a primit nimic

en: expecting operand before ','; got nothing
ro: se aștepta un operand înainte de „.”; nu s-a primit nimic

en: expecting prefix; got nothing
ro: se aștepta un prefix; nu s-a primit nimic

en: expecting register
ro: se aștepta un registru

en: expecting scale factor of 1, 2, 4, or 8: got `%s'
ro: se aștepta un factor de scară de 1, 2, 4 sau 8: s-a primit „%s”

en: expecting valid branch instruction after `bnd'
ro: se așteaptă o instrucțiune de ramificare validă după „bnd”

en: expecting {
ro: se aștepta „{”

en: expr too huge
ro: expresie prea enormă

en: expression doesn't fit in BYTE
ro: expresia nu încape în BYTE

en: expression doesn't fit in WORD
ro: expresia nu încape în WORD

en: expression error
ro: eroare în expresie

en: expression is too complex to be resolved or converted into relocations
ro: expresia este prea complexă pentru a fi rezolvată sau convertită în realocări

en: expression must be constant
ro: expresia trebuie să fie constantă

en: expression out of range: defaulting to 0
ro: expresie în afara intervalului: se trece la valoarea implicită de 0

en: expression out of range: defaulting to 1
ro: expresie în afara intervalului: se trece la valoarea implicită de 1

en: expression too complex
ro: expresia regulată este complexă

en: extended GPR cannot be used as base/index
ro: GPR extins nu poate fi utilizat ca bază/index

en: extended instruction in a branch delay slot
ro: instrucțiune extinsă într-un slot de întârziere de ramificare

en: extended instruction in delay slot
ro: instrucțiune extinsă în slot de întârziere

en: extended operand requested but not required
ro: operand extins solicitat, dar nu este obligatoriu

en: extending shift is not permitted
ro: extinderea deplasării nu este permisă

en: extension `%s' unrecognized
ro: extensia „%s” nu este recunoscută

en: extension does not apply to the base architecture
ro: extensia nu se aplică arhitecturii de bază

en: extra .LABEL arguments ignored.
ro: argumentele .LABEL suplimentare sunt ignorate.

en: extra characters '%s' at end of constant expression '%s'
ro: caractere extra „%s” la sfârșitul expresiei constante „%s”

en: extra characters '%s' at end of immediate expression '%s'
ro: caractere extra „%s” la sfârșitul expresiei imediate „%s”

en: extra characters '%s' at end of operand '%s'
ro: caractere extra „%s” la sfârșitul operandului „%s”

en: extra characters '%s' at the end of absolute operand '%s'
ro: caractere extra „%s” la sfârșitul operandului absolut „%s”

en: extra closing brace
ro: acoladă de închidere, în plus

en: extra colon
ro: două puncte (:) în plus

en: extra comma
ro: virgulă extra

en: extra dot
ro: punct extra

en: extra opening brace
ro: acoladă de deschidere, în plus

en: extra stuff on line ignored
ro: elementele suplimentare din linie sunt ignorate

en: extraneous characters at end of numeric section type
ro: caractere stranii la sfârșitul tipului de secțiune numerică

en: extraneous shift as part of operand to shift insn
ro: deplasare stranie ca parte a operandului din instrucțiunea de deplasare

en: failed for %d
ro: a eșuat pentru %d

en: failed general register sanity check.
ro: a eșuat verificarea corectitudinii registrului general.

en: failed regnum sanity check.
ro: a eșuat verificarea corectitudinii numărului de registru.

en: failed sanity check
ro: a eșuat verificarea stării de sănătate

en: failed sanity check.
ro: a eșuat verificarea stării de sănătate.

en: failed sanity check: long_jump
ro: a eșuat verificarea corectitudinii: long_jump

en: failed sanity check: short_jump
ro: a eșuat verificarea corectitudinii: short_jump

en: failed special case insn sanity check
ro: a eșuat verificarea corectitudinii instrucțiunii de caz special

en: failed to assemble instruction: "%s"
ro: asamblarea instrucțiunii a eșuat: „%s”

en: failed to parse flags
ro: eșec la analizarea fanioanelor

en: failed to read instruction table %s
ro: a eșuat citirea tabelului de instrucțiuni %s

en: failed to set flags for "%s": %s
ro: nu s-au putut activa fanioanele pentru „%s”: %s

en: failed to set subsections by symbols
ro: a eșuat stabilirea subsecțiunilor după simboluri

en: failed to set up debugging information: %s
ro: nu s-a reușit să se configureze informațiile de depanare: %s

en: fake .file after real one
ro: .file fals după cel real

en: fall through frequency must be greater than 0
ro: frecvența de trecere trebuie să fie mai mare decât 0

en: field fx_size too small to hold %lu
ro: câmpul fx_size este prea mic pentru a conține %lu

en: field size must be 16 when value is relocatable
ro: dimensiunea câmpului trebuie să fie 16 atunci când valoarea este realocabilă

en: field value "%s" too complex for a bitfield
ro: valoarea câmpului „%s” este prea complexă pentru un câmp de biți

en: field value truncated
ro: valoarea câmpului este trunchiată

en: field width "%s" too complex for a bitfield
ro: lățimea câmpului „%s” este prea complexă pentru un câmp de biți

en: field width %lu too big to fit in %d byte: truncated to %d bits | field width %lu too big to fit in %d bytes: truncated to %d bits
ro[0]: lățimea câmpului %lu este prea mare pentru a încăpea în %d octet: trunchiată la %d biți
ro[1]: lățimea câmpului %lu este prea mare pentru a încăpea în %d octeți: trunchiată la %d biți
ro[2]: lățimea câmpului %lu este prea mare pentru a încăpea în %d de octeți: trunchiată la %d biți

en: fifth
ro: al cincilea

en: file finished with an open IT block.
ro: fișierul s-a terminat cu un bloc IT deschis.

en: file finished with an open VPT/VPST block.
ro: fișierul s-a terminat cu un bloc VPT/VPST deschis.

en: file not found: %s
ro: fișier negăsit: %s

en: file number %lu is too big
ro: numărul de fișier %lu este prea mare

en: file number %u is too big
ro: numărul fișierului %u este prea mare

en: file number less than one
ro: număr de fișier mai mic de unu

en: file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)
ro: slotul din tabelul de fișiere %u este deja ocupat de un fișier diferit (%s%s%s vs %s%s%s)

en: file was compiled assuming all data will be in the lower memory region, but the upper region is in use
ro: fișierul a fost compilat presupunând că toate datele vor fi în regiunea de memorie inferioară, dar regiunea superioară este în uz

en: file was compiled assuming data could be in the upper memory region, but the lower data region is exclusively in use
ro: fișierul a fost compilat presupunând că datele ar putea fi în regiunea de memorie superioară, dar regiunea de date inferioară este utilizată exclusiv

en: file was compiled for the 430 ISA but the %s ISA is selected
ro: fișierul a fost compilat pentru ISA 430, dar ISA %s este selectat

en: file was compiled for the 430X ISA but the 430 ISA is selected
ro: fișierul a fost compilat pentru ISA 430X, dar ISA 430 este selectat

en: file was compiled for the large memory model, but the small memory model is selected
ro: fișierul a fost compilat pentru modelul de memorie mare, dar este selectat modelul de memorie mică

en: file was compiled for the small memory model, but the large memory model is selected
ro: fișierul a fost compilat pentru modelul de memorie mică, dar este selectat modelul de memorie mare

en: filename goes over one page boundary
ro: numele fișierului depășește limita unei pagini

en: fill pattern too long, truncating to %u
ro: model de umplere prea lung, trunchiat la %u

en: first
ro: primul

en: first and second operands shall be the same register
ro: primul și al doilea operand trebuie să fie același registru

en: first operand is floating point
ro: primul operand este cu virgulă mobilă

en: first operand is too large for 16-bit signed int
ro: primul operand este prea mare pentru un număr întreg cu semn pe 16 biți

en: first operand is too large for a 24-bit displacement
ro: primul operand este prea mare pentru o deplasare pe 24 de biți

en: first register must be r4
ro: primul registru trebuie să fie r4

en: first transfer register must be even
ro: primul registru de transfer trebuie să fie par

en: fixes not all moved from %s
ro: nu toate remedierile au fost mutate de la %s

en: flag for {c}psr instruction expected
ro: se aștepta un fanion pentru instrucțiunea {c}psr

en: flag mismatch
ro: nepotrivire a fanionelor

en: float register should be even, was %d
ro: registrul de virgulă mobilă ar trebui să fie par, a fost %d

en: float16 format cannot be set more than once, ignoring.
ro: formatul float16 nu poate fi definit de mai multe ori, se ignoră.

en: floating point args are in fp regs
ro: argumentele în virgulă mobilă sunt în registre fp

en: floating point constant too large
ro: constantă cu virgulă mobilă prea mare

en: floating point number invalid
ro: număr în virgulă mobilă nevalid

en: floating point number invalid; zero assumed
ro: număr în virgulă mobilă nevalid; se presupune zero

en: floating-point expression required
ro: este necesară o expresie în virgulă mobilă

en: floating-point register
ro: registru cu virgulă mobilă

en: format names only valid inside bundles
ro: nume de formate valide numai în interiorul pachetelor

en: found %d operand for '%s':  Expected %d | found %d operands for '%s':  Expected %d
ro[0]: s-a găsit %d operand pentru „%s”: se aștepta %d
ro[1]: s-au găsit %d operanzi pentru „%s”: se așteptau %d
ro[2]: s-au găsit %d de operanzi pentru „%s”: se așteptau %d

en: found '%c', expected: '%c'
ro: s-a găsit „%c”, se aștepta „%c”

en: found `%sd'; assuming `%sl' was meant
ro: s-a găsit „%sd”; se presupune că se referea la „%sl”

en: fourth
ro: al patrulea

en: fr_mem record before region record!
ro: înregistrarea fr_mem înainte de înregistrarea regiunii!

en: fr_var %lu < length %d
ro: fr_var %lu < lungimea %d

en: fr_var (%ld) < length (%d)
ro: fr_var (%ld) < lungimea (%d)

en: fraction bits value out of range
ro: valoare de biți de fracție în afara intervalului

en: frame reg expected, using $%d.
ro: se aștepta un registru cadru, folosind $%d.

en: frame size specified twice
ro: dimensiunea cadrului specificată de două ori

en: frgr_mem record before region record!
ro: înregistrarea frgr_mem înainte de înregistrarea regiunii!

en: functional unit already masked
ro: unitate funcțională deja mascată

en: functional unit already masked for operand %u of '%.*s'
ro: unitate funcțională deja mascată pentru operandul %u din „%.*s”

en: functional unit already used in this execute packet
ro: unitate funcțională deja utilizată în acest pachet de execuție

en: further multibyte character warnings suppressed
ro: alte avertismente de caractere multi-octet au fost suprimate

en: g?csrxchg require rj != r0 && rj != r1
ro: g?csrxchg necesită rj != r0 && rj != r1

en: garbage after index spec ignored
ro: deșeurile după specificația indexului se ignoră

en: garbage at end of line
ro: deșeuri la sfârșit de linie

en: garbage following instruction
ro: gunoi după instrucțiune

en: gas doesn't understand your configure target %s
ro: «gas» nu înțelege ținta dvs. de configurare %s

en: general register
ro: registru general

en: general-purpose register
ro: registru de uz general

en: generate PIC code
ro: generează codul PIC

en: generating 16-bit `iret' for .code16gcc directive
ro: generând „iret” pe 16 biți pentru directiva .code16gcc

en: generating 32-bit `%s', unlike earlier gas versions
ro: generând „%s” pe 32 de biți, spre deosebire de versiunile de gas anterioare

en: get_expanded_loop_offset: invalid opcode
ro: get_expanded_loop_offset: cod operațional nevalid

en: ginsn unsupported for target
ro: ginsn nu este acceptată pentru țintă

en: gr_gr record before region record!
ro: înregistrarea gr_gr înainte de înregistrarea regiunii!

en: gr_mem record before region record!
ro: înregistrarea gr_mem înainte de înregistrarea regiunii!

en: group name for SHF_GROUP not specified
ro: numele grupului pentru SHF_GROUP nu este specificat

en: group name not parseable
ro: numele grupului nu poate fi analizat

en: group section `%s' has no group signature
ro: secțiunea de grup „%s” nu are semnătură de grup

en: handlerdata in cantunwind frame
ro: handlerdata în cadrul cantunwind

en: hard-float conflicts with specified fpu
ro: virgulă mobilă hardware intră în conflict cu fpu-ul specificat

en: hardware divide
ro: împărțirea (prin) hardware

en: hardware loop extension
ro: extensie de buclă hardware

en: having the base register in the register list when using write back is UNPREDICTABLE
ro: prezența registrului de bază în lista de registre atunci când se utilizează scrierea înapoi este IMPREDICTIBILĂ

en: here is the "else" of the unterminated conditional
ro: aici este „else” din condiționalul neterminat

en: here is the previous ".else"
ro: aici este precedentul „.else”

en: here is the previous ".if"
ro: aici este precedentul „.if”

en: here is the start of the unterminated conditional
ro: aici este începutul condiționalului neterminat

en: hi() relocation used on an instruction which does not support it
ro: realocarea hi() utilizată pe o instrucțiune care nu o acceptă

en: hi0() relocation used on an instruction which does not support it
ro: realocarea hi0() utilizată pe o instrucțiune care nu o acceptă

en: high bits set in register list expression
ro: biți înalți definiți în expresia listei de registre

en: hint in B unit can't be used
ro: indicația din unitatea B nu poate fi utilizată

en: hint in B unit may be treated as nop
ro: indicația din unitatea B poate fi tratată ca nop

en: hint.b may be treated as nop
ro: hint.b poate fi tratată ca nop

en: hint.b shouldn't be used
ro: hint.b nu ar trebui să fie utilizată

en: i386_output_nops called to generate nops of at most %d bytes!
ro: i386_output_nops apelat pentru a genera nop-uri de cel mult %d octeți!

en: iWMMXt control register expected
ro: se aștepta un registru de control iWMMXt

en: iWMMXt data or control register expected
ro: se aștepta un registru de date sau de control iWMMXt

en: iWMMXt data register expected
ro: se aștepta un registru de date iWMMXt

en: iWMMXt scalar register expected
ro: se aștepta un registru scalar iWMMXt

en: identifier+constant@%s means identifier@%s+constant
ro: identificator+constant@%s înseamnă identificator@%s+constant

en: if writeback register is in list, it must be the lowest reg in the list
ro: dacă registrul de scriere-înapoi este în listă, trebuie să fie cel mai mic registru din listă

en: ignoring `.d32' suffix due to earlier `{disp<N>}'
ro: se ignoră sufixul „.d32” din cauza „{disp<N>}” anterior

en: ignoring `.d8' suffix due to earlier `{disp<N>}'
ro: se ignoră sufixul „.d8” din cauza „{disp<N>}” anterior

en: ignoring `.s' suffix due to earlier `{%s}'
ro: se ignoră sufixul „.s” din cauza „{%s}” anterior

en: ignoring attempt to re-define symbol `%s'.
ro: se ignoră încercarea de a redefini simbolul „%s”.

en: ignoring attempt to redefine built-in register '%s'
ro: se ignoră încercarea de redefinire a registrului încorporat „%s”

en: ignoring attempt to redefine symbol %s
ro: se ignoră încercarea de redefinire a simbolului %s

en: ignoring attempt to undefine built-in register '%s'
ro: se ignoră încercarea de anulare a definirii registrului încorporat „%s”

en: ignoring attempt to use .unreq on fixed register name: '%s'
ro: se ignoră încercarea de a utiliza .unreq pe numele de registru fix: „%s”

en: ignoring bad alignment
ro: se ignoră alinierea defectuoasă

en: ignoring changed section attributes for %s
ro: se ignoră atributele secțiunii modificate pentru %s

en: ignoring changed section type for %s
ro: se ignoră tipul de secțiune schimbat pentru %s

en: ignoring extra '-rename-section' delimiter ':'
ro: se ignoră delimitatorul suplimentar „:” din „-rename-section”

en: ignoring fill value in absolute section
ro: se ignoră valoarea de umplere în secțiunea absolută

en: ignoring fill value in section `%s'
ro: se ignoră valoarea de umplere în secțiunea „%s”

en: ignoring incorrect section type for %s
ro: se ignoră tipul incorect de secțiune pentru %s

en: ignoring invalid '-rename-section' specification: '%s'
ro: se ignoră specificația nevalidă „-rename-section”: „%s”

en: ignoring macro exit outside a macro definition.
ro: se ignoră ieșirea din macro în afara unei definiții de macro.

en: ignoring operands: %s
ro: se ignoră operanzii: %s

en: ignoring redefinition of register alias '%s'
ro: se ignoră redefinirea pseudonimului de registru „%s”

en: iif convert internal pcrel/binary
ro: iif convertește intern pcrel/binar

en: iif convert internal pcrel/pointer
ro: iif convertește intern pcrel/indicator

en: illegal %s relocation size: %d
ro: dimensiune de relocare %s ilegală: %d

en: illegal .stab%c directive, bad character
ro: directivă .stab%c ilegală, caracter greșit

en: illegal .stabx expression; zero assumed
ro: expresie .stabx ilegală; se presupune zero

en: illegal double indirection
ro: indirectă dublă ilegală

en: illegal expression
ro: expresie ilegală

en: illegal immediate register operand %s
ro: operand de registru imediat ilegal %s

en: illegal indirect reference
ro: referință indirectă ilegală

en: illegal opcode %s for mcu %s
ro: cod operațional ilegal %s pentru mcu %s

en: illegal opcode for zve32x
ro: cod operațional ilegal pentru zve32x

en: illegal operand
ro: operand ilegal

en: illegal operand - register name found where none expected
ro: operand ilegal - s-a găsit un nume de registru unde nu se aștepta niciunul

en: illegal operands
ro: operanzi ilegali

en: illegal prefix used with VEX/XOP/EVEX
ro: prefix ilegal utilizat cu VEX/XOP/EVEX

en: illegal range of target hardware versions
ro: plajă ilegală de versiuni hardware țintă

en: illegal register after @
ro: registru ilegal după @

en: illegal register after @-
ro: registru ilegal după @-

en: illegal register included in list
ro: registru ilegal inclus în listă

en: illegal register number
ro: număr de registru ilegal

en: illegal resource usage in bundle
ro: utilizare ilegală a resurselor în pachet

en: imm5 should >= 2
ro: imm5 ar trebui să fie >= 2

en: immediate 0 cannot be used here
ro: 0 imediat nu poate fi utilizat aici

en: immediate 1 or 2 expected
ro: se aștepta o valoare imediată de 1 sau 2

en: immediate cannot be moved by a single instruction
ro: valoarea imediată nu poate fi mutată printr-o singură instrucțiune

en: immediate constant is valid both as a bit-pattern and a floating point value (using the fp value)
ro: constanta imediată este valabilă atât ca model de bit, cât și ca valoare în virgulă mobilă (folosind valoarea fp)

en: immediate expression requires a # prefix
ro: expresia imediată necesită un prefix #

en: immediate has bits set outside the operand size
ro: valoarea imediată are biți definiți în afara dimensiunii operandului

en: immediate is not 16bit aligned
ro: valoarea imediată nu este aliniată pe 16 de biți

en: immediate is not 32bit aligned
ro: valoarea imediată nu este aliniată pe 32 de biți

en: immediate is not a power of two
ro: imediat nu este o putere a lui doi

en: immediate is out of bounds
ro: valoarea imediată este în afara limitelor

en: immediate must be 1 or 2
ro: valoarea imediată trebuie să fie 1 sau 2

en: immediate must be a multiple of 2 in the range of +/-[0,254]
ro: valoarea imediată trebuie să fie un multiplu de 2 în intervalul +/-[0,254].

en: immediate must be a multiple of 4 in the range of +/-[0,508]
ro: valoarea imediată trebuie să fie un multiplu de 4 în intervalul +/-[0,508].

en: immediate must be a multiple of 8 in the range of +/-[0,1016]
ro: valoarea imediată trebuie să fie un multiplu de 8 în intervalul +/-[0,1016].

en: immediate must be either 1, 2, 4 or 8
ro: valoarea imediată, trebuie să fie 1, 2, 4 sau 8

en: immediate must be in the range of +/-[0,127]
ro: valoarea imediată trebuie să fie în intervalul +/-[0,127].

en: immediate offset not 2-byte-aligned
ro: decalajul imediat nu este aliniat la 2 octeți

en: immediate offset not 4-byte-aligned
ro: decalajul imediat nu este aliniat la 4 octeți

en: immediate offset out of range
ro: decalaj imediat în afara intervalului

en: immediate operand expected in the range [1,16]
ro: operand imediat așteptat în intervalul [1,16]

en: immediate operand expected in the range [1,8]
ro: operand imediat așteptat în intervalul [1,8]

en: immediate operand illegal with absolute jump
ro: operand imediat ilegal cu salt absolut

en: immediate operand is not match
ro: operandul imediat nu se potrivește

en: immediate operand is too large
ro: operandul imediat este prea mare

en: immediate operand required
ro: se necesită operand direct(immediate)

en: immediate operand requires iWMMXt2
ro: operandul imediat necesită iWMMXt2

en: immediate operands sum to greater than 32
ro: suma operanzilor imediați este mai mare de 32

en: immediate out of range
ro: valoare imediată în afara intervalului

en: immediate out of range for insert
ro: valoare imediată în afara intervalului de inserare

en: immediate out of range for narrowing operation
ro: valoare imediată în afara intervalului pentru operația de îngustare

en: immediate out of range for shift
ro: imediat în afara intervalului de deplasare

en: immediate out of range, shall fit in 32 bits
ro: valoare imediată în afara intervalului, trebuie să se încadreze în 32 de biți

en: immediate too large (bigger than 0xF)
ro: valoare imediată prea mare (mai mare de 0xF)

en: immediate value
ro: valoare imediată

en: immediate value %d out of range %d to %d
ro: valoarea imediată %d în afara intervalului %d până la %d

en: immediate value %llu out of range %u to %lu
ro: valoarea imediată %llu în afara intervalului %u - %lu

en: immediate value %u out of range %u to %u
ro: valoare imediată %u în afara intervalului %u la %u

en: immediate value 0x%x truncated to 0x%x
ro: valoarea imediată 0x%x trunchiată la 0x%x

en: immediate value 48 or 64 expected
ro: se aștepta valoarea imediată 48 sau 64

en: immediate value is out of range
ro: valoarea imediată este în afara intervalului

en: immediate value must be 16, 20, 24, 28
ro: valoarea imediată trebuie să fie 16, 20, 24, 28

en: immediate value must be a multiple of %d at operand %d -- `%s'
ro: valoarea imediată trebuie să fie un multiplu de %d la operandul %d -- „%s”

en: immediate value not allowed when source & dest differ
ro: valoarea imediată nu este permisă atunci când sursa și destinația diferă

en: immediate value out of range
ro: valoare imediată în afara intervalului

en: immediate value out of range
ro: valoare directă(immediate) în afara intervalului

en: immediate value out of range, expected range [0, 16]
ro: valoare imediată în afara intervalului, interval așteptat [0, 16]

en: immediate value out of range, expected range [1, 32]
ro: valoare imediată în afara intervalului, interval așteptat [1, 32]

en: immediate zero expected
ro: zero imediat așteptat

en: improper CSR address (%llu)
ro: adresă CSR necorespunzătoare (%llu)

en: improper CSR address (%lu)
ro: adresă CSR necorespunzătoare (%lu)

en: improper CSRxI immediate (%llu)
ro: imediat CSRxI necorespunzător (%llu)

en: improper CSRxI immediate (%lu)
ro: imediat CSRxI necorespunzător (%lu)

en: improper immediate value (%li)
ro: valoare imediată improprie  (%li)

en: improper immediate value (%lli)
ro: valoare imediată improprie  (%lli)

en: improper immediate value (%llu)
ro: valoare imediată improprie (%llu)

en: improper immediate value (%lu)
ro: valoare imediată improprie (%lu)

en: improper prefetch offset (%ld)
ro: decalaj de prefetch necorespunzător (%ld)

en: improper shift amount (%llu)
ro: valoarea deplasării necorespunzătoare (%llu)

en: improper shift amount (%lu)
ro: valoarea deplasării necorespunzătoare (%lu)

en: inappropriate arguments for opcode '%s'
ro: argumente nepotrivite pentru codul operațional „%s”

en: inappropriate arguments for opcode `%s'
ro: argumente nepotrivite pentru codul operațional „%s”

en: incompatible flag %i in line directive
ro: opțiune %i incompatibilă în directiva de linie

en: inconsistent types in Neon instruction
ro: tipuri inconsistente în instrucțiunea Neon

en: inconsistent uses of .cfi_sections
ro: utilizări inconsecvente ale .cfi_sections

en: incorrect condition in IT block
ro: condiție incorectă în blocul IT

en: incorrect condition in VPT/VPST block
ro: condiție incorectă în blocul VPT/VPST

en: incorrect format for multiply parallel instruction
ro: format incorect pentru instrucțiunea paralelă de multiplicare

en: incorrect number of operands given in the first instruction
ro: număr incorect de operanzi dat în prima instrucțiune

en: incorrect number of operands given in the second instruction
ro: număr incorect de operanzi dați în a doua instrucțiune

en: incorrect register `%s%s' used with `%c' suffix
ro: registru incorect „%s%s” folosit cu sufixul „%c”

en: incorrect register in reglist
ro: registru incorect în lista de registre

en: incorrect register number, ignoring
ro: număr de registru incorect, se ignoră

en: index and destination registers should be distinct
ro: indexul și registrele de destinație trebuie să fie distincte

en: index must be 0 or 1
ro: indexul trebuie să fie 0 sau 1

en: index must be in the range 0 to 3
ro: indexul trebuie să fie cuprins între 0 și 3

en: index not allowed inside register list
ro: indexul nu este permis în interiorul listei de registre

en: index overflow (%+ld)
ro: depășire index (%+ld)

en: index overflow (%+lld)
ro: depășire index (%+lld)

en: index register
ro: registru index

en: index register overlaps transfer register
ro: registrul index se suprapune peste registrul de transfer

en: index value too big for %s
ro: valoarea indexului este prea mare pentru %s

en: indexed register must be less than 16
ro: registrul indexat trebuie să fie mai mic de 16

en: indexed register must be less than 8
ro: registrul indexat trebuie să fie mai mic de 8

en: indexed vector register expected
ro: se așteapta un registru vectorial indexat

en: indirect %s without `*'
ro: %s indirect fără „*”

en: indirect `%s` with memory operand should be avoided
ro: „%s” indirect cu operand de memorie trebuie evitat

en: input/output port address isn't allowed with `%s'
ro: adresa portului de intrare/ieșire nu este permisă cu „%s”

en: insn can't be combined with parallel processing insn
ro: insn nu poate fi combinată cu procesarea paralelă insn

en: insn cannot be combined with non-nopx
ro: insn nu poate fi combinată cu non-nopx

en: insn cannot be combined with non-nopy
ro: insn nu poate fi combinată cu non-nopy

en: insn cannot be combined with pmuls
ro: insn nu poate fi combinată cu pmuls

en: insn name: %s	format: %s	syntax error
ro: nume instrucțiune: %s	format: %s	eroare de sintaxă

en: insn name: %s
    format: %s
    macro: %s	syntax error
ro: nume instrucțiune: %s
    format: %s
    macro: %s	eroare de sintaxă

en: insn name: %s
    format: %s
    we want macro but macro is NULL
ro: nume instrucțiune: %s
    format: %s
    vrem macro, dar macro este NULL

en: instruction %s may not follow another I/O instruction.
ro: instrucțiunea %s nu poate urma o altă instrucțiune de In/Ieș.

en: instruction %s may not follow another memory access instruction.
ro: instrucțiunea %s nu poate urma o altă instrucțiune de acces la memorie.

en: instruction %s requires %d operand | instruction %s requires %d operands
ro[0]: instrucțiunea %s necesită %d operand
ro[1]: instrucțiunea %s necesită %d operanzi
ro[2]: instrucțiunea %s necesită %d de operanzi

en: instruction %s requires MSP430X mcu
ro: instrucțiunea %s necesită mcu MSP430X

en: instruction %s requires absolute expression
ro: instrucțiunea %s necesită o expresie absolută

en: instruction %s requires enabling AUDIO extension
ro: instrucțiunea %s necesită activarea extensiei AUDIO

en: instruction %s requires enabling DIV & DX_REGS extension
ro: instrucțiunea %s necesită activarea extensiei DIV & DX_REGS

en: instruction %s requires enabling DX_REGS extension
ro: instrucțiunea %s necesită activarea extensiei DX_REGS

en: instruction %s requires enabling FPU extension
ro: instrucțiunea %s necesită activarea extensiei FPU

en: instruction %s requires enabling FPU_DP extension
ro: instrucțiunea %s necesită activarea extensiei FPU_DP

en: instruction %s requires enabling FPU_MAC extension
ro: instrucțiunea %s necesită activarea extensiei FPU_MAC

en: instruction %s requires enabling FPU_SP extension
ro: instrucțiunea %s necesită activarea extensiei FPU_SP

en: instruction %s requires enabling STRING extension
ro: instrucțiunea %s necesită activarea extensiei STRING

en: instruction %s requires enabling dsp extension
ro: instrucțiunea %s necesită activarea extensiei dsp

en: instruction %s requires enabling performance extension
ro: instrucțiunea %s necesită activarea extensiei de performanță

en: instruction %s requires enabling performance extension II
ro: instrucțiunea %s necesită activarea extensiei de performanță II

en: instruction %s requires enabling zol extension
ro: instrucțiunea %s necesită activarea extensiei zol

en: instruction %s.a does not exist
ro: instrucțiunea %s.a nu există

en: instruction %s: result is always false
ro: instrucțiunea %s: rezultatul este întotdeauna fals

en: instruction %s: result is always true
ro: instrucțiunea %s: rezultatul este întotdeauna adevărat

en: instruction '%.*s' cannot be predicated
ro: instrucțiunea „%.*s” nu poate fi predicată

en: instruction '%s' cannot be executed in parallel.
ro: instrucțiunea „%s” nu poate fi executată în paralel.

en: instruction '%s' is for the M32R2 only
ro: instrucțiunea „%s” este numai pentru M32R2

en: instruction '%s' is for the M32RX only
ro: instrucțiunea „%s” este numai pentru M32RX

en: instruction `%s' after `xacquire' not allowed
ro: instrucțiunea „%s” după „xacquire” nu este permisă

en: instruction `%s' isn't supported outside of protected mode.
ro: instrucțiunea „%s” nu este acceptată în afara modului protejat.

en: instruction address is not a multiple of %d
ro: adresa instrucțiunii nu este un multiplu de %d

en: instruction address is not a multiple of 16
ro: Adresa instrucțiunii nu este un multiplu de 16

en: instruction address is not a multiple of 2
ro: adresa instrucțiunii nu este un multiplu de 2

en: instruction address is not a multiple of 8
ro: adresa instrucțiunii nu este un multiplu de 8

en: instruction cannot be conditional
ro: instrucțiunea nu poate fi condițională

en: instruction cannot operate on pair values
ro: instrucțiunea nu poate opera asupra valorilor perechi

en: instruction does not accept PC-relative addressing
ro: instrucțiunea nu acceptă adresarea relativă la PC

en: instruction does not accept preindexed addressing
ro: instrucțiunea nu acceptă adresarea preindexată

en: instruction does not accept register index
ro: instrucțiunea nu acceptă indexul de registru

en: instruction does not accept scaled register index
ro: instrucțiunea nu acceptă indexul de registru scalat

en: instruction does not accept this addressing mode
ro: instrucțiunea nu acceptă acest mod de adresare

en: instruction does not accept unindexed addressing
ro: instrucțiunea nu acceptă adresarea neindexată

en: instruction does not allow shifted index
ro: instrucțiunea nu permite un index decalat

en: instruction does not support unindexed addressing
ro: instrucțiunea nu acceptă adresarea neindexată

en: instruction does not support writeback
ro: instrucțiunea nu acceptă scrierea-înapoi

en: instruction does not take a block type
ro: instrucțiunea nu ia un tip de bloc

en: instruction form not available on this architecture.
ro: formă de instrucțiune nedisponibilă pe această arhitectură.

en: instruction implicitly accesses R31 of previous load.
ro: instrucțiunea accesează implicit R31 din încărcarea anterioară.

en: instruction is always unconditional
ro: instrucțiunea este întotdeauna necondițională

en: instruction length of %u bytes exceeds the limit of 15
ro: lungimea instrucțiunii de %u octeți depășește limita de 15

en: instruction missing MVE vector predication code
ro: instrucțiunii îi lipsește codul de predicare a vectorului MVE

en: instruction mnemonic too long: %s
ro: instrucțiune mnemonică prea lungă: %s

en: instruction not allowed in IT block
ro: instrucțiune nepermisă în blocul IT

en: instruction not allowed in VPT block
ro: instrucțiune nepermisă în blocul VPT

en: instruction not supported in Thumb16 mode
ro: instrucțiunea nu este acceptată în modul Thumb16

en: instruction requires label
ro: instrucțiunea necesită etichetă

en: instruction requires label or value in range -511:512
ro: instrucțiunea necesită etichetă sau valoare în intervalul -511:512

en: instruction requires label sans '$'
ro: instrucțiunea necesită o etichetă fără „$”

en: instruction requires register index
ro: instrucțiunea necesită un index de registru

en: instruction sequence (write a0, branch, retw) may trigger hardware errata
ro: secvența de instrucțiuni (write a0, branch, retw) poate declanșa erori hardware

en: instructions write to the same destination register.
ro: instrucțiunile scriu în același registru de destinație.

en: integer operand out of range
ro: operand de număr întreg în afara intervalului

en: integer register expected in the extended/shifted operand register
ro: registrul de numere întregi așteptat în registrul operandului extins/decalat

en: integer register expected in the shifted operand register
ro: registrul de numere întregi așteptat în registrul operandului decalat

en: internal confusion: relocation in a section without contents
ro: confuzie internă: realocare într-o secțiune fără conținut

en: internal error
ro: eroare internă

en: internal error in argument parsing
ro: eroare internă în analizarea argumentelor

en: internal error: [%s] unexpected code [%lx] in frob symbol
ro: eroare internă: [%s] cod neașteptat [%lx] în simbolul frob

en: internal error: bad file property ID %d
ro: eroare internă: ID-ul proprietății fișierului este greșit %d

en: internal error: bad microMIPS opcode (incorrect length: %u): %s %s
ro: eroare internă: cod operațional microMIPS greșit (lungime incorectă: %u): %s %s

en: internal error: bad microMIPS opcode (opcode/length mismatch): %s %s
ro: eroare internă: cod operațional microMIPS greșit (nepotrivire cod operațional/lungime): %s %s

en: internal error: base section index out of range
ro: eroare internă: indexul secțiunii de bază este în afara intervalului

en: internal error: can't export reloc type %d (`%s')
ro: eroare internă: nu se poate exporta tipul de realocare %d („%s”)

en: internal error: can't install fix for reloc type %d (`%s')
ro: eroare internă: nu se poate instala o remediere pentru tipul de realocare %d („%s”)

en: internal error: cannot get align symbol
ro: eroare internă: nu se poate obține simbolul de aliniere

en: internal error: failed to allocate %d indirectsymbol pointers
ro: eroare internă: nu s-a reușit alocarea a %d indicatori de simboluri indirecte

en: internal error: fixup not contained within frag
ro: eroare internă: remedierea nu este conținută în fragment

en: internal error: lookup/get operands failed
ro: eroare internă: căutarea/obținerea operanzilor a eșuat

en: internal error: losing opcode: `%s' "%s"
ro: eroare internă: pierderea codului operațional: „%s” „%s”

en: internal error: more indirect mach-o symbols than expected
ro: eroare internă: mai multe simboluri mach-o indirecte decât cele așteptate

en: internal error: reloc %d (`%s') not supported by object file format
ro: eroare internă: realocarea %d („%s”) nu este suportată de formatul de fișier obiect

en: internal error: unknown dwarf2 format
ro: eroare internă: format dwarf2 necunoscut

en: internal error: unknown instruction attribute: 0x%08x
ro: eroare internă: atribut de instrucțiune necunoscut: 0x%08x

en: internal error: unknown nop check state
ro: eroare internă: stare de verificare nop necunoscută

en: internal error: unknown option name '%s'
ro: eroare internă: nume de opțiune necunoscut „%s”

en: internal error: we have no internal label yet
ro: eroare internă: nu avem încă o etichetă internă

en: internal error; cannot generate `%s' relocation
ro: eroare internă: nu se poate genera realocarea „%s”

en: internal error? cannot generate `%s' relocation
ro: eroare internă? nu se poate genera realocarea „%s”

en: internal error? cannot generate `%s' relocation (%d, %d)
ro: eroare internă? nu se poate genera realocarea „%s” (%d, %d)

en: internal failure in parse_register_list
ro: eroare internă în parse_register_list

en: internal inconsistency in %s: bdap.w with no symbol
ro: inconsistență internă în %s: bdap.w fără niciun simbol

en: internal inconsistency in %s: bdapq no symbol
ro: inconsistență internă în %s: bdapq fără simbol

en: internal inconsistency problem in %s: %lx
ro: problemă de inconsistență internă în %s: %lx

en: internal inconsistency problem in %s: ext. insn %04lx
ro: problemă de inconsistență internă în %s: instrucțiunea ext. %04lx

en: internal inconsistency problem in %s: fr_subtype %d
ro: problemă de inconsistență internă în %s: fr_subtip %d

en: internal inconsistency problem in %s: fr_symbol %lx
ro: problemă de inconsistență internă în %s: fr_simbol %lx

en: internal inconsistency problem in %s: insn %04lx
ro: problemă de inconsecvență internă în %s: instrucțiunea %04lx

en: internal inconsistency problem in %s: resolved symbol
ro: problemă de inconsistență internă în %s: simbol rezolvat

en: internal inconsistency problem: %s called for %d bytes
ro: problemă de inconsistență internă: %s apelat pentru %d octeți

en: internal relocation (type: IMMEDIATE) not fixed up
ro: realocare internă (tip: IMMEDIATE) necorectată

en: internal: BFD_RELOC_MMIX_BASE_PLUS_OFFSET not resolved to section
ro: intern: BFD_RELOC_MMIX_BASE_PLUS_OFFSET nu a fost rezolvat în secțiunea

en: internal: GREG expression not resolved to section
ro: intern: expresia GREG nu a fost rezolvată în secțiune

en: internal: bad CFA value #%d
ro: intern: valoare CFA eronată nr. %d

en: internal: bad RISC-V CSR class (0x%x)
ro: intern: clasă RISC-V CSR greșită (0x%x)

en: internal: bad RISC-V opcode (bits %#llx undefined or invalid): %s %s
ro: intern: cod operațional RISC-V greșit (biți %#llx nedefiniți sau nevalabili): %s %s

en: internal: bad RISC-V opcode (mask error): %s %s
ro: intern: cod operațional RISC-V greșit (eroare de mască): %s %s

en: internal: bad RISC-V opcode (unknown operand type `%s'): %s %s
ro: intern: cod operațional RISC-V greșit (tip de operand necunoscut „%s”): %s %s

en: internal: bad RISC-V privileged spec (%s)
ro: intern: specificație privilegiată RISC-V greșită (%s)

en: internal: bad mips opcode (bits 0x%08lx defined): %s %s
ro: intern: cod operațional mips greșit (biți 0x%08lx definiți): %s %s

en: internal: bad mips opcode (bits 0x%08lx doubly defined): %s %s
ro: intern: cod operațional mips greșit (biți 0x%08lx dublu definiți): %s %s

en: internal: bad mips opcode (bits 0x%08lx undefined): %s %s
ro: intern: cod operațional mips greșit (biți 0x%08lx nedefiniți): %s %s

en: internal: bad mips opcode (mask error): %s %s
ro: intern: cod operațional mips greșit (eroare de mască): %s %s

en: internal: bad relocation #%d
ro: intern: realocare greșită #%d

en: internal: broken assembler.  No assembly attempted
ro: intern: asamblor defect. Nu se încearcă asamblarea

en: internal: duplicate %s
ro: intern: %s duplicat

en: internal: invalid macro argument `%s'
ro: intern: argument macro nevalid „%s”

en: internal: macro %s not implemented
ro: intern: macro %s nu este implementată

en: internal: mmix_prefix_name but empty prefix
ro: intern: mmix_prefix_name dar prefixul este gol

en: internal: unexpected argument '%d' to msp430_object_attribute
ro: intern: argument neașteptat „%d” pentru msp430_object_attribute

en: internal: unexpected relax type %d:%d
ro: intern: tip de relaxare neașteptat %d:%d

en: internal: unhandled label %s
ro: intern: etichetă negestionată %s

en: internal: unknown argument type `%s'
ro: intern: tip de argument necunoscut „%s”

en: internal: unknown operand type: %s %s
ro: intern: tip de operand necunoscut: %s %s

en: internal: unsupported RISC-V relocation number %d
ro: intern: număr de realocare RISC-V neacceptat %d

en: internal_relocation (type: OFFSET_IMM) not fixed up
ro: internal_relocation (tip: OFFSET_IMM) necorectată

en: interrupt vector for trap instruction out of range
ro: vectorul de întrerupere pentru instrucțiunea trap este în afara intervalului

en: invalid %%-tag in BPF opcode '%s'
ro: etichetă %% nevalidă în codul operațional BPF „%s”

en: invalid %s option for %s cpu
ro: opțiune %s nevalidă pentru cpu %s

en: invalid %s relocation against register
ro: realocare %s nevalidă în raport cu registrul

en: invalid -malign-branch-boundary= value: %s
ro: opțiune -malign-branch-boundary= nevalidă: „%s”

en: invalid -malign-branch-prefix-size= value: %s
ro: opțiune -malign-branch-prefix-size= nevalidă: „%s”

en: invalid -malign-branch= option: `%s'
ro: opțiune -malign-branch= nevalidă: „%s”

en: invalid -march= option: `%s'
ro: opțiune -march= nevalidă: „%s”

en: invalid -mavxscalar= option: `%s'
ro: opțiune -mavxscalar= nevalidă: „%s”

en: invalid -mevexlig= option: `%s'
ro: opțiune -mevexlig= nevalidă: „%s”

en: invalid -mevexrcig= option: `%s'
ro: opțiune -mevexrcig= nevalidă: „%s”

en: invalid -mevexwig= option: `%s'
ro: opțiune -mevexwig= nevalidă: „%s”

en: invalid -mfence-as-lock-add= option: `%s'
ro: opțiune -mfence-as-lock-add= nevalidă: „%s”

en: invalid -mlfence-after-load= option: `%s'
ro: opțiune -mlfence-after-load= nevalidă: „%s”

en: invalid -mlfence-before-indirect-branch= option: `%s'
ro: opțiune -mlfence-before-indirect-branch= nevalidă: „%s”

en: invalid -mlfence-before-ret= option: `%s'
ro: opțiune -mlfence-before-ret= nevalidă: „%s”

en: invalid -mmnemonic= option: `%s'
ro: opțiune -mmnemonic= nevalidă: „%s”

en: invalid -momit-lock-prefix= option: `%s'
ro: opțiune -momit-lock-prefix= nevalidă: „%s”

en: invalid -moperand-check= option: `%s'
ro: opțiune -moperand-check= nevalidă: „%s”

en: invalid -mrelax-relocations= option: `%s'
ro: opțiune -mrelax-relocations= nevalidă: „%s”

en: invalid -msse-check= option: `%s'
ro: opțiune -msse-check= nevalidă: „%s”

en: invalid -msyntax= option: `%s'
ro: opțiune -msyntax= nevalidă: „%s”

en: invalid -mtls-check= option: `%s'
ro: opțiune -mtls-check= nevalidă: „%s”

en: invalid -mtune= option: `%s'
ro: opțiune -mtune= nevalidă: „%s”

en: invalid -mvexwig= option: `%s'
ro: opțiune -mvexwig= nevalidă: „%s”

en: invalid -mx86-used-note= option: `%s'
ro: opțiune -mx86-used-note= nevalidă: „%s”

en: invalid <arch> in --march=<arch>: %s
ro: <ahitectura> nu este validă în --march=<ahitectura>: %s

en: invalid @slotcount value
ro: valoare @slotcount nevalidă

en: invalid BSPEC expression
ro: expresie BSPEC nevalidă

en: invalid CSR `%s' for the privileged spec `%s'
ro: CSR „%s” nevalid pentru specificația privilegiată „%s”

en: invalid CSR `%s', needs `%s' extension
ro: CSR „%s” nevalid, are nevoie de extensia „%s”

en: invalid CSR `%s', needs `h' extension
ro: CSR „%s” nevalid, are nevoie de extensia „h”

en: invalid CSR `%s', needs rv32i extension
ro: CSR „%s” nevalid, are nevoie de extensia rv32i

en: invalid Hi register with immediate
ro: registru Hi nevalid cu o imediată

en: invalid INST in command line: %s
ro: INST nevalidă în linia de comandă: %s

en: invalid LOC expression
ro: expresie LOC nevalidă

en: invalid NaN setting -mnan=%s
ro: definire NaN nevalidă „-mnan=%s”

en: invalid PC-relative operand
ro: operand relativ la PC nevalid

en: invalid PLT expression `%s'
ro: expresie PLT nevalidă „%s”

en: invalid Rt register number in 64-byte load/store
ro: număr de registru Rt nevalid în încărcare/stocare pe 64 de octeți

en: invalid SIB address
ro: adresă SIB nevalidă

en: invalid VSIB address
ro: adresă VSIB nevalidă

en: invalid WakeOnStatus %ld
ro: WakeOnStatus nevalid %ld

en: invalid XFR WideBus Address %ld
ro: adresă XFR WideBus nevalidă %ld

en: invalid ZA tile
ro: piesă ZA nevalidă

en: invalid `%s' prefix
ro: prefix „%s” nevalid

en: invalid abi -mabi=%s
ro: abi nevalid, „-mabi=%s”

en: invalid accumulator register
ro: registru acumulator nevalid

en: invalid address
ro: adresă nevalidă

en: invalid addressing mode
ro: mod de adresare nevalid

en: invalid architectural extension
ro: extensie arhitecturală nevalidă

en: invalid architecture -A%s
ro: arhitectură nevalidă „-A%s”

en: invalid architecture -xarch=%s
ro: arhitectură nevalidă -xarch=%s

en: invalid architecture -z%s
ro: arhitectură nevalidă -z%s

en: invalid architecture option -m%s, ignored
ro: opțiune de arhitectură nevalidă „-m%s”, ignorată

en: invalid argument '%s' to -fdebug-prefix-map
ro: argument nevalid „%s” pentru -fdebug-prefix-map

en: invalid attempt to declare external version name as default in symbol `%s'
ro: încercare nevalidă de a declara numele versiunii externe ca implicit în simbolul „%s”

en: invalid auto-litpool-limit argument
ro: argument auto-litpool-limit nevalid

en: invalid auto-litpool-limit argument (range is 100-10000)
ro: argument auto-litpool-limit nevalid (intervalul este 100-10000)

en: invalid barrier type
ro: tip de barieră „barrier” nevalid

en: invalid base register
ro: registru de bază nevalid

en: invalid base register for register offset
ro: registru de bază nevalid pentru decalajul registrului

en: invalid branch operand
ro: operand de ramificare nevalid

en: invalid byte branch offset
ro: decalaj de ramificare pe octeți nevalid

en: invalid cache operation name
ro: nume de operație de cache nevalid

en: invalid char %s beginning operand %d `%s'
ro: caracter nevalid %s care începe operandul %d „%s”

en: invalid character %#x found inside .base64 string
ro: caracter nevalid %#x găsit în interiorul șirului .base64

en: invalid character %s before operand %d
ro: caracter nevalid %s înaintea operandului %d

en: invalid character %s in mnemonic
ro: caracter nevalid %s în mnemonic

en: invalid character %s in operand %d
ro: caracter nevalid %s în operandul %d

en: invalid character '%c' found inside .base64 string
ro: caracter nevalid „%c” găsit în interiorul șirului .base64

en: invalid characters in input
ro: caractere nevalide la intrare

en: invalid co-processor operand
ro: operand coprocesor nevalid

en: invalid condition
ro: condiție nevalidă

en: invalid condition code '%s'
ro: cod de condiție nevalid „%s”

en: invalid condition code name
ro: nume de cod de condiție nevalid

en: invalid configuration option '%s' in transition rule '%s'
ro: opțiune de configurare nevalidă „%s” în regula de tranziție „%s”

en: invalid constant
ro: constantă nevalidă

en: invalid constant (%lx) after fixup
ro: constantă nevalidă (%lx) după corectare

en: invalid constant table offset %ld
ro: decalaj nevalid al tabelului de constante %ld

en: invalid constant: %d bit expression not in range %d..%d
ro: constantă nevalidă: expresia de %d biți nu se află în intervalul %d..%d

en: invalid constant: %d bit expression not in range %u..%u
ro: constantă nevalidă: expresia de %d biți nu se află în intervalul %u..%u

en: invalid constant: %d is not word align integer
ro: constantă nevalidă: %d nu este un număr întreg aliniat la cuvânt

en: invalid constant: 10 bit expression not in range [-2^9, 2^9-1]
ro: constantă nevalidă: expresia de 10 biți nu se află în intervalul [-2^9, 2^9-1]

en: invalid constant: 20 bit expression not in range -2^19..2^19-1
ro: constantă nevalidă: expresia de 20 de biți nu se află în intervalul -2^19..2^19-1

en: invalid constant: 25 bit expression not in range [-16777216, 16777215]
ro: constantă nevalidă: expresia de 25 de biți nu se află în intervalul [-16777216, 16777215]

en: invalid constant: 32 bit expression not in range [-0x80000000, 0x7fffffff]
ro: constantă nevalidă: expresia de 32 de biți nu se află în intervalul [-0x80000000, 0x7fffffff]

en: invalid constant: 32 bit expression not in range [0, 0xffffffff]
ro: constantă nevalidă: expresia de 32 de biți nu se află în intervalul [0, 0xffffffff]

en: invalid constant: 32 bit expression not word align
ro: constantă nevalidă: expresia de 32 de biți nu este aliniată la cuvânt

en: invalid constant: bit expression not defined
ro: constantă nevalidă: expresia de biți nu este definită

en: invalid control register name
ro: nume de registru de control nevalid

en: invalid data size %d
ro: dimensiune nevalidă a datelor %d

en: invalid default displacement size "%s". Defaulting to %d.
ro: dimensiune de deplasare implicită nevalidă „%s”. Se aplică valoarea implicită %d.

en: invalid destination memory operand
ro: operand de memorie de destinație nevalid

en: invalid destination register
ro: registru de destinație nevalid

en: invalid destination register list
ro: listă de registre de destinație nevalidă

en: invalid destination unit
ro: unitate de destinație nevalidă

en: invalid element selector
ro: selector de elemente nevalid

en: invalid element size %d and vector size combination %c
ro: combinație nevalidă între dimensiunea elementului %d și dimensiunea vectorului %c

en: invalid empty loop
ro: buclă goală nevalidă

en: invalid expression for operand %i of '%s'
ro: expresie nevalidă pentru operandul %i din „%s”

en: invalid expression in load/store multiple
ro: expresie nevalidă în încărcarea/stocarea multiplă

en: invalid expression in the address
ro: expresie nevalidă în adresă

en: invalid flag '%s'
ro: opțiune nevalidă „%s”

en: invalid floating point numbers type `%s'
ro: tip de numere în virgulă mobilă nevalid „%s”

en: invalid floating-point constant
ro: constantă cu virgulă mobilă nevlidă

en: invalid fourth register
ro: al patrulea registru nevalid

en: invalid frame size
ro: dimensiune nevalidă a cadrului

en: invalid hvc expression
ro: expresie hvc nevalidă

en: invalid identifier for ".ifdef"
ro: identificator nevalid pentru „.ifdef”

en: invalid immediate
ro: valoare imediată nevalidă

en: invalid immediate field position
ro: poziția câmpului imediat nu este validă

en: invalid immediate for address calculation (value = 0x%08lX)
ro: imediată nevalidă pentru calculul adresei (valoare = 0x%08lX)

en: invalid immediate for stack address calculation
ro: imediată nevalidă pentru calcularea adresei stivei

en: invalid immediate size
ro: dimensiune imediată nevalidă

en: invalid immediate value
ro: valoare directă(immediate) nevalidă

en: invalid immediate: %ld is out of range
ro: imediată nevalidă: %ld este în afara intervalului

en: invalid index size for coldfire
ro: dimensiune nevalidă a indexului pentru coldfire

en: invalid indirect register size
ro: dimensiune de registru indirect nevalidă

en: invalid instruction `%s' after `%s'
ro: instrucțiune nevalidă „%s” după „%s”

en: invalid instruction for this architecture; needs
ro: instrucțiune nevalidă pentru această arhitectură; se necesită

en: invalid instruction shape
ro: formă nevalidă a instrucțiunii

en: invalid instruction size selected (%d)
ro: dimensiune nevalidă a instrucțiunii selectate (%d)

en: invalid instruction suffix
ro: sufix de instrucțiune nevalid

en: invalid last instruction for a zero-overhead loop
ro: ultima instrucțiune nu este validă pentru o buclă cu încărcare-zero (zero-overhead)

en: invalid length for .scomm directive
ro: lungime nevalidă pentru directiva .scomm

en: invalid listing option `%c'
ro: opțiune nevalidă de listare „%c”

en: invalid literal constant: pool needs to be closer
ro: constantă literală nevalidă: fondul trebuie să fie mai aproape

en: invalid lrlive '%lu'
ro: lrlive nevalid „%lu”

en: invalid machine `%s'
ro: mașină nevalidă `%s'

en: invalid machine mode `%s'
ro: mod mașină nevalid „%s”

en: invalid memory operand
ro: operand de memorie nevalid

en: invalid merge / string entity size
ro: dimensiune invalidă a entității de fuzionare / șir

en: invalid mode
ro: mod nevalid

en: invalid movx address register
ro: registru de adrese movx nevalid

en: invalid movx dsp register
ro: registru dsp movx nevalid

en: invalid movy address register
ro: registru de adrese movy nevalid

en: invalid movy dsp register
ro: registru dsp movy nevalid

en: invalid neon suffix for non neon instruction
ro: sufix neon nevalid pentru instrucțiunea non-neon

en: invalid number
ro: număr nevalid

en: invalid number of registers in the list at operand %d -- `%s'
ro: număr nevalid de registre în lista de la operandul %d -- „%s”

en: invalid offset expression
ro: expresie de deplasare nevalidă

en: invalid offset register
ro: registru de poziție nevalid

en: invalid offset, target not word aligned (0x%08lX)
ro: decalaj nevalid, ținta nu este aliniată la cuvânt (0x%08lX)

en: invalid offset, value too big (0x%08lX)
ro: decalaj nevalid, valoare prea mare (0x%08lX)

en: invalid opcode
ro: cod operațional nevalid

en: invalid opcode '%s' in transition rule '%s'
ro: cod operațional nevalid „%s” în regula de tranziție „%s”

en: invalid operand
ro: operand nevalid

en: invalid operand (%s section) for `%s'
ro: operand nevalid (secțiunea %s) pentru „%s”

en: invalid operand (%s section) for `%s' when setting `%s'
ro: operand nevalid (secțiunea %s) pentru „%s” la definirea „%s”

en: invalid operand in ldm
ro: operand nevalid în ldm

en: invalid operand in stm
ro: operand nevalid în stm

en: invalid operand mode for this architecture; needs 68020 or higher
ro: mod operand nevalid pentru această arhitectură; necesită 68020 sau superior

en: invalid operand of ()+
ro: operand nevalid al ()+

en: invalid operand of -()
ro: operand nevalid al lui -()

en: invalid operand of S^#
ro: operand nevalid al lui S^#

en: invalid operand size requested
ro: dimensiune nevalidă a operandului solicitat

en: invalid operand to .code directive (%d) (expecting 16 or 32)
ro: operand nevalid pentru directiva .code (%d) (se aștepta să fie 16 sau 32)

en: invalid operand to opcode %s: `%s'
ro: operand nevalid pentru codul operațional %s: „%s”

en: invalid operands
ro: operanzi nevalabili

en: invalid operands (%s and %s sections) for `%s'
ro: operanzi nevalizi (secțiunile %s și %s) pentru „%s”

en: invalid operands (%s and %s sections) for `%s' when setting `%s'
ro: operanzi nevalizi (secțiunile %s și %s) pentru „%s” la definirea „%s”

en: invalid operands for cross-unit op
ro: operanzi nevalabili pentru operația între unități

en: invalid operands for opcode
ro: operanzi nevalid pentru codul operațional

en: invalid operands to opcode %s: `%s'
ro: operanzi nevalid pentru codul operațional %s: „%s”

en: invalid or unsupported encoding in .cfi_lsda
ro: codificare nevalidă sau neacceptată în .cfi_lsda

en: invalid or unsupported encoding in .cfi_personality
ro: codificare nevalidă sau neacceptată în .cfi_personality

en: invalid pc-relative address
ro: adresă relativă la calculator nevalidă

en: invalid performance register
ro: registru de performanță nevalid

en: invalid pref operation name
ro: nume de operație pref nevalid

en: invalid priority '%lu'
ro: prioritate nevalidă „%lu”

en: invalid pseudo operation
ro: pseudo-operație nevalidă

en: invalid quickrot register specified
ro: registru quickrot nevalid specificat

en: invalid quickrot unit specified
ro: unitate quickrot nevalidă specificată

en: invalid range in vector register list
ro: interval nevalid în lista de registre vectoriale

en: invalid register
ro: registru nevalid

en: invalid register '%s' for '%s' instruction
ro: registru nevalid „%s” pentru instrucțiunea „%s”

en: invalid register expression
ro: expresie de registru nevalidă

en: invalid register for memory access
ro: registru pentru acces la memorie nevalid

en: invalid register list
ro: listă de registru nevalidă

en: invalid register list at operand %d
ro: listă de registre nevalidă la operandul %d

en: invalid register list to push/pop instruction
ro: listă de registre nevalidă pentru instrucțiunea push/pop

en: invalid register mask
ro: mască de registru nevalidă

en: invalid register name
ro: nume de registru nevalid

en: invalid register number (%ld) for '%s'
ro: număr de registru nevalid (%ld) pentru „%s”

en: invalid register number (%ld) for '%s' instruction
ro: număr de registru nevalid (%ld) pentru instrucțiunea „%s”

en: invalid register number: %d is not in [r0--r7]
ro: număr de registru nevalid: %d nu este în [r0--r7]

en: invalid register operand
ro: operand registru nevalid

en: invalid register operand #1
ro: operand nr. 1 de registru nevalid

en: invalid register operand #2
ro: operand nr. 2 de registru nevalid

en: invalid register operand #3
ro: operand nr. 3 de registru nevalid

en: invalid register operand #4
ro: operand nr. 4 de registru nevalid

en: invalid register operand size for `%s'
ro: dimensiunea operandului registrului nu este validă pentru „%s”

en: invalid register operand: %s
ro: operand de registru nevalid: %s

en: invalid register range
ro: interval de registre nevalid

en: invalid register stride at operand %d -- `%s'
ro: interval de registru nevalid la operandul %d -- „%s”

en: invalid register: r15 illegal
ro: registru nevalid: r15 ilegal

en: invalid relaxation fragment result
ro: rezultat nevalid al fragmentului de relaxare

en: invalid reloc expression
ro: expresie de realocare nevalidă

en: invalid relocation
ro: realocare nevalidă

en: invalid relocation %s for field
ro: realocare nevalidă %s pentru câmpul

en: invalid relocation expression
ro: expresie de realocare nevalidă

en: invalid relocation for '%s' instruction
ro: realocare nevalidă pentru instrucțiunea „%s”

en: invalid relocation for field
ro: realocare nevalidă pentru câmp

en: invalid relocation for instruction
ro: realocare nevalidă pentru instrucțiune

en: invalid relocation for operand %d of '%s'
ro: realocare nevalidă pentru operandul %d din „%s”

en: invalid relocation for operand %i of '%s'
ro: realocare nevalidă pentru operandul %i din „%s”

en: invalid relocation in instruction slot %i
ro: realocare nevalidă în slotul de instrucțiuni %i

en: invalid rotation
ro: rotație nevalidă

en: invalid rounding mode
ro: mod de rotunjire nevalid

en: invalid scalar register in list
ro: registru scalar nevalid în listă

en: invalid segment "%s"
ro: segment nevalid „%s”

en: invalid shift
ro: deplasare nevalidă

en: invalid shift for the register offset addressing mode
ro: deplasare nevalidă pentru modul de adresare cu decalaj de registru

en: invalid shift operator
ro: operator de deplasare nevalid

en: invalid shift value: %ld
ro: valoare de deplasare nevalidă: %ld

en: invalid short form floating point immediate operand
ro: operand imediat cu virgulă mobilă în formă scurtă nevalid

en: invalid single nop size: %d (expect within [0, %d])
ro: dimensiune nevalidă a unui singur nop: %d (se așteaptă la [0, %d])

en: invalid smc expression
ro: expresie smc nevalidă

en: invalid source memory operand
ro: operand de memorie sursă nevalid

en: invalid source register
ro: registru sursă nevalid

en: invalid source register list
ro: listă de registre sursă nevalidă

en: invalid source unit
ro: unitate sursă nevalidă

en: invalid suffix
ro: sufix nevalid

en: invalid suffix after register.
ro: sufix nevalid după registru.

en: invalid swi expression
ro: expresie swi nevalidă

en: invalid switch -m%s
ro: opțiune nevalidă „-m%s”

en: invalid symbolic operand
ro: operand simbolic nevalid

en: invalid syntax
ro: sintaxă nevalidă

en: invalid syntax for .dn directive
ro: sintaxă nevalidă pentru directiva .dn

en: invalid syntax for .qn directive
ro: sintaxă nevalidă pentru directiva .qn

en: invalid syntax for .req directive
ro: sintaxă nevalidă pentru directiva .req

en: invalid syntax for .unreq directive
ro: sintaxă nevalidă pentru directiva .unreq

en: invalid system register name
ro: nume de registru de sistem nevalid

en: invalid target hardware version
ro: versiune hardware țintă nevalidă

en: invalid type for literal pool
ro: tip nevalid pentru fondul literal

en: invalid unextended operand value
ro: valoare nevalidă a operandului neextins

en: invalid unwind opcode
ro: cod operațional de desfășurare nevalid

en: invalid use of "=immediate"
ro: utilizare nevalidă a „=immediate”

en: invalid use of %s relocation
ro: utilizare nevalidă a realocării %s

en: invalid use of 'MSL'
ro: utilizare nevalidă a „MSL”

en: invalid use of 'MUL'
ro: utilizare nevalidă a „MUL”

en: invalid use of 32-bit register offset
ro: utilizarea nevalidă a deplasării registrului pe 32 de biți

en: invalid use of 64-bit register offset
ro: utilizarea nevalidă a deplasării registrului pe 64 de biți

en: invalid use of operator "%s"
ro: utilizare nevalidă a operatorului „%s”

en: invalid use of vector register
ro: utilizare nevalidă a registrului vectorial

en: invalid value for special purpose register
ro: valoare nevalidă pentru registrul cu scop special

en: invalid vector group size
ro: dimensiunea grupului de vectori nu este validă

en: invalid vector register in list
ro: registru vectorial nevalid în listă

en: invalid vector register name
ro: nume de registru vectorial nevalid

en: invalid version name '%s' for symbol `%s'
ro: nume de versiune nevalid „%s” pentru simbolul „%s”

en: invalid write mask `%s'
ro: mască de scriere nevalidă „%s”

en: invalid zeroing-masking `%s'
ro: mascarea cu zerouri nu este validă „%s”

en: is_stmt value not 0 or 1
ro: valoarea is_stmt nu este 0 sau 1

en: isa number less than zero
ro: numărul isa este mai mic decât zero

en: jump not 3..10 bytes away (is %d)
ro: saltul nu este la 3..10 octeți distanță (este la %d)

en: jump over nop padding out of range
ro: sare peste nop de umplere în afara intervalului

en: jump target out of range
ro: salt țintă în afara limitei

en: jump target out of range; no usable trampoline found
ro: ținta de salt este în afara razei de acțiune; nu s-a găsit nicio trambulină utilizabilă

en: jump to a symbol in another ISA mode
ro: salt la un simbol în alt mod ISA

en: jump to misaligned address (0x%lx)
ro: salt la adresa prost aliniată (0x%lx)

en: junk `%s' after expression
ro: deșeuri „%s” după expresie

en: junk `%s' after register
ro: deșeuri „%s” după registru

en: junk after operand %u of '%.*s'
ro: gunoi după operandul %u din „%.*s”

en: junk at end of line, first unrecognized character is `%c'
ro: gunoi la sfârșit de linie, primul caracter nerecunoscut este „%c”

en: junk at end of line, first unrecognized character valued 0x%x
ro: gunoi la sfârșit de linie, primul caracter nerecunoscut evaluat 0x%x

en: junk at end of line: "%s"
ro: gunoi la sfârșit de linie: „%s”

en: junk at end of line: `%s'
ro: gunoi la sfârșit de linie: „%s”

en: junk at end of machine string, first unrecognized character is `%c'
ro: gunoi la sfârșitul șirului de mașină, primul caracter nerecunoscut este „%c”

en: junk found after instruction: %s.%s
ro: gunoi găsit după instrucțiunea: %s.%s

en: la must use with symbol. '%s'
ro: „la” trebuie utilizat cu simbol. „%s”

en: la used to load 64-bit address; recommend using dla instead
ro: „la” utilizat pentru încărcarea adresei pe 64 de biți; se recomandă utilizarea a „dla” în locul acestuia

en: label "$%d" redefined
ro: eticheta „$%d” a fost redefinită

en: label "%ld$" redefined
ro: eticheta „%ld$” a fost redefinită

en: label %s was not defined in this dwarf section
ro: eticheta %s nu a fost definită în această secțiune dwarf

en: label after '||'
ro: etichetă după „||”

en: label after predicate
ro: etichetă după predicat

en: label not at start of execute packet
ro: eticheta nu se află la începutul pachetului de execuție

en: labels are not valid inside bundles
ro: etichetele nu sunt valabile în interiorul pachetelor

en: lacking label
ro: lipsește eticheta

en: lacking label
ro: lipsește eticheta

en: last register must be r7
ro: ultimul registru trebuie să fie r7

en: ldr to register 15 must be 4-byte aligned
ro: ldr la registrul 15 trebuie să fie aliniat pe 4 octeți

en: ldrd/strd requires even:odd register pair
ro: ldrd/strd necesită o pereche de registre par:impar

en: leb128 operand is an undefined symbol: %s
ro: operandul leb128 este un simbol nedefinit: %s

en: left operand is a bignum; integer 0 assumed
ro: operandul stâng este un număr mare (bignum); se presupune un număr întreg 0

en: left operand is a float; integer 0 assumed
ro: operandul stâng este un număr în virgulă mobilă; se presupune un număr întreg 0

en: length
ro: lungimea

en: length not needed
ro: lungimea nu este necesară

en: length of .lcomm "%s" is already %ld. Not changed to %ld.
ro: lungimea lui .lcomm „%s” este deja %ld. Nu se modifică la %ld.

en: li overflow: hi32:0x%x lo32:0x%x
ro: depășire de li: hi32:0x%x lo32:0x%x

en: li rd label isn't correct instruction form
ro: eticheta li rd nu este o formă de instrucțiune corectă

en: libbfd ABI mismatch
ro: nepotrivire ABI libbfd

en: line %d: rep or repi must include at least 4 instructions
ro: linia %d: rep sau repi trebuie să includă cel puțin 4 instrucțiuni

en: line %d: unknown relocation type: 0x%x
ro: linia %d: tip de realocare necunoscut: 0x%x

en: line number (%d) for .stab%c directive cannot fit in index field (20 bits)
ro: numărul liniei (%d) pentru directiva .stab%c nu poate încăpea în câmpul index (20 biți)

en: line numbers must be positive; line number %d rejected
ro: numerele de linie trebuie să fie pozitive; numărul de linie %d este respins

en: link register must be in a low numbered register
ro: registrul de legătură trebuie să fie într-un registru cu număr mic

en: link register unit must be one of %s
ro: unitatea de registru de legătură trebuie să fie una dintre %s

en: literal pool insertion failed
ro: inserția fondului literal a eșuat

en: literal pool location required for text-section-literals; specify with .literal_position
ro: locația fondului de literale necesară pentru literalele secțiunii text (text-section-literals); se specifică cu .literal_position

en: literal pool overflow
ro: depășirea fondului literal

en: literal referenced across section boundary
ro: literal la care se face referire peste limita secțiunii

en: lk addressing modes are invalid for memory-mapped register addressing
ro: modurile de adresare lk nu sunt valabile pentru adresarea registrelor cu alocare de memorie

en: lmi pseudo instruction should not use a label in imm field
ro: pseudo instrucțiunea lmi nu trebuie să utilizeze o etichetă în câmpul imm

en: lo register required
ro: se necesită un registru lo

en: lo() relocation used on an instruction which does not support it
ro: realocarea lo() utilizată pe o instrucțiune care nu o acceptă

en: loading the same register in parallel operation
ro: se încarcă același registru în operația paralelă

en: local label `%s' is not defined
ro: eticheta locală „%s” nu este definită

en: local label too large near %s
ro: etichetă locală prea mare lângă %s

en: long jump required
ro: se necesită un salt lung

en: loop containing less than three instructions may trigger hardware errata
ro: bucla care conține mai puțin de trei instrucțiuni poate declanșa erori hardware

en: loop count constant %ld is out of range [1..%d]
ro: constanta de numărare a buclelor %ld este în afara intervalului [1..%d]

en: loop end too close to another loop end may trigger hardware errata
ro: un capăt de buclă prea aproape de un alt capăt de buclă poate declanșa erori hardware

en: loop target does not follow loop instruction in section
ro: ținta buclei nu urmează instrucțiunea buclei din secțiune

en: loop: 32-bit displacement not supported
ro: loop: deplasamentul pe 32 de biți nu este acceptat

en: low register (r0-r15) expected, not '%.100s'
ro: se aștepta un registru inferior (r0-r15), nu „%.100s”

en: lower 16 bits of mask ignored
ro: cei 16 biți inferiori ai măștii sunt ignorați

en: lui expression not in range 0..1048575
ro: expresia „lui” nu se află în intervalul 0..1048575

en: m68k and cf features both selected
ro: caracteristicile m68k și cf sunt ambele selectate

en: macro %s not implemented yet
ro: macro %s nu este încă implementată

en: macro instruction expanded into a wrong size instruction in a 16-bit branch delay slot
ro: instrucțiune macro extinsă într-o instrucțiune de dimensiune greșită într-un slot de întârziere a ramificării pe 16 biți

en: macro instruction expanded into a wrong size instruction in a 32-bit branch delay slot
ro: instrucțiune macro extinsă într-o instrucțiune de dimensiune greșită într-un slot de întârziere a ramificării pe 32 biți

en: macro instruction expanded into multiple instructions
ro: macroinstrucțiune extinsă în mai multe instrucțiuni

en: macro instruction expanded into multiple instructions in a branch delay slot
ro: macroinstrucțiune extinsă în mai multe instrucțiuni într-un slot de întârziere a ramificării

en: macro invoked from here
ro: macro invocată de aici

en: macro requires $at register while noat in effect
ro: macro necesită registrul $at în timp ce noat este în vigoare

en: macro requires $at while $at in use
ro: macro necesită $at în timp ce $at este în uz

en: macro used $at after ".set noat"
ro: macro a utilizat $at după „.set noat”

en: macros nested too deeply
ro: macro-uri imbricate prea adânc

en: major opcode is not sorted for %s
ro: codul operațional major nu este sortat pentru %s

en: major opcode not in range [0x%02x - 0x%02x]
ro: codul operațional major nu se află în intervalul [0x%02x - 0x%02x]

en: malformed reglist in push/pop
ro: listă de registre formată greșit în push/pop

en: mask not on destination operand
ro: masca nu se află pe operandul de destinație

en: mask trims opcode bits for %s
ro: masca ajustează biții codului operațional pentru %s

en: mask, index, and destination registers must be distinct
ro: masca, indexul și registrele de destinație trebuie să fie distincte

en: mask, index, and destination registers should be distinct
ro: masca, indexul și registrele de destinație trebuie să fie distincte

en: matching operands to opcode
ro: se potrivesc operanzii cu codul operațional

en: md5 value too small or not a constant
ro: valoarea md5 este prea mică sau nu este o constantă

en: md5_stream failed
ro: md5_stream a eșuat

en: md_apply_fix: unknown r_type 0x%x
ro: md_apply_fix: r_type necunoscut 0x%x

en: md_apply_fix: unknown reloc type 0x%x
ro: md_apply_fix: tip de realocare necunoscut 0x%x

en: memory destination needed for instruction `%s' after `xrelease'
ro: destinație de memorie necesară pentru instrucțiunea „%s” după „xrelease”

en: minor opcode not in range [0x00 - 0x3f]
ro: codul operațional minor nu se află în intervalul [0x00 - 0x3f]

en: misaligned branch destination
ro: destinația ramificării nu este aliniată

en: misaligned data
ro: date prost aliniate

en: misaligned offset
ro: decalaj prost aliniat

en: mismatch between opcode size and operand size
ro: nepotrivire între dimensiunea codului operațional și dimensiunea operandului

en: mismatch between register and suffix
ro: nepotrivire între registru și sufix

en: mismatch for format '%s': #slots = %d, #opcodes = %d
ro: nepotrivire pentru formatul „%s”: nr. sloturi = %d, nr. coduri operraționale = %d

en: mismatched .eb
ro: .eb nepotrivit

en: mismatched element/structure types in list
ro: tipurile de elemente/structuri nu corespund în listă

en: mismatched parentheses
ro: paranteze care nu corespund

en: misplaced .procend
ro: .procend plasat greșit

en: misplaced PIC operand
ro: operand PIC plasat greșit

en: missing '%c'
ro: lipsește „%c”

en: missing ')'
ro: „)” lipsește

en: missing ']'
ro: „]” lipsește

en: missing +
ro: lipsește „+”

en: missing .end
ro: lipsește „.end”

en: missing .end at end of assembly
ro: lipsește „.end” la sfârșitul asamblării

en: missing .end or .bend at end of file
ro: lipsește .end sau .bend la sfârșitul fișierului

en: missing .endp before .cfi_startproc
ro: lipsește .endp înainte de .cfi_startproc

en: missing .fnstart before unwinding directive
ro: lipsește .fnstart înainte de derularea directivei

en: missing .func
ro: lipsește .func

en: missing .proc
ro: lipsește .proc

en: missing =
ro: lipsește „=”

en: missing CPS flags
ro: lipsesc fanioanele CPS

en: missing DSP name `%s'
ro: lipsește numele DSP „%s”

en: missing ZA tile size
ro: dimensiunea pieselor ZA lipsește

en: missing [
ro: lipsește „[”

en: missing ]
ro: lipsește „]”

en: missing `)'
ro: „)” lipsește

en: missing `)' after formals in macro definition `%s'
ro: lipsește „)” după formele din definiția macrocomenzii „%s”

en: missing `.end'
ro: lipsește „.end”

en: missing `]'
ro: „]” lipsește

en: missing `lock' with `%s'
ro: lipsește „lock” cu „%s”

en: missing `}'
ro: lipsește „}”

en: missing `}' in `%s'
ro: lipsește „}” din „%s”

en: missing `}' or `,' in pseudo-suffix
ro: lipsește „}” sau „,” în pseudo-sufix

en: missing abi name `%s'
ro: lipsește numele abi „%s”

en: missing alignment
ro: lipsește alinierea

en: missing alignment hint
ro: lipsește indicația de aliniere

en: missing architectural extension
ro: extensie arhitecturală lipsă

en: missing architecture name `%s'
ro: lipsește numele arhitecturii „%s”

en: missing argument
ro: argument lipsă

en: missing argument for %s_check directive
ro: argument lipsă pentru directiva %s_check

en: missing argument separator ',' for .cpsetup
ro: lipsește separatorul de argumente „,” pentru .cpsetup

en: missing block type
ro: tipul de bloc lipsește

en: missing braces at operand %d
ro: lipsesc acoladele la operandul %d

en: missing break count
ro: lipsește contorizarea întreruperilor

en: missing call argument
ro: lipsește argumentul de apel

en: missing call signature
ro: lipsește semnătura de apel

en: missing class
ro: lipsește clasa

en: missing close quote; (assumed)
ro: lipsesc ghilimelele de închidere; (presupus)

en: missing closing '"'
ro: lipsește închiderea „"”

en: missing closing `%c'
ro: lipsește închiderea „%c”

en: missing closing brace
ro: lipsește acolada de închidere

en: missing closing parenthesis
ro: lipsește paranteza de închidere

en: missing comma
ro: lipsește virgula

en: missing comma after insn constant
ro: lipsește virgula după constanta insn

en: missing comma or colon
ro: lipsește virgula sau două puncte „:”

en: missing condition code in structured control directive
ro: lipsește codul de condiție în directiva de control structurat

en: missing cpu architecture
ro: arhitectura cpu-ului lipsește

en: missing cpu name `%s'
ro: lipsește numele CPU-ului „%s”

en: missing do
ro: lipsește „do”

en: missing element size
ro: lipsește dimensiunea elementului

en: missing emulation mode name
ro: lipsește numele modului de emulare

en: missing expression
ro: lipsește expresia

en: missing expression for paper width
ro: lipsește expresia pentru lățimea hârtiei

en: missing expression in .abiversion directive
ro: expresie lipsă în directiva .abiversion

en: missing expression in .localentry directive
ro: expresie lipsă în directiva .localentry

en: missing expression in .size directive
ro: expresie lipsă în directiva .size

en: missing flags: one of 'P', 'N' or 'Z' required
ro: fanioane lipsă: este necesar unul dintre „P”, „N” sau „Z”

en: missing fpu name `%s'
ro: lipsește numele fpu „%s”

en: missing frame size
ro: dimensiunea cadrului lipsește

en: missing horizontal or vertical suffix at operand %d
ro: lipsește sufixul orizontal sau vertical la operandul %d

en: missing immediate expression
ro: se necesită expresie directă(immediate)

en: missing immediate offset
ro: lipsește decalajul imediat

en: missing label
ro: lipsește eticheta

en: missing label '%s' in func '%s' may result in imprecise cfg
ro: lipsa etichetei „%s” în funcția „%s” poate avea ca rezultat un cfg imprecis

en: missing local expression
ro: lipsește expresia locală

en: missing local index
ro: lipsește indexul local

en: missing model parameter
ro: lipsește parametrul modelului

en: missing name
ro: lipsește numele

en: missing offset
ro: decalaj lipsă

en: missing offset in the pre-indexed address
ro: decalaj lipsă în adresa preindexată

en: missing operand
ro: operand lipsă

en: missing operand after comma
ro: operand lipsă după virgulă

en: missing operand; zero assumed
ro: operand lipsă; se presupune zero

en: missing or bad offset expression
ro: expresie de deplasare lipsă sau greșită

en: missing or invalid displacement expression `%s'
ro: expresie de deplasare lipsă sau nevalidă „%s”

en: missing or invalid displacement expression `%s' taken as 0
ro: expresie de deplasare lipsă sau nevalidă „%s” luată ca 0

en: missing or invalid expression `%s'
ro: expresie lipsă sau nevalidă „%s”

en: missing or invalid immediate expression `%s'
ro: expresie imediată lipsă sau nevalidă „%s”

en: missing predication type
ro: lipsește tipul de predicat

en: missing real symbol name
ro: lipsește numele simbolului real

en: missing register index
ro: lipsește indexul registrului

en: missing reloc type
ro: tipul de realocare lipsește

en: missing rename string
ro: lipsește șirul de redenumire

en: missing reserved current_memory/grow_memory argument
ro: lipsește argumentul rezervat current_memory/grow_memory

en: missing rotation field after comma
ro: lipsește câmpul de rotație după virgulă

en: missing separator
ro: lipsește separatorul

en: missing shift amount
ro: lipsește valoarea deplasării

en: missing size
ro: lipsește dimensiunea

en: missing size expression
ro: lipsește expresia dimensiunii

en: missing sizeof_stub expression
ro: lipsește expresia sizeof_stub

en: missing stack size
ro: dimensiunea stivei lipsește

en: missing string
ro: șir lipsă

en: missing symbol name
ro: lipsește numele simbolului

en: missing symbol name for .variant_cc directive
ro: lipsește numele simbolului pentru directiva .variant_cc

en: missing table index
ro: lipsește indexul tabelului

en: missing then
ro: lipsește „then”

en: missing to or downto
ro: lipsește „to” sau „downto”

en: missing type
ro: tipul lipsește

en: missing type suffix
ro: lipsește sufixul de tip

en: missing value
ro: lipsește valoarea

en: missing version name in `%s' for symbol `%s'
ro: lipsește numele versiunii în „%s” pentru simbolul „%s”

en: mnemonic suffix used with `%s'
ro: sufix mnemonic utilizat cu „%s”

en: more than 65K literal pools
ro: mai mult de 65K fonduri literale

en: mov cannot use RD port as destination
ro: mov nu poate utiliza portul RD ca destinație

en: multibyte character (%#x) encountered in %s
ro: caracter multi-octet (%#x) întâlnit în %s

en: multibyte character (%#x) encountered in %s at or near line %u
ro: caracter multi-octet (%#x) întâlnit în %s la sau în apropierea liniei %u

en: multibyte character (%#x) encountered in input
ro: caracter multi-octet (%#x) întâlnit în intrare

en: multiple '||' on same line
ro: multiple „||” pe aceeași linie

en: multiple branches or jumps in the same bundle
ro: ramuri multiple sau salturi în același pachet

en: multiple condition specifications
ro: specificații multiple de condiție

en: multiple emulation names specified
ro: multiple nume de emulare specificate

en: multiple formats specified for one bundle; using '%s'
ro: formate multiple specificate pentru un pachet; folosind „%s”

en: multiple literals in expansion
ro: literale multiple în expansiune

en: multiple movx specifications
ro: specificații movx multiple

en: multiple movy specifications
ro: specificații movy multiple

en: multiple parallel processing specifications
ro: specificații de procesare paralelă multiplă

en: multiple predicates on same line
ro: multiple predicate pe aceeași linie

en: multiple sections remapped to output section %s
ro: secțiuni multiple realocate la secțiunea de ieșire %s

en: multiple vediv constants
ro: constante „vediv” multiple

en: multiple versions [`%s'|`%s'] for symbol `%s'
ro: versiuni multiple [„%s”|„%s”] pentru simbolul „%s”

en: multiple vlen constants
ro: constante „vlen” multiple

en: multiple vlmul constants
ro: constante „vlmul” multiple

en: multiple vma constants
ro: constante „vma” multiple

en: multiple vsew constants
ro: constante „vsew” multiple

en: multiple vta constants
ro: constante „vta” multiple

en: multiple writes to the same register
ro: scrieri multiple în același registru

en: must be @(r0,...)
ro: trebuie să fie @(r0,...)

en: must provide temp if destination overlaps mask
ro: trebuie să furnizeze temp dacă destinația se suprapune peste mască

en: must specify extensions to add before specifying those to remove
ro: trebuie să specificați extensiile de adăugat înainte de a le specifica pe cele de eliminat

en: need PIC qualifier with symbol. '%s'
ro: necesită calificator PIC cu un simbol. „%s”

en: needs @GOT or @GOTOFF. %s
ro: necesită @GOT sau @GOTOFF. %s

en: negative alignment
ro: aliniere negativă

en: negative nop control byte, ignored
ro: octet de control nop negativ, este ignorat

en: negative offset
ro: decalaj negativ

en: negative size
ro: dimensiune negativă

en: negative value ignored in %s
ro: valoare negativă ignorată în %s

en: nested .bs blocks
ro: blocuri .bs imbricate

en: nested .ent directives
ro: directive .ent imbricate

en: nested software pipelined loop
ro: buclă de linie de conducte software imbricate

en: new line in title
ro: linie nouă în titlu

en: new paper width is too small
ro: lățimea hârtiei noi este prea mică

en: new section '%s' defined without attributes - this might cause problems
ro: secțiune nouă „%s” definită fără atribute - acest lucru poate cauza probleme

en: next outside of structured loop
ro: „next” în afara buclei structurate

en: no %d-byte relocations available
ro: nu sunt disponibile realocări de %d-octeți

en: no '(' to match ')'
ro: nu există „(” pentru a se potrivi cu „)”

en: no '[' to match ']'
ro: nu există „[” pentru a se potrivi cu „]”

en: no .cprestore pseudo-op used in PIC code
ro: nicio pseudo operație .cprestore utilizată în codul PIC

en: no .frame pseudo-op used in PIC code
ro: nicio pseudo operație .frame utilizată în codul PIC

en: no EVEX encoding
ro: fără codificare EVEX

en: no HOWTO loong relocation number %d
ro: nu există niciun HOWTO pentru realocarea numărului luuung %d

en: no VEX/XOP encoding
ro: fără codificare VEX/XOP

en: no architecture contains all the instructions used
ro: nicio arhitectură nu conține toate instrucțiunile utilizate

en: no base64 characters expected after '=' padding characters
ro: nu sunt așteptate caractere base64 după caracterele „=” de umplere

en: no compiled in support for 32bit x86_64
ro: nu a fost compilat cu suport pentru x86_64 pe 32 de biți

en: no compiled in support for 64 bit object file format
ro: nu a fost compilat cu suport pentru formatul de fișier obiect pe 64 de biți

en: no compiled in support for ix86
ro: nu a fost compilat cu suport pentru ix86

en: no compiled in support for x86_64
ro: nu a fost compilat cu suport pentru x86_64

en: no current file pointer
ro: nu există un indicator de fișier curent

en: no entry symbol for global function '%s'
ro: niciun simbol de intrare pentru funcția globală „%s”

en: no file name following -t option
ro: niciun nume de fișier după opțiunea „-t”

en: no filename following .INCLUDE pseudo-op
ro: niciun nume de fișier după pseudo-operatorul .INCLUDE

en: no floating point unit specified
ro: nicio unitate de virgulă mobilă specificată

en: no function type on PLT reloc
ro: niciun tip de funcție pentru realocarea PLT

en: no hppa_fixup entry for fixup type 0x%x
ro: nicio intrare hppa_fixup pentru tipul de corecție 0x%x

en: no instruction mnemonic suffix given and no register operands
ro: nu se indică sufixul mnemonic al instrucțiunii și nu există operanzi de registru

en: no instruction mnemonic suffix given and no register operands; can't size `%s'
ro: nu este dat sufixul mnemonic al instrucțiunii și nu există operanzi de registru; nu se poate dimensiona „%s”

en: no instruction mnemonic suffix given; can't determine immediate size
ro: nu se indică sufixul mnemonic al instrucțiunii; nu se poate determina dimensiunea imediată

en: no known dwarf XCOFF section for flag 0x%08x
ro: nicio secțiune XCOFF dwarf cunoscută pentru fanionul 0x%08x

en: no match insn: %s	%s
ro: nicio potrivire pentru instrucțiunea: %s	%s

en: no registered fragment for literal
ro: niciun fragment înregistrat pentru literal

en: no relaxation found for this instruction.
ro: nu s-a găsit nicio relaxare pentru această instrucțiune.

en: no sequence number after !%s
ro: nici un număr de secvență după !%s

en: no size modifier after period, .w assumed
ro: fără modificator de dimensiune după punct, se presupune .w

en: no such architecture modifier: `%s'
ro: nu există un astfel de modificator de arhitectură: „%s”

en: no such architecture: `%s'
ro: nu există o astfel de arhitectură: „%s”

en: no such instruction: `%s'
ro: nu există o astfel de instrucțiune: „%s”

en: no such machine extension `%s'
ro: nu există o astfel de extensie de mașină „%s”

en: no suitable GREG definition for operands
ro: nicio definiție GREG adecvată pentru operanzi

en: no tag specified for %s
ro: nicio etichetă specificată pentru %s

en: no way to handle .file within .ent/.end section
ro: nicio modalitate de a gestiona .file în cadrul secțiunii .ent/.end

en: no-auto-litpools is incompatible with auto-litpool-limit
ro: no-auto-litpools este incompatibil cu auto-litpool-limit

en: non-PIC jump used in PIC library
ro: salt non-PIC utilizat în biblioteca PIC

en: non-absolute expression in constant field
ro: expresie neabsolută în câmp constant

en: non-absolute value used with .space/.bes
ro: valoare neabsolută utilizată cu .space/.bes

en: non-constant .sleb128 is not supported
ro: .sleb128 neconstant nu este acceptat

en: non-constant byte count
ro: număr de octeți neconstant

en: non-constant expression in ".elseif" statement
ro: expresie non-constantă în declarația „.elseif”

en: non-constant expression in ".if" statement
ro: expresie non-constantă în declarația „.if”

en: non-constant fill count for absolute section
ro: contor de umplere neconstant pentru secțiunea absolută

en: non-contiguous register range
ro: interval de registre necontiguu

en: non-immediate OPF operand, ignored
ro: operand OPF neimediat, ignorat

en: non-optional operand %d follows optional operand in %s
ro: operandul neopțional %d urmează operandul opțional în %s

en: non-pc-relative relocation for pc-relative field
ro: realocare ne-relativă la PC pentru câmpul relativ la PC

en: not a 16 bit instruction '%s'
ro: nu este o instrucțiune de 16 biți „%s”

en: not enough operands (%d) for '%s'; expected %d
ro: nu sunt suficienți operanzi (%d) pentru „%s”; se așteptau %d

en: not support reloc bit-field
    fmt: %c%c %s
    args: %s
ro: realocarea câmpurilor de biți nu este acceptată
    format: %c%c %s
    argumente: %s

en: number (0x%llx) larger than 32 bits
ro: număr (0x%llx) mai mare de 32 de biți

en: number (0x%lx) larger than 32 bits
ro: număr (0x%lx) mai mare de 32 de biți

en: number invalid
ro: număr nevalid

en: number larger than 64 bits
ro: număr mai mare de 64 biți

en: number must be positive and less than %d
ro: numărul trebuie să fie pozitiv și mai mic decât %d

en: number of literal tokens != 1
ro: numărul de simboluri (tokens) literale != 1

en: number of operands mismatch
ro: nepotrivire a numărului de operanzi

en: numeric view can only be asserted to zero
ro: vizualizarea numerică poate fi declarată numai la zero

en: odd address operand: %ld
ro: operand de adresă impară: %ld

en: odd displacement at %x
ro: deplasare impară la %x

en: odd distance branch (0x%lx byte) | odd distance branch (0x%lx bytes)
ro[0]: ramură la distanță impară (0x%lx octet)
ro[1]: ramură la distanță impară (0x%lx octeți)
ro[2]: ramură la distanță impară (0x%lx de octeți)

en: odd number cannot be used here
ro: numărul impar nu poate fi utilizat aici

en: odd number of bytes in operand description
ro: număr impar de octeți în descrierea operandului

en: odd register cannot be used here
ro: registrul impar nu poate fi utilizat aici

en: offset and base must be from the same unit
ro: decalajul și baza trebuie să fie din aceeași unitate

en: offset has different size from base
ro: decalajul are dimensiuni diferite față de bază

en: offset in operand %u of '%.*s' not divisible by %u
ro: decalajul din operandul %u din „%.*s” nu este divizibil cu %u

en: offset in operand %u of '%.*s' out of range
ro: decalajul din operandul %u din „%.*s” este în afara intervalului

en: offset must be a multiple of %d
ro: decalajul trebuie să fie un multiplu de %d

en: offset must be zero in ARM encoding
ro: decalajul trebuie să fie zero în codificarea ARM

en: offset not a multiple of 4
ro: decalajul nu este un multiplu de 4

en: offset out of range
ro: decalaj în afara intervalului

en: offset overflow (%+ld)
ro: depășire a decalajului (%+ld)

en: offset overflow (%+lld)
ro: depășire a decalajului (%+lld)

en: offset to unaligned destination
ro: decalaj către destinația nealiniată

en: offset too large
ro: decalaj prea mare

en: offset value out of range
ro: valoarea de compensare în afara intervalului

en: only 'LSL' shift is permitted
ro: doar deplasarea „LSL” este permisă

en: only 'MUL VL' is permitted
ro: doar „MUL VL” este permis

en: only 'MUL' is permitted
ro: doar „MUL” este permis

en: only D and Q registers may be indexed
ro: numai registrele D și Q pot fi indexate

en: only D registers may be indexed
ro: numai registrele D pot fi indexate

en: only LSL shift allowed in thumb mode
ro: doar deplasarea LSL este permisă în modul thumb

en: only SUBS PC, LR, #const allowed
ro: doar SUBS PC, LR, #const sunt permise

en: only constant expression allowed
ro: este permisă doar expresia constantă

en: only constant offsets supported in absolute section
ro: doar decalajele constante sunt acceptate în secțiunea absolută

en: only floating point zero is allowed as immediate value
ro: numai zero în virgulă mobilă este permis ca valoare imediată

en: only lo regs allowed with immediate
ro: numai registrele lo sunt permise cu imediate

en: only lower 16-bits of first operand are used
ro: numai cei 16 biți inferiori ai primului operand sunt utilizați

en: only one type should be specified for operand
ro: trebuie specificat un singur tip pentru operand

en: only one version name with `@@@' is allowed for symbol `%s'
ro: doar un nume de versiune cu „@@@” este permis pentru simbolul „%s”

en: only r0 can be used as byte count register
ro: doar r0 poate fi utilizat ca registru de numărare a octeților

en: only r0.bX byte fields of r0 can be used as byte count
ro: numai câmpurile de octeți r0.bX din r0 pot fi utilizate ca număr de octeți

en: only r15 allowed here
ro: doar r15 este permis aici

en: only single block types allowed
ro: sunt permise numai tipuri de blocuri unice

en: only two consecutive VFP SP registers allowed here
ro: doar două registre VFP SP consecutive sunt permise aici

en: opcode %s not found in opcode hash table
ro: codul operațional %s nu a fost găsit în tabelul hash de coduri operaționale

en: opcode '%s' not supported for target %s
ro: codul operațional „%s” nu este acceptat pentru ținta %s

en: opcode '%s': cannot find literal definition
ro: codul operațional „%s”: nu se poate găsi definiția literală

en: opcode '%s': could not parse operand '%s' in '%s'
ro: codul operațional „%s”: nu s-a putut analiza operandul „%s” în „%s”

en: opcode '%s': no bound opname '%s' for precondition in '%s'
ro: codul operațional „%s”: niciun nume de operație legat „%s” pentru precondiția din „%s

en: opcode '%s': precondition only contains constants in '%s'
ro: codul operațional „%s”: precondiția conține numai constante în „%s”

en: opcode '%s': replacement does not have %d op | opcode '%s': replacement does not have %d ops
ro[0]: codul operațional „%s”: înlocuirea nu are %d operație
ro[1]: codul operațional „%s”: înlocuirea nu are %d operații
ro[2]: codul operațional „%s”: înlocuirea nu are %d de operații

en: opcode '%s': unidentified operand '%s' in '%s'
ro: codul operațional „%s”: operand neidentificat „%s” în „%s”

en: opcode 'NOP.N' unavailable in this configuration
ro: codul operațional „NOP.N” nu este disponibil în această configurație

en: opcode `%s' not supported for target %s
ro: codul operațional „%s” nu este acceptat pentru ținta %s

en: opcode has no effect
ro: codul operațional nu are niciun efect

en: opcode is not sorted for %s
ro: codul operațional nu este sortat pentru %s

en: opcode missing or not found on input line
ro: codul operațional lipsește sau nu este găsit pe linia de intrare

en: opcode not supported in the `insn32' mode
ro: cod operațional care nu este acceptat în modul „insn32”

en: opcode not supported in the `insn32' mode `%s'
ro: cod operațional neacceptat în modul „insn32” „%s”

en: opcode not supported on this processor: %s (%s)
ro: codul operațional nu este acceptat de acest procesor: %s (%s)

en: opcode not valid for this cpu variant
ro: codul operațional nu este valabil pentru această variantă de cpu

en: opcode residual (%#llx) too wide
ro: cod operațional rezidual (%#llx) prea extins

en: opcode residual (%#lx) too wide
ro: cod operațional rezidual (%#lx) prea extins

en: opcode-specific %s relocation used outside an instruction
ro: realocarea %s specifică codului operațional utilizată în afara unei instrucțiuni

en: opcodes '%s' (slot %d) and '%s' (slot %d) both have volatile port accesses
ro: codurile op „%s” (slot %d) și „%s” (slot %d) au amândouă accesări volatile ale porturilor

en: opcodes '%s' (slot %d) and '%s' (slot %d) write the same port
ro: codurile operaționale „%s” (slot %d) și „%s” (slot %d) scriu același port

en: opcodes '%s' (slot %d) and '%s' (slot %d) write the same register
ro: codurile operaționale „%s” (slot %d) și „%s” (slot %d) scriu același registru

en: opcodes '%s' (slot %d) and '%s' (slot %d) write the same state
ro: codurile operaționale „%s” (slot %d) și „%s” (slot %d) scriu aceeași stare

en: open CFI at the end of file; missing .cfi_endproc directive
ro: CFI deschis la sfârșitul fișierului; lipsește directiva .cfi_endproc

en: operand %d must be %s -- `%s'
ro: operandul %d trebuie să fie %s -- „%s”

en: operand %d must be an immediate
ro: operandul %d trebuie să fie o imediată

en: operand %d must be an immediate expression
ro: operandul %d trebuie să fie o expresie imediată

en: operand %d must be constant
ro: operandul %d trebuie să fie o constantă

en: operand %d must be scalar
ro: operandul %d trebuie să fie scalar

en: operand %d must be the same register as operand 1 -- `%s'
ro: operandul %d trebuie să fie același registru ca și operandul 1 -- „%s”

en: operand %d must have a vector group size of %d -- `%s'
ro: operandul %d trebuie să aibă o dimensiune a grupului vectorial de %d -- „%s”

en: operand %d must have the same immediate value as operand 1 -- `%s'
ro: operandul %d trebuie să aibă aceeași valoare imediată ca și operandul 1 -- „%s”

en: operand %d of '%s' has invalid value '%u'
ro: operandul %d din „%s” are valoarea nevalidă „%u”

en: operand %d of '%s' has out of range value '%u'
ro: operandul %d din „%s” are valoarea „%u” în afara intervalului

en: operand %d out of range
ro: operand %d în afara intervalului

en: operand %d overlap in %s
ro: operandul %d se suprapune în %s

en: operand %d: base register specified but zero
ro: operand %d: registru de bază specificat, dar este zero

en: operand %d: expected %s name
ro: operand %d: se aștepta numele %s

en: operand %d: expected %s name as base register
ro: operand %d: se aștepta numele %s ca registru de bază

en: operand %d: expected %s name as index register
ro: operand %d: se aștepta numele %s ca registru index

en: operand %d: illegal operand
ro: operand %d: operand ilegal

en: operand %d: illegal use expression: `%s`
ro: operand %d: expresie de utilizare ilegală: `%s`

en: operand %d: index register specified but zero
ro: operand %d: registru index specificat, dar este zero

en: operand %d: invalid floating-point register (FPR) pair (valid FPR pair operands are 0, 1, 4, 5, 8, 9, 12 or 13)
ro: operand %d: pereche nevalidă de registre în virgulă mobilă (FPR) (operanzii perechi FPR valide sunt 0, 1, 4, 5, 8, 9, 12 sau 13)

en: operand %d: invalid length field specified
ro: operand %d: câmp de lungime nevalidă specificat

en: operand %d: invalid operand suffix
ro: operand %d: sufix de operand nevalid

en: operand %d: missing %s operand
ro: operand %d: lipsește operandul %s

en: operand %d: odd numbered general purpose register specified as register pair
ro: operand %d: registru de uz general cu număr impar specificat ca pereche de registre

en: operand %d: operand out of range (%ld is not between %ld and %ld)
ro: operand %d: operand în afara intervalului (%ld nu este între %ld și %ld)

en: operand %d: operand out of range (%lld is not between %lld and %lld)
ro: operand %d: operand în afara intervalului (%lld nu este între %lld și %lld)

en: operand %d: syntax error; '%c' not allowed here
ro: operand %d: eroare de sintaxă; „%c” nu este permis aici

en: operand %d: syntax error; expected ','
ro: operand %d: eroare de sintaxă; se aștepta „,”

en: operand %d: syntax error; missing '(' after displacement
ro: operand %d: eroare de sintaxă; lipsește „(” după deplasare

en: operand %d: syntax error; missing ')' after base register
ro: operand %d: eroare de sintaxă; lipsește „)” după registrul de bază

en: operand %d: too many fixups
ro: operand %d: prea multe corecții

en: operand %s0x%lx out of range.
ro: operand %s0x%lx în afara intervalului.

en: operand %u `%s%s' implicitly denotes `%s%s' to `%s%s' group in `%s'
ro: operandul %u „%s%s” denotă implicit „%s%s” grupului „%s%s” din „%s”

en: operand %u of '%.*s' is read-only
ro: operandul %u din „%.*s” este numai-pentru-citire

en: operand %u of '%.*s' is write-only
ro: operandul %u din „%.*s” este numai-pentru-scriere

en: operand %u of '%.*s' not a valid base address register
ro: operandul %u din „%.*s” nu este un registru de adresă de bază valid

en: operand %u of '%.*s' not a valid memory reference
ro: operandul %u din „%.*s” nu este o referință de memorie validă

en: operand %u of '%.*s' not a valid return address register
ro: operand %u din „%.*s” nu este un registru de adresă de returnare valid

en: operand %u of '%.*s' not constant
ro: operandul %u din „%.*s” nu este o constantă

en: operand %u of '%.*s' on wrong side
ro: operandul %u din „%.*s” este în partea echivoca tă

en: operand %u of '%.*s' out of range
ro: operand %u din „%.*s” în afara intervalului

en: operand 1 must be FPSCR
ro: operandul 1 trebuie să fie FPSCR

en: operand index error for %s
ro: eroare de index de operand pentru %s

en: operand is not an absolute constant
ro: operandul nu este o constantă absolută

en: operand is not an immediate
ro: operandul nu este o valoare imediată

en: operand is not duplicate of the previous one
ro: operandul nu este un duplicat al celui anterior

en: operand mask overflow
ro: depășirea măștii operandului

en: operand mismatch -- `%s'
ro: nepotrivire de operanzi --„%s”

en: operand must be LR register
ro: operandul trebuie să fie un registru LR

en: operand must be SP register
ro: operandul trebuie să fie un registru SP

en: operand must be a constant
ro: operandul trebuie să fie o constantă

en: operand must be a constant or a label
ro: operandul trebuie să fie o constantă sau o etichetă

en: operand must be a multiple of 2
ro: operandul trebuie să fie un multiplu de 2

en: operand must be a multiple of 4
ro: operandul trebuie să fie un multiplu de 4

en: operand must be absolute in range %lx..%lx, not %lx
ro: operandul trebuie să fie absolut în intervalul %lx..%lx, nu %lx

en: operand must be absolute in range %u..%u, not %ld
ro: operandul trebuie să fie absolut în intervalul %u..%u, nu %ld

en: operand must be r12
ro: operandul trebuie să fie r12

en: operand number mismatch
ro: neconcordanță a numărului de operanzi

en: operand out of range
ro: operand în afara intervalului

en: operand out of range (%d is not between %d and %d)
ro: operand în afara intervalului (%d nu este între %d și %d)

en: operand out of range (%ld is not between %ld and %ld)
ro: operand în afara intervalului (%ld nu este între %ld și %ld)

en: operand out of range (%lld is not between %lld and %lld)
ro: operand în afara intervalului (%lld nu este între %lld și %lld)

en: operand out of range, instruction expanded
ro: operand în afara intervalului, instrucțiune extinsă

en: operand out of range: %ld
ro: operand în afara intervalului: %ld

en: operand out of range: %lu
ro: operand în afara intervalului: %lu

en: operand out of range: 0x%lx
ro: operand în afara intervalului: 0x%lx

en: operand overflow
ro: depășirea operandului

en: operand references R%ld of instruction before previous.
ro: operandul face trimitere la R%ld de la instrucțiunea anterioară celei precedente.

en: operand references R%ld of previous instruction.
ro: operandul face trimitere la R%ld din instrucțiunea anterioară.

en: operand references R%ld of previous load.
ro: operandul face trimitere la R%ld din încărcarea anterioară.

en: operand size mismatch
ro: nepotrivire de dimensiune a operandului

en: operand size must be specified for immediate VMOV
ro: dimensiunea operandului trebuie să fie specificată pentru valoarea imediată VMOV

en: operand size must match register width
ro: dimensiunea operandului trebuie să se potrivească cu lățimea registrului

en: operand type mismatch
ro: nepotrivire de tip de operand

en: operand types can't be inferred
ro: tipurile de operanzi nu pot fi deduse

en: operand value out of range for instruction
ro: valoarea operandului este în afara intervalului pentru instrucțiune

en: operand/size mis-match
ro: nepotrivire operand/dimensiune

en: operands 0 and 1 must be the same register
ro: operanzii 0 și 1 trebuie să fie același registru

en: operands for opcode `%s' do not match any valid format
ro: operanzii pentru codul operațional „%s” nu se potrivesc cu niciun format valid

en: operands mismatch
ro: nepotrivire operanzi

en: operands were not reducible at assembly-time
ro: operanzii nu erau reductibili la asamblare

en: operation combines symbols in different segments
ro: operația combină simboluri din diferite segmente

en: option `%s' may not be negated
ro: opțiunea „%s” nu poate fi negată

en: option `%s' not recognized
ro: opțiunea „%s” nu este recunoscută

en: option `-%c%s' is deprecated: %s
ro: opțiunea „-%c%s” este depreciată: %s

en: option `-A%s' is deprecated: use `-%s'
ro: opțiunea „--A%s” este învechită, folosiți „-%s” în schimb

en: or higher
ro: sau mai mare

en: out of memory
ro: memorie insuficientă

en: out of range
ro: în afara intervalului

en: out of range label-relative fixup value
ro: valoarea de corecție relativă a etichetei în afara intervalului de valori

en: output verbose error messages
ro: afișează mesaje de eroare detaliate

en: overflow
ro: depășire

en: overflow in branch to %s; converted into longer instruction sequence
ro: depășire în ramificarea pentru %s; convertită în secvență de instrucțiuni mai lungă

en: overflow in immediate argument
ro: depășire în argumentul imediat

en: overflow in literal (.lit8) table
ro: depășirea limitei în tabelul literal (.lit8)

en: overflow in literal (.lita) table
ro: depășire în tabelul literal (.lita)

en: p2align not supported on this target
ro: p2align nu este acceptată pe această țintă

en: packing conflict: %s must dispatch sequentially
ro: conflict de împachetare: %s trebuie să expedieze secvențial

en: padding added
ro: umplutură adăugată

en: parallel
ro: paralel

en: parallel instruction not following another instruction
ro: instrucțiunea paralelă nu urmează o altă instrucțiune

en: parentheses ignored
ro: paranteze ignorate

en: parse error
ro: eroare de analizare

en: pc may not be used with write-back
ro: pc nu poate fi utilizat cu scrierea-înapoi

en: pc-relative
ro: relativă la pc

en: pc-relative address offset out of range
ro: decalajul adresei relative la PC este în afara intervalului

en: pc-relative load offset not word aligned
ro: decalajul de încărcare relativă la PC nu este aliniat la cuvânt

en: pc-relative load offset out of range
ro: decalajul de încărcare relativă la PC este în afara intervalului

en: pc-relative offset out of range, shall fit in 16 bits
ro: decalajul pc-relativ în afara intervalului, trebuie să se încadreze în 16 de biți

en: pc-relative offset out of range, shall fit in 32 bits
ro: decalajul pc-relativ în afara intervalului, trebuie să se încadreze în 32 de biți

en: pce instruction error (16 bit || 16 bit).
ro: eroare de instrucțiune pce (16 bit || 16 bit).

en: pcrel for branch to %s too far (0x%lx)
ro: pcrel pentru ramificarea la %s este prea departe (0x%lx)

en: pcrel for branch to %s too far (0x%x)
ro: pcrel pentru ramificarea la %s prea departe (0x%x)

en: pcrel for loopt too far (0x%lx)
ro: pcrel pentru loopt este prea departe (0x%lx)

en: pcrel for lrw/jmpi/jsri to %s too far (0x%lx)
ro: pcrel pentru lrw/jmpi/jsr la %s este prea departe (0x%lx)

en: pcrel offset for branch to %s too far (0x%lx)
ro: decalajul pcrel pentru ramificarea la %s prea departe (0x%lx)

en: pcrel relocation not allowed in an instruction
ro: realocarea pcrel nu este permisă într-o instrucțiune

en: pcrel too far
ro: pcrel prea departe

en: pcrel too far BFD_RELOC_BFIN_10
ro: pcrel prea departe de BFD_RELOC_BFIN_10

en: pcrel too far BFD_RELOC_BFIN_11_PCREL
ro: pcrel prea departe de BFD_RELOC_BFIN_11_PCREL

en: pcrel too far BFD_RELOC_BFIN_12
ro: pcrel prea departe de BFD_RELOC_BFIN_12

en: pcrel too far BFD_RELOC_BFIN_24
ro: pcrel prea departe de BFD_RELOC_BFIN_24

en: pcrel too far BFD_RELOC_BFIN_5
ro: pcrel prea departe de BFD_RELOC_BFIN_5

en: pcrel too far BFD_RELOC_MOXIE_10
ro: pcrel prea departe de BFD_RELOC_MOXIE_10

en: personality routine required before .handlerdata directive
ro: rutină de personalitate necesară înainte de directiva .handlerdata

en: personality routine specified for cantunwind frame
ro: rutină de personalitate specificată pentru cadrul cantunwind

en: pointer register (X, Y or Z) required
ro: registru indicator (X, Y sau Z) este necesar

en: pointer register (Y or Z) required
ro: registru indicator (Y sau Z) este necesar

en: pointer register Z required
ro: registru indicator Z este necesar

en: polymorphs are not enabled. Use -mP option to enable.
ro: polimorfii nu sunt activați. Utilizați opțiunea „-mP” pentru a-i activa.

en: post-index must be a register
ro: post-index trebuie să fie un registru

en: post-indexed expression used in preload instruction
ro: expresie post-indexată utilizată în instrucțiunea de preîncărcare

en: postincrement not supported
ro: post-incrementarea nu este admisă

en: powerpc_operands[%d] duplicates powerpc_operands[%d]
ro: powerpc_operands[%d] duplică powerpc_operands[%d]

en: powerpc_operands[%d].bitm invalid
ro: powerpc_operands[%d].bitm nu este valid

en: pre-indexed expression expected
ro: se aștepta o expresie preindexată

en: predicate not followed by instruction
ro: predicatul nu este urmat de o instrucțiune

en: predication on A0 not supported on this architecture
ro: predicarea pe A0 nu este acceptată pe această arhitectură

en: prefer-const16 conflicts with prefer-l32r
ro: prefer-const16 intră în conflict cu prefer-l32r

en: prefer-l32r conflicts with prefer-const16
ro: prefer-l32r intră în conflict cu prefer-const16

en: premature end of floating point prefix
ro: sfârșit prematur al prefixului în virgulă mobilă

en: previous .ent not closed by a .end
ro: directiva .ent precedentă nu este închisă printr-o directivă .end

en: previous CFI entry not closed (missing .cfi_endproc)
ro: intrarea CFI anterioară nu a fost închisă (lipsește .cfi_endproc)

en: previous `%s' sequence has not been closed
ro: secvența precedentă „%s” nu a fost închisă

en: previous movx requires nopy
ro: movx precedent necesită nopy

en: previous movy requires nopx
ro: movy precedent necesită nopx

en: privileged elf attributes must set before any instructions
ro: atributele elf privilegiate trebuie definite înainte de orice instrucțiuni

en: profiling in absolute section?
ro: profilare în secțiunea absolută?

en: pseudo instruction `%s' not supported
ro: pseudo-instrucțiunea „%s” nu este acceptată

en: pseudo prefix ahead of label; ignoring
ro: pseudo-prefix înaintea etichetei; se ignoră

en: pseudo prefix without instruction
ro: pseudoprefix fără instrucțiune

en: pseudo-op illegal within .struct/.union
ro: pseudo-op ilegal în cadrul .struct/.union

en: pseudo-prefix conflicts with encoding specifier
ro: pseudo-prefixul intră în conflict cu specificatorul de codificare

en: push/pop do not support {reglist}^
ro: push/pop nu acceptă {reglist}^

en: qualifying predicate not followed by instruction
ro: predicatul calificativ nu este urmat de o instrucțiune

en: quick branch offset %d out of range %d to %d
ro: decalajul ramurii rapide %d în afara intervalului %d - %d

en: r0-r12, lr or APSR expected
ro: se aștepta r0-r12, lr sau APSR

en: r12 not allowed here
ro: r12 nu este permis aici

en: r13 not allowed here
ro: r13 nu este permis aici

en: r14 not allowed as first register when second register is omitted
ro: r14 nu este permis ca prim registru atunci când al doilea registru este omis

en: r14 not allowed here
ro: r14 nu este permis aici

en: r15 based store not allowed
ro: stocarea bazată pe r15 nu este permisă

en: r15 not allowed here
ro: r15 nu este permis aici

en: r2 should not be used in indexed addressing mode
ro: r2 nu trebuie utilizat în modul de adresare indexată

en: rd must be even number.
ro: rd trebuie să fie un număr par.

en: rdhi and rdlo must be different
ro: rdhi și rdlo trebuie să fie diferite

en: rdhi, rdlo and rm must all be different
ro: rdhi, rdlo și rm trebuie să fie diferite

en: re-entrant code
ro: cod reentrant

en: read-only CSR is written `%s'
ro: CSR numai-pentru-citire este scris „%s”

en: record type is not valid
ro: tipul înregistrării nu este valid

en: record_type_not_valid
ro: tip_de_înregistrare_nevalid

en: redefined symbol cannot be used on reloc
ro: simbolul redefinit nu poate fi utilizat la realocare

en: redefinition of global register
ro: redefinirea registrului global

en: redefinition of mcu type `%s' to `%s'
ro: redefinirea tipului mcu „%s” la „%s”

en: redundant %s prefix
ro: prefix %s redundant

en: reg should <= 31
ro: reg ar trebui să fie <= 31

en: reg-reg expected
ro: se aștepta reg-reg

en: register '%s%s' cannot be used here
ro: registrul „%s%s” nu poate fi folosit aici

en: register alias %s is deprecated, use %s instead
ro: registrul alias %s este depreciat, utilizați %s în schimb

en: register expected
ro: se aștepta un registru

en: register expected, but saw '%.6s'
ro: se aștepta registru, dar a apărut „%.6s”

en: register expected, not '%.100s'
ro: se aștepta un registru, nu „%.100s”

en: register is out of order
ro: registrul nu este în ordine

en: register is wrong size for a word %s
ro: registrul are dimensiunea greșită pentru un cuvânt %s

en: register is wrong size for address %s
ro: registrul are dimensiunea greșită pentru adresa %s

en: register list must be even numbered
ro: lista de registre trebuie să fie numerotată par

en: register list must be from the same unit
ro: lista de registre trebuie să provină de la aceeași unitate

en: register list must contain at least 1 and at most 16 registers
ro: lista de registre trebuie să conțină cel puțin 1 și cel mult 16 registre

en: register list must contain at least 1 and at most 32 registers
ro: lista de registre trebuie să conțină cel puțin 1 și cel mult 32 registre

en: register list must not contain duplicates
ro: lista de registre nu trebuie să conțină duplicate

en: register list not in ascending order
ro: lista de registre nu este în ordine crescătoare

en: register must be either sp or set by a previousunwind_movsp directive
ro: registrul trebuie să fie, fie sp sau să fie definit de o directivă previousunwind_movsp

en: register name or number from 0 to 31 required
ro: este necesar un nume de registru sau un număr de la 0 la 31

en: register name or number from 16 to 31 required
ro: este necesar un nume de registru sau un număr de la 16 la 31

en: register number %u not supported on this architecture
ro: numărul de registru %u nu este acceptat pe această arhitectură

en: register number above 15 required
ro: un număr de registru mai mare de 15 este necesar

en: register number out of range
ro: număr de registru în afara intervalului

en: register number too large for push/pop
ro: numărul registrului este prea mare pentru push/pop

en: register offset not allowed in pre-indexed addressing mode
ro: decalajul registrului nu este permis în modul de adresare pre-indexat

en: register operand expected, but got scalar
ro: se aștepta un operand registru, dar s-a primit un operand scalar

en: register out of range in list
ro: registru în afara intervalului din listă

en: register pair for operand %u of '%.*s' not a valid even/odd pair
ro: perechea de registre pentru operandul %u din „%.*s” nu este o pereche par/impar validă

en: register r%d out of range
ro: registru r%d în afara intervalului

en: register r0 cannot be used here
ro: registrul r0 nu poate fi utilizat aici

en: register r16-r23 required
ro: se necesită n registru r16-r23

en: register r24, r26, r28 or r30 required
ro: registrul r24, r26, r28 sau r30 este necesar

en: register range not in ascending order
ro: intervalul de registre nu este în ordine crescătoare

en: register rh%d out of range
ro: registru rh%d în afara intervalului

en: register rl%d out of range
ro: registru rl%d în afara intervalului

en: register rq%d does not exist
ro: registrul rq%d nu există

en: register rq%d out of range
ro: registru rq%d în afara intervalului

en: register rr%d does not exist
ro: registrul rr%d nu există

en: register rr%d out of range
ro: registru rr%d în afara intervalului

en: register same as write-back base
ro: registrul este identic cu baza de scriere-înapoi

en: register save offset not a multiple of %u
ro: decalajul de salvare a registrului nu este un multiplu de %u

en: register scaling is being ignored here
ro: scalarea registrului este ignorată aici

en: register section has contents
ro: secțiunea de registru are conținut

en: register stride must be 1
ro: pasul de înregistrare trebuie să fie 1

en: register stride must be 1 or 2
ro: pasul de înregistrare trebuie să fie 1 sau 2

en: register syntax is .register %%g[2367],{#scratch|symbolname|#ignore}
ro: sintaxa registrului este .register %%g[2367],{#scratch|symbolname|#ignore}

en: register type mismatch
ro: nepotrivire de tip de registru

en: register unit must be one of %s
ro: unitatea de registru trebuie să fie una dintre %s

en: register value used as expression
ro: valoare de registru utilizată ca expresie

en: registers may not be the same
ro: registrele nu pot fi aceleași

en: rel too far BFD_RELOC_16
ro: rel prea departe de BFD_RELOC_16

en: rel too far BFD_RELOC_8
ro: rel prea departe de BFD_RELOC_8

en: rel31 relocation overflow
ro: depășirea realocării rel31

en: relative address out of range
ro: adresă relativă în afara intervalului

en: relative call out of range
ro: apel relativ în afara intervalului

en: relative jump out of range
ro: salt relativ în afara intervalului

en: relax hint unrecognized instruction: line %d.
ro: instrucțiune nerecunoscută de indiciu de relaxare: linia %d.

en: relaxable branches not supported in absolute section
ro: ramificările relaxabile nu sunt acceptate în secțiunea absolută

en: relaxation not supported
ro: relaxarea nu este acceptată

en: relaxed out-of-range branch into a jump
ro: ramificare relaxată în afara intervalului într-un salt

en: reloc %d not supported by object file format
ro: realocarea %d nu este acceptată de formatul de fișier obiect

en: reloc not within (fixed part of) section
ro: realocarea nu se află în (parte fixă din) secțiune

en: relocated field and relocation type differ in signedness
ro: câmpul realocat și tipul de realocare diferă în ceea ce privește semnul

en: relocation %s isn't supported by the current ABI
ro: realocarea %s nu este acceptată de ABI-ul curent

en: relocation cannot be done when using -mrelocatable
ro: realocarea nu poate fi făcută atunci când se utilizează „-mrelocatable”

en: relocation is not supported
ro: realocarea nu este acceptată

en: relocation not allowed
ro: realocarea nu este permisă

en: relocation not applicable
ro: realocarea nu este aplicabilă

en: relocation out of range
ro: realocare în afara intervalului

en: relocation overflow
ro: debordare de realocare

en: relocation qualifier does not match instruction size
ro: calificativul de realocare nu se potrivește cu dimensiunea instrucțiunii

en: relocation valid in thumb1 code only
ro: realocarea este validă numai în codul thumb1

en: repeat < 0; .fill ignored
ro: repetare < 0; .fill este ignorată

en: repeat count cannot be used with %s
ro: numărul de repetări nu poate fi utilizat cu %s

en: repeat instruction used with non-register mode instruction
ro: instrucțiune de repetare utilizată cu o instrucțiune în mod non-registru

en: replacing `rep'/`repe' prefix by `bnd'
ro: se înlocuiește prefixul „rep”/“repe” cu „bnd”

en: require imm low %d bit is 0.
ro: necesită ca bitul %d scăzut imm să fie 0.

en: required displacement wasn't given in indirect reference
ro: deplasarea necesară nu a fost indicată în referința indirectă

en: residual low bits in pmem diff relocation
ro: biți inferiori reziduali în realocarea diferențială pmem

en: resource conflict (A%d)
ro: conflict de resursă (A%d)

en: resource conflict (C flag)
ro: conflict de resursă (fanion C)

en: resource conflict (F flag)
ro: conflict de resursă (fanion F)

en: resource conflict (PSW)
ro: conflict de resursă (PSW)

en: resource conflict (R%d)
ro: conflict de resursă (R%d)

en: rest of line ignored; first ignored character is `%c'
ro: restul liniei este ignorat; primul caracter ignorat este „%c”

en: restore without save
ro: restaurare fără salvare

en: return column number %d overflows in CIE version 1
ro: numărul coloanei de retur %d este depășit în versiunea CIE 1

en: returned from mips_ip(%s) insn_opcode = 0x%x
ro: returnat de mips_ip(%s) insn_opcode = 0x%x

en: rex2 pseudo prefix cannot be used
ro: pseudoprefixul rex2 nu poate fi utilizat

en: right operand is a bignum; integer 0 assumed
ro: operandul drept este un număr mare (bignum); se presupune un număr întreg 0

en: right operand is a float; integer 0 assumed
ro: operandul drept este un număr în virgulă mobilă; se presupune un număr întreg 0

en: ror #imm not supported
ro: ror #imm nu este acceptat

en: rotation can only be 0, 8, 16, or 24
ro: rotația poate fi doar 0, 8, 16 sau 24

en: rounding down first operand float to signed int
ro: se rotunjește în jos primul operand în virgulă mobilă la număr întreg cu semn

en: rounding down first operand float to unsigned int
ro: se rotunjește în jos primul operand în virgulă mobilă la număr întreg fără semn

en: rva without symbol
ro: rva fără simboluri

en: s suffix on comparison instruction is deprecated
ro: sufixul s pe instrucțiunea de comparație este depreciat

en: s3_PIC code offset overflow (max 16 signed bits)
ro: depășirea decalajului codului s3_PIC (max 16 biți cu semn)

en: same oszc flag used twice
ro: același fanion oszc folosit de două ori

en: same type of prefix used twice
ro: același tip de prefix folosit de două ori

en: scalar fp16 instruction cannot be conditional, the behaviour is UNPREDICTABLE
ro: instrucțiunea scalară fp16 nu poate fi condițională, comportamentul este IMPREDICTIBIL

en: scalar index must be constant
ro: indexul scalar trebuie să fie constant

en: scalar index out of range
ro: index scalar în afara intervalului

en: scalar must have an index
ro: scalarul trebuie să aibă un index

en: scalar out of range
ro: scalar în afara intervalului

en: scalar out of range for multiply instruction
ro: scalar în afara intervalului pentru instrucțiunea de multiplicare

en: scale factor invalid on this architecture; needs cpu32 or 68020 or higher
ro: factor de scalare nevalid pe această arhitectură; necesită cpu32 sau 68020 sau o versiune superioară

en: scale factor of %d without an index register
ro: factor de scară de %d fără un registru de indexare

en: score3d instruction.
ro: instrucțiune score3d.

en: sdaoff() relocation used on an instruction which does not support it
ro: realocarea sdaoff() utilizată pe o instrucțiune care nu o acceptă

en: second
ro: al doilea

en: second .ent directive found before .end directive
ro: a doua directivă .ent găsită înainte de directiva .end

en: second operand missing
ro: al doilea operand lipsește

en: second operand must be 1
ro: al doilea operand trebuie să fie 1

en: second operand must be 4
ro: al doilea operand trebuie să fie 4

en: second operand of .insn not a constant
ro: al doilea operand al .insn nu este o constantă

en: second register should be greater than first register
ro: al doilea registru trebuie să fie mai mare decât primul registru

en: second register should follow dash in register list
ro: al doilea registru trebuie să fie după liniuță în lista de registre

en: section
ro: secțiune

en: section %s already has a group (%s)
ro: secțiunea %s are deja un grup (%s)

en: section %s renamed multiple times
ro: secțiunea %s redenumită de mai multe ori

en: section '%s' finished with an open IT block.
ro: secțiunea „%s” s-a terminat cu un bloc IT deschis.

en: section '%s' finished with an open VPT/VPST block.
ro: secțiunea „%s” s-a terminat cu un bloc VPT/VPST deschis.

en: section `%s' aliased to `%s' is not used
ro: secțiuneal „%s” ce are ca alias „%s” nu este utilizată

en: section alignment must be >= 4 bytes to check MULS/MULU safeness
ro: alinierea secțiunii trebuie să fie >= 4 octeți pentru a verifica siguranța MULS/MULU

en: section change from within a BSPEC/ESPEC pair is not supported
ro: schimbarea secțiunii din cadrul unei perechi BSPEC/ESPEC nu este acceptată

en: section does not have enough alignment to ensure safe PC-relative loads
ro: secțiunea nu are o aliniere suficientă pentru a asigura încărcări sigure relative la PC

en: section name '%s' already defined as another symbol
ro: numele secțiunii „%s” a fost deja definit ca un alt simbol

en: seek to end of .incbin file failed `%s'
ro: căutarea la sfârșitul fișierului .incbin a eșuat „%s”

en: segment override on `%s' is ineffectual
ro: înlocuirea segmentului pe „%s” este ineficientă

en: selected FPU does not support instruction
ro: FPU selectat nu acceptă instrucțiunea

en: selected architecture does not support wide conditional branch instruction
ro: arhitectura selectată nu acceptă instrucțiunea de ramificare condițională largă

en: selected processor does not have all features of selected architecture
ro: procesorul selectat nu are toate caracteristicile arhitecturii selectate

en: selected processor does not support 'A' form of this instruction
ro: procesorul selectat nu acceptă forma „A” a acestei instrucțiuni

en: selected processor does not support 32bit wide variant of instruction `%s'
ro: procesorul selectat nu acceptă varianta pe 32 de biți a instrucțiunii „%s”

en: selected processor does not support ARM opcodes
ro: procesorul selectat nu acceptă codurile operaționale ARM

en: selected processor does not support DSP extension
ro: procesorul selectat nu acceptă extensia DSP

en: selected processor does not support PACBTI extention
ro: procesorul selectat nu acceptă extensia PACBTI

en: selected processor does not support PSTATE field name '%s'
ro: procesorul selectat nu acceptă numele câmpului PSTATE „%s”

en: selected processor does not support SETPAN instruction
ro: procesorul selectat nu acceptă instrucțiunea SETPAN

en: selected processor does not support THUMB opcodes
ro: procesorul selectat nu acceptă codurile operaționale THUMB

en: selected processor does not support `%s'
ro: procesorul selectat nu acceptă „%s”

en: selected processor does not support `%s' in ARM mode
ro: procesorul selectat nu acceptă „%s” în modul ARM

en: selected processor does not support `%s' in Thumb mode
ro: procesorul selectat nu acceptă „%s” în modul Thumb

en: selected processor does not support `%s' in Thumb-2 mode
ro: procesorul selectat nu acceptă „%s” în modul Thumb-2

en: selected processor does not support bf16 instruction
ro: procesorul selectat nu acceptă instrucțiunea bf16

en: selected processor does not support cde instruction
ro: procesorul selectat nu acceptă instrucțiunea cde

en: selected processor does not support fp16 instruction
ro: procesorul selectat nu acceptă instrucțiunea fp16

en: selected processor does not support instruction
ro: procesorul selectat nu acceptă instrucțiunea

en: selected processor does not support requested special purpose register
ro: procesorul selectat nu acceptă registrul cu scop special solicitat

en: selected processor does not support system register name '%s'
ro: procesorul selectat nu acceptă numele registrului de sistem „%s”

en: selected target format '%s' unknown
ro: format de țintă selectat „%s” necunoscut

en: sequence number in use for !tlsgd!%ld
ro: număr de secvență în uz pentru !tlsgd!%ld

en: sequence number in use for !tlsldm!%ld
ro: număr de secvență în uz pentru !tlsldm!%ld

en: sequential
ro: secvențial

en: set can only use RD port as source
ro: setul poate utiliza numai portul RD ca sursă

en: set: number not in -2147483648..4294967295 range
ro: set: numărul nu se află în intervalul -2147483648..4294967295

en: set: number not in 0..4294967295 range
ro: set: numărul nu se află în intervalul 0..4294967295

en: setend use is deprecated for ARMv8
ro: utilizarea setend este depreciată pentru ARMv8

en: setsw: number not in -2147483648..4294967295 range
ro: setsw: numărul nu se află în intervalul -2147483648..4294967295

en: setting incorrect section attributes for %s
ro: stabilirea unor atribute de secțiune incorecte pentru %s

en: setting incorrect section type for %s
ro: definirea unui tip de secțiune incorect pentru %s

en: setx: illegal temporary register g0
ro: setx: registru temporar ilegal g0

en: setx: temporary register same as destination register
ro: setx: registru temporar identic cu registrul de destinație

en: shift amount out of range 0 to 63
ro: valoare de deplasare în afara intervalului de la 0 la 63

en: shift by register not allowed in thumb mode
ro: deplasarea prin registru nu este permisă în modul thumb

en: shift count
ro: contor deplasare(shift)

en: shift expression expected
ro: se aștepta expresia de deplasare

en: shift expression is too large
ro: expresia de deplasare este prea mare

en: shift immediate must be 1, 2 or 3 for half-word, word or double-word accesses respectively
ro: deplasarea imediată trebuie să fie 1, 2 sau 3 pentru accesarea unei jumătăți de cuvânt, a unui cuvânt sau, respectiv, a unui cuvânt dublu

en: shift must be constant
ro: deplasarea trebuie să fie constantă

en: shift not allowed for bitmask immediate
ro: deplasarea nu este permisă pentru masca de biți imediată

en: shift operator expected
ro: se aștepta operatorul de deplasare

en: shift out of range
ro: deplasare în afara intervalului

en: shift value over 3 not allowed in thumb mode
ro: valoarea de deplasare peste 3 nu este permisă în modul thumb

en: shifts in CMP/MOV instructions are only supported in unified syntax
ro: deplasările din instrucțiunile CMP/MOV sunt acceptate numai în sintaxa unificată

en: short branch with zero offset: use :w
ro: ramură scurtă cu decalaj zero: utilizați :w

en: shortcut designator invalid
ro: designator de prescurtare nevalid

en: signed .word overflow; switch may be too large; %ld at 0x%lx
ro: depășirea .word cu semn; comutatorul poate fi prea mare; %ld la 0x%lx

en: signed instruction operand out of range, shall fit in 32 bits
ro: operandul instrucțiunii cu semn este în afara limitelor, trebuie să se încadreze în 32 de biți

en: signed number
ro: număr cu semn

en: signed value out of range
ro: valoare cu semn în afara intervalului

en: signed16 PCREL value out of range
ro: valoarea PCREL signed16 este în afara intervalului

en: signed37 PCREL value out of range
ro: valoarea PCREL signed37 este în afara intervalului

en: signed43 PCREL value out of range
ro: valoarea PCREL signed43 este în afara intervalului

en: simd instructions operate on pair values (L prefix)
ro: instrucțiunile simd operează pe valori pereche (prefix L)

en: single instruction is %u bytes long, but .bundle_align_mode limit is %u bytes
ro: instrucțiunea .single are o lungime de %u octeți, dar limita .bundle_align_mode este de %u octeți

en: size (%ld) out of range, ignored
ro: dimensiune (%ld) în afara intervalului, se ignoră

en: size is not 4 or 6
ro: dimensiunea nu este 4 sau 6

en: size negative; .fill ignored
ro: dimensiune negativă: .fill este ignorată

en: size of "%s" is already %ld; not changing to %ld
ro: dimensiunea lui „%s” este deja %ld; nu se schimbă în %ld

en: size override not allowed with `%s'
ro: depășirea dimensiunii nu este permisă cu „%s”

en: size value for space directive too large: %lx
ro: valoarea dimensiunii pentru directiva spațiu este prea mare: %lx

en: skip (%ld) or count (%ld) invalid for file size (%ld)
ro: omiterea (%ld) sau numărul(%ld) nu sunt valabile pentru dimensiunea fișierului (%ld)

en: skipping SFrame FDE; %s register %u in .cfi_register
ro: se omite SFrame FDE; registru %s %u în .cfi_register

en: skipping SFrame FDE; %s register %u in .cfi_val_offset
ro: se omite SFrame FDE; registru %s %u în .cfi_val_offset

en: skipping SFrame FDE; .cfi_def_cfa_offset without CFA base register in effect
ro: se omite SFrame FDE; .cfi_def_cfa_offset fără registrul de bază CFA în vigoare

en: skipping SFrame FDE; .cfi_negate_ra_state_with_pc
ro: se omite SFrame FDE; .cfi_negate_ra_state_with_pc

en: skipping SFrame FDE; .cfi_remember_state without prior SFrame FRE state
ro: se omite SFrame FDE; .cfi_remember_state fără starea SFrame FRE anterioară

en: skipping SFrame FDE; .cfi_window_save
ro: se omite SFrame FDE;.cfi_window_save

en: skipping SFrame FDE; CFI insn %s (%#x)
ro: se omite SFrame FDE; instrucțiunea CFI %s (%#x)

en: skipping SFrame FDE; FP without RA on stack
ro: se omite SFrame FDE; FP fără RA în stivă

en: skipping SFrame FDE; non-SP/FP register %u in .cfi_def_cfa
ro: se omite SFrame FDE; registru %u non-SP/FP în .cfi_def_cfa

en: skipping SFrame FDE; non-SP/FP register %u in .cfi_def_cfa_register
ro: se omite SFrame FDE; registru %u non-SP/FP în .cfi_def_cfa_register

en: skipping SFrame FDE; non-default RA register %u
ro: se omite SFrame FDE; registru RA neimplicit %u

en: skipping prefixes on `%s'
ro: se omit prefixele pentru „%s”

en: skipping two-word instruction
ro: sărind peste instrucțiunea de două cuvinte

en: smi pseudo instruction should not use a label in imm field
ro: pseudo instrucțiunea smi nu trebuie să utilizeze o etichetă în câmpul imm

en: some symbol undefined; zero assumed
ro: unele simboluri sunt nedefinite; se presupune zero

en: source
ro: sursa

en: source and address units must not be shared for this addressing mode
ro: unitățile sursă și adresă nu trebuie să fie partajate pentru acest mod de adresare

en: source and destination increment mode must agree
ro: modul de incrementare al sursei și al destinației trebuie să coincidă

en: source and destination must be different
ro: sursa și destinația trebuie să fie diferite

en: source and destination register must be in different units
ro: registrul sursă și registrul destinație trebuie să fie în unități diferite

en: source operand must be 16bit absolute address
ro: operandul sursă trebuie să fie o adresă absolută pe 16 biți

en: source operand must be 8 bit register
ro: operandul sursă trebuie să fie un registru pe 8 biți

en: source register must be in the trigger unit
ro: registrul sursă trebuie să fie în unitatea de declanșare

en: source register must be r1
ro: registrul sursă trebuie să fie r1

en: source register same as write-back base
ro: registrul sursă este identic cu baza de scriere-înapoi

en: source register should be even numbered
ro: registrul sursă trebuie să fie numerotat par

en: source registers should be even numbered
ro: registrele sursă trebuie să fie numerotate par

en: source1 and dest must be same register
ro: sursa1 și destinația trebuie să fie același registru

en: space allocation too complex in absolute section
ro: alocarea spațiului este prea complexă în secțiunea absolută

en: space allocation too complex in common section
ro: alocarea spațiului este prea complexă în secțiunea comună

en: special left instruction `%s' kills instruction `%s' in right container
ro: instrucțiunea specială din stânga „%s” omoară instrucțiunea „%s” din containerul din dreapta

en: specified location wasn't TETRA-aligned
ro: locația specificată nu era aliniată TETRA

en: spill_mask record unimplemented.
ro: înregistrare spill_mask neimplementată.

en: spurious operands; (%d operands/instruction max)
ro: operanzi nepotriviți; (%d operanzi/instrucțiune max)

en: st/ld offset 23 instruction was disabled .
ro: instrucțiunea st/ld offset 23 a fost dezactivată .

en: stack frame layout does not match personality routine
ro: aspectul cadrului stivei nu corespunde rutinei de personalitate

en: stack frame layout too complex for unwinder
ro: aspectul cadrului stivei este prea complex pentru desfășurător

en: stack increment must be multiple of 4
ro: incrementul stivei trebuie să fie multiplu de 4

en: stack pointer offset too large for personality routine
ro: decalajul indicatorului de stivă este prea mare pentru rutina de personalitate

en: stand-alone `%s' prefix
ro: prefix „%s” independent

en: start address not supported
ro: adresa de început nu este acceptată

en: strange paper height, set to no form
ro: înălțime ciudată a hârtiei, stabilită la niciun format

en: stray `\'
ro: caracter în plus „\”

en: stride must be a multiple of 64; lower 6 bits ignored
ro: pasul (stride) trebuie să fie un multiplu de 64; cei 6 biți inferiori sunt ignorați

en: stride of 2 unavailable when element size is 8
ro: pasul de 2 nu este disponibil atunci când dimensiunea elementului este 8

en: string too big (%lu bytes)
ro: șir prea mare (%lu octeți)

en: strings must be placed into a section
ro: șirurile trebuie să fie plasate într-o secțiune

en: support ARM/Thumb interworking
ro: suport pentru interfuncționarea ARM/Thumb

en: swp{b} use is deprecated for ARMv6 and ARMv7
ro: utilizarea swp{b} este depreciată pentru ARMv6 și ARMv7

en: swp{b} use is obsoleted for ARMv8 and later
ro: utilizarea swp{b} este obsoletă pentru ARMv8 și ulterior

en: symbol "%s" undefined; zero assumed
ro: simbolul „%s” nedefinit; se presupune zero

en: symbol %s is in a different section
ro: simbolul %s se află într-o secțiune diferită

en: symbol %s is weak and may be overridden later
ro: simbolul %s este slab și poate fi înlocuit ulterior

en: symbol '%s' already has its type set
ro: simbolul „%s” are deja tipul stabilit

en: symbol '%s' contains multibyte characters
ro: simbolul „%s” conține caractere multioctet

en: symbol '%s' is already defined
ro: simbolul „%s” este deja definit

en: symbol '%s' with multiple versions cannot be used in relocation
ro: simbolul „%s” cu multiple versiuni nu poate fi utilizat în realocare

en: symbol `%s' aliased to `%s' is not used
ro: simbolul „%s” ce are ca alias „%s” nu este utilizat

en: symbol `%s' already defined
ro: simbolul „%s” este deja definit

en: symbol `%s' can not be both weak and common
ro: simbolul „%s” nu poate fi atât slab, cât și comun

en: symbol `%s' is already defined
ro: simbolul „%s” este deja definit

en: symbol `%s' is already defined as "%s"/%s%ld
ro: simbolul „%s” este deja definit ca „%s”/%s%ld

en: symbol definition loop encountered at `%s'
ro: buclă de definire a simbolului întâlnită la „%s”

en: symbol in .toc does not match any .tc
ro: simbolul din .toc nu corespunde niciunui .tc

en: symbol name not recognised in the current locale
ro: numele simbolului nu este recunoscut în configurația regională curentă

en: symbol size computation overflow
ro: depășirea calculului dimensiunii simbolului

en: symbol too far away
ro: simbol prea îndepărtat

en: symbol type "%s" is not supported by MIPS targets
ro: tipul de simbol „%s” nu este acceptat de țintele MIPS

en: symbol type "%s" is supported only by GNU and FreeBSD targets
ro: tipul de simbol „%s” este acceptat doar de țintele GNU și FreeBSD

en: symbol type "%s" is supported only by GNU targets
ro: tipul de simbol „%s” este acceptat doar de țintele GNU

en: symbol%d
ro: simbol%d

en: symbol+offset@%s means symbol@%s+offset
ro: simbol+decalaj@%s înseamnă simbol@%s+decalaj

en: symbol+offset@%s not supported
ro: simbol+decalaj@%s nu este acceptat

en: symbolic operand not allowed
ro: operand simbolic nepermis

en: symbols assigned with .asg must begin with a letter
ro: simbolurile atribuite cu .asg trebuie să înceapă cu o literă

en: symbols assigned with .eval must begin with a letter
ro: simbolurile atribuite cu .eval trebuie să înceapă cu o literă

en: syntax error
ro: eroare de sintaxă

en: syntax error in .startof. or .sizeof.
ro: eroare de sintaxă în .startof. sau .sizeof.

en: syntax error in @(disp,[Rn, gbr, pc])
ro: eroare de sintaxă în @(disp,[Rn, gbr, pc])

en: syntax error in @(r0,...)
ro: eroare de sintaxă în @(r0,...)

en: syntax error in @(r0...)
ro: eroare de sintaxă în @(r0...)

en: syntax error in register list
ro: eroare de sintaxă în lista de registre

en: syntax error in structured control directive
ro: eroare de sintaxă în directiva de control structurat

en: syntax error: condition code not expected
ro: eroare de sintaxă: nu se aștepta un cod de condiție

en: syntax error: register not expected
ro: eroare de sintaxă: nu se aștepta un registru

en: syntax error: system register not expected
ro: eroare de sintaxă: nu se aștepta un registru de sistem

en: syntax error: value is missing before the register name
ro: eroare de sintaxă: lipsește o valoare înainte de numele registrului

en: syntax error: vector register not expected
ro: eroare de sintaxă: nu se aștepta un registru vectorial

en: syntax error; end of line, expected `%c'
ro: eroare de sintaxă; sfârșit de linie, se aștepta „%c”

en: syntax error; found `%c', expected `%c'
ro: eroare de sintaxă; s-a găsit „%c”, se aștepta „%c”

en: system register name '%s' is deprecated and may be removed in a future release
ro: numele registrului de sistem „%s” este depreciat și poate fi eliminat într-o versiune viitoare

en: system registers cannot be included in list
ro: registrele de sistem nu pot fi incluse în listă

en: tag not found for .tag %s
ro: marcaj negăsit pentru .tag %s

en: target out of range
ro: țintă în afara intervalului

en: tdaoff() relocation used on an instruction which does not support it
ro: realocarea tdaoff() utilizată pe o instrucțiune care nu o acceptă

en: temporary switch for dumping
ro: comutator temporar pentru descărcare

en: text label `%s' aligned to odd boundary
ro: etichetă text „%s” aliniată la limita impară

en: the %d-bit %s architecture does not support the `%s' extension
ro: arhitectura %d-bit %s nu acceptă extensia „%s”

en: the %s name '%s' is too long (maximum 16 characters)
ro: numele %s „%s” este prea lung (maxim 16 caractere)

en: the XCOFF file format does not support arbitrary sections
ro: formatul de fișier XCOFF nu acceptă secțiuni arbitrare

en: the `%s' extension requires %s%d revision %d or greater
ro: extensia „%s” necesită %s%d revizuirea %d sau mai mare

en: the `%s' extension requires 64-bit FPRs
ro: extensia „%s” necesită FPR-uri pe 64 de biți

en: the `%s' extension was removed in %s%d revision %d
ro: extensia „%s” a fost eliminată în %s%d revizuirea %d

en: the architecture string of -march and elf architecture attributes cannot be empty
ro: șirul arhitecturii din atributele de arhitectură „-march” și elf nu poate fi gol

en: the equals character cannot be the second character in a block of four base64 encoded bytes
ro: caracterul egal nu poate fi al doilea caracter dintr-un bloc de patru octeți codificați base64

en: the equals character cannot start a block of four base64 encoded bytes
ro: caracterul egal nu poate începe un bloc de patru octeți codificați base64

en: the first operand must be a symbol
ro: primul operand trebuie să fie un simbol

en: the floating-point format has not been set (or has been disabled)
ro: formatul în virgulă mobilă nu a fost definit (sau a fost dezactivat)

en: the last offset is equal to the first offset
ro: ultimul decalaj este egal cu primul decalaj

en: the last offset is less than the first offset
ro: ultimul decalaj este mai mic decât primul decalaj

en: the number of .indirect_symbols defined in section %s does not match the number expected (%d defined, %d expected)
ro: numărul de .indirect_symbols definite în secțiunea %s nu se potrivește cu numărul așteptat (%d definite, %d așteptate)

en: the offset 0x%08lX is not representable
ro: decalajul 0x%08lX nu este reprezentabil

en: the only valid suffixes here are '(plt)' and '(tlscall)'
ro: singurele sufixe valide aici sunt „(plt)” și „(tlscall)”

en: the optional immediate offset can only be 0
ro: decalajul imediat opțional poate fi doar 0

en: the preceding `%s' should be followed by `%s` rather than `%s` -- `%s'
ro: precedentul „%s” ar trebui să fie urmat de „%s” mai degrabă decât de „%s” -- „%s”

en: the register list must have a stride of %d at operand %d -- `%s'
ro: lista de registre trebuie să aibă un interval de lungime de %d la operandul %d -- „%s”

en: the register list must have a stride of %d or %d at operand %d -- `%s`
ro: lista de registre trebuie să aibă un interval de lungime de %d sau %d la operandul %d -- „%s”

en: the source register must not be $0
ro: registrul sursă nu trebuie să fie $0

en: the source register must not be $31
ro: registrul sursă nu trebuie să fie $31

en: the specified option is not accepted in DSB
ro: opțiunea specificată nu este acceptată în DSB

en: the specified option is not accepted in ISB
ro: opțiunea specificată nu este acceptată în ISB

en: the specified relocation type is not allowed for 32-bit register
ro: tipul de realocare specificat nu este permis pentru un registru pe 32 de biți

en: the specified relocation type is not allowed for MOVK
ro: tipul de realocare specificat nu este permis pentru MOVK

en: the top half of a 128-bit FP/SIMD register is expected
ro: se aștepta jumătatea superioară a unui registru FP/SIMD pe 128 de biți

en: the type of %s is too complex; it will be simplified
ro: tipul de %s este prea complex; acesta va fi simplificat

en: the use of -mvle requires -a32.
ro: utilizarea lui „-mvle” necesită „-a32”.

en: the use of -mvle requires big endian.
ro: utilizarea lui „-mvle” necesită big endian.

en: the yielding instruction %s may not be in a delay slot.
ro: este posibil ca instrucțiunea care generează %s să nu se afle într-un slot de întârziere.

en: there are no pc-relative size relocations
ro: nu există realocări de dimensiuni relative la pc

en: there are no unsigned pc-relative relocations
ro: nu există realocări relative la pc fără semn

en: third
ro: al treilea

en: this `%s' should have an immediately preceding `%s' -- `%s'
ro: acest „%s” ar trebui să aibă un „%s” -- „%s” imediat anterior

en: this `.arch pop' requires `.code%u%s' to be in effect
ro: acest „.arch pop” necesită ca „.code%u%s” să fie în vigoare

en: this addressing mode is not applicable for destination operand
ro: acest mod de adresare nu este aplicabil pentru operandul de destinație

en: this addressing mode requires base-register writeback
ro: acest mod de adresare necesită o scriere-înapoi în registrul de bază

en: this group relocation is not allowed on this instruction
ro: această realocare de grup nu este permisă pentru această instrucțiune

en: this instruction does not accept an accumulator
ro: această instrucțiune nu acceptă un acumulator

en: this instruction does not accept an immediate
ro: această instrucțiune nu acceptă un imediat

en: this instruction implies use of ARMv8.1 AdvSIMD.
ro: această instrucțiune implică utilizarea ARMv8.1 AdvSIMD.

en: this instruction requires a post-indexed address
ro: această instrucțiune necesită o adresă post-indexată

en: this instruction will not write back the base register
ro: această instrucțiune nu va scrie-înapoi în registrul de bază

en: this instruction will write back the base register
ro: această instrucțiune va scrie-înapoi =n registrul de bază

en: this relocation modifier is not allowed on this instruction
ro: acest modificator de realocare nu este permis pentru această instrucțiune

en: this string may not contain '\0'
ro: acest șir nu poate conține „\0”

en: this type of register can't be indexed
ro: acest tip de registru nu poate fi indexat

en: thumb conditional instruction should be in IT block
ro: instrucțiunea condițională thumb trebuie să fie în blocul IT

en: too few operands
ro: prea puțini operanzi

en: too few register/memory operands
ro: prea puțini operanzi de registru/memorie

en: too many !literal!%ld for %s
ro: prea multe !literal!%ld pentru %s

en: too many .dim entries
ro: prea multe intrări .dim

en: too many .size entries
ro: prea multe intrări .size

en: too many GREG registers allocated (max %d)
ro: prea multe registre GREG alocate (maxim %d)

en: too many IVC2 insns to pack together
ro: prea multe instrucțiuni IVC2 pentru a fi împachetate împreună

en: too many IVC2 insns to pack with a 16-bit core insn
ro: prea multe instrucțiuni IVC2 pentru a fi împachetate cu o instrucțiune core pe 16 biți

en: too many IVC2 insns to pack with a 32-bit core insn
ro: prea multe instrucțiuni IVC2 pentru a fi împachetate cu o instrucțiune core pe 32 de biți

en: too many arguments
ro: prea multe argumente

en: too many fixups
ro: prea multe remedieri

en: too many instructions in execute packet
ro: prea multe instrucțiuni în pachetul de execuție

en: too many lda insns for !gpdisp!%ld
ro: prea multe instrucțiuni lda pentru !gpdisp!%ld

en: too many ldah insns for !gpdisp!%ld
ro: prea multe instrucțiuni ldah pentru !gpdisp!%ld

en: too many lituse insns for !lituse_tlsgd!%ld
ro: prea multe instrucțiuni lituse pentru !lituse_tlsgd!%ld

en: too many lituse insns for !lituse_tlsldm!%ld
ro: prea multe instrucțiuni lituse pentru !lituse_tlsldm!%ld

en: too many memory references for `%s'
ro: prea multe referințe de memorie pentru „%s”

en: too many operands
ro: prea mulți operanzi

en: too many operands (%d) for '%s'; expected %d
ro: prea mulți operanzi (%d) pentru „%s”; se așteptau %d

en: too many operands in instruction
ro: prea mulți operanzi: în instrucțiune

en: too many operands to '%.*s'
ro: prea multe operanzi pentru „%.*s”

en: too many pcrel_hi
ro: prea multe pcrel_hi

en: too many positional arguments
ro: prea multe argumente poziționale

en: too many register operands with VSIB
ro: prea mulți operanzi de registru cu VSIB

en: too many register/memory operands
ro: prea mulți operanzi de registru/memorie

en: too many registers in vector register list
ro: prea multe registre în lista de registre vectoriale

en: too many st_End's
ro: prea multe st_End-uri

en: too many unwind opcodes
ro: prea multe coduri operaționale de desfășurare

en: too many unwind opcodes for personality routine 0
ro: prea multe coduri operaționale de desfășurare pentru rutina de personalitate 0

en: too many unwinding instructions
ro: prea multe instrucțiuni de desfășurare

en: trailing garbage after expression: %s
ro: gunoi la sfârșit după expresia: %s

en: translating bgeni to movi
ro: se convertește bgeni în movi

en: translating bmaski to movi
ro: se convertește bmaski în movi

en: translating mgeni to movi
ro: conversia mgeni în movi

en: translating to `%s %s%s'
ro: se traduce în „%s %s%s”

en: translating to `%s %s%s,%s%s'
ro: se traduce în „%s %s%s,%s%s”

en: translating to `%sp'
ro: se traduce în „%sp”

en: trap value %ld is not valid
ro: valoarea de captură %ld nu este validă

en: tried to set unrecognized symbol: %s
ro: s-a încercat definirea unui simbol nerecunoscut: %s

en: truncated file `%s', %ld of %ld bytes read
ro: fișier trunchiat „%s”, %ld din %ld de octeți citiți

en: two dest registers must be distinct
ro: două registre de destinație trebuie să fie distincte

en: type %d reloc done?
ro: tipul %d de realocare a terminat?

en: type mismatch in vector register list
ro: nepotrivire de tip în lista de registre vectoriale

en: type specifier has the wrong number of parts
ro: specificatorul de tip are un număr greșit de părți

en: types specified in both the mnemonic and operands
ro: tipuri specificate atât în mnemonic, cât și în operanzi

en: unable to compute ADRL instructions for PC offset of 0x%lx
ro: nu se pot calcula instrucțiunile ADRL pentru decalajul PC de 0x%lx

en: unable to continue with assembly.
ro: nu se poate continua asamblarea.

en: unable to create reloc for build note
ro: nu se poate crea o realocare pentru nota de construcție

en: unable to generate unwinding opcode for frame pointer offset
ro: nu se poate genera codul operațional de desfășurare pentru decalajul indicatorului de cadru

en: unable to generate unwinding opcode for frame pointer reg %d
ro: nu se poate genera codul operațional de desfășurare pentru registrul indicatorului de cadru %d

en: unable to generate unwinding opcode for reg %d
ro: nu se poate genera codul operațional de desfășurare pentru registrul %d

en: unable to include `%s'
ro: nu se poate include „%s”

en: unable to locate include file: %s
ro: nu se poate localiza fișierul de includere: %s

en: unable to pack %s by itself?
ro: incapabil de a împacheta %s el însuși?

en: unable to rebuffer file: %s
ro: nu se poate reîncărca în memoria tampon fișierul: %s

en: unable to repeat %s insn
ro: nu se poate repeta instrucțiunea %s

en: unable to restore return address from previously restored reg
ro: nu se poate restabili adresa de returnare din registrul restaurat anterior

en: unable to widen instruction
ro: imposibil de a se extinde instrucțiunea

en: unaligned branch target: %d bytes at 0x%lx
ro: ramură țintă nealiniată: %d octeți la 0x%lx

en: unaligned data at an absolute location is not supported
ro: datele nealiniate într-o locație absolută nu sunt acceptate

en: unaligned entry instruction
ro: instrucțiune de intrare nealiniată

en: unaligned loop: %d bytes at 0x%lx
ro: buclă nealiniată: %d octeți la 0x%lx

en: unassigned file number %ld
ro: număr de fișier neatribuit %ld

en: unbalanced double quotes in operand %d.
ro: ghilimele duble fără pereche în operandul %d.

en: unbalanced figure braces
ro: element între acolade fără pereche

en: unbalanced parenthesis in operand %d.
ro: paranteză fără pereche în operandul %d.

en: unclosed '('
ro: „(” neînchisă

en: undecodable fix
ro: remediere ce nu poate fi decodificată

en: undecodable instruction in instruction frag
ro: instrucțiune ce nu poate fi decodificată în fragmentul de instrucțiuni

en: undefined combination of operands
ro: combinație de operanzi nedefinită

en: undefined linked-to symbol `%s' on section `%s'
ro: simbolul linked-to „%s” este nedefinit în secțiunea „%s”

en: undefined local label `%s'
ro: etichetă locală nedefinită „%s”

en: undefined symbol %s in PCR relocation
ro: simbol nedefinit %s în realocarea PCR

en: undefined symbol %s used as an immediate value
ro: simbol nedefinit %s folosit ca valoare imediată

en: undefined symbol for opcode "%s"
ro: simbol nedefinit pentru codul operațional „%s”

en: undocumented instruction
ro: instrucțiune nedocumentată

en: unexpected %s fixup
ro: corecție neașteptată %s

en: unexpected .cantunwind directive
ro: directivă .cantunwind neașteptată

en: unexpected .cfi_inline_lsda
ro: .cfi_inline_lsda neașteptat

en: unexpected .handlerdata directive
ro: directivă .handlerdata neașteptată

en: unexpected .unwind_movsp directive
ro: directivă .unwind_movsp neașteptată

en: unexpected 12-bit reloc type
ro: tip realocare neașteptată pe 12 biți

en: unexpected 18-bit reloc type
ro: tip realocare neașteptată pe 18 biți

en: unexpected PC relative expression
ro: expresie relativă a PC neașteptată

en: unexpected TLS relocation
ro: realocare TLS neașteptată

en: unexpected `"' in expression
ro: ghilimea neașteptată „"” în expresie

en: unexpected addressing mode for %s
ro: mod de adresare neașteptat pentru %s

en: unexpected argument to --multibyte-input-option: '%s'
ro: argument neașteptat pentru opțiunea „--multibyte-input-option”: «%s»

en: unexpected bit specified after APSR
ro: bit neașteptat specificat după APSR

en: unexpected character `%c' in element size
ro: caracter neașteptat „%c” în dimensiunea elementului

en: unexpected character `%c' in predication type
ro: caracter neașteptat „%c” în tipul de predicat

en: unexpected character `%c' in type specifier
ro: caracter neașteptat „%c” în specificatorul de tip

en: unexpected characters following instruction
ro: caractere neașteptate după instrucțiune

en: unexpected comma after the mnemonic name `%s' -- `%s'
ro: virgulă neașteptată după numele mnemonic „%s” -- „%s”

en: unexpected comma before the omitted optional operand
ro: virgulă neașteptată înainte de operandul opțional omis

en: unexpected end of file in irp or irpc
ro: sfârșit neașteptat de fișier în irp sau irpc

en: unexpected end of file in macro `%s' definition
ro: sfârșit neașteptat de fișier în definiția macrocomenzii „%s”

en: unexpected end of line
ro: sfârșit de linie neașteptat

en: unexpected fix
ro: remediere neașteptată

en: unexpected literal (%s)
ro: literal neașteptat (%s)

en: unexpected negative constant
ro: constantă negativă neașteptată

en: unexpected register in the immediate operand
ro: registru neașteptat în operandul direct(immediate)

en: unexpected register name `%s' in expression
ro: nume de registru neașteptat „%s” în expresie

en: unexpected register type at operand %d
ro: tip de registru neașteptat la operandul %d

en: unexpected section size information
ro: informații neașteptate despre dimensiunea secțiunii

en: unexpected shift operator
ro: operator de deplasare neașteptat

en: unexpected storage class %d
ro: clasă de stocare neașteptată %d

en: unexpected type character `b' -- did you mean `bf'?
ro: caracter de tip neașteptat „b” -- ați vrut să spuneți „bf”?

en: unexpected vector group size at operand %d -- `%s'
ro: dimensiune neașteptată a grupului de vectori la operandul %d -- „%s”

en: unhandled %d
ro: negestionat %d

en: unhandled CFA insn for unwinding (%d)
ro: instrucțiune CFA negestionată pentru desfășurare (%d)

en: unhandled local relocation fix %s
ro: remediere a realocării locale negestionate %s

en: unhandled operand code %d
ro: cod operand negestionat %d

en: unhandled reloc %s in md_pcrel_from_section
ro: realocare negestionată %s în md_pcrel_from_section

en: unhandled relocation type %s
ro: tip de realocare negestionat %s

en: unhandled: .proc %s,%d
ro: negestionat: .proc %s,%d

en: unimplemented .nops directive
ro: directivă .nops neimplementată

en: unimplemented opcode "%s"
ro: cod operațional neimplementat „%s”

en: unimplemented relocation suffix
ro: sufix de realocare neimplementat

en: unimplemented segment %s in operand
ro: segment neimplementat %s în operand

en: unindexed addressing used in preload instruction
ro: adresare neindexată utilizată în instrucțiunea de preîncărcare

en: unknown
ro: necunoscut

en: unknown -mpid= argument '%s'
ro: argument necunoscut -mpid= „%s”

en: unknown .gnu_attribute value
ro: valoare .gnu_attribute necunoscută

en: unknown .loc sub-directive `%s'
ro: sub-directivă .loc „%s” necunoscută

en: unknown ABI version`%s'
ro: versiune ABI necunoscută „%s”

en: unknown CSR `%s'
ro: CSR „%s” necunoscut

en: unknown DSP `%s'
ro: DSP „%s” necunoscut

en: unknown DSP prefix character %c %s
ro: caracter de prefix DSP necunoscut %c %s

en: unknown DWARF option %s
ro: opțiune DWARF necunoscută %s

en: unknown EABI `%s'
ro: EABI necunoscută „%s”

en: unknown FPU configuration `%s'
ro: configurație FPU necunoscută „%s”

en: unknown GNU build attribute value '%d' for Tag_GNU_MSP430_Data_Region(%d) in .gnu_attribute directive
ro: valoare necunoscută a atributului de construire GNU „%d” pentru Tag_GNU_MSP430_Data_Region(%d) în directiva .gnu_attribute

en: unknown ISA level %s
ro: nivel ISA necunoscut %s

en: unknown ISA or architecture %s
ro: ISA sau arhitectură necunoscută %s

en: unknown MCU: %s
ro: MCU necunoscut: %s

en: unknown MSPABI build attribute tag '%d' in .mspabi_attribute directive
ro: etichetă a atributului de construire MSPABI necunoscută „%d” în directiva .mspabi_attribute

en: unknown MSPABI build attribute value '%d' for %s(%d) in .mspabi_attribute directive
ro: valoare necunoscută a atributului de construire MSPABI „%d” pentru %s(%d) în directiva .mspabi_attribute

en: unknown MSPABI build attribute value '%d' for OFBA_MSPABI_Tag_ISA(%d) in .mspabi_attribute directive
ro: valoare necunoscută a atributului de construire MSPABI „%d” pentru OFBA_MSPABI_Tag_ISA(%d) în directiva .mspabi_attribute

en: unknown abi `%s'
ro: abi necunoscut „%s”

en: unknown addressing mode %s
ro: mod de adresare necunoscut %s

en: unknown arch name `%s'
ro: nume de arhitectură necunoscut „%s”

en: unknown architectural extension `%s'
ro: extensie arhitecturală necunoscută „%s”

en: unknown architecture
ro: arhitectură necunoscută

en: unknown architecture %s
ro: arhitectură necunoscută „%s”

en: unknown architecture '%s'
ro: arhitectură necunoscută „%s”

en: unknown architecture `%s'
ro: arhitectură necunoscută „%s”

en: unknown architecture `%s'
ro: arhitectură necunoscută „%s”

en: unknown architecture extension `%s'
ro: extensie de arhitectură necunoscută „%s”

en: unknown architecture: %s
ro: arhitectură necunoscută: %s

en: unknown argument for .usepv
ro: argument necunoscut pentru .usepv

en: unknown baseline `%s'
ro: linie de bază (baseline) necunoscută „%s”

en: unknown condition code: %s
ro: cod de condiție necunoscut: %s

en: unknown constraint `%c'
ro: constrângere necunoscută „%c”

en: unknown cpu `%s'
ro: CPU necunoscut „%s”

en: unknown default cpu = %s, os = %s
ro: cpu implicit necunoscut = %s, so = %s

en: unknown default privileged spec `%d.%d.%d' set by privileged elf attributes
ro: specificație privilegiată implicită necunoscută „%d.%d.%d” stabilită de atributele elf privilegiate

en: unknown default privileged spec `%s' set by -mpriv-spec or --with-priv-spec
ro: specificație privilegiată implicită necunoscută „%s” stabilită prin „-mpriv-spec” sau „--with-priv-spec”

en: unknown directive
ro: directivă necunoscută

en: unknown escape
ro: eludare necunoscută

en: unknown escape '\%c' in string; ignored
ro: eludare necunoscută „\%c” în șir; ignorată

en: unknown execution type passed to write_2_short()
ro: tip de execuție necunoscut pasat la write_2_short()

en: unknown expression in operand %s
ro: expresie necunoscută în operand %s

en: unknown expression in operand %s.  Use #llo(), #lhi(), #hlo() or #hhi()
ro: expresie necunoscută în operand %s.  Utilizați #llo(), #lhi(), #hlo() sau #hhi()

en: unknown fixup size
ro: dimensiune de corecție necunoscută

en: unknown floating point abi `%s'
ro: abi în virgulă mobilă necunoscută „%s”

en: unknown floating point format `%s'
ro: format necunoscut în virgulă mobilă „%s”

en: unknown floating point mnemonic: "%s"
ro: mnemonic necunoscut în virgulă mobilă: „%s”

en: unknown floating point prefix character
ro: caracter prefix în virgulă mobilă necunoscut

en: unknown floating type '%c'
ro: tip de virgulă mobilă necunoscut „%c”

en: unknown fpu `%s'
ro: fpu „%s” necunoscut

en: unknown group relocation
ro: realocare de grup necunoscută

en: unknown implicit IT mode `%s', should be arm, thumb, always, or never.
ro: mod IT implicit necunoscut „%s”, trebuie să fie arm, thumb, always, sau never.

en: unknown instruction '%s'
ro: instrucțiune necunoscută „%s”

en: unknown interrupt %s
ro: întrerupere necunoscută %s

en: unknown mnemonic -- `%s'
ro: mnemonic necunoscut -- „%s”

en: unknown mnemonic `%s' -- `%s'
ro: mnemonic necunoscut „%s” -- „%s”

en: unknown mnemonic: "%s"
ro: mnemonic necunoscut: „%s”

en: unknown opcode
ro: cod operațional necunoscut

en: unknown opcode "%s"
ro: cod operațional necunoscut „%s”

en: unknown opcode %s
ro: cod operațional necunoscut %s

en: unknown opcode '%s'
ro: cod operațional necunoscut „%s”

en: unknown opcode `%s'
ro: cod operațional necunoscut „%s”

en: unknown opcode or format name '%s'
ro: cod operațional sau nume de format necunoscut „%s”

en: unknown opcode: %s
ro: cod operațional necunoscut: %s

en: unknown opcode: `%s'
ro: cod operațional necunoscut: „%s”

en: unknown operand %s
ro: operand necunoscut %s

en: unknown operand count
ro: număr necunoscut de operanzi

en: unknown operand shift: %x
ro: operand de deplasare necunoscut: %x

en: unknown operand to .arch
ro: operand necunoscut pentru .arch

en: unknown operator %s. Did you mean X(Rn) or #[hl][hl][oi](CONST) ?
ro: operator necunoscut %s. Ați vrut să spuneți X(Rn) sau #[hl][hl][oi](CONST) ?

en: unknown option `%s'
ro: opțiune necunoscută „%s”

en: unknown or invalid section attribute '%s'
ro: atribut de secțiune necunoscut sau nevalid „%s”

en: unknown or invalid section type '%s'
ro: tip de secțiune necunoscut sau nevalid „%s”

en: unknown or missing PSTATE field name
ro: nume de câmp PSTATE necunoscut sau lipsă

en: unknown or missing operation name
ro: nume de operație necunoscut sau lipsă

en: unknown or missing system register name
ro: nume de registru de sistem necunoscut sau lipsă

en: unknown parameter following .SECTION directive: %s
ro: parametru necunoscut după directiva .SECTION: %s

en: unknown procedure kind
ro: tip de procedură necunoscut

en: unknown profiling flag - ignored.
ro: fanion de profilare necunoscut - se ignoră.

en: unknown pseudo-op: `%s'
ro: pseudo-operator necunoscut: „%s”

en: unknown record type %d (in %s)
ro: tip de înregistrare necunoscut %d (în %s)

en: unknown register %s
ro: registru necunoscut „%s”

en: unknown register '%s' -- .req ignored
ro: registru necunoscut „%s” -- directiva .req este ignorată

en: unknown register `%s'
ro: registru necunoscut „%s”

en: unknown register `%s`
ro: registru necunoscut „%s”

en: unknown register alias '%s'
ro: alias de registru necunoscut „%s”

en: unknown relocation (%u)
ro: realocare necunoscută (%u)

en: unknown relocation modifier
ro: modificator de realocare necunoscut

en: unknown section attribute %s
ro: atribut de secțiune necunoscut %s

en: unknown section attribute '%c'
ro: atribut de secțiune necunoscut „%c”

en: unknown user-defined function %s
ro: funcție necunoscută definită de utilizator %s

en: unknown vector operation: `%s'
ro: operație vectorială necunoscută: „%s”

en: unknown width specifier '.%c'
ro: specificator de lățime necunoscut „.%c”

en: unknown/incorrect operand
ro: operand necunoscut/incorect

en: unmatched '['
ro: „[” fără corespondent

en: unmatched .end directive
ro: directivă .end nepotrivită (fără pereche)

en: unpredictable DCTI couple
ro: cuplu DCTI impredictibil

en: unpredictable load of register pair -- `%s'
ro: încărcare impredictibilă a perechii de registre -- „%s”

en: unpredictable load pair transfer with register overlap -- `%s'
ro: transfer impredictibil al perechii de încărcare cu suprapunere de registre -- „%s”

en: unpredictable transfer with writeback (load) -- `%s'
ro: transfer impredictibil cu scriere-înapoi (încărcare) -- „%s”

en: unpredictable transfer with writeback (store) -- `%s'
ro: transfer impredictibil cu scriere-înapoi (stocare) -- „%s”

en: unpredictable transfer with writeback -- `%s'
ro: transfer impredictibil cu scriere-înapoi -- „%s”

en: unpredictable: identical base and status registers --`%s'
ro: impredictibil: registre de bază și de stare identice -- „%s”

en: unpredictable: identical transfer and status registers --`%s'
ro: impredictibil: registre de transfer și de stare identice --„%s”

en: unrecognised RX CPU type %s
ro: tip CPU RX nerecunoscut %s

en: unrecognised alignment value in .SECTION directive: %s
ro: valoare de aliniere nerecunoscută în directiva .SECTION: %s

en: unrecognised argument to -mcpu option '%s'
ro: argument nerecunoscut pentru opțiunea -mcpu „%s”

en: unrecognised cpu type '%s'
ro: tip de CPU nerecunoscut „%s”

en: unrecognised float16 format "%s"
ro: format float16 nerecunoscut „%s”

en: unrecognised instruction %s
ro: instrucțiune nerecunoscută %s

en: unrecognised instruction size modifier .%c
ro: modificator de dimensiune a instrucțiunii nerecunoscut .%c

en: unrecognized .linkonce type `%s'
ro: tip .linkonce nerecunoscut „%s”

en: unrecognized .option directive: %s
ro: directivă .option nerecunoscută: %s

en: unrecognized .section attribute: want a,e,o,w,x,M,S,G,T or number
ro: atribut .section nerecunoscut: se necesită unul dintre a,e,o,w,x,M,S,G,T sau un număr

en: unrecognized CPS flag
ro: fanion CPS nerecunoscut

en: unrecognized characters at end of parallel processing insn
ro: caractere nerecunoscute la sfârșitul procesării paralele a insn

en: unrecognized default cpu `%s'
ro: cpu implicit nerecunoscut „%s”

en: unrecognized emulation name `%s'
ro: nume de emulare nerecunoscut „%s”

en: unrecognized extended version of MIPS16 opcode
ro: versiune extinsă nerecunoscută a codului operațional MIPS16

en: unrecognized flag
ro: fanion nerecunoscut

en: unrecognized fopt option
ro: opțiune fopt nerecunoscută

en: unrecognized instruction `%s'
ro: instrucțiune nerecunoscută „%s”

en: unrecognized opcode
ro: cod operațional nerecunoscut

en: unrecognized opcode: `%s'
ro: cod operațional nerecunoscut: „%s”

en: unrecognized option "%s"
ro: opțiune nerecunoscută „%s”

en: unrecognized option `-%c%s'
ro: opțiune nerecunoscută „-%c%s”

en: unrecognized option `--%s'
ro: opțiune nerecunoscută „--%s”

en: unrecognized option `--%s=%s'
ro: opțiune nerecunoscută „--%s-%s”

en: unrecognized oszc flags or illegal `,' in pseudo-suffix
ro: fanioane oszc nerecunoscute sau „,” ilegală în pseudo-sufix

en: unrecognized pseudo-suffix
ro: pseudo-sufixe nerecunoscut

en: unrecognized register name `%s'
ro: nume de registru nerecunoscut „%s”

en: unrecognized reloc type
ro: tip de realocare nerecunoscut

en: unrecognized relocation suffix
ro: sufix de realocare nerecunoscut

en: unrecognized section attribute
ro: atribut de secțiune nerecunoscut

en: unrecognized section type
ro: tip de secțiune nerecunoscut

en: unrecognized stab type '%c'
ro: tip de stab nerecunoscut „%c”

en: unrecognized symbol suffix
ro: sufix de simbol nerecunoscut

en: unrecognized symbol type "%s"
ro: tip de simbol nerecunoscut „%s”

en: unrecognized syntax mode "%s"
ro: mod de sintaxă nerecunoscut „%s”

en: unrecognized unextended version of MIPS16 opcode
ro: versiune nerecunoscută și neextinsă a codului operațional MIPS16

en: unrecognized values
ro: valori nerecunoscute

en: unresolvable or nonpositive repeat count; using 1
ro: număr repetat nerezolvabil sau nepozitiv; folosind 1

en: unresolved expression that must be resolved
ro: expresie nerezolvată care trebuie rezolvată

en: unresolved loop target symbol: %s
ro: simbol țintă de buclă nerezolvat: %s

en: unshifted register required
ro: este necesar un registru ne decalat

en: unsigned number
ro: număr fără semn

en: unsigned value out of range
ro: valoare fără semn în afara intervalului

en: unsupported BFD relocation size %d
ro: dimensiune de realocare BFD neacceptată %d

en: unsupported BFD relocation size %u
ro: dimensiune de realocare BFD neacceptată %u

en: unsupported alignment for instruction
ro: aliniere neacceptată pentru instrucțiune

en: unsupported broadcast
ro: difuzare neacceptată

en: unsupported byte value; use a different suffix
ro: valoare de octet neacceptată; utilizați un sufix diferit

en: unsupported constant in relocation
ro: constantă neacceptată în realocare

en: unsupported constant size %d
ro: dimensiune constantă neacceptată %d

en: unsupported fixup size %d
ro: dimensiune de corecție neacceptată %d

en: unsupported flag %i in line directive
ro: opțiune neacceptată „%i” în directiva de linie

en: unsupported fptr fixup
ro: corecție fptr neacceptată

en: unsupported fptr fixup size %d
ro: dimensiune de corecție fptr neacceptată %d

en: unsupported instruction `%s'
ro: instrucțiune neacceptată „%s”

en: unsupported instruction, assembled as NOP
ro: instrucțiune neacceptată, asamblată ca NOP

en: unsupported large constant
ro: constantă mare neacceptată

en: unsupported masking
ro: mascare neacceptată

en: unsupported mbind section info: %s
ro: informații despre secțiunea mbind neacceptate: %s

en: unsupported relocation
ro: realocare neacceptată

en: unsupported relocation against %s
ro: realocare neacceptată față de %s

en: unsupported relocation for DS offset field
ro: realocare nesuportată pentru câmpul de decalaj DS

en: unsupported relocation type
ro: tip de realocare neacceptat

en: unsupported section attribute '%c'
ro: atribut de secțiune neacceptat „%c”

en: unsupported section id: %s
ro: id de secțiune neacceptat: %s

en: unsupported static rounding/sae
ro: rotunjire/sae statică neacceptată

en: unsupported syntax
ro: sintaxă neacceptată

en: unsupported use of %s
ro: utilizare neadmisă a %s

en: unsupported use of .ehword
ro: utilizare neadmisă a .ehword

en: unsupported use of .gpdword
ro: utilizare neadmisă a .gpdword

en: unsupported use of .gpword
ro: utilizarea neadmisă a .gpword

en: unsupported variable nop control in .nops directive
ro: control nop variabil neacceptat în directiva .nops

en: unsupported variable size or fill value
ro: dimensiune variabilă sau valoare de umplere neacceptată

en: unsupported vector index register
ro: registru de indexare vectorială neacceptat

en: unsupported with Intel mnemonic
ro: nu este acceptat cu mnemonicul Intel

en: unterminated string
ro: șir neterminat

en: unterminated string; newline inserted
ro: șir neterminat; linie nouă inserată

en: until without repeat
ro: „until” fără „repeat”

en: untraceable control flow for func '%s'
ro: flux de control imposibil de urmărit pentru funcția „%s”

en: unwind opcode too long
ro: cod operațional de desfășurare prea lung

en: unwound frame has negative size
ro: cadrul desfășurat are o dimensiune negativă

en: unwound stack pointer not doubleword aligned
ro: indicatorul de stivă desfășurat nu este aliniat la cuvinte duble

en: use -march=armv2
ro: utilizează -march=armv2

en: use -march=armv2a
ro: utilizează -march=armv2a

en: use -march=armv3
ro: utilizează -march=armv3

en: use -march=armv3m
ro: utilizează -march=armv3m

en: use -march=armv4
ro: utilizează -march=armv4

en: use -march=armv4t
ro: utilizează -march=armv4t

en: use -march=armv5
ro: utilizează -march=armv5

en: use -march=armv5t
ro: utilizează -march=armv5t

en: use -march=armv5te
ro: utilizează -march=armv5te

en: use -mcpu=all
ro: utilizează -mcpu=all

en: use -mcpu=arm1
ro: utilizează -mcpu=arm1

en: use -mcpu=arm2
ro: utilizează -mcpu=arm2

en: use -mcpu=arm250
ro: utilizează -mcpu=arm250

en: use -mcpu=arm3
ro: utilizează -mcpu=arm3

en: use -mcpu=arm6
ro: utilizează -mcpu=arm6

en: use -mcpu=arm600
ro: utilizează -mcpu=arm600

en: use -mcpu=arm610
ro: utilizează -mcpu=arm610

en: use -mcpu=arm620
ro: utilizează -mcpu=arm620

en: use -mcpu=arm7
ro: utilizează -mcpu=arm7

en: use -mcpu=arm70
ro: utilizează -mcpu=arm70

en: use -mcpu=arm700
ro: utilizează -mcpu=arm700

en: use -mcpu=arm700i
ro: utilizează -mcpu=arm700i

en: use -mcpu=arm710
ro: utilizează -mcpu=arm710

en: use -mcpu=arm7100
ro: utilizează -mcpu=arm7100

en: use -mcpu=arm710c
ro: utilizează -mcpu=arm710c

en: use -mcpu=arm710t
ro: utilizează -mcpu=arm710t

en: use -mcpu=arm720
ro: utilizează -mcpu=arm720

en: use -mcpu=arm720t
ro: utilizează -mcpu=arm720t

en: use -mcpu=arm740t
ro: utilizează -mcpu=arm740t

en: use -mcpu=arm7500
ro: utilizează -mcpu=arm7500

en: use -mcpu=arm7500fe
ro: utilizează -mcpu=arm7500fe

en: use -mcpu=arm7d
ro: utilizează -mcpu=arm7d

en: use -mcpu=arm7di
ro: utilizează -mcpu=arm7di

en: use -mcpu=arm7dm
ro: utilizează -mcpu=arm7dm

en: use -mcpu=arm7dmi
ro: utilizează -mcpu=arm7dmi

en: use -mcpu=arm7m
ro: utilizează -mcpu=arm7m

en: use -mcpu=arm7tdmi
ro: utilizează -mcpu=arm7tdmi

en: use -mcpu=arm8
ro: utilizează -mcpu=arm8

en: use -mcpu=arm810
ro: utilizează -mcpu=arm810

en: use -mcpu=arm9
ro: utilizează -mcpu=arm9

en: use -mcpu=arm920
ro: utilizează -mcpu=arm920

en: use -mcpu=arm940
ro: utilizează -mcpu=arm940

en: use -mcpu=arm9tdmi
ro: utilizează -mcpu=arm9tdmi

en: use -mcpu=iwmmxt
ro: utilizează -mcpu=iwmmxt

en: use -mcpu=strongarm
ro: utilizează -mcpu=strongarm

en: use -mcpu=strongarm110
ro: utilizează -mcpu=strongarm110

en: use -mcpu=strongarm1100
ro: utilizează -mcpu=strongarm1100

en: use -mcpu=strongarm1110
ro: utilizează -mcpu=strongarm1110

en: use -mcpu=xscale
ro: utilizează -mcpu=xscale

en: use -mfpu=softvfp
ro: utilizează -mfpu=softvfp

en: use .code16 to ensure correct addressing mode
ro: utilizați .code16 pentru a asigura modul de adresare corect

en: use frame pointer
ro: utilizează indicatorul de cadru

en: use of .indirect_symbols requires `-dynamic'
ro: utilizarea lui .indirect_symbols necesită „-dynamic”

en: use of PC in this instruction is deprecated
ro: utilizarea lui PC în această instrucțiune este depășită

en: use of old and new-style options to set CPU type
ro: se utilizează opțiuni de tip vechi și nou pentru a defini tipul de CPU

en: use of old and new-style options to set FPU type
ro: se utilizează opțiuni de tip vechi și nou pentru a defini tipul de FPU

en: use of r13 is deprecated
ro: utilizarea lui r13 este depreciată

en: use of r15 in blx in ARM mode is not really useful
ro: utilizarea lui r15 în blx în modul ARM nu este foarte utilă

en: use of r15 in bx in ARM mode is not really useful
ro: utilizarea lui r15 în bx în modul ARM nu este foarte utilă

en: use of r15 in bxj is not really useful
ro: utilizarea lui r15 în bxj nu este foarte utilă

en: use stack size checking
ro: utilizează verificarea dimensiunii stivei

en: used $%u with ".set at=$%u"
ro: s-a utilizat $%u cu „.set at=$%u”

en: used $at without ".set noat"
ro: s-a utilizat $at fără „.set noat”

en: using
ro: se utilizează

en: using a bit field width of zero
ro: utilizând o lățime a câmpului de biți de zero

en: valid endian specifiers are be or le
ro: specificatorii endian valabili sunt be sau le

en: value %d out of range. Use #lo() or #hi()
ro: valoare %d în afara intervalului. Utilizați #lo() sau #hi()

en: value %ld out of range
ro: valoare %ld în afara intervalului

en: value %lu is too large for a byte operand
ro: valoarea %lu este prea mare pentru un operand de octeți

en: value 0x%x out of extended range.
ro: valoarea 0x%x în afara intervalului extins.

en: value cannot be expressed as a .cv_scomp
ro: valoarea nu poate fi exprimată ca o .cv_scomp

en: value cannot be expressed as a .cv_ucomp
ro: valoarea nu poate fi exprimată ca o .cv_ucomp

en: value conflicts with instruction length
ro: valoarea intră în conflict cu lungimea instrucțiunii

en: value not in range [-0xffffffff, 0xffffffff]
ro: valoarea nu este în intervalul [-0xffffffff, 0xffffffff]

en: value not in range [0, 0x7fffffff]
ro: valoarea nu este în intervalul [0, 0x7fffffff]

en: value not in range [0, 0xffffffff]
ro: valoarea nu este în intervalul [0, 0xffffffff]

en: value of %ld out of byte displacement range.
ro: valoarea %ld în afara intervalului de deplasare a octeților.

en: value of %ld out of double word displacement range.
ro: valoarea %ld iese din intervalul de deplasare a cuvintelor duble (double word).

en: value of %ld out of word displacement range.
ro: valoarea %ld în afara intervalului de deplasare a cuvintelor (word).

en: value of %ld too large for 16-bit branch
ro: valoarea lui %ld este prea mare pentru ramificarea pe 16 biți

en: value of %ld too large for 8-bit branch
ro: valoarea lui %ld este prea mare pentru ramificarea pe 8 biți

en: value of %s too large for field of %d byte at %s | value of %s too large for field of %d bytes at %s
ro[0]: valoarea %s este prea mare pentru un câmp de %d octet la %s
ro[1]: valoarea %s este prea mare pentru un câmp de %d octeți la %s
ro[2]: valoarea %s este prea mare pentru un câmp de %d de octeți la %s

en: value out of range
ro: valoare în afara intervalului

en: value out of range: 0x%x
ro: valoare în afara intervalului: 0x%x

en: value stored for r%d is UNKNOWN
ro: valoarea stocată pentru r%d este NECUNOSCUTĂ

en: value too large for 1-byte field
ro: valoare prea mare pentru câmpul de 1 octet

en: value too large for 2-byte field
ro: valoare prea mare pentru câmpul de 2 octeți

en: value too large to fit in %d bits
ro: valoare prea mare pentru a încăpea în %d biți

en: values must be constant
ro: valorile trebuie să fie constante

en: vcx instructions with Q registers require MVE
ro: instrucțiunile vcx cu registrele Q necesită MVE

en: vcx instructions with S or D registers require either MVE or Armv8-M floating point extension.
ro: instrucțiunile vcx cu registrele S sau D necesită fie MVE, fie extensia în virgulă mobilă Armv8-M.

en: vcx1 with S or D registers takes immediate within 0-2047
ro: vcx1 cu registrele S sau D ia o valoare imediată între 0-2047

en: vcx2 with S or D registers takes immediate within 0-63
ro: vcx2 cu registrele S sau D ia o valoare imediată între 0-63

en: vcx2 with S or D registers takes immediate within 0-7
ro: vcx2 cu registrele S sau D ia o valoare imediată între 0-7

en: vector element must be constant
ro: elementul vectorial trebuie să fie constant

en: vector index register
ro: registru de indexare vectorială

en: vector predicated instruction should be in VPT/VPST block
ro: instrucțiunea cu predicare vectorială trebuie să fie în blocul VPT/VPST

en: vector register
ro: registru vectorial

en: vector size above %u required for `%s'
ro: dimensiunea vectorului peste %u este necesară pentru „%s”

en: vector type expected
ro: se aștepta tipul de vector

en: vfmal/vfmsl with FP16 type cannot be conditional, the behaviour is UNPREDICTABLE
ro: vfmal/vfmsl cu tipul FP16 nu poate fi condițional, comportamentul este IMPREVIZIBIL

en: view number mismatch
ro: numărul de vizualizare nu corespunde

en: vliw group must consist of 1 core and 1 copro insn.
ro: grupul vliw trebuie să fie format din 1 instrucțiune core și 1 instrucțiune copro.

en: warn about performance deprecated IT instructions in ARMv8-A and ARMv8-R
ro: avertizează cu privire la instrucțiunile IT depreciate din punct de vedere al performanței în ARMv8-A și ARMv8-R

en: warn about symbols that match instruction names [default]
ro: avertizează cu privire la simbolurile care se potrivesc cu numele instrucțiunilor [implicit]

en: warning: symbol %s has no csect
ro: avertisment: simbolul %s nu are csect

en: wasm32 assembler options:
ro: Opțiunile asamblorului wasm32:

en: we can't li.d on 32bit-arch
ro: nu putem face li.d pe 32bit-arch

en: width suffixes are invalid in ARM mode
ro: sufixele de lățime nu sunt valide în modul ARM

en: width suffixes are invalid in ARM mode -- `%s'
ro: sufixele de lățime nu sunt valide în modul ARM -- „%s”

en: word of NOPs added between word multiply and 16-bit multiply
ro: cuvânt de NOP-uri adăugată între multiplicarea de cuvânt și multiplicarea pe 16 biți

en: word of NOPs added between word multiply and load
ro: cuvânt de NOP-uri adăugat între multiplicarea și încărcarea cuvântului

en: writeback (!) must be used for VLDMDB and VSTMDB
ro: scrierea-înapoi (!) trebuie să fie utilizată pentru VLDMDB și VSTMDB

en: writeback of base register is UNPREDICTABLE
ro: scrierea-înapoi a registrului de bază este IMPREDICTIBILĂ

en: writeback of base register when in register list is UNPREDICTABLE
ro: scrierea-înapoi a registrului de bază atunci când se află în lista de registre este IMPREDICTIBILĂ

en: writeback used in preload instruction
ro: scrierea-înapoi utilizată în instrucțiunea de preîncărcare

en: writeback value must be an immediate constant
ro: valoarea de scriere-înapoi trebuie să fie o constantă imediată

en: writing or modifying # is unpredictable
ro: scrierea sau modificarea # este imprevizibilă

en: writing to APSR without specifying a bitmask is deprecated
ro: scrierea în APSR fără a specifica o mască de biți este depreciată

en: wrong argument to .cfi_personality_id
ro: argument greșit pentru .cfi_personality_id

en: wrong number of operands for '%s'
ro: număr greșit de operanzi pentru „%s”

en: wrong register in floating-point reglist
ro: registru greșit în lista de registre în virgulă mobilă

en: wrong second argument to .cfi_lsda
ro: al doilea argument pentru .cfi_lsda este greșit

en: wrong second argument to .cfi_personality
ro: al doilea argument pentru .cfi_personality este greșit

en: wrong size instruction in a %u-bit branch delay slot
ro: instrucțiune de dimensiune greșită într-un interval de întârziere de ramificare de %u-bit

en: wrong third argument to .cfi_val_encoded_addr
ro: al treilea argument pentru .cfi_val_encoded_addr este greșit

en: xtensa-isa failure: %s
ro: eșec xtensa-isa: %s

en: you can't `%s %s%s'
ro: nu puteți „%s %s%s”

en: you must specify a single type only
ro: trebuie să specificați doar un singur tip

en: you must use a hi/lo directive or 16-bit macro to load a 16-bit value.
ro: trebuie să utilizați o directivă hi/lo sau o macro pe 16 biți pentru a încărca o valoare pe 16 biți.

en: zdaoff() relocation used on an instruction which does not support it
ro: realocarea zdaoff() utilizată pe o instrucțiune care nu o acceptă

en: zero assumed for missing expression
ro: zero presupus pentru expresia lipsă

en: zero flag is not valid for this instruction
ro: fanionul zero nu este valabil pentru această instrucțiune

en: zero used as immediate value
ro: zero folosit ca valoare directă(immediate)

en: zeroing-masking only allowed with write mask
ro: mascarea cu zerouri este permisă numai cu masca de scriere

en: {nf} cannot be combined with {vex}/{vex3}
ro: {nf} nu poate fi combinat cu {vex}/{vex3}

en: {nf} unsupported
ro: {nf} neacceptat

en: {rex2} prefix invalid with `%s'
ro: prefixul {rex2} nu este valid cu „%s”

en: {standard input}
ro: (intrare standard)
