gas 2.42.90 - en to ro translation catalogue (2182 entries)

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

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

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

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

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:                           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:                           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:    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:   --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:   --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:   --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:   --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:   --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  -mbig-endian		generate big-endian output
ro:   -EB  -mbig-endian		generează cod 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:   -I DIR                  add DIR to search list for .include directives
ro:   -I DIR                  adaugă DIR la lista de căutare pentru directivele .include

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:   -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:   -Q                      ignored
ro:   -Q                      ignorată

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:   -W, --no-warn           suppress warnings
ro:   -W, --no-warn           suprimă avertismentele

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:   -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:   -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:   -jsri2bsr  -mjsri2bsr		transform jsri to bsr
ro:   -jsri2bsr  -mjsri2bsr		transformă jsri în bsr

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-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=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:   -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-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:   -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:   -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:   -mhard-float			enable hard float instructions
ro:   -mhard-float			activează instrucțiunile în virgulă mobilă hardware

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:   -mistack			enable interrupt stack instructions
ro:   -mistack			activează instrucțiunile stivei de întreruperi

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:   -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:   -mnaked-reg             don't require `%%' prefix for registers
ro:   -mnaked-reg             nu necesită prefixul „%%” pentru registre

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

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:   -mrelax                 enable relaxation
ro:   -mrelax                 activează relaxarea

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:   -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:   -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:   -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:   -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:   -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:   -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:   -nocpp                  ignored
ro:   -nocpp                  ignorată

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:   -s                      ignored
ro:   -s                      ignorată

en:   -w                      ignored
ro:   -w                      ignorată

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

en:  (default)
ro:  (implicit)

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:  H8300-specific assembler options:
ro:  Opțiuni de asamblare specifice H8300:

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: ".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: #4 not valid on H8/300.
ro: nr.4 nu este valabil pentru H8/300.

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: %s -- `%s'
ro: %s - „%s”

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

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

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

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

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

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

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 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 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 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%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: 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:%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; 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' 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' 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: ',' 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: 'LSL' or 'ASR' required
ro: se necesită „LSL” sau „ASR”

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

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

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: ']' 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: '}' expected at end of 'option' field
ro: se aștepta „}” la sfârșitul câmpului „option”

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: --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: --no-underscore is invalid with a.out format
ro: „--no-underscore” nu este validă cu formatul a.out

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

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: -R option not supported on this target.
ro: Opțiunea „-R” nu este acceptată pe această țintă.

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: -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: -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: -mfdpic         Assemble for the FDPIC ABI
ro: -mfdpic         asamblează pentru FDPIC ABI

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: -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: -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: -mljump is ignored for ck801/ck802
ro: „-mljump” este ignorată pentru ck801/ck802

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

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: -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: -msoft-float    Mark generated file as using software FP
ro: -msoft-float    marchează fișierul generat ca utilizând software-ul FP

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: .%s outside of %s
ro: .%s în afara lui %s

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

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: .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: .callinfo is not within a procedure definition
ro: .callinfo nu se află într-o definiție de procedură

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: .cpu: missing cpu name
ro: .cpu: lipsește numele CPU-ului

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: .dim pseudo-op used outside of .def/.endef: ignored.
ro: pseudo-operator .dim utilizat în afara lui .def/.endef: se ignoră.

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

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

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

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 outside of .def/.endef: ignored.
ro: pseudo-operator .endef utilizat în afara lui .def/.endef: se ignoră.

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: .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: .handler directive has no name
ro: directiva .handler nu are un nume

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

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: .ln pseudo-op inside .def/.endef: ignored.
ro: .ln pseudo-operator în interiorul .def/.endef: se ignoră.

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: .mask outside of .ent
ro: .mask în afara directivei .ent

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: .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: .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 pseudo-op only available with -mccs flag.
ro: . pseudo-operatorul .ref este disponibil numai cu fanionul „-mccs”.

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

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: .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: .type pseudo-op used outside of .def/.endef: ignored.
ro: pseudo-operator .type utilizat în afara lui .def/.endef: se ignoră.

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

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: .val pseudo-op used outside of .def/.endef: ignored.
ro: pseudo-operator .val utilizat în afara lui .def/.endef: se ignoră.

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

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%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 jump out of range
ro: salt de 16 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: 32bit mode not supported on `%s'.
ro: Modul pe 32 de biți nu este acceptat pe „%s”.

