gcc 7.1-b20170101 - en to vi translation catalogue (3891 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, hãy xem tại:
    %s.

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

en: 
    Linker options
    ==============
vi: 
    Tùy 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: 
    Tùy 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 tùy chọn -W<chữ> để gửi thêm tùy 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ộ tạo/hủy.

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 tùy chọn dòng lệnh nào đó.

en:     -F, --fullname                      Print full filename
vi:     -F, --fullname                      In tên tập tin đầy đủ

en:     -f, --function                      Print function level info
vi:     -f, --function                      In thông tin mức hàm

en:     -h, --hotonly                       Only print info for hot objects/functions
vi:     -h, --hotonly                       Chỉ in thông tin cho hàm/đối tượng nóng

en:     -n, --normalize <int64_t>           Normalize the profile
vi:     -n, --normalize <int64_t>           Tiêu chuẩn hóa hồ sơ

en:     -o, --object                        Print object level info
vi:     -o, --object                        In thông tin mức đối tượng

en:     -o, --output <dir>                  Output directory
vi:     -o, --output <dir>                  Thư mục xuất

en:     -s, --scale <float or simple-frac>  Scale the profile counters
vi:     -s, --scale <float or simple-frac>  Tỷ lệ con đếm hồ sơ

en:     -t <float>, --hot_threshold <float> Set the threshold for hotness
vi:     -t <float>, --hot_threshold <float> Đặt ngưỡng cho không nóng

en:     -v, --verbose                       Verbose mode
vi:  -v, --verbose                         Chế độ chi tiết

en:     -w, --weight <w1,w2>                Set weights (float point values)
vi:     -w, --weight <w1,w2>                Đặt trọng lượng (giá trị dấu chấm động)

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

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

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

en:   %q+T has a non-trivial destructor
vi:   %q+T có một cấu tử non-trivial

en:   %qE is not equivalent to %qE
vi:   %qE không tương đương với %qE

en:   %qT is an ambiguous base class of %qT
vi:   %qT là lớp cơ sở chưa rõ ràng của %qT

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 tùy 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à tùy chọn nằm trong dấu
                                nháy và lệnh không được thực hiện.

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

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

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:   --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:   -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, assemble hay liên kết.

en:   -S                       Compile only; do not assemble or link.
vi:   -S                       Chỉ biên dịch, đừng assemble hay liên kết.

en:   -Wa,<options>            Pass comma-separated <options> on to the assembler.
vi:   -Wa,<các_tuỳ_chọn>      Chuyển cho chương trình assembler các tùy 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,<các_tuỳ_chọn>      Chuyển cho bộ liên kết <các tùy 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,<các_tuỳ_chọn>       Chuyển cho bộ tiền xử lý 
                                 các tùy 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 assembler.

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ố nhưng đừng liên kết.

en:   -c, --branch-counts             Output counts of branches taken
                                        rather than percentages
vi:   -c, --branch-counts             Đưa ra số lượng 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 rồi thoát.

en:   -h, --help                      Print this help, then exit
vi:   -h, --help                      Hiển thị trợ giúp này rồi 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:   -m, --demangled-names           Output demangled function names
vi:   -m, --demangled-names           Xuất các tên hàm không được quản lý

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 biên dịch
                                 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-tin>             Để kết xuất vào <tập-tin> này.

en:   -o, --object-directory DIR|FILE Search for object files in DIR or called FILE
vi:   -o, --object-directory TMỤC|TẬP-TIN
            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:   -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 tùy 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-multiarch         Display the target's normalized GNU triplet, used as
                               a component in the library path.
vi:   -print-multiarch         Hiển thị bộ ba GNU thường hóa của đích, được dùng như
                               một thành phần trong đường dẫn thư viện.

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 xóa bỏ tập tin trung gian.

en:   -save-temps=<arg>        Do not delete intermediate files.
vi:   -save-temps=<đối_số>     Đừng xóa 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-tin>         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>       Coi rằng 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, --version                         Print version number, then exit
vi:   -v, --version                        Hiển thị số thứ tự phiên bản, sau đó thoát.

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ữ>            Chỉ định ngôn ngữ của những tập tin đầu vào mà theo sau
                                Các ngôn ngữ có thể sử dụng: c c++ assembler 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:   -x, --hash-filenames            Hash long pathnames
vi:   -x, --hash-filenames            Băm các đường dẫn dài

en:   a qualified-id is required
vi:   cần qualified-id

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:   base %qT
vi:   cơ sở %qT

en:   base class %qT of %q+T is non-literal
vi:   lớp cơ sở %qT của %q+T là non-literal

en:   but %d required
vi:   nhưng cần %d

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

en:   candidate expects %d argument, %d provided |   candidate expects %d arguments, %d provided
vi[0]:   ứng cử cần %d đối số, %d được cung cấp

en:   candidate expects at least %d argument, %d provided |   candidate expects at least %d arguments, %d provided
vi[0]:   ứng cử cần ít nhất %d đối số, nhưng cung cấp %d

en:   cannot convert %qE (type %qT) to type %qT
vi:   không thể chuyển đổi %qE (kiểu %qT) thành kiểu %qT

en:   crosses initialization of %q#D
vi:   sự khởi tạo chéo của %q+#D

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

en:   enters OpenMP structured block
vi:   vào khối được cấu trúc OpenMP

en:   exits OpenMP structured block
vi:   thoát khỏi khối được cấu trúc OpenMP

en:   expected %qD but got %qD
vi:   cần %qD nhưng lại nhận %qD

en:   expected a class template, got %qE
vi:   cần mẫu lớp, nhưng lại nhận được %qE

en:   expected a class template, got %qT
vi:   cần mẫu lớp, nhưng lại nhận được %qT

en:   expected a constant of type %qT, got %qT
vi:   cần hằng của kiểu %qT, nhưng lại nhận được %qT

en:   expected a template of type %qD, got %qT
vi:   cần mẫu kiểu %qD, nhưng lại nhận được %qT

en:   expected a type, got %qE
vi:   cần kiểu, nhưng lại nhận %qE

en:   expected a type, got %qT
vi:   cần một kiểu, nhưng lại nhận được %qT

en:   from definition of %q#D
vi:   từ định nghĩa của %q#D

en:   from here
vi:   từ đây

en:   in call to %qD
vi:   trong gọi đến %qD

en:   in evaluation of %<%Q(%#T, %#T)%>
vi:   trong định giá %<%Q(%#T, %#T)%>

en:   in thrown expression
vi:   nằm trong biểu thức thrown

en:   member function type %qT is not a valid template argument
vi:   kiểu hàm thành viên %qT không phải là một đối số mẫu hợp lệ

en:   merge [options] <dir1> <dir2>         Merge coverage file contents
vi:   merge [options] <dir1> <dir2>         Hòa trộng nội dung tập tin phủ quét

en:   mismatched types %qT and %qT
vi:   kiểu không khớp %qT và %qT

en:   non-static data member %qD has non-literal type
vi:   thành viên dữ liệu không-tĩnh %qD có kiểu không-văn-chương

en:   non-static data member %qD has volatile type
vi:   thành viên dữ liệu không-tĩnh %qD có kiểu hay thay đổi

en:   or %<operator=(const %T&)%>
vi:   hoặc %<operator=(const %T&)%>

en:   or a %<transaction_may_cancel_outer%> function
vi:   hoặc một hàm %<transaction_may_cancel_outer%>

en:   overlap [options] <dir1> <dir2>       Compute the overlap of two profiles
vi:   overlap [options] <dir1> <dir2>       Tính toán chồng đè hai hồ sơ

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:   rewrite [options] <dir>               Rewrite coverage file contents
vi:   rewrite [options] <dir>               Ghi lại nội dung tập tin phủ quét

en:   skips initialization of %q#D
vi:   bỏ qua sự khởi tạo của %q#D

en:   when initialized here
vi:   khi khởi tạo ở đây

en:  (operand type is %qT)
vi:  (kiểu toán hạng là %qT)

en:  (operand types are %qT and %qT)
vi:  (các kiểu toán hạng là %qT và %qT)

en:  (operand types are %qT, %qT, and %qT)
vi:  (các kiểu toán hạng là %qT, %qT, and %qT)

en:  All options with the desired characteristics have already been displayed
vi:  Đã hiển thị tất cả các tùy 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 tùy 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 tùy 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: !$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L
vi: !$OMP ATOMIC phân bổ bên trong phải là MIN, MAX, IAND, IOR hay IEOR tại %L

en: "USE :: module" at %C
vi: "USE :: module" tại %C

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: $ descriptor at %L
vi: $ mô tả tại %L

en: %<!%> not valid in GIMPLE
vi: %<!%> không hợp lệ trong GIMPLE

en: %<#pragma GCC optimize (string [,string]...)%> does not have a final %<)%>
vi: %<#pragma tối ưu GCC (chuỗi [,chuỗi]…)%> không có một %<)%> kết thúc

en: %<#pragma GCC optimize%> is not a string or number
vi: %<#pragma GCC optimize%> không phải là một chuỗi hay số

en: %<#pragma GCC option%> is not a string
vi: %<#pragma GCC option%> không phải là một chuỗi

en: %<#pragma GCC pch_preprocess%> must be first
vi: %<#pragma GCC pch_preprocess%> phải là đầu tiên

en: %<#pragma STDC FLOAT_CONST_DECIMAL64%> is not supported for C++
vi: %<#pragma STDC FLOAT_CONST_DECIMAL64%> không được hỗ trợ cho C++

en: %<#pragma STDC FLOAT_CONST_DECIMAL64%> is not supported on this target
vi: %<#pragma STDC FLOAT_CONST_DECIMAL64%> không được hỗ trợ trên đích này

en: %<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause
vi: %<#pragma acc update%> phải chứa ít nhất là một mệnh đề %<device%> hay %<host%> hay %<self%>

en: %<#pragma omp atomic capture%> uses two different expressions for memory
vi: %<#pragma omp atomic capture%> sử dụng hai biểu thức khác nhau cho bộ nhớ

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 weak%> declaration of %q+D not allowed, ignored
vi: không cho khai báo %<#pragma weak%> của %q+D, bỏ qua

en: %<#pragma%> is not allowed here
vi: %<#pragma%> là không được phép ở đây

en: %<%%%> constraint used with last operand
vi: %<%%%> hằng được dùng với toán hạng cuối

en: %<%%%c%> yields only last 2 digits of year
vi: %<%%%c%> chỉ sinh ra 2 số cuối của năm

en: %<%%%c%> yields only last 2 digits of year in some locales
vi: %<%%%c%> chỉ sinh ra 2 số cuối của năm trong một số địa phương

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

en: %<%D::%D%> is not a member of %qT
vi: %<%D::%D%> không phải là thành viên của %qT

en: %<%E::%E%> has not been declared
vi: %<%E::%E%> chưa được khai báo

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: %<%E::%E%> is not a class, namespace, or enumeration
vi: %<%E::%E%> không phải là một lớp, namespace, enumeration

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

en: %<%T::%D%> names constructor in %qT
vi: %<%T::%D%> các tên cấu tử trong %qT

en: %<%T::%E%> has not been declared
vi: %<%T::%E%> chưa được khai báo

en: %<%T::%E%> is not a type
vi: %<%T::%E%> không phải một kiểu

en: %<%T::%E%> names the constructor, not the type
vi: %<%T::%E%> tên cấu tử, không phải kiểu

en: %<%c%E%> not found in protocol(s)
vi: %<%c%E%> không tìm thấy trong giao thức

en: %<&&%> not valid in GIMPLE
vi: %<&&%> không hợp lệ trong GIMPLE

en: %<)%> expected at %C
vi: cần %<)%> tại %C

en: %<-Wabi=1%> is not supported, using =2
vi: %<-Wabi=1%> không được hỗ trợ, dùng =2

en: %<-fabi-compat-version=1%> is not supported, using =2
vi: %<-fabi-compat-version=1%> không được hỗ trợ, dùng =2

en: %<-fabi-version=1%> is no longer supported
vi: %<-fabi-version=1%> không còn tiếp tục được hỗ trợ nữa

en: %<-femit-struct-debug-detailed=dir:...%> must allow at least as much as %<-femit-struct-debug-detailed=ind:...%>
vi: %<-femit-struct-debug-detailed=dir:…%> phải cho phép ít nhất là %<-femit-struct-debug-detailed=ind:…%>

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

en: %<-fobjc-sjlj-exceptions%> is ignored for %<-fgnu-runtime%>
vi: %<-fobjc-sjlj-exceptions%> bị bỏ qua đối với %<-fgnu-runtime%>

en: %<-fsplit-stack%> currently only supported on GNU/Linux
vi: %<-fsplit-stack%> hiện nay chỉ được hỗ trợ trên GNU/Linux

en: %<-fsplit-stack%> currently only supported on PowerPC64 GNU/Linux with glibc-2.18 or later
vi: %<-fsplit-stack%> hiện nay chỉ được hỗ trợ trên GNU/Linux PowerPC64 với glibc-2.18 hay mới hơn

en: %<-gnat%> misspelled as %<-gant%>
vi: %<-gnat%> gõ nhầm là %<-gant%>

en: %<-march=%s%> is not compatible with the selected ABI
vi: %<-march=%s%> không tương thích với ABI đã chọn

en: %<-mcpu=%> is deprecated; use %<-mtune=%> or %<-march=%> instead
vi: %<-mcpu=%> đã lạc hậu; dùng %<-mtune=%> hoặc %<-march=%> để thay thế

en: %<-mdynamic-no-pic%> overrides %<-fpic%>, %<-fPIC%>, %<-fpie%> or %<-fPIE%>
vi: %<-mdynamic-no-pic%> đè lên %<-fpic%>, %<-fPIC%>, %<-fpie%> hay %<-fPIE%>

en: %<-mfused-madd%> is deprecated; use %<-ffp-contract=%> instead
vi: %<-mfused-madd%> đã lạc hậu; dùng %<-ffp-contract=%> để thay thế

en: %<-mgp32%> and %<-mfp64%> can only be combined when using the o32 ABI
vi: %<-mgp32%> và %<-mfp64%> chỉ có thể được tổ hợp cùng nhau khi sử dụng o32 ABI

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

en: %<-mgp64%> used with a 32-bit ABI
vi: %<-mgp64%> được dùng với 32-bit ABI

en: %<-mgp64%> used with a 32-bit processor
vi: %<-mgp64%> được dùng với bộ xử lý 32-bit

en: %<-mintel-syntax%> and %<-mno-intel-syntax%> are deprecated; use %<-masm=intel%> and %<-masm=att%> instead
vi: %<-mintel-syntax%> và %<-mno-intel-syntax%> đã lạc hậu; dùng %<-masm=intel%> và %<-masm=att%> để thay thế

en: %<-mips3d%> requires %<-mpaired-single%>
vi: %<-mips3d%> cần %<-mpaired-single%>

en: %<-mno-gpopt%> needs %<-mexplicit-relocs%>
vi: %<-mno-gpopt%> cần %<-mexplicit-relocs%>

en: %<-mrtd%> is ignored in 64bit mode
vi: %<-mrtd%> bị bỏ qua trong chế độ 64bit

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

en: %<-msseregparm%> used without SSE enabled
vi: %<-msseregparm%> được dùng mà không bật SSE

en: %<-x %s%> after last input file has no effect
vi: %<-x %s%> sau tập tin đầu vào cuối không chịu tác động

en: %<::%D%> has not been declared
vi: %<::%D%> chưa được khai báo

en: %<::%E%> has not been declared
vi: %<::%E%> chưa được khai báo

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

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

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

en: %<::main%> must return %<int%>
vi: %<::main%> phải trả về %<int%>

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

en: %<@dynamic%> not in @implementation context
vi: %<@dynamic%> không trong ngữ cảnh @implementation

en: %<@dynamic%> requires the @interface of the class to be available
vi: %<@dynamic%> cần @interface của lớp sẵn có

en: %<@end%> must appear in an @implementation context
vi: %<@end%> phải xuất hiện trong một ngữ cảnh @implementation

en: %<@optional%> is allowed in @protocol context only
vi: %<@optional%> chỉ cho phép tronh ngữ cảnh @protocol

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

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

en: %<@package%> presently has the same effect as %<@public%>
vi: %<@package%> hiện tại có cùng hiệu ứng với %<@public%>

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

en: %<@required%> is allowed in @protocol context only
vi: %<@required%> chỉ được phép trong ngữ cảnh @protocol

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

en: %<@synchronized%> argument is not an object
vi: %<@synchronized%> đối số không phải là một đối tượng

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

en: %<@synthesize%> not in @implementation context
vi: %<@synthesize%> không trong ngữ cảnh @implementation

en: %<@synthesize%> requires the @interface of the class to be available
vi: %<@synthesize%> cần @interface của lớp sẵn có

en: %<@throw%> argument is not an object
vi: %<@throw%> đối số không phải là một đối tượng

en: %<@try%> without %<@catch%> or %<@finally%>
vi: %<@try%> không có %<@catch%> hay %<@finally%>

en: %<G0%> in format at %L
vi: %<G0%> trong chuỗi định dạng tại %L

en: %<[*]%> not in a declaration
vi: %<[*]%> không trong khai báo

en: %<_Atomic%> %qD in %qs clause
vi: %<_Atomic%> %qD trong mệnh đề %qs

en: %<_Atomic%> %qE in %<reduction%> clause
vi: %<_Atomic%> %qE trong mệnh đề %<reduction%>

en: %<_Atomic%> %qE in %qs clause
vi: %<_Atomic%> %qE trong mệnh đề %qs

en: %<_Atomic%> applied to a qualified type
vi: %<_Atomic%> áp dụng cho kiểu hạn định

en: %<_Atomic%> in Objective-C
vi: %<_Atomic%> trong Objective-C

en: %<_Noreturn%> in empty declaration
vi: %<_Noreturn%> trong khai báo trống rỗng

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

en: %<__alignof%> applied to a bit-field
vi: %<__alignof%> được áp dụng cho trường bít

en: %<__auto_type%> used with a bit-field initializer
vi: %<__auto_type%> được áp dụng cho một bộ khởi tạo trường-bit

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

en: %<__builtin_longjmp%> second argument must be 1
vi: %<__builtin_longjmp%> đối số thứ hai phải là 1

en: %<__builtin_next_arg%> called without an argument
vi: %<__builtin_next_arg%> được gọi mà không có đối số

en: %<__gcc_host_wide_int__%> is not defined as %<long%> or %<long long%>
vi: %<__gcc_host_wide_int__%> không được định nghĩa như là kiểu %<long%> hay %<long long%>

en: %<__gcc_host_wide_int__%> is not defined as a type
vi: %<__gcc_host_wide_int__%> không được định nghĩa là một kiểu

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

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

en: %<__label__%> not at the beginning of a block
vi: %<__label__%> không ở đầu của một khối

en: %<__restrict%> can only be specified for objects and functions
vi: %<__restrict%> chỉ có thể được chỉ định cho đối tượng và hàm

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

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

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

en: %<__thread%> can only be specified for objects and functions
vi: %<__thread%> chỉ có thể được chỉ định cho đối tượng và hàm

en: %<__transaction_cancel%> not within %<__transaction_atomic%>
vi: %<__transaction_cancel%> không nằm trong %<__transaction_atomic%>

en: %<__transaction_cancel%> within a %<__transaction_relaxed%>
vi: %<__transaction_cancel%> nằm trong một %<__transaction_relaxed%>

en: %<async%> expression must be integral
vi: %<async%> biểu thức phải nguyên

en: %<auto%> changes meaning in C++11; please remove it
vi: %<auto%> thay đổi ý nghĩa trong C++11; hãy bỏ nó đi

en: %<const%> can only be specified for objects and functions
vi: %<const%> chỉ có thể được chỉ định cho lớp và hàm

en: %<device%> id must be integral
vi: chỉ số %<device%> phải là số nguyên

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

en: %<enum %E%> declared in %<for%> loop initial declaration
vi: %<enum %E%> được khai báo trong khai báo khởi tạo vòng lặp %<for%>

en: %<explicit%> can only be specified for constructors
vi: %<explicit%> chỉ có thể được chỉ định cho cấu tử

en: %<explicit%> outside class declaration
vi: %<explicit%> ngoài khai báo lớp

en: %<friend%> can only be specified inside a class
vi: %<friend%> chỉ có thể được chỉ định trong một lớp

en: %<friend%> used outside of class
vi: %<friend%> được dùng bên ngoài lớp

en: %<gang%> num expression must be integral
vi: biểu thức số %<gang%> phải nguyên

en: %<gang%> num value must be positive
vi: %<gang%> giá trị phải dương

en: %<gang%> static expression must be integral
vi: biểu thức tĩnh %<gang%> phải nguyên

en: %<gnu_inline%> attribute present on %q+D
vi: thuộc tính %<gnu_inline%> hiện tại trên %q+D

en: %<grainsize%> expression must be integral
vi: chỉ số %<device%> phải là số nguyên

en: %<grainsize%> value must be positive
vi: %<grainsize%> giá trị phải dương

en: %<inline%> can only be specified for functions
vi: %<inline%> chỉ có thể được chỉ định cho hàm

en: %<inline%> in empty declaration
vi: %<inline%> trong khai báo trống rỗng

en: %<inline%> specified for friend class declaration
vi: %<inline%> được chỉ định cho khai báo lớp bạn

en: %<location_t%> is not defined as a type
vi: %<location_t%> không được định nghĩa như là một kiểu

en: %<locus%> is not defined as a type
vi: %<locus%> không được định nghĩa như là một kiểu

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

en: %<main%> declared %<_Noreturn%>
vi: %<main%> được khai báo %<_Noreturn%>

en: %<namespace%> definition is not allowed here
vi: %<namespace%> không cho phép định nghĩa ở đây

en: %<noreturn%> function does return
vi: %<noreturn%> hàm trả về

en: %<num_tasks%> value must be positive
vi: %<num_tasks%> giá trị phải dương

en: %<num_teams%> value must be positive
vi: %<num_teams%> giá trị phải dương

en: %<num_threads%> value must be positive
vi: %<num_threads%> giá trị phải dương

en: %<operator delete%> must return type %qT
vi: %<operator delete%> phải trả về kiểu %qT

en: %<operator delete%> takes type %qT as first parameter
vi: %<operator delete%> nhận kiểu %qT như là đối số thứ nhất

en: %<operator new%> must return type %qT
vi: %<operator new%> phải trả về kiểu %qT

en: %<operator new%> takes type %<size_t%> (%qT) as first parameter
vi: %<operator new%> nhận kiểu %<size_t%> (%qT) như là đối số thứ nhất

en: %<operator%s%> in %<%E %s %E%>
vi: %<operator%s%> trong %<%E %s %E%>

en: %<operator%s%> in %<%E%s%>
vi: %<operator%s%> trong %<%E%s%>

en: %<operator%s%> in %<%s%E%>
vi: %<operator%s%> trong %<%s%E%>

en: %<operator=%> should return a reference to %<*this%>
vi: %<operator=%> cần trả về một tham chiếu đến %<*this%>

en: %<operator[]%> in %<%E[%E]%>
vi: %<operator[]%> trong %<%E[%E]%>

en: %<priority%> expression must be integral
vi: chỉ số %<device%> phải là số nguyên

en: %<priority%> value must be non-negative
vi: %<priority%> giá trị phải dương

en: %<readonly%> attribute conflicts with %<setter%> attribute
vi: thuộc tính %<readonly%> xung đột với %<setter%>

en: %<return%> with a value, in function returning void
vi: %<return%> với một giá trị, trong hàm trả lại void (rỗng)

en: %<return%> with no value, in function returning non-void
vi: %<return%> (trả lại) không có giá trị, trong hàm trả lại non-void (không rỗng)

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

en: %<sizeof...%> argument must be surrounded by parentheses
vi: đối số cho %<sizeof…%> phải được bao quanh bởi dấu ngoặc đơn

en: %<static%> may not be used when defining (as opposed to declaring) a static data member
vi: %<static%> không sử dụng khi định nghĩa (như ngược với khai báo) một thành viên dữ liệu tĩnh

en: %<struct %E%> declared in %<for%> loop initial declaration
vi: %<struct %E%> được khai báo trong khai báo khởi tạo vòng lặp %<for%>

en: %<this%> may not be used in this context
vi: %<this%> có lẽ không nên được dùng trong ngữ cảnh này

en: %<thread_limit%> expression must be integral
vi: %<thread_limit%> biểu thức phải nguyên

en: %<thread_limit%> value must be positive
vi: %<thread_limit%> giá trị phải dương

en: %<tree%> is not defined as a pointer type
vi: %<tree%> không được định nghĩa là kiểu con trỏ

en: %<tree%> is not defined as a type
vi: %<tree%> không được định nghĩa như là một kiểu

en: %<typedef%> was ignored in this declaration
vi: %<typedef%> bị bỏ qua trong khai báo này

en: %<typeid%> operator cannot appear in a constant-expression
vi: %<typeid%> toán tử không thể xuất hiện trong biểu thức hằng

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

en: %<union %E%> declared in %<for%> loop initial declaration
vi: %<union %E%> được khai báo trong khai báo khởi tạo vòng lặp %<for%>

en: %<vector%> length expression must be integral
vi: chiều dài %<vector%> phải là số nguyên

en: %<virtual%> can only be specified for functions
vi: %<virtual%> chỉ có thể được chỉ định cho hàm

en: %<virtual%> outside class declaration
vi: %<virtual%> ngoài khai báo lớp

en: %<void%> must be the only parameter
vi: %<void%> phải là đối số duy nhất

en: %<volatile%> can only be specified for objects and functions
vi: %<volatile%> chỉ có thể được chỉ định cho đối tượng và hàm

en: %<wait%> expression must be integral
vi: biểu thức %<wait%> phải là số nguyên

en: %<worker%> num expression must be integral
vi: biểu thức số %<worker%> phải là số nguyên

en: %<||%> not valid in GIMPLE
vi: %<||%> không hợp lệ trong GIMPLE

en: %<~%> on a boolean expression
vi: %<~%> trên một biểu thức lôgíc

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: %i-bit mode not compiled in
vi: chế độ %i-bit chưa được biên dịch bên trong

en: %q#D conflicts with a previous declaration
vi: %q#D xung đột với khai báo trước

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

en: %q#D explicitly defaulted here
vi: %q#D đã là mặc định rõ ràng ở đây

en: %q#D has incomplete type
vi: đối số %q#D có kiểu chưa đầy đủ

en: %q#D is inaccessible within this context
vi: %q#D là không thể truy cập trong ngữ cảnh này

en: %q#D is not a function template
vi: %q#D không phải là hàm mẫu

en: %q#D is not const
vi: %q#D không là const

en: %q#D is volatile
vi: %q#D là volatile

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

en: %q#D previously declared here
vi: %q#D trước định nghĩa ở đây

en: %q#D previously defined here
vi: %q#D trước được định nghĩa ở đây

en: %q#D should be initialized
vi: %q#D nên được khởi tạo

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

en: %q#T has no member named %qE; did you mean %qE?
vi: %q#T không có thành viên nào mang tên %qE; ý bạn là %qE?

en: %q#T has pointer data members
vi: %q#T có thành viên dữ liệu con trỏ

en: %q#T has virtual base classes
vi: %q#T có lớp cơ sở ảo

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

en: %q#T is not a template
vi: %q#T không phải là một mẫu

en: %q#T used where a %qT was expected
vi: %q#T được dùng ở nơi mà %qT cần

en: %q#T was previously declared here
vi: %q#T trước đã khai báo ở đây

en: %q+#D cannot be declared
vi: %q+#D không thể được khai báo

en: %q+#D is not a static data member of %q#T
vi: %q+#D không phải là thành viên tĩnh của %q#T

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

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

en: %q+D static data member inside of declare target directive
vi: thành viên dữ liệu tĩnh %q+D bên trong của chỉ thị khai báo đích

en: %q+D takes only zero or two arguments
vi: %q+D chỉ nhận không hoặc hai đối số

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: %q+T is not literal because:
vi: %q+T không là kiểu văn chương vì:

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

en: %qD can be marked override
vi: %q#D không thể được tạo đè

en: %qD cannot be defaulted
vi: %qD không thể là mặc định

en: %qD cannot be used as a function
vi: %qD không thể được dùng như một hàm

en: %qD cannot have default arguments
vi: %qD không thể có đối số mặc định

en: %qD changed semantics in GCC 4.4
vi: %qD đã đổi ngữ nghĩa trong GCC 4.4

en: %qD declared as a %<virtual%> field
vi: %qD được khai báo như là trường %<virtual%>

en: %qD declared as a %<virtual%> parameter
vi: %qD được khai báo như là đối số %<virtual%>

en: %qD declared as a %<virtual%> type
vi: %qD được khai báo như là kiểu %<virtual%>

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 as an %<inline%> field
vi: %qD được khai báo là một trường %<inline%>

en: %qD declared as an %<inline%> parameter
vi: %qD được khai báo là một đối số %<inline%>

en: %qD declared as an %<inline%> type
vi: %qD được khai báo là một kiểu %<inline%>

en: %qD declared as reference but not initialized
vi: %qD được khai báo như là một tham chiếu nhưng lại chưa được khởi tạo

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

en: %qD declared here, later in the translation unit
vi: %+D đã khai báo weakref sau khi được dùng

en: %qD defined but not used
vi: %q+D được định nghĩa nhưng không dùng

en: %qD does not have a mappable type in %qs clause
vi: %qD không phải một biến trong mệnh đề %qs

en: %qD does not name an enumeration in %qT
vi: %qD không phải tên một kiểu enumeration trong %qT

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

en: %qD has incomplete type
vi: %qD có kiểu chưa đầy đủ

en: %qD in %<reduction%> clause is a zero size array
vi: %qD trong mệnh đề %<reduction%> là một mạng cỡ không

en: %qD invalid in lambda
vi: %qD không hợp lệ trong lambda

en: %qD is a namespace
vi: %qD là một namespace

en: %qD is a usual (non-placement) deallocation function
vi: %qD thường không phải là hàm non-static

en: %qD is already a friend of %qT
vi: %qD đã sẵn là bạn của %qT

en: %qD is already a friend of class %qT
vi: %qD đã sẵn là bạn của lớp %qT

en: %qD is already defined in %qT
vi: %qD đã định nghĩa sẵn trong %qT

en: %qD is already defined in class %qT
vi: %qD đã sẵn định nghĩa trong %qT

en: %qD is already defined in the class %qT
vi: %qD đã định nghĩa trong lớp %qT

en: %qD is an enumeration template
vi: %qD là một mẫu liệt kê

en: %qD is defined with tls model %s
vi: %qD được định nghĩa với mô hình tls %s

en: %qD is deprecated
vi: %qD đã lạc hậu

en: %qD is deprecated: %s
vi: %qD đã lạc hậu: %s

en: %qD is initialized with itself
vi: %qD được khởi tạo bằng chính nó

en: %qD is normally a non-static function
vi: %qD thường không phải là hàm non-static

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

en: %qD is not a function template
vi: %qD không phải là một mẫu hàm

en: %qD is not a member of %qD
vi: %qD không phải là thành viên của %qD

en: %qD is not a member of %qT
vi: %qD không phải là thành viên của %qT

en: %qD is not a member template function
vi: %qD không phải là hàm thành viên mẫu

en: %qD is not a namespace-name
vi: %qD không là một namespace-name

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

en: %qD is not a static data member of a class template
vi: %qD không phải là một thành viên dữ liệu tĩnh của một mẫu lớp

en: %qD is not a template
vi: %qD không phải một mẫu

en: %qD is not a template function
vi: %qD không phải là một hàm mẫu

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 not a variable in %<aligned%> clause
vi: %qD không phải một biến trong mệnh đề  %<aligned%>

en: %qD is not a variable in %qs clause
vi: %qD không phải một biến trong mệnh đề %qs

en: %qD is not a variable in clause %<lastprivate%>
vi: %qD không phải một biến trong mệnh đề %<lastprivate%>

en: %qD is not a variable in clause %qs
vi: %qD không phải một biến trong mệnh đề %qs

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

en: %qD is not an argument in %<uniform%> clause
vi: %qD không phải một đối số trong mệnh đề %<uniform%>

en: %qD is not captured
vi: %qD không bị bắt

en: %qD is not compatible with %qD
vi: %qD không tương thích với %qD

en: %qD is threadprivate variable in %qs clause
vi: %qD không phải một biến trong mệnh đề %qs

en: %qD may not be declared as static
vi: %qD không được khai báo như là tĩnh

en: %qD must be a non-member function
vi: %qD phải là một hàm không-thành-viên

en: %qD not defined
vi: %qD chưa được định nghĩa

en: %qD should be initialized
vi: %qD cần được khởi tạo

en: %qD should return by value
vi: %qD cần trả về bằng giá trị

en: %qD used before its definition
vi: %qD được dùng trước khi nó được định nghĩa

en: %qD used in its own initializer
vi: %qD được dùng trong bộ khởi tạo của chính nó

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

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

en: %qD was not declared %<constexpr%>
vi: %qD chưa được khai báo %<constexpr%>

en: %qD was not declared in this scope
vi: %qD chưa được khai báo trong phạm vi này

en: %qD was not initialized with a constant expression
vi: %qD không được khởi tạo với một biểu thức hằng

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

en: %qD will be initialized after
vi: %qD sẽ được khởi tạo sau

en: %qE argument not an identifier
vi: %qE đối số không phải là một định danh

en: %qE attribute duplicated
vi: thuộc tính %qE bị trùng

en: %qE attribute follows %qE
vi: thuộc tính %qE theo %qE

en: %qE attribute ignored
vi: thuộc tính %qE bị lờ đi

en: %qE attribute ignored for %qE
vi: thuộc tính %qE bị lờ đi cho %qE

en: %qE attribute ignored on types
vi: Thuộc tính %qE bị lờ đi với các kiểu

en: %qE attribute is only applicable on functions
vi: thuộc tính %qE chỉ áp dụng cho các hàm

en: %qE attribute on non-volatile variable
vi: Thuộc tính %qE trên biến không hay thay đổi

en: %qE attribute only affects top level objects
vi: Thuộc tính %qE chỉ được áp dụng cho các đối tượng mức

en: %qE attribute only applies to SH2A
vi: Thuộc tính %qE chỉ được áp dụng cho SH2A

en: %qE attribute only applies to functions
vi: thuộc tính %qE chỉ áp dụng cho các hàm

en: %qE attribute only applies to variables
vi: Thuộc tính %qE chỉ được áp dụng cho các biến

en: %qE attribute only available for 32-bit
vi: Thuộc tính %qE chỉ dùng được trên hệ thống 32-bit

en: %qE attribute requires a string argument
vi: Thuộc tính %qE cần tham số là chuỗi

en: %qE attribute requires a void return type
vi: Thuộc tính %qE cần kiểu trả về là void

en: %qE cannot be used as a function
vi: %qE không thể dùng như một hàm

en: %qE does not have a mappable type in %qs clause
vi: %qE không phải một kiểu ánh xạ được trong mệnh đề %qs

en: %qE does not have pointer or array type
vi: %qE không có con trỏ hay kiểu mảng

en: %qE does not name a type
vi: %qE không phải tên một kiểu

en: %qE has invalid type for %<reduction(%s)%>
vi: %qE có kiểu không hợp lệ cho %<reduction(%s)%>

en: %qE has not been declared
vi: %qE chưa được khai báo

en: %qE in %q#T does not name a template type
vi: %qE trong %q#T không phải là tên của kiểu mẫu

en: %qE in %q#T does not name a type
vi: %qE trong %q#T không là tên một kiểu

en: %qE is a member of a union
vi: %qE không phải là thành viên của union

en: %qE is deprecated
vi: %qE đã lạc hậu

en: %qE is deprecated: %s
vi: %qE đã lạc hậu: %s

en: %qE is neither a variable nor a function name in clause %qs
vi: %qE không phải một biến cũng không phải tên hàm trong mệnh đề %qs

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 class template
vi: %qE không phải một lớp mẫu

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 template
vi: %qE không phải là một mẫu

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

en: %qE is not a variable in %<aligned%> clause
vi: %qE không phải một biến trong mệnh đề %<aligned%>

en: %qE is not a variable in %qs clause
vi: %qE không phải một biến trong mệnh đề %qs

en: %qE is not an argument in %<uniform%> clause
vi: %qE không phải một đối số trong mệnh đề %<uniform%>

en: %qE is not at beginning of declaration
vi: %qE không ở đầu của khai báo

en: %qE is not initialized
vi: %qE chưa được khởi tạo

en: %qE is not of type %qT
vi: %qE không là kiểu %qT

en: %qE may not respond to %<%c%E%>
vi: %qE có lẽ không đáp ứng với %<%c%E%>

en: %qE must be %<threadprivate%> for %<copyin%>
vi: %qE phải là %<threadprivate%> với %<copyin%>

en: %qE needs isa option %s
vi: %qE cần là tùy chọn %s

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

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

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

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

en: %qT defined with direct virtual base
vi: %qT được định nghĩa cơ sở trực tiếp ảo

en: %qT defined with multiple direct bases
vi: %qT được định nghĩa với cơ sở đa trực tiếp

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

en: %qT has no member named %qE; did you mean %qE?
vi: %qT không có thành viên nào mang tên %qE; ý bạn là %qE?

en: %qT is already a friend of %qT
vi: %qT đã sẵn là bạn của %qT

en: %qT is not a base of %qT
vi: %qT không là cơ sở của %qT

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

en: %qT is not a class type
vi: %qT không phải là kiểu lớp

en: %qT is not a class, struct, or union type
vi: %qT không phải có kiểu lớp, cấu trúc hay union

en: %qT is not a member of %qT
vi: %qT không phải là thành viên của %qT

en: %qT is not a nested class of %qT
vi: %qT không phải lớp lồng nhau của %qT

en: %qT is not a pointer-to-object type
vi: %qT không phải kiểu con trỏ đến đối tượng

en: %qT is not a template
vi: %qT không phải một mẫu

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

en: %qT is not an enumeration type
vi: %qT không phải một kiểu enumeration

en: %qT is/uses unnamed type
vi: %qT là/dùng kiểu nặc danh

en: %qT referred to as %qs
vi: %qT được coi là %qs

en: %qT referred to as enum
vi: %qT được coi là enum

en: %qs argument of %qs intrinsic at %L cannot be INTENT(IN)
vi: đối số %qs của %qs intrinsict tại %L phải là INTENT(IN)

en: %qs argument of %qs intrinsic at %L must be %s
vi: đối số %qs của %qs intrinsict tại %L phải là %s

en: %qs argument of %qs intrinsic at %L must be ALLOCATABLE
vi: đối số %qs của %qs intrinsict tại %L phải là ALLOCATABLE

en: %qs argument of %qs intrinsic at %L must be INTEGER
vi: Tham số %qs của hạn chế %qs tại %L phải là SỐ-NGUYÊN

en: %qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE
vi: đối số %qs của %qs intrinsict tại %L phải là NGUYÊN hay THỦ TỤC

en: %qs argument of %qs intrinsic at %L must be INTEGER or REAL
vi: đối số %qs của %qs intrinsict tại %L phải là NGUYÊN hay THỰC

en: %qs argument of %qs intrinsic at %L must be REAL or COMPLEX
vi: đối số %qs của %qs intrinsict tại %L phải là THỰC hay PHỨC

en: %qs argument of %qs intrinsic at %L must be a constant
vi: đối số %qs của %qs intrinsict tại %L phải là hằng

en: %qs argument of %qs intrinsic at %L must be a data entity
vi: Đối số %qs của hạn chế %qs tại %L phải là thực thể dữ liệu

en: %qs argument of %qs intrinsic at %L must be a logical array
vi: đối số %qs của %qs intrinsict tại %L phải là mảng lôgíc

en: %qs argument of %qs intrinsic at %L must be a scalar
vi: đối số %qs của %qs intrinsict tại %L phải là tuyến tính

en: %qs argument of %qs intrinsic at %L must be a variable
vi: đối số %qs của %qs intrinsict tại %L phải là một biến

en: %qs argument of %qs intrinsic at %L must be an array
vi: đối số %qs của %qs intrinsict tại %L phải là một mảng

en: %qs argument of %qs intrinsic at %L must be double precision
vi: đối số %qs của %qs intrinsict tại %L phải là chính đôi

en: %qs argument of %qs intrinsic at %L must be of kind %d
vi: đối số %qs của %qs intrinsict tại %L phải là các loại %d

en: %qs argument of %qs intrinsic at %L must be of rank 1 or 2
vi: Đối số %qs của hạn chế %qs tại %L phải là khoảng 1 hay 2

en: %qs argument of %qs intrinsic at %L must not be OPTIONAL
vi: đối số %qs của %qs intrinsict tại %L phải không là TÙY-CHỌN

en: %qs at %C is not a member of the %qs structure
vi: %qs tại %C không phải là thành viên của cấu trúc %qs

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

en: %qs at %L already is initialized at %L
vi: “%qs” tại %L đã được khởi tạo tại %L rồi

en: %qs at %L is ambiguous
vi: %qs tại %L phải là số nguyên

en: %qs at %L is not a function
vi: “%qs” tại %L không phải là một hàm

en: %qs at %L is of the ABSTRACT type %qs
vi: %qs tại %L phải là kiểu ABSTRACT %s

en: %qs at %L must be less than BIT_SIZE(%qs)
vi: %qs tại %L phải ít hơn BIT_SIZE(%qs)

en: %qs at %L must be nonnegative
vi: %s tại %L phải là số nguyên

en: %qs at %L should be a FUNCTION
vi: %qs tại %L phải là HÀM

en: %qs at %L should be a SUBROUTINE
vi: %qs tại %L phải là THỦ TỤC CON

en: %qs attribute ignored
vi: thuộc tính %qs bị bỏ qua

en: %qs cannot appear in a constant-expression
vi: %qs không thể xuất hiện trong biểu thức hằng

en: %qs does not support MIPS16 code
vi: %qs không hỗ trợ mã MIPS16

en: %qs expects 1 argument but %d given
vi: %qs cần một đối số nhưng lại đưa ra %d

en: %qs expects 2 arguments but %d given
vi: %qs cần 2 đối số nhưng chỉ nhận được %d

en: %qs expects a constant argument
vi: %qs cần một đối số hằng

en: %qs expects a fixed-point value as argument
vi: %qs cần giá trị dấu chấm cố định làm đối số

en: %qs expects a fixed-point value as first argument
vi: %qs cần giá trị dấu chấm cố định làm đối số đầu tiên

en: %qs expects an integer value as second argument
vi: %qs cần giá trị nguyên làm đối số thứ hai

en: %qs expression must be integral
vi: biểu thức %qs phải là số nguyên

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 in %<%s %E%>
vi: %qs trong %<%s %E%>

en: %qs is deprecated
vi: %qs đã lạc hậu

en: %qs is deprecated; use -fno-zero-initialized-in-bss
vi: %qs đã lỗi thời; hãy dùng -fno-zero-initialized-in-bss

en: %qs is deprecated; use -fstack-check
vi: %qs đã lỗi thời; hãy dùng -fstack-check

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

en: %qs is not a directory
vi: %qs không phải là một thư mục

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 option to the preprocessor
vi: “%qs” không phải là một tùy chọn hợp lệ cho bộ tiền xử lý

en: %qs is not an option that controls warnings
vi: “%qs” không phải là một tùy chọn cái mà điều khiển cảnh báo

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

en: %qs is version %q.*s, expected version %q.*s
vi: %qs là phiên bản %q.*s, cần phiên bản %q.*s

en: %qs must be the first clause of %qs
vi: %qs phải là mệnh đề đầu tiên của %qs

en: %qs must be used with %qs
vi: %qs phải được sử dụng cùng với %qs

en: %qs of %qs is PRIVATE at %L
vi: %qs của %qs là RIÊNG tại %L

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

en: %qs value must be positive
vi: %qs giá trị phải dương

en: %s  Same as %s.
vi: %s Giống như %s.

en: %s %wd out of range %wd - %wd
vi: %s %wd nằm ngoài vùng %wd - %wd

en: %s '%s'
vi: %s “%s”

en: %s at %L
vi: %s tại %L

en: %s at %L must be INTEGER
vi: %s tại %L phải là SỐ-NGUYÊN

en: %s at %L must be a scalar
vi: %s tại %L phải là một scalar

en: %s at %L must be integer
vi: %s tại %L phải là số nguyên

en: %s attribute applied to %s %s at %L
vi: thuộc tính %s được áp dụng cho %s %s tại %L

en: %s attribute conflicts with %s attribute in %qs at %L
vi: thuộc tính %s xung đột với thuộc tính %s trong %sq tại %L

en: %s attribute of %qs conflicts with %s attribute at %L
vi: thuộc tính %s của %qs xung đột với thuộc tính %s tại %L

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

en: %s does not support %s with the %<%%%c%> %s format
vi: %s không hỗ trợ %s với %<%%%c%> định dạng %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 dump_bb_for_graph
vi: %s không hỗ trợ dump_bb_for_graph

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 force_nonfallthru
vi: %s không hỗ trợ force_nonfallthru

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 does not support the %<%%%c%> %s format
vi: %s không hỗ trợ %<%%%c%> định dạng %s

en: %s does not support the %<%%%s%c%> %s format
vi: %s không hỗ trợ %<%%%s%c%> định dạng %s

en: %s ignored with %s and %<%%%c%> %s format
vi: %s bị bỏ qua với %s và %<%%%c%> %s định dạng

en: %s ignored with %s in %s format
vi: %s bị bỏ qua với %s trong %s định dạng

en: %s is not supported by this configuration
vi: %s không được hỗ trợ bởi cấu hình này

en: %s out of range: Range is %i to %i, value is %i
vi: %s ở ngoài phạm vi: Vùng là từ %i đến %i, giá trị là %i

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

en: %s statement expected at %L
vi: cần lệnh %s tại %L

en: %s tag
vi: thẻ %s

en: %s tag at %L must be a character string of default kind
vi: thẻ %s tại %L phải là chuỗi ký tự của kiểu mặc định

en: %s tag at %L must be of type %s
vi: thẻ %s tại %L phải là kiểu %s

en: %s tag at %L must be scalar
vi: thẻ %s tại %L phải là scalar

en: %s tag with INQUIRE
vi: thẻ %s với INQUIRE

en: %s terminated with signal %d [%s]%s
vi: %s đã kết thúc với tín hiệu %d [%s]%s

en: %s used with %<%%%c%> %s format
vi: %s được dùng với định dạng %<%%%c%> %s

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: 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: could not open compare-debug file %s
vi: %s: không thể mở tập tin compare-debug %s

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: 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: 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:'%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, coi là nó chưa thực hiện

en: %s:cannot open notes file
vi: %s: không thể mở tập tin ghi chú

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:not a gcov notes file
vi: %s: không phải là tập tin ghi chú 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:source file is newer than notes file '%s'
vi: %s: tập tin nguồn mới hơn tập tin ghi chú “%s”

en: %s:stamp mismatch with notes file
vi: %s: dấu vết thời gian không khớp với tập tin ghi chú

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: '
vi: “

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 đặt

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 namespace)
vi: (namespace vô danh)

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

