gcc 4.7.1 - en to vi translation catalogue (2458 entries)

en: 
    For bug reporting instructions, please see:
vi: 
    Để tìm hướng dẫn về thông báo lỗi, thăm địa chỉ:

en: 
    For bug reporting instructions, please see:
    %s.
vi: 
    Để tìm hướng dẫn về thông báo lỗi, thăm địa chỉ:
    %s.

en: 
    Go ahead? (y or n)
vi: 
    Tiếp tục ? (c/k)

en: 
    Linker options
    ==============
vi: 
    Tuỳ chọn liên kết
    ==============

en: 
    Options starting with -g, -f, -m, -O, -W, or --param are automatically
     passed on to the various sub-processes invoked by %s.  In order to pass
     other options on to these processes the -W<letter> options must be used.
vi: 
    Tuỳ chọn bắt đầu với một của -g, -f, -m, -O, -W, --param
    thì được tự động gửi cho những tiến trình con khác nhau được %s gọi.
    Phải sử dụng tuỳ chọn -W<chữ> để gửi thêm tuỳ chọn cho những tiến trình này.

en: 
    ldd output with constructors/destructors.
vi: 
    kết xuất ldd với bộ (hủy) cấu trúc.

en: 
    write_c_file - output name is %s, prefix is %s
vi: 
    write_c_file - tên kết xuất là %s, tiền tố là %s

en:                            Display specific types of command line options
vi:                            Hiển thị một số loại tuỳ chọn dòng lệnh nào đó

en:     inlined from %qs
vi:     trực tiếp từ %qs

en:     inlined from %qs at %s:%d
vi:     trực tiếp từ %qs tại %s:%d

en:     inlined from %qs at %s:%d:%d
vi:     trực tiếp từ %qs tại %s:%d:%d

en:   %qT is not derived from %qT
vi:   %qT không được dẫn xuất từ %qT

en:   (Use '-v --help' to display command line options of sub-processes)
vi:   (Hãy sử dụng '-v --help' để hiển thị các tuỳ chọn dòng lệnh của tiến trình con)

en:   -###                     Like -v but options quoted and commands not executed
vi:   -###                     Giống như -v nhưng mà tuỳ chọn nằm trong dấu nháy
            và lệnh không được thực hiện

en:   --bootclasspath PATH    Override built-in class path
vi:   --bootclasspath ĐƯỜNG_DẪN    Có quyền cao hơn đường dẫn hạng dựng sẵn

en:   --classpath PATH        Set path to find .class files
vi:   --classpath ĐƯỜNG_DẪN    Lập đường dẫn theo đó cần tìm tập tin .class (hạng)

en:   --extdirs PATH          Set extensions directory path
vi:   --extdirs ĐƯỜNG_DẪN          Lập đường dẫn đến thư mục phần mở rộng

en:   --help                   Display this information
vi:   --help                   Hiển thị trợ giúp này

en:   --help                  Print this help, then exit
vi:   --help                  Hiển thị trợ giúp này, sau đó thoát

en:   --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...]
vi:   --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...]
    
    help				trợ giúp
    common				chung
    optimizers		bộ tối ưu hoá
    params			(viết tắt parameters) tham số
    warnings			cảnh báo
    target			đích
    joined			nối lại
    separate			không nối lại
    undocumented		không có tài liệu diễn tả

en:   --javap                 Generate output in 'javap' format
vi:   --javap                 Tạo kết xuất bằng định dạng 'javap'

en:   --sysroot=<directory>    Use <directory> as the root directory for headers
                               and libraries
vi:   --sysroot=<thư_mục>
            Dùng thư mục này làm thư mục gốc cho các phần đầu và thư viện

en:   --target-help            Display target specific command line options
vi:   --target-help            Hiển thị những tuỳ chọn dòng lệnh đặc trưng cho đích

en:   --version                Display compiler version information
vi:   --version                Hiển thị thông tin về phiên bản của bộ biên dịch

en:   --version               Print version number, then exit
vi:   --version               Hiển thị số thứ tự phiên bản, sau đó thoát

en:   -B <directory>           Add <directory> to the compiler's search paths
vi:   -B <thư_mục>    Thêm thư mục này vào các đường dẫn tìm kiếm của bộ biên dịch

en:   -E                       Preprocess only; do not compile, assemble or link
vi:   -E                  Chỉ tiền xử lý, đừng biên dịch, dịch mã số hoặc liên kết

en:   -IDIR                   Append directory to class path
vi:   -ITHƯ_MỤC                   Phụ thêm thư mục vào đường dẫn hạng

en:   -S                       Compile only; do not assemble or link
vi:   -S                       Chỉ biên dịch, đừng dịch mã số hoặc liên kết

en:   -Wa,<options>            Pass comma-separated <options> on to the assembler
vi:   -Wa,<tuỳ_chọn>
        Chuyển cho chương trình dịch mã số các tuỳ chọn này định giới bằng dấu phẩy

en:   -Wl,<options>            Pass comma-separated <options> on to the linker
vi:   -Wl,<tuỳ_chọn>
        Chuyển cho bộ liên kết các tuỳ chọn này định giới bằng dấu phẩy

en:   -Wp,<options>            Pass comma-separated <options> on to the preprocessor
vi:   -Wp,<tuỳ_chọn>
        Chuyển cho bộ tiền xử lý các tuỳ chọn này định giới bằng dấu phẩy

en:   -Xassembler <arg>        Pass <arg> on to the assembler
vi:   -Xassembler <đối_số>        Chuyển đối số này cho chương trình dịch mã số

en:   -Xlinker <arg>           Pass <arg> on to the linker
vi:   -Xlinker <đối_số>           Chuyển đối số này cho bộ liên kết

en:   -Xpreprocessor <arg>     Pass <arg> on to the preprocessor
vi:   -Xpreprocessor <đối_số>     Chuyển đối số này cho bộ tiền xử lý

en:   -a, --all-blocks                Show information for every basic block
vi:   -a, --all-blocks                Hiển thị thông tin cho mọi khối cơ bản

en:   -b, --branch-probabilities      Include branch probabilities in output
vi:   -b, --branch-probabilities      Bao gồm trong kết xuất các xác xuất nhánh

en:   -c                       Compile and assemble, but do not link
vi:   -c                       Biên dịch và dịch mã số mà đừng liên kết

en:   -c                      Disassemble method bodies
vi:   -c                      Tháo rời các thân phương pháp

en:   -c, --branch-counts             Given counts of branches taken
                                        rather than percentages
vi:   -c, --branch-counts    Đưa ra số đếm các nhánh được theo, thay cho phần trăm

en:   -d, --display-progress          Display progress information
vi:   -d, --display-progress          Hiển thị tiến trình công việc

en:   -dumpmachine             Display the compiler's target processor
vi:   -dumpmachine             Hiển thị bộ xử lý đích của bộ biên dịch

en:   -dumpspecs               Display all of the built in spec strings
vi:   -dumpspecs               Hiển thị tất cả các chuỗi đặc tả dựng sẵn

en:   -dumpversion             Display the version of the compiler
vi:   -dumpversion             Hiển thị phiên bản của bộ biên dịch

en:   -f, --function-summaries        Output summaries for each function
vi:   -f, --function-summaries        Xuất bản tóm tắt cho mỗi hàm

en:   -h, --help                      Print this help, then exit
vi:   -h, --help                  Hiển thị trợ giúp này, sau đó thoát.

en:   -l, --long-file-names           Use long output file names for included
                                        source files
vi:   -l, --long-file-names    Dùng tên tập tin kết xuất dài cho tập tin nguồn được bao gồm

en:   -n, --no-output                 Do not create an output file
vi:   -n, --no-output                 Đừng tạo tập tin kết xuất

en:   -no-canonical-prefixes   Do not canonicalize paths when building relative
                               prefixes to other gcc components
vi:   -no-canonical-prefixes    Đừng làm cho đường dẫn theo đúng quy tắc
            khi xây dựng tiền tố tương ứng với thành phần gcc khác

en:   -o <file>                Place the output into <file>
vi:   -o <tệp>                Để kết xuất vào tập tin này

en:   -o FILE                 Set output file name
vi:   -o TỆP                 Lập tên tập tin kết xuất

en:   -o, --object-directory DIR|FILE Search for object files in DIR or called FILE
vi:   -o, --object-directory TMỤC|TỆP
            Quét thư mục này hoặc tập tin được gọi này tìm tập tin đối tượng

en:   -p, --preserve-paths            Preserve all pathname components
vi:   -p, --preserve-paths            Bảo tồn tất cả các thành phần tên đường dẫn

en:   -pass-exit-codes         Exit with highest error code from a phase
vi:   -pass-exit-codes         Thoát với mã lỗi cao nhất từ một giai đoạn nào đó

en:   -pie                     Create a position independent executable
vi:   -pie                    Tạo vị trí độc lập thi hành

en:   -pipe                    Use pipes rather than intermediate files
vi:   -pipe                    Dùng ống dẫn thay cho tập tin trung gian

en:   -print-file-name=<lib>   Display the full path to library <lib>
vi:   -print-file-name=<thư_viện>    Hiển thị đường dẫn đầy đủ đến thư viện này

en:   -print-libgcc-file-name  Display the name of the compiler's companion library
vi:   -print-libgcc-file-name    Hiển thị tên của thư viện bổ trợ của bộ biên dịch

en:   -print-multi-directory   Display the root directory for versions of libgcc
vi:   -print-multi-directory    Hiển thị thư mục gốc cho các phiên bản thư viện libgcc

en:   -print-multi-lib         Display the mapping between command line options and
                               multiple library search directories
vi:   -print-multi-lib
        Hiển thị sự ánh xạ giữa các tuỳ chọn dòng lệnh và nhiều thư mục tìm kiếm thư viện

en:   -print-multi-os-directory Display the relative path to OS libraries
vi:   -print-multi-os-directory    Hiển thị đường dẫn tương đối đến các thư mục HĐH

en:   -print-prog-name=<prog>  Display the full path to compiler component <prog>
vi:   -print-prog-name=<trình>
            Hiển thị đường dẫn đầy đủ đến thành phần bộ biên dịch này

en:   -print-search-dirs       Display the directories in the compiler's search path
vi:   -print-search-dirs
            Hiển thị những thư mục nằm trên đường dẫn tìm kiếm của bộ biên dịch

en:   -print-sysroot           Display the target libraries directory
vi:   -print-sysroot           Hiển thị thư mục chứa các thư viện đích

en:   -print-sysroot-headers-suffix Display the sysroot suffix used to find headers
vi:   -print-sysroot-headers-suffix    Hiển thị hậu tố sysroot dùng để tìm phần đầu

en:   -r, --relative-only             Only show data for relative sources
vi:   -r, --relative-only             Chỉ hiển thị dữ liệu cho dữ liệu nguồn có liên quan

en:   -s, --source-prefix DIR         Source prefix to elide
vi:   -s, --source-prefix TMỤC        Tiền tố mã nguồn cho elide

en:   -save-temps              Do not delete intermediate files
vi:   -save-temps              Đừng xoá bỏ tập tin trung gian

en:   -save-temps=<arg>        Do not delete intermediate files
vi:   -save-temps=<đối_số>        Đừng xoá bỏ tập tin trung gian

en:   -shared                  Create a shared library
vi:   -shared                  Tạo thư viện chia sẻ (liên kết động)

en:   -specs=<file>            Override built-in specs with the contents of <file>
vi:   -specs=<tệp>    Ghi đè lên đặc tả dựng sẵn bằng nội dung của tập tin này

en:   -std=<standard>          Assume that the input sources are for <standard>
vi:   -std=<tiêu_chuẩn>          Giả sử là các nguồn đầu vào là theo tiêu chuẩn này

en:   -time                    Time the execution of each subprocess
vi:   -time                    Đếm thời gian chạy mỗi tiến trình con

en:   -u, --unconditional-branches    Show unconditional branch counts too
vi:   -u, --unconditional-branches    Cũng hiển thị số đếm các nhánh không điều khiển

en:   -v                       Display the programs invoked by the compiler
vi:   -v                       Hiển thị những chương trình được gọi bởi bộ biên dịch

en:   -v, --verbose           Print extra information while running
vi:   -v, --verbose           Hiển thị thêm thông tin trong khi chạy

en:   -v, --version                   Print version number, then exit
vi:   -v, --version               Hiển thị số thứ tự phiên bản, sau đó thoát.

en:   -x <language>            Specify the language of the following input files
                               Permissible languages include: c c++ assembler none
                               'none' means revert to the default behavior of
                               guessing the language based on the file's extension
vi:   -x <ngôn_ngữ>    Ghi rõ ngôn ngữ của những tập tin nhập vào mà theo sau
        		               Các ngôn ngữ có thể sử dụng: c, c++, none
                                      'none' (không có) = hoàn nguyên về ứng dụng mặc định
                                      là đoán ngôn ngữ dựa vào phần mở rộng của tập tin

en:   as it is a non-system directory that duplicates a system directory
vi:   vì nó là một thư mục không phải hệ thống mà nhân đôi một thư mục hệ thống

en:   by %q+D
vi:   bởi %q+D

en:   for conversion from %qT to %qT
vi:   cho chuyển đổi từ %qT thành %qT

en:   from here
vi:   từ đây

en:   profiling support are only provided in archive format
vi:   cũng hỗ trợ chức năng đo hiệu năng sử dụng chỉ được cung cấp theo định dạng kho lưu

en:  All options with the desired characteristics have already been displayed
vi:  Đã hiển thị tất cả các tuỳ chọn có những đặc điểm đã muốn

en:  No options with the desired characteristics were found
vi:  Không tìm thấy tuỳ chọn có những đặc điểm đã muốn

en:  None found.  Use --help=%s to show *all* the options supported by the %s front-end
vi:  Không tìm thấy. Hãy sử dụng --help=%s để hiển thị * tất cả * các tuỳ chọn được giao diện %s hỗ trợ

en:  candidate 1: %q+#F
vi:  ứng cử 1: %q+#F

en:  candidate 2: %q+#F
vi:  ứng cử 2: %q+#F

en:  conflicting code gen style switches are used
vi:  sử dụng các cái chuyển loại tạo mã xung đột với nhau

en: #include "..." search starts here:
vi: #include "..." việc tìm kiếm bắt đầu ở đây:

en: #include <...> search starts here:
vi: #include <...> việc tìm kiếm bắt đầu ở đây:

en: %<#pragma omp barrier%> may only be used in compound statements
vi: %<#pragma omp barrier%> chỉ có thể sử dụng trong các biểu thức phức hợp

en: %<#pragma omp flush%> may only be used in compound statements
vi: %<#pragma omp flush%> chỉ có thể sử dụng trong các biểu thức phức hợp

en: %<#pragma omp section%> may only be used in %<#pragma omp sections%> construct
vi: %<#pragma omp section%> chỉ có thể sử dụng trong cấu trúc %<#pragma omp sections%>

en: %<#pragma omp taskwait%> may only be used in compound statements
vi: %<#pragma omp taskwait%> chỉ có thể sử dụng trong các biểu thức phức hợp

en: %<#pragma omp taskyield%> may only be used in compound statements
vi: %<#pragma omp taskyield%> chỉ có thể sử dụng trong các biểu thức phức hợp

en: %<%D::%D%> is not a class member
vi: %<%D::%D%> không phải là thành viên lớp

en: %<%E::%E%> is not a class or namespace
vi: %<%E::%E%> không phải là một lớp hoặc namespace

en: %<%T::%D%> is not a valid declarator
vi: %<%T::%D%>không phải là khai báo hợp lệ

en: %<-fobjc-gc%> is ignored for %<-fgnu-runtime%>
vi: %<-fobjc-gc%> bị lờ đi cho %<-fgnu-runtime%>

en: %<-fobjc-sjlj-exceptions%> is ignored for %<-fnext-runtime%> when %<-fobjc-abi-version%> >= 2
vi: %<-fobjc-sjlj-exceptions%> bị lờ đi cho %<-fnext-runtime%> khi %<-fobjc-abi-version%> >= 2

en: %<-mcpu=%> is deprecated; use %<-mtune=%> or %<-march=%> instead
vi: %<-mcpu=%> bị phản đối; dùng %<-mtune=%> hoặc %<-march=%> để thay thế

en: %<-mgp32%> used with a 64-bit ABI
vi: %<-mgp32%> dùng với 64-bit ABI

en: %<-mintel-syntax%> and %<-mno-intel-syntax%> are deprecated; use %<-masm=intel%> and %<-masm=att%> instead
vi: %<-mintel-syntax%> và %<-mno-intel-syntax%> bị phản đối; dùng %<-masm=intel%> và %<-masm=att%> để thay thế

en: %<-msse5%> was removed
vi: %<-msse5%> đã bị gỡ bỏ

en: %<::%E%> is not a class or namespace
vi: %<::%E%> không phải một lớp hay namespace

en: %<@dynamic%> is not available in Objective-C 1.0
vi: %<@dynamic%> không sẵn dùng trong Objective-C 1.0

en: %<@synthesize%> is not available in Objective-C 1.0
vi: %<@synthesize%> không sẵn dùng trong Objective-C 1.0

en: %<_Sat%> is used without %<_Fract%> or %<_Accum%>
vi: %<_Sat%> được dùng mà không có %<_Fract%> or %<_Accum%>

en: %<__builtin_complex%> operands of different types
vi: %<__builtin_complex%> toán hạng không đúng kiểu

en: %<__int128%> is not supported by this target
vi: %<__int128%> không được hỗ trợ bởi đích này

en: %<__int128%> is not supported for this target
vi: %<__int128%> không được hỗ trợ cho đích này

en: %<__thread%> before %<extern%>
vi: %<__thread%> trước %<extern%>

en: %<__thread%> before %<static%>
vi: %<__thread%> trước %<static%>

en: %<__thread%> used with %<auto%>
vi: %<__thread%> được dùng với %<auto%>

en: %<__thread%> used with %<register%>
vi: %<__thread%> được dùng với %<register%>

en: %<__thread%> used with %<typedef%>
vi: %<__thread%> được dùng với %<typedef%>

en: %<__thread%> used with %qE
vi: %<__thread%> được dùng với %qE

en: %<else%> without a previous %<if%>
vi: %<else%> mà không có %<if%> ở trước

en: %<long long long%> is too long for GCC
vi: %<long long long%> là quá dài đối với GCC

en: %<long long%> invalid for %qs
vi: %<long long%> không hợp lệ với %qs

en: %<long%> and %<short%> specified together for %qs
vi: %<long%> và %<short%> được chỉ định cùng nhau với %qs

en: %<long%> invalid for %qs
vi: %<long%>không hợp lệ với %qs

en: %<long%> or %<short%> invalid for %qs
vi: %<long%> hoặc %<short%> không hợp lệ với %qs

en: %<long%> or %<short%> specified with char for %qs
vi: %<long%> hoặc %<short%> đựoc chỉ định với kiểu char với %qs

en: %<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs
vi: %<long%>, %<int%>, %<short%>, hoặc %<char%> không hợp lệ cho %qs

en: %<short%> invalid for %qs
vi: %<short%> không hợp lệ với %qs

en: %<short%> or %<long%> invalid for %qs
vi: %<short%> hoặc %<long%> không hợp lệ với %qs

en: %<signed%> and %<unsigned%> specified together for %qs
vi: %<signed%> và %<unsigned%> được chỉ định cùng với nhau cho %qs

en: %<signed%> or %<unsigned%> invalid for %qs
vi: %<signed%> hoặc %<unsigned%> không hợp lệ với %qs

en: %<sizeof%> applied to a bit-field
vi: %<sizeof%> được áp dụng cho bit-field

en: %<typeof%> applied to a bit-field
vi: %<typeof%> được áp dụng cho một bit-field

en: %d constructor found
     | %d constructors found
vi[0]: Tìm thấy %d bộ cấu trúc

en: %d destructor found
     | %d destructors found
vi[0]: Tìm thấy %d bộ hủy cấu trúc

en: %d frame table found
     | %d frame tables found
vi[0]: Tìm thấy %d bảng khung

en: %q#D not declared in class
vi: %q#D chưa được khai báo trong lớp

en: %q#T is not a class
vi: %q#T không phải là một lớp

en: %q+#D cannot be overloaded
vi: %q+#D không thể được quá tải

en: %q+#D is inaccessible
vi: %q+#D là không thể truy cập

en: %q+#D is private
vi: %q+#D là private

en: %q+#D is protected
vi: %q+#D là protected

en: %q+D declared as a friend
vi: %q+D được khai báo là friend

en: %q+D declared here
vi: %q+D được khai báo ở đây

en: %q+D is usually a function
vi: %q+D thường là một hàm

en: %q+D was hidden
vi: %q+D bị ẩn

en: %q+E is not a constant expression
vi: %q+E không phải biểu thức hằng

en: %q+F used but never defined
vi: %q+F được dùng mà chưa từng được định nghĩa

en: %qD called in a constant expression
vi: %qD được gọi trong một biểu thức hằng

en: %qD declared as a %<virtual%> variable
vi: %qD được khai báo là một biến %<virtual%>

en: %qD declared as a non-parameter
vi: %qD đã được định nghĩa là không có tham số

en: %qD declared here
vi: %qD được khai báo ở đây

en: %qD has already been defined
vi: %qD đã định nghĩa rồi

en: %qD is not a type
vi: %qD không phải là một kiểu

en: %qD is not a variable
vi: %qD không phải là một biến

en: %qD is used uninitialized in this function
vi: %qD được dùng để bỏ khởi tạo trong hàm này

en: %qD was declared here
vi: %qD đã được khai báo ở đây

en: %qE is not a class or namespace
vi: %qE không phải một lớp hay namespace

en: %qE is not a constant expression
vi: %qE không phải là biểu thức hằng

en: %qE is not a type
vi: %qE không phải là một kiểu

en: %qT has no member named %qE
vi: %qT không có thành viên nào mang tên %qE

en: %qs function cannot have arguments
vi: %qs hàm không có đối số

en: %qs function cannot return a value
vi: %qs hàm không trả về giá trị nào

en: %qs has overflowed
vi: %qs có chỗ bị tràn

en: %qs is incompatible with %qs
vi: %qs không tương thích với %qs

en: %qs is not a gcov data file
vi: %qs không phải là tập tin dữ liệu gcov

en: %qs is not a valid class name
vi: '%qs' không phải là một tên lớp đúng

en: %qs is not a valid option to the preprocessor
vi: '%qs' không phải là một tuỳ chọn hợp lệ cho bộ tiền xử lý

en: %qs is not valid for %qs
vi: %qs không hợp lệ cho %qs

en: %s (program %s)
vi: %s (chương trình %s)

en: %s does not support block_ends_with_call_p
vi: %s không hỗ trợ block_ends_with_call_p

en: %s does not support block_ends_with_condjump_p
vi: %s không hỗ trợ block_ends_with_condjump_p

en: %s does not support can_duplicate_block_p
vi: %s không hỗ trợ can_duplicate_block_p

en: %s does not support can_merge_blocks_p
vi: %s không hỗ trợ can_merge_blocks_p

en: %s does not support can_remove_branch_p
vi: %s không hỗ trợ can_remove_branch_p

en: %s does not support create_basic_block
vi: %s không hỗ trợ create_basic_block

en: %s does not support delete_basic_block
vi: %s không hỗ trợ delete_basic_block

en: %s does not support duplicate_block
vi: %s không hỗ trợ duplicate_block

en: %s does not support flow_call_edges_add
vi: %s không hỗ trợ flow_call_edges_add

en: %s does not support make_forwarder_block
vi: %s không hỗ trợ make_forwarder_block

en: %s does not support merge_blocks
vi: %s không hỗ trợ merge_blocks

en: %s does not support move_block_after
vi: %s không hỗ trợ move_block_after

en: %s does not support predict_edge
vi: %s không hỗ trợ predict_edge

en: %s does not support predicted_by_p
vi: %s không hỗ trợ predicted_by_p

en: %s does not support redirect_edge_and_branch
vi: %s không hỗ trợ redirect_edge_and_branch

en: %s does not support redirect_edge_and_branch_force
vi: %s không hỗ trợ redirect_edge_and_branch_force

en: %s does not support split_block
vi: %s không hỗ trợ split_block

en: %s does not support split_edge
vi: %s không hỗ trợ split_edge

en: %s only accepts %d arguments
vi: %s chỉ chấp nhận %d tham số

en: %s only accepts 1 argument
vi: %s chỉ chấp nhận một tham số

en: %s only accepts 2 arguments
vi: %s chỉ chấp nhận hai tham số

en: %s returned %d exit status
vi: %s trả lại trạng thái thoát %d

en: %s tag
vi: thẻ %s

en: %s terminated with signal %d [%s]
vi: %s bị chấm dứt với tín hiệu %d [%s]

en: %s terminated with signal %d [%s], core dumped
vi: %s bị chấm dứt với tín hiệu %d [%s], cũng đổ lõi

en: %s"%s"%s is invalid
vi: %s"%s"%s không hợp lệ

en: %s"%s"%s is not allowed
vi: %s"%s"%s là không được phép

en: %s%D(%T) <built-in>
vi: %s%D(%T) <dựng-sẵn>

en: %s%D(%T, %T) <built-in>
vi: %s%D(%T, %T) <dựng-sẵn>

en: %s%D(%T, %T, %T) <built-in>
vi: %s%D(%T, %T, %T) <dựng-sắn>

en: %s%s%s %sversion %s (%s)
    %s	compiled by GNU C version %s,
vi: %s%s%s %sversion %s (%s)
    %s	biên dịch bằng GNU C phiên bản %s,

en: %s%s%s %sversion %s (%s) compiled by CC,
vi: %s%s%s %sversion %s (%s) biên dịch bằng CC,

en: %s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
vi: %s%sGGC tìm ra: --param ggc-min-expand=%d --param ggc-min-heapsize=%d

en: %s%swarning: %s header version %s differs from library version %s.
vi: %s%swarning: phiên bản phần đầu %s %s vẫn khác với phiên bản thư viện %s.

en: %s-%s is an empty range
vi: %s-%s là một vùng trống rỗng

en: %s: %s compiler not installed on this system
vi: %s: trình biên dịch %s chưa được cài đặt trên hệ thống này

en: %s: -fcompare-debug failure
vi: %s: -fcompare-debug thất bại

en: %s: -fcompare-debug failure (length)
vi: %s: -fcompare-debug thất bại (độ dài)

en: %s: Cannot open output file: %s
vi: %s: Không thể mở tập tin kết xuất: %s

en: %s: Failed to close output file %s
vi: %s: Không đóng được tập tin kết xuất %s

en: %s: PCH file was invalid
vi: %s: tập tin PCH không hợp lệ

en: %s: all warnings being treated as errors
vi: %s: xử lý các cảnh báo như là các lỗi

en: %s: cannot open as COFF file
vi: %s: không thể mở dưới dạng tập tin COFF

en: %s: couldn%'t open PCH file: %m
vi: %s: couldn%'t mở tập tin PCH: %m

en: %s: not a COFF file
vi: %s: không phải là một tập tin COFF

en: %s: section %s is missing
vi: %s: phần %s còn thiếu

en: %s: some warnings being treated as errors
vi: %s: xử lý một số các cảnh báo như là các lỗi

en: %s:%d: Invalid state file;
vi: %s:%d: Sai tập tin trạng thái;

en: %s:%d: confused by earlier errors, bailing out
vi: %s:%d: lộn xộn do lỗi trước nên hủy bỏ

en: %s:%d:%d: Invalid state file;
vi: %s:%d:%d: Tập tin tình trạng không hợp lệ;

en: %s:'%s' has arcs from exit block
vi: %s: '%s' có cung từ khối đi vào

en: %s:'%s' has arcs to entry block
vi: %s: '%s' có cung đến khối đi vào

en: %s:'%s' lacks entry and/or exit blocks
vi: %s: '%s' còn thiếu khối đi vào và/hay đi ra

en: %s:already seen blocks for '%s'
vi: %s: đã thấy khối cho '%s'

en: %s:cannot open data file, assuming not executed
vi: %s: không thể mở tập tin dữ liệu, giả sử là nó chưa thực hiện

en: %s:corrupted
vi: %s: bị hỏng

en: %s:graph is unsolvable for '%s'
vi: %s: đồ thị không thể giải được cho '%s'

en: %s:no functions found
vi: %s: không tìm thấy hàm

en: %s:no lines for '%s'
vi: %s: không có dòng cho '%s'

en: %s:not a gcov data file
vi: %s: không phải là một tập tin dữ liệu gcov

en: %s:overflowed
vi: %s: bị tràn

en: %s:profile mismatch for '%s'
vi: %s: hồ sơ không tương ứng với '%s'

en: %s:unknown function '%u'
vi: %s: không rõ hàm '%u'

en: %s:version '%.4s', prefer '%.4s'
vi: %s: phiên bản '%.4s' mà thích '%.4s' hơn

en: %s:version '%.4s', prefer version '%.4s'
vi: %s: phiên bản '%.4s' mà thích phiên bản '%.4s' hơn

en: ' ' flag
vi: cờ ' '

en: '!' flag
vi: cờ '!'

en: '#' flag
vi: cờ '#'

en: '%%%c' is not a valid operand prefix
vi: '%%%c' không phải là một tiền tố toán hạng đúng

en: '%%&' used without any local dynamic TLS references
vi: '%%&' bị sử dụng mà không có tham chiếu TLS năng động cục bộ

en: '%%l' operand isn't a label
vi: toán hạng '%%l' không phải là một nhãn

en: ''' flag
vi: cờ '''

en: '(' flag
vi: cờ '('

en: '+' flag
vi: cờ '+'

en: '-' flag
vi: cờ '-'

en: '0' flag
vi: cờ '0'

en: 'B' operand has multiple bits set
vi: toán hạng 'B' có nhiều bit được lập

en: 'B' operand is not constant
vi: toán hạng 'B' không phải là một hằng số

en: 'E' modifier
vi: đồ sửa đổi 'E'

en: 'I' flag
vi: cờ 'I'

en: 'O' modifier
vi: đồ sửa đổi 'O'

en: '^' flag
vi: cờ '^'

en: '_' flag
vi: cờ '_'

en: 'a' flag
vi: cờ 'a'

en: 'm' flag
vi: cờ 'm'

en: 'o' operand is not constant
vi: toán hạng 'o' không phải là một hằng số

en: 'q' flag
vi: cờ 'q'

en: (C)
vi: ©

en: (anonymous)
vi: (nặc danh)

en: (static destructors for %s)
vi: (bộ hủy tĩnh cho %s)

en: (static initializers for %s)
vi: (bộ sơ khởi tĩnh cho %s)

en: (the message is only displayed one per source file)
vi: (thông điệp này được hiển thị chỉ một lần cho mỗi tập tin nguồn)

en: ({anonymous})
vi: ({nặc danh})

en: *** WARNING *** there are active plugins, do not report this as a bug unless you can reproduce it without enabling any plugins.
vi: *** CẢNH BÁO *** có phần bổ sung vẫn hoạt động: đừng thông báo trường hợp này như là một lỗi nếu bạn có thể tạo nó lần nữa mà không hiệu lực phần bổ sung nào.

en: --CLASSPATH	Deprecated; use --classpath instead
vi: --CLASSPATH	Bị phản đối; có nên sử dụng --classpath để thay thế

en: --bootclasspath=<path>	Replace system path
vi: --bootclasspath=<đường_dẫn>	Thay thế đường dẫn hệ thống

en: --classpath=<path>	Set class path
vi: --classpath=<đường_dẫn>	Lập đường dẫn hạng

en: --encoding=<encoding>	Choose input encoding (defaults from your locale)
vi: --encoding=<mã_ký_tự>	Chọn mã ký tự của đầu vào (mặc định là miền địa phương)

en: --extdirs=<path>	Set the extension directory path
vi: --extdirs=<đường_dẫn>	Lập đường dẫn đến thư mục phần mở rộng

en: --help argument %q.*s is ambiguous, please be more specific
vi: đối số --help %q.*s chưa rõ ràng, hãy chính xác hơn

en: --param inline-unit-growth limit reached
vi: đã tới giới hạn --param inline-unit-growth

en: --param large-function-growth limit reached
vi: đã tới giới hạn --param large-function-growth

en: --param large-stack-frame-growth limit reached
vi: đã tới giới hạn --param large-stack-frame-growth

en: --param max-inline-insns-auto limit reached
vi: đã tới giới hạn --param max-inline-insns-auto

en: --param max-inline-insns-single limit reached
vi: đã tới giới hạn --param max-inline-insns-single

en: --resource requires -o
vi: '--resource' cũng yêu cầu '-o'

en: -A<question>=<answer>	Assert the <answer> to <question>.  Putting '-' before <question> disables the <answer> to <question>
vi: -A<hỏi>=<đáp>	Khắng định trả lời cho một câu hỏi nào đó.
    		Thêm dấu trừ - vào trước <hỏi> thì tắt <đáp> đó.

en: -D<macro>[=<val>]	Define a <macro> with <val> as its value.  If just <macro> is given, <val> is taken to be 1
vi: -D<vĩ_lệnh>[=<giá_trị>]	Xác định vĩ lệnh này có giá trị này. Chỉ đưa ra vĩ lệnh thì giá trị được giả sử là 1

en: -E or -x required when input is from standard input
vi: Nhập từ đầu vào tiêu chuẩn thì cũng yêu cầu tuỳ chọn -E hoặc -x

en: -F <dir>	Add <dir> to the end of the main framework include path
vi: -F <thư_mục>	Phụ thêm thư mục này vào đường dẫn bao gồm khuôn khổ chính

en: -I <dir>	Add <dir> to the end of the main include path
vi: -I <thư_mục>	Phụ thêm thư mục này vào đường dẫn bao gồm chính