en: 32bit x86_64 is only supported for ELF
ro: X86_64 pe 32 de biți este acceptat doar pentru ELF

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: :lower16: not allowed in this instruction
ro: :lower16: nu este permis în această instrucțiune

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>	  assemble for floating point ABI <abi>
ro: <abi>	  asamblează pentru ABI în virgulă mobilă <abi>

en: <arch name>	  assemble for architecture <arch name>
ro: <nume arhi>	  asamblează pentru arhitectura <nume arhi>

en: <cpu name>	  assemble for CPU <cpu name>
ro: <nume cpu>	  asamblează pentru CPU-ul <nume cpu>

en: <fpu name>	  assemble for FPU architecture <fpu name>
ro: <nume fpu>	  asamblează pentru arhitectura FPU <nume fpu>

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 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: 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: 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: ARC-specific assembler options:
ro: Opțiuni de asamblare specifice ARC:

en: ARM register expected
ro: se aștepta un registru ARM

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: Addend to unresolved symbol not on word boundary.
ro: Adăugare la un simbol nerezolvat și nu la limita cuvântului.

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 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 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: Argument to .BLOCK/.BLOCKZ must be between 0 and 0x3fffffff
ro: Argumentul pentru .BLOCK/.BLOCKZ trebuie să fie cuprins între 0 și 0x3fffffff

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 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: 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: 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 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 () - floating point formats are not supported
ro: Apel greșit la md_atof () - formatele cu virgulă mobilă nu sunt acceptate

en: Bad expression: @%s + %s.
ro: Expresie greșită: @%s + %s.

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 register name
ro: Nume de registru greșit

en: Bad register range
ro: Interval de registru incorect

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: Banked registers are not available with this architecture.
ro: Registrele în bancuri nu sunt disponibile cu această arhitectură.

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: 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: 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 set dlx_skip_hi16_flag
ro: Nu se poate stabili dlx_skip_hi16_flag

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 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 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 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 represent relocation type %s
ro: Nu se poate reprezenta tipul de realocare %s

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: Chose GP value of %lx
ro: Alege valoarea GP de %lx

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: 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: Copyright (C) 2024 Free Software Foundation, Inc.
ro: Drepturi de autor © 2024 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: 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: Destination registers may not be the same
ro: Registrele de destinație ar putea să nu fie aceleași

en: Directive invalid within a bundle
ro: Directivă nevalidă în cadrul unui pachet

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 equal sign (=) in instruction
ro: Semnul egal (=) duplicat în instrucțiune

en: Duplicate predicate register ignored
ro: Registrul de predicat duplicat este ignorat

en: ECOFF debugging is disabled.
ro: Depanarea ECOFF este dezactivată.

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

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: 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 comma after name "%s"
ro: Se aștepta o virgulă după numele „%s”

en: Expected quoted string
ro: Se aștepta un șir între ghilimele

en: Expected separator `='
ro: Se aștepta separatorul „=”

en: Expression Error for operand modifier %%hi/%%lo
ro: Eroare de expresie pentru modificatorul operandului %%hi/%%lo

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: 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 real start of function: %s
ro: Nu s-a reușit să se găsească începutul real al funcției: %s

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: 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: 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: 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: 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: 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: 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 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: 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 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 index register pair (`%s') in Instruction: `%s'
ro: Pereche de registre de index ilegală („%s”) în instrucțiunea: „%s”

en: Illegal operand (arg %d)
ro: Operand ilegal (arg %d)

en: Illegal operand separator `%c'
ro: Separator de operanzi ilegal „%c”

en: Illegal operands
ro: Operanzi ilegali

en: Illegal operands (whitespace): `%s'
ro: Operanzi ilegali (spații albe): „%s”

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 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: Immediates %d and %d will give undefined behavior.
ro: Valorile imediate %d și %d vor avea un comportament nedefinit.

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: Incorrect number of operands
ro: Număr incorect de operanzi

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: 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 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 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 may not be executed in parallel
ro: Instrucțiunile nu pot fi executate în paralel

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 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: Unable to find containing space for %s.
ro: Eroare internă: Imposibil de găsit spațiul care conține %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 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 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 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 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 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 --mach option: %s
ro: Argument nevalid pentru opțiunea --mach: %s

en: Invalid expression after # number
ro: Expresie nevalidă după # numărul

en: Invalid expression after %%%%
ro: Expresie nevalidă după %%%%

en: Invalid field selector.  Assuming F%%.
ro: Selector de câmp nevalid. Se presupune F%%.

en: Invalid label '%s'
ro: Etichetă nevalidă „%s”

en: Invalid left/right combination completer
ro: Completare combinație stânga/dreapta nevalidă

en: Invalid number
ro: Număr nevalid