en: (near initialization for %qs)
vi: (gần chỗ khởi tạo cho %qs)

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

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

en: (the message is displayed only once 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à tắt phần bổ sung nào.

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: -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 coi 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 tùy 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 cuối đường dẫn bao gồm khung 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: -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-tin>	Ghi vào tập tin này kết xuất về quan hệ phụ thuộc.

en: -O<number>	Set optimization level to <number>.
vi: -O<số>	Đặt mức tối ưu hóa thành <số>.

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

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: -c required for gnat2scil
vi: -c là cần cho gnat2scil

en: -c required for gnat2why
vi: -c cần cho gnat2why

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 ignored (not supported for DJGPP)
vi: -f%s được bỏ qua (không được DJGPP 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: -fcoarray=<none|single|lib>	Specify which coarray parallelization should be used.
vi: -fcoarray=<none|single|lib>	Chỉ định đồng mảng song song nào nên được dùng.

en: -fconst-string-class=<name>	Use class <name> for constant strings.
vi: -fconst-string-class=<tên>	Dùng <tên> lớp cho chuỗi hằng.

en: -fconstexpr-depth=<number>	Specify maximum constexpr recursion depth.
vi: -fconstexpr-depth=<number>	Chỉ định mức đệ quy constexpr (bt hằng) tối đa.

en: -fconstexpr-loop-limit=<number>	Specify maximum constexpr loop iteration count.
vi: -fconstexpr-loop-limit=<number>	Chỉ định số lượng bước lặp constexpr (bt hằng) tối đa.

en: -fexec-charset=<cset>	Convert all strings and character constants to character set <cset>.
vi: -fexec-charset=<cset>	Chuyển mọi hằng chuỗi và ký tự sang bảng ký tự <cset>.

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-summary=[...]	Print summary of floating point exceptions.
vi: -ffpe-summary=[…]	Đừng in tổng hợp ngoại lệ dấu chấm động.

en: -ffpe-trap=[...]	Stop on following floating point exceptions.
vi: -ffpe-trap=[…]	Đừng lại theo ngoại lệ dấu chấm độ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ố>	Khởi tạo 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ố>	Khởi tạo 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>	Khởi tạo các biến hợp lý cục bộ (true=đúng, false=sai).

en: -finit-real=<zero|snan|nan|inf|-inf>	Initialize local real variables.
vi: -finit-real=<zero|snan|nan|inf|-inf>	Khởi tạo các biến thực nội bộ.

en: -finline-matmul-limit=<n>	Specify the size of the largest matrix for which matmul will be inlined.
vi: -finline-matmul-limit=<số>	Kích cỡ của ma trận nhỏ nhất cho đó matmul sẽ được chung dòng.

en: -finput-charset=<cset>	Specify the default character set for source files.
vi: -finput-charset=<cset>	Chỉ định bảng mã ký tự mặc định cho tập tin mã nguồn.

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-errors=<number>	Maximum number of errors to report.
vi: -fmax-errors=<số>	Số lượng tối đa các lỗi cần thông báo.

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ăn xếp.

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: -fopt-info[-<type>=filename]	Dump compiler optimization details.
vi: -fopt-info[-<type>=tập-tin]	Đổ chi tiết việc tối ưu hóa bộ dịch.

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

en: -fpermitted-flt-eval-methods=[c11|ts-18661]	Specify which values of FLT_EVAL_METHOD are permitted.
vi: -fpermitted-flt-eval-methods=[c11|ts-18661]	Chỉ định xem giá trị của FLT_EVAL_METHOD sẽ cho phép.

en: -fplugin-arg-<name>-<key>[=<value>]	Specify argument <key>=<value> for plugin <name>.
vi: -fplugin-arg-<tên>-<khóa>[=<giá trị>]	Chỉ định đối số <khóa>=<giá trị> cho plugin <tên>.

en: -fstack-check=[no|generic|specific]	Insert stack checking code into the program.
vi: -fstack-check=[no|generic|specific]	 Chèn mã kiểm tra ngăn xếp vào chương trình.

en: -fstack-limit-register=<register>	Trap if the stack goes past <register>.
vi: -fstack-limit-register=<register>	Bẫy nếu ngăn xếp đi qua <register>.

en: -fstack-limit-symbol=<name>	Trap if the stack goes past symbol <name>.
vi: -fstack-limit-symbol=<tên>	Bẫy nếu ngăn xếp đi qua ký hiệu <tên>.

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: -fvisibility=[private|protected|public|package]	Set the default symbol visibility.
vi: -fvisibility=[private|protected|public|package]	Đặt tính khả kiến ký hiệu mặc định.

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

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

en: -fwide-exec-charset=<cset>	Convert all wide strings and character constants to character set <cset>.
vi: -fwide-exec-charset=<cset>	Chuyển đổi mọi chuỗi rộng và hằng ký tự rộng ra bộ mã <cset>.

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

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

en: -gz=<format>	Generate compressed debug sections in format <format>.
vi: -gz=<định dạng>	Tạo phần gỡ lỗi nén theo định dạng <định dạng>.

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

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: -imultiarch <dir>	Set <dir> to be the multiarch include subdirectory.
vi: -imultiarch <dir>	Đặt <dir> để cho thư mục con bao gồm đa kiến trúc.

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

en: -iplugindir=<dir>	Set <dir> to be the default plugin directory.
vi: -iplugindir=<dir>	Đặt <dir> cho thư mục phần bổ sung mặc định.

en: -iquote <dir>	Add <dir> to the end of the quote 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: -isysroot <dir>	Set <dir> to be the system root directory.
vi: -isysroot <thư_mục>	Đặt <thư_mục> này vào đường dẫn gốc hệ thống.

en: -isystem <dir>	Add <dir> to the start of the system include path.
vi: -isystem <thư_mục>	Thêm <thư_mục> này vào đầu đường dẫn bao gồm hệ thống.

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

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

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: -mbranch-cost=COST	Set the cost of branches to roughly COST instructions.
vi: -mbranch-cost=GIÁ	Đặt 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=CÀI-ĐẶT	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=CPU	Compile code for ARC variant CPU.
vi: -mcpu=VXL	Biên dịch mã cho CPU biến thế ARC.

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 và mã tác vụ 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: -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ăn xếp.

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: -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 xếp nào vượt quá kích cỡ này.

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: -mpointer-size=[no,32,short,64,long]	Set the default pointer size.
vi: -mpointer-size=[no,32,short,64,long]	đặt cỡ con trỏ mặc định.

en: -mr10k-cache-barrier=SETTING	Specify when r10k cache barriers should be inserted.
vi: -mr10k-cache-barrier=CÀI-ĐẶT	Ghi rõ khi nào nên chèn rào cản vùng nhớ tạm r10k.

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 tùy chọn -msingle-float và -msoft-float

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 chíp hoặc CPU đưa ra.

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

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: -pie is not supported in this configuration
vi: -pie không được hỗ trợ trong cấu hình này

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

en: -trigraphs	Support ISO C trigraphs.
vi: -trigraphs	Hỗ trợ bộ ba ISO C.

en: 31 bit ABI.
vi: ABI 31-bit.

en: 64 bit ABI.
vi: ABI 64-bit.

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

en: <brace-enclosed initializer list>
vi: <danh sách bộ khởi tạo 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 khai báo>

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 khai báo>

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

en: <template arguments error>
vi: <lỗi đối số mẫu>

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: <ubsan routine call>
vi: <gọi thủ tục ubsan>

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

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

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

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

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

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: ABSTRACT INTERFACE %qs must not be referenced at %L
vi: ABSTRACT INTERFACE %qs phải không tham chiếu tại %L

en: ABSTRACT INTERFACE at %C
vi: ABSTRACT INTERFACE tại %C

en: ABSTRACT type %qs used at %L
vi: Kiểu TRỪU TƯỢNG tại %qs được dùng tại %L

en: ABSTRACT type at %C
vi: Kiểu TRỪU TƯỢNG tại %C

en: ACQUIRED_LOCK variable
vi: biến ACQUIRED_LOCK

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

en: ASSIGN statement at %C
vi: câu lệnh ASSIGN tại %C

en: ASSOCIATE construct at %C
vi: cấu trúc ASSOCIATE tại %C

en: ASYNCHRONOUS attribute at %C
vi: thuộc tính ASYNCHRONOUS tại%C

en: ASYNCHRONOUS statement at %C
vi: câu lệnh ASYNCHRONOUS tại %C

en: Accept extensions to support legacy code.
vi: Chấp nhận phần mở rộng để hỗ trợ mã nguồn cũ.

en: Actual argument contains too few elements for dummy argument %qs (%lu/%lu) at %L
vi: Đối số thực tế có chứa quá ít phần tử cho đối số giả “%qs” (%lu/%lu) tại %L

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 khai báo 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 khai báo cho đối số giả “%s” (%ld/%ld)

en: Add explicit checks for division by zero.
vi: Thêm kiểm tra cho phép chia không.

en: Add explicit checks for division overflow in INT_MIN / -1.
vi: Thêm kiểm tra cho tràn phép chia trong INT_MIN / -1.

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

en: Alias for -mcpu=g10.
vi: Bí danh cho  -mcpu=g10.

en: Alias for -mcpu=g13.
vi: Bí danh cho  -mcpu=g13.

en: Alias for -mcpu=g14.
vi: Bí danh cho  -mcpu=g14.

en: Alias has call edges
vi: Bí danh có cạnh gọi

en: Alias has non-alias reference
vi: Bí danh có tham chiếu non-alias

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 the start of functions.
vi: Chỉnh đầu của hàm.

en: Align the start of loops.
vi: Chỉnh đầu của vòng lặp.

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 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: 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ăn xếp để cho phép đệ quy một cách gián tiếp.

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 dollar signs in entity names.
vi: Cho phép tên thực thể chứa dấu đồng đô la "$".

en: Allow function addresses to be held in registers.
vi: Sử dụng địa chỉ hàm mà được giữ trong các thanh ghi.

en: Allow gcc to generate LIW instructions.
vi: Cho phép gcc tạo chỉ lệnh LIW.

en: Allow gcc to generate the SETLB and Lcc instructions.
vi: Cho phép gcc tạo chỉ lệnh SETLB và Lcc.

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 instructions for V850E2V3 and up.
vi: Cho phép sử dụng các câu lệnh kiểu dấu chấm động phần cứng với V850E2V3 và hơn.

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 thay thế.

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

en: AltiVec not supported in this target
vi: AltiVec không được hỗ trợ ở đích này

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ăn xếp.

en: Always use JSR, never BSR, for calls.
vi: Luôn dùng JSR, không phải BSR, cho gọi.

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: Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs
vi: Đối số %qs của %qs với PASS(%s) tại %L phải là dẫn xuất kiểu %qs

en: Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs
vi: Đối số %qs của %qs với PASS(%s) tại %L phải là kiểu dẫn xuất %qs

en: Argument %qs of %qs with PASS(%s) at %L must be scalar
vi: Đối số %qs của %qs với PASS(%s) tại %L phải là vô hướng

en: Argument %qs of elemental procedure at %L must be scalar
vi: Tham số %qs của thủ tục cơ bản tại %L phải là vô hướng

en: Argument NCOPIES of REPEAT intrinsic is negative (its value is %ld)
vi: Tham số NCOPIES của REPEAT (lặp lại) hạn chế là âm (giá trị của nó là %ld)

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: Argument of %s at %L must be of length one
vi: Đối số của %s tại %L phải là của một độ dài

en: Argument of %s function at %L is negative
vi: Đối số của hàm %s tại %L là âm

en: Argument of FINAL procedure at %L must be of type %qs
vi: Đối số của thủ tục FINAL tại %L phải là kiểu %qs

en: Arithmetic IF statement at %C
vi: Câu lệnh IF số học tại %C

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: Tùy 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: Assignment of scalar to unallocated array
vi: Gán vô hướng cho mảng chưa cấp phát

en: Assume ICPLBs are enabled at runtime.
vi: Coi là các ICPLB được bật vào lúc chạy.

en: Assume a large TLS segment.
vi: Coi là một đoạn TLS lớn.

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

en: Assume all variable arg functions are prototyped.
vi: Giả 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: Coi là mã sẽ được GAS dịch.

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

en: Assume code will be linked by HP ld.
vi: Coi 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: Coi là ngăn xếp đến được xếp hàng theo lũy thừa 2 này.

en: Assume normal C execution environment.
vi: Coi là môi trường thực thi C bình thường.

en: Assume possible double misalignment.
vi: Coi có thể bị sai xếp hàng đôi.

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

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

en: Assume target CPU is configured as little endian.
vi: Coi 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: Coi 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: Coi là đã 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: Coi là tập tin nguồn có dạng cố định.

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

en: Assume the VxWorks RTP environment.
vi: Coi là môi trường RTP VxWorks.

en: Assume the VxWorks vThreads environment.
vi: Coi là môi trường vThreads VxWorks.

en: Assumed type at %C
vi: Giả định kiểu tại %C

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

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

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ăn xếp được xếp hàng theo lũy thừa 2 này.

en: Attempting to allocate already allocated variable
vi: Đang cố cấp phát một biến đã được cấp phát rồi

en: Attempting to allocate already allocated variable '%s'
vi: Đang cố cấp phát một biến đã được cấp phát rồi “%s”

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 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: BB %i has incorrect edge
vi: BB %i có cạnh sai

en: BB %i is missing an edge
vi: BB %i thiếu cạnh

en: BIND(C) applied to %s %s at %L
vi: BIND(C) được áp dụng với %s %s tại %L

en: BIND(C) at %L
vi: BIND(C) tại %L

en: BIND(C) statement at %C
vi: BIND(C) tại %C

en: BLOCK construct at %C
vi: cấu trúc BLOCK tại %C

en: BYTE type at %C
vi: kiểu BYTE tại %C

en: Bad 128-bit move
vi: Di chuyển 128-bit sai

en: Bad GPR fusion
vi: Hợp nhất GPR 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 hóa 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 hóa bằng sự tối ưu hóa 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ơ hóa.

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ơ hóa.

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

en: Bound on the complexity of the expressions in the scalar evolutions analyzer.
vi: Đóng kết với độ tinh vi của biểu thức đượ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 thức để tính số các lần lặp lại.

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: 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: Biên dịch cho Lõi B.

en: Build for SDRAM.
vi: Biên dịch cho SDRAM.

en: CLASS statement at %C
vi: câu lệnh CLASS tại %C

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

en: COMMON %qs at %L does not exist
vi: COMMON “%qs” tại %L không tồn tại

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: CONTIGUOUS attribute at %C
vi: thuộc tính CONTIGUOUS tại %C

en: CONTIGUOUS statement at %C
vi: câu lệnh CONTIGUOUS tại %C

en: CONVERT tag at %L
vi: CONVERT tag tại %L

en: CPU you selected does not support x86-64 instruction set
vi: CPU bạn chọn không hỗ trợ chỉ lệnh x86-64

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 change directory to %s
vi: Không thể chuyển sang thư mục %s

en: Cannot get current directory name
vi: Không thể lấy tên thư mục hiện thời

en: Cannot make directory %s
vi: Không thể tạo thư mục %s

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

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

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 of value in conversion from %qs to %qs at %L
vi: Đổi giá trị trong chuyển đổi từ %qs sang %qs tại %L

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ăn xếp.

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ăn xếp mà không tắt tín hiệu ngắt.

en: Character length of actual argument shorter than of dummy argument %qs (%lu/%lu) at %L
vi: Chiều dài chuỗi thật vẫn nhỏ hơn điều khai báo cho đối số giả “%qs” (%lu/%lu) tại %L

en: Check for stack overflow at runtime.
vi: Kiểm tra tràn stack lúc chạy.

en: Check for syntax errors, then stop.
vi: Kiểm tra lỗi cú pháp, sau đó dừng lại.

en: Check the return value of new in C++.
vi: Kiểm tra giá trị trả về của new trong C++.

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: Clear all tune features.
vi: Đặc tính đã bị xóa bỏ:

en: Coarray declaration at %C
vi: Khai báo Coarray tại %C

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

en: Compile code for big endian mode.
vi: Tạo mã trong chế độ về cuối lớn.

en: Compile code for little endian mode.  This is the default.
vi: Biên dịch mã cho chế độ về cuối nhỏ. Đây là mặc định.

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/xóa.

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

en: Compile for 64-bit pointers.
vi: Biên dịch cho con 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 DSBT shared library ABI.
vi: Tạo thư viện dùng chung

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 v850e3v5 processor.
vi: Biên dịch cho bộ xử lý v850e3v5.

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: Component %qs at %C already declared at %L
vi: Thành phần “%qs” tại %C đã sẵn được khai báo tại %L

en: Component %qs at %C already in the parent type at %L
vi: Thành phần “%qs” tại %C đã sẵn trong kiểu cha mẹ %L

en: Computed GOTO at %C
vi: Được tính toán GOTO tại %C

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 1990 C standard as amended in 1994.
vi: Làm cho hợp với chuẩn ISO 1990 C như sửa đổi trong 1994.

en: Conform to the ISO 1990 C standard with GNU extensions.
vi: Làm cho hợp với chuẩn ISO 1990 C với phần mở rộng GNU.

en: Conform to the ISO 1990 C standard.
vi: Làm cho hợp với chuẩn ISO 1990 C.

en: Conform to the ISO 1998 C++ standard revised by the 2003 technical corrigendum.
vi: Làm cho hợp với chuẩn ISO 1998 C++ xem xét lại đính chính kỹ thuật năm 2003.

en: Conform to the ISO 1999 C standard with GNU extensions.
vi: Làm cho hợp với chuẩn ISO 1999 C với phần mở rộng GNU.

en: Conform to the ISO 1999 C standard.
vi: Làm cho hợp với chuẩn ISO 1999 C.

en: Conform to the ISO 2011 C standard with GNU extensions.
vi: Làm cho hợp với chuẩn ISO 2011 C với phần mở rộng GNU.

en: Conform to the ISO 2011 C standard.
vi: Làm cho hợp với chuẩn ISO 2011 C++.

en: Conform to the ISO 2011 C++ standard with GNU extensions.
vi: Làm cho hợp với chuẩn ISO 2011 C++ với phần mở rộng GNU.

en: Conform to the ISO 2011 C++ standard.
vi: Làm cho hợp với chuẩn ISO 2011 C++.

en: Conform to the ISO 2014 C++ standard with GNU extensions.
vi: Làm cho hợp với chuẩn ISO 2014 C++ với phần mở rộng GNU.

en: Conform to the ISO 2014 C++ standard.
vi: Làm cho hợp với chuẩn ISO 2014 C++.

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 including TS 29113.
vi: Làm cho hợp với tiêu chuẩn ISO Fortran 2008 bao gồm TS 29113.

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: Conform to the o32 FPXX ABI.
vi: Phù hợp với o32 FPXX ABI.

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: 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 dấu chấm độ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ề dấu chấm động.

en: Conversion from %qs to %qs at %L
vi: Chuyển đổi từ %qs sang %qs tại %L

en: Conversion from %s to %s at %L
vi: Chuyển đổi từ %s sang %s tại %L

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 coi đối với một câu lệnh nhánh.

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

en: Could not generate addis value for fusion
vi: Không thể tạo addis cho sát nhập

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: Cray pointer %qs in %s clause at %L
vi: Con trỏ Cray %qs trong mệnh đề %s tại %L

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

en: Create a shared library.
vi: Tạo thư viện dùng chung.

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

en: Create data files needed by "gcov".
vi: Tạo tập tin dữ liệu cần bởi "gcov".

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

en: Creating array temporary at %L
vi: Đang tạo mảng tạm tại %L

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 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: Deleted feature:
vi: Đặc tính đã bị xóa bỏ:

en: Deprecated in favor of -std=c++11.
vi: Đã lạc hậu và được thay thế bằng -std=c++11.

en: Deprecated in favor of -std=c++14.
vi: Đã lạc hậu và được thay thế bằng -std=c++14.

en: Deprecated in favor of -std=c11.
vi: Đã lạc hậu và được thay thế bằng -std=c11.

en: Deprecated in favor of -std=c99.
vi: Đã lạc hậu và được thay thế bằng -std=c99.

en: Deprecated in favor of -std=gnu++11.
vi: Đã lạc hậu và được thay thế bằng -std=gnu++11.

en: Deprecated in favor of -std=gnu++14.
vi: Đã lạc hậu và được thay thế bằng -std=gnu++14.

en: Deprecated in favor of -std=gnu11.
vi: Đã lạc hậu và được thay thế bằng -std=gnu11.

en: Deprecated in favor of -std=gnu99.
vi: Đã lạc hậu và được thay thế bằng -std=gnu99.

en: Deprecated in favor of -std=iso9899:1999.
vi: Đã lạc hậu và được thay thế bằng -std=iso9899:1999.

en: Deprecated option.  Use -mno-vrsave instead.
vi: Tùy chọn đã lạc hậu.  Dùng -mno-vrsave để thay thế.

en: Deprecated option.  Use -mvrsave instead.
vi: Tùy chọn đã lạc hậu.  Dùng -mvrsave để thay thế.

en: Deprecated.  This switch has no effect.
vi: Đã lỗi thời. Tùy chọn này không có tác dụng gì.

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 hardware floating point.
vi: Tắt dấu chấm động bằng 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: 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: Disallow more than 'msched-max-memory-insns' in instruction group. Otherwise, limit is 'soft' (prefer non-memory operations when limit is reached).
vi: Không cho phép nhiều hơn “msched-max-memory-insns trong nhóm chỉ lệnh. Không thì giới hạn là “mềm” (thích thao tác không phải vùng nhớ hơn khi tới giới hạn này).

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

en: Display the code tree after front end optimization.
vi: Hiển thị cây mã sau tối ưu hóa mặt tiền.

en: Display the code tree after parsing.
vi: Hiển thị cây mã sau khi phân tích cú pháp.

en: Display the code tree after parsing; deprecated option.
vi: Hiển thị cây mã sau phân tích; tùy chọn này đã lạc hậu.

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

en: Display this information.
vi: Hiển thị thông tin này.

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

en: Do not allow constant data to be placed in code sections.
vi: Không cho phép đặt dữ liệu hằng trong phần mã.

en: Do not assume a large TLS segment.
vi: Đừng coi là 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 in macro expansions.
vi: Đừng loại bỏ ghi chú trong sự mở rộng vĩ lệnh.

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

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 cạnh.

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 enforce strict alignment.
vi: Đừng ép buộc hạn chế xếp hàng.

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

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

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 code that can only run in supervisor mode (default).
vi: Đừng tạo mã mà nó chỉ chạy được trong chế độ siêu giám sát (mặc định).

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 generate mpy instructions for ARC700.
vi: Đừng tạo chỉ lệnh mpy cho ARC700.

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ố dấu chấm độ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 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ăn xếp.

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 dấu chấm độ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 dấu chấm động bằng phần cứng.

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

en: Do not use hardware fp.
vi: Đừng sử dụng dấu chấm động bằng 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 dấu chấm động phần cứng.

en: Do not use the AltiVec ABI extensions.
vi: Không dùng lệnh mở rộng AltiVec 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 the callt instruction (default).
vi: Đừng sử dụng chỉ lệnh callt (mặc định).

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ăn xếp dùng biên giới trong vùng nhớ nháp cấp 1.

en: Does nothing.  Preserved for backward compatibility.
vi: Không làm gì. Dành cho mục đích tương thích ngược.

en: Does nothing. Preserved for backward compatibility.
vi: Không làm gì. Giữ lại vì mục đích tương thích ngược.

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, use memcpy.
vi: Đừng tối ưu hóa sự di chuyển khối, dùng memcpy.

en: Don't optimize block moves.
vi: Đừng tối ưu hóa sự di chuyển khối.

en: Don't use P-mnemonics for branches.
vi: Sử dụng gợi-nhớ-P cho nhánh.

en: Don't use any of r32..r63.
vi: Đừng dùng bất kỳ r32..r63 nào.

en: Don't warn about uses of Microsoft extensions.
vi: Không cảnh báo dùng lệnh mở rộng Microsoft.

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

en: Duplicate %s attribute at %L
vi: Trùng thuộc tính %s tại %L

en: Duplicate %s specification at %C
vi: Trùng đặc tả %s tại %C

en: Duplicate DEFERRED at %C
vi: Trùng DEFERRED tại %C

en: Duplicate construct label %qs at %C
vi: Trùng nhãn cấu trúc %qs tại %C

en: Duplicate symbol %qs in formal argument list at %C
vi: Trùng ký hiệu %qs trong danh sách đối số hình thức tại %C

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

en: ENTRY statement at %C
vi: câu lệnh ENTRY tại %C

en: ENUM and ENUMERATOR at %C
vi: ENUM và ENUMERATOR tại %C

en: ERRMSG at %L
vi: ERRMSG tại %L

en: ERRMSG tag at %L
vi: ERRMSG tag tại %L

en: ERRMSG variable
vi: Biến ERRMSG

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

en: EXTENDS at %L
vi: EXTENDS tại %L

en: Emit .gnu_attribute tags.
vi: Phát cờ .gnu_attribute.

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 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 dấu chấm độ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 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ăn xếp 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 con trỏ tuyến trì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: Empty FINAL at %C
vi: FINAL trống rỗng tại %C

en: Enable DWARF line debug info via GNU as.
vi: Bật thông tin gỡ rối dòng Dwarf 2 thông qua as của GNU.

en: Enable Function Descriptor PIC mode.
vi: Bật chế độ PIC Mô tả Hàm.

en: Enable ID based shared library.
vi: Bật thư viện dùng chung dựa vào mã số (ID).

en: Enable IEEE 128-bit floating point via the __float128 keyword.
vi: Bậ sử dụng câu lệnh só thực dấu chấm động thập phân 128-bit IEEE thông qua từ khóa __float128.

en: Enable Local Register Allocation.
vi: Bật Local Register Allocation.

en: Enable MUL.X and UMUL.X instructions.
vi: Bật các chỉ lệnh MUL.X và UMUL.X.

en: Enable OpenACC.
vi: Bật OpenACC.

en: Enable OpenMP's SIMD directives.
vi: Bật chỉ thị OpenMP's SIMD.

en: Enable PIC support for building libraries.
vi: Bật sự hỗ trợ PIC để biên dịch thư viện.

en: Enable TPF-OS tracing code.
vi: Bật mã tìm đường TFP-OS.

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ất cả cảnh báo -Wunused-.

en: Enable all DEC language extensions.
vi: Bật mọi phần mở rộng ngôn ngữ DEC.

en: Enable asan builtin functions protection.
vi: Bật chức năng bảo vệ hàm dựng sẵn asan.

en: Enable asan detection of use-after-return bugs.
vi: Bật dò tìm asan của lỗi dùng-sau-khi-trả-về.

en: Enable asan globals protection.
vi: Bật chức năng bảo vệ asan toàn cục.

en: Enable asan load operations protection.
vi: Bật chức năng bảo vệ thao tác tải asan.

en: Enable asan stack protection.
vi: Bật chức năng bảo vệ ngăn xếp asan.

en: Enable asan store operations protection.
vi: Bật chức năng bảo vệ thao tác lưu trữ asan.

en: Enable backend debugging.
vi: Bật chức năng gỡ rối hậu phương.

en: Enable barrel shift instructions.
vi: Bật câu lệnh barrel shift.

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

en: Enable conditional moves.
vi: Bật sự di chuyển có điều kiện.

en: Enable constructor/destructor feature.
vi: Bật tính năng cấu/hủy tử

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

en: Enable decimal floating point hardware support.
vi: Bật việc hỗ trợ phần cứng dấu chấm động thập phân.

en: Enable divide and modulus instructions.
vi: Bật câu lệnh chia và câu lệnh lấy số dư.

en: Enable earlier placing stop bits for better scheduling.
vi: Bật 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 exception handling.
vi: Bật tiếp nhận ngoại lệ.

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

en: Enable hardware floating point.
vi: Bật dấu chấm động loại phần cứng.

en: Enable inlining of PLT in function calls.
vi: Bật sự chèn trực tiếp PLT vào cuộc gọi hàm.

en: Enable label alignment optimizations.
vi: Bật sự tối ưu hóa cách xếp hàng nhãn.

en: Enable linker optimizations.
vi: Bật số tối ưu hóa bộ liên kết.

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

en: Enable linker relaxations.
vi: Bật hàm yếu về bộ liên kết.

en: Enable linker relaxing.
vi: Bật làm yếu bộ liên kết.

en: Enable most warning messages.
vi: Bật phần lớn các thông điệp cảnh báo.

en: Enable multicore support.
vi: Bật khả năng hỗ trợ đa lõi.

en: Enable multiply instructions.
vi: Bật câu lệnh nhân.

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

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

en: Enable parsing GIMPLE.
vi: Bật phân tích cú pháp GIMPLE.

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

en: Enable range checking during compilation.
vi: Bật chức năng kiểm tra phạm vi trong khi biên dịch.

en: Enable separate data segment.
vi: Bật ngăn cách đoạn dữ liệu.

en: Enable setting GPRs to the result of comparisons.
vi: Bật chức năng đặt GPR thành kết quả của phép so sánh.

en: Enable sign extend instructions.
vi: Bật câu lệnh mở rộng ký hiệu.

en: Enable stack probing.
vi: Bật chức năng dò ngăn xếp.

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

en: Enable support for C++ concepts.
vi: Bật sự hỗ trợ cho khái niệm C++.

en: Enable support for DEC STRUCTURE/RECORD.
vi: Bật hỗ trợ cho DEC STRUCTURE/RECORD.

en: Enable support for the RH850 ABI.  This is the default.
vi: Bật hỗ trợ cho RH850 ABI.  Đây là mặc định.

en: Enable the loop nest optimizer.
vi: Bật sự tối ưu hóa vòng lặp lồng nhau.

en: Enable the normal mode.
vi: Bật 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: Bật sử dụng thay ghi dấu chấm độ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 dấu chấm động RX. Đây là cài đặt mặc định.

en: Enable the use of indexed loads.
vi: Bật sử dụng tải chỉ mục.

en: Enable the use of the fsca instruction.
vi: Bật sử dụng câu lệnh fsca.

en: Enable the use of the fsrra instruction.
vi: Bật sử dụng câu lệnh fsrra.

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

en: Enable traditional preprocessing.
vi: Bật tiền xử lý theo kiểu cổ điển.

en: Enable use of GPREL for read-only data in FDPIC.
vi: Bật 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: Bật sử dụng sdata/scommon/sbss.

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

en: Enable using IEEE 128-bit floating point instructions.
vi: Bật sử dụng câu lệnh dấu số thực chấm động 128-bit IEEE.

en: Enable v850e3v5 loop instructions.
vi: Cho phép các chỉ lệnh lặp v850e3v5.

en: Enable verbose output.
vi: Bật kết xuất chi tiết.

en: Enabled ID based shared library.
vi: Bật thư viện dùng chung dựa vào mã số (ID).

en: Encode SSE instructions with VEX prefix.
vi: Mã hóa 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
vi: Lỗi

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

en: Error in pointer initialization at %C
vi: Lỗi trong khởi tạo con trỏ tại %C

en: Error in type-spec at %L
vi: Sai trong type-spec tại %L

en: Error writing modules file: %s
vi: Gặp lỗi khi ghi tập tin môt-đun: %s

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

en: Event
vi: Dữ kiện

en: Exit on the first error occurred.
vi: Thoát khi gặp lỗi lần đầu.

en: Expected ")" at %C
vi: Cần ")" tại %C

en: Expected "," at %C
vi: Cần "," tại %C

en: Expected %<(%> at %C
vi: Cần %<(%> tại %C

en: Expected %<)%> or %<,%> at %C
vi: cần %<)%> hoặc %<,%> tại %C

en: Expected %<,%> at %C
vi: Cần %<,%> tại %C

en: Expected %<,%> or end of statement at %C
vi: cần %<,%> hoặc kết thúc câu lệnh tại %C

en: Expected %<::%> at %C
vi: Cần %<::%> tại %C

en: Expected %<=>%> at %C
vi: Cần %<=>%> tại %C

en: Expected %<END INTERFACE ASSIGNMENT (=)%> at %C
vi: Cần %<END INTERFACE ASSIGNMENT (=)%> tại %C

en: Expected :: in TYPE definition at %C
vi: Cần :: trong định nghĩa KIỂU tại %C

en: Expected DO loop at %C
vi: Cần vòng lặp DO tại %C

en: Expected a nameless interface at %C
vi: Cần một giao diện không tên tại %C

en: Expected a procedure for argument %qs at %L
vi: Cần một thủ tục cho đối số %qs tại %L

en: Expected a procedure pointer for argument %qs at %L
vi: Cần một con trỏ thủ tục cho đối số %qs tại %L

en: Expected access-specifier at %C
vi: Cần access-specifier tại %C

en: Expected argument list at %C
vi: Cần danh sách đối số tại %C

en: Expected array subscript at %C
vi: Cần chỉ số mảng tại %C

en: Expected association at %C
vi: Cần kết hợp tại %C

en: Expected association list at %C
vi: Cần danh sách kết hợp tại %C

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

en: Expected binding attribute at %C
vi: Cần thuộc tính ràng buộc tại %C

en: Expected binding name at %C
vi: Cần tên ràng buộc tại %C

en: Expected component reference at %C
vi: Cần tham chiếu thành phần tại %C

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: Expected terminating name at %C
vi: Cần tên chấm dứt tại %C

en: Expected variable name at %C
vi: Cần tên biến tại %C

en: Expecting %<END INTERFACE %s%> at %C
vi: Cần %<END INTERFACE %s%> tại %C

en: Expecting %<END INTERFACE OPERATOR (.%s.)%> at %C
vi: Cần %<END INTERFACE OPERATOR (.%s.)%> tại %C

en: Expecting %s at %C
vi: Cần %s tại %C

en: Expecting %s statement at %L
vi: Cần câu lệnh %s tại %L

en: Export functions even if they can be inlined.
vi: Xuất hàm ngay cả khi chúng có thể chung dòng.

en: Expression at %L must be scalar
vi: Biểu thức tại %L phải thuộc kiểu scalar

en: FLUSH statement at %C
vi: câu lệnh FLUSH tại %C

en: FP exceptions are enabled.
vi: Đã bật ngoại lệ dấu chấm động.

en: Factor complex constructors and destructors to favor space over speed.
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: Fatal Error
vi: Lỗi nghiêm trọng

en: Fine grain control of tune features.
vi: Đặc tính đã bị xóa bỏ:

en: Fix min_int calculation
vi: Sửa tính toán min_int

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 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ăn xếp.

en: Force assembly output to always use hex constants.
vi: Buộc hợp ngữ luôn xuất sử dụng hằng dạng thập lục.

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: Fortran 2008 obsolescent feature:
vi: Các đặc tính đã cũ của Fortran 2008:

en: Function %qs as initialization expression at %L
vi: Hàm %qs được khởi tạo giống như là một biểu thức %L

en: Function %qs at %L cannot have an initializer
vi: Hàm %qs tại %L không thể có bộ khởi tạo

en: Function %qs at %L must be PURE
vi: Hàm %qs tại %L phải là PURE

en: Function %qs requires an argument list at %C
vi: Hàm %qs cần một danh sách đối số tại %C

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: GENERIC binding at %C
vi: GENERIC ràng buộc tại %C

en: GMP version %s, MPFR version %s, MPC version %s, isl version %s
vi: GMP phiên bản %s, MPFR phiên bản %s, MPC phiên bản %s, isl 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 Extension:
vi: Phần mở rộng GNU:

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 16-bit instructions.
vi: Tạo ra câu lệnh 16-bit.

en: Generate 16bit i386 code.
vi: Tạo ra mã i386 16-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 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ăn xếp làm hợp với APCS.

en: Generate ELF FDPIC code.
vi: Tạo ra mã ELF FDPIC.

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 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 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 auto-inc/dec instructions.
vi: Tạo ra câu lệnh auto-inc/dec.

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 big-endian.

en: Generate bit instructions.
vi: Tạo ra câu lệnh bit.

en: Generate call insns as direct calls.
vi: Tạo ra câu lệnh gọi dưới dạng cuộc gọi trực tiếp.

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 call insns as indirect calls.
vi: Tạo ra câu lệnh gọi dưới dạng cuộc gọi gián tiếp.

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 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 assembler (gas).

en: Generate code for GNU ld.
vi: Tạo ra mã cho ld của GNU.

en: Generate code for GNU runtime environment.
vi: Tạo ra mã môi trường thực thi 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 Thumb state.
vi: Tạo ra mã cho trạng thái Thumb.

en: Generate code for UNIX assembler.
vi: Tạo ra mã cho bộ dịch mã số UNIX assembler.

en: Generate code for a 32-bit ABI.
vi: Tạo ra mã cho một ABI 32 bít.

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 64-bit ABI.
vi: Tạo ra mã cho một ABI 64 bít.

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, 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 68040.
vi: Tạo ra mã cho một 68040.

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 68060.
vi: Tạo ra mã cho một 68060.

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 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 functions even if they are fully inlined.
vi: Xuất hàm ngay cả khi chúng có thể chung dòng.

en: Generate code for given CPU.
vi: Tạo ra mã cho CPU đưa ra.

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 static functions even if they are never called.
vi: Xuất mã cho hàm tĩnh ngay cả khi chúng không bao giờ được gọi.

en: Generate code for the Android platform.
vi: Tạo ra mã cho Nền tảng Android.

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 for the supervisor mode (default).
vi: Tạo mã cho chế độ siêu giám sát (mặc định).

en: Generate code for the user mode.
vi: Tạo ra mã cho chế độ người dùng.

en: Generate code in 32 bit ARM state.
vi: Tạo ra mã cho ARM 32 bit.

en: Generate code in big endian mode.
vi: Tạo mã trong chế độ về cuối lớn.

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 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 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 Intel MCU psABI.
vi: Tạo ra mã thích hợp vớiIntel MCU psABI.

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 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 dấu chấm động phần cứng.

en: Generate code which uses only the general registers.
vi: Tạo ra mã mả sử dụng câu lệnh dấu chấm độ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 dấu chấm động.

en: Generate code without GP reg.
vi: Tạo ra mã không có GP reg.

en: Generate conditional move instructions.
vi: Tạo chỉ lệnh di chuyển điều kiện

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 discontiguous stack frames.
vi: Tạo ra các khung ngăn xếp không liên tiếp.

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 tính toán dùng dấu chấm động dùng tập hợp câu lệnh đưa ra.

en: Generate inline floating point division, optimize for latency.
vi: Tạo ra phép chia dấu chấm động trực tiếp, tối ưu hóa cho sự ngấm ngầm

en: Generate inline floating point division, optimize for throughput.
vi: Tạo ra phép chia dấu chấm động trực tiếp, tối ưu hóa 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 hóa 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 hóa 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 instructions supported by barrel shifter.
vi: Bật các chỉ lệnh hỗ trợ bởi dịch barrel.

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ỏ little-endian.

en: Generate load/store multiple instructions.
vi: Tạo ra câu lệnh đa nạp/lưu.

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 and compile.
vi: Tạo ra quan hệ phụ thuộc của make, và biên dịch.

en: Generate make dependencies.
vi: Tạo ra quan hệ phụ thuộc của make.

en: Generate mul64 and mulu64 instructions.
vi: Tạo ra câu lệnh mul64 và mulu64.

en: Generate norm instruction.
vi: Tạo ra câu lệnh norm.

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 performance extension instructions.
vi: Tạo chỉ lệnh năng suất mở rộng.

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ị dấu chấm động).

en: Generate swap instruction.
vi: Tạo ra câu lệnh swap.

en: Generate v3 push25/pop25 instructions.
vi: Tạo ra câu lệnh push25/pop25 v3.

en: Give branches their default cost.
vi: Gán cho mỗi nhánh giá mặc định của nó.

en: Hollerith constant at %C
vi: hằng Hollerith tại %C

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 biên dịch.

en: IMPORT statement at %C
vi: câu lệnh IMPORT tại %C

en: IMPURE procedure at %C
vi: thủ tục IMPURE tại %C

en: IOMSG tag at %L
vi: IOMSG tag tại %L

en: ISO C does not allow %<%E (expression)%>
vi: ISO C không cho phép %<%E (biểu thức)%>

en: ISO C does not support %<#pragma STDC FLOAT_CONST_DECIMAL64%>
vi: ISO C không hỗ trợ %<#pragma STDC FLOAT_CONST_DECIMAL64%>

en: ISO C does not support %<__int%d%> types
vi: ISO C không hỗ trợ kiểu %<__int%d%>

en: ISO C does not support fixed-point types
vi: ISO C không hỗ trợ kiểu dấu chấm cố định

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 forbids casts to union type
vi: ISO C cấm chỉ áp kiểu thành kiểu hỗn hợp

en: ISO C forbids comparison of %<void *%> with function pointer
vi: ISO C cấm chỉ việc so sánh của %<void *%> với con trỏ hàm

en: ISO C forbids conditional expr between %<void *%> and function pointer
vi: ISO C cấm chỉ biểu thức điều kiện giữa %<void *%> với con trỏ hàm

en: ISO C forbids nested functions
vi: ISO C cấm hàm lồng nhau

en: ISO C forbids zero-size array
vi: ISO C cấm chỉ mảng có độ dài là không

en: ISO C forbids zero-size array %qE
vi: ISO C cấm chỉ mảng có độ dài là không %qE

en: ISO C++ does not allow %<alignof%> with a non-type
vi: ISO C++ không cho phép %<alignof%> với một non-type

en: ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>
vi: ISO C++ không cho phép %<%T::%D%> được định nghĩa như là %<%T::%D%>

en: ISO C++ does not permit %<alignof%> applied to a function type
vi: ISO C++ không cho phép %<alignof%> áp dụng cho kiểu hàm

en: ISO C++ does not support %<__int%d%> for %qs
vi: ISO C++ không hỗ trợ %<__int%d%> cho %qs

en: ISO C++ forbids calling %<::main%> from within program
vi: ISO C++ cấm gọi %<::main%> từ bên trong chương trình

en: ISO C++ forbids casting to an array type %qT
vi: ISO C++ cấm việc áp đổi kiểu của mảng %qT

en: ISO C++ forbids compound-literals
vi: ISO C++ cấm compound-literals

en: ISO C++ forbids computed gotos
vi: ISO C++ cấm tính toán gotos

en: ISO C++ forbids converting a string constant to %qT
vi: ISO C++ cấm chuyển đổi hằng chuỗi thành %qT

en: ISO C++ forbids empty unnamed enum
vi: ISO C++ cấm kiểu liệt kê nặc danh không tên trống rỗng

en: ISO C++ forbids variable length array
vi: ISO C++ cấm biến có kích thước biến đổi

en: ISO C++ forbids variable length array %qD
vi: ISO C++ cấm biến có kích thước biến đổi %qD

en: ISO C++ forbids zero-size array
vi: ISO C++ cấm mảng có kích thước bằng không

en: ISO C++ forbids zero-size array %qD
vi: ISO C++ cấm mảng có kích thước bằng không %qD

en: ISO C90 does not support %<_Generic%>
vi: ISO C90 không hỗ trợ %<_Generic%>

en: ISO C90 does not support %<_Noreturn%>
vi: ISO C90 không hỗ trợ %<_Noreturn%>

en: ISO C90 does not support %<__func__%> predefined identifier
vi: ISO C90 không hỗ trợ từ hạn định %<_Atomic%>

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 boolean types
vi: ISO C90 không hỗ trợ kiểu lô-gíc

en: ISO C90 does not support complex types
vi: ISO C90 không hỗ trợ kiểu complex

en: ISO C90 does not support flexible array members
vi: ISO C90 không hỗ trợ thành viên mảng linh động

en: ISO C90 does not support the %<_Atomic%> qualifier
vi: ISO C90 không hỗ trợ từ hạn định %<_Atomic%>

en: ISO C90 forbids variable length array
vi: ISO C90 cấm mảng có kích thước biến đổi

en: ISO C90 forbids variable length array %qE
vi: ISO C90 cấm mảng có kích thước biến đổi %qE

en: ISO C99 does not support %<_Generic%>
vi: ISO C99 không hỗ trợ %<_Generic%>

en: ISO C99 does not support %<_Noreturn%>
vi: ISO C99 không hỗ trợ %<_Noreturn%>

en: ISO C99 does not support %qE
vi: ISO C99 không hỗ trợ %qE

en: ISO C99 does not support the %<_Atomic%> qualifier
vi: ISO C99 không hỗ trợ từ hạn định %<_Atomic%>

en: ISO_C_BINDING module at %C
vi: mô đun ISO_C_BINDING tại %C

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ơ hóa.

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: Nếu số lượng ứng cử trong một tập hợp nhỏ hơn, chúng tôi luôn thử gỡ bỏ iv chưa dùng nào trong khi tối ưu hóa nó.

en: Ignore 'D' in column one in fixed form.
vi: Bỏ qu chữ “D” trong cột đầu tiên trong thể dạng cố định.

en: Ignore dllimport for functions.
vi: Bỏ qua dllimport đối với chức năng.

en: Ignored.
vi: Bị bỏ qua.

en: Illegal preprocessor directive
vi: Chỉ thị tiền xử lý không hợp lệ

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: Include directory %qs: %s
vi: Thư mục bao gồm %qs: %s

en: Incompatible ranks in %s (%d and %d) at %L
vi: Vùng không tương thích nhau trong %s (%d và %d) tại %L

en: Incompatible typespec for array element at %L
vi: Đặc tả kiểu không tương thích cho phần tử mảng tại %L

en: Increase the IEEE compliance for floating-point comparisons.
vi: Sử dụng toán học IEEE cho phép so sánh dấu chấm động.

en: Inhibit the use of 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: Initialize local variables to zero (from g77).
vi: Khởi tạo 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: Insert stack checking code into the program.  Same as -fstack-check=specific.
vi: Chèn mã kiểm tra ngăn xếp vào chương trình. Giống với -fstack-check=specific.

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 too large at %C
vi: Số nguyên quá lớn tại %C

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: Interface %qs at %L may not be a statement function
vi: Giao diện %qs tại %L không thể là hàm khai báo

en: Internal procedure %qs is used as actual argument at %L
vi: Thủ tục nội tại %qs được dùng làm đối số thật tại %L

en: Interpret any INTEGER(4) as an INTEGER(8).
vi: Biên dịch bất kỳ INTEGER(4) như là INTEGER(8)

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 NULL at %L
vi: NULL không hợp lệ %L

en: Invalid character in name at %C
vi: Tên có chứa ký tự không hợp lệ tại %C

en: Invalid context for NULL () intrinsic at %L
vi: Ngữ cảnh sai cho hạn chế NULL() tại %L

en: Invalid image number %d in SYNC IMAGES
vi: Số ảnh không hợp lệ %d trong SYNC IMAGES

en: Invalid kind for %s at %L
vi: loại không hợp lệ cho %s tại %L

en: Invalid procedure argument at %L
vi: Đối số thủ tục không hợp lệ tại %L

en: Invalid range %s in option %s
vi: Vùng %s không hợp lệ trong tùy chọn %s

en: Invalid type-spec at %C
vi: type-spec không hợp lệ tại %C

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 AArch64 ABIs (for use with the -mabi= option):
vi: Không hiểu AArch64 ABIs (để dùng với tùy chọn -mabi=):

en: Known ABIs (for use with the -mabi= option):
vi: Chưa biết ABIs (để dùng với tùy chọn -mabi=):

en: Known ARC CPUs (for use with the -mcpu= option):
vi: Không hiểu ARC CPUs (để dùng với tùy chọn -mcpu=):

en: Known ARM ABIs (for use with the -mabi= option):
vi: 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: 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: Hiểu ARM FPUs (để dùng với tùy chọn -mfpu=):

en: Known ARM architectures (for use with the -march= option):
vi: 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 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: Hiểu MIPS CPUs (để dùng với tùy chọn -march= và -mtune=):

en: Known MIPS IEEE 754 settings (for use with the -mabs= and -mnan= options):
vi: Không hiểu  các cài đặt MIPS IEEE (để dùng với tùy chọn -mabs= và -mnan=):

en: Known MIPS ISA levels (for use with the -mips option):
vi: Hiểu mức MIPS ISA (để dùng với tùy chọn -mips):

en: Known TLS dialects (for use with the -mtls-dialect= option):
vi: Chưa biết TLS dialects (để dùng với tùy chọn -mtls-dialect=):

en: Known address mode (for use with the -maddress-mode= option):
vi: Không hiểu mô hình địa chỉ (để dùng với tùy chọn -maddress-mode=):

en: Known arch types (for use with the -march= option):
vi: Hiểu kiến trúc (để dùng với tùy chọn -march=):

en: Known cmodel types (for use with the -mcmodel= option):
vi: Hiểu cmodel (để dùng với tùy chọn -mcmodel=):

en: Known code models (for use with the -mcmodel= option):
vi: Không hiểu mô hinh mã (để dùng với tùy chọn -mcmodel=):

en: Known data alignment choices (for use with the -malign-data= option):
vi: Không hiểu lựa chọn cân chỉnh dữ liệu (để dùng với tùy chọn -malign-data=):

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: Known stack protector guard (for use with the -mstack-protector-guard= option):
vi: Chưa biết bảo vệ bộ bảo vệ ngăn xếp (để dùng với tùy chọn -mstack-protector-guard=):

en: Known vectorization library ABIs (for use with the -mveclibabi= option):
vi: Chưa biết thư viện véc-tơ-hóa ABIs (để dùng với tùy chọn -mveclibabi=):

en: LINEAR variable %qs must be INTEGER at %L
vi: biến LINEAR %qs tại %L phải là SỐ-NGUYÊN

en: LTO support has not been enabled in this configuration
vi: Phần hỗ trợ LTO không được bật trong cấu hình này

en: Label %d at %L defined but not used
vi: Nhãn %d tại %L đã định nghĩa nhưng chưa được dùng

en: Legacy Extension:
vi: Phần mở rộng cũ:

en: Lift restrictions on GOT size.
vi: Nâng 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: Line truncated at %L
vi: Dòng bị cắt cụt tại %L

en: Lines executed:%s of %d
vi: Dòng được thực hiện: %s trên %d

en: Link in code for a __main kernel.
vi: Lien kết mã cho __main của nhân.

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 libc.a and libdebug.a.
vi: Liên kết với libc.a và libdebug.a.

en: Link with libc.a and libsim.a.
vi: Liên kết với libc.a và libsim.a.

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: 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 at %C cannot be a coarray
vi: Biến vòng lặp tại %C không thể là một coarray

en: Loop variable at %C cannot be a sub-component
vi: Biến vòng lặp tại %C không thể là một thành-phần-con

en: Loop variable at %C cannot be an array
vi: Biến vòng lặp tại %C không thể là một mảng

en: Loop variable has been modified
vi: Biến vòng lặp bị sửa đổi

en: MIPS16 PIC for ABIs other than o32 and o64
vi: MIPS16 PIC cho ABIs khác hơn o32 và o64

en: MMIX Internal: Bad value for 'm', not a CONST_INT
vi: MMIX nội bộ: sai đặt 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: MODULE prefix at %C
vi: Tiền tố MODULE tại %C

en: MOLD tag at %L
vi: MOLD tag tại %L

en: Maintain backchain pointer.
vi: Bảo tồn hàm trỏ dây chuyền ngược

en: Make "char" signed by default.
vi: Làm cho "char" là có dấu theo mặc định.

en: Make "char" unsigned by default.
vi: Làm cho "char" là không dấu theo mặc định.

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 một bội số cho 4 byte (cảnh báo: ABI bị sửa đổi).

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 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 mã 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 ước lượng tối đa 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ả ước lượng tối đa 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ăn xếp tối đa (theo phần trăm) do chèn vào trực tiế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 hóa sẵn cây.

en: Maximum number of conditional store pairs that can be sunk.
vi: Số tối đa các cặp lưu điều kiện cái mà có thể hạ xuống.

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 insns in a basic block to consider for RTL if-conversion.
vi: Số tối đa các lệnh trong khối cơ bản cần để coi là cho if-conversion 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 namespaces to search for alternatives when name lookup fails.
vi: Số tối đa các không gian tên để tìm kiếm cái thay thế khi việc tìm gặp lỗi.

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 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: 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ớ để bật 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 để bật 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 %<&%> in continued character constant at %C
vi: Thiếu %<&%> trong hằng ký tự tiếp tục tại %C

en: Missing actual argument %qs in call to %qs at %L
vi: Thiếu đối số đối thực tế %qs trong cú gọi đến %qs tại %L

en: Missing actual argument for argument %qs at %L
vi: Thiếu đối số đối thực tế cho đối số %qs tại %L

en: Missing comma at %L
vi: Thiếu dấu phẩy tại %L

en: Missing format label at %C
vi: Thiếu nhãn định dạng tại %C

en: Missing symbol
vi: Thiếu ký hiệu

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: NO_ARG_CHECK attribute
vi: thuộc tính NO_ARG_CHECK

en: NULL used in arithmetic
vi: NULL được dùng trong số học

en: Name %qs at %C is already defined as a generic interface at %L
vi: Tên “%qs” tại %C đã được định nghĩa trước tại %L

en: Name at %C is too long
vi: Tên tại %C quá dài

en: Name too long
vi: Tên quá dài

en: Negative argument N at %L
vi: Đối số âm N tại %L

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: Nonconforming tab character at %C
vi: Có ký tự tab không phù hợp tại %C

en: Nonexistent include directory %qs
vi: Không phải là thư mục bao gồm sẵn có %qs

en: Not expected TAG.
vi: Không cần THẺ.

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: Object %qs is not a variable at %L
vi: Đối tượng %qs không phải là một biến tại %L

en: Obsolescent feature:
vi: Đặc tính cũ:

en: Offline tool to handle gcda counts
vi: Công cụ ngoại tuyến để xử lý đếm gcda

en: Old-style initialization at %C
vi: Sự khởi tạo kiểu cũ tại %C

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ỏ qua con 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 retained for backward compatibility.
vi: Giữ lại vì mục đích tương thích ngược.

en: Only use 32 FPRs.
vi: Chỉ sử dụng 32 FPRs.

en: Only use 32 GPRs.
vi: Chỉ sử dụng 32 GPRs.

en: Optimize for debugging experience rather than speed or size.
vi: Tối ưu hóa về thử nghiệm hơn là kích thước hay tốc độ.

en: Optimize for space rather than speed.
vi: Tối ưu hóa về kích thước thay vì tốc độ.

en: Optimize for speed disregarding exact standards compliance.
vi: Tối ưu hóa cho tốc độ bất kể có tuân theo đúng chuẩn hay không.

en: Optimize frame header.
vi: Tối ưu hóa về đầu khung.

en: Optimize lui/addiu address loads.
vi: Tối ưu hóa việc nạp địa chỉ lui/addiu.

en: Optimize opcode sizes at link time.
vi: Tối ưu hóa mã lúc liên kết.

en: Optimize tail call instructions in assembler and linker.
vi: Tối ưu hóa 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ăn xếp.

en: Override -mbest-lib-options.
vi: Ghi đè lên -mbest-lib-options.

en: PCS variant
vi: biến thể PCS

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: PROCEDURE list at %C
vi: danh sách PROCEDURE tại %C

en: PROTECTED attribute at %C
vi: thuộc tính BẢO VỆ tại %C

en: Pack VLIW instructions.
vi: Đóng gói các câu lệnh VLIW.

en: Pass -EB option through to linker.
vi: Chuyển tùy chọn -EB cho bộ liên kết.

en: Pass -EL option through to linker.
vi: Chuyển tùy chọn -EL cho bộ liên kết.

en: Pass -marclinux option through to linker.
vi: Chuyển tùy chọn -marclinux cho bộ liên kết.

en: Pass -marclinux_prof option through to linker.
vi: Chuyển tùy chọn -marclinux_prof cho bộ liên kết.

en: Pass -z text to linker.
vi: Chuyển tùy chọn -z text cho bộ liên kết.

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 hóa sự xếp hàng một cách đặc trưng cho VR4130.

en: Permit '$' as an identifier character.
vi: Cho phép “$” là ký tự dùng để định danh.

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: 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ố dấu chấm độ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: Con trỏ là 32-bit.

en: Pointers are 64-bit.
vi: Con trỏ là 64-bit

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: Preprocess directives only.
vi: Chỉ các chỉ thị tiền xử lý.

en: Preprocessed source stored into %s file, please attach this to your bugreport.
vi: Nguồn tiền xử lý lưu vào trong tập tin %s, vui lòng đính kèm cái này vào báo cáo lỗi của bạn.

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: 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 extra (possibly unwanted) warnings.
vi: Hiển thị các cảnh báo thêm nữa (gần như chắc chắn là không cần).

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: Procedure %qs at %C is already defined at %L
vi: Thủ tục “%qs” tại %C đã được định nghĩa trước tại %L

en: Procedure %qs at %L already has basic type of %s
vi: Thủ tục “%qs” tại %L đã sẵn có kiểu cơ bản của %s

en: Procedure %qs called at %L is not explicitly declared
vi: Thủ tục %qs được gọi tại %L không được khai báo rõ rà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: Prohibit PC relative jumps.
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 uninitialized constants in ROM (needs -membedded-data).
vi: Để vào ROM các hằng số chưa khởi tạo (yêu cầu -membedded-data).

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: RTP PIC is incompatible with Thumb
vi: RTP PIC không tương thích với Thumb

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ăn xếp trong đoạn mở đầu.

en: Reallocate the LHS in assignments.
vi: Tái cấp phát được LHS trong phép gán.

en: Recognize GNU-defined keywords.
vi: Không chấp nhận từ khóa "GNU-define"

en: Recognize built-in functions.
vi: Chấp nhận các hàm dựng sẵn.

en: Recognize the "asm" keyword.
vi: Không chấp nhận từ khóa "asm".

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: Result of %s is NaN at %L
vi: Kết quả của %s là NaN tại %L

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 value %qs of function %qs declared at %L not set
vi: Trả lại giá trị %sq của hàm %qs khai báo tại %L chưa đặt

en: Return value of function %qs at %L not set
vi: Trả lại giá trị của hàm %qs tại %L chưa đặt

en: Return values of functions in FPU registers.
vi: Trả lại giá trị của hàm trong thanh ghi FPU (đơn vị dấu chấm độ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: Rewrite subcommand usage:
vi: Cách dùng lệnh con ghi lại:

en: Run only the second compilation of -fcompare-debug.
vi: Chỉ chạy biên dịch lần hai của tùy chọn -fcompare-debug.

en: Running spec function '%s' with %d args
vi: Đang chạy hàm hàm đặc tả “%s” với %d đối số

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: SIZE at %L must be positive
vi: SIZE tại %L phải là số dương

en: SOURCE tag at %L
vi: SOURCE tag tại %L

en: SSA corruption
vi: SSA hỏng

en: SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set
vi: SSA_NAME_OCCURS_IN_ABNORMAL_PHI cần được đặt

en: SSE instruction set disabled, using 387 arithmetics
vi: Chỉ lệnh SSE đặt là tắt, sử dụng số học 387

en: STAT variable
vi: biến STAT

en: STAT= argument to %s at %L
vi: STAT= đối số cho %s tại %L

en: SYNC statement at %C
vi: câu lệnh SYNC tại %C

en: Same as -mA6.
vi: Giống với -mA6.

en: Same as -mA7.
vi: Giống với -mA7.

en: Same as: -mep -mprolog-function.
vi: Giống như: -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: See %s for instructions.
vi: Xem %s để có chỉ dẫn.

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 large model - 20-bit addresses/pointers.
vi: Chọn chế độ rộng - con trỏ và địa chỉ 20 bít.

en: Select method for sdata handling.
vi: Chọn phương pháp để quản lý sdata.

en: Select small model - 16-bit addresses/pointers (default).
vi: Chọn chế độ nhỏ - con trỏ và địa chỉ 20 bít (mặc định).

en: Select the runtime.
vi: Chọn lúc chạy.

en: Select what to sanitize.
vi: Chọn cái gì để cải thiện.

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: Đặt định nghĩa Windows.

en: Set branch cost.
vi: Đặt giá của lệnh rẽ nhánh.

en: Set default accessibility of module entities to PRIVATE.
vi: Đặt 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: Đặt tên của hàm chính cho chương trình gỡ rối.

en: Set register to hold -1.
vi: Đặt thanh ghi giữ giá trị -1

en: Set sizeof(bool) to 1.
vi: Đặt kích cỡ biểu thức bun thành 1.

en: Set start-address of data.
vi: Đặt địa chỉ bắt đầu của dữ liệu.

en: Set start-address of the program.
vi: Đặt địa chỉ bắt đầu của chương trình.

en: Set the PPC_EMB bit in the ELF flags header.
vi: Đặt bit PPC_EMB trong phần đầu cờ ELF.

en: Set the cost of branches.
vi: Đặt giá của nhánh.

en: Set the default double precision kind to an 8 byte wide type.
vi: Đặt 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: Đặt 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: Đặt loại số thực 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: Đặt 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: Đặt 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: Đặt 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: Đặt số tối đa các byte cần để cho kích cỡ ngăn xếp 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: Đặt số lượng tối đa cho một thao tác lượng gia loại ngăn xếp đơn.

en: Set the target CPU type.
vi: Đặt loại CPU đích.

en: Setting spec %s to '%s'
vi: Đang đặt đặ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: 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 bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48.
vi: Ghi rõ kích cỡ bit của hiệu số TLS trực tiếp. giá trị hợp lệ là 12, 24, 32, 48.

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 ngắt.

en: Specifies whether interrupt functions should save and restore the accumulator register.
vi: Ghi rõ nếu hàm ngắt 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 a plugin to load.
vi: Chỉ định phần bổ sung cần nạp.

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 trực tiếp.

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 how to access the thread pointer.
vi: Ghi rõ cách truy cập đến con trỏ tuyến trình.

en: Specify if floating point hardware should be used.
vi: Ghi rõ có nên sử dụng phần cứng dấu chấm độ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 ISA to build for: msp430, msp430x, msp430xv2.
vi: Chỉ định ISA cần biên dịch cho: msp430, mdsp430x, msp430xv2.

en: Specify the MCU to build for.
vi: Chỉ định MCU cần biên dịch cho nó.

en: Specify the __fp16 floating-point format.
vi: Ghi rõ định dấu chấm động __fp16.

en: Specify the code model.
vi: Chỉ định mô hình mã.

en: Specify the model for atomic operations.
vi: Tạo ra mã cho các thao tác atomic.

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 configuration.
vi: Chỉ ra tên của cấu hình dấu chấm động đí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ề dấu chấm độ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 thread local storage scheme.
vi: Chỉ định lược đồ lưu tuyến cục bộ.

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 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: Start expression in DO loop
vi: Biểu thức bắt đầu trong vòng lặp DO (làm)

en: Statement function %qs requires argument list at %C
vi: Câu lệnh hàm %qs cần một danh sách đối số tại %C

en: Statement function at %L cannot appear within an INTERFACE
vi: Hàm khai báo tại %L không phải xuất hiện trong một GIAO DIỆN

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à cài đặt mặc định.

en: String length at %L is too large
vi: Chiều dài chuỗi tại %L là quá lớn

en: Substring at %L has length zero
vi: Chuỗi con tại %L có độ dài là không

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 BMI 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 BMI.

en: Support BMI2 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 BMI2.

en: Support CLFLUSHOPT instructions.
vi: Hỗ trợ chỉ lệnh CLFLUSHOPT.

en: Support CLWB instruction.
vi: Hỗ trợ chỉ lệnh CLWB.

en: Support CLZERO 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 CLZERO.

en: Support F16C 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 F16C.

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 FSGSBASE 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 FSGSBASE.

en: Support FXSAVE and FXRSTOR instructions.
vi: Hỗ trợ chỉ lệnh FXSAVE và FXRSTOR.

en: Support Hardware Lock Elision prefixes.
vi: Hỗ trợ tiền tố Hardware Lock Elision.

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 LZCNT built-in function 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 LZCNT.

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 MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512BW 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, AVX2 và AVX512F và AVX512BW.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512CD 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, AVX2 và AVX512F và AVX512CD.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512DQ 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, AVX2 và AVX512F và AVX512DQ.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512IFMA 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, AVX2 và AVX512F và AVX512IFMA.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512VBMI 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, AVX2 và AVX512F và AVX512VBMI.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512VL 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, AVX2 và AVX512F và AVX512VL.

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F built-in functions and code generation.
vi: Hỗ trợ hàm dựng sẵn MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 và AVX512F và tạo mã.

en: Support MWAITX and MONITORX 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 MWAITX và MONITORX.

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 PKU 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 PKU.

en: Support PREFETCHW instruction.
vi: Hỗ trợ chỉ lệnh PREFETCHW.

en: Support RDRND 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 RDRND.

en: Support RDSEED instruction.
vi: Hỗ trợ chỉ lệnh RDSEED.

en: Support RTM 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 RTM.

en: Support SHA1 and SHA256 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 SHA1 và SHA256.

en: Support TBM 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 TBM.

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 XSAVE and XRSTOR instructions.
vi: Hỗ trợ chỉ lệnh XSAVE và XRSTOR.

en: Support XSAVEC instructions.
vi: Hỗ trợ chỉ lệnh XSAVEC.

en: Support XSAVEOPT instruction.
vi: Hỗ trợ chỉ lệnh XSAVEOPT.

en: Support XSAVES and XRSTORS instructions.
vi: Hỗ trợ chỉ lệnh XSAVES và XRSTORS.

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 flag-preserving add-carry instructions.
vi: Hỗ trợ chức năng tạo ra mã là câu lệnh crc32.

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: Suppress warnings.
vi: Thu hồi cảnh báo.

en: Switch ARM/Thumb modes 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: 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: Switches off the -mstack-guard= option.
vi: Tắt tùy chọn -mstack-guard=.

en: Symbol %qs already declared
vi: Ký hiệu %qs đã sẵn được khai báo

en: Symbol %qs at %C also declared as a type at %L
vi: Ký hiệu “%qs” tại %C đã sẵn được khai báo tại %L

en: Symbol %qs at %C is already in a COMMON block
vi: Ký hiệu %qs tại %C đã có trong khối COMMON

en: Symbol %qs at %L is ambiguous
vi: Ký hiệu “%qs” tại %L chưa rõ ràng

en: Synonym for -Wcomment.
vi: Đồ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: TILE requires constant expression at %L
vi: TILE cần biểu thức hằng tại %L

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 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 the AM34 processor.
vi: Đích là bộ xử lý AM34.

en: Target: %s
vi: Đích: %s

en: The bug is not reproducible, so it is likely a hardware or OS problem.
vi: Nếu lỗi không được tái lặp lại, thế thì gần như chắc chắn là phần cứng hay HDH có trục trặc.

en: The following options are language-independent
vi: Theo đây có những tùy 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 tùy chọn liên quan đến ngôn ngữ

en: The following options are not documented
vi: Theo đây có những tùy 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 tùy 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 tùy chọn được hỗ trợ bởi ngôn ngữ

en: The following options are target specific
vi: Theo đây có những tùy chọn đặc trưng cho đích

en: The following options control compiler warning messages
vi: Theo đây có những tùy 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 tùy chọn điều khiển việc tối ưu hóa

en: The following options take joined arguments
vi: Theo đây có những tùy 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 tùy 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ăn xếp bị đập tan ra.

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 còn treo.

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 branches on the path through the peeled sequence.
vi: Số tối đa các nhánh trên đường dẫn xuyên suốt chuỗi vỏ bọc.

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 combine tries to combine.
vi: Số tối đa các chỉ lệnh phối hợp cố phối hợp.

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 insns của một vòng lặp được lột.

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 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 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 bình quân.

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 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 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 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 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 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 đảo để lấy chỗ trống.

en: The maximum ratio of insertions to deletions of expressions in GCSE.
vi: Tỷ lệ tối đa các của các lệnh chèn để xóa của biểu thức trong GCSE.

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 thức 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 insn đượ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 lớp 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 hồ sơ phản hồi sẵn có.

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 hồ sơ phản hồi không sẵn có.

en: The resolution file.
vi: Tập tin phân giải.

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 L1 cache.
vi: Kích cỡ của 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 xếp 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ưỡngg để 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 type for function %qs at %L is not accessible
vi: Kiểu của hàm %qs tại %L là không thể truy cập

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; 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 option lacks documentation.
vi: Tùy chọn này còn thiếu tài liệu hướng dẫn.

en: This switch is deprecated; do not use.
vi: Cái chuyển này đã lạc hậu: đừng dùng.

en: This switch is deprecated; use -Werror=implicit-function-declaration instead.
vi: Tùy chọn này đã lạc hậu: hãy thay thế bằng -Werror=implicit-function-declaration.

en: This switch is deprecated; use -Wextra instead.
vi: Tùy chọn này đã lạc hậu: hãy thay thế bằng -Wextra.

en: This switch is deprecated; use -fsanitize-recover= instead.
vi: Cái chuyển này đã lạc hậu: hãy thay thế bằng -fsanitize-recover=.

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: Coi là con trỏ hàm có thể nhảy đến mã không phải Thumb.

en: Thumb: Assume non-static functions may be called from ARM code.
vi: Thumb: Coi 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ăn xếp (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ăn xếp (không phải loại lá) ngay cả khi không cần thiết.

en: To enable preprocessing, use %<-cpp%>
vi: Bật khả năng tiền xử lý dùng %<-cpp%>

en: Too many arguments in call to %qs at %L
vi: Quá nhiều đối số trong cuộc gọi đến %qs tại %L

en: Too many arguments to %s at %L
vi: Quá nhiều đối số cho %s tại %L

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: Coi dòng có chữ “D” trong cột đầu tiên là ghi chú.

en: Treat missing header files as generated files.
vi: Coi tập tin phần đầu còn thiếu là tập tin được tạo ra.

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: UNIT not specified at %L
vi: UNIT không được chỉ ra tại %L

en: Unable to find symbol %qs
vi: không thể tìm thấy ký hiệu %qs

en: Unable to generate load/store offset for fusion
vi: Không thể tạo ra việc tải/lưu offset cho hợp nhất

en: Unable to resolve the specific function %qs at %L
vi: Không thể phân giải hàm đặc tả %qs tại %L

en: Unexpected %<*%> for codimension %d of %d at %C
vi: Không cần %<*%> cho đối chiếu %d của %d tại %C

en: Unexpected %s statement at %C
vi: Không cần câu lệnh %s tại %C

en: Unexpected CASE statement at %C
vi: Không cần câu lệnh CASE tại %C

en: Unexpected END statement at %C
vi: Không cần câu lệnh END tại %C

en: Unexpected ENTRY statement at %C
vi: Không cần câu lệnh ENTRY tại %C

en: Unexpected EOF
vi: Gặp kết thúc tập tin bất thường

en: Unexpected element %qc in format string at %L
vi: Gặp phần tử không cần “%qc” trong chuỗi định dạng tại %L

en: Unexpected end of file in %qs
vi: Gặp kết thúc tập tin bất thường tại %qs

en: Unexpected end of module
vi: Gặp kết thức mô-đun bất thường

en: Unexpected intrinsic type %qs at %L
vi: Gặp kiểu hạn chế không cần %qs tại %L

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 intrinsic op
vi: Không hiểu intrinsic op

en: Unknown procedure name %qs at %C
vi: Không rõ tên thủ tục “%qs” tại %C

en: Unrecognized option to floating-point init value: %qs
vi: Không nhận ra tùy chọn để khởi tạo giá trị dấu chấm động: %qs

en: Unrecognized option: %qs
vi: Không nhận ra tùy chọn: "%qs"

en: Unsupported code '%c' for fixed-point:
vi: Không hỗ trợ mã “%c” cho dấu chấm cố định:

en: Unsupported operand for code '%c'
vi: Không hỗ trợ toán hạng cho mã “%c”

en: Unused dummy argument %qs at %L
vi: Đối số giả chưa dùng %qs tại %L

en: Unused parameter %qs declared at %L
vi: Đối số chưa dùng %qs được khai báo tại %L

en: Unused variable %qs declared at %L
vi: Biến số chưa dùng %qs được khai báo tại %L

en: Usage: %s [OPTION]... SUB_COMMAND [OPTION]...
vi: Cách dùng: %s [TÙY_CHỌN]… LỆNH_CON [TÙY-CHỌN]…

en: Usage: %s [options] file...
vi: Cách dùng: %s [tuỳ_chọn] tập-tin…

en: Use "-Wa,OPTION" to pass "OPTION" to the assembler.
vi: Hãy sử dụng "-Wl,TÙY_CHỌN" để gửi tùy 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 tùy 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 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 đa phương tiện.

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 FPRs.

en: Use 64 GPRs.
vi: Sử dụng 64 GPRs.

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 đa phương tiện.

en: Use 80-bit long double.
vi: Sử dụng đôi dài 80-bit.

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 Enhanced Virtual Addressing instructions.
vi: Dùng các chỉ lệnh Địa chỉ Ảo hóa Nâng cao.

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 dấu chấm động

en: Use ISA 2.07 Category:Vector.AES and Category:Vector.SHA2 instructions.
vi: Sử dụng câu lệnh ISA 2.07 Category:Vector.AES và Category:Vector.SHA2.

en: Use LRA instead of reload (transitional).
vi: Sử dụng LRA thay cho reload (cổ điển).

en: Use MCU instructions.
vi: Dùng chỉ lệnh MCU.

en: Use MIPS MSA Extension instructions.
vi: Sử dụng câu lệnh mở rộng MIPS MSA.

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 double-word (rather than quad-word) registers for vectorization.
vi: Sử dụng thanh ghi từ kép (thay cho từ bốn) Neon để véc-tơ hóa.

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ơ hóa.

en: Use P-mnemonics for branches statically predicted as taken.
vi: Sử dụng gợi-nhớ-P cho nhánh dự đoán tĩnh là bắt được.

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 dấu chấm độ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 dấu chấm độ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 all registers, reserving none 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 ngắt.

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: Dùng giá trị trực tiếp cỡ tùy ý trong thao tác bit.

en: Use big-endian byte order.
vi: Sử dụng thứ tự byte 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 dấu chấm động thập phân bằng phần cứng.

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 eXtended Physical Address (XPA) instructions.
vi: Dùng các chỉ lệnh Địa chỉ Ảo hóa Nâng cao (XPA).

en: Use epsilon-respecting floating point compare instructions.
vi: Sử dụng câu lệnh so sánh loại dấu chấm động tùy theo épxilô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 và định thời CPU đó.

en: Use flat register window model.
vi: Sử dụng mô hình cửa sổ thanh ghi phẳng.

en: Use fp double instructions.
vi: Sử dụng câu lệnh dấu chấm động chính đôi.

en: Use fp registers.
vi: Sử dụng thanh ghi dấu chấm động.

en: Use full-set registers for register allocation.
vi: Sử dụng cả bộ thanh ghi cho phân bổ thanh ghi.

en: Use given SPARC-V9 code model.
vi: Sử dụng mẫu mã SPARC-V9 đưa ra.

en: Use given address mode.
vi: Dùng chế độ địa chỉ đã cho.

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 (default).
vi: Sử dụng FP (dấu chấm động) bằng phần cứng (mặc định).

en: Use hardware FP.
vi: Sử dụng dấu chấm động bằng 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 conversion instructions.
vi: Dùng chỉ lệnh chuyển đổi dấu chấm động bằng phần cứng.

en: Use hardware floating point instructions.
vi: Sử dụng các chỉ lệnh chấm động phần cứng.

en: Use hardware floating point square root instruction.
vi: Dùng chỉ lệnh bình phương chấm động bằng phần cứng.

en: Use hardware floating point.
vi: Sử dụng dấu chấm động loại phần cứng.

en: Use hardware fp.
vi: Sử dụng dấu chấm động bằng phần cứng.

en: Use hardware quad FP instructions.
vi: Sử dụng câu lệnh loại bốn dấu chấm động phần cứng.

en: Use hardware transactional execution instructions.
vi: Sử dụng các chỉ lệnh thực thi giao dịch bằ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 integer madd/msub instructions.
vi: Sử dụng chỉ lệnh madd/msub số nguyên.

en: Use little-endian byte order.
vi: Sử dụng thứ tự byte 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 đa phương tiện.

en: Use microMIPS instructions.
vi: Sử dụng các chỉ lệnh microMIPS.

en: Use multiply add/subtract instructions.
vi: Sử dụng câu lệnh nhân_cộng/trừ.

en: Use multiply high instructions for high part of 32x32 multiply.
vi: Dùng các chỉ lệnh nhân cao cho các phần cao của phép nhân 32x32.

en: Use musl C library.
vi: Sử dụng thư viện musl C

en: Use native (MS) bitfield layout.
vi: Sử dụng bố trí trường bit sở hữu (MS).

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 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ăn xếp đó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 pattern compare instructions.
vi: Sử dụng câu lệnh so sánh mẫu.

en: Use portable calling conventions.
vi: Sử dụng quy ước gọi di động.

en: Use propolice as a stack protection method.
vi: Bật chức năng bảo vệ ngăn xếp asan.

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ăn xếp 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 shared libraries.
vi: Sử dụng thư viện dùng chung.

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 simple data speculation check.
vi: Dùng hàm kiểm tra phép đầu cơ loại dữ liệu đơn giản.

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

en: Use software emulation for floating point (default).
vi: Sử dụng dấu chấm động bằng phần mềm (mặc định)

en: Use software floating point comparisons.
vi: Sử dụng so sánh dấu chấm động bằng phần mềm.

en: Use software floating point.
vi: Sử dụng dấu chấm động bằng phần mềm.

en: Use stack bias.
vi: Sử dụng khuynh hướng về ngăn xếp.

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 synci instruction to invalidate i-cache.
vi: Sử dụng câu lệnh synci để làm tắt i-cache.

en: Use tas.b instruction for __atomic_test_and_set.
vi: Dùng chỉ lệnh tas.b cho __atomic_test_and_set.

en: Use the AltiVec ABI extensions.
vi: Dùng lệnh mở rộng AltiVec ABI.

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 ELFv1 ABI.
vi: Sử dụng ELFv1 ABI.

en: Use the ELFv2 ABI.
vi: Sử dụng ELFv2 ABI.

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 given data alignment.
vi: Dùng xếp hàng dữ liệu đã cho.

en: Use the most feature-enabling options allowed by other options.
vi: Sử dụng những tùy chọn bật nhiều tính năng nhất tùy theo giới hạn của tùy chọn khác.

en: Use the mvcle instruction for block moves.
vi: Tạo ra câu lệnh chuỗi mvcle để di chuyển khối.

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: Uses of this option are diagnosed.
vi: Dùng tùy-chọn này để chuẩn đoán.

en: Using built-in specs.
vi: Đang sử dụng các đặc tả dựng sẵn.

en: VALUE attribute at %C
vi: thuộc tính VALUE tại %C

en: VALUE statement at %C
vi: câu lệnh VALUE tại %C

en: VOIDmode on an output
vi: Chế độ VOIDmode trên một đầu ra

en: VOLATILE attribute at %C
vi: thuộc tính VOLATILE tại %C

en: VOLATILE statement at %C
vi: câu lệnh VOLATILE tại %C

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 -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: Variable %qs cannot appear in the expression at %L
vi: Biến %qs không thể xuất hiện trong biểu thức tại %L

en: Variable %qs is not a dummy argument at %L
vi: Biến %qs không phải là đối số hàm giả tại %L

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 khai báo “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 'new' of type with extended alignment without -faligned-new.
vi: Cảnh báo về “new” của kiểu với căn chỉnh được mở rộng mà không có -faligned-new.

en: Warn about @selector()s without previously declared methods.
vi: Cảnh báo về @selector()s không có lời khai báo trước.

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 C++ constructs whose meaning differs between ISO C++ 2011 and ISO C++ 2014.
vi: Cảnh báo về cấu trúc C++ mà nó có nghĩa khác nhau giữa ISO C++ 2001 và ISO C++ 2014.

en: Warn about C++11 inheriting constructors when the base has a variadic constructor.
vi: Cảnh báo về các cấu trúc kế thừa C++11 khi cơ sở có một cấu tử variadic.

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 USE statements that have no ONLY qualifier.
vi: Cảnh báo về chuỗi định dạng không phải có nghĩa chữ

en: Warn about __TIME__, __DATE__ and __TIMESTAMP__ usage.
vi: Cảnh báo về sử dụng __TIME__, __DATE__ và __TIMESTAMP__.

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 an invalid DO loop.
vi: Cảnh báo về vòng lặp DO không hợp lệ.

en: Warn about boolean expression compared with an integer value different from true/false.
vi: Cảnh báo về so sánh biểu thứ lôgíc với một giá trị nguyên khác đúng/sai.

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 khai báo 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ề hàm áp kiểu cho kiểu không tương thích.

en: Warn about casts which discard qualifiers.
vi: Cảnh báo về sự ép kiểu mà loại bỏ đoạn điều kiện.

en: Warn about certain operations on boolean expressions.
vi: Cảnh báo về thao tác chắc chắn trên biểu thức lô-gíc.

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 constant integer divisions with truncated results.
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 dangling else.
vi: Cảnh báo về else thừa.

en: Warn about deleting polymorphic objects with non-virtual destructors.
vi: Cảnh báo về xóa các đối tượng đa thể với cấu trúc không phải ảo.

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 duplicated conditions in an if-else-if chain.
vi: Cảnh báo về các điều kiện trùng lắp trong chuỗi if-else-if.

en: Warn about equality comparisons involving REAL or COMPLEX expressions.
vi: Cảnh báo về so sánh bằng liên quan đến biểu thức REAL hay COMPLEX.

en: Warn about features not present in ISO C90, but present in ISO C99.
vi: Cảnh báo về các đặc điểm không có trong ISO C90, nhưng lại có trong ISO C99.

en: Warn about features not present in ISO C99, but present in ISO C11.
vi: Cảnh báo về các đặc điểm không có trong ISO C99, nhưng lại có trong ISO C11.

en: Warn about features not present in traditional C.
vi: Cảnh báo về các đặc điểm không có trong ISO C90, nhưng lại có trong ISO C99

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 call elimination.
vi: Cảnh báo về lời gọi hàm ngầm.

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 khai báo 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 khai báo 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 conversions from "float" to "double".
vi: Cảnh báo về sự chuyển đổi ngầm "float" thành "double".

en: Warn about implicit declarations.
vi: Cảnh báo khai báo ngầm.

en: Warn about implicit function declarations.
vi: Cảnh báo về lời khai báo hàm ngầm.

en: Warn about incompatible integer to pointer and pointer to integer conversions.
vi: Cảnh báo về sự không thể chuyển đổi số nguyên thành con trỏ và con trỏ thành số nguyên.

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 macros defined in the main file that are not used.
vi: Cảnh báo về các vĩ lệnh đã định nghĩa trong tập tin chính mà không được sử dụng.

en: Warn about maybe uninitialized automatic variables.
vi: Cảnh báo về các biến tự động tự động không được khởi tạo.

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 khởi tạo cấu trúc thiếu trường.

en: Warn about missing sized deallocation functions.
vi: Cảnh báo về thiếu hàm giải cấp phát cỡ.

en: Warn about misuses of pragmas.
vi: Cảnh báo lạm dụng pragmas.

en: Warn about most implicit conversions.
vi: Cảnh báo chuyển đổi ngầm.

en: Warn about multiple declarations of the same object.
vi: Cảnh báo về nhiều khai báo trên cùng đối tượ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 overflow in arithmetic expressions.
vi: Cảnh báo về biểu thức toán học bị tràn.

en: Warn about overloaded virtual function names.
vi: Cảnh báo về các tên hàm ảo quá tải.

en: Warn about overriding initializers with side effects.
vi: Cảnh báo về ghi đè lên đoạn khởi tạo mà có hiệu ứng cạnh.

en: Warn about overriding initializers without side effects.
vi: Cảnh báo về ghi đè lên đoạn khởi tạo mà không có hiệu ứng cạnh.

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 pointer casts which increase alignment.
vi: Cảnh báo về ép đổi con trỏ cái mà sẽ gia tăng sắp hàng.

en: Warn about positional initialization of structs requiring designated initializers.
vi: Cảnh báo về đoạn khởi tạo của cấu trúc cần bộ khởi tạo thiết kế.

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 đề về hàm định dạng.

en: Warn about possible violations of sequence point rules.
vi: Cảnh báo về sự vi phạm quy tắc điểm liên tiếp.

en: Warn about possibly missing braces around initializers.
vi: Cảnh báo về đoạn khởi tạo 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 real-literal-constants with 'q' exponent-letter.
vi: Cảnh báo về hằng-chữ-số-thực với chữ-số-mũ “q”.

en: Warn about returning structures, unions or arrays.
vi: Cảnh báo về trả về các cấu trúc, liên hợp hay mảng.

en: Warn about sign differences with format functions.
vi: Cảnh báo về các khác biệt dấu với các hàm định dạng.

en: Warn about signed-unsigned comparisons.
vi: Cảnh báo về so sánh có và không dấu.

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 khai báo “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 switches with boolean controlling expression.
vi: Cảnh báo về switches với biểu thức điều khiển trả về lô-gíc.

en: Warn about things that change between the current -fabi-version and the specified version.
vi: Cảnh báo về những thứ thay đổi giữa -fabi-version hiện tại và phiên bản chỉ định.

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 uncasted NULL used as sentinel.
vi: Cảnh báo NULL chưa áp kiểu dùng làm ký hiệu cầm canh.

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 uninitialized automatic variables.
vi: Cảnh báo về các biến tự động tự động không được khởi tạo.

en: Warn about unprototyped function declarations.
vi: Cảnh báo về khai báo hàm không được khai báo mẫu trước.

en: Warn about unrecognized pragmas.
vi: Cảnh báo về pragmas không thừa nhận.

en: Warn about unsuffixed float constants.
vi: Cảnh báo hằng thực không có hậu tố.

en: Warn about unused dummy arguments.
vi: Cảnh báo về đối số giả có không dùng.

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 useless casts.
vi: Cảnh báo về áp kiểu vô ích.

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 uses of __attribute__((deprecated)) declarations.
vi: Cảnh báo về việc dùng khai báo __attribute__((đã lạc hậu)).

en: Warn about using variadic macros.
vi: Cảnh báo về dùng các vĩ lệnh variadic.

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ự khởi tạo.

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 about zero-trip DO loops.
vi: Cảnh báo về định dạng có chiều dài số không

en: Warn for conditionally-supported constructs.
vi: Cảnh báo cho cấu trúc hỗ-trợ-có-điều-kiện.

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 cause loss of floating point precision.
vi: Cảnh báo về sự chuyển đổi loại ngầm có thể làm nguyên nhân mất chính xác số thực dấu chấm động.

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 khai báo kiểu cũ.

en: Warn if "defined" is used outside #if.
vi: Cảnh báo nếu như "defined" được sử dụng ngoài #if.

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 comparison always evaluates to true or false.
vi: Cảnh báo khi so sánh luôn ước lượng là đúng hoặc là sai.

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, lớp, phương pháp hay trường đã lạc hậu.

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 local declaration hides an instance variable.
vi: Cảnh báo khi một lời khai báo nội bộ ẩn một biến minh dụ.

en: Warn if a selector has multiple methods.
vi: Cảnh báo nếu một chọn có nhiều phương thức.

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 subobject has an abi_tag attribute that the complete object type does not have.
vi: Cảnh báo nếu một đối tượng con có thuộc tính abi_tag cái mà kiểu đối tượng hoàn chỉnh không có.

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 a variable length array is used.
vi: Cảnh báo nếu mảng có độ dài biến đổi được dùng.

en: Warn if an array is accessed out of bounds.
vi: Cảnh báo nếu một mảng bị truy cập ở ngoài phạm vi của nó.

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 left shifting a negative value.
vi: Cảnh báo nếu số lượng dịch trái là số âm.

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 qualifiers on arrays which are pointer targets are discarded.
vi: Cảnh báo nến từ hạn định trên mảng cái mà đích trỏ đến bị loại bỏ.

en: Warn if shift count >= width of type.
vi: Cảnh báo nếu số lượng dịch >= độ rộng của kiểu.

en: Warn if shift count is negative.
vi: Cảnh báo nếu số lượng dịch là số âm.

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ố dấu chấm động.

en: Warn if the pointer in a pointer assignment might outlive its target.
vi: Cảnh báo nếu con trỏ trong phép gán con trỏ có thể vượt qua đích của nó.

en: Warn if the type of a variable might be not interoperable with C.
vi: Cảnh báo nếu kiểu của biến có thể không có khả năng tương thích với C.

en: Warn if type qualifiers on pointers are discarded.
vi: Cảnh báo nếu từ hạn định trên các con trỏ bị loại bỏ.

en: Warn on any use of alloca.
vi: Cảnh báo mọi sử dụng alloca.

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 on namespace definition.
vi: Cảnh báo lúc định nghĩa không gian tên.

en: Warn on primary template declaration.
vi: Cảnh báo về khai báo hàm mẫu sơ cấp.

en: Warn when __builtin_frame_address or __builtin_return_address is used unsafely.
vi: Cảnh báo khi __builtin_frame_address hay __builtin_return_address được dùng không an toàn.

en: Warn when a #warning directive is encountered.
vi: Cảnh báo khi chạm trán chỉ thị #warning.

en: Warn when a built-in function is declared with the wrong signature.
vi: Cảnh báo một hàm dựng sẵn được khai báo với chữ ký sai.

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 const variable is unused.
vi: Cảnh báo khi biến hằng không được dùng.

en: Warn when a declaration does not specify a type.
vi: Cảnh báo khi một lời khai báo 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 khai báo đẳ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ự khởi tạo 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 left-hand-side array variable is reallocated.
vi: Cảnh báo khi mảng bên-tay-trái được tái cấp phát.

en: Warn when a left-hand-side variable is reallocated.
vi: Cảnh báo khi biến bên-tay-trái được tái cấp phát.

en: Warn when a literal '0' is used as null pointer.
vi: Cảnh báo khi chuỗi văn “0” được dùng như là con trỏ null.

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 pointer is cast to an integer of a different size.
vi: Cảnh báo khi có một sự gán cho một hàm trỏ cho một số nguyên có kích cỡ khác.

en: Warn when a register variable is declared volatile.
vi: Cảnh báo khi biến thanh ghi được khai báo là hay thay đổi.

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 an inlined function cannot be inlined.
vi: Cảnh báo khi không không thể dùng hàm chung dòng.

en: Warn when an optimization pass is disabled.
vi: Cảnh báo khi chuyển một tối ưu mà nó bị tắt

en: Warn when attempting to free a non-heap object.
vi: Cảnh báo khi cố giải phóng một đối tượng không-heap.

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 thành viên.

en: Warn when deleting a pointer to incomplete type.
vi: Cảnh báo khi xóa một con trỏ tới kiểu không hoàn toà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 khai báo bên trong một mẫu.

en: Warn when the compiler reorders code.
vi: Cảnh báo khi trình dịch đổi thứ tự mã.

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 when there is a conversion between pointers that have incompatible types.
vi: Cảnh báo khi chuyển đổi giữa một con trỏ tới kiểu không tương thích.

en: Warn when typedefs locally defined in a function are not used.
vi: Cảnh báo khi typedefs nội bộ định nghĩa hàm mà nó không được dùng.

en: Warn whenever a trampoline is generated.
vi: Cảnh báo khi nào đoạn điều kiện loại bị bỏ qua.

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 attributes are ignored.
vi: Cảnh báo khi nào các thuộc tính bị bỏ qua.

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ã -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: Whether to use canonical types.
vi: Có nên sử dụng loại hợp nguyên tắc hay không.

en: Which -fsched-pressure algorithm to apply.
vi: Thuật toán nào được áp dụng.

en: While setting up signal handler: %m
vi: Trong khi cài đặt bộ tiếp hợp tín hiệu: %m

en: While setting up signal stack: %m
vi: Trong khi cài đặt stack tín hiệu: %m

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 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 24K errata.
vi: Khắc phục một số lỗi 24K nào đó.

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 RM7000 errata.
vi: Khắc phục một số lỗi RM7000 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: [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: `
vi: “

en: a comma operator cannot appear in a constant-expression
vi: toán tử dấu phẩy không được xuất hiện trong biểu thức hằng

en: a concept cannot be a member function
vi: cấu tử không thể là hàm thành viên tĩnh

en: a constructor cannot be %<concept%>
vi: cấu tử không thể là %<concept%>

en: a function call cannot appear in a constant-expression
vi: cú gọi hàm không được xuất hiện trong biểu thức hằng

en: a function-definition is not allowed here
vi: không cho phép định nghĩa hàm tại đây

en: a template cannot be defaulted
vi: một mẫu không thể là mặc định

en: a wide string is invalid in this context
vi: một chuỗi lớn là không hợp lệ trong ngữ cảnh này

en: abort in %s, at %s:%d
vi: bỏ dở lúc %s, tại %s:%d

en: accumulator is not a constant integer
vi: thanh ghi tổng không phải là số nguyên hằng

en: actual argument to INTENT = OUT/INOUT
vi: tham số thực tế cho INTENT = OUT/INOUT

en: add_sym(): Bad sizing mode
vi: add_sym(): Chế độ cỡ sai

en: address of label %qD returned
vi: địa chỉ của nhãn %qD được trả về

en: address of local variable %qD returned
vi: địa chỉ của biến cục bộ %q+D được trả về

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: aka
vi: được biết là

en: allocatable argument
vi: đối số phân bổ được

en: also found %<%c%s%>
vi: cũng tìm thấy %<%c%s%>

en: ambiguous method %s%s%s
vi: phương thức còn chưa rõ ràng %s%s%s

en: ambiguous overload for
vi: quá tải chưa rõ ràng đối với

en: an assignment cannot appear in a constant-expression
vi: phép gán không thể được xuất hiện trong biểu thức hằng

en: an decrement cannot appear in a constant-expression
vi: phép gia số không thể được xuất hiện trong biểu thức hằng

en: an increment cannot appear in a constant-expression
vi: phép gia số không được phép xuất hiện trong biểu thức hằng

en: anachronism
vi: niên đại

en: anachronism:
vi: sai niên đại:

en: and %qT has no template constructors
vi: và %qT không có các cấu tử mẫu

en: argument %qd is not a constant
vi: đối số %qd không phải hằng số

en: argument %qs to %<-Waligned-new%> not recognized
vi: không nhận ra tham số %qs cho %<-Waligned-new%>

en: argument %qs to %<-Wnormalized%> not recognized
vi: không nhận ra tham số %qs cho %<-Wnormalized%>

en: argument %qs to %<-femit-struct-debug-detailed%> not recognized
vi: không nhận ra đối số %qs cho %<-femit-struct-debug-detailed%>

en: argument %qs to %<-femit-struct-debug-detailed%> unknown
vi: không hiểu đối số %qs cho %<-femit-struct-debug-detailed%>

en: argument 1 must be a map
vi: đối số 1 phải là ánh xạ

en: argument must be a field reference
vi: đối số phải là một tham chiếu trường

en: argument must be channel
vi: đối số phải là kênh

en: argument must have complex type
vi: đối số phải có kiểu phức

en: argument to %qs is too large (max. %d)
vi: đối số cho %qs quá lớn (tối đa là %d)

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: arith_power(): Bad base
vi: arith_power(): Cơ số sai

en: arith_power(): unknown type
vi: arith_power(): không hiểu kiểu

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ộ khởi tạo 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ộ khởi tạo 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ộ khởi tạo 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ộ khởi tạo không phải mảng

en: array index range in initializer exceeds array bounds
vi: bộ khởi tạo 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ị khởi tạo 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ị khởi tạo từ hằng số chuỗi nằm trong ngoặc đơn

en: array member %q#D declared here
vi: thành viên mảng %q#D đã khai báo ở đây

en: array of inappropriate type initialized from string constant
vi: mảng loại không thích hợp bị khởi tạo từ hằng số chuỗi

en: array result
vi: kết quả mảng

en: array size missing in %q+D
vi: thiếu kích thước mảng trong %q+D

en: array size missing in %qD
vi: thiếu kích thước mảng trong %qD

en: array size missing in %qT
vi: thiếu kích thước mảng trong %qT

en: array subscript is not an integer
vi: chỉ số mảng không phải là số nguyên

en: array used as initializer
vi: mảng được dùng như là bộ khởi tạo

en: assertion missing after %qs
vi: thiếu quyết toán sau %qs

en: assigning to an array from an initializer list
vi: gán giá trị cho mảng từ một danh sách bộ khởi tạo

en: assignment
vi: sự gán

en: assignment of function %qD
vi: gán của hàm %qD

en: assignment of read-only member %qD
vi: gán thành viên chỉ-đọc %qD

en: assignment of read-only variable %qD
vi: gán cho biến chỉ đọc %qD

en: assignment suppression
vi: thu hồi sự gán

en: assumed-rank argument
vi: đối số assumed-rank

en: assumed-shape argument
vi: đối số assumed-shape

en: assumed-type argument
vi: đối số assumed-type

en: asynchronous argument
vi: đối số không đồng bộ

en: atexit failed
vi: atexit gặp lỗi

en: attribute %<target%> argument not a string
vi: thuộc tính %<target%> không là một chuỗi

en: attribute declaration
vi: lời khai báo thuộc tính

en: attribute ignored
vi: thuộc tính bị bỏ qua

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 a constant:
vi: địa chỉ sai, không phải là một hằng số:

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 builtin code
vi: mã dựng sẵn sai

en: bad builtin fcode
vi: fcode dựng sẵn sai

en: bad builtin icode
vi: icode dựng sẵn sai

en: bad condition code
vi: mã điều kiện sai

en: bad insn for 'A'
vi: sai đặt 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, đặt 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 đặt lệnh tới frv_print_operand_address:

en: bad insn to frv_print_operand_memory_reference:
vi: sai đặt 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: đặt sai toán hạng output_condmove_single

en: bad output_move_double operand
vi: đặt sai toán hạng output_move_double

en: bad output_move_single operand
vi: đặt 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 đặt 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 usage of spec function %qs
vi: cách dùng hàm đặc tả %qs sai

en: base class %q#T has accessible non-virtual destructor
vi: lớp cơ sở %q+T có một hủy tử non-trivial truy cập được

en: base operand of %<->%> is not a pointer
vi: toán hạng cơ sở của %<->%> không phải là một con trỏ

en: bb %d does not belong to loop %d
vi: bb %d không thuộc về vòng lặp %d

en: bb %d on wrong place
vi: bb %d trên chỗ sai

en: bind(c) procedure
vi: thủ tục bind(c)

en: block IF
vi: IF (nếu) loại khối

en: bogus JARL construction: %d
vi: chỉ lệnh JARL giả: %d

en: bogus JR construction: %d
vi: chỉ lệnh JR giả: %d

en: bogus PREPEARE construction: %d
vi: chỉ lệnh PREPEARE giả: %d

en: both %<__thread%> and %<thread_local%> specified
vi: đã chỉ ra cả hai %<__thread%> và %<thread_local%>

en: both arguments to %<__builtin___clear_cache%> must be pointers
vi: cả hai đối số cho %<__builtin___clear_cache%> phải là các con trỏ

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ộ khởi tạo vô hướng

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: call of %<(%T) (%A)%> is ambiguous
vi: cú gọi của %<(%T) (%A)%> chưa rõ ràng

en: call of overloaded %<%D(%A)%> is ambiguous
vi: gọi hàm quá tải %<%D(%A)%> chưa rõ ràng

en: call of overloaded %<%s(%A)%> is ambiguous
vi: gọi hàm quá tải %<%s(%A)%> chưa rõ ràng

en: called from here
vi: được gọi từ đây

en: called from this function
vi: được gọi từ hàm này

en: caller is not optimized
vi: cú gọi không được tối ưu hóa

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: candidates are:
vi: các ứng cử là:

en: cannot call constructor %<%T::%D%> directly
vi: không thể gọi cấu tử %<%T::%D%> một cách trực tiếp

en: cannot capture member %qD of anonymous union
vi: không thể chụp thành viên %qD trong hỗn hợp nặc danh

en: cannot convert to a pointer type
vi: không thể chuyển đổi thành kiểu con trỏ

en: cannot declare pointer to %q#T
vi: không thể khai báo con trỏ đến %q#T

en: cannot declare pointer to %q#T member
vi: không thể khai báo con trỏ cho thành viên %q#T

en: cannot declare reference to %q#T
vi: không thể khai báo tham chiếu đến %q#T

en: cannot decompose address
vi: không thể giải mã địa chỉ

en: cannot disable built-in function %qs
vi: không thể tắt hàm dựng sẵn %qs

en: cannot find %s in plugin %s
    %s
vi: không tìm thấy %s trong phần bổ xung %s
    %s

en: cannot find LTO cgraph in %s
vi: không thể tìm thấy LTO cgraph trong %s

en: cannot find LTO section refs in %s
vi: không thể tìm thấy tham chiếu phần LTO trong %s

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 open %s: %m
vi: không thể mở %s: %m

en: cannot open '%s'
vi: không mở được “%s”

en: cannot open intermediate ptx file
vi: Không thể mở tập tin xuất trung gian ptx

en: cannot read %s: %m
vi: không thể đọc %s: %m

en: cannot read LTO mode table from %s
vi: không thể đọc chế độ LTO từ %s

en: cannot specify %<override%> for a class
vi: không thể chỉ định %<override%> cho lớp

en: cannot specify -static with -fsanitize=address
vi: không thể chỉ định -static với -fsanitize=địa_chỉ

en: cannot specify -static with -fsanitize=thread
vi: không thể chỉ định -static với -fsanitize=thread

en: cannot take address of %qs
vi: không thể lấy địa chỉ của %qs

en: cannot use %<::%> in parameter declaration
vi: không thể dùng %<::%> trong khai báo đối số

en: cannot use mshared and static together
vi: không cho phép sử dụng đồng thời hai tùy 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 tùy chọn mthreads và mlegacy-threads

en: cannot use type %s as type %s
vi: không thể dùng kiểu %s như là %s

en: case labels not sorted in switch statement
vi: các nhãn case không được sắp xếp trong câu lệnh switch

en: case labels not sorted:
vi: nhãn cho case chưa được sắp xếp:

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: cgraph_node has wrong clone list
vi: cgraph_node có danh sách nhân bản sai

en: cgraph_node has wrong clone_of
vi: cgraph_node có clone_of sai

en: check_intents(): List mismatch
vi: check_intents(): Danh sách không khớp

en: check_restricted(): Unknown expression type
vi: check_restricted(): không hiểu kiểu biểu thức

en: check_some_aliasing(): List mismatch
vi: check_some_aliasing(): Danh sách không khớp

en: checksum is (%x,%x) instead of (%x,%x)
vi: tổng kiểm là (%x,%x) thay vì (%x,%x)

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: class %qE is deprecated
vi: lớp %qE đã lạc hậu

en: class type %qT is incomplete
vi: kiểu lớp %qT chưa hoàn thiện

en: cleanup argument not a function
vi: dọn các đối số không phải hàm

en: cleanup argument not an identifier
vi: dọn các đối số không phải định danh

en: closing dependency file %s: %m
vi: đóng tập tin phụ thuộc %s: %m

en: coarray argument
vi: đối số coarray

en: code model %qs not supported in x32 mode
vi: mô hình mã %qs không được hỗ trợ trong chế độ x32

en: code model %s does not support PIC mode
vi: mô hình mã %s không hỗ trợ chế độ PIC

en: collect2 version %s
vi: collect2 phiên bản %s

en: comma at end of enumerator list
vi: dấu phẩy ở cuối của danh dánh liệt kê

en: compare_actual_expr(): Bad component code
vi: compare_actual_expr(): Mã thành phần sai

en: compare_real(): Bad operator
vi: compare_real(): Toán tử sai

en: comparison between %q#T and %q#T
vi: so sánh giữa %q#T và %q#T

en: comparison between %qT and %qT
vi: so sánh giữa %qT và %qT

en: comparison is always %d
vi: so sánh luôn là %d

en: compatible type is here
vi: kiểu tương thích là ở đây

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: complex invalid for %qs
vi: số ảo không hợp lệ cho %qs

en: compressed stream: %s
vi: dòng dữ liệu được nén: %s

en: conflicting super class name %qE
vi: xung đột tên siêu lớp %qE

en: conflicting types for %<%c%s%>
vi: các kiểu xung đột với %<%c%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: cân nhắc dùng “-pg” thay cho “-p” với gprof(1)

en: consider using `-pg' instead of `-p' with gprof(1)
vi: sử dụng gprof(1) thì đề nghị bạn đặt "-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: constant argument out of range for %qs
vi: đối số hằng nằm ngoài phạm vi cho %qs

en: constant refers to itself
vi: hằng tham chiếu đến chính nó

en: constructor cannot be static member function
vi: cấu tử không thể là hàm thành viên tĩnh

en: constructor priorities are not supported
vi: các quyền ưu tiên cấu tử là không được hỗ trợ

en: containing loop here
vi: chứa vòng lặp

en: continue statement not within a loop
vi: câu lệnh “continue” nằm ở ngoài một vòng lặp

en: conversion casts away constness
vi: việc chuyển đổi cũng bỏ trình trạng bất biến

en: conversion from %q#T to %q#T
vi: chuyển đổi từ %q#T sang %q#T

en: converting far pointer to near pointer
vi: không thể chuyển đổi thành kiểu con trỏ

en: corrupt loop tree root
vi: gốc cây loop bị hỏng

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 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 interface for class %qE
vi: không tìm thấy giao diện cho 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 dump file %qs: %m
vi: không thể mở tập tin dump %qs: %m

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 parse file offset
vi: không thể phân tích khoảng bù tập tin

en: could not parse hex number
vi: không thể phân tích số thập lục phân

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 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 differing settings of '%s'
vi: được tạo và sử dụng với cài đặt khác nhau của “%s”

en: creating array of %qT
vi: đang tạo mảng của %qT

en: creating array of function members
vi: tạo mảng của thành viên hàm

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: creating pointer to member of type void
vi: đang tạo con trỏ đến thành viên của kiểu void

en: data declaration
vi: lời khai báo dữ liệu

en: debug
vi: gỡ lỗi

en: debug output level %qs is too high
vi: mức gỡ lỗi %qs là quá cao

en: debug:
vi: gỡ rối:

en: declaration of %<~%T%> as member of %qT
vi: phần khai báo của %<~%T%> là thành viên của %qT

en: declaration of %q#D has no initializer
vi: khai báo của %q#D chưa có bộ khởi tạo

en: declaration of %q#T
vi: khai báo của %q#T

en: declaration of %qD as %<typedef%>
vi: sự khai báo của %qD như là %<typedef%>

en: declaration of %qD as array of function members
vi: sự khai báo của %qD như là mảng của các thành viên hàm

en: declaration of %qD as array of functions
vi: sự khai báo của %qD như là mảng của các hàm

en: declaration of %qD as array of references
vi: sự khai báo của %qD như là mảng của các tham chiếu

en: declaration of %qD as array of void
vi: sự khai báo của %qD như là mảng void

en: declaration of %qD as member of %qT
vi: sự khai báo của %qD như là thành viên của %qT

en: declaration of %qD as non-function
vi: sự khai báo của %qD như là non-function

en: declaration of %qD as parameter
vi: khai báo của %qD như là đối số

en: declaration of %qD shadows a member of %qT
vi: sự khai báo của các bóng %qD như là thành viên của %qT

en: declaration of %qE as array of functions
vi: sự khai báo của %qE như là mảng của các hàm

en: declaration of %qE as array of voids
vi: sự khai báo của %qE như là mảng của void

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

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

en: declared protected here
vi: được khai báo bảo vệ ở đây

en: decrement of enumeration value is invalid in C++
vi: phép giảm giá trị kiểu liệt kê là không hợp lệ trong C++

en: decrement of function %qD
vi: số giảm của hàm %qD

en: decrement of pointer to an incomplete type %qT
vi: giảm con trỏ tới loại không hoàn toàn %qT

en: decrement of read-only member %qD
vi: giảm thành viên chỉ-đọc %qD

en: definition of protocol %qE not found
vi: không thể tìm thấy phần định nghĩa của giao thức %qE

en: deleting LTRANS file %s: %m
vi: đang xóa bỏ tập tin LTRANS %s: %m

en: deleting array %q#E
vi: đang xóa mảng %q#E

en: deleting file %s: %m
vi: đang xóa bỏ tập tin %s: %m

en: deprecated conversion from string constant to %qT
vi: việc chuyển đổi từ chuỗi thành %qT đã lỗi thời

en: derived type declaration
vi: lời khai báo loại có hướng

en: destructor priorities are not supported
vi: các quyền ưu tiên hủy tử là không được hỗ trợ

en: destructors may not have parameters
vi: hủy tử không được có đối số

en: did you mean to use logical not?
vi: ý bạn là dùng not lôgíc?

en: different number of parameters
vi: khác số lượng đối số

en: different number of results
vi: khác số của kết quả

en: different parameter types
vi: khác kiểu tham số

en: different receiver types
vi: khác kiểu nhận được

en: different result types
vi: kiểu kết quả khác biệt

en: different varargs
vi: varargs khác biệt

en: disable pass %s for function %s
vi: tắt chuyển %s cho hàm %s

en: division by zero
vi: chia cho 0

en: do not specify both -march=... and -mcpu=...
vi: không dùng đồng thời hai tùy chọn -march=… và -mcpu=…

en: do_check(): too many args
vi: do_check(): quá nhiều đối số

en: do_simplify(): Too many args for intrinsic
vi: do_simplify(): Quá nhiều đối số cho intrinsic

en: does not support multilib
vi: không hỗ trợ chức năng đa thư viện

en: duplicate %<_Atomic%>
vi: trùng lặp %<_Atomic%>

en: duplicate %<_Thread_local%> or %<__thread%>
vi: trùng %<_Thread_local%> hay %<__thread%>

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 %qD
vi: trùng %qD

en: duplicate %qE
vi: lặp lại %qE

en: duplicate %qs
vi: trùng %qs

en: duplicate case value
vi: trùng giá trị cho case

en: duplicate cv-qualifier
vi: trùng cv-qualifier

en: duplicate declaration for protocol %qE
vi: khai báo bị trùng lắp cho giao thức %qE

en: duplicate initialization of %qD
vi: khởi tạo lặp lại cho %qD

en: duplicate instance variable %q+D
vi: trùng biến minh dụ %q+D

en: duplicate label %qD
vi: trùng nhãn %qD

en: duplicate member %q+D
vi: thành viên trùng lặp %q+D

en: duplicate virt-specifier
vi: trùng virt-specifier

en: dynamic dependency %s not found
vi: không tìm thấy quan hệ phụ thuộc năng động %s

en: element types must be the same
vi: các kiểu phần tử phải đồng nhất

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: embedded %<\0%> in format
vi: %<\0%> được nhúng trong định dạng

en: empty declaration
vi: khai báo trống rỗng

en: empty index range in initializer
vi: bộ khởi tạo chứa phạm vi chỉ mục vẫn trống

en: empty left precision in %s format
vi: độ chính xác trái bị trống rỗng trong định dạng %s

en: empty precision in %s format
vi: độ chính xác bị trống rỗng trong định dạng %s

en: empty range specified
vi: vùng trống rỗng được chỉ ra

en: enable pass %s for function %s
vi: bật chuyển %s cho hàm %s

en: enum conversion in assignment is invalid in C++
vi: chuyển đổi enum trong bộ khởi tạo thì không hợp lệ trong C++

en: enum conversion in initialization is invalid in C++
vi: chuyển đổi enum trong bộ khởi tạo 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_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: error
vi: lỗi

en: error closing %s: %m
vi: lỗi đóng %s: %m

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: eval_intrinsic(): Bad operator
vi: eval_intrinsic(): Sai toán tử

en: exception handling personality mismatch
vi: xử lý ngoại lệ không khớp personality

en: exception of type %<%T%> will be caught
vi: ngoại lệ kiểu %<%T%> sẽ được bắt

en: excess elements in array initializer
vi: gặp yếu tố thừa trong bộ khởi tạo mảng

en: excess elements in scalar initializer
vi: gặp yếu tố thừa trong bộ khởi tạo vô hướng

en: excess elements in struct initializer
vi: gặp yếu tố thừa trong bộ khởi tạo cấu trúc

en: excess elements in union initializer
vi: gặp yếu tố thừa trong bộ khởi tạo hợp

en: excess elements in vector initializer
vi: gặp yếu tố thừa trong bộ khởi tạo véc-tơ

en: exit %d->%d not recorded
vi: thoát khỏi %d->%d không được ghi lại

en: expected %<#pragma omp section%> or %<}%>
vi: cần %<#pragma omp section%> hoặc %<}%>

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 %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier
vi: cần %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> hoặc định danh

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 %<;%> after class definition
vi: cần %<;%> sau định nghĩa lớp

en: expected %<;%> after struct definition
vi: cần %<;%> sau định nghĩa cấu trúc

en: expected %<;%> after union definition
vi: cần %<;%> sau định nghĩa kiểu hỗn hợp

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 %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>
vi: cần %<=%>, %<,%>, %<;%>, %<asm%> hay %<__attribute__%>

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_atomic%>
vi: cần %<__transaction_atomic%>

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%> or %<typename%>
vi: cần %<class%>, hoặc %<typename%>

en: expected %<class%>, %<typename%>, or %<template%>
vi: cần %<class%>, %<typename%>, hoặc %<template%>

en: expected %<data%>
vi: cần %<data%>

en: expected %<decltype%>
vi: cần %<decltype%>

en: expected %<delete%>
vi: cần %<delete%>

en: expected %<extern%>
vi: cần %<extern%>

en: expected %<for%> after %qs
vi: cần %<for%> sau %qs

en: expected %<namespace%>
vi: cần %<namespace%>

en: expected %<new%>
vi: cần %<new%>

en: expected %<omp_priv%> or function-name
vi: cần %<omp_priv%> hoặc tên-hàm

en: expected %<operator%>
vi: cần %<operator%>

en: expected %<point%>
vi: cần %<point%>

en: expected %<return%>
vi: cần %<return%>

en: expected %<static_assert%>
vi: cần %<static_assert%>

en: expected %<target%>
vi: cần %<target%>

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 %qT but argument is of type %qT
vi: cần %qT nhưng đối số là kiểu %qT

en: expected ...
vi: cần …

en: expected an SSA_NAME object
vi: cần một đối tượng SSA_NAME

en: expected binary operator
vi: cần toán tử hai ngôi

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 class-key
vi: cần class-key

en: expected class-name
vi: cần class-name

en: expected declaration
vi: cần khai báo

en: expected declaration or statement
vi: cần khai báo hay câu lệnh

en: expected declaration specifiers
vi: cần các định danh khai báo

en: expected declaration specifiers or %<...%>
vi: cần các định danh khai báo hay %<…%>

en: expected declarator
vi: cần câu khai báo

en: expected else statement
vi: cần điều lệnh else

en: expected end of capture-list
vi: cần kết thúc của capture-list

en: expected end of line
vi: cần kết thúc dòng

en: expected expression
vi: cần biểu thức

en: expected function
vi: cần hàm

en: expected function name
vi: cần tên hàm

en: expected function-name %<(%>
vi: cần tên-hàm %<(%>

en: expected goto expression
vi: cần điều lệnh goto

en: expected id-expression
vi: cần id-expression

en: expected id-expression (arguments)
vi: cần id-expression (các đối số)

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 định danh %<)%>

en: expected identifier or %<*%>
vi: cần một định danh hoặc %<*%>

en: expected initializer
vi: cần bộ khởi tạo

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

en: expected integer expression
vi: cần biểu thức nguyên

en: expected interface or pointer to interface
vi: cần giao diện hay con trỏ đến giao diện

en: expected iteration declaration or initialization
vi: cần khai báo nhắc lại hay sự khởi tạo

en: expected iteration-statement
vi: cần iteration-statement

en: expected jump-statement
vi: cần jump-statement

en: expected labeled-statement
vi: cần labeled-statement

en: expected namespace-name
vi: cần namespace-name

en: expected nested-name-specifier
vi: cần nested-name-specifier

en: expected numeric type
vi: cần kiểu số

en: expected operator
vi: cần toán tử

en: expected pass name
vi: cần tên chuyển qua

en: expected pointer
vi: cần con trỏ

en: expected primary-expression
vi: cần biểu thức cơ bản

en: expected ptr-operator
vi: cần ptr-operator

en: expected selection-statement
vi: cần selection-statement

en: expected specifier-qualifier-list
vi: cần specifier-qualifier-list

en: expected statement
vi: cần biểu thức

en: expected string literal
vi: cần chuỗi văn chương

en: expected string-literal
vi: cần một chuỗi chữ

en: expected suffix identifier
vi: cần định danh hậu tố

en: expected template-argument
vi: cần template-argument

en: expected template-id
vi: cần template-id

en: expected template-id for type
vi: cần template-id cho kiểu

en: expected template-name
vi: cần template-name

en: expected type specifier
vi: cần bộ chỉ định kiểu

en: expected type-name
vi: cần type-name (tên kiểu)

en: expected type-specifier
vi: cần type-specifier

en: expected unqualified-id
vi: cần unqualified-id

en: expression cannot be used as a function
vi: biểu thức không thể được dùng như một hàm

en: expression must be integral
vi: chỉ số phải là số nguyên

en: extend_ref(): Bad tail
vi: extend_ref(): Đuôi sai

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ộ khởi tạo

en: extra elements in scalar initializer
vi: gặp yếu tố thừa trong bộ khởi tạo vô hướng

en: extra qualification not allowed
vi: không cho phép từ hạn định mở rộng

en: extra semicolon
vi: dấu chấm phẩy mở rộ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 get exit status: %m
vi: gặp lỗi khi lấy trạng thái thoát: %m

en: failed to get process times: %m
vi: gặp lỗi khi lấy thời gian tiến trình: %m

en: failure trying to reload:
vi: gặp lỗi nghiêm trọng khi tải lại:

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 %q#D with same name as class
vi: trường %q#D với cùng tên với lớp

en: field %qE declared as a function
vi: trường %qE được khai báo như là một hàm

en: field name not in record or union initializer
vi: không có tên trường trong bộ khởi tạo hợp hoặc mục ghi

en: field precision specifier
vi: chỉ định độ chính xác trường

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: field width specifier
vi: chỉ định độ rộng trường

en: file %qs left but not entered
vi: tập tin còn %qs nhưng không vào được

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: first argument must be []byte
vi: đối số đầu tiên phải là []byte

en: first argument of %q+D should be %<int%>
vi: đối số đầu tiên của %q+D phải là %<int%>

en: fixed-point types not supported for this target
vi: kiểu dấu chấm cố định không được hỗ trợ trên đích này

en: fixed-point types not supported in C++
vi: kiểu dấu chấm cố định không hỗ trợ trong C++

en: floating constant misused
vi: sai sử dụng hằng số dấu chấm động

en: floating constant truncated to zero
vi: hằng dấu chấm động bị cắt cụt thành số không

en: floating literal truncated to zero
vi: văn bản dấu chấm động cắt ngắn thành số không

en: floating-point constant not a valid immediate operand
vi: hằng số dấu chấm động không phải là một giá trị trực tiếp hợp lệ

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 %qD
vi: cho %qD

en: for statement expected
vi: cần câu lệnh for

en: for template declaration %q+D
vi: cho khai báo hàm mẫu %q+D

en: for, while or do statement expected
vi: cần câu lệnh for, while hoặc do

en: format
vi: định dạng

en: format is a wide character string
vi: định dạng là một chuỗi ký tự rộng lớn

en: forward declaration of %q#T
vi: khai báo trước của %q#T

en: found %<%c%s%>
vi: tìm thấy %<%c%s%>

en: found %<-%E%> instead of %<+%E%> in protocol(s)
vi: tìm thấy %<-%E%> thay vì %<+%E%> trong giao thức

en: fr30_print_operand: invalid %%F code
vi: fr30_print_operand: sai đặt mã %%F

en: fr30_print_operand: invalid %%x code
vi: fr30_print_operand: sai đặt 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: free_expr0(): Bad expr type
vi: free_expr0(): Kiểu biểu thức sai

en: frv_print_operand: unknown code
vi: frv_print_operand: gặp mã không rõ

en: function %qD declared %<virtual%> inside a union
vi: hàm %qD được khai báo %<virtual%> trong một union

en: function %qD is initialized like a variable
vi: hàm %qD được khởi tạo giống như là một biến

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 can be overwritten at link time
vi: thân hàm có thể bị ghi đè lúc liên kết

en: function body not available
vi: thân hàm không sẵn sàng

en: function call has aggregate value
vi: cú gọi hàm có giá trị tập hợp

en: function declared %<noreturn%> has a %<return%> statement
vi: hàm đã khai báo %<noreturn%> có một câu lệnh %<return%>

en: function definition declared %<auto%>
vi: định nghĩa hàm được khai báo là %<auto%>

en: function definition declared %<register%>
vi: định nghĩa hàm được khai báo là %<register%>

en: function definition declared %<typedef%>
vi: định nghĩa hàm được khai báo là %<typedef%>

en: function definition declared %qs
vi: định nghĩa hàm được khai báo là %qs

en: function definition does not declare parameters
vi: định nghĩa hàm không khai báo đối số

en: function definition has qualified void return type
vi: định nghĩa hàm có kiểu trả về là void

en: function does not return string type
vi: hàm không trả về kiểu chuỗi

en: function may return address of local variable
vi: hàm có thể trả về địa chỉ của biến cục bộ

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 khai báo 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 return type cannot be function
vi: kiểu trả về hàm không thể là hàm

en: function returning a function
vi: hàm trả về hàm

en: function returning an array
vi: hàm trả về một mảng

en: function returns address of label
vi: hàm trả về địa chỉ của biến cục bộ

en: function returns address of local variable
vi: hàm trả về địa chỉ của biến cục bộ

en: function returns an aggregate
vi: hàm trả về một tập hợp

en: function symbol is not function
vi: ký hiệu hàm không phải là một hàm

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: gfc_add_interface(): Bad interface type
vi: gfc_add_interface(): Kiểu giao diện sai

en: gfc_arith_divide(): Bad basic type
vi: gfc_arith_divide(): Kiểu cơ bản sai

en: gfc_arith_error(): Bad error code
vi: gfc_arith_error(): Mã câu lệnh sai

en: gfc_arith_minus(): Bad basic type
vi: gfc_arith_minus(): Kiểu cơ bản sai

en: gfc_arith_plus(): Bad basic type
vi: gfc_arith_plus(): Kiểu cơ bản sai

en: gfc_arith_times(): Bad basic type
vi: gfc_arith_times(): Kiểu cơ bản sai

en: gfc_arith_uminus(): Bad basic type
vi: gfc_arith_uminus(): Kiểu cơ bản sai

en: gfc_compare_expr(): Bad basic type
vi: gfc_compare_expr(): Kiểu cơ bản sai

en: gfc_copy_expr(): Bad expr node
vi: gfc_copy_expr(): nút biểu thức sai

en: gfc_get_constant_expr(): locus %<where%> cannot be NULL
vi: gfc_get_constant_expr(): vị trí %<where%> không thể là NULL

en: gfc_is_constant_expr(): Unknown expression type
vi: gfc_is_constant_expr(): không hiểu kiểu biểu thức

en: gfc_match(): Bad match code %c
vi: gfc__match(): Mã khớp sai %c

en: gfc_range_check(): Bad type
vi: gfc_range_check(): Kiểu sai

en: gfc_resolve_blocks(): Bad block type
vi: gfc_resolve_blocks(): Kiểu khối sai

en: gfc_resolve_code(): Bad statement code
vi: gfc_resolve_code(): Mã câu lệnh sai

en: gfc_resolve_code(): No expression on DO WHILE
vi: gfc_resolve_code(): Không có biểu thức trên DO WHILE

en: gfc_resolve_expr(): Bad expression type
vi: gfc_resolve_expr(): sai kiểu biểu thức

en: gfc_simplify_abs(): Bad type
vi: gfc_simplify_abs(): Kiểu sai

en: gfc_simplify_dcmplx(): Bad type (x)
vi: gfc_simplify_dcmplx(): Kiểu sai (x)

en: gfc_simplify_dcmplx(): Bad type (y)
vi: gfc_simplify_dcmplx(): Kiểu sai (y)

en: gfc_simplify_dim(): Bad type
vi: gfc_simplify_dim(): Kiểu sai

en: gfc_simplify_floor(): Bad kind
vi: gfc_simplify_floor(): Kiểu sai

en: gfc_simplify_log: bad type
vi: gfc_simplify_log: Kiểu sai

en: gfc_trans_code(): Bad statement code
vi: gfc_trans_code(): Mã câu lệnh sai

en: gfc_trans_select(): Bad type for case expr.
vi: gfc_trans_select(): Kiểu cho biểu thức case sai.

en: gfc_validate_kind(): Got bad kind
vi: gfc_validate_kind(): Nhận loại sai

en: gfc_validate_kind(): Got bad type
vi: gfc_validate_kind(): Nhận kiểu sai

en: gfc_variable_attr(): Expression isn't a variable
vi: gfc_variable_attr(): Biểu thức không phải là một biến

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: global register variable has initial value
vi: biến thanh ghi toàn cục có giá trị khởi tạo

en: got %d template parameters for %q#D
vi: nhận được %d đối số mẫu cho %q#D

en: got %d template parameters for %q#T
vi: nhận được %d đối số mẫu cho %q#T

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: iWMMXt and NEON are incompatible
vi: iWMMXt và NEON là xung khác lẫn nhau

en: iWMMXt unsupported under Thumb mode
vi: iWMMXt không được hỗ trợ dưới chế độ Thumb

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
vi: toán hạng không hợp lệ

en: illegal operand address (1)
vi: địa chỉ toán hạng không hợp lệ (1)

en: illegal operand address (2)
vi: địa chỉ toán hạng không hợp lệ (2)

en: illegal operand address (3)
vi: địa chỉ toán hạng không hợp lệ (3)

en: illegal operand address (4)
vi: địa chỉ toán hạng không hợp lệ (4)

en: illegal operand detected
vi: phát hiện toán hạng cấm

en: implicit declaration of function %qE
vi: khai báo ngầm của hàm %qE

en: implicit templates may not be %<virtual%>
vi: các mẫu ngầm không nên là %<virtual%>

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 declaration %q+D
vi: trong khai báo %q+D

en: in definition of macro %qs
vi: trong phần định nghĩa macro %qs

en: in expansion of macro %qs
vi: trong phần mở rộng macro %qs

en: in gfc_simplify_acos(): Bad type
vi: in gfc_simplify_acos(): Kiểu sai

en: in gfc_simplify_acosh(): Bad type
vi: in gfc_simplify_acosh(): Kiểu sai

en: in gfc_simplify_asin(): Bad type
vi: in gfc_simplify_asin(): Kiểu sai

en: in gfc_simplify_asinh(): Bad type
vi: in gfc_simplify_asinh(): Kiểu sai

en: in gfc_simplify_atan(): Bad type
vi: in gfc_simplify_atan(): Kiểu sai

en: in gfc_simplify_atanh(): Bad type
vi: in gfc_simplify_atanh(): Kiểu sai

en: in gfc_simplify_cos(): Bad type
vi: in gfc_simplify_cos(): Kiểu sai

en: in gfc_simplify_exp(): Bad type
vi: in gfc_simplify_exp(): Kiểu sai

en: in gfc_simplify_sin(): Bad type
vi: in gfc_simplify_sin(): Kiểu sai

en: in passing argument %P of %qD
vi: trong đối số chuyển qua %P của %qD

en: in the definition of %q#T
vi: trong định nghĩa của %q#T

en: incompatible floating point / vector register operand for '%%%c'
vi: toán hạn dấu chấm động / thanh ghi véctơ không tương thích cho “%%%c”

en: incompatible type for argument %d of %qE
vi: kiểu không tương thích cho đối số %d của %qE

en: incompatible type for map index
vi: kiểu không tương thích cho chỉ mục ánh xạ

en: incompatible type for method %s%s%s
vi: kiểu không tương thích cho phương thức %s%s%s

en: incompatible type for method %s%s%s (%s)
vi: kiểu không tương thích cho phương thức %s%s%s (%s)

en: incompatible type for receiver
vi: không tương thích kiểu đối với bộ nhận

en: incompatible types in assignment of %qT to %qT
vi: phép gán %qT cho %qT không tương thích kiểu

en: incompatible types in send
vi: không tương thích kiểu trong bộ gửi

en: incorrect comparison mode
vi: chế độ so sánh không đúng

en: incorrect format in scaling, using 1/1
vi: định dạng biến đổi không đúng, nên dùng 1/1

en: incorrect insn:
vi: lệnh không đúng:

en: incorrect rounding operand
vi: lệnh không đúng:

en: increment of enumeration value is invalid in C++
vi: phép gia tăng giá trị kiểu liệt kê là không hợp lệ trong C++

en: increment of function %qD
vi: số gia của hàm %qD

en: increment of pointer to an incomplete type %qT
vi: tăng con trỏ tới loại không hoàn toàn %qT

en: increment of read-only member %qD
vi: gia số cho thành viên chỉ-đọc %qD

en: index value is out of bound
vi: giá trị chỉ mục nằm ngoài phạm vi cho phép

en: init function found in object %s
vi: hàm init được tìm trong đối tượng %s

en: init_arglist(): too many arguments
vi: init_arglist(): quá nhiều đối số

en: initialization of a flexible array member
vi: đã khởi tạo 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ị khởi tạo trong một ngữ cảnh lồng nhau

en: initialized field overwritten
vi: trường đã khởi tạo bị ghi đè

en: initialized field with side-effects overwritten
vi: trường đã khởi tạo với hiệu ứng khác bị ghi đè

en: initializer element is not a constant expression
vi: yếu tố khởi tạo 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ố khởi tạo không tính được vào lúc nạp

en: initializer element is not constant
vi: yếu tố khởi tạo không phải hằng số

en: initializer ends prematurely
vi: bộ khởi tạo kết thúc bất ngờ

en: initializer for %q#D is invalid
vi: bộ khởi tạo cho %q#D không hợp lệ

en: initializer provided for function
vi: bộ khởi tạo được cung cấp cho hàm

en: inline function %q+D declared but never defined
vi: hàm chung dòng %q+D được khai báo nhưng chưa bao giờ được định nghĩa

en: inline function %q+D declared weak
vi: hàm chung dòng %q+D được khai báo yếu

en: inline function %qD used but never defined
vi: hàm chung dòng %qD được dùng nhưng chưa bao giờ được định nghĩa

en: inlined_to pointer is wrong
vi: inlined_to con trỏ là sai

en: inlined_to pointer refers to itself
vi: con trỏ inlined_to chỉ đến chính nó

en: input file %qs is the same as output file
vi: tập tin đầu vào %qs là cùng với tập tin đầu ra

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: integer division by zero
vi: số nguyên chia cho không

en: integer overflow in array size
vi: tràn số nguyên trong kích thước mảng

en: integral expression %qE is not constant
vi: biểu thức nguyên %qE không là hằng

en: internal compiler error
vi: lỗi biên dịch nội bộ

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 consistency failure
vi: tính nhất quán nội tại gặp lỗi nghiêm trọng

en: internal error: bad register: %d
vi: lỗi nội bộ : thanh ghi sai: %d

en: internal unit in WRITE
vi: đơn vị bên trong trong GHI

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 value
vi: giá trị %%H sai

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 value
vi: giá trị %%L sai

en: invalid %%M value
vi: giá trị %%M sai

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 %%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 %%d value
vi: giá trị %%d sai

en: invalid %%e value
vi: giá trị %%e sai

en: invalid %%f operand
vi: toán hạng %%f sai

en: invalid %%f value
vi: giá trị %%f sai

en: invalid %%h value
vi: giá trị %%h sai

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 %%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 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/%%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” không hợp lệ:

en: invalid IACC argument
vi: đối số IACC không hợp lệ

en: invalid UNSPEC as operand
vi: đặt sai UNSPEC như là toán hạng

en: invalid UNSPEC as operand: %d
vi: UNSPEC không hợp lệ như là toán hạng: %d

en: invalid abstract type for %q+D
vi: kiểu trừu tượng cho %q+D không hợp lệ

en: invalid address
vi: địa chỉ sai

en: invalid addressing mode
vi: sai đặt chế độ đặt địa chỉ

en: invalid argument of %qE attribute
vi: đối số của thuộc tính %qE không hợp lệ

en: invalid argument of %qs attribute
vi: đối số của thuộc tính %qs không hợp lệ

en: invalid argument of SQRT at %L
vi: đối số của SQRT tại %L không hợp lệ

en: invalid argument to %qD
vi: đối số không hợp lệ cho %qD

en: invalid argument to gimple call
vi: đối số không hợp lệ cho cú gọi hàm gimple

en: invalid arguments
vi: các đối số không hợp lệ

en: invalid array assignment
vi: gán mảng không hợp lệ

en: invalid base-class specification
vi: đặc tả lớp-cơ-sở không hợp lệ

en: invalid case label in switch statement
vi: nhãn case không hợp lệ trong câu lệnh switch

en: invalid cast to abstract class type %qT
vi: áp đổi kiểu trừu tượng cho kiểu lớp %qT không hợp lệ

en: invalid const_double operand
vi: toán hạng const_double sai

en: invalid constant
vi: hằng không hợp lệ

en: invalid constant - try using an output modifier
vi: hằng không hợp lệ - hãy thử dùng bổ nghĩa kết xuất

en: invalid constant for output modifier '%c'
vi: hằng không hợp lệ cho bổ nghĩa kết xuất “%c”

en: invalid constant in %<#pragma %s%>
vi: hằng không hợp lệ trong %<#pragma %s%>

en: invalid constant in %<#pragma pack%> - ignored
vi: hằng không hợp lệ trong %<#pragma pack%> - nên bỏ qua

en: invalid constant vector for output modifier '%c'
vi: véc-tơ hằng không hợp lệ cho bổ nghĩa kết xuất “%c”

en: invalid constraints for operand
vi: sai đặt 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 declaration of %<%T::%E%>
vi: khai báo không hợp lệ của %<%T::%E%>

en: invalid declarator
vi: bộ khai báo không hợp lệ

en: invalid definition of qualified type %qT
vi: định nghĩa không hợp lệ của kiểu hạn định %qT

en: invalid depend kind
vi: kiểu phụ thuộc không hợp lệ

en: invalid dist_schedule kind
vi: kiểu dist_schedule không hợp lệ

en: invalid explicit specialization
vi: đặc tả rõ ràng không hợp lệ

en: invalid expression - try using an output modifier
vi: biểu thức không hợp lệ - hãy thử dùng bổ nghĩa kết xuất

en: invalid expression as operand
vi: biểu thức như là toán hạng không hợp lệ

en: invalid expression for output modifier '%c'
vi: biểu thức không hợp lệ cho bộ sửa đầu ra “%c”

en: invalid form of %<#pragma omp atomic%>
vi: sai dạng thức của %<#pragma omp atomic%>

en: invalid format of %s
vi: định dạng của %s không hợp lệ

en: invalid function in gimple call
vi: hàm không hợp lệ trong cú gọi gimple

en: invalid increment expression
vi: biểu thức gia không hợp lệ

en: invalid initializer
vi: bộ khởi tạo sai

en: invalid initializer clause
vi: mệnh đề khởi tạo không hợp lệ

en: invalid initializer for %q#D
vi: bộ khởi tạo cho %q#D không hợp lệ

en: invalid insn:
vi: lệnh sai:

en: invalid line in the resolution file
vi: gặp dòng sai trong tập tin phân giải

en: invalid linkage-specification
vi: đặc tả linkage không hợp lệ

en: invalid map kind
vi: kiểu ánh xạ không hợp lệ

en: invalid mask
vi: bộ lọc sai

en: invalid operand
vi: toán hạng không hợp lệ

en: invalid operand address
vi: địa chỉ toán hạng không hợp lệ

en: invalid operand code '%c'
vi: mã toán hạng sai “%c”

en: invalid operand for '%%%c'
vi: toán hạng không hợp lệ đối với “%%%c”

en: invalid operand for 'A' modifier
vi: sai đặt toán hạng cho sự sửa đổi “A”

en: invalid operand for 'D' modifier
vi: sai đặt toán hạng cho sự sửa đổi “D”

en: invalid operand for 'H' modifier
vi: sai đặt toán hạng cho sự sửa đổi “H”

en: invalid operand for 'O' modifier
vi: sai đặt toán hạng cho sự sửa đổi “O”

en: invalid operand for 'T' modifier
vi: sai đặt toán hạng cho sự sửa đổi “T”

en: invalid operand for 'b' modifier
vi: sai đặt toán hạng cho sự sửa đổi “b”

en: invalid operand for 'e' modifier
vi: sai đặt toán hạng cho sự sửa đổi “e”

en: invalid operand for 'm' modifier
vi: sai đặt toán hạng cho sự sửa đổi “m”

en: invalid operand for 'o' modifier
vi: sai đặt toán hạng cho sự sửa đổi “o”

en: invalid operand for 'p' modifier
vi: sai đặt toán hạng cho sự sửa đổi “p”

en: invalid operand for 'z' modifier
vi: sai đặt toán hạng cho sự sửa đổi “z”

en: invalid operand for code '%c'
vi: sai đặt toán hạng cho mã “%c”

en: invalid operand in unary operation
vi: toán hạng không hợp lệ trong phép toán một ngôi

en: invalid operand modifier letter
vi: sai đặt chữ sửa đổi toán hạng

en: invalid operand output code
vi: sai đặt mã kết xuất toán hạng

en: invalid operand prefix
vi: tiền tố toán hạng không hợp lệ

en: invalid operand prefix '%%%c'
vi: tiền tố toán hạng không hợp lệ “%%%c”

en: invalid operand size for operand code 'O'
vi: sai kích cỡ toán hạng cho mã toán hạng “O”

en: invalid operand size for operand code 'z'
vi: sai kích cỡ toán hạng cho mã toán hạng “z”

en: invalid operand to %%H/%%L code
vi: sai đặt toán hạng tới mã %%H/%%L

en: invalid operand to %%M code
vi: toán hạng không hợp lệ cho mã %%M

en: invalid operand to %%N code
vi: sai đặt toán hạng tới mã %%N

en: invalid operand to %%O code
vi: toán hạng không hợp lệ cho mã %%O

en: invalid operand to %%R
vi: sai đặt toán hạng tới %%R

en: invalid operand to %%R code
vi: sai đặt toán hạng tới mã %%R

en: invalid operand to %%S
vi: sai đặt toán hạng tới %%S

en: invalid operand to %%T/%%B code
vi: sai đặt toán hạng tới mã %%T/%%B

en: invalid operand to %%U code
vi: sai đặt toán hạng tới mã %%U

en: invalid operand to %%V code
vi: toán hạng không hợp lệ cho mã %%V

en: invalid operand to %%Z code
vi: toán hạng không hợp lệ cho mã %%Z

en: invalid operand to %%p code
vi: sai đặt toán hạng tới mã %%p

en: invalid operand to %%s code
vi: sai đặt toán hạng tới mã %%s

en: invalid operand to %%z code
vi: toán hạng không hợp lệ cho mã %%z

en: invalid operands in binary operation
vi: toán hạng không hợp lệ trong phép toán nhị phân

en: invalid operands in ternary operation
vi: toán hạng không hợp lệ trong phép toán tam nguyên

en: invalid operation
vi: toán hạng không hợp lệ

en: invalid operation (%s)
vi: toán tử không hợp lệ (%s)

en: invalid operation on %<__fpreg%>
vi: thao tác sai %<__fpreg%>

en: invalid operator for %<#pragma omp atomic%>
vi: thao tác không hợp lệ cho %<#pragma omp atomic%>

en: invalid parameter type %qT
vi: kiểu đối số không hợp lệ %qT

en: invalid pointer mode %qs
vi: chế độ con trỏ %qs không hợp lệ

en: invalid pointer to bit-field %qD
vi: con trỏ cho trường bít %qD không hợp lệ

en: invalid proc_bind kind
vi: kiểu proc_bind không hợp lệ

en: invalid receiver type %qs
vi: kiểu bộ nhận không hợp lệ %qs

en: invalid reduction-identifier
vi: bộ khởi tạo sai

en: invalid register name for %q+D
vi: tên thanh ghi cho %q+D không hợp lệ

en: invalid resolution in the resolution file
vi: phân giải không hợp lệ trong tập tin phân giải

en: invalid schedule kind
vi: kiểu lịch biểu không hợp lệ

en: invalid setter, it must have one argument
vi: bộ đặt không hợp lệ, nó phải có một đối số

en: invalid shift operand
vi: sai đặt toán hạng dời

en: invalid template declaration of %qD
vi: phần khai báo mẫu của %qD không hợp lệ

en: invalid template-id
vi: template-id không hợp lệ

en: invalid type %qT declared %<friend%>
vi: kiểu không hợp lệ %qT được khai báo %<friend%>

en: invalid type argument (have %qT)
vi: kiểu tham số không hợp lệ (có %qT)

en: invalid type argument of %<->%> (have %qT)
vi: kiểu tham số không hợp lệ của %<->%> (có %qT)

en: invalid type argument of %<->*%> (have %qT)
vi: kiểu tham số không hợp lệ của %<->*%> (có %qT)

en: invalid type for instance variable
vi: kiểu không hợp lệ cho biến instance (minh dụ)

en: invalid type for property
vi: kiểu không hợp lệ cho thuộc tính

en: invalid types in nop conversion
vi: các kiểu không hợp lệ trong chuyển đổi nop

en: invalid use of %%d, %%x, or %%X
vi: dùng không đúng %%d, %%x hoặc %%X

en: invalid use of %<::%>
vi: dùng %<::%> không hợp lệ

en: invalid use of %<auto%> in default template argument
vi: dùng %<auto%> không hợp lệ trong đối số mẫu mặc định

en: invalid use of %<auto%> in exception-specification
vi: dùng %<auto%> không hợp lệ trong đặc tả ngoại lệ

en: invalid use of %<auto%> in template argument
vi: dùng %<auto%> không hợp lệ trong đối số mẫu

en: invalid use of %<restrict%>
vi: dùng %<restrict%> không hợp lệ

en: invalid use of %qD
vi: dùng %qD không hợp lệ

en: invalid use of %qT
vi: cách dùng không hợp lệ %qT

en: invalid use of '%%%c'
vi: sai sử dụng “%%%c”

en: invalid use of asm flag output
vi: sử dụng kết xuất cờ asm sai

en: invalid use of constructor as a template
vi: dùng cấu tử như là một mẫu là không hợp lệ

en: invalid use of non-lvalue array
vi: sai sử dụng mảng không phải lvalue

en: invalid use of qualified-name %<%D::%D%>
vi: cách dùng không đúng tên từ hạn định %<%D::%D%>

en: invalid use of qualified-name %<%T::%D%>
vi: cách dùng không đúng tên từ hạn định %<%T::%D%>

en: invalid use of qualified-name %<::%D%>
vi: cách dùng không đúng tên từ hạn định %<::%D%>

en: invalid use of type
vi: sử dụng kiểu sai

en: invalid use of type %<void%> in parameter declaration
vi: không thể dùng %<::%> trong khai báo đối số

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: invalid zero extract
vi: trích số không không hợp lệ

en: item in READ
vi: mục tin trong READ

en: iterator variable
vi: biến iterator

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: junk at end of %<#pragma %s%>
vi: có rác ở cuối %<#pragma %s%>

en: junk at end of %<#pragma GCC visibility%>
vi: có rác ở cuối %<#pragma GCC visibility%>

en: junk at end of %<#pragma align%>
vi: có rác ở cuối %<#pragma align%>

en: junk at end of %<#pragma fini%>
vi: có rác ở cuối %<#pragma fini%>

en: junk at end of %<#pragma init%>
vi: có rác ở cuối %<#pragma init%>

en: junk at end of %<#pragma pack%>
vi: có rác ở cuối %<#pragma pack%>

en: junk at end of %<#pragma redefine_extname%>
vi: có rác ở cuối của %<#pragma redefine_extname%>

en: junk at end of %<#pragma reset_options%>
vi: có rác ở cuối %<#pragma reset_options%>

en: junk at end of %<#pragma weak%>
vi: có rác ở cuối %<#pragma weak%>

en: label %q+D declared but not defined
vi: nhãn %q+D được khai báo nhưng chưa được định nghĩa

en: label %q+D defined but not used
vi: nhãn %q+D được định nghĩa nhưng chưa được dùng

en: label %q+D used but not defined
vi: nhãn %q+D được dùng nhưng chưa định nghĩa

en: label %qD defined here
vi: nhãn %qD được định nghĩa ở đây

en: language %s not recognized
vi: không chấp nhận ngôn ngữ %s

en: last argument must be an immediate
vi: đối số cuối phải là giá trị trực tiếp

en: ld returned %d exit status
vi: ld trả về trạng thái thoát %d

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: left shift of negative value
vi: dịch trái của một giá trị âm

en: len larger than cap
vi: len lớn hơn cap

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: letter %c was found & insn was not CONST_INT
vi: chữ %c được tìm thấy & insn không phải là CONST_INT

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: linear step expression must be integral
vi: biểu thức bước thẳng phải là số nguyên

en: lo_sum not of register
vi: lo_sum không phải thanh ghi

en: local symbols must be defined
vi: ký hiệu cục bộ phải được định nghĩa

en: lseek failed while reading export data
vi: lseek gặp lỗi khi xuất dữ liệu

en: lvalue required as decrement operand
vi: lvalue được yêu cầu như là toán hạng giảm

en: lvalue required as increment operand
vi: lvalue được yêu cầu như là toán hạng gia

en: macro name missing after %qs
vi: thiếu tên macro sau %qs

en: malformed %<#pragma %s%>, ignored
vi: %<#pragma %s%> sai dạng, bị bỏ qua

en: malformed %<#pragma %s%>, ignoring
vi: %<#pragma %s%> sai dạng, bị bỏ qua

en: malformed %<#pragma align%>
vi: %<#pragma align%> sai định dạng

en: malformed %<#pragma align%>, ignoring
vi: %<#pragma align%> sai dạng, bị bỏ qua

en: malformed %<#pragma fini%>
vi: %<#pragma fini%> sai dạng

en: malformed %<#pragma fini%>, ignoring
vi: %<#pragma fini%> sai dạng, bị bỏ qua

en: malformed %<#pragma init%>
vi: %<#pragma init%> sai dạng

en: malformed %<#pragma init%>, ignoring
vi: %<#pragma init%> sai dạng, bị bỏ qua

en: malformed %<#pragma message%>, ignored
vi: %<#pragma message%> sai dạng, bị bỏ qua

en: malformed %<#pragma pack%> - ignored
vi: %<#pragma pack%> sai dạng, bị bỏ qua

en: malformed %<#pragma pack(pop[, id])%> - ignored
vi: %<#pragma pack(pop[, id])%> sai dạng - nên bỏ qua

en: malformed %<#pragma pack(push[, id][, <n>])%> - ignored
vi: %<#pragma pack(push[, id][, <n>])%> sai dạng - nên bỏ qua

en: malformed ptx file
vi: tập tin ptx có dạng sai

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: match_attr_spec(): Bad attribute
vi: match_attr_spec(): Thuộc tính sai

en: may not use both -EB and -EL
vi: không cho phép sử dụng đồng thời hai tùy 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 tùy chọn -m32 và -m64

en: memory allocation failed while reading export data
vi: gặp lỗi phân bổ bộ nhớ khi đang đọc dữ liệu xuất

en: method %s%s%s is marked go:nointerface
vi: phương thức %s%s%s được đánh dấu là go:nointerface

en: method %s%s%s requires a pointer receiver
vi: phương thức %s%s%s yêu cầu bộ nhận con trỏ

en: mismatched declarations during linktime optimization
vi: khai báo không khớp khi đang tối ưu hóa lúc liên kết

en: mismatching parens
vi: các cha mẹ không khớp

en: missing %<(%> after %<#pragma GCC visibility push%> - ignored
vi: thiếu %<(%> sau %<#pragma GCC visibility push%> - nên bỏ qua

en: missing %<(%> after %<#pragma pack%> - ignored
vi: thiếu %<(%> sau %<#pragma pack%> - nên bỏ qua

en: missing argument to %qs
vi: thiếu đối số đối cho %qs

en: missing barrier after block %i
vi: thiếu chắn sau khối %i

en: missing braces around initializer
vi: thiếu ngoặc móc chung quanh bộ khởi tạo

en: missing close paren
vi: thiếu paren đóng

en: missing definition
vi: thiếu định nghĩa

en: missing device or architecture after %qs
vi: thiếu thiết bị hay kiến trúc sau %qs

en: missing edge %i->%i
vi: thiếu edge %i->%i

en: missing filename after %qs
vi: thiếu tên tập tin sau %qs

en: missing increment expression
vi: thiếu biểu thức gia số

en: missing initializer for member %qD
vi: thiếu bộ khởi tạo cho thành viên %qD

en: missing makefile target after %qs
vi: thiếu đích makefile sau %qs

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 open paren
vi: thiếu paren mở

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: missing terminating %c character
vi: thiếu ký tự “%c” chấm dứt

en: more than %d operands in %<asm%>
vi: nhiều hơn %d toán hạng trong %<asm%>

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 %qs is invalid
vi: sự lựa chọn đa thư viện %qs %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: multiple definition of %q#T
vi: nhiều định nghĩa cho %q#T

en: multiple inline callers
vi: nhiều bộ gọi chung dòng

en: multiple ref-qualifiers
vi: đa ref-qualifiers

en: need %<typename%> before %<%T::%E%> because %qT is a dependent scope
vi: cần %<typename%> trước %<%T::%E%> bởi vì %qT có phạm vi phụ thuộc

en: need explicit conversion
vi: cần chuyển đổi rõ ràng

en: negative insn length
vi: chiều dài insn âm

en: negative shift count
vi: số lượng dịch âm

en: negative width in bit-field %q+D
vi: độ rộng bị âm trong trường bít %q+D

en: nested assembly dialect alternatives
vi: các sự xen kẽ phương ngôn assembly lồng nhau

en: nested redefinition of %<struct %E%>
vi: định nghĩa lại bị lồng của %<struct %E%>

en: nested redefinition of %<union %E%>
vi: định nghĩa lại bị lồng của %<union %E%>

en: next member %q#D declared here
vi: thành viên kế %q#D đã khai báo ở đây

en: no %<%c%E%> method found
vi: không tìm thấy phương thức %<%c%E%>

en: no %qs getter found
vi: không tìm thấy getter %qs

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 class name specified with %qs
vi: không chỉ định tên lớp với %qs

en: no closing %<]%> for %<%%[%> format
vi: chưa đóng %<]%> cho định dạng %<%%[%>

en: no data type for mode %qs
vi: không có kiểu dữ liệu cho chế độ %qs

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 match for
vi: không khớp cho

en: no match for call to %<(%T) (%A)%>
vi: cú gọi không khớp tới %<(%T) (%A)%>

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 previous declaration for %qD
vi: chưa có khai báo trước đây cho %qD

en: no previous prototype for %qD
vi: chưa có khai báo nguyên mẫu trước đây cho %qD

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: no return statement in function returning non-void
vi: %<return%> (trả lại) không có giá trị, trong hàm trả lại non-void (không rỗng)

en: no type named %q#T in %q#T
vi: không có kiểu có tên %q#T trong %q#T

en: node has unknown type
vi: nút có kiểu không hiểu

en: non-AAPCS derived PCS variant
vi: non-AAPCS dẫn suất biến thể PCS

en: non-NULL pointer initialization at %C
vi: Khởi tạo con trỏ khác KHÔNG tại %C

en: non-scalar type
vi: kiểu không-scalar

en: non-static data member declared with placeholder %qT
vi: thành viên dữ liệu không-tĩnh được khai báo giữ chỗ %qT

en: non-static initialization of a flexible array member
vi: một bộ phận mảng dẻo bị khởi tạo một cách không phải tĩnh

en: nonconstant array index in initializer
vi: bộ khởi tạo chứa một chỉ mục mảng không phải hằng số

en: normalization cannot co-exist with scaling
vi: thường hóa không thể cùng tồn tại với biến đổi

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: not enough arguments to return
vi: không có đủ đối số để trả về

en: not enough type information
vi: không đủ thông tin kiểu

en: note
vi: ghi chú

en: note:
vi: ghi chú:

en: null pointer
vi: con trỏ rỗng

en: number must be 0 or 1
vi: số phải là 0 hay 1

en: number of arguments doesn%'t match prototype
vi: số lượng đối số không giống với nó khi khai báo mẫu hàm

en: number of components of vector not a power of two
vi: số lượng thành phần của véctơ không thể là mũ của hai

en: number of results does not match number of values
vi: số của kết quả không khớp với số của giá trị

en: objc++-cpp-output is deprecated; please use objective-c++-cpp-output instead
vi: objc++-cpp-output đã lạc hậu; vui lòng dùng objective-c++-cpp-output để thay thế

en: objc-cpp-output is deprecated; please use objective-c-cpp-output instead
vi: objc-cpp-output đã lạc hậu; vui lòng dùng objective-c-cpp-output để thay thế

en: object is not a method
vi: đối tượng không phải là phương thức

en: obsolete Maverick format code '%c'
vi: định dạng mã Maverick đã cũ “%c”

en: old declaration %q#D
vi: khai báo cũ %q#D

en: old-style function definition
vi: định nghĩa hàm theo cách cũ

en: only 0.0 can be loaded as an immediate
vi: 0.0 chỉ nạp được như là một số trực tiếp

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 %qs: %s
vi: mở tập tin kết xuất %qs: %s

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 '%c'
vi: toán hạng không phải là một mã điều kiện, mã toán hạng không hợp lệ “%c”

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: operand types are %qT and %qT
vi: các kiểu toán hạng là %qT và %qT

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: optimization level attribute mismatch
vi: thuộc tính mức tối ưu không khớp

en: option %qs is valid for %s but not for %s
vi: tùy chọn dòng lệnh %qs thì hợp lệ cho %s nhưng lại không với %s

en: optional argument
vi: đối số tùy chọn

en: ordered argument needs positive constant integer expression
vi: cần biểu thức nguyên

en: original %<default%> is here
vi: %<default%> nguyên gốc ở đây

en: original definition appeared here
vi: định nghĩa nguyên bản xuất hiện ở đây

en: originally defined here
vi: định nghĩa lần đầu ở đâ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: originally specified here
vi: nguyên gốc được chỉ định ở đây

en: orphaned %qs construct
vi: cấu tử %qs mồ côi

en: outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>
vi: vòng ngoài hơn %<__transaction_cancel%> không nằm trong vòng ngoài hơn %<__transaction_atomic%>

en: output filename specified twice
vi: tên tập tin kết xuất được chỉ ra hai lần

en: overflow in array dimension
vi: tràn kích thước mảng

en: overflow in constant expression
vi: tràn trong biểu thức hằng

en: overflow in enumeration values
vi: tràn giá trị liệt kê

en: padding struct to align %q+D
vi: chèn thêm cấu trúc cho vừa %q+D

en: parameter %q+D declared %<_Noreturn%>
vi: đối số %q+D được khai báo %<_Noreturn%>

en: parameter %q+D declared %<inline%>
vi: đối số %q+D được khai báo %<inline%>

en: parameter %qD declared with void type
vi: đối số %qD được khai báo với kiểu void

en: parameter %qD has incomplete type
vi: đối số %qD có kiểu chưa đầy đủ

en: parameter %qD is initialized
vi: tham số %qD được khởi tạo

en: parameter %qD set but not used
vi: đối số %qD đặt nhưng chưa được dùng

en: parametrized derived type argument
vi: đối số kiểu được dẫn suất tham số hóa

en: passing too large argument on stack
vi: chuyển đối số quá lớn cho ngăn xếp

en: pointer argument
vi: đối số con trỏ

en: pointer assignment
vi: sự gán hàm trỏ

en: pointer or allocatable result
vi: con trỏ hoặc kết quả cấp phát được

en: pointer to a function used in arithmetic
vi: con trỏ đến hàm được dùng trong số học

en: pointer to a function used in subtraction
vi: con trỏ đến hàm được dùng trong phép trừ

en: polymorphic argument
vi: đối số polymorphic

en: post-increment address is not a register
vi: địa chỉ hậu gia không phải là một thanh ghi

en: postfix %qD should return %qT
vi: hậu tố %qD cần trả về %qT

en: potential null pointer dereference
vi: đích không phải là một hàm trỏ hoặc một tham chiếu

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: prefix %qD should return %qT
vi: tiền tố %qD cần trả về %qT

en: prev_bb of %d should be %d, not %d
vi: prev_bb của %d phải là %d, chứ không phải %d

en: previous %<#pragma omp declare reduction%>
vi: %<#pragma omp declare reduction%> trước

en: previous declaration
vi: khai báo trước

en: previous declaration %q#D
vi: khai báo trước đây %q#D

en: previous declaration as %q#D
vi: khai báo trước đây là %q#D

en: previous declaration here
vi: khai báo trước ở đây

en: previous declaration of %<%c%E%>
vi: khai báo trước đây của %<%c%E%>

en: previous declaration of %<%c%E%> as %<@optional%>
vi: khai báo trước đây của %<%c%E%> như là %<@optional%>

en: previous declaration of %<%c%E%> as %<@required%>
vi: khai báo trước đây của %<%c%E%> như là %<@required%>

en: previous declaration of %<%c%s%>
vi: khai báo trước của %<%c%s%>

en: previous declaration of %q+D
vi: khai báo trước đây của %q+D

en: previous declaration of %qD
vi: khai báo trước đây của %qD

en: previous declaration of %qE
vi: khai báo trước đây của %qE

en: previous declaration with %qL linkage
vi: khai báo trước đây của %qL là linkage

en: previous definition here
vi: định nghĩa trước ở đây

en: previous specification in %q#D here
vi: sau đặc tả trước đây trong %q#D

en: previously declared here
vi: đã khai báo trước ở đây

en: previously defined here
vi: đã định nghĩa trước ở đây

en: previously defined here as %s
vi: đã định nghĩa trước là %s

en: previously used here
vi: cái trước được dùng là ở đây

en: primary template here
vi: mẫu nguyên gốc ở đây

en: private member %q#D in anonymous union
vi: thành viên riêng %q+#D trong hỗn hợp nặc danh

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: protected member %q#D in anonymous union
vi: thành viên bảo vệ %q+#D trong hỗn hợp nặc danh

en: protocol %qE is deprecated
vi: giao thức %qE đã lạc hậu

en: prototype declaration
vi: khai báo mẫu trước

en: provided for %qD
vi: được cung cấp cho %qD

en: q/Q modifiers invalid for symbol references
vi: bổ từ q/Q không hợp lệ cho tham chiếu ký hiệu

en: qualified-id in declaration
vi: mã hạn định trong khai báo

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

en: re-initialization of %qs at %L
vi: khởi tạo lại của %qs tại %L

en: read failed while reading export data
vi: đọc gặp lỗi khi đọc dữ liệu xuất

en: reading input file
vi: đang đọc tập tin đầu vào

en: recursive inlining
vi: chèn vào trực tiếp một cách đệ quy

en: recursively required by substitution of %qS
vi: yêu cầu đệ quy bởi thay thế của %qS

en: recursively required from %q#D
vi: yêu cầu đệ quy từ %q#D

en: recursively required from here
vi: yêu cầu đệ quy từ đây

en: redeclaration of %<enum %E%>
vi: khai báo lại của %<enum %E%>

en: redeclaration of %q#D
vi: khai báo lại của %q#D

en: redeclared here as %q#D
vi: khai báo lại ở đây như là %q#D

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: redefinition of %<struct %E%>
vi: định nghĩa lại của %<struct %E%>

en: redefinition of %<union %E%>
vi: định nghĩa lại của %<union %E%>

en: redefinition of %q#D
vi: định nghĩa lại của %q#D

en: redefinition of %q#T
vi: định nghĩa lại của %q#T

en: redefinition of %q+D
vi: định nghĩa lại của %q+D

en: redefinition of parameter %q+D
vi: định nghĩa lại của đối số %q+D

en: redefinition of typedef %q+D
vi: định nghĩa lại của typedef %q+D

en: redefinition of typedef %q+D with different type
vi: định nghĩa lại của typedef %q+D với kiểu khác

en: redefinition of typedef %q+D with variably modified type
vi: định nghĩa lại của typedef %q+D với kiểu sửa biến đổi

en: redundant redeclaration of %q+D
vi: tái khai báo không hợp lệ cho %q+D

en: reference %qD is initialized with itself
vi: tham chiếu %qD được khởi tạo bằng chính nó

en: reference to local variable %qD returned
vi: tham chiếu đến biến cục bộ %qD được trả về

en: region of lp %i is wrong
vi: vùng của lp %i là sai

en: regparam and thiscall attributes are not compatible
vi: thuộc tính regparam và thiscall không tương thích với nhau

en: reimplementation of class %qE
vi: thực hiện lại lớp %qE

en: rename spec %s to %s
vi: thay đổi tên của đặc tả %s thành %s

en: repeated %s in format
vi: lặp %s trong định dạng

en: required by substitution of %qS
vi: được yêu cầu bởi thay thế của %qS

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: resolve_function(): bad function type
vi: resolve_function(): kiểu hàm sai

en: resolve_operator(): Bad intrinsic
vi: resolve_operator(): intrinsic sai

en: resolve_subroutine(): bad function type
vi: resolve_subroutine(): kiểu hàm sai

en: return not followed by barrier
vi: trả về không được phép bởi rào chắn

en: return type %q#T is incomplete
vi: kiểu trả về %q#T là một kiểu không hoàn toàn

en: return type defaults to %<int%>
vi: trả về kiểu mặc định cho %<int%>

en: return type is an incomplete type
vi: kiểu trả về là một kiểu không hoàn toàn

en: return with value in function with no return type
vi: trả về giá trị trong một hàm mà có kiểu không trả về

en: returning a value from a constructor
vi: trả về một giá trị từ cấu tử

en: returning a value from a destructor
vi: trả về một giá trị từ hủy tử

en: returning initializer list
vi: trả về danh sách bộ khởi tạo

en: returning reference to temporary
vi: trả về tham chiếu đến tạm thời (temporary)

en: right operand of shift expression %q+E is negative
vi: toán hạng phải của biểu thức dịch %q+E là số âm

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: routine %qD declared here
vi: %qD được khai báo ở đây

en: rx100 cpu does not have FPU hardware
vi: CPU rx100 không có phần cứng xử lý số thực dấu chấm động FPU

en: rx200 cpu does not have FPU hardware
vi: CPU rx200 không có phần cứng đơn vị dấu chấm động (FPU)

en: scaling cannot co-exist with normalization, skipping
vi: biến đổi không thể cùng tồn tại với tiêu chuẩn hóa, nên bỏ qua

en: second argument must be slice or string
vi: đối số thứ hai phải là kiểu slice hay chuỗi

en: second argument to %<__builtin_call_with_static_chain%> must be a pointer type
vi: đối số 1 của __builtin_paired_predicate phải là một hằng

en: second parameter of %<va_start%> not last named argument
vi: đối số thứ hai của %<va_start%> không là đối số có tên cuối

en: section attribute argument not a string constant
vi: đối số thuộc tính phần không phải là một hằng chuỗi

en: section of %q+D cannot be overridden
vi: phần của %q+D không thể bị ghi đè

en: selector must be an immediate
vi: bộ chọn phải là một giá trị trực tiếp

en: self-tests are not enabled in this build
vi: self-tests không được bật trong lần biên dịch này

en: shared and mdll are not compatible
vi: shared và mdll không tương thích với nhau

en: shared call_stmt:
vi: call_stmt được chia sẻ:

en: shared is not supported
vi: chia sẻ (dùng chung) không được hỗ trợ

en: shared rtx
vi: rtx dùng chung

en: shift of non-integer operand
vi: dịch của toán hạng không nguyên

en: short read while reading export data
vi: đọc ngắn khi xuất dữ liệu

en: simple IF
vi: IF (nếu) đơn giản

en: simplify_intrinsic_op(): Bad operator
vi: simplify_intrinsic_op(): Toán tử sai

en: size of array %qE is negative
vi: kích cỡ mảng %qE bị âm

en: size of array %qE is too large
vi: kích cỡ mảng %qE quá lớn

en: size of array is not an integral constant-expression
vi: kích cỡ mảng không phải là biểu thức hằng số nguyên

en: size of array is too large
vi: kích cỡ mảng là quá lớn

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 unnamed array is negative
vi: cỡ của mảng không tên là âm

en: size of unnamed array is too large
vi: kích thước của mảng chưa đặt tên là quá lớn

en: size of variable %q+D is too large
vi: kích cỡ biến %q+D quá lớn

en: sizeof(long double) is 12.
vi: kích cỡ (long double) là 12.

en: sizeof(long double) is 16.
vi: kích cỡ (long double) là 16.

en: soft-float and long-double-128 are incompatible
vi: soft-float và long-double-128 là xung khắc nhau

en: sorry, unimplemented
vi: tiếc là chưa thực hiện

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 lớp

en: source is not of class type
vi: nguồn không phải có loại lớp

en: source is of incomplete class type
vi: nguồn có loại lớp 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 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 %s spec was not found to be renamed
vi: đặc tả chứa đặc tả %s không có tên mới

en: stack frame too large
vi: khung stack quá lớn

en: stackframe too big: %d bytes
vi: khung stack quá lớn: %d bytes

en: statement has no effect
vi: câu lệnh không có tác động gì

en: statement marked for throw in middle of block
vi: lệnh được đánh dấu cho throw ở giữa một khối

en: statement marked for throw, but doesn%'t
vi: lệnh được đánh dấu cho throw, nhưng không phải vậy

en: statement with no effect
vi: câu lệnh không có tác dụng

en: static assertion failed
vi: thẩm tra tĩnh gặp lỗi

en: static data member %qD in unnamed class
vi: thành viên dữ liệu tĩnh %qD trong lớp không tên

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: stray %<@%> in program
vi: lạc %<@%> trong chương trình

en: stray %<\%o%> in program
vi: lạc %<\%o%> trong chương trình

en: stray %qc in program
vi: lạc %qc trong chương trình

en: stray %qs in program
vi: lạc %qs trong chương trình

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: struct has no named members
vi: cấu có không thành viên đã đặt tên

en: suggest parentheses around %<&&%> within %<||%>
vi: gợi ý bao quanh %<&&%> bằng dấu ngoặc đơn phía trong %<||%>

en: suggest parentheses around %<+%> in operand of %<&%>
vi: đề nghị bao %<+%> bằng dấu ngoặc đơn toán hạng của %<&%>

en: suggest parentheses around %<+%> inside %<<<%>
vi: đề nghị bao %<+%> bằng dấu ngoặc đơn phía trong %<<<%>

en: suggest parentheses around %<+%> inside %<>>%>
vi: đề nghị bao %<+%> bằng dấu ngoặc đơn phía trong %<>>%>

en: suggest parentheses around %<-%> in operand of %<&%>
vi: đề nghị bao %<-%> bằng dấu ngoặc đơn toán hạng của %<&%>

en: suggest parentheses around %<-%> inside %<<<%>
vi: đề nghị bao %<-%> bằng dấu ngoặc đơn phía trong %<<<%>

en: suggest parentheses around %<-%> inside %<>>%>
vi: đề nghị bao %<-%> bằng dấu ngoặc đơn phía trong %<>>%>

en: suggest parentheses around %<>>%> expression
vi: gợi ý bao quanh biểu thức %<>>%> bằng dấu ngoặc đơn

en: suggest parentheses around arithmetic in operand of %<^%>
vi: gợi ý là dùng dấu ngoặc đơn bao quanh biểu thức toán học trong toán hạng của %<^%>

en: suggest parentheses around arithmetic in operand of %<|%>
vi: gợi ý là dùng dấu ngoặc đơn bao quanh biểu thức toán học trong toán hạng của %<|%>

en: suggest parentheses around assignment used as truth value
vi: gợi ý là dùng dấu ngoặc đơn bao quanh phép gán được dùng như là giá trị chân lý

en: suggest parentheses around comparison in operand of %<!=%>
vi: gợi ý là dùng dấu ngoặc đơn bao quanh biểu thức so sánh trong toán hạng của %<!=%>

en: suggest parentheses around comparison in operand of %<&%>
vi: gợi ý là dùng dấu ngoặc đơn bao quanh biểu thức so sánh trong toán hạng của %<&%>

en: suggest parentheses around comparison in operand of %<==%>
vi: gợi ý là dùng dấu ngoặc đơn bao quanh biểu thức so sánh trong toán hạng của %<==%>

en: suggest parentheses around comparison in operand of %<^%>
vi: gợi ý là dùng dấu ngoặc đơn bao quanh biểu thức so sánh trong toán hạng của %<^%>

en: suggest parentheses around comparison in operand of %<|%>
vi: gợi ý là dùng dấu ngoặc đơn bao quanh biểu thức so sánh trong toán hạng của %<|%>

en: suggest parentheses around operand of %<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>
vi: gợi ý là dùng dấu ngoặc đơn bao quanh biểu thức so sánh trong toán hạng của %<!%> hoặc thay đổi %<&%> thành %<&&%> hay %<!%> thành %<~%>

en: suggest parentheses around operand of %<!%> or change %<|%> to %<||%> or %<!%> to %<~%>
vi: gợi ý là dùng dấu ngoặc đơn bao quanh biểu thức so sánh trong toán hạng của %<!%> hay thay đổi %<|%> thành %<||%> hay %<!%> thành %<~%>

en: suggested alternative: | suggested alternatives:
vi[0]: các khả năng được gợi ý:

en: support for mode %qs
vi: hỗ trợ cho chế độ %qs

en: switch %qs does not start with %<-%>
vi: switch %qs không bắt đầu với %<-%>

en: switch %qs is no longer supported
vi: switch %qs không còn tiếp tục được hỗ trợ nữa

en: switch missing default case
vi: switch thiếu case mặc định

en: switch starts here
vi: switch bắt đầu ở đây

en: symbol used as immediate operand
vi: ký hiệu dùng như là toán hạng giá trị trực tiếp

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: symtab_node::verify failed
vi: symtab_node::verify gặp lỗi

en: system path %qs is not absolute
vi: đường dẫn hệ thống %qs không phải dạng tuyệt đối

en: target CPU does not support ARM mode
vi: CPU đích không hỗ trợ chế độ ARM

en: target CPU does not support THUMB instructions
vi: CPU đích không hỗ trợ chỉ lệnh THUMB

en: target CPU does not support interworking
vi: CPU đích không hỗ trợ làm việc tương tác

en: target CPU does not support unaligned accesses
vi: CPU đích không hỗ trợ truy cập chưa cân chỉnh

en: target OS does not support unaligned accesses
vi: CPU đích không hỗ trợ truy cập chưa cân chỉnh

en: target argument
vi: đối số đích

en: target format does not support infinity
vi: định dạng đích không hỗ trợ vô cực

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: tùy chọn đặc trưng cho đích vẫn không tương ứng

en: target system does not support debug output
vi: hệ thống đích không hỗ trợ xuất gỡ lỗi

en: template declaration of %q#D
vi: cho khai báo hàm mẫu %q+D

en: template parameter %q+#D
vi: đối số mẫu %q+#D

en: template parameters cannot be friends
vi: các đối số tạm không thể là bạn

en: template-id %qD for %q+D does not match any template declaration
vi: template-id %qD cho %q+D không khớp bất kỳ khai báo mẫu nào

en: template-id %qD used as a declarator
vi: template-id %qD được dùng như bộ khai báo

en: templates may not be %<virtual%>
vi: các mẫu không thể là %<virtual%>

en: ternary %<operator?:%>
vi: bộ tam nguyên %<operator?:%>

en: ternary %<operator?:%> in %<%E ? %E : %E%>
vi: bộ tam nguyên %<operator?:%> trong %<%E ? %E : %E%>

en: the %<interrupt%> attribute requires a MIPS32r2 processor or greater
vi: thuộc tính %<interrupt%> cần bộ xử lý MIPS32r2 hay mới hơn

en: the %qE attribute requires arguments
vi: thuộc tính %qE cần tham số

en: the %qs architecture does not support %<-mfp32%>
vi: đích này không hỗ trợ %qs

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: tùy chọn -shared (chia sẻ) hiện thời không được hỗ trợ cho VAX ELF

en: the RX100 cpu does not have FPU hardware
vi: CPU RX100 không có phần cứng hỗ trợ dấu chấm động (FPU)

en: the RX200 cpu does not have FPU hardware
vi: CPU RX200 không có phần cứng hỗ trợ dấu chấm động (FPU)

en: the address of %qD will never be NULL
vi: địa chỉ của %qD sẽ không bao giờ là NULL

en: the assignment suppression scanf feature
vi: tính năng scanf để thu hồi sự gán

en: the compiler can assume that the address of %qD will never be NULL
vi: trình biên dịch sẽ coi rằng địa chỉ của %qD sẽ không bao giờ là NULL

en: the fifth argument must be an 8-bit immediate
vi: đối số thứ năm phải là giá trị trực tiếp 8-bit

en: the immediate argument must be a 4-bit immediate
vi: đối số trực tiếp phải là giá trị trực tiếp 4-bít

en: the immediate argument must be a 5-bit immediate
vi: đối số trực tiếp phải là giá trị trực tiếp 5-bít

en: the immediate argument must be an 8-bit immediate
vi: đối số trực tiếp phải là giá trị trực tiếp 8-bít

en: the incompatible type is defined here
vi: kiểu không tương thích được định nghĩa ở đây

en: the last argument must be a 1-bit immediate
vi: đối số cuối phải là giá trị trực tiếp 1-bít

en: the last argument must be a 2-bit immediate
vi: đối số cuối phải là giá trị trực tiếp 2-bít

en: the last argument must be a 3-bit immediate
vi: đối số cuối phải là giá trị trực tiếp 3-bít

en: the last argument must be a 32-bit immediate
vi: đối số cuối phải là giá trị trực tiếp 32-bít

en: the last argument must be a 4-bit immediate
vi: đối số cuối phải là giá trị trực tiếp 4-bít

en: the last argument must be a 5-bit immediate
vi: đối số cuối phải là giá trị trực tiếp 5-bít

en: the last argument must be an 1-bit immediate
vi: đối số cuối phải là giá trị trực tiếp 1-bít

en: the last argument must be an 8-bit immediate
vi: đối số cuối phải là giá trị trực tiếp 8-bít

en: the last argument must be scale 1, 2, 4, 8
vi: đối số cuối phải là tỷ lệ 1, 2, 4, 8

en: the m210 does not have little endian support
vi: m210 không có hỗ trợ về cuối nhỏ

en: the range of mask should be in 0 to 255
vi: vùng mặt nạ phải nằm từ 0 đến 255

en: the range of selector should be in 0 to 1
vi: vùng bộ chọn phải nằm từ 0 đến 1

en: the range of selector should be in 0 to 3
vi: vùng bộ chọn phải nằm từ 0 đến 3

en: the range of selector should be in 0 to 7
vi: vùng bộ chọn phải nằm từ 0 đến 7

en: the third argument must be an 8-bit immediate
vi: đối số thứ ba phải là giá trị trực tiếp 8-bit

en: the third argument must be comparison constant
vi: đối số thứ năm phải là giá trị trực tiếp 8-bit

en: this is the first default label
vi: đây là nhãn mặc định đầu tiên

en: this is the insn:
vi: đây là lệnh:

en: this media function is only available on the fr400 and fr550
vi: hàm đa phương tiện chỉ sẵn có trên fr400 và fr500

en: this media function is only available on the fr500
vi: hàm đa phương tiện chỉ sẵn có trên fr500

en: this target does not support %qs
vi: đích này không hỗ trợ %qs

en: this target is little-endian
vi: kiến trúc đích là về cuối nhỏ (little-endian)

en: too few arguments to %%:version-compare
vi: quá ít đối số tới %%:version-compare

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
vi: quá ít đối số cho hàm

en: too few arguments to function %q#D
vi: quá ít đối số cho hàm %q#D

en: too few arguments to function %qE
vi: quá ít đối số cho hàm %qE

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 %<if%> clauses
vi: quá nhiều mệnh đề %<if%>

en: too many %<static%> arguments
vi: quá nhiều đối số %<static%>

en: too many %qs clauses
vi: quá nhiều mệnh đề %qs

en: too many alternatives in %<asm%>
vi: quá nhiều thay thế trong %<asm%>

en: too many arguments
vi: quá nhiều đối số

en: too many arguments for format
vi: quá nhiều đối số cho định dạng

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 constructor %q#D
vi: quá nhiều đối số cho cấu tử %q#D

en: too many arguments to function
vi: quá nhiều đối số cho hàm

en: too many arguments to function %q#D
vi: quá nhiều đối số cho hàm %q#D

en: too many arguments to function %qE
vi: quá nhiều đối số cho hàm %qE

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 initializers for %qT
vi: quá nhiều bộ khởi tạo cho %qT

en: too many input files
vi: quá nhiều tập tin nhập vào

en: too many open parens
vi: quá nhiều cha được mở

en: too many values in return statement
vi: quá nhiều giá trị trong lệnh trả về

en: traditional C rejects the unary plus operator
vi: ngôn ngữ C truyền thống từ chối toán tử cộng một ngôi

en: tree check: %s, have %s in %s, at %s:%d
vi: kiểm tra cây: %s, có %s trong %s, tại %s:%d

en: tree check: expected class %qs, have %qs (%s) in %s, at %s:%d
vi: tree check: cần lớp %qs, có %qs (%s) trong %s, tại %s:%d

en: tree check: expected none of %s, have %s in %s, at %s:%d
vi: tree check: cần không gì của %s, có %s trong %s, tại %s:%d

en: try using %qE instead
vi: dùng %qE để thay thế

en: two or more sections for %s
vi: cần thiết ít nhất hai phần cho %s

en: type %qE has virtual member functions
vi: kiểu %qE có các hàm thành viên ảo

en: type %qT is not a direct base of %qT
vi: kiểu %qT không là cơ sở trực tiếp của %qT

en: type %qT is too large
vi: kiểu %qT quá lớn

en: type %qT should match type %qT
vi: kiểu %qT nên khớp kiểu %qT

en: type has no methods
vi: kiểu không có phương thức

en: type is deprecated
vi: kiểu đã lạc hậu

en: type is deprecated: %s
vi: kiểu đã lạc hậu: %s

en: type mismatch for case label in switch statement
vi: kiểu không khớp cho nhãn case trong câu lệnh switch

en: type mismatch in binary expression
vi: kiểu không khớp trong biểu thức nhị phân

en: type mismatch in conditional expression
vi: kiểu không khớp trong biểu thức điều kiện

en: type mismatch in parameter %i
vi: không khớp kiểu trong tham số %i

en: type of %qD defaults to %<int%>
vi: kiểu của %qD mặc định đến %<int%>

en: type of %qE is unknown
vi: không hiểu kiểu của %qE

en: typedef %q+D declared %<_Noreturn%>
vi: typedef %q+D được khai báo %<_Noreturn%>

en: typedef %q+D declared %<inline%>
vi: typedef %q+D được khai báo %<inline%>

en: typedef declared %<auto%>
vi: typedef được khai báo %<auto%>

en: types may not be defined in casts
vi: các kiểu có lẽ không nên được định nghĩa trong áp kiểu

en: types may not be defined in template arguments
vi: các kiểu không nên được định nghĩa trong đối số mẫu

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 file
vi: không thể mở tập tin

en: unable to open log file %<vtv_class_set_sizes.log%>: %m
vi: không thể mở tập tin nhật ký %<vtv_class_set_sizes.log%>: %m

en: unable to open log file %<vtv_count_data.log%>: %m
vi: không thể mở tập tin nhật ký %<vtv_count_data.log%>: %m

en: unable to open log file %<vtv_set_ptr_data.log%>: %m
vi: không thể mở tập tin nhật ký %<vtv_set_ptr_data.log%>: %m

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: undeclared selector %qE
vi: bộ chọn chưa được khai báo %qE

en: unexpected AST of kind %s
vi: cần AST thuộc kiểu %s

en: unexpected argument
vi: gặp tham số thừa

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 offset
vi: không cần offset

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 IRA region %qs
vi: không hiểu vùng IRA %qs

en: unknown LTO partitioning model %qs
vi: không hiểu mô hình phân vùng TLS %qs

en: unknown TLS model %qs
vi: không hiểu mô hình TLS %qs

en: unknown basic block reordering algorithm %qs
vi: không hiểu thuật toán xếp lại khối cơ bản %qs

en: unknown dest
vi: không rõ đích

en: unknown excess precision style %qs
vi: không hiểu kiểu chính xác bị vượt quá %qs

en: unknown insn mode
vi: không rõ chế độ lệnh

en: unknown linker output %qs
vi: không hiểu xuất bộ liên kết %qs

en: unknown machine mode %qE
vi: không hiểu chế độ máy %qE

en: unknown move insn:
vi: không rõ lệnh di chuyển:

en: unknown offload ABI %qs
vi: không hiểu ABI offload %qs

en: unknown operator %qs in %%:version-compare
vi: không hiểu toán tử %qs trong %%:version-compare

en: unknown option %q.*s in %<-fopt-info-%s%>
vi: không hiểu tùy chọn %q.*s trong %<-fopt-info-%s%>

en: unknown pointer size model %qs
vi: không hiểu mô hình kích thước con trỏ %qs

en: unknown property attribute
vi: không hiểu thuộc tính tính chất

en: unknown punctuation '%c'
vi: không hiểu dấu chấm câu “%c”

en: unknown register name: %s
vi: không hiểu tên thanh ghi: %s

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: unknown tuning option (%s)
vi: không hiểu tùy chọn chỉnh (%s)

en: unknown type name %qE
vi: không hiểu tên kiểu %qE

en: unknown type name %qE; did you mean %qs?
vi: không hiểu kiểu tên %qE; ý bạn là %qs?

en: unnamed class defined here
vi: union được định nghĩa ở đây

en: unquote_string(): got bad string
vi: unquote_string(): nhận chuỗi sai

en: unreachable
vi: không thể đọc được

en: unrecognizable argument of option
vi: không nhận ra đối số của tùy chọ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 tùy chọn %qs

en: unrecognized ivar visibility value %qs
vi: không nhận giá trị khả kiến ivar %qs

en: unrecognized register name %qs
vi: không nhận ra tên thanh ghi %qs

en: unrecognized scalar storage order value %qs
vi: không nhận ra giá trị thứ tự kho vô hướng %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: unsupported argument to %qD
vi: đối số không được hỗ trợ cho %D

en: unsupported combination: %s
vi: Hóa hợp không được hỗ trợ: %s

en: unsupported fixed-point conversion
vi: không hỗ trợ chuyển đổi dấu chấm cố định

en: unterminated assembly dialect alternative
vi: sự xen kẽ phương ngôn assembly chưa chấm dứt

en: unterminated format string
vi: gặp chuỗi định dạng chưa được chấm dứt

en: unused parameter %qD
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: unused variable %qD
vi: biến chưa được dùng %qD

en: use %<%T::%D%> instead
vi: dùng %<%T::%D%> thay thế

en: use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name
vi: dùng %<%T::%D%> thay cho %<%T::%D%> cho tên của cấu tử trong tên hạn định

en: use %<this->%D%> instead
vi: dùng %<this->%D%> thay thế

en: use of %qs in template
vi: dùng %qs trong mẫu

en: use of %s and %s together in %s format
vi: dùng của %s và %s cùng với định dạng %s

en: use of %s and %s together with %<%%%c%> %s format
vi: dùng của %s và %s cùng với %<%%%c%> định dạng %s

en: use of deleted function %qD
vi: dùng hàm bị xóa %qD

en: useless cast to type %qT
vi: trừ phi ép thành kiểu %qT

en: using %<%c%s%>
vi: đang dùng %<%c%s%>

en: using darwin64 ABI
vi: sử dụng darwin64 ABI

en: using invalid field %qD
vi: đang dùng trường không hợp lệ %qD

en: using old darwin ABI
vi: sử dụng darwin ABI kiểu cũ

en: valid arguments are: %s; did you mean %qs?
vi: đối số hợp lệ là: %s; có phải ý bạn là là: %qs?

en: valid arguments to %qs are: %s
vi: đối số hợp lệ cho cho %qs là: %s

en: value argument
vi: đối số giá trị

en: value computed is not used
vi: giá trị được tính không được sử dụng

en: variable %q+D declared %<_Noreturn%>
vi: biến %q+D được khai báo %<_Noreturn%>

en: variable %q+D declared %<inline%>
vi: biến %q+D được khai báo %<inline%>

en: variable %qD has function type
vi: biến %qD có kiểu hàm

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 length array %qD is used
vi: mảng có độ dài biến đổi %qD được dùng

en: variable length array is used
vi: mảng có độ dài biến đổi được dùng

en: variable or field declared void
vi: biến hay trường được khai báo là void

en: variable symbol is not variable
vi: ký hiệu biến đổi không là một biến

en: verify_cgraph_node failed
vi: verify_cgraph_node gặp lỗi

en: verify_flow_info failed
vi: verify_flow_info gặp lỗi

en: verify_flow_info: Basic block %d succ edge is corrupted
vi: verify_flow_info: Khối cơ sở %d succ edge bị hỏng

en: verify_flow_info: Block %i has loop_father, but there are no loops
vi: verify_flow_info: Khối %i có loop_father, nhưng chẳng có vòng lặp nào cả

en: verify_flow_info: Block %i lacks loop_father
vi: verify_flow_info: Khối %i thiếu loop_father

en: verify_flow_info: Duplicate edge %i->%i
vi: verify_flow_info: Trùng cạnh (edge) %i->%i

en: verify_flow_info: Incorrect blocks for fallthru %i->%i
vi: verify_flow_info: Các khối sai cho fallthru %i->%i

en: verify_flow_info: Incorrect fallthru %i->%i
vi: verify_flow_info: fallthru sai %i->%i

en: verify_flow_info: REG_BR_PROB does not match cfg %i %i
vi: verify_flow_info: REG_BR_PROB không khớp cfg %i %i

en: verify_gimple failed
vi: verify_gimple gặp lỗi

en: verify_ssa failed
vi: verify_ssa gặp lỗi

en: version attribute is not a string
vi: thuộc tính phiên bản không phải là một chuỗi

en: virtual method %qD
vi: phương thức ảo %qD

en: vms '#pragma __message' is ignored
vi: vms “#pragma __message” bị lờ đi

en: volatile argument
vi: đối số hay thay đổi

en: vtable for
vi: bảng vtable cho

en: waitpid failed
vi: waitpid bị lỗi

en: warning:
vi: cảnh báo:

en: warning: consider linking with '-static' as system libraries with
vi: cảnh báo: nên cân nhắc liên kết dùng “-static” như là thư viện hệ thống

en: when writing output to %s: %m
vi: khi ghi kết xuất ra %s: %m

en: with
vi: với

en: within this loop
vi: trong vòng lặp này

en: writing output file
vi: đang ghi tập tin đầu ra

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_addressof%>
vi: sai số tham số cho %<__builtin_addressof%>

en: wrong number of arguments to %<__builtin_call_with_static_chain%>
vi: sai số lượng đối số cho %<__builtin_choose_expr%>

en: wrong number of arguments to %<__builtin_choose_expr%>
vi: sai số lượng đối số cho %<__builtin_choose_expr%>

en: wrong number of arguments to %<__builtin_complex%>
vi: đối số sai số lượng cho %<__builtin_complex%>

en: wrong number of arguments to %<__builtin_launder%>
vi: đối số sai số lượng cho %<__builtin_launder%>

en: wrong number of arguments to %<__builtin_shuffle%>
vi: sai số tham số cho %<__builtin_shuffle%>

en: wrong number of arguments to function %<__builtin_next_arg%>
vi: sai số lượng đối số cho hàm %<__builtin_next_arg%>

en: wrong number of arguments to function %<va_start%>
vi: sai số lượng đối số cho hàm %<va_start%>

en: wrong number of template arguments (%d, should be %d)
vi: sai số lượng đối số hàm mẫu (%d, phải là %d)

en: wrong number of template arguments (%d, should be at least %d)
vi: sai số lượng đối số mẫu (%d, cần ít nhất phải là %d)

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 decrement
vi: sai đối số kiểu để giảm

en: wrong type argument to increment
vi: đối số sai kiểu cho gia số

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 or negative size array %q+D
vi: mảng có kích thước bằng không hay bị âm %q+D

en: zero vector size
vi: kích thước véc-tơ không

en: zero width for bit-field %q+D
vi: trường bít %q+D có độ rộng là không

en: zero width for bit-field %qs
vi: độ rộng bằng không cho bit-field %qs

en: zero width in %s format
vi: độ rộng bằng không trong định dạng %s

en: zero-length %s format string
vi: chuỗi định dạng %s có độ dài bằng không

en: zero-size array %qD
vi: mảng có kích thước bằng không %qD

en: zero-size array %qT
vi: mảng có kích thước không %qT

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