en: -I- specified twice
vi: -I- được chỉ định hai lần

en: -J<directory>	Put MODULE files in 'directory'
vi: -J<thư_mục>	Để vào thư mục này các tập tin MÔ-ĐUN

en: -MF <file>	Write dependency output to the given file
vi: -MF <tệp>	Ghi vào tập tin này kết xuất về quan hệ phụ thuộc

en: -MG may only be used with -M or -MM
vi: -MG chỉ nên dùng với -M hoặc -MM

en: -MQ <target>	Add a MAKE-quoted target
vi: -MQ <đích>	Thêm một đích được MAKE trích dẫn

en: -MT <target>	Add an unquoted target
vi: -MT <đích>	Thêm một đích không phải được trích dẫn

en: -U<macro>	Undefine <macro>
vi: -U<vĩ_lệnh>	Hủy xác định vĩ lệnh này

en: -Werror=%s: no option -%s
vi: -Werror=%s: không có tùy chọn -%s

en: -Wformat-contains-nul ignored without -Wformat
vi: -Wformat-contains-nul bị lờ đi nếu không có -Wformat

en: -Wformat-extra-args ignored without -Wformat
vi: -Wformat-extra-args bị lờ đi nếu không có -Wformat

en: -Wformat-nonliteral ignored without -Wformat
vi: -Wformat-nonliteral bị lờ đi nếu không có -Wformat

en: -Wformat-security ignored without -Wformat
vi: -Wformat-security bị lờ đi nếu không có -Wformat

en: -Wformat-y2k ignored without -Wformat
vi: -Wformat-y2k bị lờ đi nếu không có -Wformat

en: -Wformat-zero-length ignored without -Wformat
vi: -Wformat-zero-length bị lờ đi nếu không có -Wformat

en: -Wnormalized=<id|nfc|nfkc>	Warn about non-normalised Unicode strings
vi: -Wnormalized=<id|nfc|nfkc>	Cảnh báo về chuỗi Unicode không phải chuẩn hoá

en: -Xbind-now and -Xbind-lazy are incompatible
vi: hai tùy chọn -Xbind-now và -Xbind-lazy không tương thích với nhau

en: -bundle not allowed with -dynamiclib
vi: không cho phép sử dụng -bundle với -dynamiclib

en: -bundle_loader not allowed with -dynamiclib
vi: không cho phép sử dụng -bundle_loader với -dynamiclib

en: -c or -S required for Ada
vi: sử dụng Ada thì cũng yêu cầu -c hoặc -S

en: -client_name not allowed with -dynamiclib
vi: không cho phép sử dụng -client_name với -dynamiclib

en: -current_version only allowed with -dynamiclib
vi: chỉ cho phép sử dụng -current_version với -dynamiclib

en: -f%s and -msdata=%s are incompatible
vi: -f%s và -msdata=%s là không tương thích

en: -fPIC and -mcall-%s are incompatible
vi: -fPIC và -mcall-%s là không tương thích

en: -fPIC is not supported
vi: -fPIC không được hỗ trợ

en: -falign-labels=%d is not supported
vi: -falign-labels=%d không được hỗ trợ

en: -fblas-matmul-limit=<n>	Size of the smallest matrix for which matmul will use BLAS
vi: -fblas-matmul-limit=<số>	Kích cỡ của ma trận nhỏ nhất cho đó matmul sẽ sử dụng BLAS

en: -fcheck=[...]	Specify which runtime checks are to be performed
vi: -fcheck=[...]	Ghi rõ có nên thực hiện những hàm kiểm tra lúc chạy nào

en: -femit-class-file should used along with -fsyntax-only
vi: có nên kết hợp tuỳ chọn --femit-class-filevới -fsyntax-only

en: -ffixed-line-length-<n>	Use n as character line width in fixed mode
vi: -ffixed-line-length-<số>	Trong chế độ cố định thì chiều rộng dòng ký tự là số này

en: -ffpe-trap=[...]	Stop on following floating point exceptions
vi: -ffpe-trap=[...]	Đừng lại theo ngoại lệ điểm phù động

en: -ffree-line-length-<n>	Use n as character line width in free mode
vi: -ffree-line-length-<số>	Trong chế độ tự do thì chiều rộng dòng ký tự là số này

en: -finit-character=<n>	Initialize local character variables to ASCII value n
vi: -finit-character=<số>	Sơ khởi các biến ký tự cục bộ thành giá trị ASCII này

en: -finit-integer=<n>	Initialize local integer variables to n
vi: -finit-integer=<số>	Sơ khởi các biến số nguyên cục bộ thành giá trị này

en: -finit-logical=<true|false>	Initialize local logical variables
vi: -finit-logical=<true|false>	Sơ khởi các biến hợp lý cục bộ (true=đúng, false=sai)

en: -finit-real=<zero|nan|inf|-inf>	Initialize local real variables
vi: -finit-real=<zero|nan|inf|-inf>	Sơ khởi các biến thật cục bộ
    	zero		số không
    	nan		không phải là một con số
    	inf		vô hạn
    	-inf		không vô hạn

en: -fjni and -femit-class-file are incompatible
vi: hai tùy chọn --fjni và --femit-class-file không tương thích với nhau

en: -fjni and -femit-class-files are incompatible
vi: hai tùy chọn --fjni và --femit-class-files không tương thích với nhau

en: -fmax-array-constructor=<n>	Maximum number of objects in an array constructor
vi: -fmax-array-constructor=<số>	Số tối đa các đối tượng trong một bộ cấu tạo mảng

en: -fmax-identifier-length=<n>	Maximum identifier length
vi: -fmax-identifier-length=<số>	Chiều dài tối đa của bộ nhận diện

en: -fmax-stack-var-size=<n>	Size in bytes of the largest array that will be put on the stack
vi: -fmax-stack-var-size=<số>	Kích cỡ theo byte của mảng lớn nhất sẽ được để vào đống

en: -fmax-subrecord-length=<n>	Maximum length for subrecords
vi: -fmax-subrecord-length=<số>	Chiều dài tối đa của mục ghi phụ

en: -force_flat_namespace not allowed with -dynamiclib
vi: không cho phép sử dụng -force_flat_namespace với -dynamiclib

en: -fpic is not supported
vi: -fpic không được hỗ trợ

en: -fuse-linker-plugin is not supported in this configuration
vi: -fuse-linker-plugin không được hỗ trợ trong cấu hình này

en: -fuse-linker-plugin, but %s not found
vi: -fuse-linker-plugin, mà không tìm thấy %s

en: -fwpa and -fltrans are mutually exclusive
vi: -fwpa và -fltrans loại trừ lẫn nhau

en: -g option disabled
vi: tùy chọn -g bị tắt

en: -gnat<options>	Specify options to GNAT
vi: -gnat<tuỳ_chọn>	Ghi rõ các tuỳ chọn tới GNAT

en: -iframework <dir>	Add <dir> to the end of the system framework include path
vi: -iframework <thư_mục>	Phụ thêm thư mục này vào đường dẫn bao gồm khuôn khổ hệ thống

en: -install_name only allowed with -dynamiclib
vi: chỉ cho phép sử dụng -install_name với -dynamiclib

en: -keep_private_externs not allowed with -dynamiclib
vi: không cho phép sử dụng -keep_private_externs với -dynamiclib

en: -mabi=ABI	Generate code that conforms to the given ABI
vi: -mabi=ABI	Tạo ra làm hợp với ABI đưa ra

en: -march=ARCH	Generate code for the specified chip or CPU version
vi: -march=KIẾN_TRÚC	Tạo ra mã cho phiến tinh thể hoặc CPU đưa ra

en: -march=ISA	Generate code for the given ISA
vi: -march=ISA	Tạo ra mã cho ISA đưa ra

en: -mas100-syntax is incompatible with -gdwarf
vi: -mas100-syntax không tương thích với -gdwarf

en: -mbig-endian and -mlittle-endian may not be used together
vi: không cho phép sử dụng đồng thời hai tuỳ chọn -mbig-endian (về cuối lớn) và -mlittle-endian (về cuối nhỏ)

en: -mbranch-cost=COST	Set the cost of branches to roughly COST instructions
vi: -mbranch-cost=GIÁ	Lập giá của nhánh thành khoảng số các câu lệnh này

en: -mcode-readable=SETTING	Specify when instructions are allowed to access code
vi: -mcode-readable=THIẾT_LẬP	Ghi rõ khi nào câu lệnh có quyền truy cập đến mã

en: -mcpu=	Use features of and schedule code for given CPU
vi: -mcpu=	Sử dụng các tính năng của CPU đưa ra, và định thời mã cho CPU đó

en: -mcpu=%s conflicts with -march=%s
vi: -mcpu=%s xung đột với -march=%s

en: -mcpu=%s is not valid
vi: -mcpu=%s không hợp lệ

en: -mcpu=PROCESSOR		Use features of and schedule code for given CPU
vi: -mcpu=PROCESSOR	Sử dụng các tính năng của định thời mã cho CPU đã cho

en: -mcpu=m16c	Compile code for M16C variants
vi: -mcpu=m16c	Biên dịch mã cho biến thế M16C

en: -mcpu=m32c	Compile code for M32C variants
vi: -mcpu=m32c	Biên dịch mã cho biến thế M32C

en: -mcpu=m32cm	Compile code for M32CM variants
vi: -mcpu=m32cm	Biên dịch mã cho biến thế M32CM

en: -mcpu=r8c	Compile code for R8C variants
vi: -mcpu=r8c	Biên dịch mã cho biến thế R8C

en: -mdebug=	Enable debug output
vi: -mdebug=	Bật kết xuất gỡ rối

en: -memregs=	Number of memreg bytes (default: 16, range: 0..16)
vi: -memregs=	Số các byte memreg (mặc định: 16, phạm vi: 0..16)

en: -mfloat-abi=hard and VFP
vi: -mfloat-abi=hard và VFP

en: -mfloat-gprs=	Select GPR floating point method
vi: -mfloat-gprs=	Chọn phương pháp điểm phù động GPR

en: -mflush-func=FUNC	Use FUNC to flush the cache before calling stack trampolines
vi: -mflush-func=HÀM	Sử dụng hàm này để chuyển hết vùng nhớ tạm ra ngoài trước khi gọi trampoline đống

en: -mfpu=	Specify FP (sp, dp, sp-lite, dp-lite) (implies -mxilinx-fpu)
vi: -mfpu=	Ghi rõ điểm phù động (sp, dp, sp-lite, dp-lite) (cũng ngụ ý -mxilinx-fpu)

en: -mhard-float not supported
vi: không hỗ trợ -mhard-float

en: -mipsN	Generate code for ISA level N
vi: -mipsSỐ	Tạo ra mã cho cấp ISA SỐ

en: -mlong-double-<n>	Specify size of long double (64 or 128 bits)
vi: -mlong-double-<số>	Ghi rõ kích cỡ của đôi dài (64 hay 128 bit)

en: -mmax-stackframe=SIZE	Warn when a stackframe is larger than the specified size
vi: -mmax-stackframe=KÍCH_CỠ	Cảnh báo khung đống nào vượt quá kích cỡ này

en: -mmcu=MCU	Select the target MCU
vi: -mmcu=MCU	Chọn MCU đích

en: -mno-altivec disables vsx
vi: -mno-altivec thì tắt vsx

en: -mno-serialize-volatile	Do not serialize volatile memory references with MEMW instructions
vi: -mno-serialize-volatile	Đối với câu lệnh MEMW thì đừng cũng xếp theo thứ tự các tham chiếu đến vùng nhớ hay thay đổi

en: -mr10k-cache-barrier=SETTING	Specify when r10k cache barriers should be inserted
vi: -mr10k-cache-barrier=THIẾT_LẬP	Ghi rõ khi nào nên chèn rào cản vùng nhớ tạm r10k

en: -mrecip requires -ffinite-math or -ffast-math
vi: -mrecip cần -ffinite-math hoặc -ffast-math

en: -mrecip requires -fno-trapping-math or -ffast-math
vi: -mrecip cần -fno-trapping-math hoặc -ffast-math

en: -mrecip requires -freciprocal-math or -ffast-math
vi: -mrecip yêu cầu -freciprocal-math hoặc -ffast-math

en: -mrelocatable and -mcall-%s are incompatible
vi: -mrelocatable và -mcall-%s là không tương thích

en: -mrelocatable and -mno-minimal-toc are incompatible
vi: -mrelocatable và -mno-minimal-toc là không tương thích

en: -mrelocatable and -msdata=%s are incompatible
vi: -mrelocatable và -msdata=%s là không tương thích

en: -msdata=%s and -mcall-%s are incompatible
vi: -msdata=%s và -mcall-%s là không tương thích

en: -msim	Use simulator runtime
vi: -msim	Sử dụng khoảng thời gian chạy của bộ mô phỏng

en: -msingle-float and -msoft-float cannot both be specified
vi: không cho phép sử dụng đồng thời hai tuỳ chọn -msingle-float và -msoft-float

en: -mtraceback=	Select full, part, or no traceback table
vi: -mtraceback=	Chọn bảng vét lùi đầy đủ (full), bộ phận (part) hoặc không có (none)

en: -mtune=	Schedule code for given CPU
vi: -mtune=	Định thời mã cho CPU đưa ra

en: -mtune=ARCH	Tune alignment for the specified chip or CPU version
vi: -mtune=KIẾN_TRÚC	Điều chỉnh sự xếp hàng cho phiến tinh thể hoặc CPU đưa ra

en: -mtune=PROCESSOR	Optimize the output for PROCESSOR
vi: -mtune=BỘ_XỬ_LÝ	Tối ưu hoá kết xuất cho bộ xử lý này

en: -mvsx and -mno-altivec are incompatible
vi: -mvsx và -mno-altivec không tương thích với nhau

en: -mvsx and -mpaired are incompatible
vi: -mvsx và -mpaired không tương thích với nhau

en: -mvsx needs indexed addressing
vi: -mvsx yêu cầu đặt địa chỉ một cách phụ lục

en: -mvsx requires hardware floating point
vi: -mvsx yêu cầu điểm phù động loại phần cứng

en: -mvsx used with little endian code
vi: -mvsx bị sử dụng với mã về cuối nhỏ

en: -o <file>	Place output into <file>
vi: -o <tập tin>	Đặt kết xuất vào <tập tin>

en: -pg and -fomit-frame-pointer are incompatible
vi: hai tùy chọn --pg và --fomit-frame-pointer không tương thích với nhau

en: -pipe not supported
vi: không hỗ trợ -pipe

en: -private_bundle not allowed with -dynamiclib
vi: không cho phép sử dụng -private_bundle với -dynamiclib

en: 31 bit ABI
vi: ABI 31-bit

en: 64 bit ABI
vi: ABI 64-bit

en: <anonymous %s>
vi: <%s nặc danh>

en: <anonymous>
vi: <nặc-danh>

en: <brace-enclosed initializer list>
vi: <danh sách bộ sơ khởi nằm trong dấu ngoặc>

en: <built-in>
vi: <có sẵn>

en: <command-line>
vi: <dòng lệnh>

en: <declaration error>
vi: <lỗi tuyên bố>

en: <enumerator>
vi: <bộ đếm>

en: <erroneous-expression>
vi: <biểu tượng bị lỗi>

en: <expression error>
vi: <lỗi biểu thức>

en: <missing>
vi: <còn thiếu>

en: <return value>
vi: <giá trị trả lại>

en: <return-value>
vi: <giá trị trả lại>

en: <statement>
vi: <lời tuyên bố>

en: <tag-error>
vi: <lỗi thẻ>

en: <template parameter error>
vi: <lỗi tham số mẫu>

en: <throw-expression>
vi: <biểu thức ném>

en: <type error>
vi: <lỗi loại>

en: <type-error>
vi: <loại sai>

en: <typedef-error>
vi: <lỗi xác định loại>

en: <typeprefixerror>
vi: <lỗi sửa sẵn loại>

en: <unknown operator>
vi: <không rõ toán hạng>

en: <unknown>
vi: <không rõ>

en: <unnamed-fixed:
vi: <không tên cố định:

en: <unnamed-float:
vi: <không tên nổi:

en: <unnamed-signed:
vi: <không tên có ký:

en: <unnamed-unsigned:
vi: <không tên không ký:

en: <unnamed>
vi: <không tên>

en: <unparsed>
vi: <chưa phân tích cú pháp>

en: <unresolved overloaded function type>
vi: <chưa giải quyết loại hàm quá tải>

en: A factor for tuning the upper bound that swing modulo scheduler uses for scheduling a loop
vi: Một hệ số để điều hưởng giới hạn trên được bộ định thời mô-đu-lô swing sử dụng để định thời một vòng lặp

en: A synonym for -std=c89 (for C) or -std=c++98 (for C++)
vi: Đồng nghĩa -std=c89 (cho C) hoặc -std=c++98 (cho C++)

en: A threshold on the average loop count considered by the swing modulo scheduler
vi: Một ngưỡng trên số trung bình đếm vòng lặp được bộ định thời mô-đu-lô swing tính

en: ACQUIRED_LOCK variable
vi: biến ACQUIRED_LOCK

en: ALLOCATE object
vi: đối tượng ALLOCATE

en: Accept extensions to support legacy code
vi: Chấp nhận phần mở rộng để hỗ trợ mã nguồn thừa tự

en: Access variables in 32-bit PPU objects (default)
vi: Truy cập đến biến trong đối tượng PPU 32-bit (mặc định)

en: Access variables in 64-bit PPU objects
vi: Truy cập đến biến trong đối tượng PPU 64-bit

en: Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)
vi: Chiều dài chuỗi thật không tương ứng với điều tuyên bố cho đối số giả '%s' (%ld/%ld)

en: Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)
vi: Chiều dài chuỗi thật vẫn nhỏ hơn điều tuyên bố cho đối số giả '%s' (%ld/%ld)

en: Additional debug prints
vi: Lần bổ sung in ra thông tin gỡ rối

en: Alias for -femit-class-file
vi: Bí danh cho -femit-class-file

en: Align all labels
vi: Cân chỉnh tất cả các nhãn

en: Align all loops to 32 byte boundary
vi: Xếp hàng tất cả các vòng lặp theo biên giới 32-byte

en: Align code and data to 32 bits
vi: Xếp hàng mã và dữ liệu theo 32-bit

en: Align destination of the string operations
vi: Đích xếp hàng của các thao tác chuỗi

en: Align doubles at 64-bit boundaries
vi: Xếp hàng các đôi theo biên giới 64-bit

en: Align some doubles on dword boundary
vi: Xếp hàng một số đôi theo biên giới dword

en: Align to the base type of the bit-field
vi: Xếp hàng theo loại cơ bản của trường bit

en: Align variables on a 32-bit boundary
vi: Xếp hàng tất cả các biến theo một biên giới 32-byte

en: All functions default to the far section
vi: Tất cả các hàm thì có phần mặc định là far (xa)

en: All intrinsics procedures are available regardless of selected standard
vi: Tất cả các thủ tục về điều thực chất vẫn sẵn sàng bất chấp tiêu chuẩn được chọn

en: All variables default to the far section
vi: Tất cả các giá trị có thể lập được thì có phần mặc định là far (xa)

en: All variables default to the near section
vi: Tất cả các giá trị có thể lập được thì có phần mặc định là near (gần)

en: All variables default to the tiny section
vi: Tất cả các giá trị có thể lập được thì có phần mặc định là tiny (rất nhỏ)

en: Allocate local variables on the stack to allow indirect recursion
vi: Cấp phát các biến cúc bộ trên đống để cho phép đệ quy một cách gián tiếp

en: Allow a symbol value to be used as an immediate value in an instruction.
vi: Cho phép sử dụng một giá trị ký hiệu dưới dạng một giá trị lập tức trong một câu lệnh.

en: Allow arbitrary character line width in fixed mode
vi: Trong chế độ cố định thì cũng cho phép chiều rộng dòng ký tự tùy ý

en: Allow arbitrary character line width in free mode
vi: Trong chế độ tự do thì cũng cho phép chiều rộng dòng ký tự tùy ý

en: Allow bit-fields to cross word boundaries
vi: Cho phép trường bit đi qua biên giới từ

en: Allow branches to be packed with other instructions
vi: Cho phép đóng gói nhánh với câu lệnh khác

en: Allow conversions between __ea and generic pointers (default)
vi: Cho phép chuyển đổi giữa hàm trỏ loại __ea và chung (mặc định)

en: Allow dollar signs in entity names
vi: Cho phép tên thực thể chứa dấu đồng đô la "$"

en: Allow gcc to use the repeat/erepeat instructions
vi: Cho phép gcc sử dụng câu lệnh repeat/erepeat

en: Allow hardware floating-point instructions to cover both 32-bit and 64-bit operations
vi: Cho phép xử lý dấu chấm động phần cứng bao quát thao tác cả hai hệ điều hành 32-bit và 64-bit

en: Allow the use of MDMX instructions
vi: Cho phép sử dụng câu lệnh MDMX

en: Allow the use of MT instructions
vi: Cho phép sử dụng câu lệnh MT

en: Allow the use of hardware floating-point ABI and instructions
vi: Cho phép sử dụng ABI và các câu lệnh kiểu dấu chấm động phần cứng

en: Allow two instructions to be issued per cycle
vi: Cho phép đưa ra hai câu lệnh từng chu kỳ

en: Alternate calling convention
vi: Quy ước gọi xen kẽ

en: AltiVec argument passed to unprototyped function
vi: đối số AltiVec bị gửi cho hàm không nguyên mẫu

en: Always check for non gcj generated classes archives
vi: Lúc nào cũng kiểm tra có kho lưu hạng không phải được gcj tạo ra

en: Always generate long calls
vi: Lúc nào cũng tạo ra cuộc gọi dài

en: Always treat bitfields as int-sized
vi: Lúc nào cũng thấy trường bit có kích cỡ số nguyên

en: Always use Dynamic Realigned Argument Pointer (DRAP) to realign stack
vi: Lúc nào cũng sử dụng DRAP (hàm trỏ đối số đã xếp hàng năng động) để xếp hàng lại đống

en: Annotate assembler instructions with estimated addresses
vi: Phụ chú câu lệnh dịch mã số bằng địa chỉ ước lượng

en: Append a second underscore if the name already contains an underscore
vi: Tên đã chứa một dấu gạch dưới thì phụ thêm một dấu gạch dưới bổ sung

en: Append underscores to externally visible names
vi: Có tên hiển thị bên ngoài thì phụ thêm dấu gạch dưới

en: Apply negative sign to zero values
vi: Có giá trị số không thì áp dụng ký hiệu trừ

en: Approximate maximum number of instructions to allow between a hint and its branch [125]
vi: Số tối đa (xấp xỉ) các câu lệnh cần cho phép giữa một lời gợi ý và nhánh tương ứng [125]

en: Argument NCOPIES of REPEAT intrinsic is too large
vi: Điều thực chất REPEAT (lặp lại) có đối số NCOPIES (số các bản sao) quá lớn

en: Arithmetic NaN at %L
vi: Số học NaN (không phải là một con số) tại %L

en: Arithmetic OK at %L
vi: Số học đúng tại %L

en: Arithmetic overflow at %L
vi: Số học bị tràn tại %L

en: Arithmetic underflow at %L
vi: Số học bị tràn ngược tại %L

en: Array operands are incommensurate at %L
vi: Các toán hạng mảng không tương xứng với nhau tại %L

en: Array reference out of bounds
vi: Tham chiếu mảng ở ngoại phạm vi

en: Assembler options
    =================
vi: Tuỳ chọn dịch ASM
    =================

en: Assigned label is not a target label
vi: Nhãn đã gán không phải là một nhãn đích

en: Assume ICPLBs are enabled at runtime.
vi: Giả sử là các ICPLB được hiệu lực vào lúc chạy.

en: Assume a large TLS segment
vi: Giả sử một đoạn TLS lớn

en: Assume all symbols have 32-bit values
vi: Giả sử là mọi ký hiệu đều có giá trị 32-bit

en: Assume all variable arg functions are prototyped
vi: Gia sử là mọi biến đối số biến đổi đều được nguyên mẫu

en: Assume code will be assembled by GAS
vi: Giả sử là mã sẽ được GAS dịch

en: Assume code will be linked by GNU ld
vi: Giả sử là mã sẽ được liên kết bởi ld của GNU

en: Assume code will be linked by HP ld
vi: Giả sử là mã sẽ được liên kết bởi ld của HP

en: Assume incoming stack aligned to this power of 2
vi: Giả sử đống gửi đến được xếp hàng theo lũy thừa 2 này

en: Assume native functions are implemented using JNI
vi: Giả sử là các hàm sở hữu được thực hiện dùng JNI

en: Assume possible double misalignment
vi: Giả sử có thể bị sai đôi xếp hàng

en: Assume pt* instructions won't trap
vi: Giả sử là câu oệnh pt* sẽ không bẫy

en: Assume small address space
vi: Giả sử là có một vùng địa chỉ nhỏ

en: Assume symbols might be invalid
vi: Giả sử là ký hiệu có thể không hợp lệ

en: Assume target CPU is configured as big endian
vi: Giả sử là CPU đích được cấu hình về cuối lớn

en: Assume target CPU is configured as little endian
vi: Giả sử là CPU đích được cấu hình về cuối nhỏ

en: Assume that floating-point stores and loads are not likely to cause conflict when placed into one instruction group
vi: Giả sử rằng các việc nạp/lưu dấu chấm động không phải rất có thể gây ra sự xung đột khi được để vào cùng một nhóm câu lệnh

en: Assume that run-time support has been provided, so omit -lsim from the linker command line
vi: Giả sử đã cung cấp hỗ trợ vào lúc chạy, vì thế bỏ sót -lsim khỏi dòng lệnh liên kết

en: Assume that the source file is fixed form
vi: Giả sử là tập tin nguồn có dạng cố định

en: Assume that the source file is free form
vi: Giả sử là tập tin nguồn có dạng tự do

en: Assume the VxWorks RTP environment
vi: Giả sử có môi trường RTP VxWorks

en: Assume the VxWorks vThreads environment
vi: Giả sử có môi trường vThreads VxWorks

en: Assume the runtime uses a hash table to map an object to its synchronization structure
vi: Giả sử là lúc chạy thì sử dụng một bảng chuỗi duy nhất để ánh xạ một đối tượng tới cấu trúc đồng bộ của nó

en: At global scope:
vi: Theo phạm vi toàn cục:

en: At top level:
vi: Ở cấp đầu:

en: Atomically write back software data cache lines (default)
vi: Tự động ghi trả lại các đường dẫn vùng nhớ tạm dữ liệu loại phần mềm (mặc định)

en: Attempt to DEALLOCATE unallocated '%s'
vi: Đang thử BỎ cấp phát một mảng đã bỏ cấp phát '%s'

en: Attempt to keep stack aligned to this power of 2
vi: Thử bảo tồn đống được xếp hàng theo lũy thừa 2 này

en: Automatically align branch targets to reduce branch penalties
vi: Tự động xếp hàng các đích nhánh để giảm giá nhánh thừa

en: Avoid all range limits on call instructions
vi: Tránh giới hạn phạm vi nào trong câu lệnh gọi

en: Avoid generating pc-relative calls; use indirection
vi: Tránh sự tạo ra cuộc gọi tương đối với PC; sử dụng hành động gián tiếp

en: Avoid generation of indexed load/store instructions when possible
vi: Tránh sự tạo ra câu lệnh nạp/lưu phụ lục khi có thể

en: Avoid overlapping destination and address registers on LDRD instructions
vi: Tránh các thanh ghi đích và địa chỉ chồng chéo lên nhau đối với câu lệnh LDRD

en: Avoid speculative loads to work around a hardware anomaly.
vi: Tránh sự nạp suy đoán để khắc phục một sự dị thường loại phần cứng.

en: Bad address, not (reg+disp):
vi: Địa chỉ sai, không phải (reg+disp):

en: Bad address, not register:
vi: Địa chỉ sai, không phải thanh ghi:

en: Bad byte codes.
vi: Mã byte sai.

en: Bad name
vi: Tên sai

en: Bad operator
vi: Toán tử sai

en: Bad type in constant expression
vi: Gặp loại saio trong biểu thức bất biến

en: Board name [and memory region].
vi: Tên bộ mạch [và vùng nhớ].

en: Bound on number of candidates below that all candidates are considered in iv optimizations
vi: Đóng kết với số các điều ứng cử dưới đó tất cả các điều ứng cử được tính trong sự tối ưu hoá iv

en: Bound on number of iv uses in loop optimized in iv optimizations
vi: Đóng kết với số các lần sử dụng iv trong vòng lặp được tối ưu hoá bằng sự tối ưu hoá iv

en: Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check
vi: Đóng kết với số các sự kiểm tra lúc chạy được chèn bởi việc kiểm tra phiên bản vòng lặp cho bí danh của bộ véc-tơ hoá

en: Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check
vi: Đóng kết với số các sự kiểm tra lúc chạy được chèn bởi việc kiểm tra phiên bản vòng lặp để xếp hàng của bộ véc-tơ hoá

en: Bound on size of expressions used in the scalar evolutions analyzer
vi: Đóng kết với kích cỡ biểu tượng được sử dụng trong bộ phân tích sự khai căn vô hướng

en: Bound on the cost of an expression to compute the number of iterations
vi: Đóng kết với giá của một biểu tượng để tính số các lần lặp lại

en: Bound on the number of equalities in Omega constraint systems
vi: Đóng kết với số các đẳng thức trong hệ thống ràng buộc Omega

en: Bound on the number of inequalities in Omega constraint systems
vi: Đóng kết với số các bất đẳng thức trong hệ thống ràng buộc Omega

en: Bound on the number of iterations the brute force # of iterations analysis algorithm evaluates
vi: Đóng kết với số các lần lặp lại được ước lượng bởi thuật toán phân tích số sức mạnh vũ phu các lần lặp lại

en: Bound on the number of keys in Omega constraint systems
vi: Đóng kết với số các khoá trong hệ thống ràng buộc Omega

en: Bound on the number of variables in Omega constraint systems
vi: Đóng kết với số các biến trong hệ thống ràng buộc Omega

en: Bound on the number of wild cards in Omega constraint systems
vi: Đóng kết với số các yếu tố đại diện trong hệ thống ràng buộc Omega

en: Bound on the size of the hash table in Omega constraint systems
vi: Đóng kết với kích cỡ của bảng chuỗi duy nhất trong hệ thống ràng buộc Omega

en: Branches are this expensive (1-5, arbitrary units)
vi: Nhánh có giá này (1-5, đơn vị tùy ý)

en: Branches executed:%s of %d
vi: Nhánh được thực hiện: %s trên %d

en: Build for Core A
vi: Xây dựng cho Lõi A

en: Build for Core B
vi: Xây dựng cho Lõi B

en: Build for SDRAM
vi: Xây dựng cho SDRAM

en: COLLECT_LTO_WRAPPER must be set
vi: COLLECT_LTO_WRAPPER phải được đặt

en: COMPLEX quantities cannot be compared at %L
vi: Không thể so sánh các số lượng PHỨC TẠP tại %L

en: Call a library routine to do integer divisions
vi: Gọi một hàm thư viện để chia số nguyên

en: Call mcount for profiling before a function prologue
vi: Gọi mcount để đo hiệu năng sử dụng đẳng trước một đoạn mở đầu hàm

en: Calls executed:%s of %d
vi: Cuộc gọi được thực hiện: %s trên %d

en: Cannot map %s
vi: Không thể map %s

en: Cannot open %s
vi: Không thể mở %s

en: Cannot open '%s' for output.
vi: Không thể mở '%s' cho kết xuất.

en: Cannot open source file %s
vi: Không thể mở tập tin nguồn %s

en: Cannot read %s
vi: Không thể đọc %s

en: Catch typos
vi: Bắt gặp lỗi đánh máy

en: Cause gas to print tomcat statistics
vi: Gây ra chương trình gas in ra thống kê về tomcat

en: Change only the low 8 bits of the stack pointer
vi: Thay đổi chỉ 8 bit thấp của hàm trỏ đống

en: Change the ABI to allow double word insns
vi: Sửa đổi ABI để cho phép câu lệnh từ đôi

en: Change the amount of scheduler lookahead
vi: Sửa đổi khoảng thời gian nhìn trước của công cụ định thời

en: Change the maximum length of conditionally-executed sequences
vi: Thay đổi chiều dài tối đa của dãy được thực hiện có điều kiện

en: Change the number of temporary registers that are available to conditionally-executed sequences
vi: Thay đổi số các thanh ghi tạm thời còn sẵn sàng cho dãy được thực hiện có điều kiện

en: Change the stack pointer without disabling interrupts
vi: Thay đổi hàm trỏ đống mà không tắt tín hiệu gián đoạn

en: Chose strategy to generate stringop using
vi: Chọn chiến lược để tạo ra thao tác chuỗi dùng

en: Code size: small, medium or large
vi: Kích cỡ mã:
     • small			nhỏ
     • medium		vừa
     • large			lớn.

en: Comma required after P descriptor
vi: Đẳng sau bộ mô tả P thì yêu cầu một dấu phẩy

en: Compile all program units at once and check all interfaces
vi: Biên dịch đồng thời tất cả các đơn vị chương trình, và kiểm tra tất cả các giao diện

en: Compile code that relies on Cygwin DLL wrappers to support C++ operator new/delete replacement
vi: Biên dịch mã nhờ trình bao bọc DLL Cygwin để hỗ trợ chức năng thay thế toán tử C++ mới/xoá

en: Compile for 32-bit pointers
vi: Biên dịch cho hàm trỏ loại 32-bit

en: Compile for 64-bit pointers
vi: Biên dịch cho hàm trỏ loại 64-bit

en: Compile for ETRAX 100 (CRIS v8)
vi: Biên dịch cho ETRAX 100 (CRIS v8)

