# Danish messages for bfd.
# Copyright (C) 2001, 2002, 2011 Free Software Foundation, Inc.
# This file is distributed under the same license as the binutils package.
#
# Keld Simonsen <keld@dkuug.dk>, 2002-2003
# Ask Hjorth Larsen <asklarsen@gmail.com>, 2011
#
# Følgende konventioner bruges, men jeg er ikke sikker på at de nødvendigvis er de bedste:
#
# entry (alene) -> post
# entry point -> startpunkt
# link -> lænke
# overlay -> overlay
# relax -> forenkle
# record -> post
# image -> aftryk
# TOC -> TOC (=table of contents, evt. indholdsfortegnelse)
msgid ""
msgstr ""
"Project-Id-Version: bfd-2.20.90\n"
"Report-Msgid-Bugs-To: bug-binutils@gnu.org\n"
"POT-Creation-Date: 2010-11-05 11:31+0100\n"
"PO-Revision-Date: 2011-03-16 02:31+0100\n"
"Last-Translator: Ask Hjorth Larsen <asklarsen@gmail.com>\n"
"Language-Team: Danish <dansk@dansk-gruppen.dk>\n"
"Language: da\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"

#: aout-adobe.c:127
msgid "%B: Unknown section type in a.out.adobe file: %x\n"
msgstr "%B: Ukendt sektionstype i a.out.adobe-fil: %x\n"

#: aout-cris.c:199
#, c-format
msgid "%s: Invalid relocation type exported: %d"
msgstr "%s: Ugyldig relokeringstype eksporteret: %d"

#: aout-cris.c:242
msgid "%B: Invalid relocation type imported: %d"
msgstr "%B: Ugyldig relokeringstype importeret: %d"

#: aout-cris.c:253
msgid "%B: Bad relocation record imported: %d"
msgstr "%B: Fejlagtig relokeringspost importeret: %d"

#: aoutx.h:1273 aoutx.h:1611
#, c-format
msgid "%s: can not represent section `%s' in a.out object file format"
msgstr "%s: kan ikke repræsentere sektionen \"%s\" i a.out-objektfilformat"

#: aoutx.h:1577
#, c-format
msgid "%s: can not represent section for symbol `%s' in a.out object file format"
msgstr "%s: kan ikke repræsentere sektion for symbolet \"%s\" i a.out-objektfilformat"

#: aoutx.h:1579 vms-alpha.c:7649
msgid "*unknown*"
msgstr "*ukendt*"

#: aoutx.h:4007 aoutx.h:4333
msgid "%P: %B: unexpected relocation type\n"
msgstr "%P: %B: uventet relokeringstype\n"

#: aoutx.h:5364
#, c-format
msgid "%s: relocatable link from %s to %s not supported"
msgstr "%s: relokérbar lænke fra %s til %s understøttes ikke"

#: archive.c:2125
msgid "Warning: writing archive was slow: rewriting timestamp\n"
msgstr "Advarsel: arkivskrivning var langsom: genskriver tidsstempel\n"

#: archive.c:2416
msgid "Reading archive file mod timestamp"
msgstr "Læser arkivfilens ændringstidsstempel"

#: archive.c:2440
msgid "Writing updated armap timestamp"
msgstr "Skriver opdateret armap-tidsstempel"

#: bfd.c:395
msgid "No error"
msgstr "Ingen fejl"

#: bfd.c:396
msgid "System call error"
msgstr "Systemkaldsfejl"

#: bfd.c:397
msgid "Invalid bfd target"
msgstr "Ugyldigt bfd-mål"

#: bfd.c:398
msgid "File in wrong format"
msgstr "Filen er i forkert format"

#: bfd.c:399
msgid "Archive object file in wrong format"
msgstr "Arkivobjektfil er i forkert format"

#: bfd.c:400
msgid "Invalid operation"
msgstr "Ugyldig handling"

#: bfd.c:401
msgid "Memory exhausted"
msgstr "Hukommelsen er opbrugt"

#: bfd.c:402
msgid "No symbols"
msgstr "Ingen symboler"

#: bfd.c:403
msgid "Archive has no index; run ranlib to add one"
msgstr "Arkivet har intet indeks; kør ranlib til at tilføje ét"

#: bfd.c:404
msgid "No more archived files"
msgstr "Ikke flere arkiverede filer"

#: bfd.c:405
msgid "Malformed archive"
msgstr "Forvansket arkiv"

#: bfd.c:406
msgid "File format not recognized"
msgstr "Filformatet ikke genkendt"

#: bfd.c:407
msgid "File format is ambiguous"
msgstr "Filformatet er flertydigt"

#: bfd.c:408
msgid "Section has no contents"
msgstr "Sektionen har intet indhold"

#: bfd.c:409
msgid "Nonrepresentable section on output"
msgstr "Ikkerepræsenterbar sektion i uddata"

#: bfd.c:410
msgid "Symbol needs debug section which does not exist"
msgstr "Symbolet kræver fejlsøgningssektion som ikke eksisterer"

#: bfd.c:411
msgid "Bad value"
msgstr "Fejlagtigt værdi"

#: bfd.c:412
msgid "File truncated"
msgstr "Filen trunkeret"

#: bfd.c:413
msgid "File too big"
msgstr "Filen er for stor"

#: bfd.c:414
#, c-format
msgid "Error reading %s: %s"
msgstr "Fejl ved læsning af %s: %s"

#: bfd.c:415
msgid "#<Invalid error code>"
msgstr "#<Ugyldig fejlkode>"

#: bfd.c:939
#, c-format
msgid "BFD %s assertion fail %s:%d"
msgstr "BFD %s-forsikring mislykkedes %s:%d"

#: bfd.c:951
#, c-format
msgid "BFD %s internal error, aborting at %s line %d in %s\n"
msgstr "Intern BFD %s-fejl, afbryder ved %s linje %d i %s\n"

#: bfd.c:955
#, c-format
msgid "BFD %s internal error, aborting at %s line %d\n"
msgstr "Internt BFD %s-fejl, afbryder ved %s linje %d\n"

#: bfd.c:957
msgid "Please report this bug.\n"
msgstr "Rapportér gerne denne fejl.\n"

#: bfdwin.c:206
#, c-format
msgid "not mapping: data=%lx mapped=%d\n"
msgstr "mapper ikke: data=%lx mappet=%d\n"

#: bfdwin.c:209
#, c-format
msgid "not mapping: env var not set\n"
msgstr "mapper ikke: miljøvariabel er ikke sat\n"

#: binary.c:271
#, c-format
msgid "Warning: Writing section `%s' to huge (ie negative) file offset 0x%lx."
msgstr "Advarsel: Skrivning af sektionen \"%s\" til enorm (dvs negativ) afsætsbyte 0x%lx."

#: bout.c:1146 elf-m10300.c:2063 elf32-avr.c:1640 elf32-frv.c:5740
#: elfxx-sparc.c:2795 reloc.c:5646 reloc16.c:162 elf32-ia64.c:842
#: elf64-ia64.c:842
msgid "%P%F: --relax and -r may not be used together\n"
msgstr "%P%F: --relax og -r kan ikke bruges sammen\n"

#: cache.c:226
msgid "reopening %B: %s\n"
msgstr "genåbner %B: %s\n"

#: coff-alpha.c:491
msgid ""
"%B: Cannot handle compressed Alpha binaries.\n"
"   Use compiler flags, or objZ, to generate uncompressed binaries."
msgstr ""
"%B: Kan ikke håndtere komprimerede Alpha-binærfiler.\n"
"   Brug kompilerflag eller objZ til at generere ukomprimerede binærfiler."

#: coff-alpha.c:648
msgid "%B: unknown/unsupported relocation type %d"
msgstr "%B: relokeringstypen %d kendes eller understøttes ikke"

#: coff-alpha.c:900 coff-alpha.c:937 coff-alpha.c:2025 coff-mips.c:1003
msgid "GP relative relocation used when GP not defined"
msgstr "GP-relativ relokering bruges når GP ikke er defineret"

#: coff-alpha.c:1502
msgid "using multiple gp values"
msgstr "bruger flere gp-værdier"

#: coff-alpha.c:1561
msgid "%B: unsupported relocation: ALPHA_R_GPRELHIGH"
msgstr "%B: relokering understøttes ikke: ALPHA_R_GPRELHIGH"

#: coff-alpha.c:1568
msgid "%B: unsupported relocation: ALPHA_R_GPRELLOW"
msgstr "%B: relokering understøttes ikke: ALPHA_R_GPRELLOW"

#: coff-alpha.c:1575 elf32-m32r.c:2493 elf64-alpha.c:3991 elf64-alpha.c:4140
#: elf32-ia64.c:4582 elf64-ia64.c:4582
msgid "%B: unknown relocation type %d"
msgstr "%B: ukendt relokeringstype %d"

#: coff-arm.c:1038
#, c-format
msgid "%B: unable to find THUMB glue '%s' for `%s'"
msgstr "%B: kan ikke finde THUMB-klistret \"%s\" til \"%s\""

#: coff-arm.c:1067
#, c-format
msgid "%B: unable to find ARM glue '%s' for `%s'"
msgstr "%B: kan ikke finde ARM-klistret \"%s\" til \"%s\""

#: coff-arm.c:1369 elf32-arm.c:6501
#, c-format
msgid ""
"%B(%s): warning: interworking not enabled.\n"
"  first occurrence: %B: arm call to thumb"
msgstr ""
"%B(%s): advarsel: samvirken (interworking) er ikke aktiveret.\n"
"  første forekomst: %B: arm-kald til thumb"

#: coff-arm.c:1459
#, c-format
msgid ""
"%B(%s): warning: interworking not enabled.\n"
"  first occurrence: %B: thumb call to arm\n"
"  consider relinking with --support-old-code enabled"
msgstr ""
"%B(%s): advarsel: \"Interworking\" er ikke slået til.\n"
"  første forekomst: %B: thumb-kald til arm\n"
"  overvej at genlænke med --support-old-code tilvalgt"

#: coff-arm.c:1754 coff-tic80.c:695 cofflink.c:3043
msgid "%B: bad reloc address 0x%lx in section `%A'"
msgstr "%B: fejlagtig relokeringsadresse 0x%lx i sektionen \"%s\""

#: coff-arm.c:2079
msgid "%B: illegal symbol index in reloc: %d"
msgstr "%B: illegalt symbolindeks i relokering: %d"

#: coff-arm.c:2210
#, c-format
msgid "error: %B is compiled for APCS-%d, whereas %B is compiled for APCS-%d"
msgstr "fejl: %B er kompileret til APCS-%d, mens %B er kompileret til APCS-%d"

#: coff-arm.c:2226 elf32-arm.c:14105
#, c-format
msgid "error: %B passes floats in float registers, whereas %B passes them in integer registers"
msgstr "fejl: %B overfører flydende tal i flydendetalsregistre, mens %B overfører dem i heltalsregistre"

#: coff-arm.c:2229 elf32-arm.c:14109
#, c-format
msgid "error: %B passes floats in integer registers, whereas %B passes them in float registers"
msgstr "fejl: %B overfører flydende tal i heltalsregistre, mens %B overfører dem i flydendetalsregistre"

#: coff-arm.c:2243
#, c-format
msgid "error: %B is compiled as position independent code, whereas target %B is absolute position"
msgstr "fejl: %s er kompileret som positionsuafhængig kode, mens målet %B har absolut position"

#: coff-arm.c:2246
#, c-format
msgid "error: %B is compiled as absolute position code, whereas target %B is position independent"
msgstr "fejl: %B er kompileret som kode med absolut position, mens målet %B er positionsuafhængigt"

#: coff-arm.c:2274 elf32-arm.c:14174
#, c-format
msgid "Warning: %B supports interworking, whereas %B does not"
msgstr "Advarsel: %B understøtter samvirken (interworking), mens %B ikke gør det"

#: coff-arm.c:2277 elf32-arm.c:14180
#, c-format
msgid "Warning: %B does not support interworking, whereas %B does"
msgstr "Advarsel: %B understøtter ikke samvirken (interworking), mens %B gør det"

#: coff-arm.c:2301
#, c-format
msgid "private flags = %x:"
msgstr "private flag = %x:"

#: coff-arm.c:2309 elf32-arm.c:10492
#, c-format
msgid " [floats passed in float registers]"
msgstr " [flydende tal overført i flydendetalsregistre]"

#: coff-arm.c:2311
#, c-format
msgid " [floats passed in integer registers]"
msgstr " [flydende tal overført i heltalsregistre]"

#: coff-arm.c:2314 elf32-arm.c:10495
#, c-format
msgid " [position independent]"
msgstr " [positionsuafhængigt]"

#: coff-arm.c:2316
#, c-format
msgid " [absolute position]"
msgstr " [absolut position]"

#: coff-arm.c:2320
#, c-format
msgid " [interworking flag not initialised]"
msgstr " [samvirkendeflag er ikke initieret]"

#: coff-arm.c:2322
#, c-format
msgid " [interworking supported]"
msgstr " [samvirken understøttes]"

#: coff-arm.c:2324
#, c-format
msgid " [interworking not supported]"
msgstr " [samvirken understøttes ikke]"

#: coff-arm.c:2370 elf32-arm.c:9520
#, c-format
msgid "Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"
msgstr "Advarsel: Sætter ikke samvirkeflaget (interworking) for %B, da den allerede er angivet som ikke-samvirkende"

#: coff-arm.c:2374 elf32-arm.c:9524
#, c-format
msgid "Warning: Clearing the interworking flag of %B due to outside request"
msgstr "Advarsel: Fjerner samvirkeflaget (interworking) for %B på grund af anmodning udefra"

#: coff-h8300.c:1122
#, c-format
msgid "cannot handle R_MEM_INDIRECT reloc when using %s output"
msgstr "kan ikke håndtere R_MEM_INDIRECT-relokering ved brug af %s-uddata"

#: coff-i860.c:147
#, c-format
msgid "Relocation `%s' not yet implemented\n"
msgstr "Relokeringen \"%s\" er endnu ikke implementeret\n"

#: coff-i860.c:605 coff-tic54x.c:398 coffcode.h:5147
msgid "%B: warning: illegal symbol index %ld in relocs"
msgstr "%B: advarsel: illegalt symbolindeks %ld i relokeringerne"

#: coff-i960.c:143 coff-i960.c:506
msgid "uncertain calling convention for non-COFF symbol"
msgstr "usikker kaldskonvention for ikke-COFF-symbol"

#: coff-m68k.c:506 elf32-bfin.c:5678 elf32-cr16.c:2897 elf32-m68k.c:4672
msgid "unsupported reloc type"
msgstr "relokeringstypen understøttes ikke"

#: coff-mips.c:688 elf32-mips.c:1014 elf32-score.c:430 elf32-score7.c:330
#: elf64-mips.c:2019 elfn32-mips.c:1832
msgid "GP relative relocation when _gp not defined"
msgstr "GP-relativ relokering når _gp ikke var defineret"

#: coff-or32.c:229
msgid "Unrecognized reloc"
msgstr "Ukendt relokering"

#: coff-rs6000.c:2794
#, c-format
msgid "%s: unsupported relocation type 0x%02x"
msgstr "%s: relokeringstypen 0x%02x understøttes ikke"

#: coff-rs6000.c:2887
#, c-format
msgid "%s: TOC reloc at 0x%x to symbol `%s' with no TOC entry"
msgstr "%s: TOC-relokering ved 0x%x til symbolet \"%s\" uden nogen TOC-post"

#: coff-rs6000.c:3652 coff64-rs6000.c:2175
msgid "%B: symbol `%s' has unrecognized smclas %d"
msgstr "%B: symbolet \"%s\" har ukendt smclas %d"

#: coff-tic4x.c:195 coff-tic54x.c:299 coff-tic80.c:458
#, c-format
msgid "Unrecognized reloc type 0x%x"
msgstr "Ukendt relokeringstype 0x%x"

#: coff-tic4x.c:240
#, c-format
msgid "%s: warning: illegal symbol index %ld in relocs"
msgstr "%s: advarsel: ikke tilladt symbolindeks %ld i relokeringerne"

#: coff-w65.c:367
#, c-format
msgid "ignoring reloc %s\n"
msgstr "ignorerer relokering %s\n"

#: coffcode.h:973
msgid "%B: warning: COMDAT symbol '%s' does not match section name '%s'"
msgstr "%B: advarsel: COMDAT-symbol \"%s\" passer ikke til sektionsnavnet \"%s\""

#. Generate a warning message rather using the 'unhandled'
#. variable as this will allow some .sys files generate by
#. other toolchains to be processed.  See bugzilla issue 196.
#: coffcode.h:1197
msgid "%B: Warning: Ignoring section flag IMAGE_SCN_MEM_NOT_PAGED in section %s"
msgstr "%B: Advarsel: Ignorerer sektionsflag IMAGE_SCN_MEM_NOT_PAGED i sektionen %s"

#: coffcode.h:1264
msgid "%B (%s): Section flag %s (0x%x) ignored"
msgstr "%B (%s): Sektionsflag %s (0x%x) ignoreret"

#: coffcode.h:2390
#, c-format
msgid "Unrecognized TI COFF target id '0x%x'"
msgstr "Ukendt TI COFF-mål-id \"0x%x\""

#: coffcode.h:2704
msgid "%B: reloc against a non-existant symbol index: %ld"
msgstr "%B: relokering mod et ikke-eksisterende symbolindeks: %ld"

#: coffcode.h:3262
msgid "%B: too many sections (%d)"
msgstr "%B: for mange sektioner (%d)"

#: coffcode.h:3676
msgid "%B: section %s: string table overflow at offset %ld"
msgstr "%B: sektion %s: overløb i strengtabel ved afsæt %ld"

#: coffcode.h:4481
msgid "%B: warning: line number table read failed"
msgstr "%B: advarsel: læsning af linjenummertabel mislykkedes"

#: coffcode.h:4511
msgid "%B: warning: illegal symbol index %ld in line numbers"
msgstr "%B: advarsel: illegalt symbolindeks %ld i linjetal"

#: coffcode.h:4525
msgid "%B: warning: duplicate line number information for `%s'"
msgstr "%B: advarsel: dobbelt linjenummersinformation for \"%s\""

#: coffcode.h:4916
msgid "%B: Unrecognized storage class %d for %s symbol `%s'"
msgstr "%B: Ukendt lagringsklasse %d for %s-symbolet \"%s\""

#: coffcode.h:5042
msgid "warning: %B: local symbol `%s' has no section"
msgstr "advarsel: %B: lokalt symbol \"%s\" har ingen sektion"

#: coffcode.h:5186
msgid "%B: illegal relocation type %d at address 0x%lx"
msgstr "%B: ikke tilladt relokeringstype %d på adresse 0x%lx"

#: coffgen.c:1573
msgid "%B: bad string table size %lu"
msgstr "%B: fejlagtig strengtabelstørrelse %lu"

#: cofflink.c:524 elflink.c:4339
msgid "Warning: type of symbol `%s' changed from %d to %d in %B"
msgstr "Advarsel: typen på symbol \"%s\" ændredes fra %d til %d i %B"

#: cofflink.c:2321
msgid "%B: relocs in section `%A', but it has no contents"
msgstr "%B: relokeringer i sektionen \"%s\", men den har intet indhold"

#: cofflink.c:2652 coffswap.h:826
#, c-format
msgid "%s: %s: reloc overflow: 0x%lx > 0xffff"
msgstr "%s: %s: relokering giver overløb: 0x%lx > 0xffff"

#: cofflink.c:2661 coffswap.h:812
#, c-format
msgid "%s: warning: %s: line number overflow: 0x%lx > 0xffff"
msgstr "%s: advarsel: %s: linjenummer giver overløb: 0x%lx > 0xffff"

#: cpu-arm.c:189 cpu-arm.c:200
msgid "error: %B is compiled for the EP9312, whereas %B is compiled for XScale"
msgstr "fejl: %B kompileret til EP9312, mens %B er kompileret til XScale"

#: cpu-arm.c:333
#, c-format
msgid "warning: unable to update contents of %s section in %s"
msgstr "advarsel: kan ikke opdatere indholdet af %s-sektion i %s"

#: dwarf2.c:490
#, c-format
msgid "Dwarf Error: Can't find %s section."
msgstr "Dwarf-fejl: Kan ikke finde %s-sektion."

#: dwarf2.c:518
#, c-format
msgid "Dwarf Error: Offset (%lu) greater than or equal to %s size (%lu)."
msgstr "Dwarf-fejl: Afsæt (%lu) større end eller lig med %s-størrelse (%lu)."

#: dwarf2.c:940
#, c-format
msgid "Dwarf Error: Invalid or unhandled FORM value: %u."
msgstr "Dwarf-fejl: Ugyldig eller ubehandlet FORM-værdi: %u."

#: dwarf2.c:1191
msgid "Dwarf Error: mangled line number section (bad file number)."
msgstr "Dwarf-fejl: vanskabt linjenummerssektion (fejlagtigt filnummer)."

#: dwarf2.c:1443
#, c-format
msgid "Dwarf Error: Unhandled .debug_line version %d."
msgstr "Dwarf-fejl: Uhåndteret .debug_line-version %d."

#: dwarf2.c:1465
msgid "Dwarf Error: Invalid maximum operations per instruction."
msgstr "Dwarf-fejl: Ugyldigt maksimalt antal operationer per instruktion."

#: dwarf2.c:1652
msgid "Dwarf Error: mangled line number section."
msgstr "Dwarf-fejl: vanskabt linjenummerssektion."

#: dwarf2.c:1978 dwarf2.c:2098 dwarf2.c:2382
#, c-format
msgid "Dwarf Error: Could not find abbrev number %u."
msgstr "Dwarf-fejl: Kunne ikke finde forkortelsesnumret %u."

#: dwarf2.c:2343
#, c-format
msgid "Dwarf Error: found dwarf version '%u', this reader only handles version 2, 3 and 4 information."
msgstr "Dwarf-fejl: fandt dwarf version \"%u\", men denne læser kan kun håndtere information fra version 2, 3 og 4."

#: dwarf2.c:2350
#, c-format
msgid "Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."
msgstr "Dwarf-fejl: fandt adressestørrelsen \"%u\", denne læser kan ikke håndtere størrelser større end \"%u\"."

#: dwarf2.c:2373
#, c-format
msgid "Dwarf Error: Bad abbrev number: %u."
msgstr "Dwarf-fejl: Fejlagtigt forkortelsesnummer: %u."

#: ecoff.c:1237
#, c-format
msgid "Unknown basic type %d"
msgstr "Ukendt grundtype %d"

#: ecoff.c:1494
#, c-format
msgid ""
"\n"
"      End+1 symbol: %ld"
msgstr ""
"\n"
"      Symbol slut+1: %ld"

#: ecoff.c:1501 ecoff.c:1504
#, c-format
msgid ""
"\n"
"      First symbol: %ld"
msgstr ""
"\n"
"      Første symbol: %ld"

#: ecoff.c:1516
#, c-format
msgid ""
"\n"
"      End+1 symbol: %-7ld   Type:  %s"
msgstr ""
"\n"
"      Symbol slut+1: %-7ld  Type:  %s"

#: ecoff.c:1523
#, c-format
msgid ""
"\n"
"      Local symbol: %ld"
msgstr ""
"\n"
"      Lokalt symbol: %ld"

#: ecoff.c:1531
#, c-format
msgid ""
"\n"
"      struct; End+1 symbol: %ld"
msgstr ""
"\n"
"      struct; symbol slut+1: %ld"

#: ecoff.c:1536
#, c-format
msgid ""
"\n"
"      union; End+1 symbol: %ld"
msgstr ""
"\n"
"      union; symbol slut+1: %ld"

#: ecoff.c:1541
#, c-format
msgid ""
"\n"
"      enum; End+1 symbol: %ld"
msgstr ""
"\n"
"      enum; symbol slut+1: %ld"

#: ecoff.c:1547
#, c-format
msgid ""
"\n"
"      Type: %s"
msgstr ""
"\n"
"      Type: %s"

#: elf-attrs.c:569
msgid "error: %B: Object has vendor-specific contents that must be processed by the '%s' toolchain"
msgstr "fejl: %B: Objekt har leverandørspecifikt indhold, som skal behandles med  '%s'-værktøjerne"

#: elf-attrs.c:578
msgid "error: %B: Object tag '%d, %s' is incompatible with tag '%d, %s'"
msgstr "fejl: %B: Objektmærke \"%d, %d\" er ikke kompatibelt med mærket \"%d, %s\""

#: elf-eh-frame.c:913
msgid "%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"
msgstr "%P: fejl i %B(%A); ingen .eh_frame_hdr-tabel vil blive oprettet.\n"

#: elf-eh-frame.c:1165
msgid "%P: fde encoding in %B(%A) prevents .eh_frame_hdr table being created.\n"
msgstr "%P: fde-kodning i %B(%A) forhindrer .eh_frame_hdr-tabel i at blive oprettet.\n"

#: elf-ifunc.c:179
msgid "%F%P: dynamic STT_GNU_IFUNC symbol `%s' with pointer equality in `%B' can not be used when making an executable; recompile with -fPIE and relink with -pie\n"
msgstr "%F%P: dynamisk STT_GNU_IFUNC-symbol \"%s\" med pointerlighed i \"%B\" kan ikke bruges når der oprettes en eksekverbar fil; genkompilér med -fPIE og genlænk med -pie\n"

#: elf-m10200.c:450 elf-m10300.c:1560 elf32-avr.c:1263 elf32-bfin.c:3193
#: elf32-cr16.c:1482 elf32-cr16c.c:780 elf32-cris.c:2077 elf32-crx.c:922
#: elf32-d10v.c:509 elf32-fr30.c:609 elf32-frv.c:4111 elf32-h8300.c:509
#: elf32-i860.c:1211 elf32-ip2k.c:1468 elf32-iq2000.c:684 elf32-lm32.c:1168
#: elf32-m32c.c:553 elf32-m32r.c:3111 elf32-m68hc1x.c:1138 elf32-mep.c:534
#: elf32-microblaze.c:1231 elf32-moxie.c:282 elf32-msp430.c:486 elf32-mt.c:395
#: elf32-openrisc.c:404 elf32-score.c:2731 elf32-score7.c:2540
#: elf32-spu.c:5042 elf32-v850.c:2143 elf32-xstormy16.c:941 elf64-mmix.c:1522
msgid "internal error: out of range error"
msgstr "intern fejl: uden for intervallet"

#: elf-m10200.c:454 elf-m10300.c:1564 elf32-avr.c:1267 elf32-bfin.c:3197
#: elf32-cr16.c:1486 elf32-cr16c.c:784 elf32-cris.c:2081 elf32-crx.c:926
#: elf32-d10v.c:513 elf32-fr30.c:613 elf32-frv.c:4115 elf32-h8300.c:513
#: elf32-i860.c:1215 elf32-iq2000.c:688 elf32-lm32.c:1172 elf32-m32c.c:557
#: elf32-m32r.c:3115 elf32-m68hc1x.c:1142 elf32-mep.c:538
#: elf32-microblaze.c:1235 elf32-moxie.c:286 elf32-msp430.c:490
#: elf32-openrisc.c:408 elf32-score.c:2735 elf32-score7.c:2544
#: elf32-spu.c:5046 elf32-v850.c:2147 elf32-xstormy16.c:945 elf64-mmix.c:1526
#: elfxx-mips.c:9186
msgid "internal error: unsupported relocation error"
msgstr "intern fejl: relokeringen understøttes ikke"

#: elf-m10200.c:458 elf32-cr16.c:1490 elf32-cr16c.c:788 elf32-crx.c:930
#: elf32-d10v.c:517 elf32-h8300.c:517 elf32-lm32.c:1176 elf32-m32r.c:3119
#: elf32-m68hc1x.c:1146 elf32-microblaze.c:1239 elf32-score.c:2739
#: elf32-score7.c:2548 elf32-spu.c:5050
msgid "internal error: dangerous error"
msgstr "intern fejl: farlig fejl"

#: elf-m10200.c:462 elf-m10300.c:1577 elf32-avr.c:1275 elf32-bfin.c:3205
#: elf32-cr16.c:1494 elf32-cr16c.c:792 elf32-cris.c:2089 elf32-crx.c:934
#: elf32-d10v.c:521 elf32-fr30.c:621 elf32-frv.c:4123 elf32-h8300.c:521
#: elf32-i860.c:1223 elf32-ip2k.c:1483 elf32-iq2000.c:696 elf32-lm32.c:1180
#: elf32-m32c.c:565 elf32-m32r.c:3123 elf32-m68hc1x.c:1150 elf32-mep.c:546
#: elf32-microblaze.c:1243 elf32-moxie.c:294 elf32-msp430.c:498 elf32-mt.c:403
#: elf32-openrisc.c:416 elf32-score.c:2748 elf32-score7.c:2552
#: elf32-spu.c:5054 elf32-v850.c:2167 elf32-xstormy16.c:953 elf64-mmix.c:1534
msgid "internal error: unknown error"
msgstr "intern fejl: ukendt fejl"

#: elf-m10300.c:1504 elf32-arm.c:9098 elf32-i386.c:4081 elf32-m32r.c:2604
#: elf32-m68k.c:4156 elf32-ppc.c:8089 elf32-s390.c:3010 elf32-sh.c:4223
#: elf32-xtensa.c:3067 elf64-ppc.c:13115 elf64-s390.c:2985 elf64-sh64.c:1636
#: elf64-x86-64.c:3719 elfxx-sparc.c:3806
msgid "%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"
msgstr "%B(%A+0x%lx): uløselig %s-relokering mod symbol \"%s\""

#: elf-m10300.c:1569
msgid "error: inappropriate relocation type for shared library (did you forget -fpic?)"
msgstr "fejl: upassende relokeringstype til delt bibliotek (glemte du -fpic?)"

#: elf-m10300.c:1572
msgid "internal error: suspicious relocation type used in shared library"
msgstr "intern fejl: mistænkelig relokeringstype brugt i delt bibliotek"