en: Invalid operands
ro: Operanzi nevalabili

en: Invalid operands %s
ro: Operanzi nevalabili %s

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 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: 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: 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: 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: Length of .comm "%s" is already %ld. Not changed to %ld.
ro: Lungimea .comm „%s” este deja %ld. Nu se modifică la %ld.

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: 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: Maximum %d bits may be set in `mask16' operand
ro: Maxim %d biți pot fi definiți în operandul „mask16”.

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 '}': '%s'
ro: Lipsește „}”: „%s”

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 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 matching brackets : `%s'
ro: Lipsesc parantezele pereche : „%s”

en: Missing predicate relation type
ro: Lipsește tipul de relație predicat

en: Missing symbol name in directive
ro: Lipsește numele simbolului din directivă

en: More than one relocation op per insn
ro: Mai mult de o operație de realocare per instrucțiune

en: Multiple .cpu directives found
ro: Multiple directive .cpu găsite

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: 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: 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 comma after .pdesc <entryname>
ro: Fără virgulă după .pdesc <entryname>

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 relocation operand
ro: Fără operand de realocare

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-global symbol: '%s' can't be a weak_definition.
ro: Simbol non-global: „%s” nu poate fi o weak_definition.

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: Number of elements must be positive
ro: Numărul de elemente trebuie să fie pozitiv

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: 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: 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: 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 has odd displacement (arg %d)
ro: Operandul are o deplasare impară (arg %d)

en: Operand of .vframe contradicts .prologue
ro: Operandul din .vframe contrazice .prologue

en: Operand out of range (arg %d)
ro: Operand în afara intervalului (arg %d)

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: 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: 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 relative relocation not allowed for (internal) type %d
ro: Nu este permisă realocarea relativă la PC pentru tipul (intern) %d

en: PC-relative relocation must be trivially resolved
ro: Realocarea relativă la PC trebuie să fie rezolvată trivial

en: PIC relocation size does not match operand size
ro: Dimensiunea realocării PIC nu se potrivește cu dimensiunea operandului

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: 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 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: 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: Previous .save incomplete
ro: Precedentul .save incomplet

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: 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: 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: Reg not valid for H8/300
ro: Registrul nu este valabil pentru H8/300

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 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 must be EVEN
ro: Numărul registrului trebuie să fie PAR

en: Register value annotation ignored
ro: Adnotarea valorii registrului este ignorată

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: Relocation %s is not safe for %s
ro: Realocarea %s nu este sigură pentru %s

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: Rn must not overlap other operands
ro: Rn nu trebuie să se suprapună peste alți operanzi

en: SCFI is not supported for this ABI
ro: SCFI nu este acceptat pentru această ABI

en: SCFI: `%s' insn with non-zero addend to sym not supported
ro: SCFI: instrucțiunea „%s” cu termen diferit de zero pentru sym nu este acceptată

en: SCFI: hand-crafting instructions not supported
ro: SCFI: instrucțiunile create manual nu sunt acceptate

en: SCFI: unexpected op %#x may cause incorrect CFI
ro: SCFI: operația neașteptată %#x poate cauza un CFI incorect

en: SCFI: unhandled op %#x may cause incorrect CFI
ro: SCFI: operația negestionată %#x poate cauza un CFI incorect

en: SCFI: unsupported APX op %#x may cause incorrect CFI
ro: SCFI: operația APX neacceptată %#x poate cauza un CFI incorect

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: 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: 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: 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: Short branches, Undefined, SVC, LDM/STM
ro: Ramificații scurte, nedefinite, SVC, LDM/STM

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: Swapping instruction order
ro: Schimbarea ordinii instrucțiunilor

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: TLS relocation cannot be used with `%s'
ro: realocarea TLS nu poate fi utilizată cu „%s”

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: Tags on unwind pseudo-ops aren't supported, yet
ro: Etichetele pe pseudo-ops de desfășurare nu sunt acceptate, încă

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 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: 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 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 many operands: %s
ro: Prea mulți operanzi: %s

en: Tried to .set unrecognized mode `%s'
ro: S-a încercat .set pentru modul nerecunoscut „%s”

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: Type is not allowed for this instruction
ro: Tipul nu este permis pentru această instrucțiune

en: Unable to find %s relocation for instruction %s
ro: Nu se poate găsi realocarea %s pentru instrucțiunea %s

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 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: 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: 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 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 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 opcode `%s'.
ro: Cod operațional necunoscut „%s”.