en: Compile for ETRAX 4 (CRIS v3)
vi: Biên dịch cho ETRAX 4 (CRIS v3)

en: Compile for V8+ ABI
vi: Biên dịch cho ABI loại V8+

en: Compile for the m32r
vi: Biên dịch cho m32r

en: Compile for the m32r2
vi: Biên dịch cho m32r2

en: Compile for the m32rx
vi: Biên dịch cho m32x

en: Compile for the v850 processor
vi: Biên dịch cho bộ xử lý v850

en: Compile for the v850e processor
vi: Biên dịch cho bộ xử lý v850e

en: Compile for the v850e1 processor
vi: Biên dịch cho bộ xử lý v850e1

en: Compile for the v850e2 processor
vi: Biên dịch cho bộ xử lý v850e2

en: Compile for the v850e2v3 processor
vi: Biên dịch cho bộ xử lý v850e3v3

en: Compile for the v850es variant of the v850e1
vi: Biên dịch cho bộ xử lý v850e và biến thể của v852el

en: Configuration name
vi: Tên cấu hình

en: Configured with: %s
vi: Cấu hình bằng %s

en: Conform more closely to IBM XLC semantics
vi: Làm cho hợp hơn với cú pháp XLC của IBM

en: Conform to nothing in particular
vi: Làm cho hợp với không gì đặc biệt

en: Conform to the ISO Fortran 2003 standard
vi: Làm cho hợp với tiêu chuẩn ISO Fortran 2003

en: Conform to the ISO Fortran 2008 standard
vi: Làm cho hợp với tiêu chuẩn ISO Fortran 2008

en: Conform to the ISO Fortran 95 standard
vi: Làm cho hợp với tiêu chuẩn ISO Fortran 95

en: Consider access to byte sized memory slow
vi: Tính là truy cập chậm đến vùng nhớ tạm theo byte

en: Consider type 'int' to be 16 bits wide
vi: Thấy 'type' (loại) 'int' (số nguyên) có chiều rộng 16 bit

en: Consider type 'int' to be 32 bits wide
vi: Thấy 'type' (loại) 'int' (số nguyên) có chiều rộng 32 bit

en: Const variables default to the near section
vi: Giá trị bất biến có thể lập được thì có phần mặc định là near (gần)

en: Constant expression required at %C
vi: Tại %C thì yêu cầu biểu thức bất biến

en: Control the IEEE trap mode
vi: Điều khiển chế độ đặt bẫy IEEE

en: Control the generated fp rounding mode
vi: Điều khiển chế độ làm tròn loại điểm phù động đã tạo ra

en: Control the precision given to fp exceptions
vi: Điều khiển độ chính xác đưa ra cho ngoại lệ về điểm phù động

en: Copy array sections into a contiguous block on procedure entry
vi: Vào thủ tục thì cũng sao chép các phần mảng vào một khối kề nhau

en: Cost to assume for a branch insn
vi: Giá cần giả sử đối với một câu lệnh nhánh

en: Cost to assume for a multiply insn
vi: Giá cần giả sử cho một câu lệnh nhân lên

en: Cost to assume for gettr insn
vi: Giá cần giả sử đối với câu lệnh gettr

en: Could not open output file '%s'
vi: Không thể mở tập tin kết xuất '%s'

en: Count speculative dependencies while calculating priority of instructions
vi: Đếm các quan hệ phụ thuộc loại đầu cơ trong khi tính mức ưu tiên của câu lệnh

en: Create GUI application
vi: Tạo ứng dụng GUI

en: Create console application
vi: Tạo ứng dụng bàn giao tiép

en: Creating '%s'
vi: Đang tạo '%s'

en: DEALLOCATE object
vi: đối tượng DEALLOCATE

en: DO step value is zero
vi: Giá trị bước DO (làm) là số không

en: Data greater than given threshold will go into .ldata section in x86-64 medium model
vi: Dữ liệu vượt quá ngưỡng này thì để vào phần .ldata trong mẫu môi giới x86-64

en: Data is stored in big-endian format.
vi: Dữ liệu được lưu theo định dạng về cuối lớn.

en: Data is stored in little-endian format.  (Default).
vi: Dữ liệu được lưu theo định dạng về cuối nhỏ. (Mặc định).

en: Deprecated option.  Use -misel instead
vi: Tùy chọn bị phản đối.  Dùng -misel để thay thế

en: Deprecated option.  Use -mno-isel instead
vi: Tùy chọn bị phản đối.  Dùng -mno để thay thế

en: Deprecated option.  Use -mno-spe instead
vi: Tùy chọn bị phản đối.  Dùng -mno-spe để thay thế

en: Deprecated option.  Use -mno-vrsave instead
vi: Tùy chọn bị phản đối.  Dùng -mno-vrsave để thay thế

en: Deprecated option.  Use -mspe instead
vi: Tùy chọn bị phản đối.  Dùng -mspe để thay thế

en: Deprecated option.  Use -mvrsave instead
vi: Tùy chọn bị phản đối.  Dùng -mvrsave để thay thế

en: Deprecated.  Use -Os instead
vi: Bị phân đối nên hãy sử dụng đối số -Os để thay thế

en: Description for mxl-mode-bootstrap
vi: Mô tả cho mxl-mode-bootstrap

en: Description for mxl-mode-executable
vi: Mô tả cho mxl-mode-executable

en: Description for mxl-mode-novectors
vi: Mô tả cho mxl-mode-novectors

en: Description for mxl-mode-xmdstub
vi: Mô tả cho mxl-mode-xmdstub

en: Determine which dependences between insns are considered costly
vi: Quyết định những quan hệ phụ thuộc nào giữa các câu lệnh thì được thấy có giá cao

en: Different CHARACTER lengths (%ld/%ld) in array constructor
vi: Bộ dựng mảng chứa các chiều dài KÝ_TỰ khác nhau (%ld/%ld)

en: Disable FP regs
vi: Tắt các thanh ghi loại điểm phù động

en: Disable all optional instructions
vi: Tắt tất cả các câu lệnh vẫn tuỳ chọn

en: Disable bcnz instruction
vi: Tắt câu lệnh bcnz

en: Disable hardware floating point
vi: Tắt điểm phù động loại phần cứng

en: Disable indexed addressing
vi: Tắt chức năng đặt địa chỉ loại phụ lục

en: Disable preprocessing
vi: Tắt khả năng tiền xử lý

en: Disable space regs
vi: Tắt thanh ghi loại sức chứa

en: Disable the use of RX FPU instructions.
vi: Tắt khả năng sử dụng câu lệnh điểm phù động RX.

en: Disallow direct calls to global functions
vi: Không cho phép gọi trực tiếp cho hàm toàn cục

en: Display compile time statistics
vi: Hiển thị thống kê về khoảng thời gian biên dịch

en: Display contents of a class file in readable form.
vi: Hiển thị nội dung của một tập tin hạng theo một định dạng cho người đọc được.

en: Display the code tree after parsing
vi: Một khi phân tích cú pháp thì hiển thị cây mã nguồn

en: Division by zero at %L
vi: Chia cho không tại %L

en: Division strategy, one of: call, call2, fp, inv, inv:minlat, inv20u, inv20l, inv:call, inv:call2, inv:fp, call-div1, call-fp, call-table
vi: Chiến lược chia là một của: call, call2, fp, inv, inv:minlat, inv20u, inv20l, inv:call, inv:call2, inv:fp, call-div1, call-fp, call-table

en: Do not assume a large TLS segment
vi: Đừng giả sử một đoạn TLS lớn

en: Do not disable space regs
vi: Đừng tắt thanh ghi loại sức chứa

en: Do not discard comments
vi: Đừng loại bỏ ghi chú

en: Do not discard comments in macro expansions
vi: Đừng loại bỏ ghi chú trong sự mở rộng vĩ lệnh

en: Do not emit addressing modes with side-effect assignment
vi: Đừng xuất chế độ đặt địa chỉ với sự gán hiệu ứng khác

en: Do not emit complex integer constants to read-only memory
vi: Đừng xuất hằng số nguyên phức tạp vào vùng nhớ chỉ đọc

en: Do not emit function prologue or epilogue
vi: Đừng xuất đoạn mở/đóng hàm

en: Do not generate #line directives
vi: Đừng tạo ra chỉ thị #line

en: Do not generate a single exit point for each function
vi: Đừng sạo ra một điểm ra khỏi riêng lẻ cho mỗi hàm

en: Do not generate load/store with update instructions
vi: Đừng tạo ra câu lệnh nạp/lưu với bản cập nhật

en: Do not inline integer division
vi: Đừng chèn vào trực tiếp phép chia số nguyên

en: Do not inline square root
vi: Đừng chèn vào trực tiếp căn bậc hai

en: Do not load the PIC register in function prologues
vi: Đừng nạp thanh ghi PIC trong đoạn mở đầu hàm

en: Do not look for object files in standard path
vi: Không tìm các tập tin đối tượng trong đường dẫn tiêu chuẩn

en: Do not mark ABI switches in e_flags
vi: Đừng đánh dấu cái chuyển ABI trong e_flags

en: Do not place floating point constants in TOC
vi: Đừng để vào TOC hằng số loại điểm phù động

en: Do not place symbol+offset constants in TOC
vi: Đừng để vào TOC hằng số loại ký_hiệu+hiệu_số

en: Do not pretend that branches are expensive
vi: Đừng làm ra vẻ là nhánh có giá cao

en: Do not provide a default start-address 0x100 of the program
vi: Đừng cung cấp một địa chỉ bắt đầu mặc định 0x100 của chương trình

en: Do not support SSE4.1 and SSE4.2 built-in functions and code generation
vi: Đừng hỗ trợ hàm dựng sẵn và chức năng tạo ra mã loại SSE4.1 và SSE4.2

en: Do not treat local variables and COMMON blocks as if they were named in SAVE statements
vi: Đừng xử lý giá trị cục bộ hoặc khối CHUNG như là nó được đặt tên trong câu lệnh LƯU

en: Do not tune code and read-only data alignment
vi: Đừng điều chỉnh sự xếp hàng mã và dữ liệu chỉ-đọc

en: Do not tune stack alignment
vi: Đừng điều chỉnh sự xếp hàng đống

en: Do not tune writable data alignment
vi: Đừng điều chỉnh sự xếp hàng dữ liệu có thể ghi được

en: Do not use MDMX instructions
vi: Đừng sử dụng câu lệnh MDMX

en: Do not use MIPS-3D instructions
vi: Đừng sử dụng câu lệnh MIPS-3D

en: Do not use VAX fp
vi: Đừng sử dụng điểm phù động loại VAX

en: Do not use a cache-flushing function before calling stack trampolines
vi: Đừng sử dụng một hàm chuyển hết vùng nhớ tạm ra ngoài trước khi gọi trampoline stack

en: Do not use addresses that allocate global registers
vi: Đừng sử dụng địa chỉ mà cấp phát thanh ghi toàn cục

en: Do not use condition codes from normal instructions
vi: Đừng sử dụng mã điều kiện từ câu lệnh thông thường

en: Do not use hardware FP
vi: Đừng sử dụng điểm phù động loại phần cứng

en: Do not use hardware floating point
vi: Đừng sử dụng điểm phù động loại phần cứng

en: Do not use hardware fp
vi: Đừng sử dụng điểm phù động loại phần cứng

en: Do not use hardware quad fp instructions
vi: Đừng sử dụng câu lệnh loại bốn điểm phù động phần cứng

en: Do not use inline patterns for copying memory
vi: Đừng sử dụng mẫu được chèn vào trực tiếp để sao chép vùng nhớ

en: Do not use the SPE ABI extensions
vi: Không dùng lệnh mở rộng SPE ABI

en: Do not use the bit-field instructions
vi: Đừng sử dụng câu lệnh loại trường-bit

en: Do not use unaligned memory references
vi: Đừng sử dụng tham chiếu vùng nhớ tạm chưa xếp hàng

en: Do not warn about using "long long" when -pedantic
vi: Bật -pedantic thì đừng cảnh báo về sử dụng 'long long'

en: Do stack checking using bounds in L1 scratch memory
vi: Kiểm tra đống dùng biên giới trong vùng nhớ nháp cấp 1

en: Don't align items in code or data
vi: Đừng xếp hàng các mục trong mã hoặc dữ liệu

en: Don't call any cache flush functions
vi: Đừng gọi hàm nào chuyển hết vùng nhớ tạm ra ngoài

en: Don't call any cache flush trap
vi: Đừng gọi bẫy nào chuyển hết vùng nhớ tạm ra ngoài

en: Don't generate checks for control speculation in selective scheduling
vi: Đừng tạo ra hàm kiểm tra đối với đầu cơ về điều khiển khi định thời một cách lựa chọn

en: Don't generate privileged-mode only code; implies -mno-inline-ic_invalidate if the inline code would not work in user mode.
vi: Đừng tạo ra mã chỉ có chế độ quyền đặc biệt; cũng ngụ ý -mno-inline-ic_invalidate nếu mã trực tiếp không có tác động trong chế độ người dùng

en: Don't optimize block moves
vi: Đừng tối ưu hoá sự di chuyển khối

en: Don't use P-mnemonics for branches
vi: Đừng sử dụng phím gới nhớ P cho nhánh

en: Don't use any of r32..r63.
vi: Đừng sử dụng r32..r63.

en: Double-precision floating point unit
vi: Đơn vị điểm phù động chính xác đôi

en: Driving:
vi: Đang điều khiển:

en: Dynamically allocate cc registers
vi: Cấp phát động các thanh ghi CC

en: E specifier not allowed with g0 descriptor
vi: Dùng bộ mô tả g0 thì không cho phép bộ ghi rõ E

en: ERRMSG variable
vi: Biến ERRMSG

en: ESA/390 architecture
vi: Kiến trúc ESA/390

en: Emit 16-bit relocations to the small data areas
vi: Xuất vào vùng dữ liệu nhỏ sự định vị lại 16-bit

en: Emit 32-bit relocations to the small data areas
vi: Xuất vào vùng dữ liệu nhỏ sự định vị lại 32-bit

en: Emit IEEE-conformant code, without inexact exceptions
vi: Xuất mã thích hợp với IEEE mà không có ngoại lệ không chính xác

en: Emit call graph information
vi: Xuất thông tin về đồ thị gọi

en: Emit cmpeqdi_t pattern even when -mcbranchdi is in effect.
vi: Xuất mẫu cmpeqdi_t pattern ngay cả khi tuỳ chọn -mcbranchdi vẫn hoạt động.

en: Emit code for the byte/word ISA extension
vi: Xuất mã cho phần mở rộng ISA byte/từ

en: Emit code for the counting ISA extension
vi: Xuất mã cho phần mở rộng ISA đếm

en: Emit code for the fp move and sqrt ISA extension
vi: Xuất mã cho phần mở rộng ISA loại điểm phù động về di chuyển v tính căn bậc hai

en: Emit code for the motion video ISA extension
vi: Xuất mã cho phần mở rộng ISA ảnh động di chuyển

en: Emit code using explicit relocation directives
vi: Xuất mã dùng chỉ thị định vị lại dứt khoát

en: Emit direct branches to local functions
vi: Xuất nhánh trực tiếp tới hàm cục bộ

en: Emit errors when run-time relocations are generated
vi: Xuất lỗi khi tạo ra sự định vị lại vào lúc chạy

en: Emit extra code in the function prologue in order to trap if the stack size exceeds the given limit
vi: Xuất mã bổ sung trong đoạn mở đầu hàm để đặt bẫy nếu kích cỡ đống vượt quá giới hạn đưa ra

en: Emit function-calls using global offset table when generating PIC
vi: Xuất cuộc gọi hàm dùng bảng hiệu số toàn cục khi tạo ra PIC

en: Emit indirect branches to local functions
vi: Xuất nhánh gián tiếp tới hàm cục bộ

en: Emit long load/store sequences
vi: Xuất dãy nạp/lưu dài

en: Emit rdval instead of rduniq for thread pointer
vi: Đối với hàm trỏ nhánh thì xuất rdval thay cho rduniq

en: Emit stop bits before and after volatile extended asms
vi: Xuất bit dừng lại đẳng trước và sau asm mở rộng hay thay đổi

en: Emit verbose debug information in assembly code
vi: Xuất nhiều thông tin gỡ rối trong mã dịch mã số

en: Emit warnings when run-time relocations are generated
vi: Cảnh báo khi tạo ra sự định vị lại vào lúc chạy

en: Enable 32-bit divide instructions
vi: Hiệu lực câu lệnh chia loại 32-bit

en: Enable 32-bit multiply instructions
vi: Hiệu lực câu lệnh nhân lên loại 32-bit

en: Enable Dwarf 2 line debug info via GNU as
vi: Hiệu lực thông tin gỡ rối dòng Dwarf 2 thông qua as của GNU

en: Enable Function Descriptor PIC mode
vi: Hiệu lực chế độ PIC Mô tả Hàm

en: Enable ID based shared library
vi: Hiệu lực thư viện dùng chung dựa vào mã số (ID)

en: Enable IVC2 scheduling
vi: Hiệu lực chức năng định thời IVC2

en: Enable MeP Coprocessor
vi: Hiệu lực bộ đồng xử lý MeP

en: Enable MeP Coprocessor with 32-bit registers
vi: Hiệu lực bộ đồng xử lý MeP với thanh ghi 32-bit

en: Enable MeP Coprocessor with 64-bit registers
vi: Hiệu lực bộ đồng xử lý MeP với thanh ghi 64-bit

en: Enable PIC support for building libraries
vi: Hiệu lực sự hỗ trợ PIC để xây dựng thư viện

en: Enable SH5 cut2 workaround
vi: Hiệu lực khắc phục cut2 SH5

en: Enable TPF-OS tracing code
vi: Hiệu lực mã tìm đường TFP-OS

en: Enable absolute difference instructions
vi: Hiệu lực câu lệnh khác biệt tuyệt đối

en: Enable alignment of COMMON blocks
vi: Bật sự xếp hàng các khối CHUNG

en: Enable all -Wunused- warnings
vi: Bật tấ cả -Wunused- warnings

en: Enable all optional instructions
vi: Hiệu lực tất cả các câu lệnh vẫn tuỳ chọn

en: Enable assignability checks for stores into object arrays
vi: Hiệu lực sự kiểm tra khả năng sự gán cho việc lưu vào mảng đối tượng

en: Enable average instructions
vi: Hiệu lực các câu lệnh tính số trung bình

en: Enable backend debugging
vi: Hiệu lực chức năng gỡ rối hậu phương

en: Enable barrel shift instructions
vi: Hiệu lực câu lệnh barrel shift

en: Enable bit manipulation instructions
vi: Hiệu lực các câu lệnh thao tác bit

en: Enable cbranchdi4 pattern
vi: Hiệu lực mẫu cbranchdi4

en: Enable clip instructions
vi: Hiệu lực các câu lệnh trích đoạn

en: Enable conditional execution other than moves/scc
vi: Hiệu lực sự thực hiện có điều kiện mà khác với moves/scc

en: Enable conditional moves
vi: Hiệu lực sự di chuyển có điều kiện

en: Enable debug output
vi: Bật kết xuất gỡ rối

en: Enable debug output to be generated.
vi: Hiệu lực chức năng tạo ra kết xuất gỡ rối.

en: Enable decimal floating point hardware support
vi: Hiệu lực sự hỗ trợ phần cứng điểm phù động thập phân

en: Enable divide and modulus instructions
vi: Hiệu lực câu lệnh chia và câu lệnh tạo giá trị tuyệt đối

en: Enable earlier placing stop bits for better scheduling
vi: Hiệu lực sự để sớm hơn các bit dừng lại, để định thời một cách thành công hơn

en: Enable front end optimization
vi: Cho phép tối ưu hoá từ chương trình gọi

en: Enable hardware floating point
vi: Hiệu lực điểm phù động loại phần cứng

en: Enable inlining of PLT in function calls
vi: Hiệu lực sự chèn trực tiếp PLT vào cuộc gọi hàm

en: Enable label alignment optimizations
vi: Hiệu lực sự tối ưu hoá cách xếp hàng nhãn

en: Enable leading zero instructions
vi: Hiệu lực câu lệnh có số không đi trước

en: Enable linker optimizations
vi: Hiệu lực số tối ưu hoá bộ liên kết

en: Enable linker relaxation.
vi: Hiệu lực chức năng làm yếu bộ liên kết.

en: Enable linker relaxations
vi: Hiệu lực hàm yếu về bộ liên kết

en: Enable linker relaxing
vi: Hiệu lực làm yếu bộ liên kết

en: Enable min/max instructions
vi: Hiệu lực câu lệnh tính số tối đa/thiểu

en: Enable most warning messages
vi: Hiệu lực phần lớn các thông điệp cảnh báo

en: Enable multicore support
vi: Hiệu lực khả năng hỗ trợ đa lõi

en: Enable multiply instructions
vi: Hiệu lực câu lệnh nhân lên

en: Enable nested conditional execution optimizations
vi: Hiệu lực sự tối ưu hoá quá trình thực hiện có điều kiện mà cũng lồng nhau

en: Enable optimization of static class initialization code
vi: Hiệu lực sự tối ưu hoá mã sơ khởi hạng tĩnh

en: Enable optimizing &&/|| in conditional execution
vi: Hiệu lực sự tối ưu hoá &&/|| trong quá trình thực hiện có điều kiện

en: Enable preprocessing
vi: Bật khả năng tiền xử lý

en: Enable range checking during compilation
vi: Hiệu lực chức năng kiểm tra phạm vi trong khi biên dịch

en: Enable saturation instructions
vi: Hiệu lực câu lệnh lập trạng thái bão hoà

en: Enable separate data segment
vi: Hiệu lực đoạn dữ liệu riêng

en: Enable setting GPRs to the result of comparisons
vi: Hiệu lực chức năng lập GPR thành kết quả của phép so sánh

en: Enable sign extend instructions
vi: Hiệu lực câu lệnh mở rộng ký hiệu

en: Enable stack probing
vi: Hiệu lực chức năng dò đống

en: Enable strict 32-bit psABI struct return checking.
vi: Hiệu lực chức năng kiểm tra trả lại cấu trúc psABI 32-bit ngặt

en: Enable the normal mode
vi: Hiệu lực chế độ thông thường

en: Enable the use of 64-bit floating point registers in fmov instructions.  See -mdalign if 64-bit alignment is required.
vi: Hiệu lực sử dụng thay ghi điểm phù động 64-bit trong câu lệnh fmov. Xem -mdalign nếu cũng yêu cầu xếp hàng theo 64-bit.

en: Enable the use of RX FPU instructions.  This is the default.
vi: Bật khả năng sử dụng câu lệnh điểm phù động RX. Đây là thiết lập mặc định.

en: Enable the use of the indexed addressing mode for SHmedia32/SHcompact
vi: Hiệu lực sử dụng chế độ đặt địa chỉ loại phụ lục cho SHmedia32/SHcompact

en: Enable the use of the short load instructions
vi: Hiệu lực sử dụng câu lệnh nạp ngắn

en: Enable unaligned load/store instruction
vi: Hiệu lực câu lệnh nạp/lưu chưa xếp hàng

en: Enable use of GPREL for read-only data in FDPIC
vi: Hiệu lực sử dụng GPREL cho dữ liệu chỉ đọc trong FDPIC

en: Enable use of POST_INC / POST_DEC
vi: Cho phép sử dụng POST_INC / POST_DEC

en: Enable use of POST_MODIFY
vi: Cho phép sử dụng POST_MODIFY

en: Enable use of sdata/scommon/sbss
vi: Hiệu lực sử dụng sdata/scommon/sbss

en: Enable user-defined instructions
vi: Hiệu lực câu lệnh được người dùng xác định

en: Enabled ID based shared library
vi: Hiệu lực thư viện dùng chung dựa vào mã số (ID)

en: Encode SSE instructions with VEX prefix
vi: Mã hoá câu lệnh SSE với tiền tố VEX

en: End expression in DO loop
vi: Biểu thức kết thúc trong vòng lặp DO (làm)

en: End of search list.
vi: Kết thúc danh sách tìm kiếm.

en: Error converting integer
vi: Gặp lỗi khi chuyển đổi số nguyên

en: Error writing output file '%s'
vi: Lỗi khi ghi tập tin kết xuất '%s'

en: Error:
vi: Lỗi:

en: Event
vi: Dữ kiện

en: Expected P edit descriptor
vi: cần bộ mô tả chỉnh sửa P

en: Expected attribute bit name
vi: Mong đợi một tên bit thuộc tính

en: Expected expression type
vi: Mong đợi một loại biểu thức

en: Expected integer
vi: Mong đợi một số nguyên

en: Expected integer string
vi: Mong đợi một chuỗi số nguyên

en: Expected left parenthesis
vi: Mong đợi một dấu ngoặc đơn mở

en: Expected name
vi: Mong đợi một tên

en: Expected real string
vi: Mong đợi một chuỗi thật

en: Expected right parenthesis
vi: Mong đợi một dấu ngoặc đơn đóng

en: Expected string
vi: Mong đợi một chuỗi

en: FP exceptions are enabled
vi: Đã bật ngoại lệ điểm phù động

en: Failed to open file %s for writing state: %s
vi: Không thể mở tập tin %s để ghi trạng thái: %s

en: Failed to open state file %s for reading [%s]
vi: Gặp lỗi khi mở tập tin trạng thái %s để đọc [%s]

en: Fatal Error:
vi: Lỗi nghiêm trọng:

en: Floating point unit does not support divide & sqrt
vi: Đơn vị điểm phù động không hỗ trợ phép chia và phép tính căn bậc hai

en: Follow Renesas (formerly Hitachi) / SuperH calling conventions
vi: Theo quy ước gọi SuperH / Renesas (còn gọi là Hitachi)

en: Follow the EABI linkage requirements
vi: Tùy theo các yêu cầu của sự liên kết EABI

en: For bug reporting instructions, please see:
    %s.
vi: Để tìm hướng dẫn về thông báo lỗi, hãy xem:
    %s.

en: For intrinsics library: pass all parameters in registers
vi: Cho thư viện các bản thực chất: gửi mọi tham số qua thanh ghi

en: For nested functions on stack executable permission is set.
vi: Gán quyền thực hiện cho hàm lồng nhau trên đống.

en: Force functions to be aligned to a 4 byte boundary
vi: Ép buộc các hàm được xếp hàng theo một biên giới 4-byte

en: Function starts are aligned to this power of 2
vi: Đầu hàng được xếp hàng theo lũy thừa 2 này

en: GCSE disabled
vi: GCSE bị tắt

en: GMP version %s, MPFR version %s, MPC version %s
vi: GMP phiên bản %s, MPFR phiên bản %s, MPC phiên bản %s

en: GNU C no longer supports -traditional without -E
vi: C của GNU không còn hỗ trợ -traditional mà không có -E

en: GNU Fortran comes with NO WARRANTY, to the extent permitted by law.
    You may redistribute copies of GNU Fortran
    under the terms of the GNU General Public License.
    For more information about these matters, see the file named COPYING
vi: GNU Fortran được phát hành mà KHÔNG BẢO ĐẢM GÌ CẢ,
    với điều khiển được pháp luật cho phép.
    Bạn có thể phân phối nó với điều kiện của
    Giấy Phép Công Cộng Gnu (GPL).
    Để tìm thấy thông tin thêm thì hãy xem tập tin có tên COPYING.

en: GNU Objective C no longer supports traditional compilation
vi: Objective C của GNU không còn hỗ trợ chức năng biên dịch truyền thống

en: Generate 32-bit FPU-less SHmedia code
vi: Tạo ra mã SHmedia 32-bit không có FPU

en: Generate 32-bit SHmedia code
vi: Tạo ra mã SHmedia 32-bit

en: Generate 32-bit code
vi: Tạo ra mã 32-bit

en: Generate 32-bit offsets in switch tables
vi: Tạo ra hiệu số 32-bit trong bảng cái chuyển

en: Generate 32bit i386 code
vi: Tạo ra mã i386 32-bit

en: Generate 32bit x86-64 code
vi: Tạo ra mã x86-64 32-bit

en: Generate 64-bit FPU-less SHmedia code
vi: Tạo ra mã SHmedia 64-bit không có FPU

en: Generate 64-bit SHmedia code
vi: Tạo ra mã SHmedia 64-bit

en: Generate 64-bit code
vi: Tạo ra mã 64-bit

en: Generate 64bit x86-64 code
vi: Tạo ra mã x86-64 64-bit

en: Generate APCS conformant stack frames
vi: Tạo ra các khung đống làm hợp với APCS

en: Generate Cell microcode
vi: Tạo ra mã vi Cell

en: Generate FPU-less SHcompact code
vi: Tạo ra mã SHcompact không có FPU

en: Generate GFLOAT double precision code
vi: Tạo ra mã chính xác đôi GFLOAT

en: Generate H8/300H code
vi: Tạo ra mã H8/300H

en: Generate H8S code
vi: Tạo ra mã H8S

en: Generate H8S/2600 code
vi: Tạo ra mã H8S/2600

en: Generate H8SX code
vi: Tạo ra mã H8SX

en: Generate ILP32 code
vi: Tạo ra mã ILP32

en: Generate LP64 code
vi: Tạo ra mã LP64

en: Generate MIPS16 code
vi: Tạo ra mã MIPS16

en: Generate PA1.0 code
vi: Tạo ra mã PA1.0

en: Generate PA1.1 code
vi: Tạo ra mã PA1.1

en: Generate PA2.0 code (requires binutils 2.10 or later)
vi: Tạo ra mã PA2.0 (yêu cầu binutils 2.10 hay sau)

en: Generate PPC750CL paired-single instructions
vi: Tạo ra câu lệnh đôi-đơn PPC750CL

en: Generate SH1 code
vi: Tạo ra mã SH1

en: Generate SH2 code
vi: Tạo ra mã SH2

en: Generate SH2a FPU-less code
vi: Tạo ra mã SH2a không có FPU

en: Generate SH2e code
vi: Tạo ra mã SH2e

en: Generate SH3 code
vi: Tạo ra mã SH3

en: Generate SH3e code
vi: Tạo ra mã SH3e

en: Generate SH4 FPU-less code
vi: Tạo ra mã SH4 không có FPU

en: Generate SH4 code
vi: Tạo ra mã SH4

en: Generate SH4-100 FPU-less code
vi: Tạo ra mã SH4-100 không có FPU

en: Generate SH4-100 code
vi: Tạo ra mã SH4-100

en: Generate SH4-200 FPU-less code
vi: Tạo ra mã SH4-200 không có FPU

en: Generate SH4-200 code
vi: Tạo ra mã SH4-200

en: Generate SH4-300 FPU-less code
vi: Tạo ra mã SH4-300 không có FPU

en: Generate SH4-300 code
vi: Tạo ra mã SH4-300

en: Generate SH4a FPU-less code
vi: Tạo ra mã SH4a không có FPU

en: Generate SH4a code
vi: Tạo ra mã SH4a

en: Generate SH4al-dsp code
vi: Tạo ra mã SH4al-dsp

en: Generate SHcompact code
vi: Tạo ra mã SHcompact

en: Generate SPE SIMD instructions on E500
vi: Tạo ra câu lệnh SIMD SPE trong E500

en: Generate VRSAVE instructions when generating AltiVec code
vi: Tạo ra câu lệnh VRSAVE khi tạo ra mã AltiVec

en: Generate a call to abort if a noreturn function returns
vi: Tạo ra một cuộc gọi nên hủy bỏ nếu một hàm không trả lại còn trả lại

en: Generate a single exit point for each function
vi: Tạo ra một điểm ra khỏi riêng lẻ cho mỗi hàm

en: Generate big endian code
vi: Tạo ra mã về cuối lớn

en: Generate big-endian code
vi: Tạo ra mã về cuối lớn

en: Generate bit instructions
vi: Tạo ra câu lệnh bit

en: Generate branch hints for branches
vi: Đối với nhánh thì tạo ra lời gợi ý nhánh

en: Generate call insns as indirect calls, if necessary
vi: Tạo ra câu lệnh gọi dưới dạng cuộc gọi gián tiếp, nếu cần thiết

en: Generate checks for references to NULL
vi: Tạo ra sự kiểm tra có tham chiếu đến NULL (vô giá trị)

en: Generate cld instruction in the function prologue.
vi: Tạo ra câu lệnh cld trong đoạn mở đầu hàm.

en: Generate code for 18 bit addressing
vi: Tạo ra mã để đặt địa chỉ 18 bit

en: Generate code for 32 bit addressing
vi: Tạo ra mã để đặt địa chỉ 32 bit

en: Generate code for GNU as
vi: Tạo ra mã cho as của GNU

en: Generate code for GNU assembler (gas)
vi: Tạo ra mã cho bộ dịch mã số GNU (gas)

en: Generate code for GNU ld
vi: Tạo ra mã cho ld của GNU

en: Generate code for SH4 340 series (MMU/FPU-less)
vi: Tạo ra mã cho loạt SH4 340 (không có MMU/FPU)

en: Generate code for SH4 400 series (MMU/FPU-less)
vi: Tạo ra mã cho loạt SH4 400 (không có MMU/FPU)

en: Generate code for SH4 500 series (FPU-less).
vi: Tạo ra mã cho loạt SH4 500 (không có MMU/FPU)

en: Generate code for UNIX assembler
vi: Tạo ra mã cho bộ dịch mã số UNIX

en: Generate code for a 5206e
vi: Tạo ra mã cho một 5206e

en: Generate code for a 520X
vi: Tạo ra mã cho một 520X

en: Generate code for a 528x
vi: Tạo ra mã cho một 528X

en: Generate code for a 5307
vi: Tạo ra mã cho một 5307

en: Generate code for a 5407
vi: Tạo ra mã cho một 5407