#: elf-m10300.c:4372 elf32-arm.c:11392 elf32-cr16.c:2451 elf32-cris.c:3044
#: elf32-hppa.c:1894 elf32-i370.c:503 elf32-i386.c:2036 elf32-lm32.c:1868
#: elf32-m32r.c:1927 elf32-m68k.c:3252 elf32-ppc.c:4994 elf32-s390.c:1652
#: elf32-sh.c:2931 elf32-vax.c:1040 elf64-ppc.c:6483 elf64-s390.c:1635
#: elf64-sh64.c:3377 elf64-x86-64.c:1871 elfxx-sparc.c:2104
#, c-format
msgid "dynamic variable `%s' is zero size"
msgstr "dynamisk variabel \"%s\" har størrelse nul"

#: elf.c:334
msgid "%B: invalid string offset %u >= %lu for section `%s'"
msgstr "%B: ugyldigt strengafsæt %u >= %lu for sektionen \"%s\""

#: elf.c:446
msgid "%B symbol number %lu references nonexistent SHT_SYMTAB_SHNDX section"
msgstr "%B-symbol nummer %lu refererer SHT_SYMTAB_SHNDX-sektion, der ikke findes"

#: elf.c:602
msgid "%B: Corrupt size field in group section header: 0x%lx"
msgstr "%B: Beskadiget størrelsesfelt i gruppesektionshoved: 0x%lx"

#: elf.c:638
msgid "%B: invalid SHT_GROUP entry"
msgstr "%B: ugyldig SHT_GROUP-post"

#: elf.c:708
msgid "%B: no group info for section %A"
msgstr "%B: ingen gruppeinformation for sektionen %A"

#: elf.c:737 elf.c:3090 elflink.c:10062
msgid "%B: warning: sh_link not set for section `%A'"
msgstr "%B: advarsel: sh_link ikke givet for sektionen \"%s\""

#: elf.c:756
msgid "%B: sh_link [%d] in section `%A' is incorrect"
msgstr "%B: sh_link [%d] sektionen \"%s\" er forkert"

#: elf.c:791
msgid "%B: unknown [%d] section `%s' in group [%s]"
msgstr "%B: ukendt [%d] sektion \"%s\" i gruppe [%s]"

#: elf.c:1041
msgid "%B: unable to initialize commpress status for section %s"
msgstr "%B: kan ikke initiere commpress-status for sektion %s"

#: elf.c:1050
msgid "%B: unable to initialize decommpress status for section %s"
msgstr "%B: kan ikke klargøre afkomprimeringsstatus for sektion %s"

#: elf.c:1158
#, c-format
msgid ""
"\n"
"Program Header:\n"
msgstr ""
"\n"
"Programhoved:\n"

#: elf.c:1200
#, c-format
msgid ""
"\n"
"Dynamic Section:\n"
msgstr ""
"\n"
"Dynamisk sektion:\n"

#: elf.c:1336
#, c-format
msgid ""
"\n"
"Version definitions:\n"
msgstr ""
"\n"
"Versionsdefinitioner:\n"

#: elf.c:1361
#, c-format
msgid ""
"\n"
"Version References:\n"
msgstr ""
"\n"
"Versionsreferencer:\n"

#: elf.c:1366
#, c-format
msgid "  required from %s:\n"
msgstr "  kræves fra %s:\n"

#: elf.c:1773
msgid "%B: invalid link %lu for reloc section %s (index %u)"
msgstr "%B: ugyldig lænke %lu for relokeringssektion %s (indeks %u)"

#: elf.c:1943
msgid "%B: don't know how to handle allocated, application specific section `%s' [0x%8x]"
msgstr "%B: ved ikke hvordan allokeret, programspecifik sektion \"%s\" [0x%8x] skal håndteres"

#: elf.c:1955
msgid "%B: don't know how to handle processor specific section `%s' [0x%8x]"
msgstr "%B: ved ikke hvordan processorspecifik sektion \"%s\" [0x%8x] skal håndteres"

#: elf.c:1966
msgid "%B: don't know how to handle OS specific section `%s' [0x%8x]"
msgstr "%B: ved ikke hvordan OS-specifik sektion \"%s\" [0x%8x] skal håndteres"

#: elf.c:1976
msgid "%B: don't know how to handle section `%s' [0x%8x]"
msgstr "%B: ved ikke hvordan sektion \"%s\" [0x%8x] skal håndteres"

#: elf.c:2603
#, c-format
msgid "warning: section `%A' type changed to PROGBITS"
msgstr "advarsel: typen af sektionen \"%A\" ændret til PROGBITS"

#: elf.c:3047
msgid "%B: sh_link of section `%A' points to discarded section `%A' of `%B'"
msgstr "%B: sh_link af sektion \"%A\" peger på forkastet sektion \"%A\" i \"%B\""

#: elf.c:3070
msgid "%B: sh_link of section `%A' points to removed section `%A' of `%B'"
msgstr "%B: sh_link af sektion \"%A\" peger på fjernet sektion \"%A\" af \"%B\""

#: elf.c:4480
msgid "%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"
msgstr "%B: Første sektion i segmentet PT_DYNAMIC er ikke .dynamic-sektionen"

#: elf.c:4507
msgid "%B: Not enough room for program headers, try linking with -N"
msgstr "%s: Ikke tilstrækkeligt med plads til programhoveder, forsøg at lænke med -N"

#: elf.c:4594
msgid "%B: section %A lma %#lx adjusted to %#lx"
msgstr "%B: sektion %A lma %#lx justeret til %#lx"

#: elf.c:4713
msgid "%B: section `%A' can't be allocated in segment %d"
msgstr "%B: sektion \"%A\" kan ikke allokeres i segment %d"

#: elf.c:4761
msgid "%B: warning: allocated section `%s' not in segment"
msgstr "%B: advarsel: allokeret sektion \"%s\" ikke i segment"

#: elf.c:5257
msgid "%B: symbol `%s' required but not present"
msgstr "%B: symbol \"%s\" kræves, men er ikke tilstede"

#: elf.c:5595
msgid "%B: warning: Empty loadable segment detected, is this intentional ?\n"
msgstr "%B: advarsel: Tomt indlæseligt segment opdaget, er dette meningen?\n"

#: elf.c:6622
#, c-format
msgid "Unable to find equivalent output section for symbol '%s' from section '%s'"
msgstr "Kunne ikke finde ækvivalent uddatasektion for symbolet \"%s\" fra sektionen \"%s\""

#: elf.c:7611
msgid "%B: unsupported relocation type %s"
msgstr "%B: relokeringstypen %s understøttes ikke"

#: elf32-arm.c:3183
msgid ""
"%B(%s): warning: interworking not enabled.\n"
"  first occurrence: %B: Thumb call to ARM"
msgstr ""
"%s(%s): advarsel: samvirken (interworking) er ikke aktiveret.\n"
"  første forekomst: %B: Thumb-kald til ARM"

#: elf32-arm.c:3226
msgid ""
"%B(%s): warning: interworking not enabled.\n"
"  first occurrence: %B: ARM call to Thumb"
msgstr ""
"%B(%s): advarsel: samvirken (interworking) er ikke aktiveret.\n"
"  første forekomst: %B: ARM-kald til Thumb"

#: elf32-arm.c:3432 elf32-arm.c:4807
#, c-format
msgid "%s: cannot create stub entry %s"
msgstr "%s: kan ikke oprette stub-posten %s"

#: elf32-arm.c:4923
#, c-format
msgid "unable to find THUMB glue '%s' for '%s'"
msgstr "kan ikke finde finde THUMB-klistret \"%s\" til \"%s\""

#: elf32-arm.c:4959
#, c-format
msgid "unable to find ARM glue '%s' for '%s'"
msgstr "kan ikke finde ARM-klistret \"%s\" til \"%s\""

#: elf32-arm.c:5485
msgid "%B: BE8 images only valid in big-endian mode."
msgstr "%B: BE8-aftryk er kun gyldige i big-endian-tilstanden."

#. Give a warning, but do as the user requests anyway.
#: elf32-arm.c:5715
msgid "%B: warning: selected VFP11 erratum workaround is not necessary for target architecture"
msgstr "%B: advarsel: valgte omgåelse af VFP11-erratum er ikke nødvendig for målarkitekturen"

#: elf32-arm.c:6259 elf32-arm.c:6279
msgid "%B: unable to find VFP11 veneer `%s'"
msgstr "%B: kan ikke finde VFP11-veneer \"%s\""

#: elf32-arm.c:6327
#, c-format
msgid "Invalid TARGET2 relocation type '%s'."
msgstr "Ugyldig TARGET2-relokeringstype \"%s\"."

#: elf32-arm.c:6411
msgid ""
"%B(%s): warning: interworking not enabled.\n"
"  first occurrence: %B: thumb call to arm"
msgstr ""
"%B(%s): advarsel: samvirken (interworking) er ikke aktiveret.\n"
"  første forekomst: %B: thumb-kald til arm"

#: elf32-arm.c:7130
msgid "\\%B: Warning: Arm BLX instruction targets Arm function '%s'."
msgstr "\\%B: Advarsel: Arm BLX-instruktion bruger Arm-funktionen \"%s\" som mål."

#: elf32-arm.c:7541
msgid "%B: Warning: Thumb BLX instruction targets thumb function '%s'."
msgstr "%B: Advarsel: Thumb BLX-instruktionen bruger thumb-funktionen \"%s\" som mål."

#: elf32-arm.c:8223
msgid "%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"
msgstr "%B(%A+0x%lx): Relokering af R_ARM_TLS_LE32 er ikke tilladt i delt objekt"

#: elf32-arm.c:8438
msgid "%B(%A+0x%lx): Only ADD or SUB instructions are allowed for ALU group relocations"
msgstr "%B(%A+0x%lx): Kun instruktionerne ADD og SUB er tilladt for ALU-grupperelokeringer"

#: elf32-arm.c:8478 elf32-arm.c:8565 elf32-arm.c:8648 elf32-arm.c:8733
msgid "%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"
msgstr "%B(%A+0x%lx): Overløb ved opdeling af 0x%lx til grupperelokering %s"

#: elf32-arm.c:8963 elf32-sh.c:4112 elf64-sh64.c:1544
msgid "%B(%A+0x%lx): %s relocation against SEC_MERGE section"
msgstr "%B(%A+0x%lx): %s-relokering mod SEC_MERGE-sektion"

#: elf32-arm.c:9074 elf32-m68k.c:4191 elf32-xtensa.c:2805 elf64-ppc.c:11689
msgid "%B(%A+0x%lx): %s used with TLS symbol %s"
msgstr "%B(%A+0x%lx): %s bruges med TLS-symbol %s"

#: elf32-arm.c:9075 elf32-m68k.c:4192 elf32-xtensa.c:2806 elf64-ppc.c:11690
msgid "%B(%A+0x%lx): %s used with non-TLS symbol %s"
msgstr "%B(%A+0x%lx): %s bruges med ikke-TLS-symbol %s"

#: elf32-arm.c:9132 elf32-tic6x.c:1632
msgid "out of range"
msgstr "uden for gyldigt interval"

#: elf32-arm.c:9136 elf32-tic6x.c:1636
msgid "unsupported relocation"
msgstr "relokeringen understøttes ikke"

#: elf32-arm.c:9144 elf32-tic6x.c:1644
msgid "unknown error"
msgstr "ukendt fejl"

#: elf32-arm.c:9569
msgid "Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"
msgstr "Advarsel: Fjerner samvirkendeflaget (interworking) i %B eftersom ikke-samvirkende kode i %B er lænket med det"

#: elf32-arm.c:9663
msgid "%B: Unknown mandatory EABI object attribute %d"
msgstr "%B: Ukendt obligatorisk EABI-objekt-attribut %d"

#: elf32-arm.c:9671
msgid "Warning: %B: Unknown EABI object attribute %d"
msgstr "Advarsel: %B: Ukendt EABI-objekt-attribut %d"

#: elf32-arm.c:9852
msgid "error: %B: Unknown CPU architecture"
msgstr "Fejl: %B: Ukendt CPU-arkitektur"

#: elf32-arm.c:9890
msgid "error: %B: Conflicting CPU architectures %d/%d"
msgstr "fejl: %B: Modstridende CPU-arkitekturer %d/%d"

#: elf32-arm.c:9942
msgid "Error: %B has both the current and legacy Tag_MPextension_use attributes"
msgstr "Fejl: %B har både nuværende og ældre Tag_MPextension_use-attributter"

#: elf32-arm.c:9967
msgid "error: %B uses VFP register arguments, %B does not"
msgstr "fejl: %B bruger VFP-registerargumenter, mens %B ikke gør"

#: elf32-arm.c:10112
msgid "error: %B: unable to merge virtualization attributes with %B"
msgstr "fejl: %B: kan ikke sammenføje virtualiseringsattributter med %B"

#: elf32-arm.c:10138
msgid "error: %B: Conflicting architecture profiles %c/%c"
msgstr "fejl: %B: Modstridende arkitekturprofiler %c/%c"

#: elf32-arm.c:10239
msgid "Warning: %B: Conflicting platform configuration"
msgstr "Advarsel: %B: Modstridende platformkonfiguration"

#: elf32-arm.c:10248
msgid "error: %B: Conflicting use of R9"
msgstr "fejl: %B: Modstridende brug af R9"

#: elf32-arm.c:10260
msgid "error: %B: SB relative addressing conflicts with use of R9"
msgstr "fejl: %B: SB-relativ adressering strider med brugen af R9"

#: elf32-arm.c:10273
msgid "warning: %B uses %u-byte wchar_t yet the output is to use %u-byte wchar_t; use of wchar_t values across objects may fail"
msgstr "advarsel: %B bruger wchar_t på %u byte, men uddata skal bruge wchar_t på %u byte; brug af wchar_t-værdier på tværs af objekter kan gå galt"

#: elf32-arm.c:10304
msgid "warning: %B uses %s enums yet the output is to use %s enums; use of enum values across objects may fail"
msgstr "advarsel: %B bruger %s-enum'er, men uddata skal bruge %s-enum'er; brug af enum-værdier på tværs af objekter kan gå galt"

#: elf32-arm.c:10316
msgid "error: %B uses iWMMXt register arguments, %B does not"
msgstr "fejl: %B bruger iWMMXt-registerargumenter, mens %B ikke gør"

#: elf32-arm.c:10333
msgid "error: fp16 format mismatch between %B and %B"
msgstr "fejl: uoverensstemmelse i fp16-format mellem %B og %B"

#: elf32-arm.c:10357
msgid "DIV usage mismatch between %B and %B"
msgstr "Uoverensstemmelse i DIV-forbrug mellem %B og %B"

#: elf32-arm.c:10376
msgid "%B has has both the current and legacy Tag_MPextension_use attributes"
msgstr "%B har både nuværende og ældre Tag_MPextension_use-attributter"

#. Ignore init flag - it may not be set, despite the flags field
#. containing valid data.
#. Ignore init flag - it may not be set, despite the flags field containing valid data.
#: elf32-arm.c:10468 elf32-bfin.c:5065 elf32-cris.c:4162 elf32-m68hc1x.c:1282
#: elf32-m68k.c:1235 elf32-score.c:3996 elf32-score7.c:3803 elf32-vax.c:528
#: elfxx-mips.c:12842
#, c-format
msgid "private flags = %lx:"
msgstr "private flag = %lx:"

#: elf32-arm.c:10477
#, c-format
msgid " [interworking enabled]"
msgstr " [samvirkende er aktiveret]"

#: elf32-arm.c:10485
#, c-format
msgid " [VFP float format]"
msgstr " [VFP-flydendetalsformat]"

#: elf32-arm.c:10487
#, c-format
msgid " [Maverick float format]"
msgstr " [Maverick-flydendetalformat]"

#: elf32-arm.c:10489
#, c-format
msgid " [FPA float format]"
msgstr " [FPA-flydendetalformat]"

#: elf32-arm.c:10498
#, c-format
msgid " [new ABI]"
msgstr " [nyt ABI]"

#: elf32-arm.c:10501
#, c-format
msgid " [old ABI]"
msgstr " [gammelt ABI]"

#: elf32-arm.c:10504
#, c-format
msgid " [software FP]"
msgstr " [programmeret FP]"

#: elf32-arm.c:10513
#, c-format
msgid " [Version1 EABI]"
msgstr " [Version1 EABI]"

#: elf32-arm.c:10516 elf32-arm.c:10527
#, c-format
msgid " [sorted symbol table]"
msgstr " [sorteret symboltabel]"

#: elf32-arm.c:10518 elf32-arm.c:10529
#, c-format
msgid " [unsorted symbol table]"
msgstr " [usorteret symboltabel]"

#: elf32-arm.c:10524
#, c-format
msgid " [Version2 EABI]"
msgstr " [Version2 EABI]"

#: elf32-arm.c:10532
#, c-format
msgid " [dynamic symbols use segment index]"
msgstr " [dynamiske symboler bruger segmentindeks]"

#: elf32-arm.c:10535
#, c-format
msgid " [mapping symbols precede others]"
msgstr " [mapningssymboler foretrækkes frem for andre]"

#: elf32-arm.c:10542
#, c-format
msgid " [Version3 EABI]"
msgstr " [Version3 EABI]"

#: elf32-arm.c:10546
#, c-format
msgid " [Version4 EABI]"
msgstr " [Version4 EABI]"

#: elf32-arm.c:10550
#, c-format
msgid " [Version5 EABI]"
msgstr " [Version5 EABI]"

#: elf32-arm.c:10553
#, c-format
msgid " [BE8]"
msgstr " [BE8]"

#: elf32-arm.c:10556
#, c-format
msgid " [LE8]"
msgstr " [LE8]"

#: elf32-arm.c:10562
#, c-format
msgid " <EABI version unrecognised>"
msgstr " <EABI-version genkendes ikke>"

#: elf32-arm.c:10569
#, c-format
msgid " [relocatable executable]"
msgstr " [relokérbar kørbar fil]"

#: elf32-arm.c:10572
#, c-format
msgid " [has entry point]"
msgstr " [har startpunkt]"

#: elf32-arm.c:10577
#, c-format
msgid "<Unrecognised flag bits set>"
msgstr "<Ukendte flagbit er sat>"

#: elf32-arm.c:10824 elf32-i386.c:1322 elf32-s390.c:1000 elf32-xtensa.c:1009
#: elf64-s390.c:960 elf64-x86-64.c:1105 elfxx-sparc.c:1370
msgid "%B: bad symbol index: %d"
msgstr "%B: fejlagtigt symbolindeks: %d"

#: elf32-arm.c:10946 elf64-x86-64.c:1265 elf64-x86-64.c:1434 elfxx-mips.c:7942
msgid "%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"
msgstr "%B: relokeringen %s mod \"%s\" kan ikke bruges når et delt objekt oprettes; genkompilér med -fPIC"

#: elf32-arm.c:11948
#, c-format
msgid "Errors encountered processing file %s"
msgstr "Stødte på fejl ved behandling af filen %s"

#: elf32-arm.c:13334
msgid "%B: error: Cortex-A8 erratum stub is allocated in unsafe location"
msgstr "%B: fejl: Cortex-A8-erratum-stub er allokeret på et usikkert sted"

#. There's not much we can do apart from complain if this
#. happens.
#: elf32-arm.c:13361
msgid "%B: error: Cortex-A8 erratum stub out of range (input file too large)"
msgstr "%B: fejl: Cortex-A8-erratum-stub er uden for gyldigt interval (inddatafil for stor)"

#: elf32-arm.c:13455 elf32-arm.c:13477
msgid "%B: error: VFP11 veneer out of range"
msgstr "%B: fejl: VFP11-veneer uden for gyldigt interval"

#: elf32-arm.c:14002
msgid "error: %B is already in final BE8 format"
msgstr "fejl: %B er allerede i endeligt BE8-format"

#: elf32-arm.c:14078
msgid "error: Source object %B has EABI version %d, but target %B has EABI version %d"
msgstr "fejl: Kildeobjektet %B har EABI-version %d, men målet %B har EABI-version %d"

#: elf32-arm.c:14094
msgid "error: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"
msgstr "fejl: %B er kompileret til APCS-%d, mens målet %B bruger APCS-%d"

#: elf32-arm.c:14119
msgid "error: %B uses VFP instructions, whereas %B does not"
msgstr "fejl: %B bruger VFP-instruktioner, mens %B ikke gør"

#: elf32-arm.c:14123
msgid "error: %B uses FPA instructions, whereas %B does not"
msgstr "fejl: %B bruger FPA-instruktioner, mens %B ikke gør"

#: elf32-arm.c:14133
msgid "error: %B uses Maverick instructions, whereas %B does not"
msgstr "fejl: %B bruger Maverick-instruktioner, mens %B ikke gør"

#: elf32-arm.c:14137
msgid "error: %B does not use Maverick instructions, whereas %B does"
msgstr "fejl: %B bruger ikke Maverick-instruktioner, men %B gør"

#: elf32-arm.c:14156
msgid "error: %B uses software FP, whereas %B uses hardware FP"
msgstr "fejl: %B bruger flydende tal i software, mens %B bruger hardware"

#: elf32-arm.c:14160
msgid "error: %B uses hardware FP, whereas %B uses software FP"
msgstr "fejl: %B bruger flydende tal i hardware, mens %B bruger software"

#: elf32-avr.c:1271 elf32-bfin.c:3201 elf32-cris.c:2085 elf32-fr30.c:617
#: elf32-frv.c:4119 elf32-i860.c:1219 elf32-ip2k.c:1479 elf32-iq2000.c:692
#: elf32-m32c.c:561 elf32-mep.c:542 elf32-moxie.c:290 elf32-msp430.c:494
#: elf32-mt.c:399 elf32-openrisc.c:412 elf32-v850.c:2151 elf32-xstormy16.c:949
#: elf64-mmix.c:1530
msgid "internal error: dangerous relocation"
msgstr "intern fejl: farlig relokering"

#: elf32-avr.c:2400 elf32-hppa.c:598 elf32-m68hc1x.c:166 elf64-ppc.c:4175
msgid "%B: cannot create stub entry %s"
msgstr "%B: kan ikke oprette stub-post %s"

#: elf32-bfin.c:1575
msgid "%B(%A+0x%lx): unresolvable relocation against symbol `%s'"
msgstr "%B(%A+0x%lx): uløselig relokering mod symbol \"%s\""

#: elf32-bfin.c:1608 elf32-i386.c:4123 elf32-m68k.c:4233 elf32-s390.c:3062
#: elf64-s390.c:3037 elf64-x86-64.c:3759
msgid "%B(%A+0x%lx): reloc against `%s': error %d"
msgstr "%B(%A+0x%lx): relokering mod \"%s\": fejl %d"

#: elf32-bfin.c:2707
msgid "%B: relocation at `%A+0x%x' references symbol `%s' with nonzero addend"
msgstr "%B: relokering ved \"%A+0x%x\" refererer til symbolet \"%s\" med addend forskellig fra nul"

#: elf32-bfin.c:2721 elf32-frv.c:2901
msgid "relocation references symbol not defined in the module"
msgstr "relokering refererer symbol som ikke er defineret i modulet"

#: elf32-bfin.c:2818
msgid "R_BFIN_FUNCDESC references dynamic symbol with nonzero addend"
msgstr "R_BFIN_FUNCDESC refererer til dynamisk symbol med addend forskellig fra nul"

#: elf32-bfin.c:2859 elf32-bfin.c:2982 elf32-frv.c:3638 elf32-frv.c:3759
msgid "cannot emit fixups in read-only section"
msgstr "kan ikke udsende fixup'er i skrivebeskyttet sektion %s"

#: elf32-bfin.c:2890 elf32-bfin.c:3020 elf32-frv.c:3669 elf32-frv.c:3803
#: elf32-lm32.c:1103 elf32-sh.c:5021
msgid "cannot emit dynamic relocations in read-only section"
msgstr "kan ikke udsende dynamiske relokeringer i skrivebeskyttet sektion"

#: elf32-bfin.c:2940
msgid "R_BFIN_FUNCDESC_VALUE references dynamic symbol with nonzero addend"
msgstr "R_BFIN_FUNCDESC_VALUE refererer dynamisk symbol med addend forskellig fra nul"

#: elf32-bfin.c:3105
msgid "relocations between different segments are not supported"
msgstr "relokeringer mellem forskellige segmenter understøttes ikke"

#: elf32-bfin.c:3106
msgid "warning: relocation references a different segment"
msgstr "advarsel: relokering refererer til et andet segment"

#: elf32-bfin.c:4957 elf32-frv.c:6406
msgid "%B: unsupported relocation type %i"
msgstr "%B: relokeringstypen %i understøttes ikke"

#: elf32-bfin.c:5111 elf32-frv.c:6814
#, c-format
msgid "%s: cannot link non-fdpic object file into fdpic executable"
msgstr "%s: kan ikke lænke ikke-fdpic-objektfil ind i fdpic-eksekveringsfil"

#: elf32-bfin.c:5115 elf32-frv.c:6818
#, c-format
msgid "%s: cannot link fdpic object file into non-fdpic executable"
msgstr "%s: kan ikke lænke fdpic-objektfil ind i en ikke-fdpic-eksekveringsfil"

#: elf32-cris.c:1172
msgid "%B, section %A: unresolvable relocation %s against symbol `%s'"
msgstr "%B, sektion %A: uløselig relokering %s mod symbol \"%s\""

#: elf32-cris.c:1234
msgid "%B, section %A: No PLT nor GOT for relocation %s against symbol `%s'"
msgstr "%B, sektion %A: Hverken nogen PLT eller GOT til relokering %s mod symbol \"%s\""

#: elf32-cris.c:1236
msgid "%B, section %A: No PLT for relocation %s against symbol `%s'"
msgstr "%B, sektion %A: Ingen PLT til relokering %s mod symbol \"%s\""

#: elf32-cris.c:1242 elf32-cris.c:1375 elf32-cris.c:1635 elf32-cris.c:1718
#: elf32-cris.c:1871
msgid "[whose name is lost]"
msgstr "[hvis navn er tabt]"

#: elf32-cris.c:1361
msgid "%B, section %A: relocation %s with non-zero addend %d against local symbol"
msgstr "%B, sektion %A: relokering %s med ikke-tom addend %d mod lokalt symbol"

#: elf32-cris.c:1369 elf32-cris.c:1712 elf32-cris.c:1865
msgid "%B, section %A: relocation %s with non-zero addend %d against symbol `%s'"
msgstr "%B, sektion %A: relokering %s med ikke-tom addend %d mod symbol \"%s\""

#: elf32-cris.c:1395
msgid "%B, section %A: relocation %s is not allowed for global symbol: `%s'"
msgstr "%B, sektion %A: relokeringen %s er ikke tilladt for globalt symbol: \"%s\""

#: elf32-cris.c:1411
msgid "%B, section %A: relocation %s with no GOT created"
msgstr "%B, sektion %A: relokering %s oprettet uden nogen GOT"

#. We shouldn't get here for GCC-emitted code.
#: elf32-cris.c:1626
msgid "%B, section %A: relocation %s has an undefined reference to `%s', perhaps a declaration mixup?"
msgstr "%B, sektion %A: relokeringen %s har en udefineret reference til \"%s\". Måske er der noget galt med erklæringen?"

#: elf32-cris.c:1998
msgid "%B, section %A: relocation %s is not allowed for symbol: `%s' which is defined outside the program, perhaps a declaration mixup?"
msgstr "%B: relokeringen %A er ikke tilladt for symbol: \"%s\", som er defineret uden for programmet. Måske er der noget galt med erklæringen?"

#: elf32-cris.c:2051
msgid "(too many global variables for -fpic: recompile with -fPIC)"
msgstr "(for mange globale variable til -fpic: genkompilér med -fPIC)"

#: elf32-cris.c:2058
msgid "(thread-local data too big for -fpic or -msmall-tls: recompile with -fPIC or -mno-small-tls)"
msgstr "(trådlokale data er for store til -fpic eller -msmall-tls: genkompilér med -fPIC eller -mno-small-tls)"

#: elf32-cris.c:3248
msgid ""
"%B, section %A:\n"
"  v10/v32 compatible object %s must not contain a PIC relocation"
msgstr ""
"%B, sektion %A:\n"
"  v10/v32-kompatibelt objekt %s må ikke indeholde en PIC-relokering"

#: elf32-cris.c:3353
msgid ""
"%B, section %A:\n"
"  relocation %s not valid in a shared object; typically an option mixup, recompile with -fPIC"
msgstr ""
"%B, sektion %A:\n"
"  relokeringen %s er ikke gyldig i et delt objekt; dette er typisk en fejl i tilvalgende - genkompilér med -fPIC"

#: elf32-cris.c:3567
msgid ""
"%B, section %A:\n"
"  relocation %s should not be used in a shared object; recompile with -fPIC"
msgstr ""
"%B, sektion %A:\n"
"  relokeringen %s bør ikke bruges i et delt objekt; genoversæt med -fPIC"

#: elf32-cris.c:3992
msgid ""
"%B, section `%A', to symbol `%s':\n"
"  relocation %s should not be used in a shared object; recompile with -fPIC"
msgstr ""
"%B, sektion %A til symbol \"%s\":\n"
"  relokeringen %s bør ikke bruges i et delt objekt; genkompilér med -fPIC"

#: elf32-cris.c:4111
msgid "Unexpected machine number"
msgstr "Uventet maskinnummer"

#: elf32-cris.c:4165
#, c-format
msgid " [symbols have a _ prefix]"
msgstr " [symboler har et _-præfiks]"

#: elf32-cris.c:4168
#, c-format
msgid " [v10 and v32]"
msgstr " [v10 og v32]"

#: elf32-cris.c:4171
#, c-format
msgid " [v32]"
msgstr " [v32]"

#: elf32-cris.c:4216
msgid "%B: uses _-prefixed symbols, but writing file with non-prefixed symbols"
msgstr "%B: bruger symboler med _-præfiks, men skriver fil med symboler uden præfiks"

#: elf32-cris.c:4217
msgid "%B: uses non-prefixed symbols, but writing file with _-prefixed symbols"
msgstr "%B: bruger symboler uden præfiks, men skriver fil med symboler med _-præfiks"

#: elf32-cris.c:4236
msgid "%B contains CRIS v32 code, incompatible with previous objects"
msgstr "%B indeholder CRIS v32-kode, som er inkompatibel med tidligere objekter"

#: elf32-cris.c:4238
msgid "%B contains non-CRIS-v32 code, incompatible with previous objects"
msgstr "%B indeholder ikke-CRIS-v32-kode, som er inkompatibel med tidligere objekter"