en: Unknown opcode: `%s'
ro: Cod operațional necunoscut: „%s”

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 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 type
ro: Tip necunoscut

en: Unrecognized .LEVEL argument
ro: Argument .LEVEL nerecunoscut

en: Unrecognized or unsupported floating point constant
ro: Constantă în virgulă mobilă nerecunoscută sau neacceptată

en: Unrecognized predicate relation type
ro: Tip de relație predicat 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: Unsupported broadcast: `%s'
ro: Difuzare neacceptată: „%s”

en: Unsupported operation on reloc
ro: Operație neacceptată la realocare

en: Unsupported use of sp
ro: Utilizare neacceptată a sp

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 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 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: Used $at without ".set noat"
ro: S-a utilizat $at fără „.set noat”

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: 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 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 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: 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: 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: 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: [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: `%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 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' cannot be used here
ro: „%s” nu poate fi utilizat aici

en: `%s' has undefined result
ro: „%s” are un rezultat nedefinit

en: `%s' is not a valid %s expression
ro: „%s” nu este o expresie %s validă

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' 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 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: `)' required
ro: „)” este necesară

en: `,' required
ro: „,” este necesară

en: `.noopt' arguments ignored
ro: argumentele „.noopt” sunt ignorate.

en: a reloc on this operand implies an overflow
ro: o realocare pe acest operand implică o depășire

en: accessing MVE system register without MVE is UNPREDICTABLE
ro: accesarea registrului de sistem MVE fără MVE este IMPREDICTIBILĂ

en: address calculation needs a strongly defined nearby symbol
ro: calculul adreselor are nevoie de un simbol apropiat bine definit

en: address too high for vector table jmp/jsr
ro: adresă prea mare pentru tabelul vectorial jmp/jsr

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 must be constant
ro: alinierea trebuie să fie constantă

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: ambiguous broadcast for `%s', using %u-bit form
ro: difuzare ambiguă pentru „%s”, folosind forma %u-bit

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: assemble Thumb code
ro: asamblează codul Thumb

en: assemble for big-endian
ro: asamblare pentru big-endian

en: assemble for little-endian
ro: asamblare pentru little-endian

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: 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 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 recreate an unwind entry
ro: încercare de a recrea o intrare de desfășurare

en: attempt to redefine typed alias
ro: încercare de redefinire a unui alias tipizat

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: 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 .mask directive
ro: directivă .mask greșită

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,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 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 to instruction
ro: argumente greșite pentru instrucțiune

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 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 expression
ro: expresie greșită

en: bad floating literal: %s
ro: literal în virgulă mobilă eronat: %s

en: bad format for ifc or ifnc
ro: format greșit pentru ifc sau ifnc

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 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 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 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 missing co-processor number
ro: număr de co-procesor greșit sau lipsă

en: bad personality routine number
ro: număr de rutină de personalitate greșit

en: bad range in register list
ro: interval greșit în lista de registre

en: bad register for mrs
ro: registru greșit pentru mrs

en: bad register for post-index
ro: registru greșit pentru post-index

en: bad register list
ro: listă de registre greșită

en: bad register name `%s'
ro: nume de registru greșit „%s”

en: bad register range
ro: interval de registru greșit

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 string constant
ro: constantă de șir 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 vector arrangement type
ro: tip de aranjament vectorial greșit

en: badly formed .dim directive ignored
ro: directivă .dim prost formată, se ignoră

en: badly formed .weak directive ignored
ro: directivă .weak prost formată, se ignoră

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: bfd-target = %s
ro: țintă-bfd = %s

en: bignum invalid; zero assumed
ro: bignum nu este valid; se presupune zero

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: 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: 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 target not word aligned
ro: ținta ramurii nu este aliniată la cuvânt

en: broadcast is needed for operand of such type
ro: difuzarea este necesară pentru un operand de acest tip

en: byte or halfword not valid for base register
ro: octet sau jumătate de cuvânt nevalabil pentru registrul de bază

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 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 change index for operand
ro: nu se poate schimba indexul pentru operand

en: can't create group: %s
ro: nu se poate crea grupul: %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 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 mix relocation modifier with explicit shift
ro: nu se poate amesteca modificatorul de realocare cu deplasarea explicită

en: can't open %s: %s
ro: nu se poate deschide %s: %s