en: Generate code for a 68000
vi: Tạo ra mã cho một 68000

en: Generate code for a 68010
vi: Tạo ra mã cho một 68010

en: Generate code for a 68020
vi: Tạo ra mã cho một 68020

en: Generate code for a 68030
vi: Tạo ra mã cho một 68030

en: Generate code for a 68040
vi: Tạo ra mã cho một 68040

en: Generate code for a 68040, without any new instructions
vi: Tạo ra mã cho một 68040 mà không có câu lệnh mới nào

en: Generate code for a 68060
vi: Tạo ra mã cho một 680220

en: Generate code for a 68060, without any new instructions
vi: Tạo ra mã cho một 68060 mà không có câu lệnh mới nào

en: Generate code for a 68302
vi: Tạo ra mã cho một 68302

en: Generate code for a 68332
vi: Tạo ra mã cho một 68332

en: Generate code for a 68851
vi: Tạo ra mã cho một 68851

en: Generate code for a ColdFire v4e
vi: Tạo ra mã cho một ColdFire v4e

en: Generate code for a DLL
vi: Tạo ra mã cho một DLL

en: Generate code for a Fido A
vi: Tạo ra mã cho một Fido A

en: Generate code for a cpu32
vi: Tạo ra mã cho một cpu32

en: Generate code for an 11/10
vi: Tạo ra mã cho một 11/10

en: Generate code for an 11/40
vi: Tạo ra mã cho một 11/40

en: Generate code for an 11/45
vi: Tạo ra mã cho một 11/45

en: Generate code for built-in atomic operations
vi: Tạo ra mã cho các thao tác atomic dựng sẵn

en: Generate code for darwin loadable kernel extensions
vi: Tạo ra mã cho phần mở rộng hạt nhân có thể nạp được với Darwin

en: Generate code for given CPU
vi: Tạo ra mã cho CPU đưa ra

en: Generate code for huge switch statements
vi: Tạo ra mã cho câu lệnh chuyển rất lớn

en: Generate code for old exec BSS PLT
vi: Tạo ra mã cho BSS PLT thực hiện cũ

en: Generate code for the Boehm GC
vi: Tạo ra mã cho Boehm GC

en: Generate code for the M*Core M210
vi: Tạo ra mã cho M*Core M210

en: Generate code for the M*Core M340
vi: Tạo ra mã cho M*Core M340

en: Generate code for the kernel or loadable kernel extensions
vi: Tạo ra mã cho hạt nhân hoặc phần mở rộng hạt nhân có thể nạp được

en: Generate code in big endian mode
vi: Tạo mã trong chế độ về cuối lớn

en: Generate code in little endian mode
vi: Tạo ra mã trong chế độ về cuối nhỏ

en: Generate code suitable for executables (NOT shared libs)
vi: Tạo ra mã thích hợp với bản thực thị (KHÔNG PHẢI thư viện dùng chung)

en: Generate code suitable for fast turn around debugging
vi: Tạo ra mã thích hợp với chức năng gỡ rối trả kết quả nhanh

en: Generate code that can be safely linked with MIPS16 code.
vi: Tạo ra mã có thể được liên kết an toàn với mã MIPS16.

en: Generate code that can be used in SVR4-style dynamic objects
vi: Tạo ra mã có thể sử dụng được trong đối tượng năng động có kiểu SVR4

en: Generate code that conforms to the given ABI
vi: Tạo ra mã thích hợp với ABI đưa ra

en: Generate code that uses 68881 floating-point instructions
vi: Tạo ra mã sử dụng chỉ lệnh dấu chấm động 68881

en: Generate code that won't be linked against any other ID shared libraries,
vi: Tạo ra mã sẽ không được liên kết đối với thư viện dùng chung mã số khác nào,

en: Generate code to use a non-exec PLT and GOT
vi: Tạo ra mã để sử dụng một PLT và GOT không thực hiện

en: Generate code which uses hardware floating point instructions
vi: Tạo ra mã mả sử dụng câu lệnh loại điểm phù động phần cứng

en: Generate code with library calls for floating point
vi: Tạo ra mã chứa cuộc gọi thư viện cho điểm phù động

en: Generate code without GP reg
vi: Tạo ra mã không có GP reg

en: Generate cpp defines for server IO
vi: Tạo ra các lời xác định cpp cho V/R máy phục vụ

en: Generate cpp defines for workstation IO
vi: Tạo ra các lời xác định cpp cho V/R máy trạm

en: Generate default double-precision SH2a-FPU code
vi: Tạo ra mã SH2a-FPU chính xác đôi mặc định

en: Generate default single-precision SH2a-FPU code
vi: Tạo ra mã SH2a-FPU chính xác đơn mặc định

en: Generate default single-precision SH4 code
vi: Tạo ra mã SH4 chính xác đơn mặc định

en: Generate default single-precision SH4-100 code
vi: Tạo ra mã SH4-100 chính xác đơn mặc định

en: Generate default single-precision SH4-200 code
vi: Tạo ra mã SH4-200 chính xác đơn mặc định

en: Generate default single-precision SH4-300 code
vi: Tạo ra mã SH4-300 chính xác đơn mặc định

en: Generate default single-precision SH4a code
vi: Tạo ra mã SH4a chính xác đơn mặc định

en: Generate divide results with reminder having the same sign as the divisor (not the dividend)
vi: Tạo ra kết quả chia có phần dư với cùng một ký hiệu (-/+) với số chia (không phải với số bị chia)

en: Generate fast indirect calls
vi: Tạo ra các cuộc gọi gián tiếp nhanh

en: Generate floating point mathematics using given instruction set
vi: Tạo ra toán học loại điểm phù động dùng tập hợp câu lệnh đưa ra

en: Generate floating-point multiply-add instructions
vi: Tạo ra câu lệnh nhân-cộng kiểu dấu chấm động

en: Generate inline floating point division, optimize for latency
vi: Tạo ra phép chia điểm phù động trực tiếp, tối ưu hoá cho sự ngấm ngầm

en: Generate inline floating point division, optimize for throughput
vi: Tạo ra phép chia điểm phù động trực tiếp, tối ưu hoá cho tốc độ truyền dữ liệu

en: Generate inline integer division, optimize for latency
vi: Tạo ra phép chia số nguyên trực tiếp, tối ưu hoá cho sự ngấm ngầm

en: Generate inline integer division, optimize for throughput
vi: Tạo ra phép chia số nguyên trực tiếp, tối ưu hoá cho tốc độ truyền dữ liệu

en: Generate inline square root, optimize for latency
vi: Tạo ra căn bậc hai trực tiếp, tối ưu cho sự ngấm ngầm

en: Generate inline square root, optimize for throughput
vi: Tạo ra căn bậc hai trực tiếp, tối ưu cho tốc độ truyền dữ liệu

en: Generate instances of Class at runtime
vi: Lúc chạy thì tạo ra các thể hiện Hạng

en: Generate isel instructions
vi: Tạo ra câu lệnh isel

en: Generate little endian code
vi: Tạo ra mã về cuối nhỏ

en: Generate little-endian code
vi: Tạo ra mã về cuối nhỏ

en: Generate load/store multiple instructions
vi: Tạo ra câu lệnh nạp/lưu nội

en: Generate load/store with update instructions
vi: Tạo ra câu lệnh nạp/lưu với bản cập nhật

en: Generate make dependencies
vi: Tạo ra quan hệ phụ thuộc của make

en: Generate make dependencies and compile
vi: Tạo ra quan hệ phụ thuộc của make, và biên dịch

en: Generate normal-mode code
vi: Tạo ra mã có chế độ thông thường

en: Generate only single-precision SH2a-FPU code
vi: Tạo ra chỉ mã SH2a-FPU chính xác đơn

en: Generate only single-precision SH4 code
vi: Tạo ra chỉ mã SH4 chính xác đơn

en: Generate only single-precision SH4-100 code
vi: Tạo ra chỉ mã SH4-100 chính xác đơn

en: Generate only single-precision SH4-200 code
vi: Tạo ra chỉ mã SH4-200 chính xác đơn

en: Generate only single-precision SH4-300 code
vi: Tạo ra chỉ mã SH4-300 chính xác đơn

en: Generate only single-precision SH4a code
vi: Tạo ra chỉ mã SH4a chính xác đơn

en: Generate pc-relative code
vi: Tạo ra mã tương đối với PC (pc-relative)

en: Generate phony targets for all headers
vi: Tạo ra đích giả cho mọi phần đầu

en: Generate re-entrant, PIC code
vi: Tạo ra mã PIC loại vào lại

en: Generate reciprocals instead of divss and sqrtss.
vi: Tạo ra số đảo thay cho divss và sqrtss.

en: Generate self-relocatable code
vi: Tạo ra mã có thể tự định vị lại

en: Generate sin, cos, sqrt for FPU
vi: Tạo ra sin, cos, sqrt cho FPU (đơn vị điểm phù động)

en: Generate string instructions for block moves
vi: Tạo ra câu lệnh chuỗi để di chuyển khối

en: Generate warnings when inefficient code is known to be generated.
vi: Tạo ra cảnh báo khi thấy là mã thiếu khả năng bị tạo ra.

en: Generated should be loaded by bootstrap loader
vi: Điều được tạo ra thì nên được nạp bởi bộ nạp và khởi động

en: Give branches their default cost
vi: Gán cho mỗi nhánh giá mặc định của nó

en: How much can given compilation unit grow because of the inlining (in percent)
vi: Độ tăng lên (theo phần trăm) được phép cho đơn vị biên dịch đưa ra do việc chèn vào trực tiếp

en: How much can given compilation unit grow because of the interprocedural constant propagation (in percent)
vi: Độ tăng lên (theo phần trăm) được phép cho đơn vị biên dịch đưa ra do sự lan truyền bất biến thuộc liên quá trình

en: ID of shared library to build
vi: mã số (ID) của thư viện dùng chung cần xây dựng

en: ISO C does not support saturating types
vi: ISO C không hỗ trợ kiểu saturating

en: ISO C forbids %<goto *expr;%>
vi: ISO C cấm %<goto *expr;%>

en: ISO C++ does not support %<__int128%> for %qs
vi: ISO C++ không hỗ trợ %<__int128%> cho %qs

en: ISO C90 does not support %<_Alignas%>
vi: ISO C90 không hỗ trợ %<_Alignas%>

en: ISO C90 does not support %<long long%>
vi: ISO C90 không hỗ trợ %<long long%>

en: ISO C90 does not support %qE
vi: ISO C90 không hỗ trợ %qE

en: ISO C90 does not support complex types
vi: ISO C90 không hỗ trợ kiểu complex

en: ISO C99 does not support %<_Alignas%>
vi: ISO C99 không hỗ trợ %<_Alignas%>

en: ISO C99 does not support %qE
vi: ISO C99 không hỗ trợ %qE

en: If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorization
vi: Dùng -ftree-vectorize thì biên giới vòng lặp tối thiểu của một vòng lặp cần tính để véc-tơ hoá

en: If -fvariable-expansion-in-unroller is used, the maximum number of times that an individual variable will be expanded during loop unrolling
vi: Dùng -fvariable-expansion-in-unroller thì số tối đa các lần mở rộng một biến nào đó trong khi bỏ cuộn vòng lặp

en: If number of candidates in the set is smaller, we always try to remove unused ivs during its optimization
vi: Gặp tập hợp chứa số nhỏ hơn các điều ứng cử thì lúc nào cũng thử gỡ bỏ iv chưa dùng nào trong khi tối ưu hoá nó

en: If set, control speculative instructions will be chosen for schedule only if there are no other choices at the moment
vi: Lập thì câu lệnh đầu cơ về điều khiển sẽ được chọn để định thời chỉ nếu không có sự chọn khác nào vào lúc này

en: If set, data speculative instructions will be chosen for schedule only if there are no other choices at the moment
vi: Lập thì câu lệnh đầu cơ về dữ liệu sẽ được chọn để định thời chỉ nếu không có sự chọn khác nào vào lúc này

en: Ignore 'D' in column one in fixed form
vi: Có dạng cố định thì qua chữ 'D' trong cột đầu tiên

en: Ignore dllimport for functions
vi: Bỏ qua dllimport đối với chức năng

en: Ignored (obsolete)
vi: Bị bỏ qua (quá cũ)

en: In constructor %qs
vi: Trong bộ dựng %qs

en: In copy constructor %qs
vi: Trong bộ dựng bản sao %qs

en: In destructor %qs
vi: Trong bộ hủy %qs

en: In function %qs
vi: Trong hàm %qs

en: In lambda function
vi: Trong hàm λ

en: In member function %qs
vi: Trong hàm bộ phận %qs

en: In static member function %qs
vi: Trong hàm bộ phận tĩnh %qs

en: Inconsistent ranks for operator at %%L and %%L
vi: Tại %%L và %%L có một toán tử với các phân hàng mâu thuẫn nhau

en: Incorrect function return value
vi: Giá trị trả lại hàm không đúng

en: Initialize local variables to zero (from g77)
vi: Sơ khởi các biến cục bộ thành số không (từ g77)

en: Inline all known string operations
vi: Chèn vào trực tiếp tất cả các thao tác chuỗi được biết

en: Inline constants if it can be done in 2 insns or less
vi: Chèn hằng số vào trực tiếp nếu có thể làm trong nhiều nhất 2 câu lệnh

en: Inline memset/memcpy string operations, but perform inline version only for small blocks
vi: Chèn vào trực tiếp các thao tác chuỗi loại memset/memcpy, mà thực hiện phiên bản trực tiếp chỉ cho khối nhỏ

en: Inline recursively only when the probability of call being executed exceeds the parameter
vi: Chèn vào trực tiếp một cách đệ quy chỉ khi xác xuất cuộc gọi được thực hiện cũng vượt quá tham số

en: Input file is a file with a list of filenames to compile
vi: Tập tin nhập vào là một tập tin chứa danh sách các tên tập tin cần biên dịch

en: Insert hbrp instructions after hinted branch targets to avoid the SPU hang issue
vi: Chèn câu lệnh hbrp đẳng sau đích nhánh đã gợi ý để tránh vấn đề SPU đang treo cứng

en: Insert nops when it might improve performance by allowing dual issue (default)
vi: Chèn nops khi có thể tăng hiệu suất bằng cách cho phép đưa ra đôi (mặc định)

en: Integer expression required at %C
vi: Tại %C thì yêu cầu biểu thức số nguyên

en: Integer outside symmetric range implied by Standard Fortran at %L
vi: số nguyên nằm ở ngoại phạm vi đối xứng ngụ ý bởi ngôn ngữ Fortran Tiêu Chuẩn tại %L

en: Integer overflow
vi: Tràn số nguyên

en: Integer value too large in expression at %C
vi: Giá trị số nguyên quá lớn trong biểu thức tại %C

en: Internal compiler error: Error reporting routines re-entered.
vi: Lỗi biên dịch nội bộ: đã nhập lại hàm thông báo lỗi.

en: Interpret any INTEGER(4) as an INTEGER(8)
vi: Biên dịch bất kỳ INTEGER(8) như là INTEGER(4)

en: Interpret any REAL(4) as a REAL(10)
vi: Biên dịch bất kỳ REAL(4) như là REAL(10)

en: Interpret any REAL(4) as a REAL(16)
vi: Biên dịch bất kỳ REAL(4) như là REAL(16)

en: Interpret any REAL(4) as a REAL(8)
vi: Biên dịch bất kỳ REAL(4) như là REAL(8)

en: Interpret any REAL(8) as a REAL(10)
vi: Biên dịch bất kỳ REAL(8) như là REAL(10)

en: Interpret any REAL(8) as a REAL(16)
vi: Biên dịch bất kỳ REAL(8) như là REAL(16)

en: Interpret any REAL(8) as a REAL(4)
vi: Biên dịch bất kỳ REAL(8) như là REAL(4)

en: Intersperse literal pools with code in the text section
vi: Chèn vào nhau các vùng gộp nghĩa chữ và mã trong phần văn bản

en: Invalid context for NULL() pointer at %%L
vi: Gặp ngữ cảnh sai cho hàm trỏ NULL() tại %%L

en: Jump targets are aligned to this power of 2
vi: Đích nhảy được xếp hàng theo lũy thừa 2 này

en: Just use icc0/fcc0
vi: Chỉ sử dụng icc0/fcc0

en: Known ABIs (for use with the -mabi= option):
vi: Không hiểu ABIs (để dùng với tùy chọn -mabi=):

en: Known ARM ABIs (for use with the -mabi= option):
vi: Không hiểu ARM ABIs (để dùng với tùy chọn -mabi=):

en: Known ARM CPUs (for use with the -mcpu= and -mtune= options):
vi: Không hiểu ARM CPUs (để dùng với tùy chọn -mcpu= và -mtune=):

en: Known ARM FPUs (for use with the -mfpu= option):
vi: Không hiểu ARM FPUs (để dùng với tùy chọn -mfpu=):

en: Known ARM architectures (for use with the -march= option):
vi: Không hiểu kiến trúc ARM (để dùng với tùy chọn -march=):

en: Known C6X ISAs (for use with the -march= option):
vi: Không hiểu C6X ISAs (để dùng với tùy chọn -march=):

en: Known CPUs (for use with the -mcpu= and -mtune= options):
vi: Không hiểu CPUs (để dùng với tùy chọn -mcpu= và -mtune=):

en: Known FR-V CPUs (for use with the -mcpu= option):
vi: Không hiểu FR-V CPUs (để dùng với tùy chọn -mcpu=):

en: Known IQ2000 CPUs (for use with the -mcpu= option):
vi: Không hiểu IQ2000 CPUs (để dùng với tùy chọn -mcpu=):

en: Known Itanium CPUs (for use with the -mtune= option):
vi: Không hiểu Itanium CPUs (để dùng với tùy chọn -mcpu=):

en: Known M68K CPUs (for use with the -mcpu= option):
vi: Không hiểu M68K CPUs (để dùng với tùy chọn -mcpu=):

en: Known M68K ISAs (for use with the -march= option):
vi: Không hiểu M68K ISAs(để dùng với tùy chọn -march=):

en: Known M68K microarchitectures (for use with the -mtune= option):
vi: Không hiểu kiến trúc M68K (để dùng với tùy chọn -mtune=):

en: Known MCU names:
vi: Các tên MCU được biết:

en: Known MIPS ABIs (for use with the -mabi= option):
vi: Không hiểu MIPS ABIs (để dùng với tùy chọn -mabi=):

en: Known MIPS CPUs (for use with the -march= and -mtune= options):
vi: Không hiểu MIPS CPUs (để dùng với tùy chọn -march= và -mtune=):

en: Known MIPS ISA levels (for use with the -mips option):
vi: Không hiểu mức MIPS ISA (để dùng với tùy chọn -mips):

en: Known SCORE architectures (for use with the -march= option):
vi: Không hiểu kiến trúc SCORE (để dùng với tùy chọn -march=):

en: Known TILE-Gx CPUs (for use with the -mcpu= option):
vi: Không hiểuTILE-Gx CPUs (để dùng với tùy chọn -mcpu=):

en: Known TILEPro CPUs (for use with the -mcpu= option):
vi: Không hiểu TILEPro CPUs (để dùng với tùy chọn -mcpu=):

en: Known TLS dialects (for use with the -mtls-dialect= option):
vi: Không hiểu TLS dialects (để dùng với tùy chọn -mtls-dialect=):

en: Known floating-point ABIs (for use with the -mfloat-abi= option):
vi: Không hiểu kiểu dấu chấm động ABIs (để dùng với tùy chọn -mfloat-abi=):

en: Left parenthesis required after '*'
vi: Đẳng sau '*' thì yêu cầu một dấu ngoặc đơn mở

en: Lift restrictions on GOT size
vi: Bỏ giới hạn về kích cỡ GOT

en: Like -M but ignore system header files
vi: Giống như -M mà bỏ qua tập tin phần đầu của hệ thống

en: Like -MD but ignore system header files
vi: Giống như -MD mà bỏ qua tập tin phần đầu của hệ thống

en: Lines executed:%s of %d
vi: Dòng được thực hiện: %s trên %d

en: Link to emit program in ELF format (rather than mmo)
vi: Liên kết tới chương trình xuất theo định dạng ELF (hơn là mmo)

en: Link with libads.a, libc.a and crt0.o
vi: Liên kết với libads.a, libc.a và crt0.o

en: Link with libmvme.a, libc.a and crt0.o
vi: Liên kết với libmvme.a, libc.a và crt0.o

en: Link with libsim.a, libc.a and sim-crt0.o
vi: Liên kết với libsim.a, libc.a và sim-crt0.o

en: Link with libyk.a, libc.a and crt0.o
vi: Liên kết với libyk.a, libc.a và crt0.o

en: Link with the fast floating-point library
vi: Liên kết với thư viện dấu chấm động nhanh

en: Link with the library-pic libraries
vi: Liên kết với các thư viện library-pic

en: Logicals at %%L must be compared with %s instead of %s
vi: Tại %%L thì các bộ hợp lý phải được so sánh với %s thay cho %s

en: Loop code aligned to this power of 2
vi: Mã vòng lặp được xếp hàng theo lũy thừa 2 này

en: Loop variable
vi: Biến vòng lặp

en: Loop variable has been modified
vi: Biến vòng lặp bị sửa đổi

en: Loops iterating at least selected number of iterations will get loop alignement.
vi: Vòng lặp nào lặp lại ít nhất số lần lặp lại được chọn thì được xếp hàng các vòng lặp

en: MMIX Internal: Bad value for 'm', not a CONST_INT
vi: MMIX nội bộ: sai lập giá trị cho 'm', không phải là một CONST_INT

en: MMIX Internal: Cannot decode this operand
vi: MMIX nội bộ: không thể giải mã toán hạng này

en: MMIX Internal: Expected a CONST_INT, not this
vi: MMIX nội bộ: mong đợi một CONST_INT, không phải như thế

en: MMIX Internal: Expected a constant, not this
vi: MMIX nội bộ: mong đợi một rằng buộc, không phải như thế

en: MMIX Internal: Expected a register, not this
vi: MMIX nội bộ: mong đợi một thanh ghi, không phải như thế

en: MMIX Internal: This is not a constant:
vi: MMIX nội bộ: đây không phải là một hằng số:

en: MMIX Internal: This is not a recognized address
vi: MMIX nội bộ: đây không phải là một địa chỉ nhận ra

en: MMIX Internal: Trying to output invalidly reversed condition:
vi: MMIX nội bộ: đang thử xuất điều kiện sai đảo ngược:

en: MMIX Internal: What is the CC of this?
vi: MMIX nội bộ: CC của điều này là gì?

en: MMIX Internal: What's the CC of this?
vi: MMIX nội bộ: CC của điều này là gì?

en: Maintain backchain pointer
vi: Bảo tồn hàm trỏ dây chuyền ngược

en: Make integers 32 bits wide
vi: Làm cho số nguyên có chiều rộng 32 bit

en: Make structs a multiple of 4 bytes (warning: ABI altered)
vi: Làm cho cấu trúc là một bội số cho 4 byte (cảnh báo: ABI bị sửa đổi)

en: Make sure loads and stores are not moved past DMA instructions
vi: Kiểm tra lại hàm nạp và hàm lưu không đi qua câu lệnh DMA

en: Malloc data into P2 space
vi: Malloc dữ liệu vào vùng P2

en: Mark MAC register as call-clobbered
vi: Đánh dấu thanh ghi MAC như là bị cuộc gọi ghi đè

en: Mark __tls_get_addr calls with argument info
vi: Đánh dấu cuộc gọi __tls_get_addr bằng thông tin về đối số

en: Mark all loops as parallel
vi: Đánh dấu tất cả các vòng lặp là xử lý song song

en: Max basic blocks number in loop for loop invariant motion
vi: số tối đa các khối cơ bản trong vòng lặp để chuyển động bất biến vòng lặp

en: Max loops number for regional RA
vi: Số tối đa các vòng lặp cho RA thuộc miền

en: Max size of conflict table in MB
vi: Kích cỡ tối đa (theo MB) của bảng xung đột

en: Max. size of var tracking hash tables
vi: Kích cỡ tối đa của bảng chuỗi duy nhất theo dõi var

en: Maximal code growth caused by tail duplication (in percent)
vi: Độ tâng lên tối đa (theo phần trăm) do đuôi bị nhân đôi

en: Maximal estimated growth of function body caused by early inlining of single call
vi: Độ tăng lên tối đa ước lượng của thân hàm do chèn vào trực tiếp sớm một cuộc gọi riêng lẻ

en: Maximal estimated outcome of branch considered predictable
vi: Kết quả tối đa ước lượng của nhánh được thấy là dự đoán được

en: Maximal growth due to inlining of large function (in percent)
vi: Độ tăng lên tối đa (theo phần trăm) do chèn hàm lớn vào trực tiếp

en: Maximal stack frame growth due to inlining (in percent)
vi: Độ tăng lên khung đống tối đa (theo phần trăm) do chèn vào trực tiếp

en: Maximum allowed growth of size of new parameters ipa-sra replaces a pointer to an aggregate with
vi: Độ tăng lên tối đa được pháp của kích cỡ tham số mới ipa-sra thì thay thế một hàm trỏ theo một chiều rộng tập hợp

en: Maximum length of partial antic set when performing tree pre optimization
vi: Chiều dài tối đa của tập hợp antic bộ phận khi thực hiện sự tối ưu hoá sẵn cây

en: Maximum number of fields in a structure before pointer analysis treats the structure as a single variable
vi: Số tối đa các trường trong một cấu trúc trước khi tiến trình phân tích hàm trỏ thấy cấu trúc đó là một biến riêng lẻ

en: Maximum number of instructions in basic block to be considered for SLP vectorization
vi: Số tối đa các lệnh trong khối cơ bản cần tính để véc-tơ hoá SLP

en: Maximum number of instructions in the ready list that are considered eligible for renaming
vi: Số tối đa các lệnh trong danh sách sẵn sàng mà được thấy là thích hợp với chức năng thay đổi tên

en: Maximum number of nops to insert for a hint (Default 2)
vi: Số tối đa các nops cần chèn cho một lời gợi ý (mặc định là 2)

en: Maximum number of statements allowed in a block that needs to be duplicated when threading jumps
vi: Số tối đa các câu lệnh được phép trong một khối cần được nhân đôi khi sắp xếp bước nhảy theo nhánh

en: Maximum number of times that an insn could be scheduled
vi: Số tối đa các lần có thể định thời một lệnh nào đó

en: Maximum size in bytes of constant values allowed as operands.
vi: Kích cỡ tối đa (theo byte) của giá trị bất biến được phép làm toán hạng.

en: Maximum size of a SCC before SCCVN stops processing a function
vi: Kích cỡ tối đa của một SCC trước khi SCCVN dừng xử lý một hàm

en: Maximum size of global and static variables which can be placed into the small data area.
vi: Kích cỡ tối đa của biến loại toàn cục và tĩnh mà có thể được để vào vùng dữ liệu nhỏ.

en: Memory allocation failed
vi: Lỗi cấp phát vùng nhớ

en: Min. ratio of insns to mem ops to enable prefetching in a loop
vi: Tỷ lệ tối thiểu giữa các lệnh và các thao tác vùng nhớ để hiệu lực lấy sẵn trong một vòng lặp

en: Min. ratio of insns to prefetches to enable prefetching for a loop with an unknown trip count
vi: Tỷ lệ tối thiểu giữa các lệnh và các lần lấy sẵn để hiệu lực lấy sẵn cho một vòng lặp không rõ số đếm lần đi qua

en: Minimal distance between possibly conflicting store and load
vi: Khoảng cách tối thiểu giữa vị trí lưu và nạp có thể xung đột với nhau

en: Minimum heap expansion to trigger garbage collection, as a percentage of the total size of the heap
vi: Sự mở rộng miền nhớ tối thiểu để gây ra tập hợp rác, theo phần trăm của kích cỡ miền nhớ hoàn toàn

en: Minimum heap size before we start collecting garbage, in kilobytes
vi: Sự mở rộng miền nhớ tối thiểu (theo kilô-byte) trước khi bắt đầu tập hợp rác

en: Missing leading left parenthesis
vi: Thiếu dấu ngoặc đơn mở đi trước

en: NOTE_INSN_BASIC_BLOCK %d in middle of basic block %d
vi: NOTE_INSN_BASIC_BLOCK %d tại giữa của khối cơ bản %d

en: NOTE_INSN_BASIC_BLOCK is missing for block %d
vi: NOTE_INSN_BASIC_BLOCK bị thiếu cho khối %d

en: Name too long
vi: Tên quá dài

en: No branches
vi: Không có nhánh

en: No calls
vi: Không có cuộc gọi

en: No default crt0.o
vi: Không có crt0.o mặc định

en: No executable lines
vi: Không có dòng thực thi

en: No longer supported
vi: không còn được hỗ trợ nữa

en: Nonnegative width required
vi: Yêu cầu chiều rộng không phải âm

en: Not a valid Java .class file.
vi: Không phải là một tập tin .class Java đúng.

en: Number of registers used to pass integer arguments
vi: Số các thanh ghi được sử dụng để gửi đối số nguyên cho đích

en: Omit frame pointer for leaf functions
vi: Bỏ sót hàm trỏ khung cho hàm lá

en: Omit the frame pointer in leaf functions
vi: Bỏ sót hàm trỏ khung trong hàm lá

en: Only generate absolute relocations on word sized values.
vi: Chỉ tạo ra sự định vị lại tuyệt đối với giá trị kích cỡ từ.

en: Only issue one instruction per cycle
vi: Chỉ đưa ra một câu lệnh từng chu kỳ

en: Only use 32 FPRs
vi: Chỉ sử dụng 32 FPR

en: Only use 32 GPRs
vi: Chỉ sử dụng 32 GPR

en: Operand of .not. operator at %%L is %s
vi: Tại %%L có một toán tử .not. với toán hạng %s

en: Operand of unary numeric operator '%s' at %%L is %s
vi: Tại %%L có một toán tử thuộc số nguyên phân '%s' với toán hạng %s

en: Operand of user operator '%s' at %%L is %s
vi: Tại %%L có một toán tử người dùng '%s' với toán hạng %s

en: Operands of binary numeric operator '%s' at %%L are %s/%s
vi: Tại %%L có một toán tử thuộc số nhị phân '%s' với các toán hạng %s/%s

en: Operands of comparison operator '%s' at %%L are %s/%s
vi: Tại %%L có một toán tử so sánh '%s' với các toán hạng %s/%s

en: Operands of logical operator '%s' at %%L are %s/%s
vi: Tại %%L có một toán tử hợp lý '%s' với các toán hạng %s/%s

en: Operands of string concatenation operator at %%L are %s/%s
vi: Tại %%L có một toán tử ghép nối chuỗi với các toán hạng %s/%s

en: Operands of user operator '%s' at %%L are %s/%s
vi: Tại %%L có một toán tử người dùng '%s' với các toán hạng %s/%s

en: Optimize lui/addiu address loads
vi: Tối ưu hoá việc nạp địa chỉ lui/addiu

en: Optimize tail call instructions in assembler and linker
vi: Tối ưu hoá các câu lệnh gọi đuôi trong bộ dịch mã số và bộ liên kết

en: Options:
vi: Tùy chọn:

en: Out of stack space.
vi: Không đủ sức chứa trong đống.

en: Output a class file
vi: Xuất một tập tin hạng

en: Override -mbest-lib-options
vi: Ghi đè lên -mbest-lib-options

en: P descriptor requires leading scale factor
vi: Bộ mô tả P yêu cầu hệ số tỷ lệ đi trước

en: PCS variant
vi: biến thể PCS

en: PIC register isn't set up
vi: Chưa thiết lập thanh ghi PIC

en: PRE disabled
vi: PRE bị tắt

en: PRINT_OPERAND, invalid insn for %%C
vi: PRINT_OPERAND, sai insn cho %%C

en: PRINT_OPERAND, invalid insn for %%N
vi: PRINT_OPERAND, sai insn cho %%N

en: Pack VLIW instructions
vi: Đóng gói các câu lệnh VLIW

en: Pass -z text to linker
vi: Chuyển tùy chọn -z text cho bộ liên kết

en: Pass FP arguments in FP registers
vi: Gửi đối số loại điểm phù động trong thanh ghi loại điểm phù động

en: Pass the address of the ra save location to _mcount in $12
vi: Gửi địa chỉ của vị trí lưu ra cho _mcount trong $12

en: Perform VR4130-specific alignment optimizations
vi: Tối ưu hoá sự xếp hàng một cách đặc trưng cho VR4130

en: Period required in format specifier
vi: Bộ ghi rõ định dạng thì yêu cầu một dấu chấm

en: Permit nonconforming uses of the tab character
vi: Cho phép sử dụng ký tự tab một cách không phù hợp

en: Permit scheduling of a function's prologue sequence
vi: Cho phép định thời dãy đoạn mở đầu của một hàm nào đó

en: Permit the use of the assert keyword
vi: Cho phép sử dụng từ khoá assert

en: Place a stop bit after every cycle when scheduling
vi: Đang định thời thì cũng để một bit dừng lại vào đẳng sau mọi chu kỳ

en: Place floating point constants in TOC
vi: Để vào TOC hằng số loại điểm phù động

en: Place symbol+offset constants in TOC
vi: Để vào TOC hằng số loại ký_hiệu+hiệu_số

en: Plugins
vi: Phần bổ sung

en: Pointers are 32-bit
vi: Hàm trỏ là 32-bit

en: Pointers are 64-bit
vi: Hàm trỏ là 64-bit

en: Positive exponent width required
vi: Yêu cầu chiều rộng lũy thừa dương

en: Positive width required
vi: Yêu cầu chiều rộng dương

en: Positive width required with T descriptor
vi: Dùng bộ mô tả T thì yêu cầu chiều rộng dương