#: elf32-frv.c:1509 elf32-frv.c:1658
msgid "relocation requires zero addend"
msgstr "relokering kræver addend på nul"

#: elf32-frv.c:2888
msgid "%B(%A+0x%x): relocation to `%s+%x' may have caused the error above"
msgstr "%B(%A+0x%x): relokering til \"%s+%x\" kan have forårsaget ovenstående fejl"

#: elf32-frv.c:2977
msgid "R_FRV_GETTLSOFF not applied to a call instruction"
msgstr "R_FRV_GETTLSOFF ikke anvendt til call-instruktion"

#: elf32-frv.c:3019
msgid "R_FRV_GOTTLSDESC12 not applied to an lddi instruction"
msgstr "R_FRV_GOTTLSDESC12 ikke anvendt til en lddi-instruktion"

#: elf32-frv.c:3090
msgid "R_FRV_GOTTLSDESCHI not applied to a sethi instruction"
msgstr "R_FRV_GOTTLSDESCHI ikke anvendt til en sethi-instruktion"

#: elf32-frv.c:3127
msgid "R_FRV_GOTTLSDESCLO not applied to a setlo or setlos instruction"
msgstr "R_FRV_GOTTLSDESCLO ikke anvendt til en setlo- eller setlos-instruktion"

#: elf32-frv.c:3175
msgid "R_FRV_TLSDESC_RELAX not applied to an ldd instruction"
msgstr "R_FRV_TLSDESC_RELAX ikke anvendt til en ldd-instruktion"

# virkelig?
#: elf32-frv.c:3259
msgid "R_FRV_GETTLSOFF_RELAX not applied to a calll instruction"
msgstr "R_FRV_GETTLSOFF_RELAX ikke anvendt til en calll-instruktion"

#: elf32-frv.c:3314
msgid "R_FRV_GOTTLSOFF12 not applied to an ldi instruction"
msgstr "R_FRV_GOTTLSOFF12 ikke anvendt til en ldi-instruktion"

#: elf32-frv.c:3344
msgid "R_FRV_GOTTLSOFFHI not applied to a sethi instruction"
msgstr "R_FRV_GOTTLSOFFHI ikke anvendt til en sethi-instruktion"

#: elf32-frv.c:3373
msgid "R_FRV_GOTTLSOFFLO not applied to a setlo or setlos instruction"
msgstr "R_FRV_GOTTLSOFFLO ikke anvendt til en setlos-instruktion"

#: elf32-frv.c:3404
msgid "R_FRV_TLSOFF_RELAX not applied to an ld instruction"
msgstr "R_FRV_TLSOFF_RELAX ikke anvendt til en ld-instruktion"

#: elf32-frv.c:3449
msgid "R_FRV_TLSMOFFHI not applied to a sethi instruction"
msgstr "R_FRV_TLSMOFFHI ikke anvendt til en sethi-instruktion"

#: elf32-frv.c:3476
msgid "R_FRV_TLSMOFFLO not applied to a setlo or setlos instruction"
msgstr "R_FRV_TLSMOFFLO ikke anvendt til en setlos-instruktion"

#: elf32-frv.c:3597
msgid "R_FRV_FUNCDESC references dynamic symbol with nonzero addend"
msgstr "R_FRV_FUNCDESC refererer dynamisk symbol med addend forskellig fra nul"

#: elf32-frv.c:3717
msgid "R_FRV_FUNCDESC_VALUE references dynamic symbol with nonzero addend"
msgstr "R_FRV_FUNCDESC_VALUE refererer dynamisk symbol med addend forskellig fra nul"

#: elf32-frv.c:3974 elf32-frv.c:4130
msgid "%B(%A+0x%lx): reloc against `%s': %s"
msgstr "%B(%A+0x%lx): relokering mod \"%s\": %s"

#: elf32-frv.c:3976 elf32-frv.c:3980
msgid "relocation references a different segment"
msgstr "relokering refererer et andet segment"

#: elf32-frv.c:6728
#, c-format
msgid "%s: compiled with %s and linked with modules that use non-pic relocations"
msgstr "%s: oversat med %s og lænket med moduler som bruger ikke-pic-relokering"

#: elf32-frv.c:6781 elf32-iq2000.c:845 elf32-m32c.c:807
#, c-format
msgid "%s: compiled with %s and linked with modules compiled with %s"
msgstr "%s: oversat med %s og lænket med moduler som oversattes med %s"

#: elf32-frv.c:6793
#, c-format
msgid "%s: uses different unknown e_flags (0x%lx) fields than previous modules (0x%lx)"
msgstr "%s: bruger andre ukendte e_flags-felter (0x%lx) end tidligere moduler (0x%lx)"

#: elf32-frv.c:6843 elf32-iq2000.c:882 elf32-m32c.c:843 elf32-mt.c:576
#: elf32-rx.c:2925
#, c-format
msgid "private flags = 0x%lx:"
msgstr "private flag = 0x%lx:"

#: elf32-gen.c:69 elf64-gen.c:69
msgid "%B: Relocations in generic ELF (EM: %d)"
msgstr "%B: Relokeringer i generisk ELF (EM: %d)"

#: elf32-hppa.c:850 elf32-hppa.c:3610
msgid "%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"
msgstr "%B(%A+0x%lx): kan ikke nå %s, genkompilér med -ffunction-sections"

#: elf32-hppa.c:1284
msgid "%B: relocation %s can not be used when making a shared object; recompile with -fPIC"
msgstr "%B: relokeringen %s kan ikke bruges når et delt objekt oprettes; genkompilér med -fPIC"

#: elf32-hppa.c:2803
msgid "%B: duplicate export stub %s"
msgstr "%B: dobbelt eksportstub %s"

#: elf32-hppa.c:3449
msgid "%B(%A+0x%lx): %s fixup for insn 0x%x is not supported in a non-shared link"
msgstr "%B(%A+0x%lx): %s-\"fixup\" for instruktion 0x%x understøttes ikke i et ikke-delt lænke"

#: elf32-hppa.c:4296
msgid "%B(%A+0x%lx): cannot handle %s for %s"
msgstr "%B(%A+0x%lx): kan ikke håndtere %s til %s"

#: elf32-hppa.c:4608
msgid ".got section not immediately after .plt section"
msgstr ".got-sektionen følger ikke umiddelbart efter .plt-sektion"

#. Unknown relocation.
#: elf32-i386.c:371 elf32-m68k.c:383 elf32-ppc.c:1674 elf32-s390.c:379
#: elf32-tic6x.c:1563 elf64-ppc.c:2284 elf64-s390.c:403 elf64-x86-64.c:234
msgid "%B: invalid relocation type %d"
msgstr "%B: ugyldig relokeringstype %d"

#: elf32-i386.c:1265 elf64-x86-64.c:1049
msgid "%B: TLS transition from %s to %s against `%s' at 0x%lx in section `%A' failed"
msgstr "%B: TLS-overgang fra %s til %s mod \"%s\" ved 0x%lx i afsnittet \"%A\" mislykkedes"

#: elf32-i386.c:1408 elf32-i386.c:3068 elf64-x86-64.c:1194 elf64-x86-64.c:2780
#: elfxx-sparc.c:3076
msgid "%B: relocation %s against STT_GNU_IFUNC symbol `%s' isn't handled by %s"
msgstr "%B: relokeringen %s mod STT_GNU_IFUNC-symbolet \"%s\" håndteres ikke af %s"

#: elf32-i386.c:1570 elf32-s390.c:1182 elf32-sh.c:6367 elf32-xtensa.c:1182
#: elf64-s390.c:1151 elfxx-sparc.c:1547
msgid "%B: `%s' accessed both as normal and thread local symbol"
msgstr "%B: \"%s\" tilgås både som normalt symbol og trådlokalt symbol"

#: elf32-i386.c:2910
msgid "%B: unrecognized relocation (0x%x) in section `%A'"
msgstr "%B: ukendt relokering (0x%x) i sektionen \"%A\""

#: elf32-i386.c:3317 elf64-x86-64.c:3174
msgid "hidden symbol"
msgstr "skjult symbol"

#: elf32-i386.c:3320 elf64-x86-64.c:3177
msgid "internal symbol"
msgstr "internt symbol"

#: elf32-i386.c:3323 elf64-x86-64.c:3180
msgid "protected symbol"
msgstr "beskyttet symbol"

#: elf32-i386.c:3326 elf64-x86-64.c:3183
msgid "symbol"
msgstr "symbol"

#: elf32-i386.c:3331
msgid "%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"
msgstr "%B: relokeringen R_386_GOTOFF mod udefineret %s \"%s\" kan ikke bruges når et delt objekt oprettes"

#: elf32-i386.c:3341
msgid "%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"
msgstr "%B: relokeringen R_386_GOTOFF mod beskyttet funktion \"%s\" kan ikke bruges når et delt objekt oprettes"

#: elf32-i386.c:4633 elf64-x86-64.c:4206
#, c-format
msgid "discarded output section: `%A'"
msgstr "forkastet uddatasektion: \"%A\""

#: elf32-ip2k.c:857 elf32-ip2k.c:863 elf32-ip2k.c:930 elf32-ip2k.c:936
msgid "ip2k relaxer: switch table without complete matching relocation information."
msgstr "ip2k relaxer: switch-tabel uden fuldstændig passende relokeringsinformation."

#: elf32-ip2k.c:880 elf32-ip2k.c:963
msgid "ip2k relaxer: switch table header corrupt."
msgstr "ip2k relaxer: switch-tabelhoved beskadiget."

#: elf32-ip2k.c:1292
#, c-format
msgid "ip2k linker: missing page instruction at 0x%08lx (dest = 0x%08lx)."
msgstr "ip2k linker: manglende sideinstruktion ved 0x%08lx (dest = 0x%08lx)."

#: elf32-ip2k.c:1308
#, c-format
msgid "ip2k linker: redundant page instruction at 0x%08lx (dest = 0x%08lx)."
msgstr "ip2k linker: gentaget sideinstruktion ved 0x%08lx (dest = 0x%08lx)."

#. Only if it's not an unresolved symbol.
#: elf32-ip2k.c:1475
msgid "unsupported relocation between data/insn address spaces"
msgstr "ikke-understøttet relokering mellem data/insn-adresserum"

#: elf32-iq2000.c:858 elf32-m32c.c:819
#, c-format
msgid "%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"
msgstr "%s: bruger andre e_flags-felter (0x%lx) end tidligere moduler (0x%lx)"

#: elf32-lm32.c:706
msgid "global pointer relative relocation when _gp not defined"
msgstr "global pointer-relativ relokering, når _gp ikke er defineret"

#: elf32-lm32.c:761
msgid "global pointer relative address out of range"
msgstr "global pointer-relativ adresse er uden for det gyldige interval"

#: elf32-lm32.c:1057
msgid "internal error: addend should be zero for R_LM32_16_GOT"
msgstr "intern fejl: addend burde være nul for R_LM32_16_GOT"

#: elf32-m32r.c:1453
msgid "SDA relocation when _SDA_BASE_ not defined"
msgstr "SDA-relokering når _SDA_BASE_ ikke er defineret"

#: elf32-m32r.c:3048
msgid "%B: The target (%s) of an %s relocation is in the wrong section (%A)"
msgstr "%B: Målet (%s) for en %s-relokering er i forkert sektion (%A)"

#: elf32-m32r.c:3576
msgid "%B: Instruction set mismatch with previous modules"
msgstr "%B: Instruktionssæt passer ikke med tidligere moduler"

#: elf32-m32r.c:3597
#, c-format
msgid "private flags = %lx"
msgstr "private flag = %lx"

#: elf32-m32r.c:3602
#, c-format
msgid ": m32r instructions"
msgstr ": m32r-instruktioner"

#: elf32-m32r.c:3603
#, c-format
msgid ": m32rx instructions"
msgstr ": m32rx-instruktioner"

#: elf32-m32r.c:3604
#, c-format
msgid ": m32r2 instructions"
msgstr ": m32r2-instruktioner"

#: elf32-m68hc1x.c:1050
#, c-format
msgid "Reference to the far symbol `%s' using a wrong relocation may result in incorrect execution"
msgstr "Reference til fjernsymbol \"%s\", der bruger en forkert relokering, kan resultere i forkert udførelse"

#: elf32-m68hc1x.c:1073
#, c-format
msgid "banked address [%lx:%04lx] (%lx) is not in the same bank as current banked address [%lx:%04lx] (%lx)"
msgstr "bankadresse [%lx:%04lx] (%lx) er ikke i samme bank som nuværende bankadresse [%lx:%04lx] (%lx)"

#: elf32-m68hc1x.c:1092
#, c-format
msgid "reference to a banked address [%lx:%04lx] in the normal address space at %04lx"
msgstr "reference til bankadresse [%lx:%04lx] i det normale adresserum ved %04lx"

#: elf32-m68hc1x.c:1225
msgid "%B: linking files compiled for 16-bit integers (-mshort) and others for 32-bit integers"
msgstr "%B: lænker filer, der er kompileret til 16 bit-heltal (-mshort), og andre til 32 bit-heltal"

#: elf32-m68hc1x.c:1232
msgid "%B: linking files compiled for 32-bit double (-fshort-double) and others for 64-bit double"
msgstr "%B: lænker filer, der er kompileret til 32 bit-double (-fshort-double), og andre til 64 bit-double"

#: elf32-m68hc1x.c:1241
msgid "%B: linking files compiled for HCS12 with others compiled for HC12"
msgstr "%B: lænkning af filer kompileret til HCS12 med andre, der er kompileret til HC12"

#: elf32-m68hc1x.c:1257 elf32-ppc.c:4232 elf64-sparc.c:703 elfxx-mips.c:12704
msgid "%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"
msgstr "%B: bruger andre e_flags-felter (0x%lx) end tidligere moduler (0x%lx)"

#: elf32-m68hc1x.c:1285
#, c-format
msgid "[abi=32-bit int, "
msgstr "[abi=32-bit int, "

#: elf32-m68hc1x.c:1287
#, c-format
msgid "[abi=16-bit int, "
msgstr "[abi=16-bit int, "

#: elf32-m68hc1x.c:1290
#, c-format
msgid "64-bit double, "
msgstr "64-bit double, "

#: elf32-m68hc1x.c:1292
#, c-format
msgid "32-bit double, "
msgstr "32-bit double, "

#: elf32-m68hc1x.c:1295
#, c-format
msgid "cpu=HC11]"
msgstr "cpu=HC11]"

#: elf32-m68hc1x.c:1297
#, c-format
msgid "cpu=HCS12]"
msgstr "cpu=HCS12]"

#: elf32-m68hc1x.c:1299
#, c-format
msgid "cpu=HC12]"
msgstr "cpu=HC12]"

# ?
#: elf32-m68hc1x.c:1302
#, c-format
msgid " [memory=bank-model]"
msgstr " [memory=bank-model]"

# ?
#: elf32-m68hc1x.c:1304
#, c-format
msgid " [memory=flat]"
msgstr " [memory=flat]"

#: elf32-m68k.c:1250 elf32-m68k.c:1251 vms-alpha.c:7292 vms-alpha.c:7307
msgid "unknown"
msgstr "ukendt"

#: elf32-m68k.c:1714
msgid "%B: GOT overflow: Number of relocations with 8-bit offset > %d"
msgstr "%B: GOT-overløb: Antallet af relokeringer med 8 bit-afsæt > %d"

#: elf32-m68k.c:1720
msgid "%B: GOT overflow: Number of relocations with 8- or 16-bit offset > %d"
msgstr "%B: GOT-overløb: Antallet af relokeringer med 8 eller 16 bit-afsæt > %d"

#: elf32-m68k.c:3959
msgid "%B(%A+0x%lx): R_68K_TLS_LE32 relocation not permitted in shared object"
msgstr "%B(%A+0x%lx): R_68K_TLS_LE32-relokering tillades ikke i delt objekt"

#: elf32-mcore.c:99 elf32-mcore.c:442
msgid "%B: Relocation %s (%d) is not currently supported.\n"
msgstr "%B: Relokering %s (%d) understøttes ikke i øjeblikket.\n"

#: elf32-mcore.c:428
msgid "%B: Unknown relocation type %d\n"
msgstr "%B: Ukendt relokeringstype %d\n"

# ?
#: elf32-mep.c:647
msgid "%B and %B are for different cores"
msgstr "%B og %B er til forskellige cpu-kerner"

#: elf32-mep.c:664
msgid "%B and %B are for different configurations"
msgstr "%B og %B er til forskellige konfigurationer"

#: elf32-mep.c:701
#, c-format
msgid "private flags = 0x%lx"
msgstr "private flag = 0x%lx"

#: elf32-microblaze.c:742
#, c-format
msgid "%s: unknown relocation type %d"
msgstr "%s: ukendt relokeringstype %d"

#: elf32-microblaze.c:867 elf32-microblaze.c:912
#, c-format
msgid "%s: The target (%s) of an %s relocation is in the wrong section (%s)"
msgstr "%s: Målet (%s) for en %s-relokering er i forkert sektion (%s)"

#: elf32-microblaze.c:1155 elfxx-sparc.c:3450
msgid "%B: probably compiled without -fPIC?"
msgstr "%B: nok oversat uden -fPIC?"

#: elf32-microblaze.c:2074 elflink.c:12601
msgid "%B: bad relocation section name `%s'"
msgstr "%B: fejlagtigt relokeringssektionsnavn \"%s\""

#: elf32-mips.c:1045 elf64-mips.c:2084 elfn32-mips.c:1888
msgid "literal relocation occurs for an external symbol"
msgstr "der sker ordret relokering for et eksternt symbol"

#: elf32-mips.c:1085 elf32-score.c:569 elf32-score7.c:469 elf64-mips.c:2127
#: elfn32-mips.c:1929
msgid "32bits gp relative relocation occurs for an external symbol"
msgstr "32-bit gp-relativ relokering forekommer for et eksternt symbol"

#: elf32-ppc.c:1739
#, c-format
msgid "generic linker can't handle %s"
msgstr "generisk lænker kan ikke håndtere %s"

#: elf32-ppc.c:2180
msgid "corrupt %s section in %B"
msgstr "beskadiget %s-sektion i %B"

#: elf32-ppc.c:2199
msgid "unable to read in %s section from %B"
msgstr "kan ikke læse i %s-sektion fra %B"

#: elf32-ppc.c:2240
msgid "warning: unable to set size of %s section in %B"
msgstr "advarsel: kan ikke sætte størrelsen af %s-sektion i %B"

#: elf32-ppc.c:2290
msgid "failed to allocate space for new APUinfo section."
msgstr "kunne ikke tildele plads til ny APUinfo-sektion."

#: elf32-ppc.c:2309
msgid "failed to compute new APUinfo section."
msgstr "kunne ikke beregne ny APUinfo-sektion."

#: elf32-ppc.c:2312
msgid "failed to install new APUinfo section."
msgstr "kunne ikke installere ny APUinfo-sektion."

#: elf32-ppc.c:3358
msgid "%B: relocation %s cannot be used when making a shared object"
msgstr "%B: relokeringen %s kan ikke bruges når et delt objekt oprettes"

#. It does not make sense to have a procedure linkage
#. table entry for a local symbol.
#: elf32-ppc.c:3702
msgid "%B(%A+0x%lx): %s reloc against local symbol"
msgstr "%B(%A+0x%lx): %s-relokering mod lokalt symbol"

#: elf32-ppc.c:4044 elf32-ppc.c:4059 elfxx-mips.c:12411 elfxx-mips.c:12437
#: elfxx-mips.c:12459 elfxx-mips.c:12485
msgid "Warning: %B uses hard float, %B uses soft float"
msgstr "Advarsel: %B bruger flydende tal i hardware, %B bruger flydende tal i software"

#: elf32-ppc.c:4047 elf32-ppc.c:4051
msgid "Warning: %B uses double-precision hard float, %B uses single-precision hard float"
msgstr "Advarsel: %B bruger dobbeltpræcisions-float i hardware, mens %B bruger enkeltpræcisions-float i hardware"

#: elf32-ppc.c:4055
msgid "Warning: %B uses soft float, %B uses single-precision hard float"
msgstr "Advarsel: %B bruger software-float, mens %B bruger enkeltpræcisions-float i hardware"

#: elf32-ppc.c:4062 elf32-ppc.c:4066 elfxx-mips.c:12391 elfxx-mips.c:12395
msgid "Warning: %B uses unknown floating point ABI %d"
msgstr "Advarsel: %B bruger ukendt ABI %d til flydende tal"

#: elf32-ppc.c:4108 elf32-ppc.c:4112
msgid "Warning: %B uses unknown vector ABI %d"
msgstr "Advarsel: %B bruger ukendt vektor-ABI %d"

#: elf32-ppc.c:4116
msgid "Warning: %B uses vector ABI \"%s\", %B uses \"%s\""
msgstr "Advarsel: %B bruger vektor-ABI \"%s\", mens %B bruger \"%s\""

#: elf32-ppc.c:4133 elf32-ppc.c:4136
msgid "Warning: %B uses r3/r4 for small structure returns, %B uses memory"
msgstr "Advarsel: %B bruger r3/r4 til små struktur-returneringer, mens %B bruger hukommelsen"

#: elf32-ppc.c:4139 elf32-ppc.c:4143
msgid "Warning: %B uses unknown small structure return convention %d"
msgstr "Advarsel: %B bruger ukendt returkonvention %d for småstrukturer"

#: elf32-ppc.c:4197
msgid "%B: compiled with -mrelocatable and linked with modules compiled normally"
msgstr "%B: kompileret med -mrelocatable og lænket med moduler som er kompileret normalt"

#: elf32-ppc.c:4205
msgid "%B: compiled normally and linked with modules compiled with -mrelocatable"
msgstr "%B: kompileret normalt og lænket med moduler som er kompileret med -mrelocatable"

#: elf32-ppc.c:4293
msgid "Using bss-plt due to %B"
msgstr "Bruger bss-plt på grund af %B"

#: elf32-ppc.c:7192 elf64-ppc.c:12307
msgid "%B: unknown relocation type %d for symbol %s"
msgstr "%B: ukendt relokeringstype %d for symbol %s"

#: elf32-ppc.c:7453
msgid "%B(%A+0x%lx): non-zero addend on %s reloc against `%s'"
msgstr "%B(%A+0x%lx): addend forskellig fra nul på %s-relokering mod \"%s\""

#: elf32-ppc.c:7651 elf64-ppc.c:12812
msgid "%B(%A+0x%lx): relocation %s for indirect function %s unsupported"
msgstr "%B(%A+0x%lx): relokering %s for indirekte funktion %s understøttes ikke"

#: elf32-ppc.c:7881 elf32-ppc.c:7911 elf32-ppc.c:7958
msgid "%B: the target (%s) of a %s relocation is in the wrong output section (%s)"
msgstr "%B: målet (%s) for en %s-relokering er i den forkerte uddatasektion (%s)"

#: elf32-ppc.c:8030
msgid "%B: relocation %s is not yet supported for symbol %s."
msgstr "%B: relokeringen %s understøttes endnu ikke for symbolet %s."

#: elf32-ppc.c:8138 elf64-ppc.c:13162
msgid "%B(%A+0x%lx): %s reloc against `%s': error %d"
msgstr "%B(%A+0x%lx): relokering af %s mod \"%s\": fejl %d"

#: elf32-ppc.c:8629
#, c-format
msgid "%s not defined in linker created %s"
msgstr "%s er ikke defineret i lænker-oprettet %s"

#: elf32-rx.c:544
msgid "%B:%A: Warning: deprecated Red Hat reloc "
msgstr "%B:%A: Advarsel: forældet Red Hat-relokering "

#: elf32-rx.c:1086
msgid "Warning: RX_SYM reloc with an unknown symbol"
msgstr "Advarsel: RX_SYM-relokering med et ukendt symbol"

#: elf32-rx.c:1251
msgid "%B(%A): error: call to undefined function '%s'"
msgstr "%B(%A): fejl: kald til udefineret funktion \"%s\""

#: elf32-rx.c:1265
msgid "%B(%A): warning: unaligned access to symbol '%s' in the small data area"
msgstr "%B(%A): advarsel: ikke-justeret tilgang til symbol \"%s\" i det lille dataområde"

#: elf32-rx.c:1269
msgid "%B(%A): internal error: out of range error"
msgstr "%B(%A): intern fejl: uden for intervallet"

#: elf32-rx.c:1273
msgid "%B(%A): internal error: unsupported relocation error"
msgstr "%B(%A): intern fejl: relokeringen understøttes ikke"

#: elf32-rx.c:1277
msgid "%B(%A): internal error: dangerous relocation"
msgstr "%B(%A): intern fejl: farlig relokering"

#: elf32-rx.c:1281
msgid "%B(%A): internal error: unknown error"
msgstr "%B(%A): intern fejl: ukendt fejl"

#: elf32-rx.c:2928
#, c-format
msgid " [64-bit doubles]"
msgstr " [64 bit-doubles]"

#: elf32-rx.c:2930
#, c-format
msgid " [dsp]"
msgstr " [dsp]"

#: elf32-s390.c:2209 elf64-s390.c:2196
msgid "%B(%A+0x%lx): invalid instruction for TLS relocation %s"
msgstr "%B(%A+0x%lx): ugyldig instruktion til TLS-relokering %s"

#: elf32-score.c:1522 elf32-score7.c:1382 elfxx-mips.c:3323
msgid "not enough GOT space for local GOT entries"
msgstr "ikke nok med GOT-plads for lokale GOT-poster"

# word er en datatype
#: elf32-score.c:2744
msgid "address not word align"
msgstr "adresse er ikke justeret til word-position"

#: elf32-score.c:2829 elf32-score7.c:2634
#, c-format
msgid "%s: Malformed reloc detected for section %s"
msgstr "%s: Fejlagtig relokering for sektion %s opdaget"

#: elf32-score.c:2880 elf32-score7.c:2685
msgid "%B: CALL15 reloc at 0x%lx not against global symbol"
msgstr "%B: CALL15-relokering ved 0x%lx er ikke mod globalt symbol"

#: elf32-score.c:3999 elf32-score7.c:3806
#, c-format
msgid " [pic]"
msgstr " [pic]"

#: elf32-score.c:4003 elf32-score7.c:3810
#, c-format
msgid " [fix dep]"
msgstr " [fix dep]"

#: elf32-score.c:4045 elf32-score7.c:3852
msgid "%B: warning: linking PIC files with non-PIC files"
msgstr "%B: advarsel: lænker PIC-filer med ikke-PIC-filer"

#: elf32-sh-symbian.c:130
msgid "%B: IMPORT AS directive for %s conceals previous IMPORT AS"
msgstr "%B: IMPORT AS-direktiv til %s skjuler forrige IMPORT AS"

#: elf32-sh-symbian.c:383
msgid "%B: Unrecognised .directive command: %s"
msgstr "%B: Ukendt .directive-kommando: %s"

#: elf32-sh-symbian.c:503
msgid "%B: Failed to add renamed symbol %s"
msgstr "%B: Kunne ikke tilføje omdøbt symbol %s"

#: elf32-sh.c:568
msgid "%B: 0x%lx: warning: bad R_SH_USES offset"
msgstr "%B: 0x%lx: advarsel: fejlagtig R_SH_USES-afstand"

#: elf32-sh.c:580
msgid "%B: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"
msgstr "%B: 0x%lx: advarsel: R_SH_USES peger på ukendt instruktion 0x%x"

#: elf32-sh.c:597
msgid "%B: 0x%lx: warning: bad R_SH_USES load offset"
msgstr "%B: 0x%lx: advarsel: fejlagtig R_SH_USES-indlæsningsafstand"

#: elf32-sh.c:612
msgid "%B: 0x%lx: warning: could not find expected reloc"
msgstr "%B: 0x%lx: advarsel: kunne ikke finde forventet relokering"

#: elf32-sh.c:640
msgid "%B: 0x%lx: warning: symbol in unexpected section"
msgstr "%B: 0x%lx: advarsel: symbol i uventet sektion"

#: elf32-sh.c:766
msgid "%B: 0x%lx: warning: could not find expected COUNT reloc"
msgstr "%B: 0x%lx: advarsel: kunne ikke finde forventet COUNT-relokering"

#: elf32-sh.c:775
msgid "%B: 0x%lx: warning: bad count"
msgstr "%B: 0x%lx: advarsel: fejlagtigt antal"

#: elf32-sh.c:1179 elf32-sh.c:1549
msgid "%B: 0x%lx: fatal: reloc overflow while relaxing"
msgstr "%B: 0x%lx: fatalt: relokering giver overløb ved forenklingen"

#: elf32-sh.c:4057 elf64-sh64.c:1514
msgid "Unexpected STO_SH5_ISA32 on local symbol is not handled"
msgstr "Uventet STO_SH5_ISA32 på lokalt symbol håndteres ikke"

#: elf32-sh.c:4304
msgid "%B: 0x%lx: fatal: unaligned branch target for relax-support relocation"
msgstr "%B: 0x%lx: fatalt: ujusteret grenmål for relokering for forenklingsunderstøttelse"

#: elf32-sh.c:4337 elf32-sh.c:4352
msgid "%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"
msgstr "%s: 0x%lx: fatalt: ujusteret %s-relokering 0x%lx"

#: elf32-sh.c:4366
msgid "%B: 0x%lx: fatal: R_SH_PSHA relocation %d not in range -32..32"
msgstr "%B: 0x%lx: fatalt: R_SH_PSHA-relokering %d er uden for gyldigt interval -32..32"

#: elf32-sh.c:4380
msgid "%B: 0x%lx: fatal: R_SH_PSHL relocation %d not in range -32..32"
msgstr "%B: 0x%lx: fatalt: R_SH_PSHL-relokering %d er uden for gyldigt interval -32..32"

#: elf32-sh.c:4524 elf32-sh.c:4994
msgid "%B(%A+0x%lx): cannot emit fixup to `%s' in read-only section"
msgstr "%B(%A+0x%lx): kan ikke udsende \"fixup\" til \"%s\" i skrivebeskyttet sektion"

#: elf32-sh.c:5101
msgid "%B(%A+0x%lx): %s relocation against external symbol \"%s\""
msgstr "%B(%A+0x%lx): %s-relokering mod eksternt symbol \"%s\""