en: can't predecrement
ro: nu se poate pre-decrementa

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 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 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: cannot both predecrement and postincrement
ro: nu se poate pre-decrementa și post-incrementa în același timp

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 create floating-point number
ro: nu se poate crea numărul în virgulă mobilă

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 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 override zerofill section type for `%s,%s'
ro: nu se poate suprascrie tipul de secțiune zerofill pentru „%s,%s”

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 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 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 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: condition code %s value (%d) too large
ro: valoarea codului de condiție %s (%d) este prea mare

en: condition required
ro: se necesită o condiție

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: 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: 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 required
ro: se necesită o expresie constantă

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 value required
ro: se necesită o valoare constantă

en: coprocessor for insn is not enabled for cde
ro: co-procesorul pentru instrucțiune nu este activat pentru cde

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 open %s for reading
ro: nu s-a putut deschide %s pentru citire

en: could not set architecture and machine
ro: nu s-a putut stabili arhitectura și mașina

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: cpu-type = %s
ro: tip-cpu = %s

en: cr%d is a reserved control register
ro: cr%d este un registru de control rezervat

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: 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 size prefix invalid with `%s'
ro: prefixul dimensiunii datelor nu este valid cu „%s”

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 and source registers must be distinct
ro: registrele destinație și sursă trebuie să fie distincte

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 modified by displacement-post-modified address
ro: registrul de destinație modificat prin deplasarea-post-modificare a adresei

en: destination register same as write-back base
ro: registrul de destinație este identic cu baza de scriere-înapoi

en: disable warnings about symobls that match instructions
ro: dezactivează avertismentele despre simbolurile care corespund instrucțiunilor

en: division by zero
ro: împărțire la zero

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: don't use Rn-Rm syntax with non-unit stride
ro: nu folosiți sintaxa Rn-Rm cu un pas neunitar

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: 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: 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
ro: sfârșit de fișier în comentariu

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 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: entity size for SHF_MERGE not specified
ro: dimensiunea entității pentru SHF_MERGE nu este specificată

en: error adding attribute: %s
ro: eroare la adăugarea atributului: %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: estimate size
ro: dimensiunea estimată

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: expected #constant
ro: se aștepta #constantă

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 '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 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 <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 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 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 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 .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 separator
ro: se aștepta o virgulă ca separator

en: expected element type rather than vector type
ro: se aștepta un tip de element și nu un tip de vector

en: expected index
ro: index așteptat

en: expected numeric constant
ro: constantă numerică așteptată

en: expected quoted string
ro: se aștepta un șir între ghilimele

en: expected register
ro: se aștepta un registru

en: expected register list
ro: se aștepta o listă de registre

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 }
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 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 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 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: expression must be constant
ro: expresia trebuie să fie constantă

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: extending shift is not permitted
ro: extinderea deplasării nu este permisă

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 comma
ro: virgulă extra

en: extra dot
ro: punct extra

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 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 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: 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 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: 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: 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 transfer register must be even
ro: primul registru de transfer trebuie să fie par

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: 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 number invalid; zero assumed
ro: număr în virgulă mobilă nevalid; se presupune zero

en: found `%sd'; assuming `%sl' was meant
ro: s-a găsit „%sd”; se presupune că se referea la „%sl”

en: fr_mem record before region record!
ro: înregistrarea fr_mem înainte de înregistrarea regiunii!

en: frame reg expected, using $%d.
ro: se aștepta un registru cadru, folosind $%d.

en: frgr_mem record before region record!
ro: înregistrarea frgr_mem înainte de înregistrarea regiunii!

en: further multibyte character warnings suppressed
ro: alte avertismente de caractere multi-octet au fost suprimate

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: 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: 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: 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: 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: 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: 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 redefine built-in register '%s'
ro: se ignoră încercarea de redefinire a registrului încorporat „%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 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 incorrect section type for %s
ro: se ignoră tipul incorect de secțiune pentru %s

en: ignoring redefinition of register alias '%s'
ro: se ignoră redefinirea pseudonimului de registru „%s”

en: illegal %s relocation size: %d
ro: dimensiune de relocare %s ilegală: %d

en: illegal expression
ro: expresie ilegală

en: illegal immediate register operand %s
ro: operand de registru imediat ilegal %s

en: illegal opcode %s for mcu %s
ro: cod operațional ilegal %s pentru mcu %s

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 prefix used with VEX/XOP/EVEX
ro: prefix ilegal utilizat cu VEX/XOP/EVEX

en: illegal register number
ro: număr de registru ilegal

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 out of bounds
ro: valoarea imediată este în afara limitelor

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 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 required
ro: se necesită operand direct(immediate)