en: Prefer branches over conditional execution
vi: Thích nhánh hơn sự thực hiện có điều kiện

en: Prefer word accesses over byte accesses
vi: Thích truy cập loại từ hơn truy cập loại byte

en: Prepend global symbols with ":" (for use with PREFIX)
vi: Thêm dấu hai chấm ":" vào trước ký hiệu toàn cục (để sử dụng với TIỀN_TỐ)

en: Pretend a branch-around-a-move is a conditional move.
vi: Làm ra vẻ rằng branch-around-a-move là một sự di chuyển có điều kiện.

en: Pretend that branches are expensive
vi: Làm ra vẻ là nhánh có giá cao

en: Prevent the use of all floating-point operations
vi: Ngăn cản sử dụng lệnh dấu chấm động nào

en: Prevent the use of all hardware floating-point instructions
vi: Ngăn cản sử dụng câu lệnh nào có loại dấu chấm động phần cứng

en: Print code coverage information.
vi: In ra thông tin về bao quát của mã

en: Print the name of header files as they are used
vi: In ra tên của tập tin phần đầu nào đang được sử dụng

en: Processing spec (%s), which is '%s'
vi: Đang xử lý đặc tả (%s), cái mà '%s'

en: Produce a backtrace when a runtime error is encountered
vi: Xuất một vết ngược khi gặp lỗi lúc chạy

en: Produce a warning at runtime if a array temporary has been created for a procedure argument
vi: Cảnh báo lúc chạy nếu một mục mảng tạm thời đã được tạo cho một đối số thủ tục

en: Produce big endian code
vi: Xuất mã về cuối lớn

en: Produce code relocatable at runtime
vi: Xuất mã có thể định vị lại vào lúc chạy

en: Produce little endian code
vi: Xuất mã về cuối nhỏ

en: Program is entirely located in low 64k of memory
vi: Chương trình nằm hoàn toàn trong 64k thấp của vùng nhớ

en: Prohibit PC relative function calls
vi: Cấm cuộc gọi hàm tương đối với PC

en: Protect parentheses in expressions
vi: Bảo vệ dấu ngoặc đơn trong biểu thức

en: Provide libraries for the simulator
vi: Cung cấp thư viện cho bộ mô phỏng

en: Put all local arrays on stack.
vi: Đặt toàn bộ các mảng nội bộ vào stack.

en: Put everything in the regular TOC
vi: Để tất cả vào TOC bình thường

en: Put jumps in call delay slots
vi: Để bước nhảy vào khe hàng đợi cuộc gọi

en: Put uninitialized constants in ROM (needs -membedded-data)
vi: Để vào ROM các hằng số chưa sơ khởi (yêu cầu -membedded-data)

en: REAL(KIND=10) is not available for -freal-4-real-10 option
vi: REAL(KIND=10) không phải là biến cho tùy chọn -freal-4-real-10

en: REAL(KIND=10) is not available for -freal-8-real-10 option
vi: REAL(KIND=10) không phải là biến cho tùy chọn -freal-8-real-10

en: REAL(KIND=10) is not available for -freal-8-real-16 option
vi: REAL(KIND=10) không phải là biến cho tùy chọn -freal-8-real-16

en: REAL(KIND=16) is not available for -freal-4-real-16 option
vi: REAL(KIND=16) không phải là biến cho tùy chọn -freal-4-real-16

en: REAL(KIND=4) is not available for -freal-8-real-4 option
vi: REAL(KIND=4) không phải là biến cho tùy chọn -freal-8-real-4

en: REAL(KIND=8) is not available for -freal-4-real-8 option
vi: REAL(KIND=8) không phải là biến cho tùy chọn -freal-4-real-8

en: RETURN_ADDRESS_OFFSET not supported
vi: RETURN_ADDRESS_OFFSET không được hỗ trợ

en: RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d
vi: kiểm tra RTL: cần  mã '%s' hoặc '%s', nhận '%s' trong %s, tại %s:%d

en: RTL check: expected code '%s', have '%s' in %s, at %s:%d
vi: kiểm tra RTL: cần  mã '%s', nhận '%s' trong %s, tại %s:%d

en: RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d
vi: kiểm tra RTL: cần elt %d kiểu '%c' hoặc '%c', nhận '%c' (rtx %s) trong %s, tại %s:%d

en: RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d
vi: kiểm tra RTL: cần elt %d kiểu '%c', nhận '%c' (rtx %s) trong %s, tại %s:%d

en: Reading specs from %s
vi: Đang đọc các đặc tả từ %s

en: Realign stack in prologue
vi: Xếp hàng lại đống trong đoạn mở đầu

en: Recognize built-in functions
vi: Chấp nhận các hàm dựng sẵn

en: Reduce the amount of reflection meta-data generated
vi: Giảm số lượng siêu dữ liệu phản chiếu được tạo ra

en: Relax branches
vi: Làm yếu các nhánh

en: Remove redundant membars
vi: Gỡ bỏ thanh vùng nhớ thừa

en: Removing '%s'
vi: Gỡ bỏ '%s'

en: Request IEEE-conformant math library routines (OSF/1)
vi: Yêu cầu hàm thư viện toán học thích hợp với IEEE (OSF/1)

en: Reserve space for outgoing arguments in the function prologue
vi: Trong đoạn mở đầu hàm thì dành riêng sức chứa cho đối số gửi ra

en: Restrict the use of hardware floating-point instructions to 32-bit operations
vi: Hạn chế sử dụng câu lệnh dấu chấm động phần cứng thành thao tác 32-bit

en: Return all structures in memory (AIX default)
vi: Trả lại tất cả các cấu trúc trong vùng nhớ (AIX mặc định)

en: Return floating-point results in ac0 (fr0 in Unix assembler syntax)
vi: Trả lại kết quả dấu chấm động theo ac0 (bằng fr0 trong cú pháp dịch mã số UNIX)

en: Return pointers in both a0 and d0
vi: Trả lại hàm trỏ trong cả hai a0 và d0

en: Return small structures in registers (SVR4 default)
vi: Trả lại các cấu trúc nhỏ trong thanh ghi (SVR4 mặc định)

en: Return values of functions in FPU registers
vi: Trả lại giá trị của hàm trong thanh ghi FPU (đơn vị điểm phù động)

en: Reuse r30 on a per function basis
vi: Sử dụng lại r30 một cách từng hàm

en: Runtime name.
vi: Tên lúc chạy.

en: SH2a does not support little-endian
vi: SH2a không hỗ trợ tình trạng về cuối nhỏ

en: SPE not supported in this target
vi: SPE không được hỗ trợ ở đích này

en: SSA corruption
vi: ngắt SSA

en: SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set
vi: SSA_NAME_OCCURS_IN_ABNORMAL_PHI cần được đặt

en: STAT variable
vi: biến STAT

en: Same as: -mep -mprolog-function
vi: Bằng: -mep -mprolog-function

en: Schedule code for given CPU
vi: Định thời mã cho CPU đưa ra

en: Schedule given CPU
vi: Định thời CPU đưa ra

en: Schedule the start and end of the procedure
vi: Định thời bắt đầu và kết thúc thủ tục

en: Section to put all const variables in (tiny, near, far) (no default)
vi: Phần vào đó cần để tất cả các giá trị bất biến có thể lập được (tiny, near, far) (không có giá trị mặc định)
    tiny		rất nhỏ
    near		gần
    far		xa

en: Select ABI calling convention
vi: Chọn quy ước gọi ABI

en: Select code model
vi: Chọn mô hình mã

en: Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment
vi: Chọn phân số của tần số tối đa lần thực hiện khối cơ bản trong hàm mà cũng quy định rằng khối cơ bản được xếp hàng

en: Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot
vi: Chọn phân số của tần số tối đa lần thực hiện khối cơ bản trong hàm mà cũng quy định rằng khối cơ bản cần phải được thấy là nóng

en: Select method for sdata handling
vi: Chọn phương pháp để quản lý sdata

en: Set 80387 floating-point precision to 32-bit
vi: Đặt độ chính xác dấu chấm động 80387 thành 32-bít

en: Set 80387 floating-point precision to 64-bit
vi: Đặt độ chính xác dấu chấm động 80387 thành 64-bít

en: Set 80387 floating-point precision to 80-bit
vi: Đặt độ chính xác dấu chấm động 80387 thành 80-bít

en: Set Windows defines
vi: Lập lời xác định Windows

en: Set default accessibility of module entities to PRIVATE.
vi: Lập thành PRIVATE (riêng) tình trạng truy cập của thực thể mô-đun.

en: Set name of main routine for the debugger
vi: Lập tên của hàm chính cho chương trình gỡ rối

en: Set name of output ALI file (internal switch)
vi: Đặt tên cho tập tin kết xuất ALI (chuyển nội bộ)

en: Set register to hold -1.
vi: Đặt thanh ghi giữ giá trị -1

en: Set sizeof(bool) to 1
vi: Lập kích cỡ biểu thức bun thành 1

en: Set start-address of data
vi: Lập địa chỉ bắt đầu của dữ liệu

en: Set start-address of the program
vi: Lập địa chỉ bắt đầu của chương trình

en: Set the PPC_EMB bit in the ELF flags header
vi: Lập bit PPC_EMB trong phần đầu cờ ELF

en: Set the cost of branches
vi: Lập giá của nhánh

en: Set the default double precision kind to an 8 byte wide type
vi: Lập loại độ chính xác đôi mặc định thành một loại có chiều rộng 8 byte

en: Set the default integer kind to an 8 byte wide type
vi: Lập loại số nguyên mặc định thành một loại có chiều rộng 8 byte

en: Set the default real kind to an 8 byte wide type
vi: Lập loại thật mặc định thành một loại có chiều rộng 8 byte

en: Set the max size of data eligible for the SDA area
vi: Lập kích cỡ tối đa của dữ liệu thích hợp với vùng SDA

en: Set the max size of data eligible for the TDA area
vi: Lập kích cỡ tối đa của dữ liệu thích hợp với vùng TDA

en: Set the max size of data eligible for the ZDA area
vi: Lập kích cỡ tối đa của dữ liệu thích hợp với vùng ZDA

en: Set the max. number of bytes which has to be left to stack size before a trap instruction is triggered
vi: Lập số tối đa các byte cần để cho kích cỡ đống trước khi gây ra một câu lệnh đặt bẫy

en: Set the maximum amount for a single stack increment operation
vi: Lập số lượng tối đa cho một thao tác lượng gia loại đống đơn

en: Set the source language version
vi: Lập phiên bản ngôn ngữ nguồn

en: Set the target CPU type
vi: Lập loại CPU đích

en: Set the target VM version
vi: Lập phiên bản VM đích

en: Setting spec %s to '%s'
vi: Đang lập đặc tả %s thành '%s'

en: Shorten address references during linking
vi: Cắt ngắn tham chiếu địa chỉ trong khi liên kết

en: Single-precision floating point unit
vi: Đơn vị điểm phù động chính xác đơn

en: Size (in KB) of software data cache
vi: Kích cỡ (theo KB) của vùng nhớ tạm dữ liệu loại phần mềm

en: Small data area: none, sdata, use
vi: Vùng dữ liệu nhỏ:
     • none	không có
     • sdata
     • use	sử dụng

en: Soft limit on number of memory insns per instruction group, giving lower priority to subsequent memory insns attempting to schedule in the same insn group. Frequently useful to prevent cache bank conflicts.  Default value is 1
vi: Giới hạn mềm về số các câu lệnh vùng nhớ mỗi nhóm câu lệnh, gán mức ưu tiên thấp hơn cho câu lệnh vùng nhớ theo sau mà thử định thời trong cùng một nhóm câu lệnh. Hữu ích để ngăn cản sự xung đột đối với nhóm vùng nhớ tạm. Giá trị mặc định là 1

en: Specifies the number of registers to reserve for interrupt handlers.
vi: Ghi rõ số các thanh ghi cần dành riêng cho bộ quản lý tín hiệu gián đoạn.

en: Specifies whether interrupt functions should save and restore the accumulator register.
vi: Ghi rõ nếu hàm gián đoạn nên lưu và phục hồi thanh ghi tích lũy hay không.

en: Specify CPU for code generation purposes
vi: Ghi rõ CPU cho mục đích tạo ra mã

en: Specify CPU for scheduling purposes
vi: Ghi rõ CPU cho mục đích định thời

en: Specify CPU for scheduling purposes.  Valid arguments are 700, 7100, 7100LC, 7200, 7300, and 8000
vi: Ghi rõ CPU cho mục đích định thời. Đối số hợp lệ là 700, 7100, 7100LC, 7200, 7300, và 8000

en: Specify UNIX standard for predefines and linking
vi: Ghi rõ tiêu chuẩn UNIX cho lời xác định sẵn và chức năng liên kết

en: Specify Xilinx FPU.
vi: Ghi rõ FPU loại Xilinx.

en: Specify alignment of structure fields default/natural
vi: Ghi rõ cách xếp hàng các trường cấu trúc: mặc định (default) hay tự nhiên (natural)

en: Specify an ABI
vi: Ghi rõ một ABI

en: Specify bit size of immediate TLS offsets
vi: Ghi rõ kích cỡ bit của hiệu số TLS lập tức

en: Specify cache flush function
vi: Ghi rõ hàm chuyển hết vùng nhớ tạm ra ngoài

en: Specify cache flush trap number
vi: Ghi rõ số thứ tự bẫy chuyển hết vùng nhớ tạm ra ngoài

en: Specify cost of branches (Default 20)
vi: Ghi rõ giá của nhánh (mặc định là 20)

en: Specify how to access the thread pointer
vi: Ghi rõ cách truy cập đến hàm trỏ mạch

en: Specify if floating point hardware should be used
vi: Ghi rõ có nên sử dụng phần cứng điểm phù động hay không

en: Specify main object for TPF-OS
vi: Ghi rõ đối tượng chính cho TFP-OS

en: Specify name for 32 bit signed division function
vi: Ghi rõ tên cho hàm chia đã ký 32-bit

en: Specify range of registers to make fixed
vi: Ghi rõ phạm vi các thanh ghi cần làm cho cố định

en: Specify scheduling priority for dispatch slot restricted insns
vi: Ghi rõ mức ưu tiên định thời cho câu lệnh bị hạn chế khe gửi đi

en: Specify that an external BLAS library should be used for matmul calls on large-size arrays
vi: Ghi rõ rằng có nên sử dụng một thư viện BLAS bên ngoài cho cuộc gọi matmul trên mạng có kích cỡ lớn

en: Specify that backslash in string introduces an escape character
vi: Ghi rõ rằng một dấu chéo ngược trong một chuỗi thì giới thiệu một ký tự thoát

en: Specify that no implicit typing is allowed, unless overridden by explicit IMPLICIT statements
vi: Ghi rõ rằng không cho phép tạo loại ngầm nào, nếu không bị ghi đè bởi câu lệnh THỰC CHẤT dứt khoát

en: Specify the __fp16 floating-point format
vi: Ghi rõ định dấu chấm động __fp16

en: Specify the minimum bit alignment of structures
vi: Ghi rõ sự xếp hàng bit tối thiểu của cấu trúc

en: Specify the name of the target CPU
vi: Ghi rõ tên của CPU đích

en: Specify the name of the target architecture
vi: Ghi rõ tên của kiến trúc đích

en: Specify the name of the target floating point hardware/format
vi: Ghi rõ tên của phần cứng / định dạng đích về điểm phù động

en: Specify the register to be used for PIC addressing
vi: Ghi rõ thanh ghi cần sử dụng để đặt địa chỉ PIC

en: Specify the target CPU
vi: Ghi rõ CPU đích

en: Specify the target RX cpu type.
vi: Ghi rõ loại CPU RX đích.

en: Specify where to find the compiled intrinsic modules
vi: Ghi rõ vị trí ở đó có các mô-đun thực chất đã biên dịch

en: Specify whether the byte access instructions should be used. Enabled by default.
vi: Ghi rõ có nên sử dụng các câu lệnh truy cập từng byte hay không. (Tùy chọn này được hiệu lực theo mặc định.)

en: Specify which post scheduling nop insertion scheme to apply
vi: Ghi rõ lược đồ chèn nop hậu định thời nào cần áp dụng

en: Specify which type of AE to target. This option sets the mul-type and byte-access.
vi: Ghi rõ có nên đặt mục đích là loại AE nào. Tuỳ chọn này cũng lập mul-type (đa loại) và byte-access (truy cập từng byte).

en: Specify which type of multiplication to use. Can be mem, mac or none.
vi: Ghi rõ có nên sử dụng cách nhân lên nào: mem, mac, hoặc none (không có).

en: Start expression in DO loop
vi: Biểu thức bắt đầu trong vòng lặp DO (làm)

en: Statically link the GNU Fortran helper library (libgfortran)
vi: Liên kết tĩnh thư viện bổ trợ Fortran của GNU (libgfortran)

en: Step expression in DO loop
vi: Biểu thức bước trong vòng lặp DO (làm)

en: Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is available
vi: Dừng tăng lên tiếp nếu xác xuất có cạnh tốt nhất vẫn nhỏ hơn ngưỡng này (theo phần trăm). Được sử dụng khi có sẵn sàng thông tin phản hồi từ hồ sơ

en: Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is not available
vi: Dừng tăng lên tiếp nếu xác xuất có cạnh tốt nhất vẫn nhỏ hơn ngưỡng này (theo phần trăm). Được sử dụng khi không có sẵn sàng thông tin phản hồi từ hồ sơ

en: Stop reverse growth if the reverse probability of best edge is less than this threshold (in percent)
vi: Dừng tăng lên ngược nếu xác xuất ngược có cạnh tốt nhất vẫn nhỏ hơn ngưỡng này (theo phần trăm)

en: Store doubles in 64 bits.
vi: Lưu đôi theo 64 bit.

en: Store function names in object code
vi: Lưu các tên hàm trong mã đối tượng

en: Stores doubles in 32 bits.  This is the default.
vi: Lưu đôi theo 32 bit. Đây là thiết lập mặc định.

en: Support 3DNow! built-in functions
vi: Hỗ trợ các hàm dựng sẵn 3DNow!

en: Support AES built-in functions and code generation
vi: Hỗ trợ các hàm dựng sẵn và chức năng tạo ra mã loại AES

en: Support Athlon 3Dnow! built-in functions
vi: Hỗ trợ các hàm dựng sẵn 3DNow! Athlon

en: Support FMA4 built-in functions and code generation
vi: Hỗ trợ các hàm dựng sẵn và chức năng tạo ra mã loại FMA4

en: Support LWP built-in functions and code generation
vi: Hỗ trợ các hàm dựng sẵn và chức năng tạo ra mã loại LWP

en: Support MMX and SSE built-in functions and code generation
vi: Hỗ trợ các hàm dựng sẵn và chức năng tạo ra mã loại MMX và SSE

en: Support MMX built-in functions
vi: Hỗ trợ các hàm dựng sẵn MMX

en: Support MMX, SSE and SSE2 built-in functions and code generation
vi: Hỗ trợ các hàm dựng sẵn và chức năng tạo ra mã loại MMX, SSE và SSE2

en: Support MMX, SSE, SSE2 and SSE3 built-in functions and code generation
vi: Hỗ trợ các hàm dựng sẵn và chức năng tạo ra mã loại MMX, SSE, SSE2 và SSE3

en: Support MMX, SSE, SSE2, SSE3 and SSE4A built-in functions and code generation
vi: Hỗ trợ các hàm dựng sẵn và chức năng tạo ra mã loại MMX, SSE, SSE2, SSE3 và SSE4A

en: Support MMX, SSE, SSE2, SSE3 and SSSE3 built-in functions and code generation
vi: Hỗ trợ các hàm dựng sẵn và chức năng tạo ra mã loại MMX, SSE, SSE2, SSE3 và SSSE3

en: Support MMX, SSE, SSE2, SSE3, SSSE3 and SSE4.1 built-in functions and code generation
vi: Hỗ trợ các hàm dựng sẵn và chức năng tạo ra mã loại MMX, SSE, SSE2, SSE3, SSSE3 và SSE4.1

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1 and SSE4.2 built-in functions and code generation
vi: Hỗ trợ các hàm dựng sẵn và chức năng tạo ra mã loại MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1 và SSE4.2

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2 and AVX built-in functions and code generation
vi: Hỗ trợ các hàm dựng sẵn và chức năng tạo ra mã loại MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2 và AVX

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and AVX2 built-in functions and code generation
vi: Hỗ trợ các hàm dựng sẵn và chức năng tạo ra mã loại MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX và AVX2

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and FMA built-in functions and code generation
vi: Hỗ trợ các hàm dựng sẵn và chức năng tạo ra mã loại MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX và FMA

en: Support PCLMUL built-in functions and code generation
vi: Hỗ trợ các hàm dựng sẵn và chức năng tạo ra mã loại PCLMUL

en: Support SCORE 7 ISA
vi: Hỗ trợ SCORE 7 ISA

en: Support SCORE 7D ISA
vi: Hỗ trợ SCORE 7D ISA

en: Support TLS segment larger than 64K
vi: Hỗ trợ đoạn TLS lớn hơn 64K

en: Support XOP built-in functions and code generation
vi: Hỗ trợ các hàm dựng sẵn và chức năng tạo ra mã loại XOP

en: Support calls between Thumb and ARM instruction sets
vi: Hỗ trợ cuộc gọi giữa các tập hợp câu lệnh loại Thumb và ARM

en: Support code generation of Advanced Bit Manipulation (ABM) instructions.
vi: Hỗ trợ chức năng tạo ra mã là câu lệnh ABM (thao tác bit cấp cao).

en: Support code generation of cmpxchg16b instruction.
vi: Hỗ trợ chức năng tạo ra mã là câu lệnh cmpxchg16b.

en: Support code generation of crc32 instruction.
vi: Hỗ trợ chức năng tạo ra mã là câu lệnh crc32.

en: Support code generation of movbe instruction.
vi: Hỗ trợ chức năng tạo ra mã là câu lệnh movbe.

en: Support code generation of popcnt instruction.
vi: Hỗ trợ chức năng tạo ra mã là câu lệnh popcnt.

en: Support code generation of sahf instruction in 64bit x86-64 code.
vi: Hỗ trợ chức năng tạo ra mã là câu lệnh sahf trong mã x86-64 64-bit.

en: Support legacy multi-threading
vi: Hỗ trợ chức năng đa luồng thừa tự

en: Support message passing with the Parallel Environment
vi: Hỗ trợ chức năng gửi thông điệp qua với Môi trường Song song (Parellel Environment)

en: Support more than 8192 GOT entries on ColdFire
vi: Hỗ trợ nhiều hơn 8192 mục nhập GOT trên ColdFire

en: Support multi-threading
vi: Hỗ trợ chức năng đa luồng

en: Support multiply accumulate instructions
vi: Hỗ trợ câu lệnh nhân-tích_lũy

en: Swap endianness for unformatted files
vi: Có tập tin chưa định dạng thì trao đổi tình trạng cuối

en: Switch on/off MIPS16 ASE on alternating functions for compiler testing
vi: Bật/tắt ASE MIPS16 trên các hàm qua lại, để kiểm tra chức năng của bộ dịch mã số

en: Symbol '%s' at %C is ambiguous
vi: Ký hiệu '%s' tại %C chưa rõ ràng

en: Synonym for -Wcomment
vi: Từ đồng nghĩa với -Wcomment

en: Synonym of -gnatk8
vi: Từ đồng nghĩa với -gnatk8

en: Syntax error in expression at %C
vi: Gặp lỗi cú pháp trong biểu thức tại %C

en: TLS dialect to use:
vi: TLS dialect được dùng:

en: Taken at least once:%s of %d
vi: Đã lấy ít nhất một lần: %s trên %d

en: Target DFLOAT double precision code
vi: Đặt mục đích là mã chính xác đôi DFLOAT

en: Target has split I&D
vi: Đích có I&D bị chia ra

en: Target the AM33 processor
vi: Đặt mục đích là bộ xử lý AM33

en: Target the AM33/2.0 processor
vi: Đặt mục đích là bộ xử lý AM33/2.0

en: Target: %s
vi: Đích: %s

en: The --param option recognizes the following as parameters
vi: Tuỳ chọn --param nhận ra những điều theo đây như là tham số

en: The earliest MacOS X version on which this program will run
vi: Phiên bản Mac OSX cũ nhất trên đó chương trình này chạy được

en: The following options are language-independent
vi: Theo đây có những tuỳ chọn không phụ thuộc vào ngôn ngữ

en: The following options are language-related
vi: Theo đây có những tuỳ chọn liên quan đến ngôn ngữ

en: The following options are not documented
vi: Theo đây có những tuỳ chọn không có tài liệu diễn tả

en: The following options are specific to just the language
vi: Theo đây có những tuỳ chọn đặc trưng cho chỉ ngôn ngữ

en: The following options are supported by the language
vi: Theo đây có những tuỳ chọn được hỗ trợ bởi ngôn ngữ

en: The following options are target specific
vi: Theo đây có những tuỳ chọn đặc trưng cho đích

en: The following options control compiler warning messages
vi: Theo đây có những tuỳ chọn điều khiển các thông điệp cảnh báo của bộ biên dịch

en: The following options control optimizations
vi: Theo đây có những tuỳ chọn điều khiển việc tối ưu hoá

en: The following options take joined arguments
vi: Theo đây có những tuỳ chọn chấp nhận các đối số nối lại

en: The following options take separate arguments
vi: Theo đây có những tuỳ chọn chấp nhận các đối số riêng

en: The lower bound for a buffer to be considered for stack smashing protection
vi: Biên giới dưới của một vùng đệm được tính để bảo vệ chống đống bị đập tan ra

en: The maximum amount of memory to be allocated by GCSE
vi: Vùng nhớ tối đa cho GCSE cấp phát

en: The maximum conflict delay for an insn to be considered for speculative motion
vi: Khoảng đợi xung đột tối đa trước khi một lệnh được tính để di chuyển một cách lý thuyết có tính chất suy đoán

en: The maximum depth of a loop nest we completely peel
vi: Độ sâu tối đa của một bộ vòng lặp xếp lồng vào nhau được chúng ta lột hoàn toàn

en: The maximum depth of recursive inlining for inline functions
vi: Độ sâu tối đa của việc chèn vào trực tiếp một cách đệ quy cho hàm trực tiếp

en: The maximum depth of recursive inlining for non-inline functions
vi: Độ sâu tối đa của việc chèn vào trực tiếp một cách đệ quy cho hàm không phải trực tiếp

en: The maximum expansion factor when copying basic blocks
vi: Hệ số mở rộng tối đa khi sao chép khối cơ bản

en: The maximum instructions CSE process before flushing
vi: Số tối đa các lệnh được CSE xử lý trước khi chuyển hết ra ngoài

en: The maximum length of path considered in cse
vi: Chiều dài tối đa của đường dẫn được tính trong CSE

en: The maximum length of scheduling's pending operations list
vi: Chiều dài tối đa của danh sách các thao tác bị hoãn của tiến trình định thời

en: The maximum memory locations recorded by cselib
vi: Số tối đa các vị trí bộ nhớ được thư viện cselib ghi lưu

en: The maximum number of RTL nodes that can be recorded as combiner's last value
vi: Số tối đa các nút RTL có thể ghi lưu như là giá trị cuối cùng của bộ kết hợp

en: The maximum number of blocks in a region to be considered for interblock scheduling
vi: Số tối đa các khối mỗi vùng cần tính để định thời giữa các khối

en: The maximum number of incoming edges to consider for crossjumping
vi: Số tối đa các cạnh gửi đến cần tính để nhảy chéo

en: The maximum number of insns in a region to be considered for interblock scheduling
vi: Số tối đa các lệnh mỗi vùng cần tính để định thời giữa các khối

en: The maximum number of insns of a completely peeled loop
vi: Số tối đa các lệnh của một vòng lặp được lột hoàn toàn

en: The maximum number of insns of a peeled loop
vi: Số tối đa các lệnh của một vòng lặp được lột

en: The maximum number of insns of a peeled loop that rolls only once
vi: Số tối đa các lệnh của một vòng lặp được lột mà cuộn chỉ một lần

en: The maximum number of insns of an unswitched loop
vi: Số tối đa các lệnh của một vòng lặp chưa chuyển đổi nhánh

en: The maximum number of insns to duplicate when unfactoring computed gotos
vi: Số tối đa các lệnh cần nhân đôi khi gỡ bỏ hệ số khỏi goto đã tính

en: The maximum number of instructions in a single function eligible for inlining
vi: Số tối đa các lệnh trong một lệnh riêng lẻ mà thích hợp với việc chèn vào trực tiếp

en: The maximum number of instructions inline function can grow to via recursive inlining
vi: Số tối đa các lệnh đến đó hàm trực tiếp có thể tới bằng cách chèn vào trực tiếp một cách đệ quy

en: The maximum number of instructions non-inline function can grow to via recursive inlining
vi: Số tối đa các lệnh đến đó hàm không phải trực tiếp có thể tới bằng cách chèn vào trực tiếp một cách đệ quy

en: The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass
vi: Số tối đa các câu lệnh sẵn sàng đưa ra cần được tính bởi bộ định thời trong lần đầu tiên chạy thủ tục định thời

en: The maximum number of instructions to consider to fill a delay slot
vi: Số tối đa các lệnh cần tính để điền vào một khe đợi

en: The maximum number of instructions to consider to find accurate live register information
vi: Số tối đa các lệnh cần tính để tìm thông tin thanh ghi vẫn hiện thời và chính xác

en: The maximum number of instructions to consider to unroll in a loop
vi: Số tối đa các lệnh cần tính nên bỏ cuộn trong một vòng lặp

en: The maximum number of instructions to consider to unroll in a loop on average
vi: Số tối đa các lệnh trung bình cần tính nên bỏ cuộn trong một vòng lặp

en: The maximum number of instructions to search backward when looking for equivalent reload
vi: Số tối đa các lệnh cần quét ngược khi tìm một sự nạp lại tương đương

en: The maximum number of instructions when automatically inlining
vi: Số tối đa các lệnh khi tự động chèn vào trực tiếp

en: The maximum number of iterations through CFG to extend regions
vi: Số tối đa các lần lặp lại qua CFG để kéo dài vùng

en: The maximum number of loop iterations we predict statically
vi: Số tối đa các lần lặp lại vòng lặp dự đoán một cách tĩnh

en: The maximum number of nested indirect inlining performed by early inliner
vi: Số tối đa các lần chèn vào trực tiếp loại gián tiếp lồng nhau được làm bởi bộ chèn vào trực tiếp sớm

en: The maximum number of peelings of a single loop
vi: Số tối đa các lần lột một vòng lặp riêng lẻ

en: The maximum number of peelings of a single loop that is peeled completely
vi: Số tối đa các lần lột một vòng lặp riêng lẻ được lột hoàn toàn

en: The maximum number of unrollings of a single loop
vi: Số tối đa các lần bỏ cuộn một vòng lặp riêng lẻ

en: The maximum number of unswitchings in a single loop
vi: Số tối đa các lần hủy chuyển đổi nhánh trong một vòng lặp riêng lẻ

en: The maximum ratio between array size and switch branches for a switch conversion to take place
vi: Tỷ lệ tối đa giữa kích cỡ mảng và các nhánh chuyển đổi để chuyển đổi nhánh

en: The maximum size of the lookahead window of selective scheduling
vi: Kích cỡ tối đa của cửa sổ nhìn trước của việc định thời lựa chọn

en: The minimal probability of speculation success (in percents), so that speculative insn will be scheduled.
vi: Xác xuất tối thiểu (theo phần trăm) có suy đoán đúng, để định thời lệnh thuộc lý thuyết có tính chất suy đoán

en: The minimum UID to be used for a nondebug insn
vi: UID tối thiểu cần sử dụng cho một lệnh không gỡ rối

en: The minimum cost of an expensive expression in the loop invariant motion
vi: Giá tối thiểu của một biểu tượng giá rất cao trong sự chuyển động bất biến vòng lặp

en: The minimum number of matching instructions to consider for crossjumping
vi: Số tối thiểu các lệnh tương ứng cần tính để nhảy chéo

en: The minimum probability of reaching a source block for interblock speculative scheduling
vi: Xác xuất tối thiểu có thể tới một khối nguồn để định thời giữa các khối một cách lý thuyết có tính chất suy đoán

en: The number of cycles the swing modulo scheduler considers when checking conflicts using DFA
vi: Số các chu kỳ được bộ định thời mô-đu-lô swing tính khi kiểm tra sự xung đột bằng DFA

en: The number of insns executed before prefetch is completed
vi: Số các lệnh được thực hiện trước khi hoàn tất quá trình lấy sẵn (prefetch)

en: The number of prefetches that can run at the same time
vi: Số các quá trình lấy sẵn có thể chạy đồng thời

en: The number of registers in each class kept unused by loop invariant motion
vi: Số các thanh ghi mỗi hạng còn lại chưa dùng do chuyển động bất biến vòng lặp

en: The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available
vi: Phần trăm hàm (tăng cấp theo tần số thực hiện) mà phải được bao quát bởi việc tạo vết. Được sử dụng khi có sẵn sàng thông tin phản hồi từ hồ sơ

en: The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is not available
vi: Phần trăm hàm (tăng cấp theo tần số thực hiện) mà phải được bao quát bởi việc tạo vết. Được sử dụng khi không có sẵn sàng thông tin phản hồi từ hồ sơ

en: The resolution file
vi: Tập tin phân giải

en: The size of L1 cache
vi: Kích cỡ của vùng nhớ tạm cấp 1

en: The size of L1 cache line
vi: Kích cỡ của đường vùng nhớ tạm cấp 1

en: The size of L2 cache
vi: Kích cỡ của vùng nhớ tạm cấp 2