#: elf32-sh.c:5574
#, c-format
msgid "%X%C: relocation to \"%s\" references a different segment\n"
msgstr "%X%C: relokering til \"%s\" refererer et andet segment\n"

#: elf32-sh.c:5580
#, c-format
msgid "%C: warning: relocation to \"%s\" references a different segment\n"
msgstr "%C: advarsel: relokering til \"%s\" refererer et andet segment\n"

#: elf32-sh.c:6358 elf32-sh.c:6441
msgid "%B: `%s' accessed both as normal and FDPIC symbol"
msgstr "%B: \"%s\" tilgås både som normalt symbol og FDPIC-symbol"

#: elf32-sh.c:6363 elf32-sh.c:6445
msgid "%B: `%s' accessed both as FDPIC and thread local symbol"
msgstr "%B: \"%s\" tilgås både som FDPIC-symbol og trådlokalt symbol"

#: elf32-sh.c:6393
msgid "%B: Function descriptor relocation with non-zero addend"
msgstr "%B: Relokering af funktionsdeskriptor med addend forskellig fra nul"

#: elf32-sh.c:6629 elf64-alpha.c:4560
msgid "%B: TLS local exec code cannot be linked into shared objects"
msgstr "%B: lokal TLS-eksekveringskode kan ikke lænkes ind i delte objekter"

#: elf32-sh64.c:223 elf64-sh64.c:2314
#, c-format
msgid "%s: compiled as 32-bit object and %s is 64-bit"
msgstr "%s: oversat som 32-bitsobjekt og %s er 64-bit"

#: elf32-sh64.c:226 elf64-sh64.c:2317
#, c-format
msgid "%s: compiled as 64-bit object and %s is 32-bit"
msgstr "%s: oversat som 64-bitsobjekt og %s er 32-bit"

#: elf32-sh64.c:228 elf64-sh64.c:2319
#, c-format
msgid "%s: object size does not match that of target %s"
msgstr "%s: objektstørrelsen stemmer ikke overens med den hos målet %s"

#: elf32-sh64.c:451 elf64-sh64.c:2833
#, c-format
msgid "%s: encountered datalabel symbol in input"
msgstr "%s: mødte dataetikettesymbol i inddata"

#: elf32-sh64.c:528
msgid "PTB mismatch: a SHmedia address (bit 0 == 1)"
msgstr "PTB passer ikke: en SHmedia-adresse (bit 0 == 1)"

#: elf32-sh64.c:531
msgid "PTA mismatch: a SHcompact address (bit 0 == 0)"
msgstr "PTA passer ikke: en SHcompact-adresse (bit 0 == 0)"

#: elf32-sh64.c:549
#, c-format
msgid "%s: GAS error: unexpected PTB insn with R_SH_PT_16"
msgstr "%s: GAS-fejl: uventet PTB-instruktion med R_SH_PT_16"

#: elf32-sh64.c:598
msgid "%B: error: unaligned relocation type %d at %08x reloc %p\n"
msgstr "%B: fejl: ujusteret relokeringstype %d på %08x-relokering %08x\n"

#: elf32-sh64.c:674
#, c-format
msgid "%s: could not write out added .cranges entries"
msgstr "%s: kunne ikke udskrive tilføjede .cranges-poster"

#: elf32-sh64.c:734
#, c-format
msgid "%s: could not write out sorted .cranges entries"
msgstr "%s: kunne ikke udskrive sorterede cranges-poster"

#: elf32-sparc.c:89
msgid "%B: compiled for a 64 bit system and target is 32 bit"
msgstr "%B: kompileret til et 64-bitssystem, men målet er 32-bit"

#: elf32-sparc.c:102
msgid "%B: linking little endian files with big endian files"
msgstr "%B: lænker little endian-filer med big endian-filer"

#: elf32-spu.c:719
msgid "%X%P: overlay section %A does not start on a cache line.\n"
msgstr "%X%P: overlay-sektion %A starter ikke på en cachelinje.\n"

#: elf32-spu.c:727
msgid "%X%P: overlay section %A is larger than a cache line.\n"
msgstr "%X%P: overlay-sektion %A er større end en cachelinje.\n"

#: elf32-spu.c:747
msgid "%X%P: overlay section %A is not in cache area.\n"
msgstr "%X%P: overlay-sektion %A er ikke i cacheområdet.\n"

#: elf32-spu.c:787
msgid "%X%P: overlay sections %A and %A do not start at the same address.\n"
msgstr "%X%P: overlay-sektionerne %A og %A starter ikke på samme adresse.\n"

#: elf32-spu.c:1011
msgid "warning: call to non-function symbol %s defined in %B"
msgstr "advarsel: kald til ikke-funktionssymbol %s defineret i %B"

#: elf32-spu.c:1361
msgid "%A:0x%v lrlive .brinfo (%u) differs from analysis (%u)\n"
msgstr "%A:0x%v lrlive .brinfo (%u) afviger fra analyse (%u)\n"

#: elf32-spu.c:1880
msgid "%B is not allowed to define %s"
msgstr "%B må ikke definere %s"

#: elf32-spu.c:1888
#, c-format
msgid "you are not allowed to define %s in a script"
msgstr "du har ikke lov til at definere %s i et script"

#: elf32-spu.c:1922
#, c-format
msgid "%s in overlay section"
msgstr "%s i overlay-sektion"

#: elf32-spu.c:1951
msgid "overlay stub relocation overflow"
msgstr "overløb ved overlay-stub-relokering"

#: elf32-spu.c:1960 elf64-ppc.c:11327
msgid "stubs don't match calculated size"
msgstr "stubbe stemmer ikke overens med beregnet størrelse"

#: elf32-spu.c:2542
#, c-format
msgid "warning: %s overlaps %s\n"
msgstr "advarsel: %s overlapper %s\n"

#: elf32-spu.c:2558
#, c-format
msgid "warning: %s exceeds section size\n"
msgstr "advarsel: %s overstiger sektionsstørrelse\n"

#: elf32-spu.c:2589
msgid "%A:0x%v not found in function table\n"
msgstr "%A:0x%v ikke fundet i funktionstabel\n"

#: elf32-spu.c:2729
msgid "%B(%A+0x%v): call to non-code section %B(%A), analysis incomplete\n"
msgstr "%B(%A+0x%v): kald til ikke-kodesektion %B(%A), analyse ufuldstændig\n"

#: elf32-spu.c:3297
#, c-format
msgid "Stack analysis will ignore the call from %s to %s\n"
msgstr "Stak-analyse vil ignorere kaldet fra %s til %s\n"

#: elf32-spu.c:3988
msgid "  %s: 0x%v\n"
msgstr "  %s: 0x%v\n"

#: elf32-spu.c:3989
msgid "%s: 0x%v 0x%v\n"
msgstr "%s: 0x%v 0x%v\n"

#: elf32-spu.c:3994
msgid "  calls:\n"
msgstr "  kald:\n"

#: elf32-spu.c:4002
#, c-format
msgid "   %s%s %s\n"
msgstr "   %s%s %s\n"

#: elf32-spu.c:4307
#, c-format
msgid "%s duplicated in %s\n"
msgstr "%s er duplikeret i %s\n"

#: elf32-spu.c:4311
#, c-format
msgid "%s duplicated\n"
msgstr "%s duplikeret\n"

#: elf32-spu.c:4318
msgid "sorry, no support for duplicate object files in auto-overlay script\n"
msgstr "beklager, men auto-overlay-scriptet understøtter ikke duplikerede objektfiler\n"

#: elf32-spu.c:4359
msgid "non-overlay size of 0x%v plus maximum overlay size of 0x%v exceeds local store\n"
msgstr "ikke-overlay-størrelse af 0x%v plus den maksimale overlaystørrelse af 0x%v overstiger lokalt lager\n"

#: elf32-spu.c:4514
msgid "%B:%A%s exceeds overlay size\n"
msgstr "%B:%A%s overstiger overlay-størrelsen\n"

#: elf32-spu.c:4676
msgid "Stack size for call graph root nodes.\n"
msgstr "Stakstørrelsen for rodknuder i funktionskaldsgrafen.\n"

#: elf32-spu.c:4677
msgid ""
"\n"
"Stack size for functions.  Annotations: '*' max stack, 't' tail call\n"
msgstr ""
"\n"
"Stakstørrelse til funktioner.  Annotationer: '*' maks stak, 't' tail call\n"

#: elf32-spu.c:4687
msgid "Maximum stack required is 0x%v\n"
msgstr "Maksimum påkrævet stak er 0x%v\n"

#: elf32-spu.c:4778
msgid "fatal error while creating .fixup"
msgstr "fatal fejl ved oprettelse af .fixup"

#: elf32-spu.c:5006
msgid "%B(%s+0x%lx): unresolvable %s relocation against symbol `%s'"
msgstr "%B(%s+0x%lx): uløselig %s-relokering mod symbol \"%s\""

#: elf32-tic6x.c:1539
msgid "%B: SB-relative relocation but __c6xabi_DSBT_BASE not defined"
msgstr "%B: SB-relativ relokering, men __c6xabi_DSBT_BASE er ikke defineret"

#. Shared libraries and exception handling support not
#. implemented.
#: elf32-tic6x.c:1554
msgid "%B: relocation type %d not implemented"
msgstr "%B: relokeringstypen %d er ikke implementeret"

#: elf32-tic6x.c:1640
msgid "dangerous relocation"
msgstr "farlig relokering"

# ikke sikker på hvad det her betyder, så bruger mere direkte oversættelse end hvad der måske er nødvendigt
#: elf32-tic6x.c:1788 elf32-tic6x.c:1796
msgid "error: %B requires more stack alignment than %B preserves"
msgstr "fejl: %B kræver mere stakjustering end %B præserverer"

#: elf32-tic6x.c:1806 elf32-tic6x.c:1815
msgid "error: unknown Tag_ABI_array_object_alignment value in %B"
msgstr "fejl: ukendt værdi for Tag_ABI_array_object_alignment i %B"

#: elf32-tic6x.c:1824 elf32-tic6x.c:1833
msgid "error: unknown Tag_ABI_array_object_align_expected value in %B"
msgstr "error: ukendt værdi for Tag_ABI_array_object_align_expected i %B"

#: elf32-tic6x.c:1841 elf32-tic6x.c:1848
msgid "error: %B requires more array alignment than %B preserves"
msgstr "fejl: %B kræver mere array-justering end %B præserverer"

#: elf32-tic6x.c:1870
msgid "warning: %B and %B differ in wchar_t size"
msgstr "advarsel: %B og %B har forskellig størrelse af wchar_t"

#: elf32-tic6x.c:1888
msgid "warning: %B and %B differ in whether code is compiled for DSBT"
msgstr "advarsel: forskel på om %B og %B er kompileret til DSBT"

#: elf32-tic6x.c:1898
msgid "warning: %B and %B differ in position-dependence of data addressing"
msgstr "advarsel: %B og %B har forskellig positionsafhængighed af dataadressering"

#: elf32-tic6x.c:1908
msgid "warning: %B and %B differ in position-dependence of code addressing"
msgstr "advarsel: %B og %B har forskellig positionsafhængighed af kodeadressering"

#: elf32-v850.c:173
#, c-format
msgid "Variable `%s' cannot occupy in multiple small data regions"
msgstr "Variabel \"%s\" kan ikke befinde sig i flere små dataområder"

#: elf32-v850.c:176
#, c-format
msgid "Variable `%s' can only be in one of the small, zero, and tiny data regions"
msgstr "Variabel \"%s\" kan kun være i ét af de små, tomme og bittesmå dataområder"

#: elf32-v850.c:179
#, c-format
msgid "Variable `%s' cannot be in both small and zero data regions simultaneously"
msgstr "Variabel \"%s\" kan ikke være i både små og tomme dataområder samtidigt"

#: elf32-v850.c:182
#, c-format
msgid "Variable `%s' cannot be in both small and tiny data regions simultaneously"
msgstr "Variabel \"%s\" kan ikke være i både små og bittesmå dataområder samtidigt"

#: elf32-v850.c:185
#, c-format
msgid "Variable `%s' cannot be in both zero and tiny data regions simultaneously"
msgstr "Variabel \"%s\" kan ikke være i både tomme og bittesmå dataområder samtidigt"

#: elf32-v850.c:483
#, c-format
msgid "FAILED to find previous HI16 reloc\n"
msgstr "MISLYKKEDES med at finde tidligere HI16-relokering\n"

#: elf32-v850.c:2155
msgid "could not locate special linker symbol __gp"
msgstr "kunne ikke lokalisere specielt lænkersymbol __gp"

#: elf32-v850.c:2159
msgid "could not locate special linker symbol __ep"
msgstr "kunne ikke lokalisere specielt lænkersymbol __ep"

#: elf32-v850.c:2163
msgid "could not locate special linker symbol __ctbp"
msgstr "kunne ikke lokalisere specielt lænkersymbol __ctbp"

#: elf32-v850.c:2341
msgid "%B: Architecture mismatch with previous modules"
msgstr "%B: Arkitekturen passer ikke sammen med tidligere moduler"

#. xgettext:c-format.
#: elf32-v850.c:2360
#, c-format
msgid "private flags = %lx: "
msgstr "private flag = %lx: "

#: elf32-v850.c:2365
#, c-format
msgid "v850 architecture"
msgstr "v850-arkitektur"

#: elf32-v850.c:2366
#, c-format
msgid "v850e architecture"
msgstr "v850e-arkitektur"

#: elf32-v850.c:2367
#, c-format
msgid "v850e1 architecture"
msgstr "v850e1-arkitektur"

#: elf32-v850.c:2368
#, c-format
msgid "v850e2 architecture"
msgstr "v850e2-arkitektur"

#: elf32-v850.c:2369
#, c-format
msgid "v850e2v3 architecture"
msgstr "v850e2v3-arkitektur"

#: elf32-vax.c:531
#, c-format
msgid " [nonpic]"
msgstr " [ikke-pic]"

#: elf32-vax.c:534
#, c-format
msgid " [d-float]"
msgstr " [d-flydende tal]"

#: elf32-vax.c:537
#, c-format
msgid " [g-float]"
msgstr " [g-flydende tal]"

#: elf32-vax.c:654
#, c-format
msgid "%s: warning: GOT addend of %ld to `%s' does not match previous GOT addend of %ld"
msgstr "%s: advarsel: GOT-addendum %ld til \"%s\" stemmer ikke overens med tidligere GOT-addendum %ld"

#: elf32-vax.c:1587
#, c-format
msgid "%s: warning: PLT addend of %d to `%s' from %s section ignored"
msgstr "%s: advarsel: PLT-addendum %d til \"%s\" fra sektionen %s ignoreredes"

#: elf32-vax.c:1714
#, c-format
msgid "%s: warning: %s relocation against symbol `%s' from %s section"
msgstr "%s: advarsel: %s-relokering mod symbol \"%s\" fra sektionen %s"

#: elf32-vax.c:1720
#, c-format
msgid "%s: warning: %s relocation to 0x%x from %s section"
msgstr "%s: advarsel: %s-relokering til 0x%x fra sektionen %s"

#: elf32-xstormy16.c:451 elf32-ia64.c:2861 elf64-ia64.c:2861
msgid "non-zero addend in @fptr reloc"
msgstr "ikke-tomt addendum i @fptr-relokering"

#: elf32-xtensa.c:918
msgid "%B(%A): invalid property table"
msgstr "%B(%A): ugyldig egenskabstabel"

#: elf32-xtensa.c:2780
msgid "%B(%A+0x%lx): relocation offset out of range (size=0x%x)"
msgstr "%B(%A+0x%lx): relokeringsafsæt uden for gyldigt interval (størrelse=0x%x)"

#: elf32-xtensa.c:2859 elf32-xtensa.c:2980
msgid "dynamic relocation in read-only section"
msgstr "dynamisk relokering i skrivebeskyttet sektion"

#: elf32-xtensa.c:2956
msgid "TLS relocation invalid without dynamic sections"
msgstr "TLS-relokering er ugyldig uden dynamiske sektioner"

#: elf32-xtensa.c:3173
msgid "internal inconsistency in size of .got.loc section"
msgstr "intern inkonsistens i størrelsen af .got.loc-sektion"

#: elf32-xtensa.c:3486
msgid "%B: incompatible machine type. Output is 0x%x. Input is 0x%x"
msgstr "%B: inkompatibel maskintype. Uddata er 0x%x. Inddata er 0x%x"

#: elf32-xtensa.c:4715 elf32-xtensa.c:4723
msgid "Attempt to convert L32R/CALLX to CALL failed"
msgstr "Forsøg på at konvertere L32R/CALLX til CALL mislykkedes"

#: elf32-xtensa.c:6333 elf32-xtensa.c:6409 elf32-xtensa.c:7525
msgid "%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"
msgstr "%B(%A+0x%lx): kunne ikke afkode instruktion; mulig konfigurationsmodstrid"

#: elf32-xtensa.c:7265
msgid "%B(%A+0x%lx): could not decode instruction for XTENSA_ASM_SIMPLIFY relocation; possible configuration mismatch"
msgstr "%B(%A+0x%lx): kunne ikke afkode instruktion til XTENSA_ASM_SIMPLIFY-relokering; mulig konfigurationsmodstrid"

#: elf32-xtensa.c:9024
msgid "invalid relocation address"
msgstr "ugyldig relokeringsadresse"

#: elf32-xtensa.c:9073
msgid "overflow after relaxation"
msgstr "overløb efter forenkling"

#: elf32-xtensa.c:10205
msgid "%B(%A+0x%lx): unexpected fix for %s relocation"
msgstr "%B(%A+0x%lx): uventet fiks til %s-relokering"

#: elf64-alpha.c:460
msgid "GPDISP relocation did not find ldah and lda instructions"
msgstr "GPDISP-relokering fandt ingen ldah- og lda-instruktioner"

#: elf64-alpha.c:2408
msgid "%B: .got subsegment exceeds 64K (size %d)"
msgstr "%B: .got-subsegment overskrider 64K (størrelse %d)"

#: elf64-alpha.c:4304 elf64-alpha.c:4316
msgid "%B: gp-relative relocation against dynamic symbol %s"
msgstr "%B: gp-relativ relokering mod dynamisk symbol %s"

#: elf64-alpha.c:4342 elf64-alpha.c:4477
msgid "%B: pc-relative relocation against dynamic symbol %s"
msgstr "%B: pc-relativ relokering mod dynamisk symbol %s"

#: elf64-alpha.c:4370
msgid "%B: change in gp: BRSGP %s"
msgstr "%B: ændring i gp: BRSGP %s"

#: elf64-alpha.c:4395
msgid "<unknown>"
msgstr "<ukendt>"

#: elf64-alpha.c:4400
msgid "%B: !samegp reloc against symbol without .prologue: %s"
msgstr "%B: !samegp-relokering mod symbol uden .prologue: %s"

#: elf64-alpha.c:4452
msgid "%B: unhandled dynamic relocation against %s"
msgstr "%B: uhåndteret dynamisk relokering mod %s"

#: elf64-alpha.c:4484
msgid "%B: pc-relative relocation against undefined weak symbol %s"
msgstr "%B: pc-relativ relokering mod udefineret svagt symbol %s"

#: elf64-alpha.c:4544
msgid "%B: dtp-relative relocation against dynamic symbol %s"
msgstr "%B: dtp-relativ relokering mod dynamisk symbol %s"

#: elf64-alpha.c:4567
msgid "%B: tp-relative relocation against dynamic symbol %s"
msgstr "%B: tp-relativ relokering mod dynamisk symbol %s"

#: elf64-hppa.c:2101
#, c-format
msgid "stub entry for %s cannot load .plt, dp offset = %ld"
msgstr "stubpost for %s kan ikke indlæse .plt, dp-afstand = %ld"

#: elf64-hppa.c:3299
msgid "%B(%A+0x%lx): cannot reach %s"
msgstr "%B(%A+0x%lx): kan ikke nå %s"

#: elf64-mmix.c:1177
#, c-format
msgid ""
"%s: Internal inconsistency error for value for\n"
" linker-allocated global register: linked: 0x%lx%08lx != relaxed: 0x%lx%08lx\n"
msgstr ""
"%s: Intern inkonsistensfejl for værdien for\n"
" lænkerallokeret globalt register: lænket: 0x%lx%08lx != forenklet: 0x%lx%08lx\n"

#: elf64-mmix.c:1607
#, c-format
msgid "%s: base-plus-offset relocation against register symbol: (unknown) in %s"
msgstr "%s: base-plus-afstandsrelokering mod registersymbol: (ukendt) i %s"

#: elf64-mmix.c:1612
#, c-format
msgid "%s: base-plus-offset relocation against register symbol: %s in %s"
msgstr "%s: base-plus-afstandsrelokering mod registersymbol: %s i %s"

#: elf64-mmix.c:1656
#, c-format
msgid "%s: register relocation against non-register symbol: (unknown) in %s"
msgstr "%s: registerrelokering mod ikke-registersymbol: (ukendt) i %s"

#: elf64-mmix.c:1661
#, c-format
msgid "%s: register relocation against non-register symbol: %s in %s"
msgstr "%s: registerrelokering mod ikke-registersymbol: %s i %s"

#: elf64-mmix.c:1698
#, c-format
msgid "%s: directive LOCAL valid only with a register or absolute value"
msgstr "%s: LOCAL-direktivet er kun gyldigt med et register eller en absolutværdi"

#: elf64-mmix.c:1726
#, c-format
msgid "%s: LOCAL directive: Register $%ld is not a local register.  First global register is $%ld."
msgstr "%s: LOCAL-direktiv: Register $%ld er ikke et lokalt register. Første globale register er $%ld."

#: elf64-mmix.c:2190
#, c-format
msgid "%s: Error: multiple definition of `%s'; start of %s is set in a earlier linked file\n"
msgstr "%s: Fejl: flere definitioner af \"%s\"; begyndelsen på %s er sat i en tidligere lænket fil\n"

#: elf64-mmix.c:2248
msgid "Register section has contents\n"
msgstr "Registersektion har indhold\n"

#: elf64-mmix.c:2440
#, c-format
msgid ""
"Internal inconsistency: remaining %u != max %u.\n"
"  Please report this bug."
msgstr ""
"Intern inkonsekvens: genstående %u != max %u.\n"
"  Rapportér gerne denne fejl."

#: elf64-ppc.c:2741 libbfd.c:997
msgid "%B: compiled for a big endian system and target is little endian"
msgstr "%B: kompileret til et big endian-system, men målet er little endian"

#: elf64-ppc.c:2744 libbfd.c:999
msgid "%B: compiled for a little endian system and target is big endian"
msgstr "%B: kompileret til et little endian-system, men målet er big endian"

# lazy (i computersammenhæng) ~ først at gøre noget, når det er nødvendigt.  Hvis programmøren skriver x = 2 + 2 men først bruger variablen x senere, vil udregningen 2+2 altså først ske senere.
#: elf64-ppc.c:6473
#, c-format
msgid "copy reloc against `%s' requires lazy plt linking; avoid setting LD_BIND_NOW=1 or upgrade gcc"
msgstr "kopiering af relokering mod \"%s\" kræver forsinket plt-lænkning; undgå at sætte LD_BIND_NOW=1 eller opgradér gcc"

#: elf64-ppc.c:6901
msgid "dynreloc miscount for %B, section %A"
msgstr "dynreloc-fejloptælling for %B, sektion %A"

#: elf64-ppc.c:6985
msgid "%B: .opd is not a regular array of opd entries"
msgstr "%B: .opd er ikke et almindeligt array af opd-poster"

#: elf64-ppc.c:6994
msgid "%B: unexpected reloc type %u in .opd section"
msgstr "%B: uventet relokeringstype %u i .opd-sektion"

#: elf64-ppc.c:7015
msgid "%B: undefined sym `%s' in .opd section"
msgstr "%B: udefineret symbol \"%s\" i .opd-sektion"

#: elf64-ppc.c:7877 elf64-ppc.c:8392
#, c-format
msgid "%s defined on removed toc entry"
msgstr "%s defineret på fjernet toc-post"

#: elf64-ppc.c:9459
#, c-format
msgid "long branch stub `%s' offset overflow"
msgstr "afsætoverløb for lang grenstub \"%s\""

#: elf64-ppc.c:9518
#, c-format
msgid "can't find branch stub `%s'"
msgstr "kan ikke finde grenstub \"%s\""

#: elf64-ppc.c:9580 elf64-ppc.c:9716
#, c-format
msgid "linkage table error against `%s'"
msgstr "lænketabelsfejl mod \"%s\""

#: elf64-ppc.c:9886
#, c-format
msgid "can't build branch stub `%s'"
msgstr "kan ikke bygge grenstub \"%s\""

#: elf64-ppc.c:10684
msgid "%B section %A exceeds stub group size"
msgstr "%B-sektionen %A overstiger stub-gruppestørrelsen"

# ?
#: elf64-ppc.c:11339
#, c-format
msgid ""
"linker stubs in %u group%s\n"
"  branch       %lu\n"
"  toc adjust   %lu\n"
"  long branch  %lu\n"
"  long toc adj %lu\n"
"  plt call     %lu"
msgstr ""
"lænkerstubbe i %u gruppe%s\n"
"  branch       %lu\n"
"  toc adjust   %lu\n"
"  long branch  %lu\n"
"  long toc adj %lu\n"
"  plt call     %lu"

#: elf64-ppc.c:12190
msgid "%B(%A+0x%lx): automatic multiple TOCs not supported using your crt files; recompile with -mminimal-toc or upgrade gcc"
msgstr "%B(%A+0x%lx): flere automatiske TOC'er understøttes ikke med dine crt-filer; genkompilér med -mminimal-toc eller opgradér gcc"

#: elf64-ppc.c:12198
msgid "%B(%A+0x%lx): sibling call optimization to `%s' does not allow automatic multiple TOCs; recompile with -mminimal-toc or -fno-optimize-sibling-calls, or make `%s' extern"
msgstr "%B(%A+0x%lx): \"sibling call\"-optimering til \"%s\" tillader ikke flere indholdsfortegnelser; genkompilér med -mminimal-toc eller -fno-optimize-sibling-calls eller gør \"%s\" ekstern"

#: elf64-ppc.c:12919
msgid "%B: relocation %s is not supported for symbol %s."
msgstr "%B: relokeringen %s understøttes ikke for symbol %s."

#: elf64-ppc.c:13096
msgid "%B: error: relocation %s not a multiple of %d"
msgstr "%B: fejl: relokeringen %s er ikke et multiplum af %d"

#: elf64-sh64.c:1682
#, c-format
msgid "%s: error: unaligned relocation type %d at %08x reloc %08x\n"
msgstr "%s: fejl: ujusteret relokeringstype %d på %08x relokering %08x\n"

#: elf64-sparc.c:444
msgid "%B: Only registers %%g[2367] can be declared using STT_REGISTER"
msgstr "%B: Kun registrene %%g[2367] kan erklæres med STT_REGISTER"

#: elf64-sparc.c:464
msgid "Register %%g%d used incompatibly: %s in %B, previously %s in %B"
msgstr "Register %%g%d bruges inkompatibelt: %s i %B, tidligere %s i %B"

#: elf64-sparc.c:487
msgid "Symbol `%s' has differing types: REGISTER in %B, previously %s in %B"
msgstr "Symbolet \"%s\" har forskellige typer: REGISTER i %B, tidligere %s i %B"

#: elf64-sparc.c:532
msgid "Symbol `%s' has differing types: %s in %B, previously REGISTER in %B"
msgstr "Symbolet \"%s\" har forskellige typer: %s i %B, tidligere REGISTER i %B"

#: elf64-sparc.c:684
msgid "%B: linking UltraSPARC specific with HAL specific code"
msgstr "%B: lænker UltraSPARC-specifik med HAL-specifik kode"

#: elf64-x86-64.c:1360
msgid "%B: '%s' accessed both as normal and thread local symbol"
msgstr "%B: \"%s\" tilgås både som normalt og trådlokalt symbol"

#: elf64-x86-64.c:2801
msgid "%B: relocation %s against STT_GNU_IFUNC symbol `%s' has non-zero addend: %d"
msgstr "%B: relokering %s mod STT_GNU_IFUNC-symbol \"%s\" har addend forskellig fra nul: %d"

#: elf64-x86-64.c:3073
msgid "%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"
msgstr "%B: relokeringen R_X86_64_GOTOFF64 mod beskyttet funktion \"%s\" kan ikke bruges når et delt objekt oprettes"

#: elf64-x86-64.c:3184
msgid "; recompile with -fPIC"
msgstr "; genkompilér med -fPIC"

#: elf64-x86-64.c:3189
msgid "%B: relocation %s against %s `%s' can not be used when making a shared object%s"
msgstr "%B: relokeringen %s mod %s \"%s\" kan ikke bruges når et delt objekt oprettes%s"

#: elf64-x86-64.c:3191
msgid "%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s"
msgstr "%B: relokeringen %s mod udefineret %s \"%s\" kan ikke bruges når et delt objekt oprettes%s"

#: elfcode.h:826
#, c-format
msgid "warning: %s has a corrupt string table index - ignoring"
msgstr "advarsel: %s har et beskadiget strengtabelindeks - ignorerer"

#: elfcode.h:1236
#, c-format
msgid "%s: version count (%ld) does not match symbol count (%ld)"
msgstr "%s: versionsantal (%ld) stemmer ikke med symbolantal (%ld)"

#: elfcode.h:1476
#, c-format
msgid "%s(%s): relocation %d has invalid symbol index %ld"
msgstr "%s(%s): relokering %d har ugyligt symbolindeks %ld"

#: elfcore.h:312
msgid "Warning: %B is truncated: expected core file size >= %lu, found: %lu."
msgstr "Advarsel: %B er afkortet: forventede kernefilstørrelse >= %lu, fandt: %lu."

#: elflink.c:1119
msgid "%s: TLS definition in %B section %A mismatches non-TLS definition in %B section %A"
msgstr "%s: TLS-definition i %B sektion %A stemmer ikke med ikke-TLS-definition i %B sektion %A"

#: elflink.c:1123
msgid "%s: TLS reference in %B mismatches non-TLS reference in %B"
msgstr "%s: TLS-reference i %B stemmer ikke med ikke-TLS-reference i %B"