en: immediate operand requires iWMMXt2
ro: operandul imediat necesită iWMMXt2

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 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 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: 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: inconsistent types in Neon instruction
ro: tipuri inconsistente în instrucțiunea Neon

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 register `%s%s' used with `%c' suffix
ro: registru incorect „%s%s” folosit cu sufixul „%c”

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 register overlaps transfer register
ro: registrul index se suprapune peste registrul de transfer

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: 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 2
ro: adresa instrucțiunii nu este un multiplu de 2

en: instruction cannot be conditional
ro: instrucțiunea nu poate fi condițională

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 form not available on this architecture.
ro: formă de instrucțiune nedisponibilă pe această arhitectură.

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 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 register index
ro: instrucțiunea necesită un index de registru

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 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: 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: failed to allocate %d indirectsymbol pointers
ro: eroare internă: nu s-a reușit alocarea a %d indicatori de simboluri indirecte

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? cannot generate `%s' relocation
ro: eroare internă? nu se poate genera realocarea „%s”

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: 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: 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_relocation (type: OFFSET_IMM) not fixed up
ro: internal_relocation (tip: OFFSET_IMM) necorectată

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 -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 Hi register with immediate
ro: registru Hi nevalid cu o imediată

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 ZA tile
ro: piesă ZA nevalidă

en: invalid `%s' prefix
ro: prefix „%s” 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 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 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 char %s beginning operand %d `%s'
ro: caracter nevalid %s care începe operandul %d „%s”

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 co-processor operand
ro: operand coprocesor nevalid

en: invalid condition
ro: condiție nevalidă

en: invalid constant
ro: constantă nevalidă

en: invalid constant (%lx) after fixup
ro: constantă nevalidă (%lx) după corectare

en: invalid element size %d and vector size combination %c
ro: combinație nevalidă între dimensiunea elementului %d și dimensiunea vectorului %c

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 floating-point constant
ro: constantă cu virgulă mobilă nevlidă

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 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: %ld is out of range
ro: imediată nevalidă: %ld este în afara intervalului

en: invalid instruction `%s' after `%s'
ro: instrucțiune nevalidă „%s” după „%s”

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 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 merge entity size
ro: dimensiune nevalidă a entității de fuziune

en: invalid mode
ro: mod 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 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 operand in ldm
ro: operand nevalid în ldm

en: invalid operand in stm
ro: operand nevalid în stm

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 operands
ro: operanzi nevalabili

en: invalid pc-relative address
ro: adresă relativă la calculator nevalidă

en: invalid pseudo operation
ro: pseudo-operație nevalidă

en: invalid range in vector register list
ro: interval nevalid în lista de registre vectoriale

en: invalid register
ro: registru 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 operand size for `%s'
ro: dimensiunea operandului registrului nu este validă pentru „%s”

en: invalid register stride at operand %d -- `%s'
ro: interval de registru nevalid la operandul %d -- „%s”

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 field
ro: realocare nevalidă pentru câmp

en: invalid relocation for instruction
ro: realocare nevalidă pentru instrucțiune

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 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 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 suffix
ro: sufix nevalid

en: invalid suffix after register.
ro: sufix nevalid după registru.

en: invalid swi expression
ro: expresie swi 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 type for literal pool
ro: tip nevalid pentru fondul literal

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 '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 vector register
ro: utilizare nevalidă a registrului vectorial

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 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: 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: junk `%s' after expression
ro: deșeuri „%s” după expresie

en: junk `%s' after register
ro: deșeuri „%s” după registru

en: label "$%d" redefined
ro: eticheta „$%d” a fost redefinită

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: 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: literal pool insertion failed
ro: inserția fondului literal a eșuat

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: lo register required
ro: se necesită un registru lo

en: long jump required
ro: se necesită un salt lung

en: lower 16 bits of mask ignored
ro: cei 16 biți inferiori ai măștii sunt ignorați

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: 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, 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: md5_stream failed
ro: md5_stream a eșuat

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: 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: mismatched .eb
ro: .eb nepotrivit

en: mismatched element/structure types in list
ro: tipurile de elemente/structuri nu corespund în listă

en: misplaced .procend
ro: .procend plasat greșit

en: missing '%c'
ro: lipsește „%c”

en: missing ')'
ro: „)” lipsește

en: missing ']'
ro: „]” lipsește

en: missing .fnstart before unwinding directive
ro: lipsește .fnstart înainte de derularea directivei

en: missing .proc
ro: lipsește .proc