en: The size of function body to be considered large
vi: Kích cỡ thân hàm cần thấy là lớn

en: The size of stack frame to be considered large
vi: Kích cỡ khung đống nên thấy là lớn

en: The size of translation unit to be considered large
vi: Kích cỡ đơn vị thông dịch cần thấy là lớn

en: The threshold ratio for performing partial redundancy elimination after reload
vi: Tỷ lệ ngững để thực hiện việc khử bộ phận sự thửa sau khi nạp lại

en: The threshold ratio of critical edges execution count that permit performing redundancy elimination after reload
vi: Tỷ lệ ngững của số đếm lần thực hiện cạnh tới hạn cũng cho phép thực hiện việc khử sự thửa sau khi nạp lại

en: The upper bound for sharing integer constants
vi: Biên giới trên để chia sẻ hằng số nguyên

en: This is free software; see the source for copying conditions.
    There is NO warranty; not even for MERCHANTABILITY or 
    FITNESS FOR A PARTICULAR PURPOSE.
vi: Đây là phần mềm tự do: bạn có quyền sửa đổi và phát hành lại nó.
    KHÔNG CÓ BẢO HÀNH GÌ CẢ, THẬM CHÍ KHÔNG CÓ BẢO ĐẢM ĐƯỢC NGỤ Ý
    KHẢ NĂNG BÁN HAY KHẢ NĂNG LÀM ĐƯỢC VIỆC DỨT KHOÁT.

en: This is free software; see the source for copying conditions.  There is NO
    warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
vi: Đây là phần mềm tự do; hãy xem mã nguồn để tìm thấy điều kiện sao chép.
    KHÔNG CÓ BẢO HÀNH GÌ CẢ, THẬM CHÍ KHÔNG CÓ BẢO ĐẢM ĐƯỢC NGỤ Ý
    KHẢ NĂNG BÁN HAY KHẢ NĂNG LÀM ĐƯỢC VIỆC DỨT KHOÁT.

en: This switch is deprecated; use -Werror=implicit-function-declaration instead
vi: Cái chuyển này bị phản đối: hãy thay thế bằng -Werror=implicit-function-declaration

en: This switch lacks documentation
vi: Cái chuyển này còn thiếu tài liệu hướng dẫn

en: Thread model: %s
vi: Mô hình tuyến trình: %s

en: Thumb: Assume function pointers may go to non-Thumb aware code
vi: Thumb: Giả sử là hàm trỏ có thể trở tới mã không phải tùy theo Thumb

en: Thumb: Assume non-static functions may be called from ARM code
vi: Thumb: Giả sử là hàm không phải tĩnh có thể được gọi từ mã ARM

en: Thumb: Generate (leaf) stack frames even if not needed
vi: Thumb: Tạo ra khung đống (loại lá) ngay cả khi không cần thiết

en: Thumb: Generate (non-leaf) stack frames even if not needed
vi: Thumb: Tạo ra khung đống (không phải loại lá) ngay cả khi không cần thiết

en: Together with -fpic and -fPIC, do not use GOTPLT references
vi: Đừng sử dụng tham chiếu GOTPLT cùng với -fpic hoặc -fPIC

en: Trap on integer divide by zero
vi: Bẫy khi số nguyên chia cho số không

en: Treat lines with 'D' in column one as comments
vi: Thấy dòng có chữ 'D' trong cột đầu tiên là ghi chú

en: Treat missing header files as generated files
vi: Thấy tập tin phần đầu còn thiếu là tập tin được tạo ra

en: Try 'jcf-dump --help' for more information.
vi: Hãy thử chạy câu lệnh trợ giúp 'jcf-dump --help' để xem thêm thông tin.

en: Try running '%s' in the shell to raise its limit.
vi: Hãy thử chạy '%s' trong trình bao để tăng giới hạn.

en: Try to allow the linker to turn PIC calls into direct calls
vi: Thử cho phép bộ liên kết chuyển đổi cuộc gọi PIC sang cuộc gọi trực tiếp

en: Try to lay out derived types as compactly as possible
vi: Thử bố trí các loại có hướng một cách tóm gọn nhất có thể

en: Tune code for the given processor
vi: Điều chỉnh mã cho bộ xử lý đưa ra

en: Tune expected memory latency
vi: Điều chỉnh độ ngấm ngầm vùng nhớ mong đợi

en: Tune for the specified target CPU or architecture
vi: Điều chỉnh cho CPU hay kiến trúc đưa ra

en: Unequal character lengths (%ld/%ld) in %s
vi: %3$s chứa các chiều dài ký tự khác nhau (%1$ld/%2$ld)

en: Unexpected EOF
vi: Gặp kết thúc tập tin bất thường

en: Unexpected element '%c' in format string at %L
vi: Gặp yếu tố bất thường '%c' trong chuỗi định dạng tại %L

en: Unexpected end of format string
vi: Gặp kết thức chuỗi định dạng bất thường

en: Unexpected end of module
vi: Gặp kết thức mô-đun bất thường

en: Unit number in I/O statement too large
vi: Câu lệnh V/R chứa con số đơn vị quá lớn

en: Unit number in I/O statement too small
vi: Câu lệnh V/R chứa con số đơn vị quá nhỏ

en: Unknown mode in print_operand (CONST_DOUBLE) :
vi: Không rõ chế độ trong print_operand (CONST_DOUBLE) :

en: Unknown operator '%s' at %%L
vi: Không rõ toán tử '%s' tại %%L

en: Usage: %s [OPTIONS]... CLASSNAMEmain [OUTFILE]
vi: Sử dụng: %s [TÙY_CHỌN]... TÊN_HẠNGmain [TỆP_XUẤT]

en: Usage: %s [options] file...
vi: Sử dụng: %s [tuỳ_chọn] tệp...

en: Usage: gcov [OPTION]... SOURCE|OBJ...
vi: Sử dụng: gcov [TÙY_CHỌN]... TẬP_TIN_NGUỒN|OBJ...

en: Usage: jcf-dump [OPTION]... CLASS...
vi: Sử dụng: jcf-dump [TÙY_CHỌN]... HẠNG...

en: Use "-Wa,OPTION" to pass "OPTION" to the assembler.
vi: Hãy sử dụng "-Wl,TÙY_CHỌN" để gửi tuỳ chọn đó cho chương trình dịch mã số.

en: Use "-Wl,OPTION" to pass "OPTION" to the linker.
vi: Hãy sử dụng "-Wl,TÙY_CHỌN" để gửi tuỳ chọn đó cho bộ liên kết.

en: Use -G for data that is not defined by the current object
vi: Sử dụng -G cho dữ liệu không phải được xác định bởi đối tượng hiện thời

en: Use -G for object-local data
vi: Sử dụng -G cho dữ liệu cục bộ với đối tượng

en: Use 128-bit long double
vi: Sử dụng đôi dài 128-bit

en: Use 16 bit int
vi: Sử dụng số nguyên 16-bit

en: Use 32 bit float
vi: Sử dụng điểm phù động 32-bit

en: Use 32 bit int
vi: Sử dụng số nguyên 32-bit

en: Use 32-bit ABI
vi: Sử dụng ABI 32-bit

en: Use 32-bit floating-point registers
vi: Sử dụng thanh ghi dấu chấm động 32-bit

en: Use 32-bit general registers
vi: Sử dụng thanh ghi chung 32-bit

en: Use 4 byte entries in switch tables
vi: Sử dụng mục nhập 4-byte trong bảng cái chuyển

en: Use 4 media accumulators
vi: Sử dụng 4 bộ tích luỹ môi giới

en: Use 4xx half-word multiply instructions
vi: Sử dụng câu lệnh nhân nửa từ 4xx

en: Use 4xx string-search dlmzb instruction
vi: Sử dụng câu lệnh dlmzb tìm kiếm chuỗi 4xx

en: Use 64 FPRs
vi: Sử dụng 64 FPR

en: Use 64 GPRs
vi: Sử dụng 64 GPR

en: Use 64 bit float
vi: Sử dụng điểm phù động 64-bit

en: Use 64-bit ABI
vi: Sử dụng ABI 64-bit

en: Use 64-bit floating-point registers
vi: Sử dụng thanh ghi dấu chấm động 64-bit

en: Use 64-bit general registers
vi: Sử dụng thanh ghi chung 64-bit

en: Use 64-bit long double
vi: Sử dụng đôi dài 64-bit

en: Use 8 media accumulators
vi: Sử dụng 8 bộ tích luỹ môi giới

en: Use ABI reserved registers
vi: Sử dụng thanh ghi dành riêng cho ABI

en: Use AltiVec instructions
vi: Sử dụng câu lệnh AltiVec

en: Use Bionic C library
vi: Sử dụng thư viện C của Bionic

en: Use Branch Likely instructions, overriding the architecture default
vi: Sử dụng câu lệnh rất có thể thích hợp với nhanh (Branch Likely), thì ghi đè lên giá trị mặc định của kiến trúc đó

en: Use CONST16 instruction to load constants
vi: Sử dụng câu lệnh CONST16 để nạp các hằng số

en: Use EABI
vi: Sử dụng EABI

en: Use GNU C library
vi: Sử dụng thư viện C của GNU

en: Use GP relative sdata/sbss sections
vi: Sử dụng phần sdata/sbss tương đối với GP

en: Use GP-relative addressing to access small data
vi: Sử dụng chức năng đặt địa chỉ tương đối với GP để truy cập đến dữ liệu nhỏ

en: Use H8/300 alignment rules
vi: Sử dụng các quy tắc xếp hàng H8/300

en: Use IEEE math for fp comparisons
vi: Sử dụng toán học IEEE cho phép so sánh loại điểm phù động

en: Use MIPS-3D instructions
vi: Sử dụng câu lệnh MIPS-3D

en: Use MIPS-DSP REV 2 instructions
vi: Sử dụng câu lệnh MIPS-DSP REV 2

en: Use MIPS-DSP instructions
vi: Sử dụng câu lệnh MIPS-DSP

en: Use Mingw-specific thread support
vi: Sử dụng hỗ trợ nhánh đặc trưng cho Mingw

en: Use Neon quad-word (rather than double-word) registers for vectorization
vi: Sử dụng thanh ghi từ bốn (thay cho từ đôi) Neon để véc-tơ hoá

en: Use NewABI-style %reloc() assembly operators
vi: Sử dụng toán tử dịch mã số %reloc() kiểu NewABI

en: Use P-mnemonics for branches statically predicted as taken
vi: Sử dụng phím gới nhớ P cho nhánh dự đoán tĩnh là không còn sẵn sàng

en: Use PMC-style 'mad' instructions
vi: Sử dụng câu lệnh mad loại PMC

en: Use PowerPC General Purpose group optional instructions
vi: Sử dụng các câu lệnh tùy chọn của nhóm General Purpose (thường dụng) PowerPC

en: Use PowerPC Graphics group optional instructions
vi: Sử dụng các câu lệnh tùy chọn của nhóm Graphics (đồ họa) PowerPC

en: Use PowerPC V2.01 single field mfcr instruction
vi: Sử dụng câu lệnh mfcr trường đơn PowerPC V2.01

en: Use PowerPC V2.02 floating point rounding instructions
vi: Sử dụng câu lệnh làm tròn loại điểm phù động PowerPC V2.02

en: Use PowerPC V2.02 popcntb instruction
vi: Sử dụng câu lệnh popcntb PowerPC V2.02

en: Use PowerPC V2.05 compare bytes instruction
vi: Sử dụng câu lệnh so sánh các byte PowerPC V2.05

en: Use PowerPC V2.06 popcntd instruction
vi: Sử dụng câu lệnh popcntd PowerPC V2.06

en: Use PowerPC-64 instruction set
vi: Sử dụng tập hợp câu lệnh PowerPC-64

en: Use ROM instead of RAM
vi: Sử dụng ROM thay cho RAM

en: Use SSE register passing conventions for SF and DF mode
vi: Sử dụng quy ước gửi qua thanh ghi loại SSE cho chế độ SF và DF

en: Use SmartMIPS instructions
vi: Sử dụng câu lệnh SmartMIPS

en: Use UNIX assembler syntax
vi: Sử dụng cú pháp dịch mã số UNIX

en: Use VAX fp
vi: Sử dụng điểm phù động loại VAX

en: Use VAXC structure conventions
vi: Sử dụng quy ước cấu trúc VAXC

en: Use a 32-bit long type
vi: Sử dụng một loại dài 32-bit

en: Use a 4-byte record marker for unformatted files
vi: Có tập tin chưa định dạng thì sử dụng một ký hiệu đánh dấu mục ghi loại 4 byte

en: Use a 64-bit long type
vi: Sử dụng một loại dài 64-bit

en: Use addresses that allocate global registers
vi: Sử dụng địa chỉ mà cấp phát thanh ghi toàn cục

en: Use alternate register names
vi: Sử dụng tên thanh ghi xen kẽ

en: Use an 8-bit 'int' type
vi: Sử dụng một loại số nguyên 8-bit

en: Use an 8-byte record marker for unformatted files
vi: Có tập tin chưa định dạng thì sử dụng một ký hiệu đánh dấu mục ghi loại 8 byte

en: Use arbitrary sized immediates in bit operations
vi: Trong thao tác bit thì sử dụng điều lập tức có kích cỡ tùy ý

en: Use big-endian byte order
vi: Sử dụng thứ tự byte về cuối lớn

en: Use big-endian format for unformatted files
vi: Có tập tin chưa định dạng thì sử dụng định dạng về cuối lớn

en: Use branch-and-break sequences to check for integer divide by zero
vi: Sử dụng dãy tạo-nhánh-và-ngắt (branch-and-break) để kiểm tra có số nguyên chia cho số không

en: Use bras for executable < 64k
vi: Sử dụng BRAS cho tập tin thực thị < 64k

en: Use call-clobbered registers for parameters and return value
vi: Sử dụng thanh ghi bị cuộc gọi ghi đè cho tham số và giá trị trả lại

en: Use control speculation
vi: Sử dụng phép đầu cơ loại điều khiển

en: Use data speculation after reload
vi: Sử dụng phép đầu cơ loại dữ liệu sau khi nạp lại

en: Use data speculation before reload
vi: Sử dụng phép đầu cơ loại dữ liệu trước khi nạp lại

en: Use decimal floating point instructions
vi: Sử dụng câu lệnh loại điểm phù động thập phân

en: Use default method for sdata handling
vi: Sử dụng phương pháp mặc định để quản lý sdata

en: Use different calling convention using 'rtd'
vi: Sử dụng một quy ước gọi khác bằng 'rtd'

en: Use direct references against %gs when accessing tls data
vi: Sử dụng tham chiếu trực tiếp đối với %gs khi truy cập đến dữ liệu của nó

en: Use epsilon-respecting floating point compare instructions
vi: Sử dụng câu lệnh so sánh loại điểm phù động tùy theo épxilông

en: Use extended PowerPC V2.05 move floating point to/from GPR instructions
vi: Sử dụng câu lệnh dời điểm phù động đến/từ GPR PowerPC V2.05 mở rộng

en: Use f2c calling convention
vi: Sử dụng quy ước gọi f2c

en: Use features of and schedule code for given CPU
vi: Sử dụng các tính năng của CPU đưa ra, và định thời mã cho CPU đó

en: Use features of and schedule given CPU
vi: Sử dụng các tính năng của CPU đưa ra, và định thời CPU đó

en: Use fp double instructions
vi: Sử dụng câu lệnh đôi loại điểm phù động

en: Use fp registers
vi: Sử dụng thanh ghi loại điểm phù động

en: Use given SPARC-V9 code model
vi: Sử dụng mẫu mã SPARC-V9 đưa ra

en: Use given assembler dialect
vi: Sử dụng phương ngôn dịch mã số đưa ra

en: Use given thread-local storage dialect
vi: Sử dụng phương ngôn lưu theo nhánh cục bộ

en: Use given x86-64 code model
vi: Sử dụng mẫu mã x86-64 đưa ra

en: Use hardware FP
vi: Sử dụng điểm phù động loại phần cứng

en: Use hardware division instructions on ColdFire
vi: Sử dụng câu lệnh chia phần cứng trong ColdFire

en: Use hardware floating point
vi: Sử dụng điểm phù động loại phần cứng

en: Use hardware fp
vi: Sử dụng điểm phù động loại phần cứng

en: Use hardware quad FP instructions
vi: Sử dụng câu lệnh loại bốn điểm phù động phần cứng

en: Use in block control speculation
vi: Sử dụng phép đầu cơ loại điều khiển theo khối

en: Use in block data speculation after reload
vi: Sử dụng phép đầu cơ loại dữ liệu theo khối sau khi nạp lại

en: Use in block data speculation before reload
vi: Sử dụng phép đầu cơ loại dữ liệu theo khối trước khi nạp lại

en: Use in/loc/out register names
vi: Sử dụng tên thanh ghi loại in/loc/out

en: Use indirect CALLXn instructions for large programs
vi: Sử dụng câu lệnh CALLXn gián tiếp cho chương trình lớn

en: Use indirect calls
vi: Sử dụng cuộc gọi gián tiếp

en: Use inline patterns for copying memory
vi: Sử dụng mẫu được chèn vào trực tiếp để sao chép vùng nhớ

en: Use little-endian byte order
vi: Sử dụng thứ tự byte về cuối nhỏ

en: Use little-endian format for unformatted files
vi: Có tập tin chưa định dạng thì sử dụng định dạng về cuối nhỏ

en: Use ll, sc and sync instructions
vi: Sử dụng câu lệnh ll, sc và sync

en: Use media instructions
vi: Sử dụng câu lệnh môi giới

en: Use multiply add/subtract instructions
vi: Sử dụng nhiều câu lệnh nhân_cộng/trừ

en: Use native (MS) bitfield layout
vi: Sử dụng bố trí trường bit sở hữu (MS)

en: Use native format for unformatted files
vi: Có tập tin chưa định dạng thì sử dụng định dạng sở hữu

en: Use new adddi3/subdi3 patterns
vi: Sử dụng các mẫu adddi3/subdi3 mới

en: Use normal calling convention
vi: Sử dụng quy ước gọi thông thường

en: Use offset tables for virtual method calls
vi: Sử dụng bảng hiệu số cho cuộc gọi phương pháp ảo

en: Use only one TOC entry per procedure
vi: Sử dụng chỉ một mục nhập TOC từng thủ tục

en: Use packed stack layout
vi: Sử dụng bố trí đống đóng gói

en: Use paired-single floating-point instructions
vi: Sử dụng câu lệnh dấu chấm động đôi-đơn

en: Use portable calling conventions
vi: Sử dụng quy ước gọi di động

en: Use push instructions to save outgoing arguments
vi: Sử dụng câu lệnh đẩy để lưu các đối số gửi đi

en: Use red-zone in the x86-64 code
vi: Sử dụng vùng màu đỏ trong mã x86-64

en: Use register stack for parameters and return value
vi: Sử dụng đống thanh ghi cho tham số và giá trị trả lại

en: Use registers for argument passing
vi: Sử dụng thanh ghi để gửi đối số qua

en: Use registers r2 and r5
vi: Sử dụng những thanh ghi r2 và r5

en: Use sdram version of runtime
vi: Sử dụng phiên bản sdram của thời gian chạy

en: Use shared libraries
vi: Sử dụng thư viện dùng chung

en: Use simple data speculation check
vi: Sử dụng hàm kiểm tra phép đầu cơ loại dữ liệu đơn giản

en: Use simple data speculation check for control speculation
vi: Sử dụng hàm kiểm tra phép đầu cơ loại dữ liệu đơn giản để đầu cơ về điều khiển

en: Use simulator runtime
vi: Sử dụng thời gian chạy của bộ mô phỏng

en: Use simulator runtime without vectors
vi: Sử dụng thời gian chạy của bộ mô phỏng mà không có véc-tơ

en: Use software floating point
vi: Sử dụng điểm phù động loại phần mềm

en: Use stack bias
vi: Sử dụng khuynh hướng về đống

en: Use standard main function as entry for startup
vi: Sử dụng hàm chính tiêu chuẩn làm điểm vào để khởi chạy

en: Use structs on stronger alignment for double-word copies
vi: Sử dụng cấu trúc khi xếp hàng mạnh hơn các bản sao từ đôi

en: Use stubs for function prologues
vi: Sử dụng mẩu cho đoạn mở đầu hàm

en: Use subroutines for function prologues and epilogues
vi: Sử dụng chương trình con cho đoạn mở/đóng hàm

en: Use synci instruction to invalidate i-cache
vi: Sử dụng câu lệnh synci để làm mất hiệu lực i-cache

en: Use the Cray Pointer extension
vi: Sử dụng phần mở rộng hàm trỏ Cray Pointer

en: Use the DEC assembler syntax
vi: Sử dụng cú pháp dịch mã số DEC

en: Use the GNU extension to the PE format for aligned common data
vi: Sử dụng phần mở rộng GNU tới định dạng PE cho dữ liệu chung xếp hàng

en: Use the bit-field instructions
vi: Sử dụng câu lệnh loại trường-bit

en: Use the divide instruction
vi: Sử dụng câu lệnh chia

en: Use the most feature-enabling options allowed by other options
vi: Sử dụng những tuỳ chọn hiệu lực nhiều tính năng nhất tùy theo giới hạn của tuỳ chọn khác

en: Use the simulator runtime.
vi: Sử dụng thời gian chạy của bộ mô phỏng.

en: Use trap instructions to check for integer divide by zero
vi: Sử dụng câu lệnh bẫy để kiểm tra có số nguyên chia cho số không

en: Use uClibc C library
vi: Sử dụng thư viện uClibc

en: Use unicode startup and define UNICODE macro
vi: Sử dụng hàm khởi chạy Unicode và xác định vĩ lệnh UNICODE

en: Use vector/scalar (VSX) instructions
vi: Sử dụng câu lệnh véc-tơ/vô_hướng (VSX)

en: Use zero-extending memory loads, not sign-extending ones
vi: Sử dụng việc nạp vùng nhớ loại mở rộng số không, không phải việc mở rộng ký hiệu

en: Using built-in specs.
vi: Đang sử dụng các đặc tả dựng sẵn.

en: VOIDmode on an output
vi: Chế độ VOIDmode trên một đầu ra

en: Valid arguments for the -msdata= option
vi: Đối số hợp lệ cho tùy chọn -msdata=

en: Valid arguments to -malign-:
vi: Đối số hợp lệ cho -malign-:

en: Valid arguments to -mcode-readable=:
vi: Đối số hợp lệ cho -mcode-readable=:

en: Valid arguments to -mfloat-gprs=:
vi: Đối số hợp lệ cho -mfloat-gprs=:

en: Valid arguments to -mfpmath=:
vi: Đối số hợp lệ cho -mfpmath=:

en: Valid arguments to -mr10k-cache-barrier=:
vi: Đối số hợp lệ cho -mr10k-cache-barrier=:

en: Valid arguments to -mstringop-strategy=:
vi: Đối số hợp lệ cho -mstringop-strategy=:

en: Valid arguments to -mtp=:
vi: Đối số hợp lệ cho -mtp=:

en: Variables this size and smaller go in the based section. (default 0)
vi: Giá trị có thể lập được có kích cỡ đến số này thì nằm trong phần based (dựa vào). (mặc định là 0)

en: Variables this size and smaller go in the tiny section. (default 4)
vi: Giá trị có thể lập được có kích cỡ đến số này thì nằm trong phần tiny (rất nhỏ). (mặc định là 4)

en: Vector library ABI to use
vi: ABI thư viện véc-tơ cần sử dụng

en: Warn about "extern" declarations not at file scope
vi: Cảnh báo về lời tuyên bố 'extern' (bên ngoài) ở ngoại phạm vi tập tin

en: Warn about "suspicious" constructs
vi: Cảnh báo về cấu trúc "đáng ngờ"

en: Warn about C constructs that are not in the common subset of C and C++
vi: Cảnh báo về cấu trúc C không nằm trong tập hợp phụ chung của C và C++

en: Warn about C++ constructs whose meaning differs between ISO C++ 1998 and ISO C++ 2011
vi: Cảnh báo về cấu trúc C++ mà nó có nghĩa khác nhau giữa ISO C++ 1998 và ISO C++ 2011

en: Warn about NULL being passed to argument slots marked as requiring non-NULL
vi: Cảnh báo khi NULL được gửi cho khe đối số đánh dấu là yêu cầu giá trị không phải NULL

en: Warn about PCH files that are found but not used
vi: Cảnh báo về tập tin PCH được tìm thấy mà không phải được sử dụng

en: Warn about alignment of COMMON blocks
vi: Cảnh báo về sự xếp hàng các khối CHUNG

en: Warn about an empty body in an if or else statement
vi: Cảnh báo về thân trống trong một câu lệnh 'if' (nếu) hay 'else' (không thì)

en: Warn about called procedures not explicitly declared
vi: Cảnh báo về thủ tục được gọi mà không phải được tuyên bố dứt khoát

en: Warn about calls with implicit interface
vi: Cảnh báo về cuộc gọi có giao diện ngầm

en: Warn about casting functions to incompatible types
vi: Cảnh báo về gán hàm cho loại không tương thích

en: Warn about casts which discard qualifiers
vi: Cảnh báo về sự gán mà loại bỏ đoạn điều kiện

en: Warn about comparison of different enum types
vi: Cảnh báo về sự so sánh các loại đếm (enum) khác nhau

en: Warn about compile-time integer division by zero
vi: Cảnh báo về số nguyên chia cho số không vào lúc biên dịch

en: Warn about creation of array temporaries
vi: Cảnh báo về sự tạo mục mảng tạm thời

en: Warn about deprecated 'vector long ...' AltiVec type usage
vi: Cảnh báo về sử dụng loại AltiVec 'vector long ...'

en: Warn about format strings that are not literals
vi: Cảnh báo về chuỗi định dạng không phải có nghĩa chữ

en: Warn about format strings that contain NUL bytes
vi: Cảnh báo về chuỗi định dạng chứa NUL byte

en: Warn about function parameters declared without a type specifier in K&R-style functions
vi: Cảnh báo về tham số hàm được tuyên bố mà không ghi rõ loại, trong hàm kiểu K&R

en: Warn about function pointer arithmetic
vi: Cảnh báo về số học trỏ đến hàm

en: Warn about functions which might be candidates for format attributes
vi: Cảnh báo về hàm có thể yêu cầu thuộc tính định dạng

en: Warn about global functions without previous declarations
vi: Cảnh báo về hàm toàn cục không có lời tuyên bố trước

en: Warn about global functions without prototypes
vi: Cảnh báo về hàm toàn cục mà không có nguyên mẫu

en: Warn about implicit function declarations
vi: Cảnh báo về lời tuyên bố hàm ngầm

en: Warn about invalid uses of the "offsetof" macro
vi: Cảnh báo khi sai sử dụng vĩ lệnh 'offsetof'

en: Warn about missing ampersand in continued character constants
vi: Cảnh báo về ký hiệu '&' còn thiếu trong hằng ký tự tiếp tục

en: Warn about missing fields in struct initializers
vi: Cảnh báo về đoạn sơ khởi cấu trúc thiếu trường

en: Warn about non-virtual destructors
vi: Cảnh báo về bộ hủy cấu trúc không phải ảo

en: Warn about none ISO msvcrt scanf/printf width extensions
vi: Cảnh báo về phần mở rộng chiều rộng scanf/printf không phải tùy theo ISO

en: Warn about overloaded virtual function names
vi: Cảnh báo về tên hàm ảo quá tải

en: Warn about overriding initializers without side effects
vi: Cảnh báo về ghi đẻ lên đoạn sơ khởi mà không có hiệu ứng khác

en: Warn about packed bit-fields whose offset changed in GCC 4.4
vi: Cảnh báo về trường bit đóng gói có hiệu số bị thay đổi trong GCC 4.4

en: Warn about possible aliasing of dummy arguments
vi: Cảnh báo về đối số giả có thể bị chồng lấp

en: Warn about possible security problems with format functions
vi: Cảnh báo về hàm định dạng có thể gây ra vấn đề bảo mật

en: Warn about possibly missing braces around initializers
vi: Cảnh báo về đoạn sơ khởi có thể thiếu dấu ngoặc móc

en: Warn about possibly missing parentheses
vi: Cảnh báo về dấu ngoặc đơn có thể bị thiếu

en: Warn about possibly nested block comments, and C++ comments spanning more than one physical line
vi: Cảnh báo về ghi chú khối có thể lồng nhau, và ghi chú C++ chiếm giữ nhiều dòng vật lý

en: Warn about printf/scanf/strftime/strfmon format string anomalies
vi: Cảnh báo khi phát hiện sự dị thường về chuỗi định dạng printf/scanf/strftime/strfmon

en: Warn about stray tokens after #elif and #endif
vi: Cảnh báo về hiệu bài thừa đẳng sau #elif và #endif

en: Warn about strftime formats yielding 2-digit years
vi: Cảnh báo về định dạng strftime xuất năm chỉ có hai chữ số

en: Warn about subscripts whose type is "char"
vi: Cảnh báo về chữ in thấp có loại 'char'

en: Warn about suspicious declarations of "main"
vi: Cảnh báo về lời tuyên bố 'main' đáng ngờ

en: Warn about suspicious uses of memory addresses
vi: Cảnh báo về sử dụng địa chỉ vùng nhớ một cách đáng ngờ

en: Warn about things that will change when compiling with an ABI-compliant compiler
vi: Cảnh báo về trường hợp sẽ thay đổi khi biên dịch bằng một bộ biên dịch tương thích với ABI

en: Warn about truncated character expressions
vi: Cảnh báo về biểu thức ký tự bị cắt ngắn

en: Warn about truncated source lines
vi: Cảnh báo về dòng nguồn bị cắt ngắn

en: Warn about underflow of numerical constant expressions
vi: Cảnh báo về biểu thức hằng thuộc số bị tràn ngược

en: Warn about use of multi-character character constants
vi: Cảnh báo về sử dụng hằng số ký tự đa ký tự

en: Warn about user-specified include directories that do not exist
vi: Cảnh báo khi người dùng xác định một thư mục không tồn tại

en: Warn about variables that might be changed by "longjmp" or "vfork"
vi: Cảnh báo về biến có thể bị thay đổi bởi 'longjmp' hoặc 'vfork'

en: Warn about variables which are initialized to themselves
vi: Cảnh báo về biến bị tự sơ khởi

en: Warn about violations of Effective C++ style rules
vi: Cảnh báo về sự vượt quá quy tắc Effective C++

en: Warn about zero-length formats
vi: Cảnh báo về định dạng có chiều dài số không

en: Warn for converting NULL from/to a non-pointer type
vi: Cảnh báo về chuyển đổi NULL từ/đến một loại không phải hàm trỏ

en: Warn for implicit type conversions between signed and unsigned integers
vi: Cảnh báo về sự chuyển đổi loại ngầm giữa số nguyên có dấu và không có dấu

en: Warn for implicit type conversions that may change a value
vi: Cảnh báo về sự chuyển đổi loại ngầm có thể thay đổi một giá trị

en: Warn for obsolescent usage in a declaration
vi: Cảnh báo về lời tuyên bố kiểu cũ

en: Warn if .class files are out of date
vi: Cảnh báo nếu có tập tin .class quá cũ

en: Warn if a C-style cast is used in a program
vi: Cảnh báo nếu một sự gán kiểu C được sử dụng trong một chương trình

en: Warn if a deprecated compiler feature, class, method, or field is used
vi: Cảnh báo nếu sử dụng một tính năng bộ biên dịch, hạng, phương pháp hay trường bị phản đối

en: Warn if a function uses alloca or creates an array with dynamic size
vi: Cảnh báo nếu một hàm sử dụng alloca hoặc tạo một mảng có kích cỡ năng động

en: Warn if a single function's framesize exceeds the given framesize
vi: Cảnh báo nếu có một hàm riêng lẻ với kích cỡ khung vượt quá kích cỡ khung đưa ra

en: Warn if a string is longer than the maximum portable length specified by the standard
vi: Cảnh báo về chuỗi dài hơn chiều dài di động tối đa được tiêu chuẩn ghi rõ

en: Warn if a user-procedure has the same name as an intrinsic
vi: Cảnh báo nếu một thủ tục người dùng có cùng một tên với một điều thực chất

en: Warn if an old-style parameter definition is used
vi: Cảnh báo về lời xác định tham số kiểu cũ

en: Warn if deprecated empty statements are found
vi: Cảnh báo nếu tìm câu lệnh trống bị phản đối

en: Warn if modifiers are specified when not necessary
vi: Cảnh báo nếu ghi rõ bộ sửa đổi không cần thiết

en: Warn if passing too many arguments to a function for its format string
vi: Cảnh báo nếu gửi cho hàm quá nhiều đối số đối với chuỗi định dạng của nó

en: Warn if testing floating point numbers for equality
vi: Cảnh báo nếu kiểm tra đẳng thức của con số điểm phù động

en: Warn on intrinsics not part of the selected standard
vi: Cảnh báo về điều thực chất không phải thuộc về tiêu chuẩn được chọn

en: Warn when a Cell microcoded instruction is emitted
vi: Cảnh báo khi xuất một câu lệnh mã vi Cell

en: Warn when a built-in preprocessor macro is undefined or redefined
vi: Cảnh báo khi một vĩ lệnh bộ tiền xử lý dựng sẵn chưa được xác định hoặc được xác định lại

en: Warn when a declaration does not specify a type
vi: Cảnh báo khi một lời tuyên bố không ghi rõ loại

en: Warn when a declaration is found after a statement
vi: Cảnh báo khi phát hiện một lời tuyên bố đẳng sau một câu lệnh

en: Warn when a function is unused
vi: Cảnh báo khi hàm không được dùng