#: elflink.c:1127
msgid "%s: TLS definition in %B section %A mismatches non-TLS reference in %B"
msgstr "%s: TLS-definition i %B sektion %A stemmer ikke med ikke-TLS-reference i %B"

#: elflink.c:1131
msgid "%s: TLS reference in %B mismatches non-TLS definition in %B section %A"
msgstr "%s: TLS-reference i %B stemmer ikke med ikke-TLS-definition i %B sektion %A"

#: elflink.c:1763
msgid "%B: unexpected redefinition of indirect versioned symbol `%s'"
msgstr "%B: uventet omdefinition af indirekte versionstildelt symbol \"%s\""

#: elflink.c:2076
msgid "%B: version node not found for symbol %s"
msgstr "%B: versionsknude ikke fundet for symbolet %s"

#: elflink.c:2166
msgid "%B: bad reloc symbol index (0x%lx >= 0x%lx) for offset 0x%lx in section `%A'"
msgstr "%B: fejlagtig relokeringssymbolindeks (0x%lx >= 0x%lx) for afsæt 0x%lx i sektionen \"%A\""

#: elflink.c:2177
msgid "%B: non-zero symbol index (0x%lx) for offset 0x%lx in section `%A' when the object file has no symbol table"
msgstr "%B: symboltabellen (0x%lx) forskelligt fra nul for afsæt 0x%lx i sektion \"%s\" mens objektfilen ikke har nogen symboltabelc"

#: elflink.c:2367
msgid "%B: relocation size mismatch in %B section %A"
msgstr "%B: relokeringsstørrelsen stemmer ikke overens i %B-sektionen %A"

#: elflink.c:2662
#, c-format
msgid "warning: type and size of dynamic symbol `%s' are not defined"
msgstr "advarsel: typen og størrelsen på dynamisk symbol \"%s\" er ikke defineret"

#: elflink.c:3418
msgid "%P: alternate ELF machine code found (%d) in %B, expecting %d\n"
msgstr "%P: alternativ ELF-maskinkode fundet (%d) i %B; forventer %d\n"

#: elflink.c:4050
msgid "%B: %s: invalid version %u (max %d)"
msgstr "%B: %s: ugyldig version %u (max %d)"

#: elflink.c:4086
msgid "%B: %s: invalid needed version %d"
msgstr "%B: %s: ugyldig krævet version %d"

#: elflink.c:4285
msgid "Warning: alignment %u of common symbol `%s' in %B is greater than the alignment (%u) of its section %A"
msgstr "Advarsel: justering %u af fælles symbol \"%s\" i %B er større end justeringen (%u) af dets sektion %A"

#: elflink.c:4291
msgid "Warning: alignment %u of symbol `%s' in %B is smaller than %u in %B"
msgstr "Advarsel: justeringen %u på symbolet \"%s\" i %B er mindre end %u i %B"

#: elflink.c:4306
msgid "Warning: size of symbol `%s' changed from %lu in %B to %lu in %B"
msgstr "Advarsel: størrelsen på symbol \"%s\" ændredes fra %lu i %B til %lu i %B"

#: elflink.c:4472
msgid "%B: undefined reference to symbol '%s'"
msgstr "%B: udefineret reference til symbol \"%s\""

#: elflink.c:4475
msgid "note: '%s' is defined in DSO %B so try adding it to the linker command line"
msgstr "bemærk: \"%s\" er defineret i DSO %B, så prøv at tilføje den til lænker-kommandolinjen"

#: elflink.c:5779
#, c-format
msgid "%s: undefined version: %s"
msgstr "%s: udefineret version: %s"

#: elflink.c:5847
msgid "%B: .preinit_array section is not allowed in DSO"
msgstr "%B: .preinit_array-sektionen er ikke tilladt i DSO"

#: elflink.c:7598
#, c-format
msgid "undefined %s reference in complex symbol: %s"
msgstr "udefineret %s-reference i komplekst symbol: %s"

#: elflink.c:7752
#, c-format
msgid "unknown operator '%c' in complex symbol"
msgstr "ukendt operator \"%c\" i komplekst symbol"

#: elflink.c:8091 elflink.c:8108 elflink.c:8145 elflink.c:8162
msgid "%B: Unable to sort relocs - they are in more than one size"
msgstr "%B: Kan ikke sortere relokeringer - de har flere forskellige størrelser"

#: elflink.c:8122 elflink.c:8176
msgid "%B: Unable to sort relocs - they are of an unknown size"
msgstr "%B: Kan ikke sortere relokeringer - de har ukendt størrelse"

#: elflink.c:8227
msgid "Not enough memory to sort relocations"
msgstr "Ikke nok hukommelse til at sortere relokeringer"

#: elflink.c:8420
msgid "%B: Too many sections: %d (>= %d)"
msgstr "%B: For mange sektioner: %d (>= %d)"

#: elflink.c:8663
msgid "%B: %s symbol `%s' in %B is referenced by DSO"
msgstr "%B: %s-symbol \"%s\" i %B refereres af DSO"

#: elflink.c:8754
msgid "%B: could not find output section %A for input section %A"
msgstr "%B: kunne ikke finde uddatasektionen %A for inddatasektionen %A"

#: elflink.c:8874
msgid "%B: %s symbol `%s' isn't defined"
msgstr "%B: %s-symbolet \"%s\" er udefineret"

#: elflink.c:9428
msgid "error: %B contains a reloc (0x%s) for section %A that references a non-existent global symbol"
msgstr "fejl: %B indeholder en relokering (0x%s) til sektionen %A, som refererer et ikke-eksisterende global symbol"

#: elflink.c:9494
msgid "%X`%s' referenced in section `%A' of %B: defined in discarded section `%A' of %B\n"
msgstr "%X\"%s\" refereret i sektion \"%A\" af %B: defineret i forkastet sektion \"%A\" af %B\n"

#: elflink.c:10141
msgid "%A has both ordered [`%A' in %B] and unordered [`%A' in %B] sections"
msgstr "%A har både ordnede [\"%A\" i %B] og uordnede [\"%A\" i %B] sektioner"

#: elflink.c:10146
#, c-format
msgid "%A has both ordered and unordered sections"
msgstr "%A har både ordnede og uordnede sektioner"

#: elflink.c:10992 elflink.c:11036
msgid "%B: could not find output section %s"
msgstr "%B: kunne ikke finde uddatasektionen %s"

#: elflink.c:10997
#, c-format
msgid "warning: %s section has zero size"
msgstr "advarsel: %s-sektionen har nulstørrelse"

#: elflink.c:11102
msgid "%P: warning: creating a DT_TEXTREL in a shared object.\n"
msgstr "%P: advarsel: opretter en DT_TEXTREL i et delt objekt.\n"

#: elflink.c:11289
msgid "%P%X: can not read symbols: %E\n"
msgstr "%P%X: kan ikke læse symboler: %E\n"

#: elflink.c:11638
msgid "Removing unused section '%s' in file '%B'"
msgstr "Fjerner ubrugt sektion \"%s\" i filen \"%B\""

# gc-sections- eller gc-sektions-?
#: elflink.c:11850
msgid "Warning: gc-sections option ignored"
msgstr "Advarsel: gc-sections-tilvalg ignoreret"

#: elflink.c:12399
msgid "%B: ignoring duplicate section `%A'"
msgstr "%B: ignorerer gentaget sektion \"%A\""

#: elflink.c:12406 elflink.c:12413
msgid "%B: duplicate section `%A' has different size"
msgstr "%B: gentaget sektion \"%A\" har forskellig størrelse"

#: elflink.c:12421 elflink.c:12426
msgid "%B: warning: could not read contents of section `%A'"
msgstr "%B: advarsel: kunne ikke læse indholdet af sektionen \"%A\""

#: elflink.c:12430
msgid "%B: warning: duplicate section `%A' has different contents"
msgstr "%B: advarsel: gentaget sektion \"%A\" har forskelligt indhold"

#: elflink.c:12531 linker.c:3138
msgid "%F%P: already_linked_table: %E\n"
msgstr "%F%P: already_linked_table: %E\n"

#: elfxx-mips.c:1220
msgid "static procedure (no name)"
msgstr "statisk procedure (intet navn)"

#: elfxx-mips.c:5623
msgid "%B: %A+0x%lx: Direct jumps between ISA modes are not allowed; consider recompiling with interlinking enabled."
msgstr "%B: %A+0x%lx: Direkte hop mellem ISA-tilstande er ikke tilladt; overvej at genkompilere med interlinking slået til."

#: elfxx-mips.c:6280 elfxx-mips.c:6503
msgid "%B: Warning: bad `%s' option size %u smaller than its header"
msgstr "%B: Advarsel: Ugyldig \"%s\"-tilvalgsstørrelse %u mindre end dens header"

#: elfxx-mips.c:7254 elfxx-mips.c:7379
msgid "%B: Warning: cannot determine the target function for stub section `%s'"
msgstr "%B: Advarsel: Kan ikke bestemme målfunktionen for stubsektionen \"%s\""

#: elfxx-mips.c:7508
msgid "%B: Malformed reloc detected for section %s"
msgstr "%B: Fejlagtig relokering for sektion %s opdaget"

#: elfxx-mips.c:7548
msgid "%B: GOT reloc at 0x%lx not expected in executables"
msgstr "%B: GOT-relokering ved 0x%lx forventes ikke i eksekveringsfiler"

#: elfxx-mips.c:7670
msgid "%B: CALL16 reloc at 0x%lx not against global symbol"
msgstr "%B: CALL16-relokering ved 0x%lx er ikke mod globalt symbol"

#: elfxx-mips.c:8365
#, c-format
msgid "non-dynamic relocations refer to dynamic symbol %s"
msgstr "udynamiske relokeringer refererer til dynamisk symbol %s"

#: elfxx-mips.c:9068
msgid "%B: Can't find matching LO16 reloc against `%s' for %s at 0x%lx in section `%A'"
msgstr "%B: Kan ikke finde matchende LO16-relokering mod \"%s\" for %s ved 0x%lx i sektion \"%A\""

#: elfxx-mips.c:9207
msgid "small-data section exceeds 64KB; lower small-data size limit (see option -G)"
msgstr "sektionen small-data overstiger 6KB; gør størrelsesgrænsen for small-data mindre (se tilvalget -G)"

#: elfxx-mips.c:12027
#, c-format
msgid "%s: illegal section name `%s'"
msgstr "%s: ugyldigt sektionsnavn \"%s\""

#: elfxx-mips.c:12405 elfxx-mips.c:12431
msgid "Warning: %B uses -msingle-float, %B uses -mdouble-float"
msgstr "Advarsel: %B bruger -msingle-float, %B bruger -mdouble-float"

#: elfxx-mips.c:12417 elfxx-mips.c:12473
msgid "Warning: %B uses -msingle-float, %B uses -mips32r2 -mfp64"
msgstr "Advarsel: %B bruger -msingle-float, %B bruger -mips32r2 -mfp64"

#: elfxx-mips.c:12443 elfxx-mips.c:12479
msgid "Warning: %B uses -mdouble-float, %B uses -mips32r2 -mfp64"
msgstr "Advarsel: %B bruger -mdouble-float, %B bruger -mips32r2 -mfp64"

#: elfxx-mips.c:12521
msgid "%B: endianness incompatible with that of the selected emulation"
msgstr "%B: endian-hed er ikke kompatibel den valgte emulerings endian-hed"

#: elfxx-mips.c:12532
msgid "%B: ABI is incompatible with that of the selected emulation"
msgstr "%B: ABI er ikke kompatibel med den valgte emulerings ABI"

#: elfxx-mips.c:12613
msgid "%B: warning: linking abicalls files with non-abicalls files"
msgstr "%B: advarsel: lænker abicalls-filer med ikke-abicalls-filer"

#: elfxx-mips.c:12630
msgid "%B: linking 32-bit code with 64-bit code"
msgstr "%B: lænker 32 bit-kode med 64 bit-kode"

#: elfxx-mips.c:12658
msgid "%B: linking %s module with previous %s modules"
msgstr "%B: lænker %s-modul med tidligere %s-moduler"

#: elfxx-mips.c:12681
msgid "%B: ABI mismatch: linking %s module with previous %s modules"
msgstr "%B: ABI passer ikke: lænker %s-modul med tidligere %s-moduler"

#: elfxx-mips.c:12845
#, c-format
msgid " [abi=O32]"
msgstr " [abi=O32]"

#: elfxx-mips.c:12847
#, c-format
msgid " [abi=O64]"
msgstr " [abi=O64]"

#: elfxx-mips.c:12849
#, c-format
msgid " [abi=EABI32]"
msgstr " [abi=EABI32]"

#: elfxx-mips.c:12851
#, c-format
msgid " [abi=EABI64]"
msgstr " [abi=EABI64]"

#: elfxx-mips.c:12853
#, c-format
msgid " [abi unknown]"
msgstr " [ukendt abi]"

#: elfxx-mips.c:12855
#, c-format
msgid " [abi=N32]"
msgstr " [abi=N32]"

#: elfxx-mips.c:12857
#, c-format
msgid " [abi=64]"
msgstr " [abi=64]"

#: elfxx-mips.c:12859
#, c-format
msgid " [no abi set]"
msgstr " [intet abi sat]"

#: elfxx-mips.c:12880
#, c-format
msgid " [unknown ISA]"
msgstr " [ukendt ISA]"

#: elfxx-mips.c:12891
#, c-format
msgid " [not 32bitmode]"
msgstr " [ikke 32-bittilstand]"

#: elfxx-sparc.c:595
#, c-format
msgid "invalid relocation type %d"
msgstr "ugyldig relokeringstype %d"

#: i386linux.c:454 m68klinux.c:458 sparclinux.c:452
#, c-format
msgid "Output file requires shared library `%s'\n"
msgstr "Uddatafilen kræver delt bibliotek \"%s\"\n"

#: i386linux.c:462 m68klinux.c:466 sparclinux.c:460
#, c-format
msgid "Output file requires shared library `%s.so.%s'\n"
msgstr "Uddatafilen kræver delt bibliotek \"%s.so.%s\"\n"

#: i386linux.c:651 i386linux.c:701 m68klinux.c:658 m68klinux.c:706
#: sparclinux.c:650 sparclinux.c:700
#, c-format
msgid "Symbol %s not defined for fixups\n"
msgstr "Symbol %s er ikke defineret for rettelser\n"

#: i386linux.c:725 m68klinux.c:730 sparclinux.c:724
msgid "Warning: fixup count mismatch\n"
msgstr "Advarsel: antal rettelser stemmer ikke\n"

#: ieee.c:159
#, c-format
msgid "%s: string too long (%d chars, max 65535)"
msgstr "%s: strengen er for lang (%d tegn, max 65535)"

#: ieee.c:286
#, c-format
msgid "%s: unrecognized symbol `%s' flags 0x%x"
msgstr "%s: ukendt symbol \"%s\" flag 0x%x"

#: ieee.c:792
msgid "%B: unimplemented ATI record %u for symbol %u"
msgstr "%B: ikke-implementeret ATI-post %u for symbol %u"

#: ieee.c:816
msgid "%B: unexpected ATN type %d in external part"
msgstr "%B: uventet ATN-type %d i ekstern del"

#: ieee.c:838
msgid "%B: unexpected type after ATN"
msgstr "%B: uventet type efter ATN"

#: ihex.c:230
msgid "%B:%d: unexpected character `%s' in Intel Hex file"
msgstr "%B:%d: uventet tegn \"%s\" i heksadecimal Intel-fil"

#: ihex.c:337
msgid "%B:%u: bad checksum in Intel Hex file (expected %u, found %u)"
msgstr "%B:%u: fejlagtig kontrolsum i heksadecimal Intel-fil (forventede %u, fandt %u)"

#: ihex.c:392
msgid "%B:%u: bad extended address record length in Intel Hex file"
msgstr "%B:%u: fejlagtig længde på post for udvidet adresse i heksadecimal Intel-fil"

#: ihex.c:409
msgid "%B:%u: bad extended start address length in Intel Hex file"
msgstr "%B:%u: fejlagtig længde på udvidet startadresse i heksadecimal Intel-fil"

#: ihex.c:426
msgid "%B:%u: bad extended linear address record length in Intel Hex file"
msgstr "%B:%u: fejlagtig længde på post for udvidet lineær adresse i heksadecimal Intel-fil"

#: ihex.c:443
msgid "%B:%u: bad extended linear start address length in Intel Hex file"
msgstr "%B:%u: fejlagtig længde på udvidet lineær startadresse i heksadecimal Intel-fil"

#: ihex.c:460
msgid "%B:%u: unrecognized ihex type %u in Intel Hex file"
msgstr "%B:%u: ukendt ihex-type %u i heksadecimal Intel-fil"

#: ihex.c:579
msgid "%B: internal error in ihex_read_section"
msgstr "%B: intern fejl i ihex_read_section"

#: ihex.c:613
msgid "%B: bad section length in ihex_read_section"
msgstr "%B: fejlagtig sektionslængde i ihex_read_sektion"

#: ihex.c:826
#, c-format
msgid "%s: address 0x%s out of range for Intel Hex file"
msgstr "%s: adressen 0x%s er uden for intervallet for heksadecimal Intel-fil"

#: libbfd.c:863
msgid "%B: unable to get decompressed section %A"
msgstr "%B: kan ikke hente dekomprimeret sektion %A"

#: libbfd.c:1027
#, c-format
msgid "Deprecated %s called at %s line %d in %s\n"
msgstr "Forældet %s kaldt ved %s linje %d i %s\n"

#: libbfd.c:1030
#, c-format
msgid "Deprecated %s called\n"
msgstr "Forældet %s kaldt\n"

#: linker.c:1911
msgid "%B: indirect symbol `%s' to `%s' is a loop"
msgstr "%B: indirekte symbol \"%s\" til \"%s\" er en løkke"

#: linker.c:2778
#, c-format
msgid "Attempt to do relocatable link with %s input and %s output"
msgstr "Forsøg at lave en relokérbar lænke med %s-inddata og %s-uddata"

#: linker.c:3105
msgid "%B: warning: ignoring duplicate section `%A'\n"
msgstr "%B: advarsel: ignorerer gentaget sektion \"%A\"\n"

#: linker.c:3119
msgid "%B: warning: duplicate section `%A' has different size\n"
msgstr "%B: advarsel: gentaget sektion \"%A\" har forskellig længde\n"

#: mach-o.c:3403
msgid "Mach-O header:\n"
msgstr "Mach-O-header:\n"

# eller skal det være magisk tal?
#: mach-o.c:3404
#, c-format
msgid " magic     : %08lx\n"
msgstr " magi      : %08lx\n"

#: mach-o.c:3405
#, c-format
msgid " cputype   : %08lx (%s)\n"
msgstr " cputype   : %08lx (%s)\n"

#: mach-o.c:3407
#, c-format
msgid " cpusubtype: %08lx\n"
msgstr " cpusubtype: %08lx\n"

#: mach-o.c:3408
#, c-format
msgid " filetype  : %08lx (%s)\n"
msgstr " filtype   : %08lx (%s)\n"

# ?
#: mach-o.c:3411
#, c-format
msgid " ncmds     : %08lx (%lu)\n"
msgstr " nkmd'er   : %08lx (%lu)\n"

# kan ikke så godt gøre de her konsistente
#: mach-o.c:3412
#, c-format
msgid " sizeofcmds: %08lx\n"
msgstr " sizeofcmds: %08lx\n"

#: mach-o.c:3413
#, c-format
msgid " flags     : %08lx ("
msgstr " flag      : %08lx ("

#: mach-o.c:3415 vms-alpha.c:7652
msgid ")\n"
msgstr ")\n"

#: mach-o.c:3416
#, c-format
msgid " reserved  : %08x\n"
msgstr " reserveret: %08x\n"

#: mach-o.c:3426
msgid "Segments and Sections:\n"
msgstr "Segmenter og sektioner:\n"

#: mach-o.c:3427
msgid " #: Segment name     Section name     Address\n"
msgstr " #: Segmentnavn      Sektionsnavn     Adresse\n"

#: merge.c:832
#, c-format
msgid "%s: access beyond end of merged section (%ld)"
msgstr "%s: tilgang ud over slutningen på sammenflettet sektion (%ld)"

#: mmo.c:456
#, c-format
msgid "%s: No core to allocate section name %s\n"
msgstr "%s: Ingen kerne til at allokere sektionsnavn %s\n"

#: mmo.c:531
#, c-format
msgid "%s: No core to allocate a symbol %d bytes long\n"
msgstr "%s: Ingen kerne til at allokere et %d byte langt symbol\n"

#: mmo.c:1187
#, c-format
msgid "%s: invalid mmo file: initialization value for $255 is not `Main'\n"
msgstr "%s: ugyldig mmo-fil: initieringsværdi for $255 er ikke \"Main\"\n"

#: mmo.c:1332
#, c-format
msgid "%s: unsupported wide character sequence 0x%02X 0x%02X after symbol name starting with `%s'\n"
msgstr "%s: bred tegn-sekvens som ikke understøttes 0x%02X 0x%02X efter symbolnavnet som begynder med \"%s\"\n"

#: mmo.c:1565
#, c-format
msgid "%s: invalid mmo file: unsupported lopcode `%d'\n"
msgstr "%s: ugyldig mmo-fil: lopkode \"%d\" understøttes ikke\n"

#: mmo.c:1575
#, c-format
msgid "%s: invalid mmo file: expected YZ = 1 got YZ = %d for lop_quote\n"
msgstr "%s: ugyldig mmo-fil: forventede YZ = 1 fik YZ = %d for lop_quote\n"

#: mmo.c:1611
#, c-format
msgid "%s: invalid mmo file: expected z = 1 or z = 2, got z = %d for lop_loc\n"
msgstr "%s: ugyldig mmo-fil: forventede z = 1 eller z = 2, fik z = %d for lop_loc\n"

#: mmo.c:1657
#, c-format
msgid "%s: invalid mmo file: expected z = 1 or z = 2, got z = %d for lop_fixo\n"
msgstr "%s: ugyldig mmo-fil: forventede z = 1 eller z = 2, fik z = %d for lop_fixo\n"

#: mmo.c:1696
#, c-format
msgid "%s: invalid mmo file: expected y = 0, got y = %d for lop_fixrx\n"
msgstr "%s: ugyldig mmo-fil: forventede y = 0, fik y = %d for lop_fixrx\n"

#: mmo.c:1705
#, c-format
msgid "%s: invalid mmo file: expected z = 16 or z = 24, got z = %d for lop_fixrx\n"
msgstr "%s: ugyldig mmo-fil: forventede z = 16 eller z = 24, fik z = %d for lop_fixr\n"

#: mmo.c:1728
#, c-format
msgid "%s: invalid mmo file: leading byte of operand word must be 0 or 1, got %d for lop_fixrx\n"
msgstr "%s: ugyldig mmo-fil: indledende byte i operandord skal være 0 eller 1, fik %d for lop_fixrx\n"

#: mmo.c:1751
#, c-format
msgid "%s: cannot allocate file name for file number %d, %d bytes\n"
msgstr "%s: kan ikke allokere filnavn for fil nummer %d, %d byte\n"

#: mmo.c:1771
#, c-format
msgid "%s: invalid mmo file: file number %d `%s', was already entered as `%s'\n"
msgstr "%s: ugyldig mmo-fil: fil nummer %d \"%s\", var allerede angivet som \"%s\"\n"

#: mmo.c:1784
#, c-format
msgid "%s: invalid mmo file: file name for number %d was not specified before use\n"
msgstr "%s: ugyldig mmo-fil: filnavnet for nummer %d blev ikke angivet inden brug\n"

#: mmo.c:1890
#, c-format
msgid "%s: invalid mmo file: fields y and z of lop_stab non-zero, y: %d, z: %d\n"
msgstr "%s: ugyldig mmo-fil: felter y og z i lop_stab er ikke-tomme, y: %d, z: %d\n"

#: mmo.c:1926
#, c-format
msgid "%s: invalid mmo file: lop_end not last item in file\n"
msgstr "%s: ugyldig mmo-fil: lop_end er ikke sidste objekt i fil\n"

#: mmo.c:1939
#, c-format
msgid "%s: invalid mmo file: YZ of lop_end (%ld) not equal to the number of tetras to the preceding lop_stab (%ld)\n"
msgstr "%s: ugyldig mmo-fil: YZ i lop_end (%ld) er ikke lig med antal af tetraer til den foregående lop_stab (%ld)\n"

#: mmo.c:2649
#, c-format
msgid "%s: invalid symbol table: duplicate symbol `%s'\n"
msgstr "%s: ugyldig symboltabel: dubletsymbol \"%s\"\n"

#: mmo.c:2889
#, c-format
msgid "%s: Bad symbol definition: `Main' set to %s rather than the start address %s\n"
msgstr "%s: Fejlagtig symboldefinition: \"Main\" er sat til %s i stedet for startadressen %s\n"

#: mmo.c:2981
#, c-format
msgid "%s: warning: symbol table too large for mmo, larger than 65535 32-bit words: %d.  Only `Main' will be emitted.\n"
msgstr "%s: advarsel: symboltabellen er for stor for mmo, større end 65535 32-bit ord: %d. Kun \"Main\" vil blive sendt.\n"

#: mmo.c:3026
#, c-format
msgid "%s: internal error, symbol table changed size from %d to %d words\n"
msgstr "%s: intern fejl, symboltabellen ændrede størrelse fra %d til %d ord\n"

#: mmo.c:3078
#, c-format
msgid "%s: internal error, internal register section %s had contents\n"
msgstr "%s: intern fejl, den interne registersektion %s havde indhold\n"

#: mmo.c:3129
#, c-format
msgid "%s: no initialized registers; section length 0\n"
msgstr "%s: ingen initierede registre; sektionslængde 0\n"

#: mmo.c:3135
#, c-format
msgid "%s: too many initialized registers; section length %ld\n"
msgstr "%s: for mange initierede registre; sektionslængde %ld\n"

#: mmo.c:3140
#, c-format
msgid "%s: invalid start address for initialized registers of length %ld: 0x%lx%08lx\n"
msgstr "%s: ugyldig startadresse for initierede registre med længden %ld: 0x%lx%08lx\n"

#: oasys.c:882
#, c-format
msgid "%s: can not represent section `%s' in oasys"
msgstr "%s: kan ikke repræsentere sektionen \"%s\" i oasys"

#: osf-core.c:140
#, c-format
msgid "Unhandled OSF/1 core file section type %d\n"
msgstr "Uhåndteret sektionstype %d for OSF/1-hukommelsesfil\n"

#: pe-mips.c:607
msgid "%B: `ld -r' not supported with PE MIPS objects\n"
msgstr "%B: \"ld -r\" understøttes ikke med PE MIPS-objekter\n"

#. OK, at this point the following variables are set up:
#. src = VMA of the memory we're fixing up
#. mem = pointer to memory we're fixing up
#. val = VMA of what we need to refer to.
#: pe-mips.c:719
msgid "%B: unimplemented %s\n"
msgstr "%B: uimplementeret %s\n"

#: pe-mips.c:745
msgid "%B: jump too far away\n"
msgstr "%B: hop for langt bort\n"

#: pe-mips.c:771
msgid "%B: bad pair/reflo after refhi\n"
msgstr "%B: fejlagtigt par/reflo efter refhi\n"

#: pei-x86_64.c:444
#, c-format
msgid "warning: .pdata section size (%ld) is not a multiple of %d\n"
msgstr "advarsel: størrelsen på .pdata-sektionen (%ld) er ikke et multiplum af %d\n"

#: pei-x86_64.c:448 peigen.c:1618 peigen.c:1801 pepigen.c:1618 pepigen.c:1801
#: pex64igen.c:1618 pex64igen.c:1801
#, c-format
msgid ""
"\n"
"The Function Table (interpreted .pdata section contents)\n"
msgstr ""
"\n"
"Funktionstabellen (tolket indhold fra .pdata-sektionen)\n"

#: pei-x86_64.c:450
#, c-format
msgid "vma:\t\t\tBeginAddress\t EndAddress\t  UnwindData\n"
msgstr "vma:\t\t\tStartadresse\t Slutadresse\t  Tilbagespolingsdata\n"

#. XXX code yet to be written.
#: peicode.h:751
msgid "%B: Unhandled import type; %x"
msgstr "%B: Uhåndteret importtype; %x"

#: peicode.h:756
msgid "%B: Unrecognised import type; %x"
msgstr "%B: Ukendt importtype; %x"

#: peicode.h:770
msgid "%B: Unrecognised import name type; %x"
msgstr "%B: Ukendt importnavnstype; %x"

#: peicode.h:1162
msgid "%B: Unrecognised machine type (0x%x) in Import Library Format archive"
msgstr "%B: Ukendt maskintype (0x%x) i Import Library Format-arkiv"

#: peicode.h:1174
msgid "%B: Recognised but unhandled machine type (0x%x) in Import Library Format archive"
msgstr "%B: Genkendt men uhåndteret maskintype (0x%x) i Import Library Format-arkiv"

#: peicode.h:1192
msgid "%B: size field is zero in Import Library Format header"
msgstr "%B: størrelsesfeltet er nul i Import Library Format-header"

#: peicode.h:1223
msgid "%B: string not null terminated in ILF object file."
msgstr "%B: streng ikke nultermineret i ILF-objektfil."

#: ppcboot.c:414
#, c-format
msgid ""
"\n"
"ppcboot header:\n"
msgstr ""
"\n"
"ppcboot-hoved:\n"

#: ppcboot.c:415
#, c-format
msgid "Entry offset        = 0x%.8lx (%ld)\n"
msgstr "Startafstand        = 0x%.8lx (%ld)\n"

#: ppcboot.c:417
#, c-format
msgid "Length              = 0x%.8lx (%ld)\n"
msgstr "Længde              = 0x%.8lx (%ld)\n"

#: ppcboot.c:421
#, c-format
msgid "Flag field          = 0x%.2x\n"
msgstr "Flagfelt            = 0x%.2x\n"

#: ppcboot.c:427
#, c-format
msgid "Partition name      = \"%s\"\n"
msgstr "Partitionsnavn      = \"%s\"\n"