en: missing CPS flags
ro: lipsesc fanioanele CPS

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 `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 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 braces at operand %d
ro: lipsesc acoladele la operandul %d

en: missing close quote; (assumed)
ro: lipsesc ghilimelele de închidere; (presupus)

en: missing closing brace
ro: lipsește acolada de închidere

en: missing comma
ro: lipsește virgula

en: missing comma or colon
ro: lipsește virgula sau două puncte „:”

en: missing cpu architecture
ro: arhitectura cpu-ului lipsește

en: missing cpu name `%s'
ro: lipsește numele CPU-ului „%s”

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 in .size directive
ro: expresie lipsă în directiva .size

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 name
ro: lipsește numele

en: missing offset in the pre-indexed address
ro: decalaj lipsă în adresa preindexată

en: missing operand
ro: operand lipsă

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 register index
ro: lipsește indexul registrului

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 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 type
ro: tipul lipsește

en: missing type suffix
ro: lipsește sufixul de tip

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: 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 emulation names specified
ro: multiple nume de emulare specificate

en: multiple versions [`%s'|`%s'] for symbol `%s'
ro: versiuni multiple [„%s”|„%s”] pentru simbolul „%s”

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: nested .ent directives
ro: directive .ent imbricate

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: no EVEX encoding
ro: fără codificare EVEX

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 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 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 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 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 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 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: non-absolute expression in constant field
ro: expresie neabsolută în câmp constant

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-contiguous register range
ro: interval de registre necontiguu

en: non-pc-relative relocation for pc-relative field
ro: realocare ne-relativă la PC pentru câmpul relativ la PC

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 operands mismatch
ro: nepotrivire a numărului de operanzi

en: odd address operand: %ld
ro: operand de adresă impară: %ld

en: offset has different size from base
ro: decalajul are dimensiuni diferite față de bază

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: 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 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 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 r15 allowed here
ro: doar r15 este permis aici

en: only two consecutive VFP SP registers allowed here
ro: doar două registre VFP SP consecutive sunt permise aici

en: opcode '%s' not supported for target %s
ro: codul operațional „%s” nu este acceptat pentru ținta %s

en: opcode `%s' not supported for target %s
ro: codul operațional „%s” nu este acceptat pentru ținta %s

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

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: illegal use expression: `%s`
ro: operand %d: expresie de utilizare ilegală: `%s`

en: operand %s0x%lx out of range.
ro: operand %s0x%lx în afara intervalului.

en: operand 1 must be FPSCR
ro: operandul 1 trebuie să fie FPSCR

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 r12
ro: operandul trebuie să fie r12

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 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/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: option `-%c%s' is deprecated: %s
ro: opțiunea „-%c%s” este depreciată: %s

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 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: packing conflict: %s must dispatch sequentially
ro: conflict de împachetare: %s trebuie să expedieze secvențial

en: parallel
ro: paralel

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 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: pcrel offset for branch to %s too far (0x%lx)
ro: decalajul pcrel pentru ramificarea la %s prea departe (0x%lx)

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: 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: 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: previous .ent not closed by a .end
ro: directiva .ent precedentă nu este închisă printr-o directivă .end

en: previous `%s' sequence has not been closed
ro: secvența precedentă „%s” nu a fost închisă

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-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: 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: 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: record type is not valid
ro: tipul înregistrării nu este valid

en: record_type_not_valid
ro: tip_de_înregistrare_nevalid

en: redefinition of mcu type `%s' to `%s'
ro: redefinirea tipului mcu „%s” la „%s”

en: redundant %s prefix
ro: prefix %s redundant

en: register '%s%s' cannot be used here
ro: registrul „%s%s” nu poate fi folosit aici

en: register expected
ro: se aștepta un registru

en: register is out of order
ro: registrul nu este în ordine

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 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 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 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 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 type mismatch
ro: nepotrivire de tip de registru

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: relaxable branches not supported in absolute section
ro: ramificările relaxabile nu sunt acceptate în secțiunea absolută

en: reloc %d not supported by object file format
ro: realocarea %d nu este acceptată de formatul de fișier obiect

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 is not supported
ro: realocarea nu este acceptată

en: relocation not allowed
ro: realocarea nu este permisă

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: replacing `rep'/`repe' prefix by `bnd'
ro: se înlocuiește prefixul „rep”/“repe” cu „bnd”

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: rex2 pseudo prefix cannot be used
ro: pseudoprefixul rex2 nu poate fi utilizat

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: s suffix on comparison instruction is deprecated
ro: sufixul s pe instrucțiunea de comparație este depreciat

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 of %d without an index register
ro: factor de scară de %d fără un registru de indexare

en: second
ro: secundă

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: section
ro: secțiune

en: section %s already has a group (%s)
ro: secțiunea %s are deja un grup (%s)

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 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 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: 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 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: 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: setend use is deprecated for ARMv8
ro: utilizarea setend este depreciată pentru ARMv8

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: 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: shortcut designator invalid
ro: designator de prescurtare nevalid

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 value out of range
ro: valoare cu semn în afara intervalului

en: size (%ld) out of range, ignored
ro: dimensiune (%ld) în afara intervalului, se ignoră

en: size of "%s" is already %ld; not changing to %ld
ro: dimensiunea lui „%s” este deja %ld; nu se schimbă în %ld

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: source
ro: sursa

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 `%s%s' implicitly denotes `%s%.3s%u' to `%s%.3s%u' source group in `%s'
ro: registrul sursă „%s%s” denotă implicit „%s%.3s%u” la grupul sursă „%s%.3s%u” din „%s”

en: source register same as write-back base
ro: registrul sursăe este identic cu baza de scriere-înapoi

en: source1 and dest must be same register
ro: sursa1 și destinația trebuie să fie același registru

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: 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: stack increment must be multiple of 4
ro: incrementul stivei trebuie să fie multiplu de 4

en: stand-alone `%s' prefix
ro: prefix „%s” independent

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: 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 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' 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' 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 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: syntax error
ro: eroare de sintaxă

en: syntax error in register list
ro: eroare de sintaxă în lista de registre

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: tag not found for .tag %s
ro: marcaj negăsit pentru .tag %s

en: temporary switch for dumping
ro: comutator temporar pentru descărcare

en: the %s name '%s' is too long (maximum 16 characters)
ro: numele %s „%s” este prea lung (maxim 16 caractere)

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 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: 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: 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 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 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 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 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 arguments
ro: prea multe argumente

en: too many fixups
ro: prea multe remedieri

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 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 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: 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: 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: 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: 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 used as an immediate value
ro: simbol nedefinit %s folosit ca valoare imediată

en: unexpected %s fixup
ro: corecție neașteptată %s

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 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 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 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 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 DWARF option %s
ro: opțiune DWARF necunoscută %s

en: unknown EABI `%s'
ro: EABI necunoscută „%s”

en: unknown MCU: %s
ro: MCU necunoscut: %s

en: unknown abi `%s'
ro: abi 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 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 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 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 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 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 mnemonic -- `%s'
ro: mnemonic necunoscut -- „%s”

en: unknown mnemonic `%s' -- `%s'
ro: mnemonic necunoscut „%s” -- „%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 operand to .arch
ro: operand necunoscut pentru .arch

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 procedure kind
ro: tip de procedură necunoscut

en: unknown record type %d (in %s)
ro: tip de înregistrare necunoscut %d (în %s)

en: unknown register '%s' -- .req ignored
ro: registru necunoscut „%s” -- directiva .req este ignorată

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 vector operation: `%s'
ro: operație vectorială necunoscută: „%s”

en: unknown width specifier '.%c'
ro: specificator de lățime necunoscut „.%c”

en: unmatched '['
ro: „[” fără corespondent

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 float16 format "%s"
ro: format float16 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 emulation name `%s'
ro: nume de emulare nerecunoscut „%s”

en: unrecognized flag
ro: fanion nerecunoscut

en: unrecognized instruction `%s'
ro: instrucțiune nerecunoscută „%s”

en: unrecognized opcode
ro: cod operațional nerecunoscut

en: unrecognized option -%c%s
ro: opțiune nerecunoscută „-%c%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 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 type "%s"
ro: tip de simbol nerecunoscut „%s”

en: unrecognized syntax mode "%s"
ro: mod de sintaxă nerecunoscut „%s”

en: unresolved expression that must be resolved
ro: expresie nerezolvată care trebuie rezolvată

en: unshifted register required
ro: este necesar un registru ne decalat

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 instruction `%s'
ro: instrucțiune neacceptată „%s”

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 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 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: unwind opcode too long
ro: cod operațional de desfășurare prea lung

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: 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 not in range [0, 0xffffffff]
ro: valoarea nu este în intervalul [0, 0xffffffff]

en: value out of range
ro: valoare în afara intervalului

en: value stored for r%d is UNKNOWN
ro: valoarea stocată pentru r%d este NECUNOSCUTĂ

en: value too large to fit in %d bits
ro: valoare prea mare pentru a încăpea în %d biți

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 predicated instruction should be in VPT/VPST block
ro: instrucțiunea cu predicare vectorială trebuie să fie în blocul VPT/VPST

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: 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: 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 to APSR without specifying a bitmask is deprecated
ro: scrierea în APSR fără a specifica o mască de biți este depreciată

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: 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”