en: Warn when a function parameter is only set, otherwise unused
vi: Cảnh báo khi tham số của hàm chỉ được đặt, nếu không thì không sử dụng

en: Warn when a function parameter is unused
vi: Cảnh báo khi tham số của hàm không được dùng

en: Warn when a jump misses a variable initialization
vi: Cảnh báo khi một bước nhảy còn thiếu sự sơ khởi biến

en: Warn when a label is unused
vi: Cảnh báo khi nhãn không được dùng

en: Warn when a logical operator is suspiciously always evaluating to true or false
vi: Cảnh báo khi một toán tử hợp lý cứ ước lượng là đúng hoặc là sai một cách đáng ngờ

en: Warn when a variable is only set, otherwise unused
vi: Cảnh báo khi biến chỉ được đặt, nếu không thì không sử dụng

en: Warn when a variable is unused
vi: Cảnh báo khi biến không được dùng

en: Warn when all constructors and destructors are private
vi: Cảnh báo khi mọi bộ cấu trúc và bộ hủy cấu trúc đều là riêng

en: Warn when an expression value is unused
vi: Cảnh báo khi giá trị của biểu thức không được dùng

en: Warn when converting the type of pointers to member functions
vi: Cảnh báo khi chuyển đổi loại hàm trỏ sang hàm bộ phận

en: Warn when non-templatized friend functions are declared within a template
vi: Cảnh báo khi hàm bạn không làm mẫu được tuyên bố bên trong một mẫu

en: Warn when there is a cast to a pointer from an integer of a different size
vi: Cảnh báo khi có một sự gán cho một hàm trỏ từ một số nguyên có kích cỡ khác

en: Warn whenever an Objective-C assignment is being intercepted by the garbage collector
vi: Cảnh báo khi nào một sự gán Objective-C bị chặn bởi bộ nhặt rác

en: Warn whenever type qualifiers are ignored.
vi: Cảnh báo khi nào đoạn điều kiện loại bị bỏ qua.

en: Warning:
vi: Cảnh báo:

en: When generating -mabicalls code, allow executables to use PLTs and copy relocations
vi: Khi tạo ra mãn -mabicalls thì cho phép tập tin thực thi sử dụng PLT và sao chép sự định vị lại

en: When generating -mabicalls code, make the code suitable for use in shared libraries
vi: Khi tạo ra mã -mabicalls, làm cho mã thích hợp với sử dụng trong thư viện dùng chung

en: When set to 1, use expensive methods to eliminate all redundant constraints
vi: Nếu lập thành 1 thì sử dụng phương pháp giá cao để loại trừ tất cả các ràng buộc thừa

en: Whether to use canonical types
vi: Có nên sử dụng loại hợp nguyên tắc hay không

en: Work around VR4130 mflo/mfhi errata
vi: Khắc phục một số lỗi mflo/mfhi VR4130 nào đó

en: Work around a hardware anomaly by adding a number of NOPs before a
vi: Khắc phục một sự dị thường phần cứng bằng cách thêm một số NOP vào trước nó

en: Work around an early 4300 hardware bug
vi: Khắc phục một lỗi phần cứng 4300 sớm

en: Work around bug in multiplication instruction
vi: Khắc phục lỗi trong câu lệnh nhân lên

en: Work around certain R10000 errata
vi: Khắc phục một số lỗi R10000 nào đó

en: Work around certain R4000 errata
vi: Khắc phục một số lỗi R4000 nào đó

en: Work around certain R4400 errata
vi: Khắc phục một số lỗi R4400 nào đó

en: Work around certain VR4120 errata
vi: Khắc phục một số lỗi VR4120 nào đó

en: Work around errata for early SB-1 revision 2 cores
vi: Khắc phục một những lỗi cho các lõi SB-1 bản sửa đổi 2 sớm

en: Work around hardware multiply bug
vi: Khắc phục lỗi nhân lên phần cứng

en: Zero width in format descriptor
vi: Bộ mô tả định dạng chứa chiều rộng số không

en: [Leaving %s]
vi: [Đang rời khỏi %s]

en: [cannot find %s]
vi: [không tìm thấy %s]

en: [default]
vi: [mặc định]

en: [disabled]
vi: [bị tắt]

en: [enabled]
vi: [đã bật]

en: __builtin_rx_%s takes 'C', 'Z', 'S', 'O', 'I', or 'U'
vi: __builtin_rx_%s nhận 'C', 'Z', 'S', 'O', 'I', hoặc 'U'

en: __fp16 and no ldrh
vi: __fp16 và không ldrh

en: __io vars are volatile by default
vi: Biến __io thì hay thay đổi theo mặc định

en: actual argument to INTENT = OUT/INOUT
vi: tham số thực tế cho INTENT = OUT/INOUT

en: address offset not a constant
vi: hiệu số địa chỉ không phải là một hằng số

en: address operand requires constraint for X, Y, or Z register
vi: toán hạng địa chỉ yêu cầu ràng buộc cho thanh ghi X, Y, hay Z

en: ambiguous method %s%s%s
vi: phương thức còn mơ hồ %s%s%s

en: anachronism:
vi: sai niên đại:

en: argument must be a constant
vi: tham số phải là một hằng

en: argument to %%:compare-debug-auxbase-opt does not end in .gk
vi: đối số tới %%:compare-debug-auxbase-opt không kết thúc bằng .gk

en: arguments '%s' and '%s' for intrinsic %s
vi: đối số '%s' và '%s' cho %s thực chất

en: arguments '%s' and '%s' for intrinsic '%s'
vi: đối số '%s' và '%s' cho '%s' thực chất

en: arguments 'a%d' and 'a%d' for intrinsic '%s'
vi: đối số 'a%d' và 'a%d' cho '%s' thực chất

en: arithmetic IF
vi: IF (nếu) số học

en: array assignment
vi: sự gán mảng

en: array index in initializer exceeds array bounds
vi: bộ sơ khởi chứa một chỉ mục mảng vượt quá giới hạn mảng

en: array index in initializer is not an integer constant expression
vi: bộ sơ khởi chứa một chỉ mục mảng không phải là một biểu tượng hằng số nguyên

en: array index in initializer not of integer type
vi: bộ sơ khởi chứa một chỉ mục mảng không có loại số nguyên

en: array index in non-array initializer
vi: gặp chỉ mục mảng trong bộ sơ khởi không phải mảng

en: array index range in initializer exceeds array bounds
vi: bộ sơ khởi chứa một phạm vi chỉ mục mảng vượt quá giới hạn mảng

en: array initialized from non-constant array expression
vi: mảng bị sơ khởi từ biểu tượng mảng không phải hằng số

en: array initialized from parenthesized string constant
vi: mảng bị sơ khởi từ hằng số chuỗi nằm trong ngoặc đơn

en: array of inappropriate type initialized from string constant
vi: mảng loại không thích hợp bị sơ khởi từ hằng số chuỗi

en: assignment
vi: sự gán

en: assignment suppression
vi: thu hồi sự gán

en: assuming that the loop counter does not overflow
vi: giả sử rằng bộ đếm vòng lặp không bị tràn

en: assuming that the loop is not infinite
vi: giả sử rằng vòng lặp có giới hạn

en: atexit failed
vi: atexit gặp lỗi

en: attribute declaration
vi: lời tuyên bố thuộc tính

en: bad address
vi: địa chỉ sai

en: bad address, not (reg+disp):
vi: địa chỉ sai, không phải (reg+disp):

en: bad address, not post_inc or pre_dec:
vi: địa chỉ sai, không phải post_inc hoặc pre_dec:

en: bad condition code
vi: mã điều kiện sai

en: bad format of .zip/.jar archive
vi: kho nén .zip/.jar có định dạng dai

en: bad insn for 'A'
vi: sai lập lệnh cho 'A'

en: bad insn in frv_print_operand, 0 case
vi: lệnh sai tới frv_print_operand, trường hợp '0'

en: bad insn in frv_print_operand, bad const_double
vi: gặp lệnh sai trong frv_print_operand, lập sai const_double

en: bad insn in frv_print_operand, z case
vi: lệnh sai tới frv_print_operand, trường hợp 'z'

en: bad insn to frv_print_operand, 'F' modifier:
vi: lệnh sai tới frv_print_operand, bộ sửa đổi 'F':

en: bad insn to frv_print_operand, 'L' modifier:
vi: lệnh sai tới frv_print_operand, bộ sửa đổi 'L':

en: bad insn to frv_print_operand, 'M/N' modifier:
vi: lệnh sai tới frv_print_operand, bộ sửa đổi 'M/N':

en: bad insn to frv_print_operand, 'O' modifier:
vi: lệnh sai tới frv_print_operand, bộ sửa đổi 'O':

en: bad insn to frv_print_operand, 'e' modifier:
vi: lệnh sai tới frv_print_operand, bộ sửa đổi 'e':

en: bad insn to frv_print_operand, 'f' modifier:
vi: lệnh sai tới frv_print_operand, bộ sửa đổi 'f':

en: bad insn to frv_print_operand, 'g' modifier:
vi: lệnh sai tới frv_print_operand, bộ sửa đổi 'g':

en: bad insn to frv_print_operand, P modifier:
vi: lệnh sai tới frv_print_operand, bộ sửa đổi 'P':

en: bad insn to frv_print_operand_address:
vi: sai lập lệnh tới frv_print_operand_address:

en: bad insn to frv_print_operand_memory_reference:
vi: sai lập lệnh tới frv_print_operand_memory_reference:

en: bad move
vi: sai di chuyển

en: bad operand
vi: toán hạng sai

en: bad output_condmove_single operand
vi: lập sai toán hạng output_condmove_single

en: bad output_move_double operand
vi: lập sai toán hạng output_move_double

en: bad output_move_single operand
vi: lập sai toán hạng output_move_single

en: bad register
vi: thanh ghi sai

en: bad register to frv_print_operand_memory_reference_reg:
vi: sai lập thanh ghi tới frv_print_operand_memory_reference_reg:

en: bad shift insn:
vi: lệnh dời sai:

en: bad test
vi: sai kiểm tra

en: bad value (%s) for -march= switch
vi: sai giá trị (%s) cho chuyển -march=

en: bad value (%s) for -mtune= switch
vi: sai giá trị (%s) cho chuyển -mtune

en: bad value for -mcall-%s
vi: sai giá trị cho -mcall-%s

en: bad value for -msdata=%s
vi: sai giá trị cho -msdata=%s

en: bad zip/jar file %s
vi: tập tin zip/jar sai %s

en: block IF
vi: IF (nếu) loại khối

en: braced spec %qs is invalid at %qc
vi: đặc tả giữa ngoặc móc %qs không hợp lệ tại %qc

en: braced spec body %qs is invalid
vi: thân của đặc tả giữa ngoặc móc %qs không hợp lệ

en: braces around scalar initializer
vi: ngoặc chung quanh bộ sơ khởi vô hướng

en: branch %2d never executed
vi: nhánh %2d chưa bao giờ thực hiện

en: branch %2d taken %s%s
vi: nhánh %2d được lấy %s%s

en: but not here
vi: nhưng không phải ở đây

en: call   %2d never executed
vi: cuộc gọi   %2d chưa bao giờ thực hiện

en: call   %2d returned %s
vi: cuộc gọi   %2d trả về %s

en: call is unlikely and code size would grow
vi: cuộc gọi không chắc, và kích cỡ mã sẽ tăng lại

en: called from here
vi: được gọi từ đây

en: can not use -mtp=cp15 with 16-bit Thumb
vi: không thể sử dụng -mtp=cp15 với 16-bit Thumb

en: can%'t close input file %s: %m
vi: can%'t đóng tập tin đầu vào %s: %m

en: can%'t get position in PCH file: %m
vi: can%'t lấy vị trí trong tập tin PCH: %m

en: can%'t open %s for writing: %m
vi: can%'t mở %s để ghi: %m

en: can%'t open %s: %m
vi: can%'t mở %s: %m

en: can%'t read %s: %m
vi: can%'t đọc %s: %m

en: can%'t read PCH file: %m
vi: can%'t đọc tập tin PCH: %m

en: can%'t specify %<-D%> without %<--main%>
vi: can%'t chỉ định %<-D%> mà không có %<--main%>

en: can%'t write %s: %m
vi: can%'t ghi %s: %m

en: can%'t write PCH file
vi: can%'t ghi tập tin PCH

en: can%'t write PCH file: %m
vi: can%'t ghi tập tin PCH: %m

en: can%'t write padding to PCH file: %m
vi: can%'t ghi phần đệm vào PCH: %m

en: can%'t write to %s: %m
vi: can%'t ghi vào %s: %m

en: can't get program status
vi: không thể lấy trạng thái về chương trình

en: can't get program status: %m
vi: không thể lấy trạng thái về chương trình: %m

en: can't open %s: %m
vi: không thể mở %s: %m

en: can't open ldd output: %m
vi: không thể mở kết xuất ldd: %m

en: can't open nm output: %m
vi: không thể mở kết xuất nm: %m

en: can't use non gp relative absolute address
vi: không cho phép sử dụng địa chỉ tuyệt đối tương đối không phải gp

en: candidate 1:
vi: ứng cử 1:

en: candidate 2:
vi: ứng cử 2:

en: candidate is: | candidates are:
vi[0]: ứng cử là:

en: candidate is: %+#D
vi: ứng cử là: %+#D

en: candidates are:
vi: ứng cử là:

en: candidates are: %+#D
vi: ứng cử là: %+#D

en: cannot convert to a pointer type
vi: không thể chuyển đổi thành kiểu con trỏ

en: cannot create temporary file
vi: không thể tạo tập tin tạm thời

en: cannot decompose address
vi: không thể phân ly địa chỉ

en: cannot find '%s'
vi: không tìm thấy '%s'

en: cannot find 'ldd'
vi: không tìm thấy 'ldd'

en: cannot find 'nm'
vi: không tìm thấy 'nm'

en: cannot find class %qE
vi: không tìm thấy lớp %qE

en: cannot load plugin %s
    %s
vi: không thể tải phần bổ xung %s
    %s

en: cannot open %s
vi: không thể mở %s

en: cannot optimize loop, the loop counter may overflow
vi: không thể tối ưu hoá vòng lặp vì bộ đếm vòng lặp có thể bị tràn

en: cannot optimize possibly infinite loops
vi: không thể tối ưu hoá vòng lặp có thể là vô hạn

en: cannot specify -o with -c, -S or -E with multiple files
vi: không thể ghi rõ nhiều tập tin với tuỳ chọn -S hoặc -E, và hai tuỳ chọn -o và c loại từ lẫn nhau

en: cannot specify both -C and -o
vi: không thể ghi rõ đồng thời hai tùy chọn --C và -o

en: cannot take address of %qs
vi: không thể lấy địa chỉ của %qs

en: cannot use mshared and static together
vi: không cho phép sử dụng đồng thời hai tuỳ chọn mshared và static

en: cannot use mthreads and mlegacy-threads together
vi: không cho phép sử dụng đồng thời hai tuỳ chọn mthreads và mlegacy-threads

en: cdecl and thiscall attributes are not compatible
vi: các thuộc tính cdecl và thiscall không tương thích với nhau

en: char-array initialized from wide string
vi: mảng ký tự bị sơ khởi từ chuỗi rộng

en: choosing %qD over %qD
vi: đóng %qD thông qua %qD

en: class %qE already exists
vi: lớp %qE đã có trước rồi

en: closing dependency file %s: %m
vi: đóng tập tin phụ thuộc %s: %m

en: collect2 version %s
vi: collect2 phiên bản %s

en: collect: reading %s
vi: tập hợp: đang đọc %s

en: collect: recompiling %s
vi: tập hợp: đang biên dịch lại %s

en: collect: relinking
vi: tập hợp: đang liên kết lại

en: collect: tweaking %s in %s
vi: tập hợp: đang điều chỉnh %s trong %s

en: comparison between %qT and %qT
vi: so sánh giữa %qT và %qT

en: compilation terminated due to -Wfatal-errors.
vi: tiến trình biên dịch bị chấm dứt do -Wfatal-errors.

en: compilation terminated due to -fmax-errors=%u.
vi: tiến trình biên dịch bị chấm dứt do -fmax-errors=%u.

en: compilation terminated.
vi: tiến trình biên dịch bị chấm dứt.

en: compressed stream: %s
vi: dòng dữ liệu được nén: %s

en: conflicting types for %q+D
vi: kiểu xung đột cho %q+D

en: conflicts with %qD
vi: xung đột với %qD

en: consider using `-pg' instead of `-p' with gprof(1)
vi: sử dụng gprof(1) thì đề nghị bạn lập "-pg" thay cho "-p"

en: const/copy propagation disabled
vi: Chức năng lan truyền hằng số / sao chép bị tắt

en: const_double_split got a bad insn:
vi: const_double_split nhận một lệnh sai:

en: conversion casts away constness
vi: việc chuyển đổi cũng bỏ trình trạng bất biến

en: could not close response file %s
vi: không thể đóng đáp ứng tập tin %s

en: could not close temporary response file %s
vi: không thể đóng tập tin đáp ứng tạm thời %s

en: could not convert %qE from %qT to %qT
vi: không thể chuyển đổi %qE từ %qT thành %qT

en: could not find a spill register
vi: không tìm thấy một thanh ghi làm tràn

en: could not find class %qE
vi: không tìm thấy lớp %qE

en: could not find specs file %s
vi: không tìm thấy tập tin đặc tả %s

en: could not open response file %s
vi: không thể mở tập tin đáp ứng %s

en: could not open temporary response file %s
vi: không thể mở tập tin đáp ứng tạm thời %s

en: could not split insn
vi: không thể chia tách insn

en: could not write to response file %s
vi: không thể ghi vào tập tin đáp ứng %s

en: could not write to temporary file %s
vi: không thể ghi vào tập tin tạm thời %s

en: could not write to temporary response file %s
vi: không thể ghi vào tập tin đáp ứng tạm thời %s

en: created and used with different ABIs
vi: tạo và sử dụng với các ABI khác nhau

en: created and used with different architectures / ABIs
vi: tạo và sử dụng với các kiến trúc hoặc ABI khác nhau

en: created and used with different endianness
vi: tạo và sử dụng với các trình trạng cuối khác nhau

en: created and used with different settings of -fpic
vi: được tạo và sử dụng với thiết lập khác nhau của -fpic

en: created and used with different settings of -fpie
vi: được tạo và sử dụng với thiết lập khác nhau của -fpie

en: created and used with differing settings of '%s'
vi: được tạo và sử dụng với thiết lập khác nhau của '%s'

en: creating array of functions
vi: tạo mảng hàm

en: creating array of references
vi: tạo mảng tham chiếu

en: creating array of void
vi: tạo mảng void

en: data declaration
vi: lời tuyên bố dữ liệu

en: debug:
vi: gỡ rối:

en: declared here
vi: được khai báo ở đây

en: deleting LTRANS file %s
vi: đang xoá bỏ tập tin LTRANS %s

en: derived type declaration
vi: lời tuyên bố loại có hướng

en: division by zero
vi: chía cho 0

en: does not support multilib
vi: không hỗ trợ chức năng đa thư viện

en: duplicate %<const%>
vi: lặp lại %<const%>

en: duplicate %<restrict%>
vi: lặp lại %<restrict%>

en: duplicate %<volatile%>
vi: lặp lại %<volatile%>

en: duplicate %qE
vi: lặp lại %qE

en: duplicate case value
vi: trùng giá trị cho case

en: duplicate initialization of %qD
vi: khởi tạo lặp lại cho %qD

en: duplicate label %qD
vi: nhãn nhân đôi %qD

en: duplicate member %q+D
vi: thành viên trùng lặp %q+D

en: dynamic dependency %s not found
vi: không tìm thấy quan hệ phụ thuộc năng động %s

en: elemental binary operation
vi: thao tác nhị phân loại yếu tố

en: elemental procedure
vi: thủ tục loại yếu tố

en: empty declaration
vi: khai báo trống rỗng

en: empty index range in initializer
vi: bộ sơ khởi chứa phạm vi chỉ mục vẫn trống

en: empty scalar initializer
vi: bộ sơ khởi vô hướng vẫn trống

en: enabled by default
vi: mặc định được bật

en: enum conversion in initialization is invalid in C++
vi: chuyển đổi enum trong bộ sơ khởi thì không hợp lệ trong C++

en: enum type defined here
vi: kiểu enum được định nghĩa ở đây

en: environment variable %qs not defined
vi: chưa định nghĩa biến môi trường%qs

en: environment variable COLLECT_GCC must be set
vi: biến môi trường COLLECT_GCC cần được đặt

en: environment variable COLLECT_GCC_OPTIONS must be set
vi: biến môi trường COLLECT_GCC_OPTIONS cần được đặt

en: environment variable DJGPP not defined
vi: chưa xác định biến môi trường DJGPP

en: environment variable DJGPP points to corrupt file '%s'
vi: biến môi trường DJGPP chỉ tới tập tin bị hỏng '%s'

en: environment variable DJGPP points to missing file '%s'
vi: biến môi trường DJGPP chỉ tới tập tin còn thiếu '%s'

en: error in args to spec function %qs
vi: gặp lỗi trong các đối số tới hàm đặc tả %qs

en: error in constant pool entry #%d
vi: gặp lỗi trong mục nhập vùng gộp hằng số #%d

en: error while parsing constant pool
vi: gặp lỗi khi phân tích cú pháp của vùng gộp hằng số

en: error while parsing fields
vi: gặp lỗi khi phân tích cú pháp của các trường

en: error while parsing final attributes
vi: gặp lỗi khi phân tích cú pháp của các thuộc tính cuối cùng

en: error while parsing methods
vi: gặp lỗi khi phân tích cú pháp của các phương pháp

en: error writing %qs
vi: lỗi ghi %qs

en: error writing to %s: %m
vi: lỗi ghi vào %s: %m

en: error:
vi: lỗi:

en: excess elements in array initializer
vi: gặp yếu tố thừa trong bộ sơ khởi mảng

en: excess elements in char array initializer
vi: gặp yếu tố thừa trong bộ sơ khởi mảng ký tự

en: excess elements in scalar initializer
vi: gặp yếu tố thừa trong bộ sơ khởi vô hướng

en: excess elements in struct initializer
vi: gặp yếu tố thừa trong bộ sơ khởi cấu trúc

en: excess elements in union initializer
vi: gặp yếu tố thừa trong bộ sơ khởi hợp

en: excess elements in vector initializer
vi: gặp yếu tố thừa trong bộ sơ khởi véc-tơ

en: expected %<#pragma omp section%> or %<}%>
vi: cần %<#pragma omp section%> hoặc %<}%>

en: expected %<#pragma omp%> clause
vi: cần mệnh đề %<#pragma omp%>

en: expected %<(%>
vi: cần %<(%>

en: expected %<(%> or end of line
vi: cần %<(%> hoặc xuống dòng

en: expected %<)%>
vi: cần %<)%>

en: expected %<*%>
vi: cần %<*%>

en: expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%>
vi: cần %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> hoặc %<max%>

en: expected %<,%>
vi: cần %<,%>

en: expected %<,%> or %<)%>
vi: cần %<,%> hoặc %<)%>

en: expected %<,%> or %<...%>
vi: cần %<,%> hoặc %<...%>

en: expected %<,%> or %<;%>
vi: cần %<,%> hoặc %<;%>

en: expected %<,%> or %<}%>
vi: cần %<,%> hoặc %<}%>

en: expected %<,%>, %<;%> or %<}%>
vi: cần %<,%>, %<;%> hoặc %<}%>

en: expected %<.%>
vi: cần %<.%>

en: expected %<...%>
vi: cần %<...%>

en: expected %<:%>
vi: cần %<:%>

en: expected %<:%> or %<...%>
vi: cần %<:%> hoặc %<...%>

en: expected %<:%> or %<::%>
vi: cần %<:%> hoặc %<::%>

en: expected %<:%>, %<,%>, %<;%>, %<}%> or %<__attribute__%>
vi: cần %<:%>, %<,%>, %<;%>, %<}%> hoặc %<__attribute__%>

en: expected %<::%>
vi: cần %<::%>

en: expected %<;%>
vi: cần %<;%>

en: expected %<;%> at end of member declaration
vi: cần %<;%> tại cuối khai báo thành viên

en: expected %<;%> or %<{%>
vi: cần %<;%> hoặc %<{%>

en: expected %<;%>, %<,%> or %<)%>
vi: cần %<;%>, %<,%> hoặc %<)%>