#: ppcboot.c:446
#, c-format
msgid ""
"\n"
"Partition[%d] start  = { 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x }\n"
msgstr ""
"\n"
"Start på partition[%d]  = { 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x }\n"

#: ppcboot.c:452
#, c-format
msgid "Partition[%d] end    = { 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x }\n"
msgstr "Slut på partition[%d]    = { 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x }\n"

#: ppcboot.c:458
#, c-format
msgid "Partition[%d] sector = 0x%.8lx (%ld)\n"
msgstr "Sektor for partition[%d] = 0x%.8lx (%ld)\n"

#: ppcboot.c:460
#, c-format
msgid "Partition[%d] length = 0x%.8lx (%ld)\n"
msgstr "Længde på partition[%d] = 0x%.8lx (%ld)\n"

#: som.c:5471
#, c-format
msgid ""
"\n"
"Exec Auxiliary Header\n"
msgstr ""
"\n"
"Ekstraheader til kørsel\n"

#: som.c:5776
msgid "som_sizeof_headers unimplemented"
msgstr "som_sizeof_headers er ikke implementeret"

#: srec.c:261
msgid "%B:%d: Unexpected character `%s' in S-record file\n"
msgstr "%B:%d: Uventet tegn \"%s\" i S-post-fil\n"

#: srec.c:567 srec.c:600
msgid "%B:%d: Bad checksum in S-record file\n"
msgstr "%B:%d: Dårlig tjeksum i S-post-fil\n"

# Hvad er stabs?
#: stabs.c:279
msgid "%B(%A+0x%lx): Stabs entry has invalid string index."
msgstr "%B(%A+0x%lx): Stabs-post har ugyldigt strengindeks."

#: syms.c:1079
msgid "Unsupported .stab relocation"
msgstr ".stab-relokering som ikke understøttes"

#: vms-alpha.c:1287
#, c-format
msgid "Unknown EGSD subtype %d"
msgstr "Ukendt EGSD-undertype %d"

#: vms-alpha.c:1318
#, c-format
msgid "Stack overflow (%d) in _bfd_vms_push"
msgstr "Stakken giver overløb (%d) i _bfd_vms_push"

#: vms-alpha.c:1331
msgid "Stack underflow in _bfd_vms_pop"
msgstr "Stakken giver underløb i _bfd_vms_pop"

#. These names have not yet been added to this switch statement.
#: vms-alpha.c:1568
#, c-format
msgid "unknown ETIR command %d"
msgstr "ukendt ETIR-kommando %d"

#: vms-alpha.c:1755
#, c-format
msgid "bad section index in %s"
msgstr "fejlagtigt sektionsindeks i %s"

#: vms-alpha.c:1768
#, c-format
msgid "unsupported STA cmd %s"
msgstr "STA-kommando %s understøttes ikke"

#. Insert field.
#. Unsigned shift.
#. Rotate.
#. Redefine symbol to current location.
#. Define a literal.
#: vms-alpha.c:1944 vms-alpha.c:1975 vms-alpha.c:2222
#, c-format
msgid "%s: not supported"
msgstr "%s: understøttes ikke"

#: vms-alpha.c:1950
#, c-format
msgid "%s: not implemented"
msgstr "%s: ikke implementeret"

#: vms-alpha.c:2206
#, c-format
msgid "invalid use of %s with contexts"
msgstr "ugyldig brug af %s med kontekster"

#: vms-alpha.c:2240
#, c-format
msgid "reserved cmd %d"
msgstr "reserveret kommando %d"

#: vms-alpha.c:2325
msgid "Object module NOT error-free !\n"
msgstr "Objektmodulet IKKE fejlfri!\n"

#: vms-alpha.c:2754
#, c-format
msgid "Symbol %s replaced by %s\n"
msgstr "Symbol %s erstattet med %s\n"

#: vms-alpha.c:3757
#, c-format
msgid "SEC_RELOC with no relocs in section %s"
msgstr "SEC_RELOC uden relokeringer i sektion %s"

#: vms-alpha.c:3810 vms-alpha.c:4041
#, c-format
msgid "Size error in section %s"
msgstr "Størrelsesfejl i sektion %s"

#: vms-alpha.c:3980
msgid "Spurious ALPHA_R_BSR reloc"
msgstr "Uægte ALPHA_R_BSD-relokering"

#: vms-alpha.c:4028
#, c-format
msgid "Unhandled relocation %s"
msgstr "Uhåndteret relokering %s"

#: vms-alpha.c:4318
#, c-format
msgid "unknown source command %d"
msgstr "ukendt kildekommando %d"

#: vms-alpha.c:4379
msgid "DST__K_SET_LINUM_INCR not implemented"
msgstr "DST__K_SET_LINUM_INCR er ikke implementeret"

#: vms-alpha.c:4385
msgid "DST__K_SET_LINUM_INCR_W not implemented"
msgstr "DST__K_SET_LINUM_INCR_W er ikke implementeret"

#: vms-alpha.c:4391
msgid "DST__K_RESET_LINUM_INCR not implemented"
msgstr "DST__K_RESET_LINUM_INCR ikke implementeret"

#: vms-alpha.c:4397
msgid "DST__K_BEG_STMT_MODE not implemented"
msgstr "DST__K_BEG_STMT_MODE er ikke implementeret"

#: vms-alpha.c:4403
msgid "DST__K_END_STMT_MODE not implemented"
msgstr "DST__K_END_STMT_MODE er ikke implementeret"

#: vms-alpha.c:4430
msgid "DST__K_SET_PC not implemented"
msgstr "DST__K_SET_PC er ikke implementeret"

#: vms-alpha.c:4436
msgid "DST__K_SET_PC_W not implemented"
msgstr "DST__K_SET_PC_W er ikke implementeret"

#: vms-alpha.c:4442
msgid "DST__K_SET_PC_L not implemented"
msgstr "DST__K_SET_PC_L er ikke implementeret"

#: vms-alpha.c:4448
msgid "DST__K_SET_STMTNUM not implemented"
msgstr "DST__K_SET_STMTNUM er ikke implementeret"

#: vms-alpha.c:4491
#, c-format
msgid "unknown line command %d"
msgstr "ukendt linjekommando %d"

#: vms-alpha.c:4938 vms-alpha.c:4955 vms-alpha.c:4969 vms-alpha.c:4984
#: vms-alpha.c:4996 vms-alpha.c:5007 vms-alpha.c:5019
#, c-format
msgid "Unknown reloc %s + %s"
msgstr "Ukendt relokering %s + %s"

#: vms-alpha.c:5074
#, c-format
msgid "Unknown reloc %s"
msgstr "Ukendt relokering %s"

#: vms-alpha.c:5087
msgid "Invalid section index in ETIR"
msgstr "Fejlagtigt sektionsindeks i ETIR"

#: vms-alpha.c:5134
#, c-format
msgid "Unknown symbol in command %s"
msgstr "Ugyldigt symbol i kommando %s"

#: vms-alpha.c:5649
#, c-format
msgid "  EMH %u (len=%u): "
msgstr "  EMH %u (længde=%u): "

#: vms-alpha.c:5658
#, c-format
msgid "Module header\n"
msgstr "Modulheader\n"

#: vms-alpha.c:5659
#, c-format
msgid "   structure level: %u\n"
msgstr "   strukturniveau : %u\n"

#: vms-alpha.c:5660
#, c-format
msgid "   max record size: %u\n"
msgstr "   maks post-str: %u\n"

#: vms-alpha.c:5663
#, c-format
msgid "   module name    : %.*s\n"
msgstr "   modulnavn      : %.*s\n"

#: vms-alpha.c:5665
#, c-format
msgid "   module version : %.*s\n"
msgstr "   modulversion   : %.*s\n"

#: vms-alpha.c:5667
#, c-format
msgid "   compile date   : %.17s\n"
msgstr "   kompileringsdag: %.17s\n"

#: vms-alpha.c:5672
#, c-format
msgid "Language Processor Name\n"
msgstr "Navn på sprogprocessor\n"

#: vms-alpha.c:5673
#, c-format
msgid "   language name: %.*s\n"
msgstr "   sprognavn: %.*s\n"

#: vms-alpha.c:5680
#, c-format
msgid "Source Files Header\n"
msgstr "Kildefilheader\n"

#: vms-alpha.c:5681
#, c-format
msgid "   file: %.*s\n"
msgstr "   fil: %.*s\n"

#: vms-alpha.c:5688
#, c-format
msgid "Title Text Header\n"
msgstr "Titeltekstheader\n"

#: vms-alpha.c:5689
#, c-format
msgid "   title: %.*s\n"
msgstr "   titel: %.*s\n"

#: vms-alpha.c:5696
#, c-format
msgid "Copyright Header\n"
msgstr "Ophavsretsheader\n"

#: vms-alpha.c:5697
#, c-format
msgid "   copyright: %.*s\n"
msgstr "   ophavsret: %.*s\n"

#: vms-alpha.c:5703
#, c-format
msgid "unhandled emh subtype %u\n"
msgstr "uhåndteret emh-undertype %u\n"

#: vms-alpha.c:5713
#, c-format
msgid "  EEOM (len=%u):\n"
msgstr "  EEOM (længde=%u):\n"

#: vms-alpha.c:5714
#, c-format
msgid "   number of cond linkage pairs: %u\n"
msgstr "   antal cond-lænkningspar: %u\n"

#: vms-alpha.c:5716
#, c-format
msgid "   completion code: %u\n"
msgstr "   fuldførelseskode: %u\n"

#: vms-alpha.c:5720
#, c-format
msgid "   transfer addr flags: 0x%02x\n"
msgstr "   overførselsadresseflag: 0x%02x\n"

#: vms-alpha.c:5721
#, c-format
msgid "   transfer addr psect: %u\n"
msgstr "   overførselsadresse-psect: %u\n"

#: vms-alpha.c:5723
#, c-format
msgid "   transfer address   : 0x%08x\n"
msgstr "   overførselsadresse : 0x%08x\n"

#: vms-alpha.c:5732
msgid " WEAK"
msgstr " WEAK"

#: vms-alpha.c:5734
msgid " DEF"
msgstr " DEF"

#: vms-alpha.c:5736
msgid " UNI"
msgstr " UNI"

#: vms-alpha.c:5738 vms-alpha.c:5759
msgid " REL"
msgstr " REL"

#: vms-alpha.c:5740
msgid " COMM"
msgstr " COMM"

#: vms-alpha.c:5742
msgid " VECEP"
msgstr " VECEP"

#: vms-alpha.c:5744
msgid " NORM"
msgstr " NORM"

#: vms-alpha.c:5746
msgid " QVAL"
msgstr " QVAL"

#: vms-alpha.c:5753
msgid " PIC"
msgstr " PIC"

#: vms-alpha.c:5755
msgid " LIB"
msgstr " LIB"

#: vms-alpha.c:5757
msgid " OVR"
msgstr " OVR"

#: vms-alpha.c:5761
msgid " GBL"
msgstr " GBL"

#: vms-alpha.c:5763
msgid " SHR"
msgstr " SHR"

#: vms-alpha.c:5765
msgid " EXE"
msgstr " EXE"

#: vms-alpha.c:5767
msgid " RD"
msgstr " RD"

#: vms-alpha.c:5769
msgid " WRT"
msgstr " WRT"

#: vms-alpha.c:5771
msgid " VEC"
msgstr " VEC"

#: vms-alpha.c:5773
msgid " NOMOD"
msgstr " NOMOD"

#: vms-alpha.c:5775
msgid " COM"
msgstr " COM"

#: vms-alpha.c:5777
msgid " 64B"
msgstr " 64B"

#: vms-alpha.c:5786
#, c-format
msgid "  EGSD (len=%u):\n"
msgstr "  EGSD (længde=%u):\n"

#: vms-alpha.c:5798
#, c-format
msgid "  EGSD entry %2u (type: %u, len: %u): "
msgstr "  EGSD-post %2u (type: %u, længde: %u): "

#: vms-alpha.c:5810
#, c-format
msgid "PSC - Program section definition\n"
msgstr "PSC - Programsektionsdefinition\n"

#: vms-alpha.c:5811 vms-alpha.c:5828
#, c-format
msgid "   alignment  : 2**%u\n"
msgstr "   justering  : 2**%u\n"

#: vms-alpha.c:5812 vms-alpha.c:5829
#, c-format
msgid "   flags      : 0x%04x"
msgstr "   flag       : 0x%04x"

#: vms-alpha.c:5816
#, c-format
msgid "   alloc (len): %u (0x%08x)\n"
msgstr "   allok (lgd): %u (0x%08x)\n"

#: vms-alpha.c:5817 vms-alpha.c:5874 vms-alpha.c:5923
#, c-format
msgid "   name       : %.*s\n"
msgstr "   navn       : %.*s\n"

#: vms-alpha.c:5827
#, c-format
msgid "SPSC - Shared Image Program section def\n"
msgstr "SPSC - Shared Image Program-sektionsdefinition\n"

#: vms-alpha.c:5833
#, c-format
msgid "   alloc (len)   : %u (0x%08x)\n"
msgstr "   allok (længde): %u (0x%08x)\n"

#: vms-alpha.c:5834
#, c-format
msgid "   image offset  : 0x%08x\n"
msgstr "   image-afsæt   : 0x%08x\n"

#: vms-alpha.c:5836
#, c-format
msgid "   symvec offset : 0x%08x\n"
msgstr "   symvec-afsæt  : 0x%08x\n"

#: vms-alpha.c:5838
#, c-format
msgid "   name          : %.*s\n"
msgstr "   navn          : %.*s\n"

#: vms-alpha.c:5851
#, c-format
msgid "SYM - Global symbol definition\n"
msgstr "SYM - Global symboldefinition\n"

#: vms-alpha.c:5852 vms-alpha.c:5912 vms-alpha.c:5933 vms-alpha.c:5952
#, c-format
msgid "   flags: 0x%04x"
msgstr "   flag : 0x%04x"

#: vms-alpha.c:5855
#, c-format
msgid "   psect offset: 0x%08x\n"
msgstr "   psect-afsæt : 0x%08x\n"

#: vms-alpha.c:5859
#, c-format
msgid "   code address: 0x%08x\n"
msgstr "   kodeadresse : 0x%08x\n"

#: vms-alpha.c:5861
#, c-format
msgid "   psect index for entry point : %u\n"
msgstr "   psect-indeks for indgangspunkt : %u\n"

#: vms-alpha.c:5864 vms-alpha.c:5940 vms-alpha.c:5959
#, c-format
msgid "   psect index : %u\n"
msgstr "   psect-indeks : %u\n"

#: vms-alpha.c:5866 vms-alpha.c:5942 vms-alpha.c:5961
#, c-format
msgid "   name        : %.*s\n"
msgstr "   navn        : %.*s\n"

#: vms-alpha.c:5873
#, c-format
msgid "SYM - Global symbol reference\n"
msgstr "SYM - Global symbolreference\n"

#: vms-alpha.c:5885
#, c-format
msgid "IDC - Ident Consistency check\n"
msgstr "IDC - identitetskonsistenstjek\n"

#: vms-alpha.c:5886
#, c-format
msgid "   flags         : 0x%08x"
msgstr "   flag          : 0x%08x"

#: vms-alpha.c:5890
#, c-format
msgid "   id match      : %x\n"
msgstr "   id-match      : %x\n"

#: vms-alpha.c:5892
#, c-format
msgid "   error severity: %x\n"
msgstr "   fejlalvorlighed: %x\n"

#: vms-alpha.c:5895
#, c-format
msgid "   entity name   : %.*s\n"
msgstr "   entitetsnavn  : %.*s\n"

#: vms-alpha.c:5897
#, c-format
msgid "   object name   : %.*s\n"
msgstr "   objektnavn    : %.*s\n"

#: vms-alpha.c:5900
#, c-format
msgid "   binary ident  : 0x%08x\n"
msgstr "   binær id      : 0x%08x\n"

#: vms-alpha.c:5903
#, c-format
msgid "   ascii ident   : %.*s\n"
msgstr "   ascii-id      : %.*s\n"

#: vms-alpha.c:5911
#, c-format
msgid "SYMG - Universal symbol definition\n"
msgstr "SYMG - Universel symboldefinition\n"

#: vms-alpha.c:5915
#, c-format
msgid "   symbol vector offset: 0x%08x\n"
msgstr "   symbolvektorafsæt   : 0x%08x\n"

#: vms-alpha.c:5917
#, c-format
msgid "   entry point: 0x%08x\n"
msgstr "   indgangspunkt: 0x%08x\n"

#: vms-alpha.c:5919
#, c-format
msgid "   proc descr : 0x%08x\n"
msgstr "   proc-beskr : 0x%08x\n"

#: vms-alpha.c:5921
#, c-format
msgid "   psect index: %u\n"
msgstr "   psect-indeks: %u\n"

#: vms-alpha.c:5932
#, c-format
msgid "SYMV - Vectored symbol definition\n"
msgstr "SYMV - vektoriseret symboldefinition\n"

#: vms-alpha.c:5936
#, c-format
msgid "   vector      : 0x%08x\n"
msgstr "   vektor      : 0x%08x\n"

#: vms-alpha.c:5938 vms-alpha.c:5957
#, c-format
msgid "   psect offset: %u\n"
msgstr "   psect-afsæt : %u\n"

#: vms-alpha.c:5951
#, c-format
msgid "SYMM - Global symbol definition with version\n"
msgstr "SYMM - Global symboldefinition med version\n"

#: vms-alpha.c:5955
#, c-format
msgid "   version mask: 0x%08x\n"
msgstr "   versionsmaske: 0x%08x\n"

#: vms-alpha.c:5966
#, c-format
msgid "unhandled egsd entry type %u\n"
msgstr "uhåndteret egsd-post-type %u\n"

#: vms-alpha.c:6000
#, c-format
msgid "    linkage index: %u, replacement insn: 0x%08x\n"
msgstr "    lænkningsindeks: %u, erstatnings-insn: 0x%08x\n"

#: vms-alpha.c:6003
#, c-format
msgid "    psect idx 1: %u, offset 1: 0x%08x %08x\n"
msgstr "    psect-idx 1: %u, afsæt 1: 0x%08x %08x\n"

#: vms-alpha.c:6007
#, c-format
msgid "    psect idx 2: %u, offset 2: 0x%08x %08x\n"
msgstr "    psect-idx 2: %u, afsæt 2: 0x%08x %08x\n"

#: vms-alpha.c:6012
#, c-format
msgid "    psect idx 3: %u, offset 3: 0x%08x %08x\n"
msgstr "    psect-idx 3: %u, afsæt 3: 0x%08x %08x\n"

#: vms-alpha.c:6017
#, c-format
msgid "    global name: %.*s\n"
msgstr "    globalt navn: %.*s\n"

#: vms-alpha.c:6027
#, c-format
msgid "  %s (len=%u+%u):\n"
msgstr "  %s (længde=%u+%u):\n"

#: vms-alpha.c:6042
#, c-format
msgid "   (type: %3u, size: 4+%3u): "
msgstr "   (type: %3u, størrelse: 4+%3u): "

#: vms-alpha.c:6046
#, c-format
msgid "STA_GBL (stack global) %.*s\n"
msgstr "STA_GBL (stak-global) %.*s\n"

#: vms-alpha.c:6050
#, c-format
msgid "STA_LW (stack longword) 0x%08x\n"
msgstr "STA_LW (stak-longword) 0x%08x\n"

#: vms-alpha.c:6054
#, c-format
msgid "STA_QW (stack quadword) 0x%08x %08x\n"
msgstr "STA_QW (stak-quadword) 0x%08x %08x\n"

#: vms-alpha.c:6059
#, c-format
msgid "STA_PQ (stack psect base + offset)\n"
msgstr "STA_PQ (stak-psect base + afsæt)\n"

#: vms-alpha.c:6060
#, c-format
msgid "    psect: %u, offset: 0x%08x %08x\n"
msgstr "    psect: %u, afsæt: 0x%08x %08x\n"

#: vms-alpha.c:6066
#, c-format
msgid "STA_LI (stack literal)\n"
msgstr "STA_LI (stak-literal)\n"

#: vms-alpha.c:6069
#, c-format
msgid "STA_MOD (stack module)\n"
msgstr "STA_MOD (stakmodul)\n"

#: vms-alpha.c:6072
#, c-format
msgid "STA_CKARG (compare procedure argument)\n"
msgstr "STA_CKARG (argument til sammenligningsprocedure)\n"

#: vms-alpha.c:6076
#, c-format
msgid "STO_B (store byte)\n"
msgstr "STO_B (gem byte)\n"

#: vms-alpha.c:6079
#, c-format
msgid "STO_W (store word)\n"
msgstr "STO_W (gem word)\n"

#: vms-alpha.c:6082
#, c-format
msgid "STO_LW (store longword)\n"
msgstr "STO_LW (gem longword)\n"

#: vms-alpha.c:6085
#, c-format
msgid "STO_QW (store quadword)\n"
msgstr "STO_QW (gem quadword)\n"

#: vms-alpha.c:6091
#, c-format
msgid "STO_IMMR (store immediate repeat) %u bytes\n"
msgstr "STO_IMMR (gem omgående gentagelse) %u byte\n"

#: vms-alpha.c:6098
#, c-format
msgid "STO_GBL (store global) %.*s\n"
msgstr "STO_GBL (gem global) %.*s\n"

#: vms-alpha.c:6102
#, c-format
msgid "STO_CA (store code address) %.*s\n"
msgstr "STO_CA (gem kodeadresse) %.*s\n"

#: vms-alpha.c:6106
#, c-format
msgid "STO_RB (store relative branch)\n"
msgstr "STO_RB (gem relativ gren)\n"

#: vms-alpha.c:6109
#, c-format
msgid "STO_AB (store absolute branch)\n"
msgstr "STO_AB (gem absolut gren)\n"

#: vms-alpha.c:6112
#, c-format
msgid "STO_OFF (store offset to psect)\n"
msgstr "STO_OFF (gem afsæt til psect)\n"

#: vms-alpha.c:6118
#, c-format
msgid "STO_IMM (store immediate) %u bytes\n"
msgstr "STO_IMM (gem omgående) %u byte\n"

#: vms-alpha.c:6125
#, c-format
msgid "STO_GBL_LW (store global longword) %.*s\n"
msgstr "STO_GBL_LW (gem globalt longword) %.*s\n"

#: vms-alpha.c:6129
#, c-format
msgid "STO_OFF (store LP with procedure signature)\n"
msgstr "STO_OFF (gem LP med proceduresignatur)\n"

#: vms-alpha.c:6132
#, c-format
msgid "STO_BR_GBL (store branch global) *todo*\n"
msgstr "STO_BR_GBL (gem gren globalt) *todo*\n"

#: vms-alpha.c:6135
#, c-format
msgid "STO_BR_PS (store branch psect + offset) *todo*\n"
msgstr "STO_BR_PS (gem gren-psect + afsæt) *todo*\n"

#: vms-alpha.c:6139
#, c-format
msgid "OPR_NOP (no-operation)\n"
msgstr "OPR_NOP (ingen operation)\n"

#: vms-alpha.c:6142
#, c-format
msgid "OPR_ADD (add)\n"
msgstr "OPR_ADD (læg sammen)\n"

#: vms-alpha.c:6145
#, c-format
msgid "OPR_SUB (substract)\n"
msgstr "OPR_SUB (træk fra)\n"

#: vms-alpha.c:6148
#, c-format
msgid "OPR_MUL (multiply)\n"
msgstr "OPR_MUL (multiplicér)\n"

#: vms-alpha.c:6151
#, c-format
msgid "OPR_DIV (divide)\n"
msgstr "OPR_DIV (dividér)\n"

#: vms-alpha.c:6154
#, c-format
msgid "OPR_AND (logical and)\n"
msgstr "OPR_AND (logisk og)\n"

#: vms-alpha.c:6157
#, c-format
msgid "OPR_IOR (logical inclusive or)\n"
msgstr "OPR_IOR (logisk inklusiv eller)\n"

#: vms-alpha.c:6160
#, c-format
msgid "OPR_EOR (logical exclusive or)\n"
msgstr "OPR_EOR (logisk eksklusiv eller)\n"

#: vms-alpha.c:6163
#, c-format
msgid "OPR_NEG (negate)\n"
msgstr "OPR_NEG (negation)\n"

#: vms-alpha.c:6166
#, c-format
msgid "OPR_COM (complement)\n"
msgstr "OPR_COM (komplement)\n"

#: vms-alpha.c:6169
#, c-format
msgid "OPR_INSV (insert field)\n"
msgstr "OPR_INSV (indsæt felt)\n"

#: vms-alpha.c:6172
#, c-format
msgid "OPR_ASH (arithmetic shift)\n"
msgstr "OPR_ASH (aritmetisk skift)\n"

#: vms-alpha.c:6175
#, c-format
msgid "OPR_USH (unsigned shift)\n"
msgstr "OPR_USH (skift uden fortegn)\n"

#: vms-alpha.c:6178
#, c-format
msgid "OPR_ROT (rotate)\n"
msgstr "OPR_ROT (rotér)\n"

#: vms-alpha.c:6181
#, c-format
msgid "OPR_SEL (select)\n"
msgstr "OPR_SEL (vælg)\n"

#: vms-alpha.c:6184
#, c-format
msgid "OPR_REDEF (redefine symbol to curr location)\n"
msgstr "OPR_REDEF (omdefinér symbol til nuværende placering)\n"

#: vms-alpha.c:6187
#, c-format
msgid "OPR_REDEF (define a literal)\n"
msgstr "OPR_REDEF (definér en literal)\n"

#: vms-alpha.c:6191
#, c-format
msgid "STC_LP (store cond linkage pair)\n"
msgstr "STC_LP (gem cond-lænkningspar)\n"

#: vms-alpha.c:6195
#, c-format
msgid "STC_LP_PSB (store cond linkage pair + signature)\n"
msgstr "STC_LP_PSB (gem cond-lænkningspar + signatur)\n"

#: vms-alpha.c:6196
#, c-format
msgid "   linkage index: %u, procedure: %.*s\n"
msgstr "   lænkningsindeks: %u, procedure: %.*s\n"

#: vms-alpha.c:6199
#, c-format
msgid "   signature: %.*s\n"
msgstr "   signatur: %.*s\n"

#: vms-alpha.c:6202
#, c-format
msgid "STC_GBL (store cond global)\n"
msgstr "STC_GBL (gem cond globalt)\n"

#: vms-alpha.c:6203
#, c-format
msgid "   linkage index: %u, global: %.*s\n"
msgstr "   lænkningsindeks: %u, global: %.*s\n"

#: vms-alpha.c:6207
#, c-format
msgid "STC_GCA (store cond code address)\n"
msgstr "STC_GCA (gem cond-kodeadresse)\n"

#: vms-alpha.c:6208
#, c-format
msgid "   linkage index: %u, procedure name: %.*s\n"
msgstr "   lænkningsindeks: %u, procedurenavn: %.*s\n"

#: vms-alpha.c:6212
#, c-format
msgid "STC_PS (store cond psect + offset)\n"
msgstr "STC_PS (gem cond-psect + afsæt)\n"

#: vms-alpha.c:6214
#, c-format
msgid "   linkage index: %u, psect: %u, offset: 0x%08x %08x\n"
msgstr "   lænkningsindeks: %u, psect: %u, afsæt: 0x%08x %08x\n"

#: vms-alpha.c:6221
#, c-format
msgid "STC_NOP_GBL (store cond NOP at global addr)\n"
msgstr "STC_NOP_GBL (gem cond NOP på global adresse)\n"

#: vms-alpha.c:6225
#, c-format
msgid "STC_NOP_PS (store cond NOP at psect + offset)\n"
msgstr "STC_NOP_PS (gem cond NOP på psect + afsæt)\n"

#: vms-alpha.c:6229
#, c-format
msgid "STC_BSR_GBL (store cond BSR at global addr)\n"
msgstr "STC_BSR_GBL (gem cond BSR på global adresse)\n"

#: vms-alpha.c:6233
#, c-format
msgid "STC_BSR_PS (store cond BSR at psect + offset)\n"
msgstr "STC_BSR_PS (gem cond BSR på psect + afsæt)\n"

#: vms-alpha.c:6237
#, c-format
msgid "STC_LDA_GBL (store cond LDA at global addr)\n"
msgstr "STC_LDA_GBL (gem cond LDA på global adresse)\n"

#: vms-alpha.c:6241
#, c-format
msgid "STC_LDA_PS (store cond LDA at psect + offset)\n"
msgstr "STC_LDA_PS (gem cond LDA på psect + afsæt)\n"

#: vms-alpha.c:6245
#, c-format
msgid "STC_BOH_GBL (store cond BOH at global addr)\n"
msgstr "STC_BOH_GBL (gem cond BOH på global adresse)\n"

#: vms-alpha.c:6249
#, c-format
msgid "STC_BOH_PS (store cond BOH at psect + offset)\n"
msgstr "STC_BOH_PS (gem cond BOH på psect + afsæt)\n"

#: vms-alpha.c:6254
#, c-format
msgid "STC_NBH_GBL (store cond or hint at global addr)\n"
msgstr "STC_NBH_GBL (gem cond eller hint på global adresse)\n"

#: vms-alpha.c:6258
#, c-format
msgid "STC_NBH_PS (store cond or hint at psect + offset)\n"
msgstr "STC_NBH_PS (gem cond eller hint på psect + afsæt)\n"

#: vms-alpha.c:6262
#, c-format
msgid "CTL_SETRB (set relocation base)\n"
msgstr "CTL_SETRB (sæt relokeringsbase)\n"

#: vms-alpha.c:6268
#, c-format
msgid "CTL_AUGRB (augment relocation base) %u\n"
msgstr "CTL_AUGRB (sammensæt (augment) relokeringsbase) %u\n"

#: vms-alpha.c:6272
#, c-format
msgid "CTL_DFLOC (define location)\n"
msgstr "CTL_DFLOC (defineŕ placering)\n"

#: vms-alpha.c:6275
#, c-format
msgid "CTL_STLOC (set location)\n"
msgstr "CTL_STLOC (indstil placering)\n"

#: vms-alpha.c:6278
#, c-format
msgid "CTL_STKDL (stack defined location)\n"
msgstr "CTL_STKDL (stakdefineret placering)\n"

#: vms-alpha.c:6281 vms-alpha.c:6695
#, c-format
msgid "*unhandled*\n"
msgstr "*uhåndteret*\n"

#: vms-alpha.c:6311 vms-alpha.c:6350
#, c-format
msgid "cannot read GST record length\n"
msgstr "kan ikke læse GST-post-længde\n"

#. Ill-formed.
#: vms-alpha.c:6332
#, c-format
msgid "cannot find EMH in first GST record\n"
msgstr "kan ikke finde EMH i første GST-post\n"

#: vms-alpha.c:6358
#, c-format
msgid "cannot read GST record header\n"
msgstr "kan ikke læse GST-post-header\n"

#: vms-alpha.c:6371
#, c-format
msgid " corrupted GST\n"
msgstr " beskadiget GST\n"

#: vms-alpha.c:6379
#, c-format
msgid "cannot read GST record\n"
msgstr "kan ikke læse GST-post\n"

#: vms-alpha.c:6408
#, c-format
msgid " unhandled EOBJ record type %u\n"
msgstr " uhåndteret EOBJ-post-type %u\n"

#: vms-alpha.c:6431
#, c-format
msgid "  bitcount: %u, base addr: 0x%08x\n"
msgstr "  antal bit: %u, basisadresse: 0x%08x\n"

#: vms-alpha.c:6444
#, c-format
msgid "   bitmap: 0x%08x (count: %u):\n"
msgstr "   bitmap: 0x%08x (antal: %u):\n"

#: vms-alpha.c:6451
#, c-format
msgid " %08x"
msgstr " %08x"

#: vms-alpha.c:6476
#, c-format
msgid "  image %u (%u entries)\n"
msgstr "  aftryk %u (%u elementer)\n"

#: vms-alpha.c:6481
#, c-format
msgid "   offset: 0x%08x, val: 0x%08x\n"
msgstr "   afsæt: 0x%08x, værdi: 0x%08x\n"

#: vms-alpha.c:6502
#, c-format
msgid "  image %u (%u entries), offsets:\n"
msgstr "  aftryk %u (%u elementer), afsæt:\n"

#: vms-alpha.c:6509
#, c-format
msgid " 0x%08x"
msgstr " 0x%08x"

#. 64 bits.
#: vms-alpha.c:6631
#, c-format
msgid "64 bits *unhandled*\n"
msgstr "64 bit *uhåndteret*\n"

#: vms-alpha.c:6635
#, c-format
msgid "class: %u, dtype: %u, length: %u, pointer: 0x%08x\n"
msgstr "klasse: %u, dtype: %u, længde: %u, pointer: 0x%08x\n"

#: vms-alpha.c:6646
#, c-format
msgid "non-contiguous array of %s\n"
msgstr "usammenhængende array af %s\n"

#: vms-alpha.c:6650
#, c-format
msgid "dimct: %u, aflags: 0x%02x, digits: %u, scale: %u\n"
msgstr "dimct: %u, aflags: 0x%02x, cifre: %u, skala: %u\n"

#: vms-alpha.c:6654
#, c-format
msgid "arsize: %u, a0: 0x%08x\n"
msgstr "arsize: %u, a0: 0x%08x\n"

#: vms-alpha.c:6658
#, c-format
msgid "Strides:\n"
msgstr "Trinstørrelser:\n"

#: vms-alpha.c:6663
#, c-format
msgid "[%u]: %u\n"
msgstr "[%u]: %u\n"

#: vms-alpha.c:6668
#, c-format
msgid "Bounds:\n"
msgstr "Grænser:\n"

#: vms-alpha.c:6673
#, c-format
msgid "[%u]: Lower: %u, upper: %u\n"
msgstr "[%u]: Nedre: %u, øvre: %u\n"

#: vms-alpha.c:6685
#, c-format
msgid "unaligned bit-string of %s\n"
msgstr "ujusteret bit-streng af %s\n"

#: vms-alpha.c:6689
#, c-format
msgid "base: %u, pos: %u\n"
msgstr "base: %u, pos: %u\n"

#: vms-alpha.c:6709
#, c-format
msgid "vflags: 0x%02x, value: 0x%08x "
msgstr "vflags: 0x%02x, værdi: 0x%08x "

#: vms-alpha.c:6715
#, c-format
msgid "(no value)\n"
msgstr "(ingen værdi)\n"

#: vms-alpha.c:6718
#, c-format
msgid "(not active)\n"
msgstr "(ikke aktiv)\n"

#: vms-alpha.c:6721
#, c-format
msgid "(not allocated)\n"
msgstr "(ikke tildelt)\n"

#: vms-alpha.c:6724
#, c-format
msgid "(descriptor)\n"
msgstr "(deskriptor)\n"

#: vms-alpha.c:6728
#, c-format
msgid "(trailing value)\n"
msgstr "(afsluttende værdi)\n"

#: vms-alpha.c:6731
#, c-format
msgid "(value spec follows)\n"
msgstr "(værdi-spec følger)\n"

#: vms-alpha.c:6734
#, c-format
msgid "(at bit offset %u)\n"
msgstr "(ved bitafsæt %u)\n"

#: vms-alpha.c:6737
#, c-format
msgid "(reg: %u, disp: %u, indir: %u, kind: "
msgstr "(reg: %u, disp: %u, indir: %u, type: "

#: vms-alpha.c:6744
msgid "literal"
msgstr "literal"

#: vms-alpha.c:6747
msgid "address"
msgstr "adresse"

#: vms-alpha.c:6750
msgid "desc"
msgstr "beskr"

#: vms-alpha.c:6753
msgid "reg"
msgstr "reg"

#: vms-alpha.c:6828
#, c-format
msgid "Debug symbol table:\n"
msgstr "Fejlsøgningssymboltabel:\n"

#: vms-alpha.c:6839
#, c-format
msgid "cannot read DST header\n"
msgstr "kan ikke læse DST-header\n"

#: vms-alpha.c:6844
#, c-format
msgid " type: %3u, len: %3u (at 0x%08x): "
msgstr " type: %3u, længde: %3u (på 0x%08x): "

#: vms-alpha.c:6858
#, c-format
msgid "cannot read DST symbol\n"
msgstr "kan ikke læse DST-symbol\n"

#: vms-alpha.c:6901
#, c-format
msgid "standard data: %s\n"
msgstr "standarddata : %s\n"

#: vms-alpha.c:6904 vms-alpha.c:6988
#, c-format
msgid "    name: %.*s\n"
msgstr "    navn: %.*s\n"

#: vms-alpha.c:6911
#, c-format
msgid "modbeg\n"
msgstr "modbeg\n"

#: vms-alpha.c:6912
#, c-format
msgid "   flags: %d, language: %u, major: %u, minor: %u\n"
msgstr "   flag: %d, sprog: %u, hoved: %u, under: %u\n"

#: vms-alpha.c:6918 vms-alpha.c:7184
#, c-format
msgid "   module name: %.*s\n"
msgstr "   modulnavn : %.*s\n"

#: vms-alpha.c:6921
#, c-format
msgid "   compiler   : %.*s\n"
msgstr "   kompiler   : %.*s\n"

#: vms-alpha.c:6926
#, c-format
msgid "modend\n"
msgstr "modend\n"

#: vms-alpha.c:6933
msgid "rtnbeg\n"
msgstr "rtnbeg\n"

#: vms-alpha.c:6934
#, c-format
msgid "    flags: %u, address: 0x%08x, pd-address: 0x%08x\n"
msgstr "    flag: %u, adresse: 0x%08x, pd-adresse: 0x%08x\n"

#: vms-alpha.c:6939
#, c-format
msgid "    routine name: %.*s\n"
msgstr "    rutinenavn: %.*s\n"

#: vms-alpha.c:6947
#, c-format
msgid "rtnend: size 0x%08x\n"
msgstr "rtnend: størrelse 0x%08x\n"

#: vms-alpha.c:6955
#, c-format
msgid "prolog: bkpt address 0x%08x\n"
msgstr "prolog: bkpt-adresse 0x%08x\n"

#: vms-alpha.c:6963
#, c-format
msgid "epilog: flags: %u, count: %u\n"
msgstr "epilog: flag: %u, antal: %u\n"

#: vms-alpha.c:6972
#, c-format
msgid "blkbeg: address: 0x%08x, name: %.*s\n"
msgstr "blkbeg: adresse: 0x%08x, navn: %.*s\n"

#: vms-alpha.c:6981
#, c-format
msgid "blkend: size: 0x%08x\n"
msgstr "blkend: størrelse: 0x%08x\n"

#: vms-alpha.c:6987
#, c-format
msgid "typspec (len: %u)\n"
msgstr "typspec (længde: %u)\n"

#: vms-alpha.c:6994
#, c-format
msgid "septyp, name: %.*s\n"
msgstr "septyp, navn: %.*s\n"

#: vms-alpha.c:7003
#, c-format
msgid "recbeg: name: %.*s\n"
msgstr "recbeg: navn: %.*s\n"

#: vms-alpha.c:7010
#, c-format
msgid "recend\n"
msgstr "recend\n"

#: vms-alpha.c:7013
#, c-format
msgid "enumbeg, len: %u, name: %.*s\n"
msgstr "enumbeg, længde: %u, navn: %.*s\n"

#: vms-alpha.c:7017
#, c-format
msgid "enumelt, name: %.*s\n"
msgstr "enumelt, navn: %.*s\n"

#: vms-alpha.c:7021
#, c-format
msgid "enumend\n"
msgstr "enumend\n"

#: vms-alpha.c:7038
#, c-format
msgid "discontiguous range (nbr: %u)\n"
msgstr "usammenhængende interval (nbr: %u)\n"

#: vms-alpha.c:7040
#, c-format
msgid "    address: 0x%08x, size: %u\n"
msgstr "    adresse: 0x%08x, størrelse: %u\n"

#: vms-alpha.c:7050
#, c-format
msgid "line num  (len: %u)\n"
msgstr "linjenummer  (længde: %u)\n"

#: vms-alpha.c:7067
#, c-format
msgid "delta_pc_w %u\n"
msgstr "delta_pc_w %u\n"

#: vms-alpha.c:7074
#, c-format
msgid "incr_linum(b): +%u\n"
msgstr "incr_linum(b): +%u\n"

#: vms-alpha.c:7080
#, c-format
msgid "incr_linum_w: +%u\n"
msgstr "incr_linum_w: +%u\n"

#: vms-alpha.c:7086
#, c-format
msgid "incr_linum_l: +%u\n"
msgstr "incr_linum_l: +%u\n"

#: vms-alpha.c:7092
#, c-format
msgid "set_line_num(w) %u\n"
msgstr "set_line_num(w) %u\n"

#: vms-alpha.c:7097
#, c-format
msgid "set_line_num_b %u\n"
msgstr "set_line_num_b %u\n"

#: vms-alpha.c:7102
#, c-format
msgid "set_line_num_l %u\n"
msgstr "set_line_num_l %u\n"

#: vms-alpha.c:7107
#, c-format
msgid "set_abs_pc: 0x%08x\n"
msgstr "set_abs_pc: 0x%08x\n"

#: vms-alpha.c:7111
#, c-format
msgid "delta_pc_l: +0x%08x\n"
msgstr "delta_pc_l: +0x%08x\n"

#: vms-alpha.c:7116
#, c-format
msgid "term(b): 0x%02x"
msgstr "term(b): 0x%02x"

#: vms-alpha.c:7118
#, c-format
msgid "        pc: 0x%08x\n"
msgstr "        pc: 0x%08x\n"

#: vms-alpha.c:7123
#, c-format
msgid "term_w: 0x%04x"
msgstr "term_w: 0x%04x"

#: vms-alpha.c:7125
#, c-format
msgid "    pc: 0x%08x\n"
msgstr "    pc: 0x%08x\n"

#: vms-alpha.c:7131
#, c-format
msgid "delta pc +%-4d"
msgstr "delta pc +%-4d"

#: vms-alpha.c:7134
#, c-format
msgid "    pc: 0x%08x line: %5u\n"
msgstr "    pc: 0x%08x linje: %5u\n"

#: vms-alpha.c:7139
#, c-format
msgid "    *unhandled* cmd %u\n"
msgstr "    *uhåndteret* kommando %u\n"

#: vms-alpha.c:7154
#, c-format
msgid "source (len: %u)\n"
msgstr "kilde (længde: %u)\n"

#: vms-alpha.c:7168
#, c-format
msgid "   declfile: len: %u, flags: %u, fileid: %u\n"
msgstr "   declfile: længde: %u, flag: %u, fil-id: %u\n"

#: vms-alpha.c:7172
#, c-format
msgid "   rms: cdt: 0x%08x %08x, ebk: 0x%08x, ffb: 0x%04x, rfo: %u\n"
msgstr "   rms: cdt: 0x%08x %08x, ebk: 0x%08x, ffb: 0x%04x, rfo: %u\n"

#: vms-alpha.c:7181
#, c-format
msgid "   filename   : %.*s\n"
msgstr "   filnavn    : %.*s\n"

#: vms-alpha.c:7190
#, c-format
msgid "   setfile %u\n"
msgstr "   setfile %u\n"

#: vms-alpha.c:7195 vms-alpha.c:7200
#, c-format
msgid "   setrec %u\n"
msgstr "   setrec %u\n"

#: vms-alpha.c:7205 vms-alpha.c:7210
#, c-format
msgid "   setlnum %u\n"
msgstr "   setlnum %u\n"

#: vms-alpha.c:7215 vms-alpha.c:7220
#, c-format
msgid "   deflines %u\n"
msgstr "   deflines %u\n"

#: vms-alpha.c:7224
#, c-format
msgid "   formfeed\n"
msgstr "   formfeed\n"

#: vms-alpha.c:7228
#, c-format
msgid "   *unhandled* cmd %u\n"
msgstr "   *uhåndteret* kommando %u\n"

#: vms-alpha.c:7240
#, c-format
msgid "*unhandled* dst type %u\n"
msgstr "*uhåndteret dst-type %u\n"

#: vms-alpha.c:7272
#, c-format
msgid "cannot read EIHD\n"
msgstr "kan ikke læse EIHD\n"

#: vms-alpha.c:7275
#, c-format
msgid "EIHD: (size: %u, nbr blocks: %u)\n"
msgstr "EIHD: (størrelse: %u, bloktal: %u)\n"

#: vms-alpha.c:7278
#, c-format
msgid " majorid: %u, minorid: %u\n"
msgstr " hovednr: %u, undernr: %u\n"

#: vms-alpha.c:7286
msgid "executable"
msgstr "eksekverbar fil"

#: vms-alpha.c:7289
msgid "linkable image"
msgstr "lænkbart aftryk"

#: vms-alpha.c:7295
#, c-format
msgid " image type: %u (%s)"
msgstr " aftrykstype: %u (%s)"

#: vms-alpha.c:7301
msgid "native"
msgstr "native"

#: vms-alpha.c:7304
msgid "CLI"
msgstr "CLI"

#: vms-alpha.c:7310
#, c-format
msgid ", subtype: %u (%s)\n"
msgstr ", undertype: %u (%s)\n"

#: vms-alpha.c:7316
#, c-format
msgid " offsets: isd: %u, activ: %u, symdbg: %u, imgid: %u, patch: %u\n"
msgstr " afsæt: isd: %u, aktiv: %u, symdbg: %u, imgid: %u, patch: %u\n"

#: vms-alpha.c:7320
#, c-format
msgid " fixup info rva: "
msgstr " fixup info-rva: "

#: vms-alpha.c:7322
#, c-format
msgid ", symbol vector rva: "
msgstr ", symbolvektor-rva: "

#: vms-alpha.c:7325
#, c-format
msgid ""
"\n"
" version array off: %u\n"
msgstr ""
"\n"
" versions-arrayafsæt: %u\n"

#: vms-alpha.c:7329
#, c-format
msgid " img I/O count: %u, nbr channels: %u, req pri: %08x%08x\n"
msgstr " img-I/O-tal: %u, antal kanaler: %u, req pri: %08x%08x\n"

#: vms-alpha.c:7335
#, c-format
msgid " linker flags: %08x:"
msgstr " lænkerflag: %08x:"

#: vms-alpha.c:7365
#, c-format
msgid " ident: 0x%08x, sysver: 0x%08x, match ctrl: %u, symvect_size: %u\n"
msgstr " ident: 0x%08x, sysver: 0x%08x, match-ktrl: %u, symvect_size: %u\n"

#: vms-alpha.c:7371
#, c-format
msgid " BPAGE: %u"
msgstr " BPAGE: %u"

#: vms-alpha.c:7377
#, c-format
msgid ", ext fixup offset: %u, no_opt psect off: %u"
msgstr ", ext-fixup-afsæt: %u, no_opt psect slået fra: %u"

#: vms-alpha.c:7380
#, c-format
msgid ", alias: %u\n"
msgstr ", alias: %u\n"

#: vms-alpha.c:7388
#, c-format
msgid "system version array information:\n"
msgstr "arrayinformation om systemversion:\n"

#: vms-alpha.c:7392
#, c-format
msgid "cannot read EIHVN header\n"
msgstr "kan ikke læse EIHVN-header\n"

#: vms-alpha.c:7402
#, c-format
msgid "cannot read EIHVN version\n"
msgstr "kan ikke læse EIHVN-version\n"

#: vms-alpha.c:7405
#, c-format
msgid "   %02u "
msgstr "   %02u "

# ?
#: vms-alpha.c:7409
msgid "BASE_IMAGE       "
msgstr "BASE_IMAGE       "

#: vms-alpha.c:7412
msgid "MEMORY_MANAGEMENT"
msgstr "MEMORY_MANAGEMENT"

#: vms-alpha.c:7415
msgid "IO               "
msgstr "IO               "

#: vms-alpha.c:7418
msgid "FILES_VOLUMES    "
msgstr "FILES_VOLUMES    "

#: vms-alpha.c:7421
msgid "PROCESS_SCHED    "
msgstr "PROCESS_SCHED    "

#: vms-alpha.c:7424
msgid "SYSGEN           "
msgstr "SYSGEN           "

#: vms-alpha.c:7427
msgid "CLUSTERS_LOCKMGR "
msgstr "CLUSTERS_LOCKMGR "

#: vms-alpha.c:7430
msgid "LOGICAL_NAMES    "
msgstr "LOGICAL_NAMES    "

#: vms-alpha.c:7433
msgid "SECURITY         "
msgstr "SECURITY         "

#: vms-alpha.c:7436
msgid "IMAGE_ACTIVATOR  "
msgstr "IMAGE_ACTIVATOR  "

#: vms-alpha.c:7439
msgid "NETWORKS         "
msgstr "NETWORKS         "

#: vms-alpha.c:7442
msgid "COUNTERS         "
msgstr "COUNTERS         "

#: vms-alpha.c:7445
msgid "STABLE           "
msgstr "STABLE           "

#: vms-alpha.c:7448
msgid "MISC             "
msgstr "MISC             "

#: vms-alpha.c:7451
msgid "CPU              "
msgstr "CPU              "

#: vms-alpha.c:7454
msgid "VOLATILE         "
msgstr "VOLATILE         "

#: vms-alpha.c:7457
msgid "SHELL            "
msgstr "SHELL            "

#: vms-alpha.c:7460
msgid "POSIX            "
msgstr "POSIX            "

#: vms-alpha.c:7463
msgid "MULTI_PROCESSING "
msgstr "MULTI_PROCESSING "

#: vms-alpha.c:7466
msgid "GALAXY           "
msgstr "GALAXY           "

#: vms-alpha.c:7469
msgid "*unknown*        "
msgstr "*ukendt*         "

#: vms-alpha.c:7472
#, c-format
msgid ": %u.%u\n"
msgstr ": %u.%u\n"

#: vms-alpha.c:7485 vms-alpha.c:7744
#, c-format
msgid "cannot read EIHA\n"
msgstr "kan ikke læse EIHA\n"

#: vms-alpha.c:7488
#, c-format
msgid "Image activation:  (size=%u)\n"
msgstr "Aftryksaktivering:  (størrelse=%u)\n"

# Den her og de nedenstående skal tilsyneladende passe sammen med placering af kolon
#: vms-alpha.c:7490
#, c-format
msgid " First address : 0x%08x 0x%08x\n"
msgstr " Første adresse: 0x%08x 0x%08x\n"

#: vms-alpha.c:7493
#, c-format
msgid " Second address: 0x%08x 0x%08x\n"
msgstr " Anden adresse : 0x%08x 0x%08x\n"

#: vms-alpha.c:7496
#, c-format
msgid " Third address : 0x%08x 0x%08x\n"
msgstr " Tredje adresse: 0x%08x 0x%08x\n"

#: vms-alpha.c:7499
#, c-format
msgid " Fourth address: 0x%08x 0x%08x\n"
msgstr " Fjerde adresse: 0x%08x 0x%08x\n"

#: vms-alpha.c:7502
#, c-format
msgid " Shared image  : 0x%08x 0x%08x\n"
msgstr " Delt aftryk   : 0x%08x 0x%08x\n"

#: vms-alpha.c:7513
#, c-format
msgid "cannot read EIHI\n"
msgstr "kan ikke læse EIHI\n"

#: vms-alpha.c:7516
#, c-format
msgid "Image identification: (major: %u, minor: %u)\n"
msgstr "Aftryksidentifikation: (hoved: %u, under: %u)\n"

#: vms-alpha.c:7519
#, c-format
msgid " image name       : %.*s\n"
msgstr " aftryksnavn      : %.*s\n"

#: vms-alpha.c:7521
#, c-format
msgid " link time        : %s\n"
msgstr " lænketidspunkt   : %s\n"

#: vms-alpha.c:7523
#, c-format
msgid " image ident      : %.*s\n"
msgstr " aftryks-id       : %.*s\n"

#: vms-alpha.c:7525
#, c-format
msgid " linker ident     : %.*s\n"
msgstr " lænker-id        : %.*s\n"

#: vms-alpha.c:7527
#, c-format
msgid " image build ident: %.*s\n"
msgstr " aftryks bygge-id : %.*s\n"

#: vms-alpha.c:7537
#, c-format
msgid "cannot read EIHS\n"
msgstr "kan ikke læse EIHS\n"

#: vms-alpha.c:7540
#, c-format
msgid "Image symbol & debug table: (major: %u, minor: %u)\n"
msgstr "Aftrykssymbol- og fejlsøgningstabel: (hoved: %u, under: %u)\n"

#: vms-alpha.c:7545
#, c-format
msgid " debug symbol table : vbn: %u, size: %u (0x%x)\n"
msgstr " symboltabel til fejlsøgning : vbn: %u, størrelse: %u (0x%x)\n"

#: vms-alpha.c:7549
#, c-format
msgid " global symbol table: vbn: %u, records: %u\n"
msgstr " global symboltabel: vbn: %u, poster: %u\n"

#: vms-alpha.c:7553
#, c-format
msgid " debug module table : vbn: %u, size: %u\n"
msgstr " fejlsøgningsmodultabel : vbn: %u, størrelse: %u\n"

#: vms-alpha.c:7566
#, c-format
msgid "cannot read EISD\n"
msgstr "kan ikke læse EISD\n"

#: vms-alpha.c:7576
#, c-format
msgid "Image section descriptor: (major: %u, minor: %u, size: %u, offset: %u)\n"
msgstr "Aftrykssektionsdeskriptor: (hoved: %u, under: %u, størrelse: %u, afsæt: %u)\n"

#: vms-alpha.c:7583
#, c-format
msgid " section: base: 0x%08x%08x size: 0x%08x\n"
msgstr " sektion: base: 0x%08x%08x size: 0x%08x\n"

#: vms-alpha.c:7588
#, c-format
msgid " flags: 0x%04x"
msgstr " flag: 0x%04x"

#: vms-alpha.c:7625
#, c-format
msgid " vbn: %u, pfc: %u, matchctl: %u type: %u ("
msgstr " vbn: %u, pfc: %u, matchktl: %u type: %u ("

#: vms-alpha.c:7631
msgid "NORMAL"
msgstr "NORMAL"

#: vms-alpha.c:7634
msgid "SHRFXD"
msgstr "SHRFXD"

#: vms-alpha.c:7637
msgid "PRVFXD"
msgstr "PRVFXD"

#: vms-alpha.c:7640
msgid "SHRPIC"
msgstr "SHRPIC"

#: vms-alpha.c:7643
msgid "PRVPIC"
msgstr "PRVPIC"

#: vms-alpha.c:7646
msgid "USRSTACK"
msgstr "USRSTACK"

#: vms-alpha.c:7654
#, c-format
msgid " ident: 0x%08x, name: %.*s\n"
msgstr " ident: 0x%08x, navn: %.*s\n"

#: vms-alpha.c:7664
#, c-format
msgid "cannot read DMT\n"
msgstr "kan ikke læse DMT\n"

#: vms-alpha.c:7668
#, c-format
msgid "Debug module table:\n"
msgstr "Fejlsøgningsmodultabel:\n"

#: vms-alpha.c:7677
#, c-format
msgid "cannot read DMT header\n"
msgstr "kan ikke læse DMT-header\n"

#: vms-alpha.c:7682
#, c-format
msgid " module offset: 0x%08x, size: 0x%08x, (%u psects)\n"
msgstr " modulafsæt: 0x%08x, størrelse: 0x%08x, (%u psect'er)\n"

#: vms-alpha.c:7692
#, c-format
msgid "cannot read DMT psect\n"
msgstr "kan ikke læse DMT-psect\n"

#: vms-alpha.c:7695
#, c-format
msgid "  psect start: 0x%08x, length: %u\n"
msgstr "  psect-start: 0x%08x, længde: %u\n"

#: vms-alpha.c:7708
#, c-format
msgid "cannot read DST\n"
msgstr "kan ikke læse DST\n"

#: vms-alpha.c:7718
#, c-format
msgid "cannot read GST\n"
msgstr "kan ikke læse GST\n"

#: vms-alpha.c:7722
#, c-format
msgid "Global symbol table:\n"
msgstr "Global symboltabel:\n"

#: vms-alpha.c:7750
#, c-format
msgid "Image activator fixup: (major: %u, minor: %u)\n"
msgstr "Fixup til aftryksaktivator: (hoved: %u, under: %u)\n"

#: vms-alpha.c:7753
#, c-format
msgid "  iaflink : 0x%08x %08x\n"
msgstr "  iaflink : 0x%08x %08x\n"

#: vms-alpha.c:7756
#, c-format
msgid "  fixuplnk: 0x%08x %08x\n"
msgstr "  fixuplnk: 0x%08x %08x\n"

#: vms-alpha.c:7759
#, c-format
msgid "  size : %u\n"
msgstr "  størrelse: %u\n"

#: vms-alpha.c:7761
#, c-format
msgid "  flags: 0x%08x\n"
msgstr "  flag: 0x%08x\n"

#: vms-alpha.c:7765
#, c-format
msgid "  qrelfixoff: %5u, lrelfixoff: %5u\n"
msgstr "  qrelfixoff: %5u, lrelfixoff: %5u\n"

#: vms-alpha.c:7769
#, c-format
msgid "  qdotadroff: %5u, ldotadroff: %5u\n"
msgstr "  qdotadroff: %5u, ldotadroff: %5u\n"

#: vms-alpha.c:7773
#, c-format
msgid "  codeadroff: %5u, lpfixoff  : %5u\n"
msgstr "  codeadroff: %5u, lpfixoff  : %5u\n"

#: vms-alpha.c:7776
#, c-format
msgid "  chgprtoff : %5u\n"
msgstr "  chgprtoff : %5u\n"

#: vms-alpha.c:7779
#, c-format
msgid "  shlstoff  : %5u, shrimgcnt : %5u\n"
msgstr "  shlstoff  : %5u, shrimgcnt : %5u\n"

#: vms-alpha.c:7781
#, c-format
msgid "  shlextra  : %5u, permctx   : %5u\n"
msgstr "  shlextra  : %5u, permctx   : %5u\n"

#: vms-alpha.c:7784
#, c-format
msgid "  base_va : 0x%08x\n"
msgstr "  base_va : 0x%08x\n"

#: vms-alpha.c:7786
#, c-format
msgid "  lppsbfixoff: %5u\n"
msgstr "  lppsbfixoff: %5u\n"

#: vms-alpha.c:7794
#, c-format
msgid " Shareable images:\n"
msgstr " Delelige aftryk:\n"

#: vms-alpha.c:7798
#, c-format
msgid "  %u: size: %u, flags: 0x%02x, name: %.*s\n"
msgstr "  %u: størrelse: %u, flag: 0x%02x, navn: %.*s\n"

#: vms-alpha.c:7805
#, c-format
msgid " quad-word relocation fixups:\n"
msgstr " fixup'er til quad-word-relokeringer:\n"

#: vms-alpha.c:7810
#, c-format
msgid " long-word relocation fixups:\n"
msgstr " fixup'er til long-word-relokeringer:\n"

#: vms-alpha.c:7815
#, c-format
msgid " quad-word .address reference fixups:\n"
msgstr " fixup'er til quad-word .address-referencer:\n"

#: vms-alpha.c:7820
#, c-format
msgid " long-word .address reference fixups:\n"
msgstr " fixup'er til long-word .address-referencer:\n"

#: vms-alpha.c:7825
#, c-format
msgid " Code Address Reference Fixups:\n"
msgstr " Fixup'er til kodeadressereferencer:\n"

#: vms-alpha.c:7830
#, c-format
msgid " Linkage Pairs Referece Fixups:\n"
msgstr " Reference-fixup'er til lænkningspar:\n"

#: vms-alpha.c:7839
#, c-format
msgid " Change Protection (%u entries):\n"
msgstr " Ændringsbeskyttelse (%u elementer):\n"

#: vms-alpha.c:7844
#, c-format
msgid "  base: 0x%08x %08x, size: 0x%08x, prot: 0x%08x "
msgstr "  base: 0x%08x %08x, størrelse: 0x%08x, beskyttelse: 0x%08x "

#. FIXME: we do not yet support relocatable link.  It is not obvious
#. how to do it for debug infos.
#: vms-alpha.c:8676
msgid "%P: relocatable link is not supported\n"
msgstr "%P: relokérbar lænke understøttes ikke\n"