en: expected %<;%>, identifier or %<(%>
vi: cần %<;%>, định danh hoặc %<(%>

en: expected %<<%>
vi: cần %<<%>

en: expected %<=%>
vi: cần %<=%>

en: expected %<>%>
vi: cần %<>%>

en: expected %<@end%>
vi: cần %<@end%>

en: expected %<@synchronized%>
vi: cần %<@synchronized%>

en: expected %<@throw%>
vi: cần %<@throw%>

en: expected %<@try%>
vi: cần %<@try%>

en: expected %<[%>
vi: cần %<[%>

en: expected %<]%>
vi: cần %<]%>

en: expected %<__label__%>
vi: cần %<__label__%>

en: expected %<__transaction_relaxed%>
vi: cần %<__transaction_relaxed%>

en: expected %<asm%>
vi: cần %<asm%>

en: expected %<catch%>
vi: cần %<catch%>

en: expected %<class%>
vi: cần %<class%>

en: expected %<class%>, %<typename%>, or %<template%>
vi: cần %<class%>, %<typename%>, hoặc %<template%>

en: expected %<decltype%>
vi: cần %<decltype%>

en: expected %<delete%>
vi: cần %<delete%>

en: expected %<extern%>
vi: cần %<extern%>

en: expected %<namespace%>
vi: cần %<namespace%>

en: expected %<new%>
vi: cần %<new%>

en: expected %<none%> or %<shared%>
vi: cần %<none%> hoặc %<shared%>

en: expected %<operator%>
vi: cần %<operator%>

en: expected %<return%>
vi: cần %<return%>

en: expected %<static_assert%>
vi: cần %<static_assert%>

en: expected %<template%>
vi: cần %<template%>

en: expected %<throw%>
vi: cần %<throw%>

en: expected %<try%>
vi: cần %<try%>

en: expected %<using%>
vi: cần %<using%>

en: expected %<while%>
vi: cần %<while%>

en: expected %<{%>
vi: cần %<{%>

en: expected %<{%> or %<:%>
vi: cần %<{%> hoặc %<:%>

en: expected %<}%>
vi: cần %<}%>

en: expected %<}%> before %<else%>
vi: cần %<}%> trước %<else%>

en: expected %<~%>
vi: cần %<~%>

en: expected boolean expression
vi: cần một biểu thức lôgíc

en: expected boolean type
vi: cần kiểu boolean

en: expected channel
vi: cần kênh

en: expected class name
vi: cần tên lớp

en: expected declaration
vi: cần khai báo

en: expected end of line
vi: cần kết thúc dòng

en: expected function
vi: cần hàm

en: expected identifier
vi: cần định danh

en: expected identifier or %<(%>
vi: cần một định danh hoặc %<(%>

en: expected identifier or %<*%>
vi: cần một định danh hoặc %<*%>

en: expected integer expression
vi: cần biểu thức nguyên

en: expected integer or boolean type
vi: cần số nguyên hoặc lôgíc

en: expected numeric type
vi: cần kiểu số

en: expected pointer
vi: cần con trỏ

en: expected primary-expression
vi: cần biểu thức cơ bản

en: expected statement
vi: cần biểu thức

en: expected string-literal
vi: cần một chuỗi chữ

en: extra brace group at end of initializer
vi: gặp nhóm ngoặc móc thừa tại kết thúc của bộ sơ khởi

en: extra elements in scalar initializer
vi: gặp yếu tố thừa trong bộ sơ khởi vô hướng

en: fail to initialize plugin %s
vi: gặp lỗi khi khởi tạo phần bổ xung %s

en: failed to find class '%s'
vi: không tìm thấy lớp '%s'

en: failed to get exit status: %m
vi: không lấy được trạng thái thoát: %m

en: failed to get process times: %m
vi: không lấy được thời gian tiến trình: %m

en: failed to open %s
vi: không mở được %s

en: failed to rename %s to state file %s [%s]
vi: gặp lỗi khi đổi tên %s thành tập tin trạng thái %s [%s]

en: fastcall and thiscall attributes are not compatible
vi: các thuộc tính fastcall và thiscall không tương thích với nhau

en: fatal error:
vi: lỗi nghiêm trọng:

en: field %qs not found
vi: không tìm thấy trường %qs

en: field name not in record or union initializer
vi: không có tên trường trong bộ sơ khởi hợp hoặc mục ghi

en: field width
vi: bề rộng trường

en: field width in printf format
vi: chiều rộng của trường theo định dạng printf

en: field width in scanf format
vi: chiều rộng của trường theo định dạng scanf

en: field width in strfmon format
vi: chiều rộng của trường theo định dạng strfmon

en: field width in strftime format
vi: chiều rộng của trường theo định dạng stfrtime

en: fill character
vi: ký tự điền vào

en: fill character in strfmon format
vi: ký tự điền vào theo định dạng strftime

en: find_enum(): Enum not found
vi: find_enum(): không tìm thấy bộ đếm

en: fini function found in object %s
vi: hàm fini được tìm trong đối tượng %s

en: floating constant misused
vi: sai sử dụng hằng số nổi

en: floating point constant not a valid immediate operand
vi: hằng số điểm phù động không phải là một toán hạng ngay lập tức đúng

en: flow control insn inside a basic block
vi: gặp lệnh điều khiển luồng bên trong một khối cơ bản

en: for statement expected
vi: cần câu lệnh for

en: format
vi: định dạng

en: fr30_print_operand: invalid %%F code
vi: fr30_print_operand: sai lập mã %%F

en: fr30_print_operand: invalid %%x code
vi: fr30_print_operand: sai lập mã %%x

en: fr30_print_operand: invalid operand to %%A code
vi: fr30_print_operand: không nhận ra mã %%A

en: fr30_print_operand: unhandled MEM
vi: fr30_print_operand: MEM chưa quản lý

en: fr30_print_operand: unknown code
vi: fr30_print_operand: không rõ mã

en: fr30_print_operand: unrecognized %%B code
vi: fr30_print_operand: không nhận ra mã %%B

en: fr30_print_operand: unrecognized %%b code
vi: fr30_print_operand: không nhận ra mã %%b

en: fr30_print_operand: unrecognized %%p code
vi: fr30_print_operand: không nhận ra mã %%p

en: fr30_print_operand_address: unhandled address
vi: fr30_print_operand_address: địa chỉ chưa quản lý

en: frv_print_operand: unknown code
vi: frv_print_operand: gặp mã không rõ

en: function %qD redeclared as variable
vi: hàm %qD được định nghĩa lại thành một biến

en: function body not available
vi: thân hàm không sẵn sàng

en: function not considered for inlining
vi: hàm không phải được tính để chèn vào trực tiếp

en: function not declared inline and code size would grow
vi: hàm không phải được tuyên bố trực tiếp, và kích cỡ mã sẽ tăng lại

en: function not inlinable
vi: hàm không thể chèn vào trực tiếp

en: function not inline candidate
vi: hàm không phải là ứng xử để chèn vào trực tiếp

en: function parameters cannot have __fp16 type
vi: tham số hàm không thể có loại __fp16

en: function returns an aggregate
vi: hàm trả về một tập hợp

en: functions cannot return __fp16 type
vi: hàm không thể trả lại loại __fp16

en: gcc driver version %s %sexecuting gcc version %s
vi: Trình điều khiển gcc phiên bản %s %sexecuting gcc phiên bản %s

en: gcc version %s %s
vi: gcc phiên bản %s %s

en: gfortran does not support -E without -cpp
vi: gfortran không hỗ trợ sử dụng -E mà không có -cpp

en: gimplification failed
vi: gimplification gặp lỗi

en: gp is constant (but save/restore gp on indirect calls)
vi: gp bất biến (mà lưu/phục_hồi gp khi được gọi gián tiếp)

en: ia64_print_operand: unknown code
vi: ia64_print_operand: gặp mã không hợp lệ

en: ignoring duplicate directory "%s"
vi: đang bỏ qua thư mục trùng "%s"

en: ignoring nonexistent directory "%s"
vi: đang bỏ qua thư mục không tồn tại "%s"

en: illegal operand detected
vi: phát hiện toán hạng cấm

en: implied END DO
vi: ngụ ý END DO (kết thúc làm)

en: in %s, at %s:%d
vi: trong %s, tại %s:%d

en: in argument to unary !
vi: trong đối số tới bộ nguyên phân !

en: in basic block %d:
vi: trong khối cơ bản %d:

en: in statement
vi: tại câu lệnh

en: incorrect insn:
vi: lệnh không đúng:

en: index must be integer
vi: chỉ số phải là số nguyên

en: init function found in object %s
vi: hàm init được tìm trong đối tượng %s

en: initialization of a flexible array member
vi: đã sơ khởi một bộ phận mảng dẻo

en: initialization of flexible array member in a nested context
vi: bộ phận mảng dẻo bị sơ khởi trong một ngữ cảnh lồng nhau

en: initialized field overwritten
vi: trường đã sơ khởi bị ghi đè

en: initialized field with side-effects overwritten
vi: trường đã sơ khởi với hiệu ứng khác bị ghi đè

en: initializer element is not a constant expression
vi: yếu tố sơ khởi không phải là một biểu tượng hằng số

en: initializer element is not computable at load time
vi: yếu tố sơ khởi không tính được vào lúc nạp

en: initializer element is not constant
vi: yếu tố sơ khởi không phải hằng số

en: inline code to invalidate instruction cache entries after setting up nested function trampolines
vi: chèn mã vào trực tiếp để làm mất hiệu lực các mục nhập vùng nhớ tạm câu lệnh sau khi thiết lập các trampoline hàm lồng nhau

en: insn contains an invalid address !
vi: insn chứa một địa chỉ sai !

en: insn does not satisfy its constraints:
vi: lệnh không thỏa những ràng buộc của nó:

en: insn outside basic block
vi: gặp lệnh bên ngoài khối cơ bản

en: install: %s%s
vi: cài đặt: %s%s

en: instruction never executed
vi: lệnh chưa bao giờ thực hiện

en: internal compiler error.  Bad address:
vi: lỗi biên dịch nội bộ. Địa chỉ sai:

en: internal compiler error.  Incorrect shift:
vi: lỗi biên dịch nội bộ. Dịch không đúng:

en: internal compiler error.  Unknown mode:
vi: lỗi biên dịch nội bộ. Không hiểu chế độ:

en: internal compiler error:
vi: lỗi biên dịch nội bộ:

en: internal function
vi: hàm nội bộ

en: invalid %%%c operand
vi: sai toán hạng %%%c

en: invalid %%-code
vi: %%-code sai

en: invalid %%A operand
vi: toán hạng %%A sai

en: invalid %%B operand
vi: toán hạng %%B sai

en: invalid %%C operand
vi: sai toán hạng %%C

en: invalid %%C value
vi: giá trị %%C sai

en: invalid %%D operand
vi: sai toán hạng %%D

en: invalid %%D value
vi: giá trị %%D sai

en: invalid %%E value
vi: giá trị %%E sai

en: invalid %%F value
vi: giá trị %%F sai

en: invalid %%G mode
vi: chế độ %%G không hợp lệ

en: invalid %%G value
vi: giá trị %%G sai

en: invalid %%H operand
vi: sai toán hạng %%H

en: invalid %%H value
vi: giá trị %%H sai

en: invalid %%I operand
vi: sai toán hạng %%I

en: invalid %%J code
vi: mã %%J sai

en: invalid %%J value
vi: giá trị %%J sai

en: invalid %%K value
vi: giá trị %%K sai

en: invalid %%L code
vi: mã %%L sai

en: invalid %%L operand
vi: sai toán hạng %%L

en: invalid %%L value
vi: giá trị %%L sai

en: invalid %%M operand
vi: sai toán hạng %%M

en: invalid %%M value
vi: giá trị %%M sai

en: invalid %%N operand
vi: sai toán hạng %%N

en: invalid %%N value
vi: giá trị %%N sai

en: invalid %%O value
vi: giá trị %%O sai

en: invalid %%P operand
vi: gặp toán hạng %%P sai

en: invalid %%P value
vi: giá trị %%P sai

en: invalid %%R value
vi: giá trị %%R sai

en: invalid %%S value
vi: giá trị %%S sai

en: invalid %%T value
vi: giá trị %%T sai

en: invalid %%U value
vi: giá trị %%U sai

en: invalid %%Y operand
vi: toán hạng %%Y sai

en: invalid %%c operand
vi: toán hạng %%c sai

en: invalid %%d operand
vi: toán hạng %%d sai

en: invalid %%d value
vi: giá trị %%d sai

en: invalid %%f operand
vi: toán hạng %%f sai

en: invalid %%f value
vi: giá trị %%f sai

en: invalid %%h operand
vi: sai toán hạng %%h

en: invalid %%h value
vi: giá trị %%h sai

en: invalid %%i operand
vi: sai toán hạng %%i

en: invalid %%j code
vi: mã %%j sai

en: invalid %%j operand
vi: sai toán hạng %%j

en: invalid %%j value
vi: giá trị %%j sai

en: invalid %%k value
vi: giá trị %%k sai

en: invalid %%m value
vi: giá trị %%m sai

en: invalid %%p value
vi: gặp giá trị %%p sai

en: invalid %%q value
vi: giá trị %%q sai

en: invalid %%r operand
vi: sai toán hạng %%r

en: invalid %%r value
vi: giá trị %%r sai

en: invalid %%s operand
vi: toán hạng %%s sai

en: invalid %%s value
vi: giá trị %%s sai

en: invalid %%t operand
vi: sai toán hạng %%t

en: invalid %%t operand '
vi: sai toán hạng %%t '

en: invalid %%t/%%b value
vi: giá trị %%t/%%b sai

en: invalid %%u value
vi: giá trị %%u sai

en: invalid %%v value
vi: giá trị %%v sai

en: invalid %%x value
vi: giá trị %%x sai

en: invalid %%xn code
vi: mã %%xn sai

en: invalid %%y value, try using the 'Z' constraint
vi: giá trị %%y sai, hãy thử sử dụng ràng buộc 'Z'

en: invalid 'asm':
vi: 'asm' sai:

en: invalid --param value %qs
vi: sai giá trị cho tùy chọn --param %qs

en: invalid CASE_CHAIN
vi: sai CASE_CHAIN

en: invalid PHI argument
vi: sai tham số PHI

en: invalid PHI result
vi: kết quả PHI không hợp lệ

en: invalid UNSPEC as operand
vi: lập sai UNSPEC như là toán hạng

en: invalid address
vi: địa chỉ sai

en: invalid addressing mode
vi: sai lập chế độ đặt địa chỉ

en: invalid const_double operand
vi: toán hạng const_double sai

en: invalid constraints for operand
vi: sai lập ràng buộc cho toán hạng

en: invalid conversion from %<__fpreg%>
vi: sai chuyển đổi từ %<__fpreg%>

en: invalid conversion to %<__fpreg%>
vi: sai chuyển đổi sang %<__fpreg%>

en: invalid cpu "%s" for %s"%s"%s
vi: sai cpu "%s" cho %s"%s"%s

en: invalid expression as operand
vi: sai lập biểu tượng dưới dạng toán hạng

en: invalid first operand of MEM_REF
vi: sai toán hạng thứ nhất của MEM_REF

en: invalid initializer
vi: bộ sơ khởi sai

en: invalid insn:
vi: lệnh sai:

en: invalid mask
vi: bộ lọc sai

en: invalid operand code '%c'
vi: mã toán hạng sai '%c'

en: invalid operand for 'A' modifier
vi: sai lập toán hạng cho sự sửa đổi 'A'

en: invalid operand for 'D' modifier
vi: sai lập toán hạng cho sự sửa đổi 'D'

en: invalid operand for 'H' modifier
vi: sai lập toán hạng cho sự sửa đổi 'H'

en: invalid operand for 'O' modifier
vi: sai lập toán hạng cho sự sửa đổi 'O'

en: invalid operand for 'T' modifier
vi: sai lập toán hạng cho sự sửa đổi 'T'

en: invalid operand for 'b' modifier
vi: sai lập toán hạng cho sự sửa đổi 'b'

en: invalid operand for 'e' modifier
vi: sai lập toán hạng cho sự sửa đổi 'e'

en: invalid operand for 'm' modifier
vi: sai lập toán hạng cho sự sửa đổi 'm'

en: invalid operand for 'o' modifier
vi: sai lập toán hạng cho sự sửa đổi 'o'

en: invalid operand for 'p' modifier
vi: sai lập toán hạng cho sự sửa đổi 'p'

en: invalid operand for 'z' modifier
vi: sai lập toán hạng cho sự sửa đổi 'z'

en: invalid operand for code '%c'
vi: sai lập toán hạng cho mã '%c'

en: invalid operand for code: '%c'
vi: sai lập toán hạng cho mã: '%c'

en: invalid operand modifier letter
vi: sai lập chữ sửa đổi toán hạng

en: invalid operand output code
vi: sai lập mã kết xuất toán hạng

en: invalid operand to %%H/%%L code
vi: sai lập toán hạng tới mã %%H/%%L

en: invalid operand to %%N code
vi: sai lập toán hạng tới mã %%N

en: invalid operand to %%R
vi: sai lập toán hạng tới %%R

en: invalid operand to %%R code
vi: sai lập toán hạng tới mã %%R

en: invalid operand to %%S
vi: sai lập toán hạng tới %%S

en: invalid operand to %%T/%%B code
vi: sai lập toán hạng tới mã %%T/%%B

en: invalid operand to %%U code
vi: sai lập toán hạng tới mã %%U

en: invalid operand to %%p code
vi: sai lập toán hạng tới mã %%p

en: invalid operand to %%s code
vi: sai lập toán hạng tới mã %%s

en: invalid operation on %<__fpreg%>
vi: thao tác sai %<__fpreg%>

en: invalid parameter %qs
vi: tham số sai %qs

en: invalid shift operand
vi: sai lập toán hạng dời

en: invalid use of %%d, %%x, or %%X
vi: sai sử dụng %%d, %%x hoặc %%X

en: invalid use of '%%%c'
vi: sai sử dụng '%%%c'

en: invalid use of ':' modifier
vi: số dòng sai

en: invalid use of non-lvalue array
vi: sai sử dụng mảng không phải lvalue

en: invalid use of type
vi: sử dụng kiểu sai

en: invalid use of void expression
vi: sử dụng sai biểu thức void

en: invalid version number %qs
vi: số thứ tự phiên bản không hợp lệ %qs

en: jcf-dump: no classes specified
vi: jcf-dump: chưa ghi rõ hạng nào

en: jump to case label
vi: nhảy tới nhãn lệnh case

en: jump to label %qD
vi: nhảy tới nhãn %qD

en: label
vi: nhãn

en: language %s not recognized
vi: không chấp nhận ngôn ngữ %s

en: left precision
vi: đồ chính xác bên trái

en: left precision in strfmon format
vi: đồ chính xác bên trái theo định dạng strfmon

en: left shift count >= width of type
vi: số lượng dịch trái  >= độ rộng của kiểu

en: left shift count is negative
vi: số lượng dịch trái là số âm

en: length modifier
vi: đồ sửa đổi bề dài

en: length modifier in printf format
vi: đồ sửa đổi chiều dài theo định dạng printf

en: length modifier in scanf format
vi: đồ sửa đổi chiều dài theo định dạng scanf

en: length modifier in strfmon format
vi: đồ sửa đổi chiều dài theo định dạng strfmon

en: libraries: %s
vi: thư viện: %s

en: library lib%s not found
vi: không tìm thấy thư viện lib%s

en: lo_sum not of register
vi: lo_sum không phải thanh ghi

en: long long constant not a valid immediate operand
vi: hằng số dài dài không phải là một toán hạng ngay lập tức đúng

en: lto_obj_file_open() failed
vi: lto_obj_file_open() gặp lỗi

en: malformed COLLECT_GCC_OPTIONS
vi: COLLECT_GCC_OPTIONS dị hình

en: malformed spec function arguments
vi: đối số hàm đặc tả dạng sai

en: malformed spec function name
vi: tên hàm đặc tả dạng sai

en: mask must be an immediate
vi: mặt nạ phải là một giá trị trực tiếp

en: maximum number of basic blocks per function to be analyzed by Graphite
vi: số tối đa các khối cơ bản mỗi hàm cần được Graphite phân tích

en: maximum number of parameters in a SCoP
vi: số tối đa các tham số trong một SCoP

en: may not use both -EB and -EL
vi: không cho phép sử dụng đồng thời hai tuỳ chọn -EB và -EL

en: may not use both -m32 and -m64
vi: không cho phép sử dụng đồng thời hai tuỳ chọn -m32 và -m64

en: mismatched arguments
vi: các đối số không tương ứng với nhau

en: missing %<=%> (after %<getter%> attribute)
vi: thiếu %<=%> (sau thuộc tính %<getter%>)

en: missing %<=%> (after %<setter%> attribute)
vi: thiếu %<=%> (sau thuộc tính %<setter%>)

en: missing PHI def
vi: thiếu PHI def

en: missing braces around initializer
vi: thiếu ngoặc móc chung quanh bộ sơ khởi

en: missing edge %i->%i
vi: thiếu edge %i->%i

en: missing field '%s' in '%s'
vi: thiếu trường '%s' trong '%s'

en: missing method %s%s%s
vi: thiếu phương thức%s%s%s

en: missing number
vi: thiếu số

en: missing operand
vi: toán hạng còn thiếu

en: missing path after %qs
vi: thiếu đường dẫn sau %qs

en: module procedure
vi: thủ tục mô-đun

en: multilib exclusion %qs is invalid
vi: sự loại từ đa thư viện %qs không hợp lệ

en: multilib exclusions %qs is invalid
vi: sự loại từ đa thư viện %qs không hợp lệ

en: multilib select %qs is invalid
vi: sự lựa chọn đa thư viện %qs không hợp lệ

en: multilib spec %qs is invalid
vi: đặc tả đa thư viện %qs không hợp lệ

en: mvcle use
vi: Cách sử dụng mvcle

en: negative insn length
vi: chiều dài insn âm

en: nested assembly dialect alternatives
vi: các sự xen kẽ phương ngôn assembly lồng nhau

en: no %qs getter found
vi: không tìm thấy getter %qs

en: no FUNCTION_PROFILER for CRIS
vi: không có FUNCTION_PROFILER cho CRIS

en: no arguments
vi: không có đối số nào

en: no arguments for spec function
vi: không có đối số tới hàm đặc tả

en: no description yet
vi: chưa có mô tả

en: no input files
vi: không có tập tin nhập vào

en: no input files; unwilling to write output files
vi: không có tập tin nhập vào ; không sẵn sàng ghi tập tin kết xuất

en: no post-decrement operator for type
vi: không có toán tử hậu giảm cho loại

en: no post-increment operator for type
vi: không có toán tử hậu gia cho loại

en: no pre-decrement operator for type
vi: không có toán tử giảm gia cho loại

en: no pre-increment operator for type
vi: không có toán tử tiền gia cho loại

en: no processor type specified for linking
vi: chưa ghi rõ loại bộ xử lý cần liên kết

en: no register in address
vi: địa chỉ không chứa thanh ghi

en: non-static initialization of a flexible array member
vi: một bộ phận mảng dẻo bị sơ khởi một cách không phải tĩnh

en: nonconstant array index in initializer
vi: bộ sơ khởi chứa một chỉ mục mảng không phải hằng số

en: not configured with sysroot headers suffix
vi: không được cấu hình với hậu số phần đầu sysroot

en: not enough arguments
vi: không đủ đối số

en: note:
vi: ghi chú:

en: null pointer
vi: con trỏ rỗng

en: object is not a method
vi: đối tượng không phải là phương thức

en: old-style function definition
vi: định nghĩa hàm theo cách cũ

en: only one of -mm and -ml may be given
vi: chỉ một trong số các tùy chọn sau được chỉ ra: -mm và -ml

en: only one of -mm and -mtiny= may be given
vi: chỉ một trong số các tùy chọn sau được chỉ ra: -mm và -mtiny=

en: only one of -ms and -ml may be given
vi: chỉ một trong số các tùy chọn sau được chỉ ra: -ms và -ml

en: only one of -ms and -mm may be given
vi: chỉ một trong số các tùy chọn sau được chỉ ra: -ms và -mm

en: only one of -ms and -mtiny= may be given
vi: chỉ một trong số các tùy chọn sau được chỉ ra: -ms và -mtiny=

en: open %s failed: %s
vi: mở %s gặp lỗi: %s

en: open /dev/zero: %m
vi: mở /dev/zero: %m

en: opening dependency file %s: %m
vi: mở tập tin phụ thuộc %s: %m

en: opening output file %s: %m
vi: mở tập tin kết xuất %s: %m

en: operand is not a condition code, invalid operand code 'D'
vi: toán hạng không phải là một mã điều kiện, mã toán hạng sai 'D'

en: operand is not a condition code, invalid operand code 'Y'
vi: toán hạng không phải là một mã điều kiện, mã toán hạng sai 'Y'

en: operand number missing after %%-letter
vi: số thứ tự toán hạng còn thiếu đằng sau %%-letter

en: operand number out of range
vi: số thứ tự toán hạng ở ngoại phạm vi

en: operands to %T/%t must be reg + const_int:
vi: các toán hạng cho %T/%t phải là reg + const_int:

en: optimizing for size and code size would grow
vi: đang tối ưu hoá cho kích cỡ, và kích cỡ mã sẽ tăng lại

en: options enabled:
vi: tuỳ chọn đã bật:

en: options passed:
vi: tuỳ chọn được gửi:

en: original type declared here
vi: kiểu nguyên bản được khai báo ở đây

en: originally indirect function call not considered for inlining
vi: cuộc gọi hàm gián tiếp lần đầu tiên không phải được tính để chèn vào trực tiếp

en: out of memory
vi: không đủ bộ nhớ

en: padding struct to align %q+D
vi: chèn thêm cấu trúc cho vừa %q+D

en: parameter %qD is initialized
vi: tham số %qD được khởi tạo

en: parameter %u has void type
vi: tham số %u có kiểu void

en: pex_init failed
vi: pex_init bị lỗi

en: pex_init failed: %m
vi: pex_init bị lỗi: %m

en: picochip_print_memory_address - Operand isn't memory based
vi: picochip_print_memory_address: toán hạng không phải dựa vào vùng nhớ

en: pointer assignment
vi: sự gán hàm trỏ

en: post-increment address is not a register
vi: địa chỉ hậu gia không phải là một thanh ghi

en: pre-decrement address is not a register
vi: địa chỉ tiền giảm không phải là một thanh ghi

en: pre-increment address is not a register
vi: địa chỉ tiền gia không phải là một thanh ghi

en: precision
vi: độ chính xác

en: precision in printf format
vi: độ chính xác theo định dạng printf

en: predicated Thumb instruction
vi: lệnh Thumb căn cứ vào

en: predicated instruction in conditional sequence
vi: gặp lệnh căn cứ vào trong dãy có điều kiện

en: previously used here
vi: cái trước được dùng là ở đây

en: profiling not supported with -mg
vi: không hỗ trợ sử dụng chức năng đo hiệu năng sử dụng với -mg

en: programs: %s
vi: chương trình: %s

en: prototype for %q+#D
vi: nguyên mẫu cho %q+#D

en: read failed while reading export data
vi: đọc gặp lỗi khi đọc dữ liệu xuất

en: recompiling with -fcompare-debug
vi: hãy dịch lại với tùy chọn -fcompare-debug

en: recursive inlining
vi: chèn vào trực tiếp một cách đệ quy

en: recursively required from here
vi: yêu cầu đệ quy từ đây

en: redefined extern inline functions are not considered for inlining
vi: hàm trực tiếp bên ngoài đã xác định lại thì không phải được tính để chèn vào trực tiếp

en: regparam and thiscall attributes are not compatible
vi: không tương thích với nhau

en: removing .rpo file: %m
vi: đang gỡ bỏ tập tin .rpo: %m

en: rename spec %s to %s
vi: thay đổi tên của đặc tả %s thành %s

en: renaming .rpo file: %m
vi: đang đổi tên tập tin .rpo: %m

en: required from %q#D
vi: được yêu cầu từ %q#D

en: required from here
vi: được yêu cầu từ đây

en: return not followed by barrier
vi: trả lại không có hàng rào theo sau

en: right precision
vi: đồ chính xác bên phải

en: right precision in strfmon format
vi: đồ chính xác bên phải theo định dạng strfmon

en: right shift count >= width of type
vi: số lượng dịch phải  >= độ rộng của kiểu

en: right shift count is negative
vi: số lượng dịch trái là số âm

en: rx200 cpu does not have FPU hardware
vi: CPU rx200 không có phần cứng đơn vị điểm phù động (FPU)

en: selector must be an immediate
vi: bộ chọn phải là một giá trị trực tiếp

en: shared and mdll are not compatible
vi: shared và mdll không tương thích với nhau

en: simple IF
vi: IF (nếu) đơn giản

en: size of %q+D is %d bytes
vi: kích thước của %q+D là %d byte

en: size of %q+D is larger than %wd bytes
vi: kích thước của %q+D lớn hơn %wd byte

en: size of loop %d should be %d, not %d
vi: kích thước của vòng lặp %d nên là %d, không phải %d

en: size of tiles for loop blocking
vi: kích cỡ tile (đơn vị dữ liệu) để chặn vòng lặp

en: sizeof(long double) is 12
vi: kích cỡ (đôi dài) là 12

en: sizeof(long double) is 16
vi: kích cỡ (đôi dài) là 16

en: sorry, unimplemented:
vi: tiếc là chưa thực hiện:

en: source is a pointer to incomplete type
vi: nguồn là một hàm trỏ tới loại không hoàn toàn

en: source is not a pointer
vi: nguồn không phải là một hàm trỏ

en: source is not a pointer to class
vi: nguồn không phải là một hàm trỏ tới hạng

en: source is not of class type
vi: nguồn không phải có loại hạng

en: source is of incomplete class type
vi: nguồn có loại hạng không hoàn toàn

en: source type is not polymorphic
vi: nguồn không có loại nhiều dạng

en: spec %qs has invalid %<%%0%c%>
vi: đặc tả %qs có %<%%0%c%> không hợp lệ

en: spec %qs has invalid %<%%W%c%>
vi: đặc tả %qs có %<%%W%c%> không hợp lệ

en: spec %qs has invalid %<%%x%c%>
vi: đặc tả %qs có %<%%x%c%> không hợp lệ

en: spec %qs invalid
vi: đặc tả %qs không hợp lệ

en: spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC
vi: spec thất bại: có nhiều hơn một đối số chuyển cho SYSROOT_HEADERS_SUFFIX_SPEC

en: spec failure: more than one arg to SYSROOT_SUFFIX_SPEC
vi: spec thất bại: có nhiều hơn một đối số chuyển cho SYSROOT_SUFFIX_SPEC

en: spec file has no spec for linking
vi: tập tin đặc tả không có đặc tả để liên kết

en: spec is '%s'
vi: đặc tả là '%s'

en: specs %%include syntax malformed after %ld characters
vi: đặc tả chứa cú pháp %%include dạng sai sau %ld ký tự

en: specs %%rename syntax malformed after %ld characters
vi: đặc tả chứa cú pháp %%rename dạng sai sau %ld ký tự

en: specs %s spec was not found to be renamed
vi: đặc tả chứa đặc tả %s không có tên mới

en: specs file malformed after %ld characters
vi: tập tin đặc tả dạng sai sau %ld ký tự

en: specs unknown %% command after %ld characters
vi: đặc tả chứa một lệnh %% không rõ sai sau %ld ký tự

en: static is not supported on TPF-OS
vi: trên TPF-OS thì không hỗ trợ static

en: stdcall and thiscall attributes are not compatible
vi: các thuộc tính stdcall và thiscal không tương thích với nhau

en: struct defined here
vi: struct được định nghĩa ở đây

en: struct has no members
vi: struct không có thành viên nào

en: symbol used as immediate operand
vi: ký hiệu dùng như là toán hạng ngay lập tức

en: symbol used with both base and indexed registers
vi: ký hiệu dùng với thanh ghi cả hai loại cơ bản và phụ lục

en: symbol with offset used in PIC mode
vi: ký hiệu với hiệu số dùng trong chế độ PIC

en: target is not pointer or reference
vi: đích không phải là một hàm trỏ hoặc một tham chiếu

en: target is not pointer or reference to class
vi: đích không phải là hàm trỏ hoặc tham chiếu đến hạng

en: target is not pointer or reference to complete type
vi: đích không phải là hàm trỏ hoặc tham chiếu đến loại hoàn toàn

en: target specific option mismatch
vi: tuỳ chọn đặc trưng cho đích vẫn không tương ứng

en: the ' ' printf flag
vi: cờ printf ' '

en: the '!' strfmon flag
vi: cờ strfmon '!'

en: the '#' printf flag
vi: cờ printf '#'

en: the '#' strftime flag
vi: cờ strftime '#'

en: the ''' printf flag
vi: cờ printf '''

en: the ''' scanf flag
vi: cờ scanf '''

en: the '(' strfmon flag
vi: cờ strfmon '('

en: the '+' printf flag
vi: cờ printf '+'

en: the '+' strfmon flag
vi: cờ strfmon '+'

en: the '-' printf flag
vi: cờ printf '-'

en: the '-' strfmon flag
vi: cờ strfmon '-'

en: the '-' strftime flag
vi: cờ strftime '-'

en: the '0' printf flag
vi: cờ printf '0'

en: the '0' strftime flag
vi: cờ strftime '0'

en: the 'E' strftime modifier
vi: đồ sửa đổi 'E' của strftime

en: the 'I' printf flag
vi: cờ printf 'I'

en: the 'I' scanf flag
vi: cờ scanf 'I'

en: the 'O' modifier
vi: đồ sửa đổi 'O'

en: the 'O' strftime modifier
vi: đồ sửa đổi 'O' của strftime

en: the '^' strfmon flag
vi: cờ strfmon '^'

en: the '^' strftime flag
vi: cờ strftime '^'

en: the '_' strftime flag
vi: cờ strftime '_'

en: the 'a' scanf flag
vi: cờ scanf 'a'

en: the 'm' scanf flag
vi: cờ scanf 'm'

en: the 'q' diagnostic flag
vi: cờ chẩn đoán 'q'

en: the -shared option is not currently supported for VAX ELF
vi: tuỳ chọn -shared (chia sẻ) hiện thời không được hỗ trợ cho VAX ELF

en: the assignment suppression scanf feature
vi: tính năng scanf để thu hồi sự gán

en: the m210 does not have little endian support
vi: m210 không có hỗ trợ về cuối nhỏ

en: this is the insn:
vi: đây là lệnh:

en: too few arguments to %%:compare-debug-auxbase-opt
vi: quá ít đối số tới %%:compare-debug-auxbase-opt

en: too few arguments to %%:version-compare
vi: quá ít đối số tới %%:version-compare

en: too few arguments to %qE
vi: quá ít đối số cho %qE

en: too few arguments to constructor %q#D
vi: quá ít đối số cho hủy tử %q#D

en: too few arguments to function %q#D
vi: quá ít đối số cho hàm %q#D

en: too few arguments to member function %q#D
vi: quá ít đối số cho hàm thành viên %q#D

en: too few arguments to method %q#D
vi: quá ít đối số cho phương thức %q#D

en: too many %qs clauses
vi: quá nhiều mệnh đề %qs

en: too many arguments
vi: quá nhiều đối số

en: too many arguments to %%:compare-debug-auxbase-opt
vi: quá nhiều đối số tới %%:compare-debug-auxbase-opt

en: too many arguments to %%:compare-debug-dump-opt
vi: quá nhiều đối số tới %%:compare-debug-dump-opt

en: too many arguments to %%:compare-debug-self-opt
vi: quá nhiều đối số tới %%:compare-debug-self-opt

en: too many arguments to %%:version-compare
vi: quá nhiều đối số tới %%:version-compare

en: too many arguments to %qE
vi: quá nhiều đối số cho %qE

en: too many arguments to constructor %q#D
vi: quá nhiều đối số cho cấu tử %q#D

en: too many arguments to function %q#D
vi: quá nhiều đối số cho hàm %q#D

en: too many arguments to make
vi: quá nhiều đối số để thực hiện

en: too many arguments to member function %q#D
vi: quá nhiều đối số cho hàm thành viên %q#D

en: too many arguments to method %q#D
vi: quá nhiều đối số cho phương thức %q#D

en: too many filenames given.  Type %s --help for usage
vi: chỉ ra quá nhiều tên tập tin. Gõ lệnh %s --help để biết cách dùng

en: too many input files
vi: quá nhiều tập tin nhập vào

en: type has no methods
vi: kiểu không có phương thức

en: type of field declared here
vi: kiểu của trường được khai báo ở đây

en: unable to emulate %qs
vi: không thể mô phỏng %qs

en: unable to generate reloads for:
vi: không thể tạo ra việc nạp lại cho:

en: unable to open dynamic dependency '%s'
vi: không thể mở quan hệ phụ thuộc năng động '%s'

en: unable to print out operand yet; code == %d (%c)
vi: thậm chí không thể in ra toán hạng; mã == %d (%c)

en: unconditional %2d never executed
vi: %2d không điều kiện chưa bao giờ thực hiện

en: unconditional %2d taken %s
vi: %2d không điều kiện được lấy %s

en: unexpected AST of kind %s
vi: cần AST thuộc kiểu %s

en: unexpected attribute
vi: cần thuộc tính

en: unexpected base-type in cris_print_base
vi: gặp loại cơ bản (base-type) bất thường trong cris_print_index

en: unexpected index-type in cris_print_index
vi: gặp loại chỉ mục (index-type) bất thường trong cris_print_index

en: unexpected multiplicative operand
vi: gặp toán hạng nhân lên bất thường

en: unexpected operand
vi: gặp toán hạng bất thường

en: unexpected side-effects in address
vi: gặp hiệu ứng khác bất thường trong địa chỉ

en: union defined here
vi: union được định nghĩa ở đây

en: union has no members
vi: union không có thành viên nào

en: union has no named members
vi: union không có thành viên nào

en: unknown IRA algorithm %qs
vi: không hiểu thuật toán IRA %qs

en: unknown cc_attr value
vi: không hiểu giá trị cc_attr

en: unknown dest
vi: không rõ đích

en: unknown insn mode
vi: không rõ chế độ lệnh

en: unknown move insn:
vi: không rõ lệnh di chuyển:

en: unknown operator %qs in %%:version-compare
vi: không hiểu toán tử %qs trong %%:version-compare

en: unknown punctuation '%c'
vi: không hiểu dấu chấm câu '%c'

en: unknown relocation unspec
vi: không rõ bỏ ghi rõ bố trí lại

en: unknown spec function %qs
vi: không hiểu hàm đặc tả %qs

en: unknown src
vi: không rõ nguồn

en: unrecognizable insn:
vi: không nhận ra lệnh:

en: unrecognized address
vi: không nhận ra địa chỉ

en: unrecognized argument in option %qs
vi: không nhận ra đối số tới tuỳ chọn %qs

en: unrecognized argument to --help= option: %q.*s
vi: không nhận ra đối số cho tuỳ chọn --help=: %q.*s

en: unrecognized option -fdisable
vi: không thừa nhận tùy chọn -fdisable

en: unrecognized option -fenable
vi: không thừa nhận tùy chọn -fenable

en: unrecognized register name %qs
vi: không nhận ra tên thanh ghi %qs

en: unrecognized supposed constant
vi: không nhận ra điều nên là hằng số

en: unrecoverable error
vi: lỗi không thể phục hồi được

en: unterminated assembly dialect alternative
vi: sự xen kẽ phương ngôn assembly chưa chấm dứt

en: unused parameter %q+D
vi: tham số chưa dùng %q+D

en: unused variable %q+D
vi: biến chưa được dùng %q+D

en: use #include instead
vi: sử dụng #include để thay thế

en: use -Winvalid-pch for more information
vi: sử dụng -Winvalid-pch để có thêm thông tin

en: use __attribute__ ((vector_size)) instead
vi: sử dụng  __attribute__ ((vector_size)) để thay thế

en: using both @FILE with multiple files not implemented
vi: chưa thực hiện chức năng sử dụng @FILE với nhiều tập tin

en: using darwin64 ABI
vi: sử dụng darwin64 ABI

en: using old darwin ABI
vi: sử dụng darwin ABI kiểu cũ

en: valid arguments to %qs are: %s
vi: đối số hợp lệ cho cho %qs là: %s

en: variable %qD redeclared as function
vi: biến %qD được định nghĩa lại là một hàm

en: variable %qD set but not used
vi: biến %qD được đặt nhưng lại chưa được dùng

en: variable-sized object may not be initialized
vi: không thể sơ khởi một đối tượng có kích cỡ biến đổi

en: vec_extract only accepts 2 arguments
vi: vec_extract chỉ chấp nhận hai tham số

en: vec_insert only accepts 3 arguments
vi: vec_insert chỉ chấp nhận ba tham số

en: verify_cgraph_node failed
vi: verify_cgraph_node gặp lỗi

en: verify_eh_tree failed
vi: verify_eh_tree gặp lỗi

en: verify_flow_info failed
vi: verify_flow_info gặp lỗi

en: verify_gimple failed
vi: verify_gimple gặp lỗi

en: verify_ssa failed
vi: verify_ssa gặp lỗi

en: virtual function %q+D
vi: hàm ảo %q+D

en: volatile must be specified on any memory that is effected by DMA
vi: Thuộc tính hay thay đổi (volatile) phải được ghi rõ trên bất cứ vùng nhớ nào bị DMA tác động.

en: vtable for
vi: bảng vtable cho

en: warning:
vi: cảnh báo:

en: when writing output to %s: %m
vi: khi ghi kết xuất ra %s: %m

en: wide character array initialized from incompatible wide string
vi: mảng ký tự rộng bị sơ khởi từ chuỗi rộng không tương thích

en: wide character array initialized from non-wide string
vi: mảng ký tự rộng bị sơ khởi từ chuỗi không phải rộng

en: with
vi: với

en: with %q+#D
vi: với %q+#D

en: wrong insn in the fallthru edge
vi: gặp lệnh không đúng trong cạnh failthru

en: wrong number of arguments to %<__builtin_shuffle%>
vi: sai số tham số cho %<__builtin_shuffle%>

en: wrong type argument to %s
vi: sai kiểu đối số cho %s

en: wrong type argument to abs
vi: đối số có loại sai đối với bộ tuyệt đối

en: wrong type argument to bit-complement
vi: đối số có loại sai đối với phần bù bit

en: wrong type argument to conjugation
vi: đối số có loại sai đối với phần chia

en: wrong type argument to unary minus
vi: đối số có loại sai đối với dấu trừ nguyên phân

en: wrong type argument to unary plus
vi: đối số có loại sai đối với dấu cộng nguyên phân

en: xstormy16_print_operand: unknown code
vi: xstormy16_print_operand: gặp mã không rõ

en: z/Architecture
vi: z/Kiến trúc

en: zero-size array %qD
vi: mảng có kích thước bằng không %qD

en: {anonymous}
vi: {nặc danh}

en: {unknown}
vi: {không rõ}