#: vms-alpha.c:8746
msgid "%P: multiple entry points: in modules %B and %B\n"
msgstr "%P: flere indgangspunkter: i modulerne %B og %B\n"

#: vms-lib.c:1421
#, c-format
msgid "could not open shared image '%s' from '%s'"
msgstr "kunne ikke åbne delt aftryk \"%s\" fra \"%s\""

#: vms-misc.c:360
msgid "_bfd_vms_output_counted called with zero bytes"
msgstr "_bfd_vms_output_counted kaldt med nul byte"

#: vms-misc.c:365
msgid "_bfd_vms_output_counted called with too many bytes"
msgstr "_bfd_vms_output_counted  kaldt med for mange byte"

#: xcofflink.c:836
#, c-format
msgid "%s: XCOFF shared object when not producing XCOFF output"
msgstr "%s: XCOFF delt objekt når ikke XCOFF-uddata produceres"

#: xcofflink.c:857
#, c-format
msgid "%s: dynamic object with no .loader section"
msgstr "%s: dynamisk objekt uden nogen .loader-sektion"

#: xcofflink.c:1415
msgid "%B: `%s' has line numbers but no enclosing section"
msgstr "%B: \"%s\" har linjenumre, men ingen omsluttende sektion"

#: xcofflink.c:1467
msgid "%B: class %d symbol `%s' has no aux entries"
msgstr "%B: klasse %d-symbol \"%s\" har ingen aux-poster"

#: xcofflink.c:1489
msgid "%B: symbol `%s' has unrecognized csect type %d"
msgstr "%B: symbol \"%s\" har ukendt csect-type %d"

#: xcofflink.c:1501
msgid "%B: bad XTY_ER symbol `%s': class %d scnum %d scnlen %d"
msgstr "%B: fejlagtigt XTY_ER-symbol \"%s\": klasse %d scnum %d scnlen %d"

#: xcofflink.c:1530
msgid "%B: XMC_TC0 symbol `%s' is class %d scnlen %d"
msgstr "%B: XMC_TC0-symbol \"%s\" er klasse %d scnlen %d"

#: xcofflink.c:1676
msgid "%B: csect `%s' not in enclosing section"
msgstr "%B: csect \"%s\" er ikke i omsluttende sektion"

#: xcofflink.c:1783
msgid "%B: misplaced XTY_LD `%s'"
msgstr "%B: fejlagtigt placeret XTY_LD \"%s\""

#: xcofflink.c:2102
msgid "%B: reloc %s:%d not in csect"
msgstr "%B: relokeringen %s:%d er ikke i csect"

#: xcofflink.c:3186
#, c-format
msgid "%s: no such symbol"
msgstr "%s: intet sådant symbol"

#: xcofflink.c:3291
#, c-format
msgid "warning: attempt to export undefined symbol `%s'"
msgstr "advarsel: forsøg på at eksportere udefineret symbol \"%s\""

#: xcofflink.c:3673
msgid "error: undefined symbol __rtinit"
msgstr "fejl: udefineret symbol __rtinit"

#: xcofflink.c:4052
msgid "%B: loader reloc in unrecognized section `%s'"
msgstr "%B: indlæserrelokering i ukendt sektion \"%s\""

#: xcofflink.c:4063
msgid "%B: `%s' in loader reloc but not loader sym"
msgstr "%B: \"%s\" i indlæserrelokering, men ikke indlæsersym"

#: xcofflink.c:4079
msgid "%B: loader reloc in read-only section %A"
msgstr "%B: indlæserrelokering i skrivebeskyttet sektion %A"

#: xcofflink.c:5097
#, c-format
msgid "TOC overflow: 0x%lx > 0x10000; try -mminimal-toc when compiling"
msgstr "TOC giver overløb: 0x%lx > 0x10000; prøv -mminimal-toc ved oversættelse"

#: elf32-ia64.c:1110 elf64-ia64.c:1110
msgid "%B: Can't relax br at 0x%lx in section `%A'. Please use brl or indirect branch."
msgstr "%B: Kan ikke forenkle br ved 0x%lx i sektionen \"%A\". Brug venligst brl eller indirekte gren."

#: elf32-ia64.c:2809 elf64-ia64.c:2809
msgid "@pltoff reloc against local symbol"
msgstr "@pltoff-relokering mod lokalt symbol"

#: elf32-ia64.c:4430 elf64-ia64.c:4430
#, c-format
msgid "%s: short data segment overflowed (0x%lx >= 0x400000)"
msgstr "%s: kort datasegment løb over (0x%lx >= 0x400000)"

#: elf32-ia64.c:4441 elf64-ia64.c:4441
#, c-format
msgid "%s: __gp does not cover short data segment"
msgstr "%s: __gp dækker ikke kort datasegment"

#: elf32-ia64.c:4708 elf64-ia64.c:4708
msgid "%B: non-pic code with imm relocation against dynamic symbol `%s'"
msgstr "%B: ikke-pic-kode med imm-relokering mod dynamisk symbol \"%s\""

#: elf32-ia64.c:4775 elf64-ia64.c:4775
msgid "%B: @gprel relocation against dynamic symbol %s"
msgstr "%B: @gprel-relokering mod dynamisk symbol %s"

#: elf32-ia64.c:4838 elf64-ia64.c:4838
msgid "%B: linking non-pic code in a position independent executable"
msgstr "%B: lænker ikke-pic-kode i en positionsuafhængig eksekverbar fil"

#: elf32-ia64.c:4975 elf64-ia64.c:4975
msgid "%B: @internal branch to dynamic symbol %s"
msgstr "%B: @intern gren til dynamisk symbol %s"

#: elf32-ia64.c:4977 elf64-ia64.c:4977
msgid "%B: speculation fixup to dynamic symbol %s"
msgstr "%B: spekulations-fixup til dynamisk symbol %s"

#: elf32-ia64.c:4979 elf64-ia64.c:4979
msgid "%B: @pcrel relocation against dynamic symbol %s"
msgstr "%B: @pcrel-relokering mod dynamisk symbol %s"

#: elf32-ia64.c:5176 elf64-ia64.c:5176
msgid "unsupported reloc"
msgstr "relokeringen understøttes ikke"

#: elf32-ia64.c:5214 elf64-ia64.c:5214
msgid "%B: missing TLS section for relocation %s against `%s' at 0x%lx in section `%A'."
msgstr "%B: manglende TLS-sektion til relokering %s mod \"%s\" ved 0x%lx i sektionen \"%A\"."

#: elf32-ia64.c:5229 elf64-ia64.c:5229
msgid "%B: Can't relax br (%s) to `%s' at 0x%lx in section `%A' with size 0x%lx (> 0x1000000)."
msgstr "%B: Kan ikke forenkle br (%s) til \"%s\" på 0x%lx i sektionen \"%A\" med størrelsen 0x%lx (> 0x1000000)."

#: elf32-ia64.c:5491 elf64-ia64.c:5491
msgid "%B: linking trap-on-NULL-dereference with non-trapping files"
msgstr "%B: lænker fang-ved-NULL-dereference med ikkefangende filer"

#: elf32-ia64.c:5500 elf64-ia64.c:5500
msgid "%B: linking big-endian files with little-endian files"
msgstr "%B: lænker big-endian-filer med little endian-filer"

#: elf32-ia64.c:5509 elf64-ia64.c:5509
msgid "%B: linking 64-bit files with 32-bit files"
msgstr "%B: lænker 64 bit-filer med 32 bit-filer"

#: elf32-ia64.c:5518 elf64-ia64.c:5518
msgid "%B: linking constant-gp files with non-constant-gp files"
msgstr "%B: lænker konstant-gp-filer med ikke-konstant-gp-filer"

#: elf32-ia64.c:5528 elf64-ia64.c:5528
msgid "%B: linking auto-pic files with non-auto-pic files"
msgstr "%B: lænker auto-pic-filer med ikke-auto-pic-filer"

#: peigen.c:1002 pepigen.c:1002 pex64igen.c:1002
#, c-format
msgid "%s: line number overflow: 0x%lx > 0xffff"
msgstr "%s: linjenummer giver overløb: 0x%lx > 0xffff"

#: peigen.c:1029 pepigen.c:1029 pex64igen.c:1029
msgid "Export Directory [.edata (or where ever we found it)]"
msgstr "Eksportkatalog [.edata (eller hvor vi fandt det)]"

#: peigen.c:1030 pepigen.c:1030 pex64igen.c:1030
msgid "Import Directory [parts of .idata]"
msgstr "Importkatalog [dele af .idata]"

#: peigen.c:1031 pepigen.c:1031 pex64igen.c:1031
msgid "Resource Directory [.rsrc]"
msgstr "Resursekatalog [.rsrc]"

#: peigen.c:1032 pepigen.c:1032 pex64igen.c:1032
msgid "Exception Directory [.pdata]"
msgstr "Undtagelseskatalog [.pdata]"

#: peigen.c:1033 pepigen.c:1033 pex64igen.c:1033
msgid "Security Directory"
msgstr "Sikkerhedskatalog"

#: peigen.c:1034 pepigen.c:1034 pex64igen.c:1034
msgid "Base Relocation Directory [.reloc]"
msgstr "Baserelokeringskatalog [.reloc]"

#: peigen.c:1035 pepigen.c:1035 pex64igen.c:1035
msgid "Debug Directory"
msgstr "Fejlsøgningskatalog"

#: peigen.c:1036 pepigen.c:1036 pex64igen.c:1036
msgid "Description Directory"
msgstr "Beskrivelseskatalog"

#: peigen.c:1037 pepigen.c:1037 pex64igen.c:1037
msgid "Special Directory"
msgstr "Specialkatalog"

#: peigen.c:1038 pepigen.c:1038 pex64igen.c:1038
msgid "Thread Storage Directory [.tls]"
msgstr "Trådlagringskatalog [.tls]"

#: peigen.c:1039 pepigen.c:1039 pex64igen.c:1039
msgid "Load Configuration Directory"
msgstr "Indlæsningskonfigurationskatalog"

#: peigen.c:1040 pepigen.c:1040 pex64igen.c:1040
msgid "Bound Import Directory"
msgstr "Katalog over bundne importer"

#: peigen.c:1041 pepigen.c:1041 pex64igen.c:1041
msgid "Import Address Table Directory"
msgstr "Importadressetabelkatalog"

#: peigen.c:1042 pepigen.c:1042 pex64igen.c:1042
msgid "Delay Import Directory"
msgstr "Katalog over forskinkede importer"

#: peigen.c:1043 pepigen.c:1043 pex64igen.c:1043
msgid "CLR Runtime Header"
msgstr "CLR-runtime-header"

#: peigen.c:1044 pepigen.c:1044 pex64igen.c:1044
msgid "Reserved"
msgstr "Reserveret"

#: peigen.c:1104 pepigen.c:1104 pex64igen.c:1104
#, c-format
msgid ""
"\n"
"There is an import table, but the section containing it could not be found\n"
msgstr ""
"\n"
"Der findes en importtabel, men sektionen som indeholder den kunne ikke findes\n"

#: peigen.c:1109 pepigen.c:1109 pex64igen.c:1109
#, c-format
msgid ""
"\n"
"There is an import table in %s at 0x%lx\n"
msgstr ""
"\n"
"Der findes en importtabel i %s på 0x%lx\n"

#: peigen.c:1151 pepigen.c:1151 pex64igen.c:1151
#, c-format
msgid ""
"\n"
"Function descriptor located at the start address: %04lx\n"
msgstr ""
"\n"
"Funktionsidentifikatorer fundet på startadressen: %04lx\n"

#: peigen.c:1154 pepigen.c:1154 pex64igen.c:1154
#, c-format
msgid "\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"
msgstr "\tkodebase %08lx toc (indlæseligt/reelt) %08lx/%08lx\n"

#: peigen.c:1162 pepigen.c:1162 pex64igen.c:1162
#, c-format
msgid ""
"\n"
"No reldata section! Function descriptor not decoded.\n"
msgstr ""
"\n"
"Ingen reldata-sektion! Funktionsidentifikatorer afkodedes ikke.\n"

#: peigen.c:1167 pepigen.c:1167 pex64igen.c:1167
#, c-format
msgid ""
"\n"
"The Import Tables (interpreted %s section contents)\n"
msgstr ""
"\n"
"Importtabellerne (tolket indhold i %s-sektion)\n"

# Hvad er thunk?
#: peigen.c:1170 pepigen.c:1170 pex64igen.c:1170
#, c-format
msgid ""
" vma:            Hint    Time      Forward  DLL       First\n"
"                 Table   Stamp     Chain    Name      Thunk\n"
msgstr ""
" vma:            Tips-   Tids-     Fremad-  DLL-      Første\n"
"                 tabel   stempel   kæde     navn      thunk\n"

#: peigen.c:1218 pepigen.c:1218 pex64igen.c:1218
#, c-format
msgid ""
"\n"
"\tDLL Name: %s\n"
msgstr ""
"\n"
"\tDLL-navn: %s\n"

#: peigen.c:1229 pepigen.c:1229 pex64igen.c:1229
#, c-format
msgid "\tvma:  Hint/Ord Member-Name Bound-To\n"
msgstr "\tvma: Tips/Ordn Medlemsnavn Bundet til\n"

#: peigen.c:1254 pepigen.c:1254 pex64igen.c:1254
#, c-format
msgid ""
"\n"
"There is a first thunk, but the section containing it could not be found\n"
msgstr ""
"\n"
"Der findes en første thunk, men sektionen som indeholder den kunne ikke findes\n"

#: peigen.c:1415 pepigen.c:1415 pex64igen.c:1415
#, c-format
msgid ""
"\n"
"There is an export table, but the section containing it could not be found\n"
msgstr ""
"\n"
"Der findes en eksporttabel, men sektionen som indeholder den kunne ikke findes\n"

#: peigen.c:1424 pepigen.c:1424 pex64igen.c:1424
#, c-format
msgid ""
"\n"
"There is an export table in %s, but it does not fit into that section\n"
msgstr ""
"\n"
"Der findes en eksporttabel i %s, men den passer ikke ind i den pågældende sektion\n"

#: peigen.c:1430 pepigen.c:1430 pex64igen.c:1430
#, c-format
msgid ""
"\n"
"There is an export table in %s at 0x%lx\n"
msgstr ""
"\n"
"Der findes en eksporttabel i %s ved 0x%lx\n"

#: peigen.c:1458 pepigen.c:1458 pex64igen.c:1458
#, c-format
msgid ""
"\n"
"The Export Tables (interpreted %s section contents)\n"
"\n"
msgstr ""
"\n"
"Eksporttabellerne (tolket indhold i %s-sektion)\n"

#: peigen.c:1462 pepigen.c:1462 pex64igen.c:1462
#, c-format
msgid "Export Flags \t\t\t%lx\n"
msgstr "Eksportflag \t\t\t%lx\n"

#: peigen.c:1465 pepigen.c:1465 pex64igen.c:1465
#, c-format
msgid "Time/Date stamp \t\t%lx\n"
msgstr "Tids-/datostempel \t\t%lx\n"

#: peigen.c:1468 pepigen.c:1468 pex64igen.c:1468
#, c-format
msgid "Major/Minor \t\t\t%d/%d\n"
msgstr "Større/mindre \t\t\t%d/%d\n"

#: peigen.c:1471 pepigen.c:1471 pex64igen.c:1471
#, c-format
msgid "Name \t\t\t\t"
msgstr "Navn \t\t\t\t"

#: peigen.c:1477 pepigen.c:1477 pex64igen.c:1477
#, c-format
msgid "Ordinal Base \t\t\t%ld\n"
msgstr "Ordningsbase \t\t\t%ld\n"

#: peigen.c:1480 pepigen.c:1480 pex64igen.c:1480
#, c-format
msgid "Number in:\n"
msgstr "Tal i:\n"

#: peigen.c:1483 pepigen.c:1483 pex64igen.c:1483
#, c-format
msgid "\tExport Address Table \t\t%08lx\n"
msgstr "\tEksportadressetabel \t\t%08lx\n"

#: peigen.c:1487 pepigen.c:1487 pex64igen.c:1487
#, c-format
msgid "\t[Name Pointer/Ordinal] Table\t%08lx\n"
msgstr "\t[Navnepeger/Ordningstal]-tabel\t%08lx\n"

#: peigen.c:1490 pepigen.c:1490 pex64igen.c:1490
#, c-format
msgid "Table Addresses\n"
msgstr "Tabeladresser\n"

#: peigen.c:1493 pepigen.c:1493 pex64igen.c:1493
#, c-format
msgid "\tExport Address Table \t\t"
msgstr "\tEksportadressetabel \t\t"

#: peigen.c:1498 pepigen.c:1498 pex64igen.c:1498
#, c-format
msgid "\tName Pointer Table \t\t"
msgstr "\tNavnepegertabel \t\t"

#: peigen.c:1503 pepigen.c:1503 pex64igen.c:1503
#, c-format
msgid "\tOrdinal Table \t\t\t"
msgstr "\tOrdningstalstabel \t\t\t"

#: peigen.c:1517 pepigen.c:1517 pex64igen.c:1517
#, c-format
msgid ""
"\n"
"Export Address Table -- Ordinal Base %ld\n"
msgstr ""
"\n"
"Eksportadressetabel -- Ordningsbase %ld\n"

#: peigen.c:1536 pepigen.c:1536 pex64igen.c:1536
msgid "Forwarder RVA"
msgstr "Videresender-RVA"

#: peigen.c:1547 pepigen.c:1547 pex64igen.c:1547
msgid "Export RVA"
msgstr "Eksport-RVA"

#: peigen.c:1554 pepigen.c:1554 pex64igen.c:1554
#, c-format
msgid ""
"\n"
"[Ordinal/Name Pointer] Table\n"
msgstr ""
"\n"
"[Ordningstals-/Navnepeger-]tabel\n"

#: peigen.c:1614 peigen.c:1797 pepigen.c:1614 pepigen.c:1797 pex64igen.c:1614
#: pex64igen.c:1797
#, c-format
msgid "Warning, .pdata section size (%ld) is not a multiple of %d\n"
msgstr "Advarsel, størrelsen på .pdata-sektionen (%ld) er ikke en multipel af %d\n"

#: peigen.c:1621 pepigen.c:1621 pex64igen.c:1621
#, c-format
msgid " vma:\t\t\tBegin Address    End Address      Unwind Info\n"
msgstr " vma:\t\t\tStartadresse      Slutadresse       Tilbagespolings-information\n"

#: peigen.c:1623 pepigen.c:1623 pex64igen.c:1623
#, c-format
msgid ""
" vma:\t\tBegin    End      EH       EH       PrologEnd  Exception\n"
"     \t\tAddress  Address  Handler  Data     Address    Mask\n"
msgstr ""
" vma:\t\tStart-    Slut-     EH-        EH-    Prologsluts-  Undtagelses-\n"
"     \t\tadresse   adresse   håndterer  data   adresse       maske\n"

#: peigen.c:1697 pepigen.c:1697 pex64igen.c:1697
#, c-format
msgid " Register save millicode"
msgstr " Registergemnings millikode"

#: peigen.c:1700 pepigen.c:1700 pex64igen.c:1700
#, c-format
msgid " Register restore millicode"
msgstr " Registergenskabnings millikode"

#: peigen.c:1703 pepigen.c:1703 pex64igen.c:1703
#, c-format
msgid " Glue code sequence"
msgstr " Klisterkodesekvens"

# Et bogstav for meget i Undtagelse og Håndtering, mon ikke det går?
#: peigen.c:1803 pepigen.c:1803 pex64igen.c:1803
#, c-format
msgid ""
" vma:\t\tBegin    Prolog   Function Flags    Exception EH\n"
"     \t\tAddress  Length   Length   32b exc  Handler   Data\n"
msgstr ""
" vma:\t\tStart    Prolog   Funktion Flag    Undtagelse EH\n"
"     \t\tAdresse  Længde   Længde   32b exc Håndtering Data\n"

#: peigen.c:1929 pepigen.c:1929 pex64igen.c:1929
#, c-format
msgid ""
"\n"
"\n"
"PE File Base Relocations (interpreted .reloc section contents)\n"
msgstr ""
"\n"
"\n"
"PE-filbaserelokeringer (tolket indhold i .reloc-sektionen)\n"

#: peigen.c:1958 pepigen.c:1958 pex64igen.c:1958
#, c-format
msgid ""
"\n"
"Virtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"
msgstr ""
"\n"
"Virtuel adresse: %08lx Områdesstørrelse %ld (0x%lx) Antal rettelser %ld\n"

#: peigen.c:1971 pepigen.c:1971 pex64igen.c:1971
#, c-format
msgid "\treloc %4d offset %4x [%4lx] %s"
msgstr "\trelokering %4d afstand %4x [%4lx] %s"

#. The MS dumpbin program reportedly ands with 0xff0f before
#. printing the characteristics field.  Not sure why.  No reason to
#. emulate it here.
#: peigen.c:2010 pepigen.c:2010 pex64igen.c:2010
#, c-format
msgid ""
"\n"
"Characteristics 0x%x\n"
msgstr ""
"\n"
"Karakteristik 0x%x\n"

#: peigen.c:2310 pepigen.c:2310 pex64igen.c:2310
msgid "%B: unable to fill in DataDictionary[1] because .idata$2 is missing"
msgstr "%B: kan ikke udfylde DataDictionary[1] fordi .idata$2 mangler"

#: peigen.c:2330 pepigen.c:2330 pex64igen.c:2330
msgid "%B: unable to fill in DataDictionary[1] because .idata$4 is missing"
msgstr "%B: kan ikke udfylde DataDictionary[1] fordi .idata$4 mangler"

#: peigen.c:2351 pepigen.c:2351 pex64igen.c:2351
msgid "%B: unable to fill in DataDictionary[12] because .idata$5 is missing"
msgstr "%B: kan ikke udfylde DataDictionary[12] fordi .idata$5 mangler"

#: peigen.c:2371 pepigen.c:2371 pex64igen.c:2371
msgid "%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"
msgstr "%B: kan ikke udfylde DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)], da .idata$6 mangler"

#: peigen.c:2413 pepigen.c:2413 pex64igen.c:2413
msgid "%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)] because .idata$6 is missing"
msgstr "%B: kan ikke udfylde DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)], da .idata$6 mangler"

#: peigen.c:2436 pepigen.c:2436 pex64igen.c:2436
msgid "%B: unable to fill in DataDictionary[9] because __tls_used is missing"
msgstr "%B: kan ikke udfylde DataDictionary[9], da __tls_used mangler"

# src/menus.c:341
#~ msgid "Missing IHCONST"
#~ msgstr "IHCONST mangler"

# src/menus.c:341
#~ msgid "Missing IHIHALF"
#~ msgstr "IHIHALF mangler"

#~ msgid "missing IHCONST reloc"
#~ msgstr "IHCONST-relokering mangler"

#~ msgid "missing IHIHALF reloc"
#~ msgstr "IHIHALF-relokering mangler"

#~ msgid "  first occurrence: %s: arm call to thumb"
#~ msgstr "  første forekomst: %s: arm-kald til thumb"

#~ msgid "  first occurrence: %s: thumb call to arm"
#~ msgstr "  første forekomst: %s: thumb-kald til arm"

#~ msgid "  consider relinking with --support-old-code enabled"
#~ msgstr "  overvej omlænkning med --support-old-code aktiveret"

#~ msgid "reloc against unsupported section"
#~ msgstr "relokering mod sektion som ikke understøttes"

#~ msgid "Dwarf Error: DW_FORM_strp offset (%lu) greater than or equal to .debug_str size (%lu)."
#~ msgstr "Dwarf-fejl: DW_FORM_strp-afstanden (%lu) større end eller lig med størrelsen på .debug_str (%lu)."

#~ msgid "Dwarf Error: Can't find .debug_abbrev section."
#~ msgstr "Dwarf-fejl: Kan ikke finde sektionen .debug_abbrev."

#~ msgid "Dwarf Error: Abbrev offset (%lu) greater than or equal to .debug_abbrev size (%lu)."
#~ msgstr "Dwarf-fejl: Forkortelsesafstanden (%lu) større end eller lig med størrelsen .debug_abbrev (%lu)."

#~ msgid "%s: warning: unresolvable relocation against symbol `%s' from %s section"
#~ msgstr "%s: advarsel: uløselig relokering mod symbol \"%s\" fra sektionen %s"

#~ msgid "%s: Not enough room for program headers (allocated %u, need %u)"
#~ msgstr "%s: Ikke tilstrækkeligt med plads for programhoveder (allokerede %u, behøver %u)"

#~ msgid "Error: First section in segment (%s) starts at 0x%x whereas the segment starts at 0x%x"
#~ msgstr "Fejl: Første sektion i segmentet (%s) begynder ved 0x%x mens segmentet begynder ved 0x%x"

#~ msgid "%s: warning: unresolvable relocation %d against symbol `%s' from %s section"
#~ msgstr "%s: advarsel: uløselig relokering %d mod symbol \"%s\" fra sektionen %s"

#~ msgid "ERROR: %s is compiled for EABI version %d, whereas %s is compiled for version %d"
#~ msgstr "FEJL: %s er oversat for EABI version %d, mens %s er oversat for version %d"

#~ msgid "%s: unresolvable relocation %s against symbol `%s' from %s section"
#~ msgstr "%s: uløselig relokering %s mod symbol \"%s\" fra sektionen %s"

#~ msgid "%s: relocation %s should not be used when making a shared object; recompile with -fPIC"
#~ msgstr "%s: relokeringen %s bør ikke bruges når et delt objekt oprettes; genoversæt med -fPIC"

#~ msgid "%s(%s+0x%lx): fixing %s"
#~ msgstr "%s(%s+0x%lx): retter %s"

#~ msgid " [m68000]"
#~ msgstr " [m68000]"

#~ msgid "Linking mips16 objects into %s format is not supported"
#~ msgstr "Lænkning af mips16-objekter til %s-format understøttes ikke"

#~ msgid "%s: Unknown special linker type %d"
#~ msgstr "%s: Ukendt speciallænkertype %d"

#~ msgid "v850ea architecture"
#~ msgstr "v850ea-arkitektur"

#~ msgid "%s: check_relocs: unhandled reloc type %d"
#~ msgstr "%s: check_relocs: uhåndteret relokeringstype %d"

#~ msgid "%s: Section %s is too large to add hole of %ld bytes"
#~ msgstr "%s: Sektionen %s er for stor til at stoppe hul med %ld byte i"

#~ msgid "Error: out of memory"
#~ msgstr "Fejl: ikke mere hukommelse"

#~ msgid "warning: relocation against removed section; zeroing"
#~ msgstr "advarsel: relokering mod fjernet sektion; nulstiller"

#~ msgid "local symbols in discarded section %s"
#~ msgstr "lokale symboler i bortkastet sektion %s"

#~ msgid "%s: %s+0x%lx: jump to stub routine which is not jal"
#~ msgstr "%s: %s+0x%lx: hop til stubrutine som ikke er jal"

#~ msgid "%s: ISA mismatch (-mips%d) with previous modules (-mips%d)"
#~ msgstr "%s: ISA (-mips%d) passer ikke med tidligere moduler (-mips%d)"

#~ msgid "%s: ISA mismatch (%d) with previous modules (%d)"
#~ msgstr "%s: ISA (%d) passer ikke med tidligere moduler (%d)"

#~ msgid " [mips1]"
#~ msgstr " [mips1]"

#~ msgid " [mips2]"
#~ msgstr " [mips2]"

#~ msgid " [mips3]"
#~ msgstr " [mips3]"

#~ msgid " [mips4]"
#~ msgstr " [mips4]"

#~ msgid " [mips5]"
#~ msgstr " [mips5]"

#~ msgid " [mips32]"
#~ msgstr " [mips32]"

#~ msgid " [mips64]"
#~ msgstr " [mips64]"

#~ msgid " [mips16]"
#~ msgstr " [mips16]"

#~ msgid " [32bitmode]"
#~ msgstr " [32-bittilstand]"

#~ msgid "bfd_make_section (%s) failed"
#~ msgstr "bfd_make_section (%s) mislykkedes"

#~ msgid "bfd_set_section_flags (%s, %x) failed"
#~ msgstr "bfd_set_section_flags (%s, %x) mislykkedes"

#~ msgid "Size mismatch section %s=%lx, %s=%lx"
#~ msgstr "Størrelsen passer ikke på sektion %s=%lx, %s=%lx"

#~ msgid "unknown gsd/egsd subtype %d"
#~ msgstr "ukendt gsd/egsd-undertype %d"

#~ msgid "failed to enter %s"
#~ msgstr "mislykkedes med at gå ind i %s"

#~ msgid "No Mem !"
#~ msgstr "Ingen hukommelse!"

#~ msgid "%s: no symbol \"%s\""
#~ msgstr "%s: intet symbol \"%s\""

#~ msgid "reserved STO cmd %d"
#~ msgstr "reserveret STO-kommando %d"

#~ msgid "reserved OPR cmd %d"
#~ msgstr "reserveret OPR-kommando %d"

#~ msgid "reserved CTL cmd %d"
#~ msgstr "reserveret CTL-kommando %d"

#~ msgid "stack-from-image not implemented"
#~ msgstr "stack-from-image er ikke implementeret"

#~ msgid "stack-entry-mask not fully implemented"
#~ msgstr "stack-entry-mask er ikke helt implementeret"

#~ msgid "stack-local-symbol not fully implemented"
#~ msgstr "stack-local-symbol er ikke helt implementeret"

#~ msgid "stack-literal not fully implemented"
#~ msgstr "stack-literal er ikke helt implementeret"

#~ msgid "stack-local-symbol-entry-point-mask not fully implemented"
#~ msgstr "stack-local-symbol-entry-point-mask er ikke helt implementeret"

#~ msgid "obj code %d not found"
#~ msgstr "objektkode %d kunne ikke findes"

#~ msgid "%s: dynamic relocation against speculation fixup"
#~ msgstr "%s: dynamisk relokering uden spekulationsrettelser"

#~ msgid "%s: speculation fixup against undefined weak symbol"
#~ msgstr "%s: spekulationsfix mod udefineret svagt symbol"

#~ msgid "%s: reloc overflow 1: 0x%lx > 0xffff"
#~ msgstr "%s: relokering giver overløb 1: 0x%lx > 0xffff"
