rustc_target/spec/
json.rs

1use std::collections::BTreeMap;
2use std::str::FromStr;
3
4use rustc_abi::{Align, AlignFromBytesError};
5
6use super::crt_objects::CrtObjects;
7use super::{
8    Abi, Arch, BinaryFormat, CodeModel, DebuginfoKind, Env, FloatAbi, FramePointer, LinkArgsCli,
9    LinkSelfContainedComponents, LinkSelfContainedDefault, LinkerFlavorCli, LldFlavor,
10    MergeFunctions, Os, PanicStrategy, RelocModel, RelroLevel, RustcAbi, SanitizerSet,
11    SmallDataThresholdSupport, SplitDebuginfo, StackProbeType, StaticCow, SymbolVisibility, Target,
12    TargetKind, TargetOptions, TargetWarnings, TlsModel,
13};
14use crate::json::{Json, ToJson};
15use crate::spec::AbiMap;
16
17impl Target {
18    /// Loads a target descriptor from a JSON object.
19    pub fn from_json(json: &str) -> Result<(Target, TargetWarnings), String> {
20        let json_deserializer = &mut serde_json::Deserializer::from_str(json);
21
22        let json: TargetSpecJson =
23            serde_path_to_error::deserialize(json_deserializer).map_err(|err| err.to_string())?;
24
25        let mut base = Target {
26            llvm_target: json.llvm_target,
27            metadata: Default::default(),
28            pointer_width: json.target_pointer_width,
29            data_layout: json.data_layout,
30            arch: json.arch,
31            options: Default::default(),
32        };
33
34        // FIXME: This doesn't properly validate anything and just ignores the data if it's invalid.
35        // That's okay for now, the only use of this is when generating docs, which we don't do for
36        // custom targets.
37        if let Some(metadata) = json.metadata {
38            base.metadata.description = metadata.description;
39            base.metadata.tier = metadata.tier.filter(|tier| (1..=3).contains(tier));
40            base.metadata.host_tools = metadata.host_tools;
41            base.metadata.std = metadata.std;
42        }
43
44        let alignment_error = |field_name: &str, error: AlignFromBytesError| -> String {
45            let msg = match error {
46                AlignFromBytesError::NotPowerOfTwo(_) => "not a power of 2 number of bytes",
47                AlignFromBytesError::TooLarge(_) => "too large",
48            };
49            ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("`{0}` bits is not a valid value for {1}: {2}",
                error.align() * 8, field_name, msg))
    })format!("`{}` bits is not a valid value for {field_name}: {msg}", error.align() * 8)
50        };
51
52        macro_rules! forward {
53            ($name:ident) => {
54                if let Some($name) = json.$name {
55                    base.$name = $name;
56                }
57            };
58        }
59        macro_rules! forward_opt {
60            ($name:ident) => {
61                if let Some($name) = json.$name {
62                    base.$name = Some($name);
63                }
64            };
65        }
66
67        if let Some(target_endian) = json.target_endian {
68            base.endian = target_endian.0;
69        }
70
71        if let Some(frame_pointer) = json.frame_pointer {
    base.frame_pointer = frame_pointer;
};forward!(frame_pointer);
72        if let Some(c_int_width) = json.c_int_width {
    base.c_int_width = c_int_width;
};forward!(c_int_width);
73        if let Some(c_enum_min_bits) = json.c_enum_min_bits {
    base.c_enum_min_bits = Some(c_enum_min_bits);
};forward_opt!(c_enum_min_bits); // if None, matches c_int_width
74        if let Some(os) = json.os { base.os = os; };forward!(os);
75        if let Some(env) = json.env { base.env = env; };forward!(env);
76        if let Some(abi) = json.abi { base.abi = abi; };forward!(abi);
77        if let Some(vendor) = json.vendor { base.vendor = vendor; };forward!(vendor);
78        if let Some(linker) = json.linker { base.linker = Some(linker); };forward_opt!(linker);
79        if let Some(linker_flavor_json) = json.linker_flavor_json {
    base.linker_flavor_json = linker_flavor_json;
};forward!(linker_flavor_json);
80        if let Some(lld_flavor_json) = json.lld_flavor_json {
    base.lld_flavor_json = lld_flavor_json;
};forward!(lld_flavor_json);
81        if let Some(linker_is_gnu_json) = json.linker_is_gnu_json {
    base.linker_is_gnu_json = linker_is_gnu_json;
};forward!(linker_is_gnu_json);
82        if let Some(pre_link_objects) = json.pre_link_objects {
    base.pre_link_objects = pre_link_objects;
};forward!(pre_link_objects);
83        if let Some(post_link_objects) = json.post_link_objects {
    base.post_link_objects = post_link_objects;
};forward!(post_link_objects);
84        if let Some(pre_link_objects_self_contained) =
        json.pre_link_objects_self_contained {
    base.pre_link_objects_self_contained = pre_link_objects_self_contained;
};forward!(pre_link_objects_self_contained);
85        if let Some(post_link_objects_self_contained) =
        json.post_link_objects_self_contained {
    base.post_link_objects_self_contained = post_link_objects_self_contained;
};forward!(post_link_objects_self_contained);
86
87        // Deserializes the backwards-compatible variants of `-Clink-self-contained`
88        if let Some(link_self_contained) = json.link_self_contained_backwards_compatible {
89            base.link_self_contained = link_self_contained;
90        }
91        // Deserializes the components variant of `-Clink-self-contained`
92        if let Some(link_self_contained) = json.link_self_contained {
93            let components = link_self_contained
94                .components
95                .into_iter()
96                .fold(LinkSelfContainedComponents::empty(), |a, b| a | b);
97            base.link_self_contained = LinkSelfContainedDefault::WithComponents(components);
98        }
99
100        if let Some(pre_link_args_json) = json.pre_link_args_json {
    base.pre_link_args_json = pre_link_args_json;
};forward!(pre_link_args_json);
101        if let Some(late_link_args_json) = json.late_link_args_json {
    base.late_link_args_json = late_link_args_json;
};forward!(late_link_args_json);
102        if let Some(late_link_args_dynamic_json) = json.late_link_args_dynamic_json {
    base.late_link_args_dynamic_json = late_link_args_dynamic_json;
};forward!(late_link_args_dynamic_json);
103        if let Some(late_link_args_static_json) = json.late_link_args_static_json {
    base.late_link_args_static_json = late_link_args_static_json;
};forward!(late_link_args_static_json);
104        if let Some(post_link_args_json) = json.post_link_args_json {
    base.post_link_args_json = post_link_args_json;
};forward!(post_link_args_json);
105        if let Some(link_script) = json.link_script {
    base.link_script = Some(link_script);
};forward_opt!(link_script);
106
107        if let Some(link_env) = json.link_env {
108            for s in link_env {
109                if let [k, v] = *s.split('=').collect::<Vec<_>>() {
110                    base.link_env.to_mut().push((k.to_string().into(), v.to_string().into()))
111                } else {
112                    return Err(::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("link-env value \'{0}\' must be of the pattern \'KEY=VALUE\'",
                s))
    })format!("link-env value '{s}' must be of the pattern 'KEY=VALUE'"));
113                }
114            }
115        }
116
117        if let Some(link_env_remove) = json.link_env_remove {
    base.link_env_remove = link_env_remove;
};forward!(link_env_remove);
118        if let Some(asm_args) = json.asm_args { base.asm_args = asm_args; };forward!(asm_args);
119        if let Some(cpu) = json.cpu { base.cpu = cpu; };forward!(cpu);
120        if let Some(need_explicit_cpu) = json.need_explicit_cpu {
    base.need_explicit_cpu = need_explicit_cpu;
};forward!(need_explicit_cpu);
121        if let Some(features) = json.features { base.features = features; };forward!(features);
122        if let Some(dynamic_linking) = json.dynamic_linking {
    base.dynamic_linking = dynamic_linking;
};forward!(dynamic_linking);
123        if let Some(direct_access_external_data) = json.direct_access_external_data {
    base.direct_access_external_data = Some(direct_access_external_data);
};forward_opt!(direct_access_external_data);
124        if let Some(dll_tls_export) = json.dll_tls_export {
    base.dll_tls_export = dll_tls_export;
};forward!(dll_tls_export);
125        if let Some(only_cdylib) = json.only_cdylib {
    base.only_cdylib = only_cdylib;
};forward!(only_cdylib);
126        if let Some(executables) = json.executables {
    base.executables = executables;
};forward!(executables);
127        if let Some(relocation_model) = json.relocation_model {
    base.relocation_model = relocation_model;
};forward!(relocation_model);
128        if let Some(code_model) = json.code_model {
    base.code_model = Some(code_model);
};forward_opt!(code_model);
129        if let Some(tls_model) = json.tls_model { base.tls_model = tls_model; };forward!(tls_model);
130        if let Some(disable_redzone) = json.disable_redzone {
    base.disable_redzone = disable_redzone;
};forward!(disable_redzone);
131        if let Some(function_sections) = json.function_sections {
    base.function_sections = function_sections;
};forward!(function_sections);
132        if let Some(dll_prefix) = json.dll_prefix { base.dll_prefix = dll_prefix; };forward!(dll_prefix);
133        if let Some(dll_suffix) = json.dll_suffix { base.dll_suffix = dll_suffix; };forward!(dll_suffix);
134        if let Some(exe_suffix) = json.exe_suffix { base.exe_suffix = exe_suffix; };forward!(exe_suffix);
135        if let Some(staticlib_prefix) = json.staticlib_prefix {
    base.staticlib_prefix = staticlib_prefix;
};forward!(staticlib_prefix);
136        if let Some(staticlib_suffix) = json.staticlib_suffix {
    base.staticlib_suffix = staticlib_suffix;
};forward!(staticlib_suffix);
137
138        if let Some(target_family) = json.target_family {
139            match target_family {
140                TargetFamiliesJson::Array(families) => base.families = families,
141                TargetFamiliesJson::String(family) => base.families = <[_]>::into_vec(::alloc::boxed::box_new([family]))vec![family].into(),
142            }
143        }
144
145        if let Some(abi_return_struct_as_int) = json.abi_return_struct_as_int {
    base.abi_return_struct_as_int = abi_return_struct_as_int;
};forward!(abi_return_struct_as_int);
146        if let Some(is_like_aix) = json.is_like_aix {
    base.is_like_aix = is_like_aix;
};forward!(is_like_aix);
147        if let Some(is_like_darwin) = json.is_like_darwin {
    base.is_like_darwin = is_like_darwin;
};forward!(is_like_darwin);
148        if let Some(is_like_solaris) = json.is_like_solaris {
    base.is_like_solaris = is_like_solaris;
};forward!(is_like_solaris);
149        if let Some(is_like_windows) = json.is_like_windows {
    base.is_like_windows = is_like_windows;
};forward!(is_like_windows);
150        if let Some(is_like_gpu) = json.is_like_gpu {
    base.is_like_gpu = is_like_gpu;
};forward!(is_like_gpu);
151        if let Some(is_like_msvc) = json.is_like_msvc {
    base.is_like_msvc = is_like_msvc;
};forward!(is_like_msvc);
152        if let Some(is_like_wasm) = json.is_like_wasm {
    base.is_like_wasm = is_like_wasm;
};forward!(is_like_wasm);
153        if let Some(is_like_android) = json.is_like_android {
    base.is_like_android = is_like_android;
};forward!(is_like_android);
154        if let Some(is_like_vexos) = json.is_like_vexos {
    base.is_like_vexos = is_like_vexos;
};forward!(is_like_vexos);
155        if let Some(binary_format) = json.binary_format {
    base.binary_format = binary_format;
};forward!(binary_format);
156        if let Some(default_dwarf_version) = json.default_dwarf_version {
    base.default_dwarf_version = default_dwarf_version;
};forward!(default_dwarf_version);
157        if let Some(allows_weak_linkage) = json.allows_weak_linkage {
    base.allows_weak_linkage = allows_weak_linkage;
};forward!(allows_weak_linkage);
158        if let Some(has_rpath) = json.has_rpath { base.has_rpath = has_rpath; };forward!(has_rpath);
159        if let Some(no_default_libraries) = json.no_default_libraries {
    base.no_default_libraries = no_default_libraries;
};forward!(no_default_libraries);
160        if let Some(position_independent_executables) =
        json.position_independent_executables {
    base.position_independent_executables = position_independent_executables;
};forward!(position_independent_executables);
161        if let Some(static_position_independent_executables) =
        json.static_position_independent_executables {
    base.static_position_independent_executables =
        static_position_independent_executables;
};forward!(static_position_independent_executables);
162        if let Some(plt_by_default) = json.plt_by_default {
    base.plt_by_default = plt_by_default;
};forward!(plt_by_default);
163        if let Some(relro_level) = json.relro_level {
    base.relro_level = relro_level;
};forward!(relro_level);
164        if let Some(archive_format) = json.archive_format {
    base.archive_format = archive_format;
};forward!(archive_format);
165        if let Some(allow_asm) = json.allow_asm { base.allow_asm = allow_asm; };forward!(allow_asm);
166        if let Some(static_initializer_must_be_acyclic) =
        json.static_initializer_must_be_acyclic {
    base.static_initializer_must_be_acyclic =
        static_initializer_must_be_acyclic;
};forward!(static_initializer_must_be_acyclic);
167        if let Some(main_needs_argc_argv) = json.main_needs_argc_argv {
    base.main_needs_argc_argv = main_needs_argc_argv;
};forward!(main_needs_argc_argv);
168        if let Some(has_thread_local) = json.has_thread_local {
    base.has_thread_local = has_thread_local;
};forward!(has_thread_local);
169        if let Some(obj_is_bitcode) = json.obj_is_bitcode {
    base.obj_is_bitcode = obj_is_bitcode;
};forward!(obj_is_bitcode);
170        if let Some(max_atomic_width) = json.max_atomic_width {
    base.max_atomic_width = Some(max_atomic_width);
};forward_opt!(max_atomic_width);
171        if let Some(min_atomic_width) = json.min_atomic_width {
    base.min_atomic_width = Some(min_atomic_width);
};forward_opt!(min_atomic_width);
172        if let Some(atomic_cas) = json.atomic_cas { base.atomic_cas = atomic_cas; };forward!(atomic_cas);
173        if let Some(panic_strategy) = json.panic_strategy {
    base.panic_strategy = panic_strategy;
};forward!(panic_strategy);
174        if let Some(crt_static_allows_dylibs) = json.crt_static_allows_dylibs {
    base.crt_static_allows_dylibs = crt_static_allows_dylibs;
};forward!(crt_static_allows_dylibs);
175        if let Some(crt_static_default) = json.crt_static_default {
    base.crt_static_default = crt_static_default;
};forward!(crt_static_default);
176        if let Some(crt_static_respected) = json.crt_static_respected {
    base.crt_static_respected = crt_static_respected;
};forward!(crt_static_respected);
177        if let Some(stack_probes) = json.stack_probes {
    base.stack_probes = stack_probes;
};forward!(stack_probes);
178
179        if let Some(min_global_align) = json.min_global_align {
180            match Align::from_bits(min_global_align) {
181                Ok(align) => base.min_global_align = Some(align),
182                Err(e) => return Err(alignment_error("min-global-align", e)),
183            }
184        }
185
186        if let Some(default_codegen_units) = json.default_codegen_units {
    base.default_codegen_units = Some(default_codegen_units);
};forward_opt!(default_codegen_units);
187        if let Some(default_codegen_backend) = json.default_codegen_backend {
    base.default_codegen_backend = Some(default_codegen_backend);
};forward_opt!(default_codegen_backend);
188        if let Some(trap_unreachable) = json.trap_unreachable {
    base.trap_unreachable = trap_unreachable;
};forward!(trap_unreachable);
189        if let Some(requires_lto) = json.requires_lto {
    base.requires_lto = requires_lto;
};forward!(requires_lto);
190        if let Some(singlethread) = json.singlethread {
    base.singlethread = singlethread;
};forward!(singlethread);
191        if let Some(no_builtins) = json.no_builtins {
    base.no_builtins = no_builtins;
};forward!(no_builtins);
192        if let Some(default_visibility) = json.default_visibility {
    base.default_visibility = Some(default_visibility);
};forward_opt!(default_visibility);
193        if let Some(emit_debug_gdb_scripts) = json.emit_debug_gdb_scripts {
    base.emit_debug_gdb_scripts = emit_debug_gdb_scripts;
};forward!(emit_debug_gdb_scripts);
194        if let Some(requires_uwtable) = json.requires_uwtable {
    base.requires_uwtable = requires_uwtable;
};forward!(requires_uwtable);
195        if let Some(default_uwtable) = json.default_uwtable {
    base.default_uwtable = default_uwtable;
};forward!(default_uwtable);
196        if let Some(simd_types_indirect) = json.simd_types_indirect {
    base.simd_types_indirect = simd_types_indirect;
};forward!(simd_types_indirect);
197        if let Some(limit_rdylib_exports) = json.limit_rdylib_exports {
    base.limit_rdylib_exports = limit_rdylib_exports;
};forward!(limit_rdylib_exports);
198        if let Some(override_export_symbols) = json.override_export_symbols {
    base.override_export_symbols = Some(override_export_symbols);
};forward_opt!(override_export_symbols);
199        if let Some(merge_functions) = json.merge_functions {
    base.merge_functions = merge_functions;
};forward!(merge_functions);
200        if let Some(mcount) = json.mcount { base.mcount = mcount; };forward!(mcount);
201        if let Some(llvm_mcount_intrinsic) = json.llvm_mcount_intrinsic {
    base.llvm_mcount_intrinsic = Some(llvm_mcount_intrinsic);
};forward_opt!(llvm_mcount_intrinsic);
202        if let Some(llvm_abiname) = json.llvm_abiname {
    base.llvm_abiname = llvm_abiname;
};forward!(llvm_abiname);
203        if let Some(llvm_floatabi) = json.llvm_floatabi {
    base.llvm_floatabi = Some(llvm_floatabi);
};forward_opt!(llvm_floatabi);
204        if let Some(rustc_abi) = json.rustc_abi { base.rustc_abi = Some(rustc_abi); };forward_opt!(rustc_abi);
205        if let Some(relax_elf_relocations) = json.relax_elf_relocations {
    base.relax_elf_relocations = relax_elf_relocations;
};forward!(relax_elf_relocations);
206        if let Some(llvm_args) = json.llvm_args { base.llvm_args = llvm_args; };forward!(llvm_args);
207        if let Some(use_ctors_section) = json.use_ctors_section {
    base.use_ctors_section = use_ctors_section;
};forward!(use_ctors_section);
208        if let Some(eh_frame_header) = json.eh_frame_header {
    base.eh_frame_header = eh_frame_header;
};forward!(eh_frame_header);
209        if let Some(has_thumb_interworking) = json.has_thumb_interworking {
    base.has_thumb_interworking = has_thumb_interworking;
};forward!(has_thumb_interworking);
210        if let Some(debuginfo_kind) = json.debuginfo_kind {
    base.debuginfo_kind = debuginfo_kind;
};forward!(debuginfo_kind);
211        if let Some(split_debuginfo) = json.split_debuginfo {
    base.split_debuginfo = split_debuginfo;
};forward!(split_debuginfo);
212        if let Some(supported_split_debuginfo) = json.supported_split_debuginfo {
    base.supported_split_debuginfo = supported_split_debuginfo;
};forward!(supported_split_debuginfo);
213
214        if let Some(supported_sanitizers) = json.supported_sanitizers {
215            base.supported_sanitizers =
216                supported_sanitizers.into_iter().fold(SanitizerSet::empty(), |a, b| a | b);
217        }
218
219        if let Some(default_sanitizers) = json.default_sanitizers {
220            base.default_sanitizers =
221                default_sanitizers.into_iter().fold(SanitizerSet::empty(), |a, b| a | b);
222        }
223
224        if let Some(generate_arange_section) = json.generate_arange_section {
    base.generate_arange_section = generate_arange_section;
};forward!(generate_arange_section);
225        if let Some(supports_stack_protector) = json.supports_stack_protector {
    base.supports_stack_protector = supports_stack_protector;
};forward!(supports_stack_protector);
226        if let Some(small_data_threshold_support) = json.small_data_threshold_support
    {
    base.small_data_threshold_support = small_data_threshold_support;
};forward!(small_data_threshold_support);
227        if let Some(entry_name) = json.entry_name { base.entry_name = entry_name; };forward!(entry_name);
228        if let Some(supports_xray) = json.supports_xray {
    base.supports_xray = supports_xray;
};forward!(supports_xray);
229
230        // we're going to run `update_from_cli`, but that won't change the target's AbiMap
231        // FIXME: better factor the Target definition so we enforce this on a type level
232        let abi_map = AbiMap::from_target(&base);
233        if let Some(entry_abi) = json.entry_abi {
234            base.options.entry_abi = abi_map.canonize_abi(entry_abi.0, false).unwrap();
235        }
236
237        base.update_from_cli();
238        base.check_consistency(TargetKind::Json)?;
239
240        Ok((base, TargetWarnings { unused_fields: ::alloc::vec::Vec::new()vec![] }))
241    }
242}
243
244impl ToJson for Target {
245    fn to_json(&self) -> Json {
246        let mut d = serde_json::Map::new();
247        let default: TargetOptions = Default::default();
248        let mut target = self.clone();
249        target.update_to_cli();
250
251        macro_rules! target_val {
252            ($attr:ident) => {
253                target_val!($attr, (stringify!($attr)).replace("_", "-"))
254            };
255            ($attr:ident, $json_name:expr) => {{
256                let name = $json_name;
257                d.insert(name.into(), target.$attr.to_json());
258            }};
259        }
260
261        macro_rules! target_option_val {
262            ($attr:ident) => {{ target_option_val!($attr, (stringify!($attr)).replace("_", "-")) }};
263            ($attr:ident, $json_name:expr) => {{
264                let name = $json_name;
265                #[allow(rustc::bad_opt_access)]
266                if default.$attr != target.$attr {
267                    d.insert(name.into(), target.$attr.to_json());
268                }
269            }};
270            (link_args - $attr:ident, $json_name:expr) => {{
271                let name = $json_name;
272                if default.$attr != target.$attr {
273                    let obj = target
274                        .$attr
275                        .iter()
276                        .map(|(k, v)| (k.desc().to_string(), v.clone()))
277                        .collect::<BTreeMap<_, _>>();
278                    d.insert(name.to_string(), obj.to_json());
279                }
280            }};
281            (env - $attr:ident) => {{
282                let name = (stringify!($attr)).replace("_", "-");
283                if default.$attr != target.$attr {
284                    let obj = target
285                        .$attr
286                        .iter()
287                        .map(|&(ref k, ref v)| format!("{k}={v}"))
288                        .collect::<Vec<_>>();
289                    d.insert(name, obj.to_json());
290                }
291            }};
292        }
293
294        {
    let name = ("llvm_target").replace("_", "-");
    d.insert(name.into(), target.llvm_target.to_json());
};target_val!(llvm_target);
295        {
    let name = ("metadata").replace("_", "-");
    d.insert(name.into(), target.metadata.to_json());
};target_val!(metadata);
296        {
    let name = "target-pointer-width";
    d.insert(name.into(), target.pointer_width.to_json());
};target_val!(pointer_width, "target-pointer-width");
297        {
    let name = ("arch").replace("_", "-");
    d.insert(name.into(), target.arch.to_json());
};target_val!(arch);
298        {
    let name = ("data_layout").replace("_", "-");
    d.insert(name.into(), target.data_layout.to_json());
};target_val!(data_layout);
299
300        {
    let name = "target-endian";

    #[allow(rustc :: bad_opt_access)]
    if default.endian != target.endian {
        d.insert(name.into(), target.endian.to_json());
    }
};target_option_val!(endian, "target-endian");
301        {
    let name = "target-c-int-width";

    #[allow(rustc :: bad_opt_access)]
    if default.c_int_width != target.c_int_width {
        d.insert(name.into(), target.c_int_width.to_json());
    }
};target_option_val!(c_int_width, "target-c-int-width");
302        {
    {
        let name = ("os").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.os != target.os {
            d.insert(name.into(), target.os.to_json());
        }
    }
};target_option_val!(os);
303        {
    {
        let name = ("env").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.env != target.env {
            d.insert(name.into(), target.env.to_json());
        }
    }
};target_option_val!(env);
304        {
    {
        let name = ("abi").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.abi != target.abi {
            d.insert(name.into(), target.abi.to_json());
        }
    }
};target_option_val!(abi);
305        {
    {
        let name = ("vendor").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.vendor != target.vendor {
            d.insert(name.into(), target.vendor.to_json());
        }
    }
};target_option_val!(vendor);
306        {
    {
        let name = ("linker").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.linker != target.linker {
            d.insert(name.into(), target.linker.to_json());
        }
    }
};target_option_val!(linker);
307        {
    let name = "linker-flavor";

    #[allow(rustc :: bad_opt_access)]
    if default.linker_flavor_json != target.linker_flavor_json {
        d.insert(name.into(), target.linker_flavor_json.to_json());
    }
};target_option_val!(linker_flavor_json, "linker-flavor");
308        {
    let name = "lld-flavor";

    #[allow(rustc :: bad_opt_access)]
    if default.lld_flavor_json != target.lld_flavor_json {
        d.insert(name.into(), target.lld_flavor_json.to_json());
    }
};target_option_val!(lld_flavor_json, "lld-flavor");
309        {
    let name = "linker-is-gnu";

    #[allow(rustc :: bad_opt_access)]
    if default.linker_is_gnu_json != target.linker_is_gnu_json {
        d.insert(name.into(), target.linker_is_gnu_json.to_json());
    }
};target_option_val!(linker_is_gnu_json, "linker-is-gnu");
310        {
    {
        let name = ("pre_link_objects").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.pre_link_objects != target.pre_link_objects {
            d.insert(name.into(), target.pre_link_objects.to_json());
        }
    }
};target_option_val!(pre_link_objects);
311        {
    {
        let name = ("post_link_objects").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.post_link_objects != target.post_link_objects {
            d.insert(name.into(), target.post_link_objects.to_json());
        }
    }
};target_option_val!(post_link_objects);
312        {
    let name = "pre-link-objects-fallback";

    #[allow(rustc :: bad_opt_access)]
    if default.pre_link_objects_self_contained !=
            target.pre_link_objects_self_contained {
        d.insert(name.into(),
            target.pre_link_objects_self_contained.to_json());
    }
};target_option_val!(pre_link_objects_self_contained, "pre-link-objects-fallback");
313        {
    let name = "post-link-objects-fallback";

    #[allow(rustc :: bad_opt_access)]
    if default.post_link_objects_self_contained !=
            target.post_link_objects_self_contained {
        d.insert(name.into(),
            target.post_link_objects_self_contained.to_json());
    }
};target_option_val!(post_link_objects_self_contained, "post-link-objects-fallback");
314        {
    let name = "pre-link-args";
    if default.pre_link_args_json != target.pre_link_args_json {
        let obj =
            target.pre_link_args_json.iter().map(|(k, v)|
                        (k.desc().to_string(),
                            v.clone())).collect::<BTreeMap<_, _>>();
        d.insert(name.to_string(), obj.to_json());
    }
};target_option_val!(link_args - pre_link_args_json, "pre-link-args");
315        {
    let name = "late-link-args";
    if default.late_link_args_json != target.late_link_args_json {
        let obj =
            target.late_link_args_json.iter().map(|(k, v)|
                        (k.desc().to_string(),
                            v.clone())).collect::<BTreeMap<_, _>>();
        d.insert(name.to_string(), obj.to_json());
    }
};target_option_val!(link_args - late_link_args_json, "late-link-args");
316        {
    let name = "late-link-args-dynamic";
    if default.late_link_args_dynamic_json !=
            target.late_link_args_dynamic_json {
        let obj =
            target.late_link_args_dynamic_json.iter().map(|(k, v)|
                        (k.desc().to_string(),
                            v.clone())).collect::<BTreeMap<_, _>>();
        d.insert(name.to_string(), obj.to_json());
    }
};target_option_val!(link_args - late_link_args_dynamic_json, "late-link-args-dynamic");
317        {
    let name = "late-link-args-static";
    if default.late_link_args_static_json != target.late_link_args_static_json
        {
        let obj =
            target.late_link_args_static_json.iter().map(|(k, v)|
                        (k.desc().to_string(),
                            v.clone())).collect::<BTreeMap<_, _>>();
        d.insert(name.to_string(), obj.to_json());
    }
};target_option_val!(link_args - late_link_args_static_json, "late-link-args-static");
318        {
    let name = "post-link-args";
    if default.post_link_args_json != target.post_link_args_json {
        let obj =
            target.post_link_args_json.iter().map(|(k, v)|
                        (k.desc().to_string(),
                            v.clone())).collect::<BTreeMap<_, _>>();
        d.insert(name.to_string(), obj.to_json());
    }
};target_option_val!(link_args - post_link_args_json, "post-link-args");
319        {
    {
        let name = ("link_script").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.link_script != target.link_script {
            d.insert(name.into(), target.link_script.to_json());
        }
    }
};target_option_val!(link_script);
320        {
    let name = ("link_env").replace("_", "-");
    if default.link_env != target.link_env {
        let obj =
            target.link_env.iter().map(|&(ref k, ref v)|
                        ::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("{0}={1}", k, v))
                            })).collect::<Vec<_>>();
        d.insert(name, obj.to_json());
    }
};target_option_val!(env - link_env);
321        {
    {
        let name = ("link_env_remove").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.link_env_remove != target.link_env_remove {
            d.insert(name.into(), target.link_env_remove.to_json());
        }
    }
};target_option_val!(link_env_remove);
322        {
    {
        let name = ("asm_args").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.asm_args != target.asm_args {
            d.insert(name.into(), target.asm_args.to_json());
        }
    }
};target_option_val!(asm_args);
323        {
    {
        let name = ("cpu").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.cpu != target.cpu {
            d.insert(name.into(), target.cpu.to_json());
        }
    }
};target_option_val!(cpu);
324        {
    {
        let name = ("need_explicit_cpu").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.need_explicit_cpu != target.need_explicit_cpu {
            d.insert(name.into(), target.need_explicit_cpu.to_json());
        }
    }
};target_option_val!(need_explicit_cpu);
325        {
    {
        let name = ("features").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.features != target.features {
            d.insert(name.into(), target.features.to_json());
        }
    }
};target_option_val!(features);
326        {
    {
        let name = ("dynamic_linking").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.dynamic_linking != target.dynamic_linking {
            d.insert(name.into(), target.dynamic_linking.to_json());
        }
    }
};target_option_val!(dynamic_linking);
327        {
    {
        let name = ("direct_access_external_data").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.direct_access_external_data !=
                target.direct_access_external_data {
            d.insert(name.into(),
                target.direct_access_external_data.to_json());
        }
    }
};target_option_val!(direct_access_external_data);
328        {
    {
        let name = ("dll_tls_export").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.dll_tls_export != target.dll_tls_export {
            d.insert(name.into(), target.dll_tls_export.to_json());
        }
    }
};target_option_val!(dll_tls_export);
329        {
    {
        let name = ("only_cdylib").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.only_cdylib != target.only_cdylib {
            d.insert(name.into(), target.only_cdylib.to_json());
        }
    }
};target_option_val!(only_cdylib);
330        {
    {
        let name = ("executables").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.executables != target.executables {
            d.insert(name.into(), target.executables.to_json());
        }
    }
};target_option_val!(executables);
331        {
    {
        let name = ("relocation_model").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.relocation_model != target.relocation_model {
            d.insert(name.into(), target.relocation_model.to_json());
        }
    }
};target_option_val!(relocation_model);
332        {
    {
        let name = ("code_model").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.code_model != target.code_model {
            d.insert(name.into(), target.code_model.to_json());
        }
    }
};target_option_val!(code_model);
333        {
    {
        let name = ("tls_model").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.tls_model != target.tls_model {
            d.insert(name.into(), target.tls_model.to_json());
        }
    }
};target_option_val!(tls_model);
334        {
    {
        let name = ("disable_redzone").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.disable_redzone != target.disable_redzone {
            d.insert(name.into(), target.disable_redzone.to_json());
        }
    }
};target_option_val!(disable_redzone);
335        {
    {
        let name = ("frame_pointer").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.frame_pointer != target.frame_pointer {
            d.insert(name.into(), target.frame_pointer.to_json());
        }
    }
};target_option_val!(frame_pointer);
336        {
    {
        let name = ("function_sections").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.function_sections != target.function_sections {
            d.insert(name.into(), target.function_sections.to_json());
        }
    }
};target_option_val!(function_sections);
337        {
    {
        let name = ("dll_prefix").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.dll_prefix != target.dll_prefix {
            d.insert(name.into(), target.dll_prefix.to_json());
        }
    }
};target_option_val!(dll_prefix);
338        {
    {
        let name = ("dll_suffix").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.dll_suffix != target.dll_suffix {
            d.insert(name.into(), target.dll_suffix.to_json());
        }
    }
};target_option_val!(dll_suffix);
339        {
    {
        let name = ("exe_suffix").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.exe_suffix != target.exe_suffix {
            d.insert(name.into(), target.exe_suffix.to_json());
        }
    }
};target_option_val!(exe_suffix);
340        {
    {
        let name = ("staticlib_prefix").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.staticlib_prefix != target.staticlib_prefix {
            d.insert(name.into(), target.staticlib_prefix.to_json());
        }
    }
};target_option_val!(staticlib_prefix);
341        {
    {
        let name = ("staticlib_suffix").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.staticlib_suffix != target.staticlib_suffix {
            d.insert(name.into(), target.staticlib_suffix.to_json());
        }
    }
};target_option_val!(staticlib_suffix);
342        {
    let name = "target-family";

    #[allow(rustc :: bad_opt_access)]
    if default.families != target.families {
        d.insert(name.into(), target.families.to_json());
    }
};target_option_val!(families, "target-family");
343        {
    {
        let name = ("abi_return_struct_as_int").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.abi_return_struct_as_int != target.abi_return_struct_as_int
            {
            d.insert(name.into(), target.abi_return_struct_as_int.to_json());
        }
    }
};target_option_val!(abi_return_struct_as_int);
344        {
    {
        let name = ("is_like_aix").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.is_like_aix != target.is_like_aix {
            d.insert(name.into(), target.is_like_aix.to_json());
        }
    }
};target_option_val!(is_like_aix);
345        {
    {
        let name = ("is_like_darwin").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.is_like_darwin != target.is_like_darwin {
            d.insert(name.into(), target.is_like_darwin.to_json());
        }
    }
};target_option_val!(is_like_darwin);
346        {
    {
        let name = ("is_like_solaris").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.is_like_solaris != target.is_like_solaris {
            d.insert(name.into(), target.is_like_solaris.to_json());
        }
    }
};target_option_val!(is_like_solaris);
347        {
    {
        let name = ("is_like_windows").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.is_like_windows != target.is_like_windows {
            d.insert(name.into(), target.is_like_windows.to_json());
        }
    }
};target_option_val!(is_like_windows);
348        {
    {
        let name = ("is_like_gpu").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.is_like_gpu != target.is_like_gpu {
            d.insert(name.into(), target.is_like_gpu.to_json());
        }
    }
};target_option_val!(is_like_gpu);
349        {
    {
        let name = ("is_like_msvc").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.is_like_msvc != target.is_like_msvc {
            d.insert(name.into(), target.is_like_msvc.to_json());
        }
    }
};target_option_val!(is_like_msvc);
350        {
    {
        let name = ("is_like_wasm").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.is_like_wasm != target.is_like_wasm {
            d.insert(name.into(), target.is_like_wasm.to_json());
        }
    }
};target_option_val!(is_like_wasm);
351        {
    {
        let name = ("is_like_android").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.is_like_android != target.is_like_android {
            d.insert(name.into(), target.is_like_android.to_json());
        }
    }
};target_option_val!(is_like_android);
352        {
    {
        let name = ("is_like_vexos").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.is_like_vexos != target.is_like_vexos {
            d.insert(name.into(), target.is_like_vexos.to_json());
        }
    }
};target_option_val!(is_like_vexos);
353        {
    {
        let name = ("binary_format").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.binary_format != target.binary_format {
            d.insert(name.into(), target.binary_format.to_json());
        }
    }
};target_option_val!(binary_format);
354        {
    {
        let name = ("default_dwarf_version").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.default_dwarf_version != target.default_dwarf_version {
            d.insert(name.into(), target.default_dwarf_version.to_json());
        }
    }
};target_option_val!(default_dwarf_version);
355        {
    {
        let name = ("allows_weak_linkage").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.allows_weak_linkage != target.allows_weak_linkage {
            d.insert(name.into(), target.allows_weak_linkage.to_json());
        }
    }
};target_option_val!(allows_weak_linkage);
356        {
    {
        let name = ("has_rpath").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.has_rpath != target.has_rpath {
            d.insert(name.into(), target.has_rpath.to_json());
        }
    }
};target_option_val!(has_rpath);
357        {
    {
        let name = ("no_default_libraries").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.no_default_libraries != target.no_default_libraries {
            d.insert(name.into(), target.no_default_libraries.to_json());
        }
    }
};target_option_val!(no_default_libraries);
358        {
    {
        let name = ("position_independent_executables").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.position_independent_executables !=
                target.position_independent_executables {
            d.insert(name.into(),
                target.position_independent_executables.to_json());
        }
    }
};target_option_val!(position_independent_executables);
359        {
    {
        let name =
            ("static_position_independent_executables").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.static_position_independent_executables !=
                target.static_position_independent_executables {
            d.insert(name.into(),
                target.static_position_independent_executables.to_json());
        }
    }
};target_option_val!(static_position_independent_executables);
360        {
    {
        let name = ("plt_by_default").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.plt_by_default != target.plt_by_default {
            d.insert(name.into(), target.plt_by_default.to_json());
        }
    }
};target_option_val!(plt_by_default);
361        {
    {
        let name = ("relro_level").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.relro_level != target.relro_level {
            d.insert(name.into(), target.relro_level.to_json());
        }
    }
};target_option_val!(relro_level);
362        {
    {
        let name = ("archive_format").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.archive_format != target.archive_format {
            d.insert(name.into(), target.archive_format.to_json());
        }
    }
};target_option_val!(archive_format);
363        {
    {
        let name = ("allow_asm").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.allow_asm != target.allow_asm {
            d.insert(name.into(), target.allow_asm.to_json());
        }
    }
};target_option_val!(allow_asm);
364        {
    {
        let name = ("static_initializer_must_be_acyclic").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.static_initializer_must_be_acyclic !=
                target.static_initializer_must_be_acyclic {
            d.insert(name.into(),
                target.static_initializer_must_be_acyclic.to_json());
        }
    }
};target_option_val!(static_initializer_must_be_acyclic);
365        {
    {
        let name = ("main_needs_argc_argv").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.main_needs_argc_argv != target.main_needs_argc_argv {
            d.insert(name.into(), target.main_needs_argc_argv.to_json());
        }
    }
};target_option_val!(main_needs_argc_argv);
366        {
    {
        let name = ("has_thread_local").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.has_thread_local != target.has_thread_local {
            d.insert(name.into(), target.has_thread_local.to_json());
        }
    }
};target_option_val!(has_thread_local);
367        {
    {
        let name = ("obj_is_bitcode").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.obj_is_bitcode != target.obj_is_bitcode {
            d.insert(name.into(), target.obj_is_bitcode.to_json());
        }
    }
};target_option_val!(obj_is_bitcode);
368        {
    {
        let name = ("min_atomic_width").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.min_atomic_width != target.min_atomic_width {
            d.insert(name.into(), target.min_atomic_width.to_json());
        }
    }
};target_option_val!(min_atomic_width);
369        {
    {
        let name = ("max_atomic_width").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.max_atomic_width != target.max_atomic_width {
            d.insert(name.into(), target.max_atomic_width.to_json());
        }
    }
};target_option_val!(max_atomic_width);
370        {
    {
        let name = ("atomic_cas").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.atomic_cas != target.atomic_cas {
            d.insert(name.into(), target.atomic_cas.to_json());
        }
    }
};target_option_val!(atomic_cas);
371        {
    {
        let name = ("panic_strategy").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.panic_strategy != target.panic_strategy {
            d.insert(name.into(), target.panic_strategy.to_json());
        }
    }
};target_option_val!(panic_strategy);
372        {
    {
        let name = ("crt_static_allows_dylibs").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.crt_static_allows_dylibs != target.crt_static_allows_dylibs
            {
            d.insert(name.into(), target.crt_static_allows_dylibs.to_json());
        }
    }
};target_option_val!(crt_static_allows_dylibs);
373        {
    {
        let name = ("crt_static_default").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.crt_static_default != target.crt_static_default {
            d.insert(name.into(), target.crt_static_default.to_json());
        }
    }
};target_option_val!(crt_static_default);
374        {
    {
        let name = ("crt_static_respected").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.crt_static_respected != target.crt_static_respected {
            d.insert(name.into(), target.crt_static_respected.to_json());
        }
    }
};target_option_val!(crt_static_respected);
375        {
    {
        let name = ("stack_probes").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.stack_probes != target.stack_probes {
            d.insert(name.into(), target.stack_probes.to_json());
        }
    }
};target_option_val!(stack_probes);
376        {
    {
        let name = ("min_global_align").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.min_global_align != target.min_global_align {
            d.insert(name.into(), target.min_global_align.to_json());
        }
    }
};target_option_val!(min_global_align);
377        {
    {
        let name = ("default_codegen_units").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.default_codegen_units != target.default_codegen_units {
            d.insert(name.into(), target.default_codegen_units.to_json());
        }
    }
};target_option_val!(default_codegen_units);
378        {
    {
        let name = ("default_codegen_backend").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.default_codegen_backend != target.default_codegen_backend {
            d.insert(name.into(), target.default_codegen_backend.to_json());
        }
    }
};target_option_val!(default_codegen_backend);
379        {
    {
        let name = ("trap_unreachable").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.trap_unreachable != target.trap_unreachable {
            d.insert(name.into(), target.trap_unreachable.to_json());
        }
    }
};target_option_val!(trap_unreachable);
380        {
    {
        let name = ("requires_lto").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.requires_lto != target.requires_lto {
            d.insert(name.into(), target.requires_lto.to_json());
        }
    }
};target_option_val!(requires_lto);
381        {
    {
        let name = ("singlethread").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.singlethread != target.singlethread {
            d.insert(name.into(), target.singlethread.to_json());
        }
    }
};target_option_val!(singlethread);
382        {
    {
        let name = ("no_builtins").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.no_builtins != target.no_builtins {
            d.insert(name.into(), target.no_builtins.to_json());
        }
    }
};target_option_val!(no_builtins);
383        {
    {
        let name = ("default_visibility").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.default_visibility != target.default_visibility {
            d.insert(name.into(), target.default_visibility.to_json());
        }
    }
};target_option_val!(default_visibility);
384        {
    {
        let name = ("emit_debug_gdb_scripts").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.emit_debug_gdb_scripts != target.emit_debug_gdb_scripts {
            d.insert(name.into(), target.emit_debug_gdb_scripts.to_json());
        }
    }
};target_option_val!(emit_debug_gdb_scripts);
385        {
    {
        let name = ("requires_uwtable").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.requires_uwtable != target.requires_uwtable {
            d.insert(name.into(), target.requires_uwtable.to_json());
        }
    }
};target_option_val!(requires_uwtable);
386        {
    {
        let name = ("default_uwtable").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.default_uwtable != target.default_uwtable {
            d.insert(name.into(), target.default_uwtable.to_json());
        }
    }
};target_option_val!(default_uwtable);
387        {
    {
        let name = ("simd_types_indirect").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.simd_types_indirect != target.simd_types_indirect {
            d.insert(name.into(), target.simd_types_indirect.to_json());
        }
    }
};target_option_val!(simd_types_indirect);
388        {
    {
        let name = ("limit_rdylib_exports").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.limit_rdylib_exports != target.limit_rdylib_exports {
            d.insert(name.into(), target.limit_rdylib_exports.to_json());
        }
    }
};target_option_val!(limit_rdylib_exports);
389        {
    {
        let name = ("override_export_symbols").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.override_export_symbols != target.override_export_symbols {
            d.insert(name.into(), target.override_export_symbols.to_json());
        }
    }
};target_option_val!(override_export_symbols);
390        {
    {
        let name = ("merge_functions").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.merge_functions != target.merge_functions {
            d.insert(name.into(), target.merge_functions.to_json());
        }
    }
};target_option_val!(merge_functions);
391        {
    let name = "target-mcount";

    #[allow(rustc :: bad_opt_access)]
    if default.mcount != target.mcount {
        d.insert(name.into(), target.mcount.to_json());
    }
};target_option_val!(mcount, "target-mcount");
392        {
    {
        let name = ("llvm_mcount_intrinsic").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.llvm_mcount_intrinsic != target.llvm_mcount_intrinsic {
            d.insert(name.into(), target.llvm_mcount_intrinsic.to_json());
        }
    }
};target_option_val!(llvm_mcount_intrinsic);
393        {
    {
        let name = ("llvm_abiname").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.llvm_abiname != target.llvm_abiname {
            d.insert(name.into(), target.llvm_abiname.to_json());
        }
    }
};target_option_val!(llvm_abiname);
394        {
    {
        let name = ("llvm_floatabi").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.llvm_floatabi != target.llvm_floatabi {
            d.insert(name.into(), target.llvm_floatabi.to_json());
        }
    }
};target_option_val!(llvm_floatabi);
395        {
    {
        let name = ("rustc_abi").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.rustc_abi != target.rustc_abi {
            d.insert(name.into(), target.rustc_abi.to_json());
        }
    }
};target_option_val!(rustc_abi);
396        {
    {
        let name = ("relax_elf_relocations").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.relax_elf_relocations != target.relax_elf_relocations {
            d.insert(name.into(), target.relax_elf_relocations.to_json());
        }
    }
};target_option_val!(relax_elf_relocations);
397        {
    {
        let name = ("llvm_args").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.llvm_args != target.llvm_args {
            d.insert(name.into(), target.llvm_args.to_json());
        }
    }
};target_option_val!(llvm_args);
398        {
    {
        let name = ("use_ctors_section").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.use_ctors_section != target.use_ctors_section {
            d.insert(name.into(), target.use_ctors_section.to_json());
        }
    }
};target_option_val!(use_ctors_section);
399        {
    {
        let name = ("eh_frame_header").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.eh_frame_header != target.eh_frame_header {
            d.insert(name.into(), target.eh_frame_header.to_json());
        }
    }
};target_option_val!(eh_frame_header);
400        {
    {
        let name = ("has_thumb_interworking").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.has_thumb_interworking != target.has_thumb_interworking {
            d.insert(name.into(), target.has_thumb_interworking.to_json());
        }
    }
};target_option_val!(has_thumb_interworking);
401        {
    {
        let name = ("debuginfo_kind").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.debuginfo_kind != target.debuginfo_kind {
            d.insert(name.into(), target.debuginfo_kind.to_json());
        }
    }
};target_option_val!(debuginfo_kind);
402        {
    {
        let name = ("split_debuginfo").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.split_debuginfo != target.split_debuginfo {
            d.insert(name.into(), target.split_debuginfo.to_json());
        }
    }
};target_option_val!(split_debuginfo);
403        {
    {
        let name = ("supported_split_debuginfo").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.supported_split_debuginfo !=
                target.supported_split_debuginfo {
            d.insert(name.into(), target.supported_split_debuginfo.to_json());
        }
    }
};target_option_val!(supported_split_debuginfo);
404        {
    {
        let name = ("supported_sanitizers").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.supported_sanitizers != target.supported_sanitizers {
            d.insert(name.into(), target.supported_sanitizers.to_json());
        }
    }
};target_option_val!(supported_sanitizers);
405        {
    {
        let name = ("default_sanitizers").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.default_sanitizers != target.default_sanitizers {
            d.insert(name.into(), target.default_sanitizers.to_json());
        }
    }
};target_option_val!(default_sanitizers);
406        {
    {
        let name = ("c_enum_min_bits").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.c_enum_min_bits != target.c_enum_min_bits {
            d.insert(name.into(), target.c_enum_min_bits.to_json());
        }
    }
};target_option_val!(c_enum_min_bits);
407        {
    {
        let name = ("generate_arange_section").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.generate_arange_section != target.generate_arange_section {
            d.insert(name.into(), target.generate_arange_section.to_json());
        }
    }
};target_option_val!(generate_arange_section);
408        {
    {
        let name = ("supports_stack_protector").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.supports_stack_protector != target.supports_stack_protector
            {
            d.insert(name.into(), target.supports_stack_protector.to_json());
        }
    }
};target_option_val!(supports_stack_protector);
409        {
    {
        let name = ("small_data_threshold_support").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.small_data_threshold_support !=
                target.small_data_threshold_support {
            d.insert(name.into(),
                target.small_data_threshold_support.to_json());
        }
    }
};target_option_val!(small_data_threshold_support);
410        {
    {
        let name = ("entry_name").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.entry_name != target.entry_name {
            d.insert(name.into(), target.entry_name.to_json());
        }
    }
};target_option_val!(entry_name);
411        {
    {
        let name = ("entry_abi").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.entry_abi != target.entry_abi {
            d.insert(name.into(), target.entry_abi.to_json());
        }
    }
};target_option_val!(entry_abi);
412        {
    {
        let name = ("supports_xray").replace("_", "-");

        #[allow(rustc :: bad_opt_access)]
        if default.supports_xray != target.supports_xray {
            d.insert(name.into(), target.supports_xray.to_json());
        }
    }
};target_option_val!(supports_xray);
413
414        // Serializing `-Clink-self-contained` needs a dynamic key to support the
415        // backwards-compatible variants.
416        d.insert(self.link_self_contained.json_key().into(), self.link_self_contained.to_json());
417
418        Json::Object(d)
419    }
420}
421
422#[derive(#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications,
clippy :: absolute_paths,)]
const _: () =
    {
        #[allow(unused_extern_crates, clippy :: useless_attribute)]
        extern crate serde as _serde;
        ;
        #[automatically_derived]
        impl<'de> _serde::Deserialize<'de> for
            LinkSelfContainedComponentsWrapper {
            fn deserialize<__D>(__deserializer: __D)
                -> _serde::__private228::Result<Self, __D::Error> where
                __D: _serde::Deserializer<'de> {
                #[allow(non_camel_case_types)]
                #[doc(hidden)]
                enum __Field { __field0, __ignore, }
                #[doc(hidden)]
                struct __FieldVisitor;
                #[automatically_derived]
                impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
                    type Value = __Field;
                    fn expecting(&self,
                        __formatter: &mut _serde::__private228::Formatter)
                        -> _serde::__private228::fmt::Result {
                        _serde::__private228::Formatter::write_str(__formatter,
                            "field identifier")
                    }
                    fn visit_u64<__E>(self, __value: u64)
                        -> _serde::__private228::Result<Self::Value, __E> where
                        __E: _serde::de::Error {
                        match __value {
                            0u64 => _serde::__private228::Ok(__Field::__field0),
                            _ => _serde::__private228::Ok(__Field::__ignore),
                        }
                    }
                    fn visit_str<__E>(self, __value: &str)
                        -> _serde::__private228::Result<Self::Value, __E> where
                        __E: _serde::de::Error {
                        match __value {
                            "components" => _serde::__private228::Ok(__Field::__field0),
                            _ => { _serde::__private228::Ok(__Field::__ignore) }
                        }
                    }
                    fn visit_bytes<__E>(self, __value: &[u8])
                        -> _serde::__private228::Result<Self::Value, __E> where
                        __E: _serde::de::Error {
                        match __value {
                            b"components" =>
                                _serde::__private228::Ok(__Field::__field0),
                            _ => { _serde::__private228::Ok(__Field::__ignore) }
                        }
                    }
                }
                #[automatically_derived]
                impl<'de> _serde::Deserialize<'de> for __Field {
                    #[inline]
                    fn deserialize<__D>(__deserializer: __D)
                        -> _serde::__private228::Result<Self, __D::Error> where
                        __D: _serde::Deserializer<'de> {
                        _serde::Deserializer::deserialize_identifier(__deserializer,
                            __FieldVisitor)
                    }
                }
                #[doc(hidden)]
                struct __Visitor<'de> {
                    marker: _serde::__private228::PhantomData<LinkSelfContainedComponentsWrapper>,
                    lifetime: _serde::__private228::PhantomData<&'de ()>,
                }
                #[automatically_derived]
                impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                    type Value = LinkSelfContainedComponentsWrapper;
                    fn expecting(&self,
                        __formatter: &mut _serde::__private228::Formatter)
                        -> _serde::__private228::fmt::Result {
                        _serde::__private228::Formatter::write_str(__formatter,
                            "struct LinkSelfContainedComponentsWrapper")
                    }
                    #[inline]
                    fn visit_seq<__A>(self, mut __seq: __A)
                        -> _serde::__private228::Result<Self::Value, __A::Error>
                        where __A: _serde::de::SeqAccess<'de> {
                        let __field0 =
                            match _serde::de::SeqAccess::next_element::<Vec<LinkSelfContainedComponents>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(0usize,
                                                &"struct LinkSelfContainedComponentsWrapper with 1 element")),
                            };
                        _serde::__private228::Ok(LinkSelfContainedComponentsWrapper {
                                components: __field0,
                            })
                    }
                    #[inline]
                    fn visit_map<__A>(self, mut __map: __A)
                        -> _serde::__private228::Result<Self::Value, __A::Error>
                        where __A: _serde::de::MapAccess<'de> {
                        let mut __field0:
                                _serde::__private228::Option<Vec<LinkSelfContainedComponents>> =
                            _serde::__private228::None;
                        while let _serde::__private228::Some(__key) =
                                _serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                            match __key {
                                __Field::__field0 => {
                                    if _serde::__private228::Option::is_some(&__field0) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("components"));
                                    }
                                    __field0 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Vec<LinkSelfContainedComponents>>(&mut __map)?);
                                }
                                _ => {
                                    let _ =
                                        _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)?;
                                }
                            }
                        }
                        let __field0 =
                            match __field0 {
                                _serde::__private228::Some(__field0) => __field0,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("components")?,
                            };
                        _serde::__private228::Ok(LinkSelfContainedComponentsWrapper {
                                components: __field0,
                            })
                    }
                }
                #[doc(hidden)]
                const FIELDS: &'static [&'static str] = &["components"];
                _serde::Deserializer::deserialize_struct(__deserializer,
                    "LinkSelfContainedComponentsWrapper", FIELDS,
                    __Visitor {
                        marker: _serde::__private228::PhantomData::<LinkSelfContainedComponentsWrapper>,
                        lifetime: _serde::__private228::PhantomData,
                    })
            }
        }
    };serde_derive::Deserialize, const _: () =
    {
        #[automatically_derived]
        #[allow(unused_braces)]
        impl schemars::JsonSchema for LinkSelfContainedComponentsWrapper {
            fn schema_name()
                -> schemars::_private::alloc::borrow::Cow<'static, str> {
                schemars::_private::alloc::borrow::Cow::Borrowed("LinkSelfContainedComponentsWrapper")
            }
            fn schema_id()
                -> schemars::_private::alloc::borrow::Cow<'static, str> {
                schemars::_private::alloc::borrow::Cow::Borrowed("rustc_target::spec::json::LinkSelfContainedComponentsWrapper")
            }
            fn json_schema(generator: &mut schemars::SchemaGenerator)
                -> schemars::Schema {
                {
                    let mut schema =
                        <::schemars::Schema as
                                    ::core::convert::TryFrom<_>>::try_from(::serde_json::Value::Object({
                                        let mut object = ::serde_json::Map::new();
                                        let _ =
                                            object.insert(("type").into(),
                                                ::serde_json::to_value(&"object").unwrap());
                                        ;
                                        object
                                    })).unwrap();
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "components",
                            generator.contract().is_deserialize() &&
                                <Vec<LinkSelfContainedComponents> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            {
                                generator.subschema_for::<Vec<LinkSelfContainedComponents>>()
                            });
                    }
                    schema
                }
            }
            fn inline_schema() -> bool { false }
        }
        ;
    };schemars::JsonSchema)]
423struct LinkSelfContainedComponentsWrapper {
424    components: Vec<LinkSelfContainedComponents>,
425}
426
427#[derive(#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications,
clippy :: absolute_paths,)]
const _: () =
    {
        #[allow(unused_extern_crates, clippy :: useless_attribute)]
        extern crate serde as _serde;
        ;
        #[automatically_derived]
        impl<'de> _serde::Deserialize<'de> for TargetFamiliesJson {
            fn deserialize<__D>(__deserializer: __D)
                -> _serde::__private228::Result<Self, __D::Error> where
                __D: _serde::Deserializer<'de> {
                let __content =
                    _serde::de::DeserializeSeed::deserialize(_serde::__private228::de::ContentVisitor::new(),
                            __deserializer)?;
                let __deserializer =
                    _serde::__private228::de::ContentRefDeserializer::<__D::Error>::new(&__content);
                if let _serde::__private228::Ok(__ok) =
                        _serde::__private228::Result::map(<StaticCow<[StaticCow<str>]>
                                    as _serde::Deserialize>::deserialize(__deserializer),
                            TargetFamiliesJson::Array) {
                    return _serde::__private228::Ok(__ok);
                }
                if let _serde::__private228::Ok(__ok) =
                        _serde::__private228::Result::map(<StaticCow<str> as
                                    _serde::Deserialize>::deserialize(__deserializer),
                            TargetFamiliesJson::String) {
                    return _serde::__private228::Ok(__ok);
                }
                _serde::__private228::Err(_serde::de::Error::custom("data did not match any variant of untagged enum TargetFamiliesJson"))
            }
        }
    };serde_derive::Deserialize, const _: () =
    {
        #[automatically_derived]
        #[allow(unused_braces)]
        impl schemars::JsonSchema for TargetFamiliesJson {
            fn schema_name()
                -> schemars::_private::alloc::borrow::Cow<'static, str> {
                schemars::_private::alloc::borrow::Cow::Borrowed("TargetFamiliesJson")
            }
            fn schema_id()
                -> schemars::_private::alloc::borrow::Cow<'static, str> {
                schemars::_private::alloc::borrow::Cow::Borrowed("rustc_target::spec::json::TargetFamiliesJson")
            }
            fn json_schema(generator: &mut schemars::SchemaGenerator)
                -> schemars::Schema {
                {
                    {
                        let mut map = schemars::_private::serde_json::Map::new();
                        map.insert("anyOf".into(),
                            schemars::_private::serde_json::Value::Array({
                                    let mut enum_values =
                                        schemars::_private::alloc::vec::Vec::new();
                                    enum_values.push({
                                                let mut schema =
                                                    generator.subschema_for::<StaticCow<[StaticCow<str>]>>();
                                                if generator.settings().untagged_enum_variant_titles {
                                                    schema.insert("title".into(), "Array".into());
                                                }
                                                schema
                                            }.to_value());
                                    enum_values.push({
                                                let mut schema =
                                                    generator.subschema_for::<StaticCow<str>>();
                                                if generator.settings().untagged_enum_variant_titles {
                                                    schema.insert("title".into(), "String".into());
                                                }
                                                schema
                                            }.to_value());
                                    enum_values
                                }));
                        schemars::Schema::from(map)
                    }
                }
            }
            fn inline_schema() -> bool { false }
        }
        ;
    };schemars::JsonSchema)]
428#[serde(untagged)]
429enum TargetFamiliesJson {
430    Array(StaticCow<[StaticCow<str>]>),
431    String(StaticCow<str>),
432}
433
434/// `Endian` is in `rustc_abi`, which doesn't have access to the macro and serde.
435struct EndianWrapper(rustc_abi::Endian);
436impl FromStr for EndianWrapper {
437    type Err = String;
438    fn from_str(s: &str) -> Result<Self, Self::Err> {
439        rustc_abi::Endian::from_str(s).map(Self)
440    }
441}
442impl<'de> serde::Deserialize<'de> for EndianWrapper {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
        D: serde::Deserializer<'de> {
        let s = String::deserialize(deserializer)?;
        FromStr::from_str(&s).map_err(serde::de::Error::custom)
    }
}crate::json::serde_deserialize_from_str!(EndianWrapper);
443impl schemars::JsonSchema for EndianWrapper {
444    fn schema_name() -> std::borrow::Cow<'static, str> {
445        "Endian".into()
446    }
447    fn json_schema(_: &mut schemars::SchemaGenerator) -> schemars::Schema {
448        <::schemars::Schema as
            ::core::convert::TryFrom<_>>::try_from(::serde_json::Value::Object({
                let mut object = ::serde_json::Map::new();
                let _ =
                    object.insert(("type").into(),
                        ::serde_json::to_value(&"string").unwrap());
                let _ =
                    object.insert(("enum").into(),
                        ::serde_json::Value::Array(<[_]>::into_vec(::alloc::boxed::box_new([::serde_json::to_value(&"big").unwrap(),
                                            ::serde_json::to_value(&"little").unwrap()]))));
                object
            })).unwrap()schemars::json_schema! ({
449            "type": "string",
450            "enum": ["big", "little"]
451        })
452        .into()
453    }
454}
455
456/// `ExternAbi` is in `rustc_abi`, which doesn't have access to the macro and serde.
457struct ExternAbiWrapper(rustc_abi::ExternAbi);
458impl FromStr for ExternAbiWrapper {
459    type Err = String;
460    fn from_str(s: &str) -> Result<Self, Self::Err> {
461        rustc_abi::ExternAbi::from_str(s)
462            .map(Self)
463            .map_err(|_| ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0} is not a valid extern ABI", s))
    })format!("{s} is not a valid extern ABI"))
464    }
465}
466impl<'de> serde::Deserialize<'de> for ExternAbiWrapper {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
        D: serde::Deserializer<'de> {
        let s = String::deserialize(deserializer)?;
        FromStr::from_str(&s).map_err(serde::de::Error::custom)
    }
}crate::json::serde_deserialize_from_str!(ExternAbiWrapper);
467impl schemars::JsonSchema for ExternAbiWrapper {
468    fn schema_name() -> std::borrow::Cow<'static, str> {
469        "ExternAbi".into()
470    }
471    fn json_schema(_: &mut schemars::SchemaGenerator) -> schemars::Schema {
472        let all =
473            rustc_abi::ExternAbi::ALL_VARIANTS.iter().map(|abi| abi.as_str()).collect::<Vec<_>>();
474        <::schemars::Schema as
            ::core::convert::TryFrom<_>>::try_from(::serde_json::Value::Object({
                let mut object = ::serde_json::Map::new();
                let _ =
                    object.insert(("type").into(),
                        ::serde_json::to_value(&"string").unwrap());
                let _ =
                    object.insert(("enum").into(),
                        ::serde_json::to_value(&all).unwrap());
                ;
                object
            })).unwrap()schemars::json_schema! ({
475            "type": "string",
476            "enum": all,
477        })
478        .into()
479    }
480}
481
482#[derive(#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications,
clippy :: absolute_paths,)]
const _: () =
    {
        #[allow(unused_extern_crates, clippy :: useless_attribute)]
        extern crate serde as _serde;
        ;
        #[automatically_derived]
        impl<'de> _serde::Deserialize<'de> for TargetSpecJsonMetadata {
            fn deserialize<__D>(__deserializer: __D)
                -> _serde::__private228::Result<Self, __D::Error> where
                __D: _serde::Deserializer<'de> {
                #[allow(non_camel_case_types)]
                #[doc(hidden)]
                enum __Field {
                    __field0,
                    __field1,
                    __field2,
                    __field3,
                    __ignore,
                }
                #[doc(hidden)]
                struct __FieldVisitor;
                #[automatically_derived]
                impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
                    type Value = __Field;
                    fn expecting(&self,
                        __formatter: &mut _serde::__private228::Formatter)
                        -> _serde::__private228::fmt::Result {
                        _serde::__private228::Formatter::write_str(__formatter,
                            "field identifier")
                    }
                    fn visit_u64<__E>(self, __value: u64)
                        -> _serde::__private228::Result<Self::Value, __E> where
                        __E: _serde::de::Error {
                        match __value {
                            0u64 => _serde::__private228::Ok(__Field::__field0),
                            1u64 => _serde::__private228::Ok(__Field::__field1),
                            2u64 => _serde::__private228::Ok(__Field::__field2),
                            3u64 => _serde::__private228::Ok(__Field::__field3),
                            _ => _serde::__private228::Ok(__Field::__ignore),
                        }
                    }
                    fn visit_str<__E>(self, __value: &str)
                        -> _serde::__private228::Result<Self::Value, __E> where
                        __E: _serde::de::Error {
                        match __value {
                            "description" =>
                                _serde::__private228::Ok(__Field::__field0),
                            "tier" => _serde::__private228::Ok(__Field::__field1),
                            "host_tools" => _serde::__private228::Ok(__Field::__field2),
                            "std" => _serde::__private228::Ok(__Field::__field3),
                            _ => { _serde::__private228::Ok(__Field::__ignore) }
                        }
                    }
                    fn visit_bytes<__E>(self, __value: &[u8])
                        -> _serde::__private228::Result<Self::Value, __E> where
                        __E: _serde::de::Error {
                        match __value {
                            b"description" =>
                                _serde::__private228::Ok(__Field::__field0),
                            b"tier" => _serde::__private228::Ok(__Field::__field1),
                            b"host_tools" =>
                                _serde::__private228::Ok(__Field::__field2),
                            b"std" => _serde::__private228::Ok(__Field::__field3),
                            _ => { _serde::__private228::Ok(__Field::__ignore) }
                        }
                    }
                }
                #[automatically_derived]
                impl<'de> _serde::Deserialize<'de> for __Field {
                    #[inline]
                    fn deserialize<__D>(__deserializer: __D)
                        -> _serde::__private228::Result<Self, __D::Error> where
                        __D: _serde::Deserializer<'de> {
                        _serde::Deserializer::deserialize_identifier(__deserializer,
                            __FieldVisitor)
                    }
                }
                #[doc(hidden)]
                struct __Visitor<'de> {
                    marker: _serde::__private228::PhantomData<TargetSpecJsonMetadata>,
                    lifetime: _serde::__private228::PhantomData<&'de ()>,
                }
                #[automatically_derived]
                impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                    type Value = TargetSpecJsonMetadata;
                    fn expecting(&self,
                        __formatter: &mut _serde::__private228::Formatter)
                        -> _serde::__private228::fmt::Result {
                        _serde::__private228::Formatter::write_str(__formatter,
                            "struct TargetSpecJsonMetadata")
                    }
                    #[inline]
                    fn visit_seq<__A>(self, mut __seq: __A)
                        -> _serde::__private228::Result<Self::Value, __A::Error>
                        where __A: _serde::de::SeqAccess<'de> {
                        let __field0 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<str>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(0usize,
                                                &"struct TargetSpecJsonMetadata with 4 elements")),
                            };
                        let __field1 =
                            match _serde::de::SeqAccess::next_element::<Option<u64>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(1usize,
                                                &"struct TargetSpecJsonMetadata with 4 elements")),
                            };
                        let __field2 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(2usize,
                                                &"struct TargetSpecJsonMetadata with 4 elements")),
                            };
                        let __field3 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(3usize,
                                                &"struct TargetSpecJsonMetadata with 4 elements")),
                            };
                        _serde::__private228::Ok(TargetSpecJsonMetadata {
                                description: __field0,
                                tier: __field1,
                                host_tools: __field2,
                                std: __field3,
                            })
                    }
                    #[inline]
                    fn visit_map<__A>(self, mut __map: __A)
                        -> _serde::__private228::Result<Self::Value, __A::Error>
                        where __A: _serde::de::MapAccess<'de> {
                        let mut __field0:
                                _serde::__private228::Option<Option<StaticCow<str>>> =
                            _serde::__private228::None;
                        let mut __field1:
                                _serde::__private228::Option<Option<u64>> =
                            _serde::__private228::None;
                        let mut __field2:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field3:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        while let _serde::__private228::Some(__key) =
                                _serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                            match __key {
                                __Field::__field0 => {
                                    if _serde::__private228::Option::is_some(&__field0) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("description"));
                                    }
                                    __field0 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<str>>>(&mut __map)?);
                                }
                                __Field::__field1 => {
                                    if _serde::__private228::Option::is_some(&__field1) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("tier"));
                                    }
                                    __field1 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<u64>>(&mut __map)?);
                                }
                                __Field::__field2 => {
                                    if _serde::__private228::Option::is_some(&__field2) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("host_tools"));
                                    }
                                    __field2 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field3 => {
                                    if _serde::__private228::Option::is_some(&__field3) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("std"));
                                    }
                                    __field3 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                _ => {
                                    let _ =
                                        _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)?;
                                }
                            }
                        }
                        let __field0 =
                            match __field0 {
                                _serde::__private228::Some(__field0) => __field0,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("description")?,
                            };
                        let __field1 =
                            match __field1 {
                                _serde::__private228::Some(__field1) => __field1,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("tier")?,
                            };
                        let __field2 =
                            match __field2 {
                                _serde::__private228::Some(__field2) => __field2,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("host_tools")?,
                            };
                        let __field3 =
                            match __field3 {
                                _serde::__private228::Some(__field3) => __field3,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("std")?,
                            };
                        _serde::__private228::Ok(TargetSpecJsonMetadata {
                                description: __field0,
                                tier: __field1,
                                host_tools: __field2,
                                std: __field3,
                            })
                    }
                }
                #[doc(hidden)]
                const FIELDS: &'static [&'static str] =
                    &["description", "tier", "host_tools", "std"];
                _serde::Deserializer::deserialize_struct(__deserializer,
                    "TargetSpecJsonMetadata", FIELDS,
                    __Visitor {
                        marker: _serde::__private228::PhantomData::<TargetSpecJsonMetadata>,
                        lifetime: _serde::__private228::PhantomData,
                    })
            }
        }
    };serde_derive::Deserialize, const _: () =
    {
        #[automatically_derived]
        #[allow(unused_braces)]
        impl schemars::JsonSchema for TargetSpecJsonMetadata {
            fn schema_name()
                -> schemars::_private::alloc::borrow::Cow<'static, str> {
                schemars::_private::alloc::borrow::Cow::Borrowed("TargetSpecJsonMetadata")
            }
            fn schema_id()
                -> schemars::_private::alloc::borrow::Cow<'static, str> {
                schemars::_private::alloc::borrow::Cow::Borrowed("rustc_target::spec::json::TargetSpecJsonMetadata")
            }
            fn json_schema(generator: &mut schemars::SchemaGenerator)
                -> schemars::Schema {
                {
                    let mut schema =
                        <::schemars::Schema as
                                    ::core::convert::TryFrom<_>>::try_from(::serde_json::Value::Object({
                                        let mut object = ::serde_json::Map::new();
                                        let _ =
                                            object.insert(("type").into(),
                                                ::serde_json::to_value(&"object").unwrap());
                                        ;
                                        object
                                    })).unwrap();
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "description",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<str>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<StaticCow<str>>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "tier",
                            generator.contract().is_deserialize() &&
                                <Option<u64> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<u64>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "host_tools",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "std",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    schema
                }
            }
            fn inline_schema() -> bool { false }
        }
        ;
    };schemars::JsonSchema)]
483struct TargetSpecJsonMetadata {
484    description: Option<StaticCow<str>>,
485    tier: Option<u64>,
486    host_tools: Option<bool>,
487    std: Option<bool>,
488}
489
490#[derive(#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications,
clippy :: absolute_paths,)]
const _: () =
    {
        #[allow(unused_extern_crates, clippy :: useless_attribute)]
        extern crate serde as _serde;
        ;
        #[automatically_derived]
        impl<'de> _serde::Deserialize<'de> for TargetSpecJson {
            fn deserialize<__D>(__deserializer: __D)
                -> _serde::__private228::Result<Self, __D::Error> where
                __D: _serde::Deserializer<'de> {
                #[allow(non_camel_case_types)]
                #[doc(hidden)]
                enum __Field {
                    __field0,
                    __field1,
                    __field2,
                    __field3,
                    __field4,
                    __field5,
                    __field6,
                    __field7,
                    __field8,
                    __field9,
                    __field10,
                    __field11,
                    __field12,
                    __field13,
                    __field14,
                    __field15,
                    __field16,
                    __field17,
                    __field18,
                    __field19,
                    __field20,
                    __field21,
                    __field22,
                    __field23,
                    __field24,
                    __field25,
                    __field26,
                    __field27,
                    __field28,
                    __field29,
                    __field30,
                    __field31,
                    __field32,
                    __field33,
                    __field34,
                    __field35,
                    __field36,
                    __field37,
                    __field38,
                    __field39,
                    __field40,
                    __field41,
                    __field42,
                    __field43,
                    __field44,
                    __field45,
                    __field46,
                    __field47,
                    __field48,
                    __field49,
                    __field50,
                    __field51,
                    __field52,
                    __field53,
                    __field54,
                    __field55,
                    __field56,
                    __field57,
                    __field58,
                    __field59,
                    __field60,
                    __field61,
                    __field62,
                    __field63,
                    __field64,
                    __field65,
                    __field66,
                    __field67,
                    __field68,
                    __field69,
                    __field70,
                    __field71,
                    __field72,
                    __field73,
                    __field74,
                    __field75,
                    __field76,
                    __field77,
                    __field78,
                    __field79,
                    __field80,
                    __field81,
                    __field82,
                    __field83,
                    __field84,
                    __field85,
                    __field86,
                    __field87,
                    __field88,
                    __field89,
                    __field90,
                    __field91,
                    __field92,
                    __field93,
                    __field94,
                    __field95,
                    __field96,
                    __field97,
                    __field98,
                    __field99,
                    __field100,
                    __field101,
                    __field102,
                    __field103,
                    __field104,
                    __field105,
                    __field106,
                    __field107,
                    __field108,
                    __field109,
                    __field110,
                    __field111,
                    __field112,
                    __field113,
                    __field114,
                    __field115,
                    __field116,
                    __field117,
                    __field118,
                    __field119,
                }
                #[doc(hidden)]
                struct __FieldVisitor;
                #[automatically_derived]
                impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
                    type Value = __Field;
                    fn expecting(&self,
                        __formatter: &mut _serde::__private228::Formatter)
                        -> _serde::__private228::fmt::Result {
                        _serde::__private228::Formatter::write_str(__formatter,
                            "field identifier")
                    }
                    fn visit_u64<__E>(self, __value: u64)
                        -> _serde::__private228::Result<Self::Value, __E> where
                        __E: _serde::de::Error {
                        match __value {
                            0u64 => _serde::__private228::Ok(__Field::__field0),
                            1u64 => _serde::__private228::Ok(__Field::__field1),
                            2u64 => _serde::__private228::Ok(__Field::__field2),
                            3u64 => _serde::__private228::Ok(__Field::__field3),
                            4u64 => _serde::__private228::Ok(__Field::__field4),
                            5u64 => _serde::__private228::Ok(__Field::__field5),
                            6u64 => _serde::__private228::Ok(__Field::__field6),
                            7u64 => _serde::__private228::Ok(__Field::__field7),
                            8u64 => _serde::__private228::Ok(__Field::__field8),
                            9u64 => _serde::__private228::Ok(__Field::__field9),
                            10u64 => _serde::__private228::Ok(__Field::__field10),
                            11u64 => _serde::__private228::Ok(__Field::__field11),
                            12u64 => _serde::__private228::Ok(__Field::__field12),
                            13u64 => _serde::__private228::Ok(__Field::__field13),
                            14u64 => _serde::__private228::Ok(__Field::__field14),
                            15u64 => _serde::__private228::Ok(__Field::__field15),
                            16u64 => _serde::__private228::Ok(__Field::__field16),
                            17u64 => _serde::__private228::Ok(__Field::__field17),
                            18u64 => _serde::__private228::Ok(__Field::__field18),
                            19u64 => _serde::__private228::Ok(__Field::__field19),
                            20u64 => _serde::__private228::Ok(__Field::__field20),
                            21u64 => _serde::__private228::Ok(__Field::__field21),
                            22u64 => _serde::__private228::Ok(__Field::__field22),
                            23u64 => _serde::__private228::Ok(__Field::__field23),
                            24u64 => _serde::__private228::Ok(__Field::__field24),
                            25u64 => _serde::__private228::Ok(__Field::__field25),
                            26u64 => _serde::__private228::Ok(__Field::__field26),
                            27u64 => _serde::__private228::Ok(__Field::__field27),
                            28u64 => _serde::__private228::Ok(__Field::__field28),
                            29u64 => _serde::__private228::Ok(__Field::__field29),
                            30u64 => _serde::__private228::Ok(__Field::__field30),
                            31u64 => _serde::__private228::Ok(__Field::__field31),
                            32u64 => _serde::__private228::Ok(__Field::__field32),
                            33u64 => _serde::__private228::Ok(__Field::__field33),
                            34u64 => _serde::__private228::Ok(__Field::__field34),
                            35u64 => _serde::__private228::Ok(__Field::__field35),
                            36u64 => _serde::__private228::Ok(__Field::__field36),
                            37u64 => _serde::__private228::Ok(__Field::__field37),
                            38u64 => _serde::__private228::Ok(__Field::__field38),
                            39u64 => _serde::__private228::Ok(__Field::__field39),
                            40u64 => _serde::__private228::Ok(__Field::__field40),
                            41u64 => _serde::__private228::Ok(__Field::__field41),
                            42u64 => _serde::__private228::Ok(__Field::__field42),
                            43u64 => _serde::__private228::Ok(__Field::__field43),
                            44u64 => _serde::__private228::Ok(__Field::__field44),
                            45u64 => _serde::__private228::Ok(__Field::__field45),
                            46u64 => _serde::__private228::Ok(__Field::__field46),
                            47u64 => _serde::__private228::Ok(__Field::__field47),
                            48u64 => _serde::__private228::Ok(__Field::__field48),
                            49u64 => _serde::__private228::Ok(__Field::__field49),
                            50u64 => _serde::__private228::Ok(__Field::__field50),
                            51u64 => _serde::__private228::Ok(__Field::__field51),
                            52u64 => _serde::__private228::Ok(__Field::__field52),
                            53u64 => _serde::__private228::Ok(__Field::__field53),
                            54u64 => _serde::__private228::Ok(__Field::__field54),
                            55u64 => _serde::__private228::Ok(__Field::__field55),
                            56u64 => _serde::__private228::Ok(__Field::__field56),
                            57u64 => _serde::__private228::Ok(__Field::__field57),
                            58u64 => _serde::__private228::Ok(__Field::__field58),
                            59u64 => _serde::__private228::Ok(__Field::__field59),
                            60u64 => _serde::__private228::Ok(__Field::__field60),
                            61u64 => _serde::__private228::Ok(__Field::__field61),
                            62u64 => _serde::__private228::Ok(__Field::__field62),
                            63u64 => _serde::__private228::Ok(__Field::__field63),
                            64u64 => _serde::__private228::Ok(__Field::__field64),
                            65u64 => _serde::__private228::Ok(__Field::__field65),
                            66u64 => _serde::__private228::Ok(__Field::__field66),
                            67u64 => _serde::__private228::Ok(__Field::__field67),
                            68u64 => _serde::__private228::Ok(__Field::__field68),
                            69u64 => _serde::__private228::Ok(__Field::__field69),
                            70u64 => _serde::__private228::Ok(__Field::__field70),
                            71u64 => _serde::__private228::Ok(__Field::__field71),
                            72u64 => _serde::__private228::Ok(__Field::__field72),
                            73u64 => _serde::__private228::Ok(__Field::__field73),
                            74u64 => _serde::__private228::Ok(__Field::__field74),
                            75u64 => _serde::__private228::Ok(__Field::__field75),
                            76u64 => _serde::__private228::Ok(__Field::__field76),
                            77u64 => _serde::__private228::Ok(__Field::__field77),
                            78u64 => _serde::__private228::Ok(__Field::__field78),
                            79u64 => _serde::__private228::Ok(__Field::__field79),
                            80u64 => _serde::__private228::Ok(__Field::__field80),
                            81u64 => _serde::__private228::Ok(__Field::__field81),
                            82u64 => _serde::__private228::Ok(__Field::__field82),
                            83u64 => _serde::__private228::Ok(__Field::__field83),
                            84u64 => _serde::__private228::Ok(__Field::__field84),
                            85u64 => _serde::__private228::Ok(__Field::__field85),
                            86u64 => _serde::__private228::Ok(__Field::__field86),
                            87u64 => _serde::__private228::Ok(__Field::__field87),
                            88u64 => _serde::__private228::Ok(__Field::__field88),
                            89u64 => _serde::__private228::Ok(__Field::__field89),
                            90u64 => _serde::__private228::Ok(__Field::__field90),
                            91u64 => _serde::__private228::Ok(__Field::__field91),
                            92u64 => _serde::__private228::Ok(__Field::__field92),
                            93u64 => _serde::__private228::Ok(__Field::__field93),
                            94u64 => _serde::__private228::Ok(__Field::__field94),
                            95u64 => _serde::__private228::Ok(__Field::__field95),
                            96u64 => _serde::__private228::Ok(__Field::__field96),
                            97u64 => _serde::__private228::Ok(__Field::__field97),
                            98u64 => _serde::__private228::Ok(__Field::__field98),
                            99u64 => _serde::__private228::Ok(__Field::__field99),
                            100u64 => _serde::__private228::Ok(__Field::__field100),
                            101u64 => _serde::__private228::Ok(__Field::__field101),
                            102u64 => _serde::__private228::Ok(__Field::__field102),
                            103u64 => _serde::__private228::Ok(__Field::__field103),
                            104u64 => _serde::__private228::Ok(__Field::__field104),
                            105u64 => _serde::__private228::Ok(__Field::__field105),
                            106u64 => _serde::__private228::Ok(__Field::__field106),
                            107u64 => _serde::__private228::Ok(__Field::__field107),
                            108u64 => _serde::__private228::Ok(__Field::__field108),
                            109u64 => _serde::__private228::Ok(__Field::__field109),
                            110u64 => _serde::__private228::Ok(__Field::__field110),
                            111u64 => _serde::__private228::Ok(__Field::__field111),
                            112u64 => _serde::__private228::Ok(__Field::__field112),
                            113u64 => _serde::__private228::Ok(__Field::__field113),
                            114u64 => _serde::__private228::Ok(__Field::__field114),
                            115u64 => _serde::__private228::Ok(__Field::__field115),
                            116u64 => _serde::__private228::Ok(__Field::__field116),
                            117u64 => _serde::__private228::Ok(__Field::__field117),
                            118u64 => _serde::__private228::Ok(__Field::__field118),
                            119u64 => _serde::__private228::Ok(__Field::__field119),
                            _ =>
                                _serde::__private228::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
                                        &"field index 0 <= i < 120")),
                        }
                    }
                    fn visit_str<__E>(self, __value: &str)
                        -> _serde::__private228::Result<Self::Value, __E> where
                        __E: _serde::de::Error {
                        match __value {
                            "llvm-target" =>
                                _serde::__private228::Ok(__Field::__field0),
                            "target-pointer-width" =>
                                _serde::__private228::Ok(__Field::__field1),
                            "data-layout" =>
                                _serde::__private228::Ok(__Field::__field2),
                            "arch" => _serde::__private228::Ok(__Field::__field3),
                            "metadata" => _serde::__private228::Ok(__Field::__field4),
                            "target-endian" =>
                                _serde::__private228::Ok(__Field::__field5),
                            "frame-pointer" =>
                                _serde::__private228::Ok(__Field::__field6),
                            "target-c-int-width" =>
                                _serde::__private228::Ok(__Field::__field7),
                            "c-enum-min-bits" =>
                                _serde::__private228::Ok(__Field::__field8),
                            "os" => _serde::__private228::Ok(__Field::__field9),
                            "env" => _serde::__private228::Ok(__Field::__field10),
                            "abi" => _serde::__private228::Ok(__Field::__field11),
                            "vendor" => _serde::__private228::Ok(__Field::__field12),
                            "linker" => _serde::__private228::Ok(__Field::__field13),
                            "linker-flavor" =>
                                _serde::__private228::Ok(__Field::__field14),
                            "lld-flavor" =>
                                _serde::__private228::Ok(__Field::__field15),
                            "linker-is-gnu" =>
                                _serde::__private228::Ok(__Field::__field16),
                            "pre-link-objects" =>
                                _serde::__private228::Ok(__Field::__field17),
                            "post-link-objects" =>
                                _serde::__private228::Ok(__Field::__field18),
                            "pre-link-objects-fallback" =>
                                _serde::__private228::Ok(__Field::__field19),
                            "post-link-objects-fallback" =>
                                _serde::__private228::Ok(__Field::__field20),
                            "crt-objects-fallback" =>
                                _serde::__private228::Ok(__Field::__field21),
                            "link-self-contained" =>
                                _serde::__private228::Ok(__Field::__field22),
                            "pre-link-args" =>
                                _serde::__private228::Ok(__Field::__field23),
                            "late-link-args" =>
                                _serde::__private228::Ok(__Field::__field24),
                            "late-link-args-dynamic" =>
                                _serde::__private228::Ok(__Field::__field25),
                            "late-link-args-static" =>
                                _serde::__private228::Ok(__Field::__field26),
                            "post-link-args" =>
                                _serde::__private228::Ok(__Field::__field27),
                            "link-script" =>
                                _serde::__private228::Ok(__Field::__field28),
                            "link-env" => _serde::__private228::Ok(__Field::__field29),
                            "link-env-remove" =>
                                _serde::__private228::Ok(__Field::__field30),
                            "asm-args" => _serde::__private228::Ok(__Field::__field31),
                            "cpu" => _serde::__private228::Ok(__Field::__field32),
                            "need-explicit-cpu" =>
                                _serde::__private228::Ok(__Field::__field33),
                            "features" => _serde::__private228::Ok(__Field::__field34),
                            "dynamic-linking" =>
                                _serde::__private228::Ok(__Field::__field35),
                            "direct-access-external-data" =>
                                _serde::__private228::Ok(__Field::__field36),
                            "dll-tls-export" =>
                                _serde::__private228::Ok(__Field::__field37),
                            "only-cdylib" =>
                                _serde::__private228::Ok(__Field::__field38),
                            "executables" =>
                                _serde::__private228::Ok(__Field::__field39),
                            "relocation-model" =>
                                _serde::__private228::Ok(__Field::__field40),
                            "code-model" =>
                                _serde::__private228::Ok(__Field::__field41),
                            "tls-model" => _serde::__private228::Ok(__Field::__field42),
                            "disable-redzone" =>
                                _serde::__private228::Ok(__Field::__field43),
                            "function-sections" =>
                                _serde::__private228::Ok(__Field::__field44),
                            "dll-prefix" =>
                                _serde::__private228::Ok(__Field::__field45),
                            "dll-suffix" =>
                                _serde::__private228::Ok(__Field::__field46),
                            "exe-suffix" =>
                                _serde::__private228::Ok(__Field::__field47),
                            "staticlib-prefix" =>
                                _serde::__private228::Ok(__Field::__field48),
                            "staticlib-suffix" =>
                                _serde::__private228::Ok(__Field::__field49),
                            "target-family" =>
                                _serde::__private228::Ok(__Field::__field50),
                            "abi-return-struct-as-int" =>
                                _serde::__private228::Ok(__Field::__field51),
                            "is-like-aix" =>
                                _serde::__private228::Ok(__Field::__field52),
                            "is-like-darwin" =>
                                _serde::__private228::Ok(__Field::__field53),
                            "is-like-solaris" =>
                                _serde::__private228::Ok(__Field::__field54),
                            "is-like-windows" =>
                                _serde::__private228::Ok(__Field::__field55),
                            "is-like-gpu" =>
                                _serde::__private228::Ok(__Field::__field56),
                            "is-like-msvc" =>
                                _serde::__private228::Ok(__Field::__field57),
                            "is-like-wasm" =>
                                _serde::__private228::Ok(__Field::__field58),
                            "is-like-android" =>
                                _serde::__private228::Ok(__Field::__field59),
                            "is-like-vexos" =>
                                _serde::__private228::Ok(__Field::__field60),
                            "binary-format" =>
                                _serde::__private228::Ok(__Field::__field61),
                            "default-dwarf-version" =>
                                _serde::__private228::Ok(__Field::__field62),
                            "allows-weak-linkage" =>
                                _serde::__private228::Ok(__Field::__field63),
                            "has-rpath" => _serde::__private228::Ok(__Field::__field64),
                            "no-default-libraries" =>
                                _serde::__private228::Ok(__Field::__field65),
                            "position-independent-executables" =>
                                _serde::__private228::Ok(__Field::__field66),
                            "static-position-independent-executables" =>
                                _serde::__private228::Ok(__Field::__field67),
                            "plt-by-default" =>
                                _serde::__private228::Ok(__Field::__field68),
                            "relro-level" =>
                                _serde::__private228::Ok(__Field::__field69),
                            "archive-format" =>
                                _serde::__private228::Ok(__Field::__field70),
                            "allow-asm" => _serde::__private228::Ok(__Field::__field71),
                            "static-initializer-must-be-acyclic" =>
                                _serde::__private228::Ok(__Field::__field72),
                            "main-needs-argc-argv" =>
                                _serde::__private228::Ok(__Field::__field73),
                            "has-thread-local" =>
                                _serde::__private228::Ok(__Field::__field74),
                            "obj-is-bitcode" =>
                                _serde::__private228::Ok(__Field::__field75),
                            "max-atomic-width" =>
                                _serde::__private228::Ok(__Field::__field76),
                            "min-atomic-width" =>
                                _serde::__private228::Ok(__Field::__field77),
                            "atomic-cas" =>
                                _serde::__private228::Ok(__Field::__field78),
                            "panic-strategy" =>
                                _serde::__private228::Ok(__Field::__field79),
                            "crt-static-allows-dylibs" =>
                                _serde::__private228::Ok(__Field::__field80),
                            "crt-static-default" =>
                                _serde::__private228::Ok(__Field::__field81),
                            "crt-static-respected" =>
                                _serde::__private228::Ok(__Field::__field82),
                            "stack-probes" =>
                                _serde::__private228::Ok(__Field::__field83),
                            "min-global-align" =>
                                _serde::__private228::Ok(__Field::__field84),
                            "default-codegen-units" =>
                                _serde::__private228::Ok(__Field::__field85),
                            "default-codegen-backend" =>
                                _serde::__private228::Ok(__Field::__field86),
                            "trap-unreachable" =>
                                _serde::__private228::Ok(__Field::__field87),
                            "requires-lto" =>
                                _serde::__private228::Ok(__Field::__field88),
                            "singlethread" =>
                                _serde::__private228::Ok(__Field::__field89),
                            "no-builtins" =>
                                _serde::__private228::Ok(__Field::__field90),
                            "default-visibility" =>
                                _serde::__private228::Ok(__Field::__field91),
                            "emit-debug-gdb-scripts" =>
                                _serde::__private228::Ok(__Field::__field92),
                            "requires-uwtable" =>
                                _serde::__private228::Ok(__Field::__field93),
                            "default-uwtable" =>
                                _serde::__private228::Ok(__Field::__field94),
                            "simd-types-indirect" =>
                                _serde::__private228::Ok(__Field::__field95),
                            "limit-rdylib-exports" =>
                                _serde::__private228::Ok(__Field::__field96),
                            "override-export-symbols" =>
                                _serde::__private228::Ok(__Field::__field97),
                            "merge-functions" =>
                                _serde::__private228::Ok(__Field::__field98),
                            "target-mcount" =>
                                _serde::__private228::Ok(__Field::__field99),
                            "llvm-mcount-intrinsic" =>
                                _serde::__private228::Ok(__Field::__field100),
                            "llvm-abiname" =>
                                _serde::__private228::Ok(__Field::__field101),
                            "llvm-floatabi" =>
                                _serde::__private228::Ok(__Field::__field102),
                            "rustc-abi" =>
                                _serde::__private228::Ok(__Field::__field103),
                            "relax-elf-relocations" =>
                                _serde::__private228::Ok(__Field::__field104),
                            "llvm-args" =>
                                _serde::__private228::Ok(__Field::__field105),
                            "use-ctors-section" =>
                                _serde::__private228::Ok(__Field::__field106),
                            "eh-frame-header" =>
                                _serde::__private228::Ok(__Field::__field107),
                            "has-thumb-interworking" =>
                                _serde::__private228::Ok(__Field::__field108),
                            "debuginfo-kind" =>
                                _serde::__private228::Ok(__Field::__field109),
                            "split-debuginfo" =>
                                _serde::__private228::Ok(__Field::__field110),
                            "supported-split-debuginfo" =>
                                _serde::__private228::Ok(__Field::__field111),
                            "supported-sanitizers" =>
                                _serde::__private228::Ok(__Field::__field112),
                            "default-sanitizers" =>
                                _serde::__private228::Ok(__Field::__field113),
                            "generate-arange-section" =>
                                _serde::__private228::Ok(__Field::__field114),
                            "supports-stack-protector" =>
                                _serde::__private228::Ok(__Field::__field115),
                            "small-data-threshold-support" =>
                                _serde::__private228::Ok(__Field::__field116),
                            "entry-name" =>
                                _serde::__private228::Ok(__Field::__field117),
                            "supports-xray" =>
                                _serde::__private228::Ok(__Field::__field118),
                            "entry-abi" =>
                                _serde::__private228::Ok(__Field::__field119),
                            _ => {
                                _serde::__private228::Err(_serde::de::Error::unknown_field(__value,
                                        FIELDS))
                            }
                        }
                    }
                    fn visit_bytes<__E>(self, __value: &[u8])
                        -> _serde::__private228::Result<Self::Value, __E> where
                        __E: _serde::de::Error {
                        match __value {
                            b"llvm-target" =>
                                _serde::__private228::Ok(__Field::__field0),
                            b"target-pointer-width" =>
                                _serde::__private228::Ok(__Field::__field1),
                            b"data-layout" =>
                                _serde::__private228::Ok(__Field::__field2),
                            b"arch" => _serde::__private228::Ok(__Field::__field3),
                            b"metadata" => _serde::__private228::Ok(__Field::__field4),
                            b"target-endian" =>
                                _serde::__private228::Ok(__Field::__field5),
                            b"frame-pointer" =>
                                _serde::__private228::Ok(__Field::__field6),
                            b"target-c-int-width" =>
                                _serde::__private228::Ok(__Field::__field7),
                            b"c-enum-min-bits" =>
                                _serde::__private228::Ok(__Field::__field8),
                            b"os" => _serde::__private228::Ok(__Field::__field9),
                            b"env" => _serde::__private228::Ok(__Field::__field10),
                            b"abi" => _serde::__private228::Ok(__Field::__field11),
                            b"vendor" => _serde::__private228::Ok(__Field::__field12),
                            b"linker" => _serde::__private228::Ok(__Field::__field13),
                            b"linker-flavor" =>
                                _serde::__private228::Ok(__Field::__field14),
                            b"lld-flavor" =>
                                _serde::__private228::Ok(__Field::__field15),
                            b"linker-is-gnu" =>
                                _serde::__private228::Ok(__Field::__field16),
                            b"pre-link-objects" =>
                                _serde::__private228::Ok(__Field::__field17),
                            b"post-link-objects" =>
                                _serde::__private228::Ok(__Field::__field18),
                            b"pre-link-objects-fallback" =>
                                _serde::__private228::Ok(__Field::__field19),
                            b"post-link-objects-fallback" =>
                                _serde::__private228::Ok(__Field::__field20),
                            b"crt-objects-fallback" =>
                                _serde::__private228::Ok(__Field::__field21),
                            b"link-self-contained" =>
                                _serde::__private228::Ok(__Field::__field22),
                            b"pre-link-args" =>
                                _serde::__private228::Ok(__Field::__field23),
                            b"late-link-args" =>
                                _serde::__private228::Ok(__Field::__field24),
                            b"late-link-args-dynamic" =>
                                _serde::__private228::Ok(__Field::__field25),
                            b"late-link-args-static" =>
                                _serde::__private228::Ok(__Field::__field26),
                            b"post-link-args" =>
                                _serde::__private228::Ok(__Field::__field27),
                            b"link-script" =>
                                _serde::__private228::Ok(__Field::__field28),
                            b"link-env" => _serde::__private228::Ok(__Field::__field29),
                            b"link-env-remove" =>
                                _serde::__private228::Ok(__Field::__field30),
                            b"asm-args" => _serde::__private228::Ok(__Field::__field31),
                            b"cpu" => _serde::__private228::Ok(__Field::__field32),
                            b"need-explicit-cpu" =>
                                _serde::__private228::Ok(__Field::__field33),
                            b"features" => _serde::__private228::Ok(__Field::__field34),
                            b"dynamic-linking" =>
                                _serde::__private228::Ok(__Field::__field35),
                            b"direct-access-external-data" =>
                                _serde::__private228::Ok(__Field::__field36),
                            b"dll-tls-export" =>
                                _serde::__private228::Ok(__Field::__field37),
                            b"only-cdylib" =>
                                _serde::__private228::Ok(__Field::__field38),
                            b"executables" =>
                                _serde::__private228::Ok(__Field::__field39),
                            b"relocation-model" =>
                                _serde::__private228::Ok(__Field::__field40),
                            b"code-model" =>
                                _serde::__private228::Ok(__Field::__field41),
                            b"tls-model" =>
                                _serde::__private228::Ok(__Field::__field42),
                            b"disable-redzone" =>
                                _serde::__private228::Ok(__Field::__field43),
                            b"function-sections" =>
                                _serde::__private228::Ok(__Field::__field44),
                            b"dll-prefix" =>
                                _serde::__private228::Ok(__Field::__field45),
                            b"dll-suffix" =>
                                _serde::__private228::Ok(__Field::__field46),
                            b"exe-suffix" =>
                                _serde::__private228::Ok(__Field::__field47),
                            b"staticlib-prefix" =>
                                _serde::__private228::Ok(__Field::__field48),
                            b"staticlib-suffix" =>
                                _serde::__private228::Ok(__Field::__field49),
                            b"target-family" =>
                                _serde::__private228::Ok(__Field::__field50),
                            b"abi-return-struct-as-int" =>
                                _serde::__private228::Ok(__Field::__field51),
                            b"is-like-aix" =>
                                _serde::__private228::Ok(__Field::__field52),
                            b"is-like-darwin" =>
                                _serde::__private228::Ok(__Field::__field53),
                            b"is-like-solaris" =>
                                _serde::__private228::Ok(__Field::__field54),
                            b"is-like-windows" =>
                                _serde::__private228::Ok(__Field::__field55),
                            b"is-like-gpu" =>
                                _serde::__private228::Ok(__Field::__field56),
                            b"is-like-msvc" =>
                                _serde::__private228::Ok(__Field::__field57),
                            b"is-like-wasm" =>
                                _serde::__private228::Ok(__Field::__field58),
                            b"is-like-android" =>
                                _serde::__private228::Ok(__Field::__field59),
                            b"is-like-vexos" =>
                                _serde::__private228::Ok(__Field::__field60),
                            b"binary-format" =>
                                _serde::__private228::Ok(__Field::__field61),
                            b"default-dwarf-version" =>
                                _serde::__private228::Ok(__Field::__field62),
                            b"allows-weak-linkage" =>
                                _serde::__private228::Ok(__Field::__field63),
                            b"has-rpath" =>
                                _serde::__private228::Ok(__Field::__field64),
                            b"no-default-libraries" =>
                                _serde::__private228::Ok(__Field::__field65),
                            b"position-independent-executables" =>
                                _serde::__private228::Ok(__Field::__field66),
                            b"static-position-independent-executables" =>
                                _serde::__private228::Ok(__Field::__field67),
                            b"plt-by-default" =>
                                _serde::__private228::Ok(__Field::__field68),
                            b"relro-level" =>
                                _serde::__private228::Ok(__Field::__field69),
                            b"archive-format" =>
                                _serde::__private228::Ok(__Field::__field70),
                            b"allow-asm" =>
                                _serde::__private228::Ok(__Field::__field71),
                            b"static-initializer-must-be-acyclic" =>
                                _serde::__private228::Ok(__Field::__field72),
                            b"main-needs-argc-argv" =>
                                _serde::__private228::Ok(__Field::__field73),
                            b"has-thread-local" =>
                                _serde::__private228::Ok(__Field::__field74),
                            b"obj-is-bitcode" =>
                                _serde::__private228::Ok(__Field::__field75),
                            b"max-atomic-width" =>
                                _serde::__private228::Ok(__Field::__field76),
                            b"min-atomic-width" =>
                                _serde::__private228::Ok(__Field::__field77),
                            b"atomic-cas" =>
                                _serde::__private228::Ok(__Field::__field78),
                            b"panic-strategy" =>
                                _serde::__private228::Ok(__Field::__field79),
                            b"crt-static-allows-dylibs" =>
                                _serde::__private228::Ok(__Field::__field80),
                            b"crt-static-default" =>
                                _serde::__private228::Ok(__Field::__field81),
                            b"crt-static-respected" =>
                                _serde::__private228::Ok(__Field::__field82),
                            b"stack-probes" =>
                                _serde::__private228::Ok(__Field::__field83),
                            b"min-global-align" =>
                                _serde::__private228::Ok(__Field::__field84),
                            b"default-codegen-units" =>
                                _serde::__private228::Ok(__Field::__field85),
                            b"default-codegen-backend" =>
                                _serde::__private228::Ok(__Field::__field86),
                            b"trap-unreachable" =>
                                _serde::__private228::Ok(__Field::__field87),
                            b"requires-lto" =>
                                _serde::__private228::Ok(__Field::__field88),
                            b"singlethread" =>
                                _serde::__private228::Ok(__Field::__field89),
                            b"no-builtins" =>
                                _serde::__private228::Ok(__Field::__field90),
                            b"default-visibility" =>
                                _serde::__private228::Ok(__Field::__field91),
                            b"emit-debug-gdb-scripts" =>
                                _serde::__private228::Ok(__Field::__field92),
                            b"requires-uwtable" =>
                                _serde::__private228::Ok(__Field::__field93),
                            b"default-uwtable" =>
                                _serde::__private228::Ok(__Field::__field94),
                            b"simd-types-indirect" =>
                                _serde::__private228::Ok(__Field::__field95),
                            b"limit-rdylib-exports" =>
                                _serde::__private228::Ok(__Field::__field96),
                            b"override-export-symbols" =>
                                _serde::__private228::Ok(__Field::__field97),
                            b"merge-functions" =>
                                _serde::__private228::Ok(__Field::__field98),
                            b"target-mcount" =>
                                _serde::__private228::Ok(__Field::__field99),
                            b"llvm-mcount-intrinsic" =>
                                _serde::__private228::Ok(__Field::__field100),
                            b"llvm-abiname" =>
                                _serde::__private228::Ok(__Field::__field101),
                            b"llvm-floatabi" =>
                                _serde::__private228::Ok(__Field::__field102),
                            b"rustc-abi" =>
                                _serde::__private228::Ok(__Field::__field103),
                            b"relax-elf-relocations" =>
                                _serde::__private228::Ok(__Field::__field104),
                            b"llvm-args" =>
                                _serde::__private228::Ok(__Field::__field105),
                            b"use-ctors-section" =>
                                _serde::__private228::Ok(__Field::__field106),
                            b"eh-frame-header" =>
                                _serde::__private228::Ok(__Field::__field107),
                            b"has-thumb-interworking" =>
                                _serde::__private228::Ok(__Field::__field108),
                            b"debuginfo-kind" =>
                                _serde::__private228::Ok(__Field::__field109),
                            b"split-debuginfo" =>
                                _serde::__private228::Ok(__Field::__field110),
                            b"supported-split-debuginfo" =>
                                _serde::__private228::Ok(__Field::__field111),
                            b"supported-sanitizers" =>
                                _serde::__private228::Ok(__Field::__field112),
                            b"default-sanitizers" =>
                                _serde::__private228::Ok(__Field::__field113),
                            b"generate-arange-section" =>
                                _serde::__private228::Ok(__Field::__field114),
                            b"supports-stack-protector" =>
                                _serde::__private228::Ok(__Field::__field115),
                            b"small-data-threshold-support" =>
                                _serde::__private228::Ok(__Field::__field116),
                            b"entry-name" =>
                                _serde::__private228::Ok(__Field::__field117),
                            b"supports-xray" =>
                                _serde::__private228::Ok(__Field::__field118),
                            b"entry-abi" =>
                                _serde::__private228::Ok(__Field::__field119),
                            _ => {
                                let __value =
                                    &_serde::__private228::from_utf8_lossy(__value);
                                _serde::__private228::Err(_serde::de::Error::unknown_field(__value,
                                        FIELDS))
                            }
                        }
                    }
                }
                #[automatically_derived]
                impl<'de> _serde::Deserialize<'de> for __Field {
                    #[inline]
                    fn deserialize<__D>(__deserializer: __D)
                        -> _serde::__private228::Result<Self, __D::Error> where
                        __D: _serde::Deserializer<'de> {
                        _serde::Deserializer::deserialize_identifier(__deserializer,
                            __FieldVisitor)
                    }
                }
                #[doc(hidden)]
                struct __Visitor<'de> {
                    marker: _serde::__private228::PhantomData<TargetSpecJson>,
                    lifetime: _serde::__private228::PhantomData<&'de ()>,
                }
                #[automatically_derived]
                impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                    type Value = TargetSpecJson;
                    fn expecting(&self,
                        __formatter: &mut _serde::__private228::Formatter)
                        -> _serde::__private228::fmt::Result {
                        _serde::__private228::Formatter::write_str(__formatter,
                            "struct TargetSpecJson")
                    }
                    #[inline]
                    fn visit_seq<__A>(self, mut __seq: __A)
                        -> _serde::__private228::Result<Self::Value, __A::Error>
                        where __A: _serde::de::SeqAccess<'de> {
                        let __field0 =
                            match _serde::de::SeqAccess::next_element::<StaticCow<str>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(0usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field1 =
                            match _serde::de::SeqAccess::next_element::<u16>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(1usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field2 =
                            match _serde::de::SeqAccess::next_element::<StaticCow<str>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(2usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field3 =
                            match _serde::de::SeqAccess::next_element::<Arch>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(3usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field4 =
                            match _serde::de::SeqAccess::next_element::<Option<TargetSpecJsonMetadata>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(4usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field5 =
                            match _serde::de::SeqAccess::next_element::<Option<EndianWrapper>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(5usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field6 =
                            match _serde::de::SeqAccess::next_element::<Option<FramePointer>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(6usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field7 =
                            match _serde::de::SeqAccess::next_element::<Option<u16>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(7usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field8 =
                            match _serde::de::SeqAccess::next_element::<Option<u64>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(8usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field9 =
                            match _serde::de::SeqAccess::next_element::<Option<Os>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(9usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field10 =
                            match _serde::de::SeqAccess::next_element::<Option<Env>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(10usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field11 =
                            match _serde::de::SeqAccess::next_element::<Option<Abi>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(11usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field12 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<str>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(12usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field13 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<str>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(13usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field14 =
                            match _serde::de::SeqAccess::next_element::<Option<LinkerFlavorCli>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(14usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field15 =
                            match _serde::de::SeqAccess::next_element::<Option<LldFlavor>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(15usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field16 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(16usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field17 =
                            match _serde::de::SeqAccess::next_element::<Option<CrtObjects>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(17usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field18 =
                            match _serde::de::SeqAccess::next_element::<Option<CrtObjects>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(18usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field19 =
                            match _serde::de::SeqAccess::next_element::<Option<CrtObjects>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(19usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field20 =
                            match _serde::de::SeqAccess::next_element::<Option<CrtObjects>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(20usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field21 =
                            match _serde::de::SeqAccess::next_element::<Option<LinkSelfContainedDefault>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(21usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field22 =
                            match _serde::de::SeqAccess::next_element::<Option<LinkSelfContainedComponentsWrapper>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(22usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field23 =
                            match _serde::de::SeqAccess::next_element::<Option<LinkArgsCli>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(23usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field24 =
                            match _serde::de::SeqAccess::next_element::<Option<LinkArgsCli>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(24usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field25 =
                            match _serde::de::SeqAccess::next_element::<Option<LinkArgsCli>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(25usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field26 =
                            match _serde::de::SeqAccess::next_element::<Option<LinkArgsCli>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(26usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field27 =
                            match _serde::de::SeqAccess::next_element::<Option<LinkArgsCli>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(27usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field28 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<str>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(28usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field29 =
                            match _serde::de::SeqAccess::next_element::<Option<Vec<StaticCow<str>>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(29usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field30 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<[StaticCow<str>]>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(30usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field31 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<[StaticCow<str>]>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(31usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field32 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<str>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(32usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field33 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(33usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field34 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<str>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(34usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field35 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(35usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field36 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(36usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field37 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(37usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field38 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(38usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field39 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(39usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field40 =
                            match _serde::de::SeqAccess::next_element::<Option<RelocModel>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(40usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field41 =
                            match _serde::de::SeqAccess::next_element::<Option<CodeModel>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(41usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field42 =
                            match _serde::de::SeqAccess::next_element::<Option<TlsModel>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(42usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field43 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(43usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field44 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(44usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field45 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<str>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(45usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field46 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<str>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(46usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field47 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<str>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(47usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field48 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<str>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(48usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field49 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<str>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(49usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field50 =
                            match _serde::de::SeqAccess::next_element::<Option<TargetFamiliesJson>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(50usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field51 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(51usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field52 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(52usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field53 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(53usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field54 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(54usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field55 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(55usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field56 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(56usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field57 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(57usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field58 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(58usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field59 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(59usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field60 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(60usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field61 =
                            match _serde::de::SeqAccess::next_element::<Option<BinaryFormat>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(61usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field62 =
                            match _serde::de::SeqAccess::next_element::<Option<u32>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(62usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field63 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(63usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field64 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(64usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field65 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(65usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field66 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(66usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field67 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(67usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field68 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(68usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field69 =
                            match _serde::de::SeqAccess::next_element::<Option<RelroLevel>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(69usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field70 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<str>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(70usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field71 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(71usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field72 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(72usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field73 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(73usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field74 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(74usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field75 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(75usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field76 =
                            match _serde::de::SeqAccess::next_element::<Option<u64>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(76usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field77 =
                            match _serde::de::SeqAccess::next_element::<Option<u64>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(77usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field78 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(78usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field79 =
                            match _serde::de::SeqAccess::next_element::<Option<PanicStrategy>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(79usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field80 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(80usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field81 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(81usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field82 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(82usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field83 =
                            match _serde::de::SeqAccess::next_element::<Option<StackProbeType>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(83usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field84 =
                            match _serde::de::SeqAccess::next_element::<Option<u64>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(84usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field85 =
                            match _serde::de::SeqAccess::next_element::<Option<u64>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(85usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field86 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<str>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(86usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field87 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(87usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field88 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(88usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field89 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(89usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field90 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(90usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field91 =
                            match _serde::de::SeqAccess::next_element::<Option<SymbolVisibility>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(91usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field92 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(92usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field93 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(93usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field94 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(94usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field95 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(95usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field96 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(96usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field97 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<[StaticCow<str>]>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(97usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field98 =
                            match _serde::de::SeqAccess::next_element::<Option<MergeFunctions>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(98usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field99 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<str>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(99usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field100 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<str>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(100usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field101 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<str>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(101usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field102 =
                            match _serde::de::SeqAccess::next_element::<Option<FloatAbi>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(102usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field103 =
                            match _serde::de::SeqAccess::next_element::<Option<RustcAbi>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(103usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field104 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(104usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field105 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<[StaticCow<str>]>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(105usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field106 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(106usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field107 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(107usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field108 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(108usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field109 =
                            match _serde::de::SeqAccess::next_element::<Option<DebuginfoKind>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(109usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field110 =
                            match _serde::de::SeqAccess::next_element::<Option<SplitDebuginfo>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(110usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field111 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<[SplitDebuginfo]>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(111usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field112 =
                            match _serde::de::SeqAccess::next_element::<Option<Vec<SanitizerSet>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(112usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field113 =
                            match _serde::de::SeqAccess::next_element::<Option<Vec<SanitizerSet>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(113usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field114 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(114usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field115 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(115usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field116 =
                            match _serde::de::SeqAccess::next_element::<Option<SmallDataThresholdSupport>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(116usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field117 =
                            match _serde::de::SeqAccess::next_element::<Option<StaticCow<str>>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(117usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field118 =
                            match _serde::de::SeqAccess::next_element::<Option<bool>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(118usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        let __field119 =
                            match _serde::de::SeqAccess::next_element::<Option<ExternAbiWrapper>>(&mut __seq)?
                                {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None =>
                                    return _serde::__private228::Err(_serde::de::Error::invalid_length(119usize,
                                                &"struct TargetSpecJson with 120 elements")),
                            };
                        _serde::__private228::Ok(TargetSpecJson {
                                llvm_target: __field0,
                                target_pointer_width: __field1,
                                data_layout: __field2,
                                arch: __field3,
                                metadata: __field4,
                                target_endian: __field5,
                                frame_pointer: __field6,
                                c_int_width: __field7,
                                c_enum_min_bits: __field8,
                                os: __field9,
                                env: __field10,
                                abi: __field11,
                                vendor: __field12,
                                linker: __field13,
                                linker_flavor_json: __field14,
                                lld_flavor_json: __field15,
                                linker_is_gnu_json: __field16,
                                pre_link_objects: __field17,
                                post_link_objects: __field18,
                                pre_link_objects_self_contained: __field19,
                                post_link_objects_self_contained: __field20,
                                link_self_contained_backwards_compatible: __field21,
                                link_self_contained: __field22,
                                pre_link_args_json: __field23,
                                late_link_args_json: __field24,
                                late_link_args_dynamic_json: __field25,
                                late_link_args_static_json: __field26,
                                post_link_args_json: __field27,
                                link_script: __field28,
                                link_env: __field29,
                                link_env_remove: __field30,
                                asm_args: __field31,
                                cpu: __field32,
                                need_explicit_cpu: __field33,
                                features: __field34,
                                dynamic_linking: __field35,
                                direct_access_external_data: __field36,
                                dll_tls_export: __field37,
                                only_cdylib: __field38,
                                executables: __field39,
                                relocation_model: __field40,
                                code_model: __field41,
                                tls_model: __field42,
                                disable_redzone: __field43,
                                function_sections: __field44,
                                dll_prefix: __field45,
                                dll_suffix: __field46,
                                exe_suffix: __field47,
                                staticlib_prefix: __field48,
                                staticlib_suffix: __field49,
                                target_family: __field50,
                                abi_return_struct_as_int: __field51,
                                is_like_aix: __field52,
                                is_like_darwin: __field53,
                                is_like_solaris: __field54,
                                is_like_windows: __field55,
                                is_like_gpu: __field56,
                                is_like_msvc: __field57,
                                is_like_wasm: __field58,
                                is_like_android: __field59,
                                is_like_vexos: __field60,
                                binary_format: __field61,
                                default_dwarf_version: __field62,
                                allows_weak_linkage: __field63,
                                has_rpath: __field64,
                                no_default_libraries: __field65,
                                position_independent_executables: __field66,
                                static_position_independent_executables: __field67,
                                plt_by_default: __field68,
                                relro_level: __field69,
                                archive_format: __field70,
                                allow_asm: __field71,
                                static_initializer_must_be_acyclic: __field72,
                                main_needs_argc_argv: __field73,
                                has_thread_local: __field74,
                                obj_is_bitcode: __field75,
                                max_atomic_width: __field76,
                                min_atomic_width: __field77,
                                atomic_cas: __field78,
                                panic_strategy: __field79,
                                crt_static_allows_dylibs: __field80,
                                crt_static_default: __field81,
                                crt_static_respected: __field82,
                                stack_probes: __field83,
                                min_global_align: __field84,
                                default_codegen_units: __field85,
                                default_codegen_backend: __field86,
                                trap_unreachable: __field87,
                                requires_lto: __field88,
                                singlethread: __field89,
                                no_builtins: __field90,
                                default_visibility: __field91,
                                emit_debug_gdb_scripts: __field92,
                                requires_uwtable: __field93,
                                default_uwtable: __field94,
                                simd_types_indirect: __field95,
                                limit_rdylib_exports: __field96,
                                override_export_symbols: __field97,
                                merge_functions: __field98,
                                mcount: __field99,
                                llvm_mcount_intrinsic: __field100,
                                llvm_abiname: __field101,
                                llvm_floatabi: __field102,
                                rustc_abi: __field103,
                                relax_elf_relocations: __field104,
                                llvm_args: __field105,
                                use_ctors_section: __field106,
                                eh_frame_header: __field107,
                                has_thumb_interworking: __field108,
                                debuginfo_kind: __field109,
                                split_debuginfo: __field110,
                                supported_split_debuginfo: __field111,
                                supported_sanitizers: __field112,
                                default_sanitizers: __field113,
                                generate_arange_section: __field114,
                                supports_stack_protector: __field115,
                                small_data_threshold_support: __field116,
                                entry_name: __field117,
                                supports_xray: __field118,
                                entry_abi: __field119,
                            })
                    }
                    #[inline]
                    fn visit_map<__A>(self, mut __map: __A)
                        -> _serde::__private228::Result<Self::Value, __A::Error>
                        where __A: _serde::de::MapAccess<'de> {
                        let mut __field0:
                                _serde::__private228::Option<StaticCow<str>> =
                            _serde::__private228::None;
                        let mut __field1: _serde::__private228::Option<u16> =
                            _serde::__private228::None;
                        let mut __field2:
                                _serde::__private228::Option<StaticCow<str>> =
                            _serde::__private228::None;
                        let mut __field3: _serde::__private228::Option<Arch> =
                            _serde::__private228::None;
                        let mut __field4:
                                _serde::__private228::Option<Option<TargetSpecJsonMetadata>> =
                            _serde::__private228::None;
                        let mut __field5:
                                _serde::__private228::Option<Option<EndianWrapper>> =
                            _serde::__private228::None;
                        let mut __field6:
                                _serde::__private228::Option<Option<FramePointer>> =
                            _serde::__private228::None;
                        let mut __field7:
                                _serde::__private228::Option<Option<u16>> =
                            _serde::__private228::None;
                        let mut __field8:
                                _serde::__private228::Option<Option<u64>> =
                            _serde::__private228::None;
                        let mut __field9: _serde::__private228::Option<Option<Os>> =
                            _serde::__private228::None;
                        let mut __field10:
                                _serde::__private228::Option<Option<Env>> =
                            _serde::__private228::None;
                        let mut __field11:
                                _serde::__private228::Option<Option<Abi>> =
                            _serde::__private228::None;
                        let mut __field12:
                                _serde::__private228::Option<Option<StaticCow<str>>> =
                            _serde::__private228::None;
                        let mut __field13:
                                _serde::__private228::Option<Option<StaticCow<str>>> =
                            _serde::__private228::None;
                        let mut __field14:
                                _serde::__private228::Option<Option<LinkerFlavorCli>> =
                            _serde::__private228::None;
                        let mut __field15:
                                _serde::__private228::Option<Option<LldFlavor>> =
                            _serde::__private228::None;
                        let mut __field16:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field17:
                                _serde::__private228::Option<Option<CrtObjects>> =
                            _serde::__private228::None;
                        let mut __field18:
                                _serde::__private228::Option<Option<CrtObjects>> =
                            _serde::__private228::None;
                        let mut __field19:
                                _serde::__private228::Option<Option<CrtObjects>> =
                            _serde::__private228::None;
                        let mut __field20:
                                _serde::__private228::Option<Option<CrtObjects>> =
                            _serde::__private228::None;
                        let mut __field21:
                                _serde::__private228::Option<Option<LinkSelfContainedDefault>> =
                            _serde::__private228::None;
                        let mut __field22:
                                _serde::__private228::Option<Option<LinkSelfContainedComponentsWrapper>> =
                            _serde::__private228::None;
                        let mut __field23:
                                _serde::__private228::Option<Option<LinkArgsCli>> =
                            _serde::__private228::None;
                        let mut __field24:
                                _serde::__private228::Option<Option<LinkArgsCli>> =
                            _serde::__private228::None;
                        let mut __field25:
                                _serde::__private228::Option<Option<LinkArgsCli>> =
                            _serde::__private228::None;
                        let mut __field26:
                                _serde::__private228::Option<Option<LinkArgsCli>> =
                            _serde::__private228::None;
                        let mut __field27:
                                _serde::__private228::Option<Option<LinkArgsCli>> =
                            _serde::__private228::None;
                        let mut __field28:
                                _serde::__private228::Option<Option<StaticCow<str>>> =
                            _serde::__private228::None;
                        let mut __field29:
                                _serde::__private228::Option<Option<Vec<StaticCow<str>>>> =
                            _serde::__private228::None;
                        let mut __field30:
                                _serde::__private228::Option<Option<StaticCow<[StaticCow<str>]>>> =
                            _serde::__private228::None;
                        let mut __field31:
                                _serde::__private228::Option<Option<StaticCow<[StaticCow<str>]>>> =
                            _serde::__private228::None;
                        let mut __field32:
                                _serde::__private228::Option<Option<StaticCow<str>>> =
                            _serde::__private228::None;
                        let mut __field33:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field34:
                                _serde::__private228::Option<Option<StaticCow<str>>> =
                            _serde::__private228::None;
                        let mut __field35:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field36:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field37:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field38:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field39:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field40:
                                _serde::__private228::Option<Option<RelocModel>> =
                            _serde::__private228::None;
                        let mut __field41:
                                _serde::__private228::Option<Option<CodeModel>> =
                            _serde::__private228::None;
                        let mut __field42:
                                _serde::__private228::Option<Option<TlsModel>> =
                            _serde::__private228::None;
                        let mut __field43:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field44:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field45:
                                _serde::__private228::Option<Option<StaticCow<str>>> =
                            _serde::__private228::None;
                        let mut __field46:
                                _serde::__private228::Option<Option<StaticCow<str>>> =
                            _serde::__private228::None;
                        let mut __field47:
                                _serde::__private228::Option<Option<StaticCow<str>>> =
                            _serde::__private228::None;
                        let mut __field48:
                                _serde::__private228::Option<Option<StaticCow<str>>> =
                            _serde::__private228::None;
                        let mut __field49:
                                _serde::__private228::Option<Option<StaticCow<str>>> =
                            _serde::__private228::None;
                        let mut __field50:
                                _serde::__private228::Option<Option<TargetFamiliesJson>> =
                            _serde::__private228::None;
                        let mut __field51:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field52:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field53:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field54:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field55:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field56:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field57:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field58:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field59:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field60:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field61:
                                _serde::__private228::Option<Option<BinaryFormat>> =
                            _serde::__private228::None;
                        let mut __field62:
                                _serde::__private228::Option<Option<u32>> =
                            _serde::__private228::None;
                        let mut __field63:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field64:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field65:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field66:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field67:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field68:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field69:
                                _serde::__private228::Option<Option<RelroLevel>> =
                            _serde::__private228::None;
                        let mut __field70:
                                _serde::__private228::Option<Option<StaticCow<str>>> =
                            _serde::__private228::None;
                        let mut __field71:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field72:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field73:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field74:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field75:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field76:
                                _serde::__private228::Option<Option<u64>> =
                            _serde::__private228::None;
                        let mut __field77:
                                _serde::__private228::Option<Option<u64>> =
                            _serde::__private228::None;
                        let mut __field78:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field79:
                                _serde::__private228::Option<Option<PanicStrategy>> =
                            _serde::__private228::None;
                        let mut __field80:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field81:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field82:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field83:
                                _serde::__private228::Option<Option<StackProbeType>> =
                            _serde::__private228::None;
                        let mut __field84:
                                _serde::__private228::Option<Option<u64>> =
                            _serde::__private228::None;
                        let mut __field85:
                                _serde::__private228::Option<Option<u64>> =
                            _serde::__private228::None;
                        let mut __field86:
                                _serde::__private228::Option<Option<StaticCow<str>>> =
                            _serde::__private228::None;
                        let mut __field87:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field88:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field89:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field90:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field91:
                                _serde::__private228::Option<Option<SymbolVisibility>> =
                            _serde::__private228::None;
                        let mut __field92:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field93:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field94:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field95:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field96:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field97:
                                _serde::__private228::Option<Option<StaticCow<[StaticCow<str>]>>> =
                            _serde::__private228::None;
                        let mut __field98:
                                _serde::__private228::Option<Option<MergeFunctions>> =
                            _serde::__private228::None;
                        let mut __field99:
                                _serde::__private228::Option<Option<StaticCow<str>>> =
                            _serde::__private228::None;
                        let mut __field100:
                                _serde::__private228::Option<Option<StaticCow<str>>> =
                            _serde::__private228::None;
                        let mut __field101:
                                _serde::__private228::Option<Option<StaticCow<str>>> =
                            _serde::__private228::None;
                        let mut __field102:
                                _serde::__private228::Option<Option<FloatAbi>> =
                            _serde::__private228::None;
                        let mut __field103:
                                _serde::__private228::Option<Option<RustcAbi>> =
                            _serde::__private228::None;
                        let mut __field104:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field105:
                                _serde::__private228::Option<Option<StaticCow<[StaticCow<str>]>>> =
                            _serde::__private228::None;
                        let mut __field106:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field107:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field108:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field109:
                                _serde::__private228::Option<Option<DebuginfoKind>> =
                            _serde::__private228::None;
                        let mut __field110:
                                _serde::__private228::Option<Option<SplitDebuginfo>> =
                            _serde::__private228::None;
                        let mut __field111:
                                _serde::__private228::Option<Option<StaticCow<[SplitDebuginfo]>>> =
                            _serde::__private228::None;
                        let mut __field112:
                                _serde::__private228::Option<Option<Vec<SanitizerSet>>> =
                            _serde::__private228::None;
                        let mut __field113:
                                _serde::__private228::Option<Option<Vec<SanitizerSet>>> =
                            _serde::__private228::None;
                        let mut __field114:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field115:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field116:
                                _serde::__private228::Option<Option<SmallDataThresholdSupport>> =
                            _serde::__private228::None;
                        let mut __field117:
                                _serde::__private228::Option<Option<StaticCow<str>>> =
                            _serde::__private228::None;
                        let mut __field118:
                                _serde::__private228::Option<Option<bool>> =
                            _serde::__private228::None;
                        let mut __field119:
                                _serde::__private228::Option<Option<ExternAbiWrapper>> =
                            _serde::__private228::None;
                        while let _serde::__private228::Some(__key) =
                                _serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                            match __key {
                                __Field::__field0 => {
                                    if _serde::__private228::Option::is_some(&__field0) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("llvm-target"));
                                    }
                                    __field0 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<StaticCow<str>>(&mut __map)?);
                                }
                                __Field::__field1 => {
                                    if _serde::__private228::Option::is_some(&__field1) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("target-pointer-width"));
                                    }
                                    __field1 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<u16>(&mut __map)?);
                                }
                                __Field::__field2 => {
                                    if _serde::__private228::Option::is_some(&__field2) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("data-layout"));
                                    }
                                    __field2 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<StaticCow<str>>(&mut __map)?);
                                }
                                __Field::__field3 => {
                                    if _serde::__private228::Option::is_some(&__field3) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("arch"));
                                    }
                                    __field3 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Arch>(&mut __map)?);
                                }
                                __Field::__field4 => {
                                    if _serde::__private228::Option::is_some(&__field4) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("metadata"));
                                    }
                                    __field4 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<TargetSpecJsonMetadata>>(&mut __map)?);
                                }
                                __Field::__field5 => {
                                    if _serde::__private228::Option::is_some(&__field5) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("target-endian"));
                                    }
                                    __field5 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<EndianWrapper>>(&mut __map)?);
                                }
                                __Field::__field6 => {
                                    if _serde::__private228::Option::is_some(&__field6) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("frame-pointer"));
                                    }
                                    __field6 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<FramePointer>>(&mut __map)?);
                                }
                                __Field::__field7 => {
                                    if _serde::__private228::Option::is_some(&__field7) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("target-c-int-width"));
                                    }
                                    __field7 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<u16>>(&mut __map)?);
                                }
                                __Field::__field8 => {
                                    if _serde::__private228::Option::is_some(&__field8) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("c-enum-min-bits"));
                                    }
                                    __field8 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<u64>>(&mut __map)?);
                                }
                                __Field::__field9 => {
                                    if _serde::__private228::Option::is_some(&__field9) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("os"));
                                    }
                                    __field9 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<Os>>(&mut __map)?);
                                }
                                __Field::__field10 => {
                                    if _serde::__private228::Option::is_some(&__field10) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("env"));
                                    }
                                    __field10 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<Env>>(&mut __map)?);
                                }
                                __Field::__field11 => {
                                    if _serde::__private228::Option::is_some(&__field11) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("abi"));
                                    }
                                    __field11 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<Abi>>(&mut __map)?);
                                }
                                __Field::__field12 => {
                                    if _serde::__private228::Option::is_some(&__field12) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("vendor"));
                                    }
                                    __field12 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<str>>>(&mut __map)?);
                                }
                                __Field::__field13 => {
                                    if _serde::__private228::Option::is_some(&__field13) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("linker"));
                                    }
                                    __field13 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<str>>>(&mut __map)?);
                                }
                                __Field::__field14 => {
                                    if _serde::__private228::Option::is_some(&__field14) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("linker-flavor"));
                                    }
                                    __field14 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<LinkerFlavorCli>>(&mut __map)?);
                                }
                                __Field::__field15 => {
                                    if _serde::__private228::Option::is_some(&__field15) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("lld-flavor"));
                                    }
                                    __field15 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<LldFlavor>>(&mut __map)?);
                                }
                                __Field::__field16 => {
                                    if _serde::__private228::Option::is_some(&__field16) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("linker-is-gnu"));
                                    }
                                    __field16 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field17 => {
                                    if _serde::__private228::Option::is_some(&__field17) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("pre-link-objects"));
                                    }
                                    __field17 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<CrtObjects>>(&mut __map)?);
                                }
                                __Field::__field18 => {
                                    if _serde::__private228::Option::is_some(&__field18) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("post-link-objects"));
                                    }
                                    __field18 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<CrtObjects>>(&mut __map)?);
                                }
                                __Field::__field19 => {
                                    if _serde::__private228::Option::is_some(&__field19) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("pre-link-objects-fallback"));
                                    }
                                    __field19 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<CrtObjects>>(&mut __map)?);
                                }
                                __Field::__field20 => {
                                    if _serde::__private228::Option::is_some(&__field20) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("post-link-objects-fallback"));
                                    }
                                    __field20 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<CrtObjects>>(&mut __map)?);
                                }
                                __Field::__field21 => {
                                    if _serde::__private228::Option::is_some(&__field21) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("crt-objects-fallback"));
                                    }
                                    __field21 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<LinkSelfContainedDefault>>(&mut __map)?);
                                }
                                __Field::__field22 => {
                                    if _serde::__private228::Option::is_some(&__field22) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("link-self-contained"));
                                    }
                                    __field22 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<LinkSelfContainedComponentsWrapper>>(&mut __map)?);
                                }
                                __Field::__field23 => {
                                    if _serde::__private228::Option::is_some(&__field23) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("pre-link-args"));
                                    }
                                    __field23 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<LinkArgsCli>>(&mut __map)?);
                                }
                                __Field::__field24 => {
                                    if _serde::__private228::Option::is_some(&__field24) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("late-link-args"));
                                    }
                                    __field24 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<LinkArgsCli>>(&mut __map)?);
                                }
                                __Field::__field25 => {
                                    if _serde::__private228::Option::is_some(&__field25) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("late-link-args-dynamic"));
                                    }
                                    __field25 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<LinkArgsCli>>(&mut __map)?);
                                }
                                __Field::__field26 => {
                                    if _serde::__private228::Option::is_some(&__field26) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("late-link-args-static"));
                                    }
                                    __field26 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<LinkArgsCli>>(&mut __map)?);
                                }
                                __Field::__field27 => {
                                    if _serde::__private228::Option::is_some(&__field27) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("post-link-args"));
                                    }
                                    __field27 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<LinkArgsCli>>(&mut __map)?);
                                }
                                __Field::__field28 => {
                                    if _serde::__private228::Option::is_some(&__field28) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("link-script"));
                                    }
                                    __field28 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<str>>>(&mut __map)?);
                                }
                                __Field::__field29 => {
                                    if _serde::__private228::Option::is_some(&__field29) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("link-env"));
                                    }
                                    __field29 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<Vec<StaticCow<str>>>>(&mut __map)?);
                                }
                                __Field::__field30 => {
                                    if _serde::__private228::Option::is_some(&__field30) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("link-env-remove"));
                                    }
                                    __field30 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<[StaticCow<str>]>>>(&mut __map)?);
                                }
                                __Field::__field31 => {
                                    if _serde::__private228::Option::is_some(&__field31) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("asm-args"));
                                    }
                                    __field31 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<[StaticCow<str>]>>>(&mut __map)?);
                                }
                                __Field::__field32 => {
                                    if _serde::__private228::Option::is_some(&__field32) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("cpu"));
                                    }
                                    __field32 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<str>>>(&mut __map)?);
                                }
                                __Field::__field33 => {
                                    if _serde::__private228::Option::is_some(&__field33) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("need-explicit-cpu"));
                                    }
                                    __field33 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field34 => {
                                    if _serde::__private228::Option::is_some(&__field34) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("features"));
                                    }
                                    __field34 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<str>>>(&mut __map)?);
                                }
                                __Field::__field35 => {
                                    if _serde::__private228::Option::is_some(&__field35) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("dynamic-linking"));
                                    }
                                    __field35 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field36 => {
                                    if _serde::__private228::Option::is_some(&__field36) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("direct-access-external-data"));
                                    }
                                    __field36 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field37 => {
                                    if _serde::__private228::Option::is_some(&__field37) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("dll-tls-export"));
                                    }
                                    __field37 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field38 => {
                                    if _serde::__private228::Option::is_some(&__field38) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("only-cdylib"));
                                    }
                                    __field38 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field39 => {
                                    if _serde::__private228::Option::is_some(&__field39) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("executables"));
                                    }
                                    __field39 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field40 => {
                                    if _serde::__private228::Option::is_some(&__field40) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("relocation-model"));
                                    }
                                    __field40 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<RelocModel>>(&mut __map)?);
                                }
                                __Field::__field41 => {
                                    if _serde::__private228::Option::is_some(&__field41) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("code-model"));
                                    }
                                    __field41 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<CodeModel>>(&mut __map)?);
                                }
                                __Field::__field42 => {
                                    if _serde::__private228::Option::is_some(&__field42) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("tls-model"));
                                    }
                                    __field42 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<TlsModel>>(&mut __map)?);
                                }
                                __Field::__field43 => {
                                    if _serde::__private228::Option::is_some(&__field43) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("disable-redzone"));
                                    }
                                    __field43 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field44 => {
                                    if _serde::__private228::Option::is_some(&__field44) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("function-sections"));
                                    }
                                    __field44 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field45 => {
                                    if _serde::__private228::Option::is_some(&__field45) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("dll-prefix"));
                                    }
                                    __field45 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<str>>>(&mut __map)?);
                                }
                                __Field::__field46 => {
                                    if _serde::__private228::Option::is_some(&__field46) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("dll-suffix"));
                                    }
                                    __field46 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<str>>>(&mut __map)?);
                                }
                                __Field::__field47 => {
                                    if _serde::__private228::Option::is_some(&__field47) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("exe-suffix"));
                                    }
                                    __field47 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<str>>>(&mut __map)?);
                                }
                                __Field::__field48 => {
                                    if _serde::__private228::Option::is_some(&__field48) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("staticlib-prefix"));
                                    }
                                    __field48 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<str>>>(&mut __map)?);
                                }
                                __Field::__field49 => {
                                    if _serde::__private228::Option::is_some(&__field49) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("staticlib-suffix"));
                                    }
                                    __field49 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<str>>>(&mut __map)?);
                                }
                                __Field::__field50 => {
                                    if _serde::__private228::Option::is_some(&__field50) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("target-family"));
                                    }
                                    __field50 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<TargetFamiliesJson>>(&mut __map)?);
                                }
                                __Field::__field51 => {
                                    if _serde::__private228::Option::is_some(&__field51) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("abi-return-struct-as-int"));
                                    }
                                    __field51 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field52 => {
                                    if _serde::__private228::Option::is_some(&__field52) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("is-like-aix"));
                                    }
                                    __field52 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field53 => {
                                    if _serde::__private228::Option::is_some(&__field53) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("is-like-darwin"));
                                    }
                                    __field53 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field54 => {
                                    if _serde::__private228::Option::is_some(&__field54) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("is-like-solaris"));
                                    }
                                    __field54 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field55 => {
                                    if _serde::__private228::Option::is_some(&__field55) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("is-like-windows"));
                                    }
                                    __field55 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field56 => {
                                    if _serde::__private228::Option::is_some(&__field56) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("is-like-gpu"));
                                    }
                                    __field56 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field57 => {
                                    if _serde::__private228::Option::is_some(&__field57) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("is-like-msvc"));
                                    }
                                    __field57 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field58 => {
                                    if _serde::__private228::Option::is_some(&__field58) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("is-like-wasm"));
                                    }
                                    __field58 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field59 => {
                                    if _serde::__private228::Option::is_some(&__field59) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("is-like-android"));
                                    }
                                    __field59 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field60 => {
                                    if _serde::__private228::Option::is_some(&__field60) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("is-like-vexos"));
                                    }
                                    __field60 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field61 => {
                                    if _serde::__private228::Option::is_some(&__field61) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("binary-format"));
                                    }
                                    __field61 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<BinaryFormat>>(&mut __map)?);
                                }
                                __Field::__field62 => {
                                    if _serde::__private228::Option::is_some(&__field62) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("default-dwarf-version"));
                                    }
                                    __field62 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<u32>>(&mut __map)?);
                                }
                                __Field::__field63 => {
                                    if _serde::__private228::Option::is_some(&__field63) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("allows-weak-linkage"));
                                    }
                                    __field63 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field64 => {
                                    if _serde::__private228::Option::is_some(&__field64) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("has-rpath"));
                                    }
                                    __field64 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field65 => {
                                    if _serde::__private228::Option::is_some(&__field65) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("no-default-libraries"));
                                    }
                                    __field65 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field66 => {
                                    if _serde::__private228::Option::is_some(&__field66) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("position-independent-executables"));
                                    }
                                    __field66 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field67 => {
                                    if _serde::__private228::Option::is_some(&__field67) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("static-position-independent-executables"));
                                    }
                                    __field67 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field68 => {
                                    if _serde::__private228::Option::is_some(&__field68) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("plt-by-default"));
                                    }
                                    __field68 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field69 => {
                                    if _serde::__private228::Option::is_some(&__field69) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("relro-level"));
                                    }
                                    __field69 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<RelroLevel>>(&mut __map)?);
                                }
                                __Field::__field70 => {
                                    if _serde::__private228::Option::is_some(&__field70) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("archive-format"));
                                    }
                                    __field70 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<str>>>(&mut __map)?);
                                }
                                __Field::__field71 => {
                                    if _serde::__private228::Option::is_some(&__field71) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("allow-asm"));
                                    }
                                    __field71 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field72 => {
                                    if _serde::__private228::Option::is_some(&__field72) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("static-initializer-must-be-acyclic"));
                                    }
                                    __field72 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field73 => {
                                    if _serde::__private228::Option::is_some(&__field73) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("main-needs-argc-argv"));
                                    }
                                    __field73 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field74 => {
                                    if _serde::__private228::Option::is_some(&__field74) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("has-thread-local"));
                                    }
                                    __field74 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field75 => {
                                    if _serde::__private228::Option::is_some(&__field75) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("obj-is-bitcode"));
                                    }
                                    __field75 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field76 => {
                                    if _serde::__private228::Option::is_some(&__field76) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("max-atomic-width"));
                                    }
                                    __field76 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<u64>>(&mut __map)?);
                                }
                                __Field::__field77 => {
                                    if _serde::__private228::Option::is_some(&__field77) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("min-atomic-width"));
                                    }
                                    __field77 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<u64>>(&mut __map)?);
                                }
                                __Field::__field78 => {
                                    if _serde::__private228::Option::is_some(&__field78) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("atomic-cas"));
                                    }
                                    __field78 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field79 => {
                                    if _serde::__private228::Option::is_some(&__field79) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("panic-strategy"));
                                    }
                                    __field79 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<PanicStrategy>>(&mut __map)?);
                                }
                                __Field::__field80 => {
                                    if _serde::__private228::Option::is_some(&__field80) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("crt-static-allows-dylibs"));
                                    }
                                    __field80 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field81 => {
                                    if _serde::__private228::Option::is_some(&__field81) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("crt-static-default"));
                                    }
                                    __field81 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field82 => {
                                    if _serde::__private228::Option::is_some(&__field82) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("crt-static-respected"));
                                    }
                                    __field82 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field83 => {
                                    if _serde::__private228::Option::is_some(&__field83) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("stack-probes"));
                                    }
                                    __field83 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StackProbeType>>(&mut __map)?);
                                }
                                __Field::__field84 => {
                                    if _serde::__private228::Option::is_some(&__field84) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("min-global-align"));
                                    }
                                    __field84 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<u64>>(&mut __map)?);
                                }
                                __Field::__field85 => {
                                    if _serde::__private228::Option::is_some(&__field85) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("default-codegen-units"));
                                    }
                                    __field85 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<u64>>(&mut __map)?);
                                }
                                __Field::__field86 => {
                                    if _serde::__private228::Option::is_some(&__field86) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("default-codegen-backend"));
                                    }
                                    __field86 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<str>>>(&mut __map)?);
                                }
                                __Field::__field87 => {
                                    if _serde::__private228::Option::is_some(&__field87) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("trap-unreachable"));
                                    }
                                    __field87 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field88 => {
                                    if _serde::__private228::Option::is_some(&__field88) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("requires-lto"));
                                    }
                                    __field88 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field89 => {
                                    if _serde::__private228::Option::is_some(&__field89) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("singlethread"));
                                    }
                                    __field89 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field90 => {
                                    if _serde::__private228::Option::is_some(&__field90) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("no-builtins"));
                                    }
                                    __field90 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field91 => {
                                    if _serde::__private228::Option::is_some(&__field91) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("default-visibility"));
                                    }
                                    __field91 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<SymbolVisibility>>(&mut __map)?);
                                }
                                __Field::__field92 => {
                                    if _serde::__private228::Option::is_some(&__field92) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("emit-debug-gdb-scripts"));
                                    }
                                    __field92 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field93 => {
                                    if _serde::__private228::Option::is_some(&__field93) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("requires-uwtable"));
                                    }
                                    __field93 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field94 => {
                                    if _serde::__private228::Option::is_some(&__field94) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("default-uwtable"));
                                    }
                                    __field94 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field95 => {
                                    if _serde::__private228::Option::is_some(&__field95) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("simd-types-indirect"));
                                    }
                                    __field95 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field96 => {
                                    if _serde::__private228::Option::is_some(&__field96) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("limit-rdylib-exports"));
                                    }
                                    __field96 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field97 => {
                                    if _serde::__private228::Option::is_some(&__field97) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("override-export-symbols"));
                                    }
                                    __field97 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<[StaticCow<str>]>>>(&mut __map)?);
                                }
                                __Field::__field98 => {
                                    if _serde::__private228::Option::is_some(&__field98) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("merge-functions"));
                                    }
                                    __field98 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<MergeFunctions>>(&mut __map)?);
                                }
                                __Field::__field99 => {
                                    if _serde::__private228::Option::is_some(&__field99) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("target-mcount"));
                                    }
                                    __field99 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<str>>>(&mut __map)?);
                                }
                                __Field::__field100 => {
                                    if _serde::__private228::Option::is_some(&__field100) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("llvm-mcount-intrinsic"));
                                    }
                                    __field100 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<str>>>(&mut __map)?);
                                }
                                __Field::__field101 => {
                                    if _serde::__private228::Option::is_some(&__field101) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("llvm-abiname"));
                                    }
                                    __field101 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<str>>>(&mut __map)?);
                                }
                                __Field::__field102 => {
                                    if _serde::__private228::Option::is_some(&__field102) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("llvm-floatabi"));
                                    }
                                    __field102 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<FloatAbi>>(&mut __map)?);
                                }
                                __Field::__field103 => {
                                    if _serde::__private228::Option::is_some(&__field103) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("rustc-abi"));
                                    }
                                    __field103 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<RustcAbi>>(&mut __map)?);
                                }
                                __Field::__field104 => {
                                    if _serde::__private228::Option::is_some(&__field104) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("relax-elf-relocations"));
                                    }
                                    __field104 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field105 => {
                                    if _serde::__private228::Option::is_some(&__field105) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("llvm-args"));
                                    }
                                    __field105 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<[StaticCow<str>]>>>(&mut __map)?);
                                }
                                __Field::__field106 => {
                                    if _serde::__private228::Option::is_some(&__field106) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("use-ctors-section"));
                                    }
                                    __field106 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field107 => {
                                    if _serde::__private228::Option::is_some(&__field107) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("eh-frame-header"));
                                    }
                                    __field107 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field108 => {
                                    if _serde::__private228::Option::is_some(&__field108) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("has-thumb-interworking"));
                                    }
                                    __field108 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field109 => {
                                    if _serde::__private228::Option::is_some(&__field109) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("debuginfo-kind"));
                                    }
                                    __field109 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<DebuginfoKind>>(&mut __map)?);
                                }
                                __Field::__field110 => {
                                    if _serde::__private228::Option::is_some(&__field110) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("split-debuginfo"));
                                    }
                                    __field110 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<SplitDebuginfo>>(&mut __map)?);
                                }
                                __Field::__field111 => {
                                    if _serde::__private228::Option::is_some(&__field111) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("supported-split-debuginfo"));
                                    }
                                    __field111 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<[SplitDebuginfo]>>>(&mut __map)?);
                                }
                                __Field::__field112 => {
                                    if _serde::__private228::Option::is_some(&__field112) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("supported-sanitizers"));
                                    }
                                    __field112 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<Vec<SanitizerSet>>>(&mut __map)?);
                                }
                                __Field::__field113 => {
                                    if _serde::__private228::Option::is_some(&__field113) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("default-sanitizers"));
                                    }
                                    __field113 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<Vec<SanitizerSet>>>(&mut __map)?);
                                }
                                __Field::__field114 => {
                                    if _serde::__private228::Option::is_some(&__field114) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("generate-arange-section"));
                                    }
                                    __field114 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field115 => {
                                    if _serde::__private228::Option::is_some(&__field115) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("supports-stack-protector"));
                                    }
                                    __field115 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field116 => {
                                    if _serde::__private228::Option::is_some(&__field116) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("small-data-threshold-support"));
                                    }
                                    __field116 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<SmallDataThresholdSupport>>(&mut __map)?);
                                }
                                __Field::__field117 => {
                                    if _serde::__private228::Option::is_some(&__field117) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("entry-name"));
                                    }
                                    __field117 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<StaticCow<str>>>(&mut __map)?);
                                }
                                __Field::__field118 => {
                                    if _serde::__private228::Option::is_some(&__field118) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("supports-xray"));
                                    }
                                    __field118 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<bool>>(&mut __map)?);
                                }
                                __Field::__field119 => {
                                    if _serde::__private228::Option::is_some(&__field119) {
                                        return _serde::__private228::Err(<__A::Error as
                                                        _serde::de::Error>::duplicate_field("entry-abi"));
                                    }
                                    __field119 =
                                        _serde::__private228::Some(_serde::de::MapAccess::next_value::<Option<ExternAbiWrapper>>(&mut __map)?);
                                }
                            }
                        }
                        let __field0 =
                            match __field0 {
                                _serde::__private228::Some(__field0) => __field0,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("llvm-target")?,
                            };
                        let __field1 =
                            match __field1 {
                                _serde::__private228::Some(__field1) => __field1,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("target-pointer-width")?,
                            };
                        let __field2 =
                            match __field2 {
                                _serde::__private228::Some(__field2) => __field2,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("data-layout")?,
                            };
                        let __field3 =
                            match __field3 {
                                _serde::__private228::Some(__field3) => __field3,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("arch")?,
                            };
                        let __field4 =
                            match __field4 {
                                _serde::__private228::Some(__field4) => __field4,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("metadata")?,
                            };
                        let __field5 =
                            match __field5 {
                                _serde::__private228::Some(__field5) => __field5,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("target-endian")?,
                            };
                        let __field6 =
                            match __field6 {
                                _serde::__private228::Some(__field6) => __field6,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("frame-pointer")?,
                            };
                        let __field7 =
                            match __field7 {
                                _serde::__private228::Some(__field7) => __field7,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("target-c-int-width")?,
                            };
                        let __field8 =
                            match __field8 {
                                _serde::__private228::Some(__field8) => __field8,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("c-enum-min-bits")?,
                            };
                        let __field9 =
                            match __field9 {
                                _serde::__private228::Some(__field9) => __field9,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("os")?,
                            };
                        let __field10 =
                            match __field10 {
                                _serde::__private228::Some(__field10) => __field10,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("env")?,
                            };
                        let __field11 =
                            match __field11 {
                                _serde::__private228::Some(__field11) => __field11,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("abi")?,
                            };
                        let __field12 =
                            match __field12 {
                                _serde::__private228::Some(__field12) => __field12,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("vendor")?,
                            };
                        let __field13 =
                            match __field13 {
                                _serde::__private228::Some(__field13) => __field13,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("linker")?,
                            };
                        let __field14 =
                            match __field14 {
                                _serde::__private228::Some(__field14) => __field14,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("linker-flavor")?,
                            };
                        let __field15 =
                            match __field15 {
                                _serde::__private228::Some(__field15) => __field15,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("lld-flavor")?,
                            };
                        let __field16 =
                            match __field16 {
                                _serde::__private228::Some(__field16) => __field16,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("linker-is-gnu")?,
                            };
                        let __field17 =
                            match __field17 {
                                _serde::__private228::Some(__field17) => __field17,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("pre-link-objects")?,
                            };
                        let __field18 =
                            match __field18 {
                                _serde::__private228::Some(__field18) => __field18,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("post-link-objects")?,
                            };
                        let __field19 =
                            match __field19 {
                                _serde::__private228::Some(__field19) => __field19,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("pre-link-objects-fallback")?,
                            };
                        let __field20 =
                            match __field20 {
                                _serde::__private228::Some(__field20) => __field20,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("post-link-objects-fallback")?,
                            };
                        let __field21 =
                            match __field21 {
                                _serde::__private228::Some(__field21) => __field21,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("crt-objects-fallback")?,
                            };
                        let __field22 =
                            match __field22 {
                                _serde::__private228::Some(__field22) => __field22,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("link-self-contained")?,
                            };
                        let __field23 =
                            match __field23 {
                                _serde::__private228::Some(__field23) => __field23,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("pre-link-args")?,
                            };
                        let __field24 =
                            match __field24 {
                                _serde::__private228::Some(__field24) => __field24,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("late-link-args")?,
                            };
                        let __field25 =
                            match __field25 {
                                _serde::__private228::Some(__field25) => __field25,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("late-link-args-dynamic")?,
                            };
                        let __field26 =
                            match __field26 {
                                _serde::__private228::Some(__field26) => __field26,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("late-link-args-static")?,
                            };
                        let __field27 =
                            match __field27 {
                                _serde::__private228::Some(__field27) => __field27,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("post-link-args")?,
                            };
                        let __field28 =
                            match __field28 {
                                _serde::__private228::Some(__field28) => __field28,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("link-script")?,
                            };
                        let __field29 =
                            match __field29 {
                                _serde::__private228::Some(__field29) => __field29,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("link-env")?,
                            };
                        let __field30 =
                            match __field30 {
                                _serde::__private228::Some(__field30) => __field30,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("link-env-remove")?,
                            };
                        let __field31 =
                            match __field31 {
                                _serde::__private228::Some(__field31) => __field31,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("asm-args")?,
                            };
                        let __field32 =
                            match __field32 {
                                _serde::__private228::Some(__field32) => __field32,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("cpu")?,
                            };
                        let __field33 =
                            match __field33 {
                                _serde::__private228::Some(__field33) => __field33,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("need-explicit-cpu")?,
                            };
                        let __field34 =
                            match __field34 {
                                _serde::__private228::Some(__field34) => __field34,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("features")?,
                            };
                        let __field35 =
                            match __field35 {
                                _serde::__private228::Some(__field35) => __field35,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("dynamic-linking")?,
                            };
                        let __field36 =
                            match __field36 {
                                _serde::__private228::Some(__field36) => __field36,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("direct-access-external-data")?,
                            };
                        let __field37 =
                            match __field37 {
                                _serde::__private228::Some(__field37) => __field37,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("dll-tls-export")?,
                            };
                        let __field38 =
                            match __field38 {
                                _serde::__private228::Some(__field38) => __field38,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("only-cdylib")?,
                            };
                        let __field39 =
                            match __field39 {
                                _serde::__private228::Some(__field39) => __field39,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("executables")?,
                            };
                        let __field40 =
                            match __field40 {
                                _serde::__private228::Some(__field40) => __field40,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("relocation-model")?,
                            };
                        let __field41 =
                            match __field41 {
                                _serde::__private228::Some(__field41) => __field41,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("code-model")?,
                            };
                        let __field42 =
                            match __field42 {
                                _serde::__private228::Some(__field42) => __field42,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("tls-model")?,
                            };
                        let __field43 =
                            match __field43 {
                                _serde::__private228::Some(__field43) => __field43,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("disable-redzone")?,
                            };
                        let __field44 =
                            match __field44 {
                                _serde::__private228::Some(__field44) => __field44,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("function-sections")?,
                            };
                        let __field45 =
                            match __field45 {
                                _serde::__private228::Some(__field45) => __field45,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("dll-prefix")?,
                            };
                        let __field46 =
                            match __field46 {
                                _serde::__private228::Some(__field46) => __field46,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("dll-suffix")?,
                            };
                        let __field47 =
                            match __field47 {
                                _serde::__private228::Some(__field47) => __field47,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("exe-suffix")?,
                            };
                        let __field48 =
                            match __field48 {
                                _serde::__private228::Some(__field48) => __field48,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("staticlib-prefix")?,
                            };
                        let __field49 =
                            match __field49 {
                                _serde::__private228::Some(__field49) => __field49,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("staticlib-suffix")?,
                            };
                        let __field50 =
                            match __field50 {
                                _serde::__private228::Some(__field50) => __field50,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("target-family")?,
                            };
                        let __field51 =
                            match __field51 {
                                _serde::__private228::Some(__field51) => __field51,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("abi-return-struct-as-int")?,
                            };
                        let __field52 =
                            match __field52 {
                                _serde::__private228::Some(__field52) => __field52,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("is-like-aix")?,
                            };
                        let __field53 =
                            match __field53 {
                                _serde::__private228::Some(__field53) => __field53,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("is-like-darwin")?,
                            };
                        let __field54 =
                            match __field54 {
                                _serde::__private228::Some(__field54) => __field54,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("is-like-solaris")?,
                            };
                        let __field55 =
                            match __field55 {
                                _serde::__private228::Some(__field55) => __field55,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("is-like-windows")?,
                            };
                        let __field56 =
                            match __field56 {
                                _serde::__private228::Some(__field56) => __field56,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("is-like-gpu")?,
                            };
                        let __field57 =
                            match __field57 {
                                _serde::__private228::Some(__field57) => __field57,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("is-like-msvc")?,
                            };
                        let __field58 =
                            match __field58 {
                                _serde::__private228::Some(__field58) => __field58,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("is-like-wasm")?,
                            };
                        let __field59 =
                            match __field59 {
                                _serde::__private228::Some(__field59) => __field59,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("is-like-android")?,
                            };
                        let __field60 =
                            match __field60 {
                                _serde::__private228::Some(__field60) => __field60,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("is-like-vexos")?,
                            };
                        let __field61 =
                            match __field61 {
                                _serde::__private228::Some(__field61) => __field61,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("binary-format")?,
                            };
                        let __field62 =
                            match __field62 {
                                _serde::__private228::Some(__field62) => __field62,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("default-dwarf-version")?,
                            };
                        let __field63 =
                            match __field63 {
                                _serde::__private228::Some(__field63) => __field63,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("allows-weak-linkage")?,
                            };
                        let __field64 =
                            match __field64 {
                                _serde::__private228::Some(__field64) => __field64,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("has-rpath")?,
                            };
                        let __field65 =
                            match __field65 {
                                _serde::__private228::Some(__field65) => __field65,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("no-default-libraries")?,
                            };
                        let __field66 =
                            match __field66 {
                                _serde::__private228::Some(__field66) => __field66,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("position-independent-executables")?,
                            };
                        let __field67 =
                            match __field67 {
                                _serde::__private228::Some(__field67) => __field67,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("static-position-independent-executables")?,
                            };
                        let __field68 =
                            match __field68 {
                                _serde::__private228::Some(__field68) => __field68,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("plt-by-default")?,
                            };
                        let __field69 =
                            match __field69 {
                                _serde::__private228::Some(__field69) => __field69,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("relro-level")?,
                            };
                        let __field70 =
                            match __field70 {
                                _serde::__private228::Some(__field70) => __field70,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("archive-format")?,
                            };
                        let __field71 =
                            match __field71 {
                                _serde::__private228::Some(__field71) => __field71,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("allow-asm")?,
                            };
                        let __field72 =
                            match __field72 {
                                _serde::__private228::Some(__field72) => __field72,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("static-initializer-must-be-acyclic")?,
                            };
                        let __field73 =
                            match __field73 {
                                _serde::__private228::Some(__field73) => __field73,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("main-needs-argc-argv")?,
                            };
                        let __field74 =
                            match __field74 {
                                _serde::__private228::Some(__field74) => __field74,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("has-thread-local")?,
                            };
                        let __field75 =
                            match __field75 {
                                _serde::__private228::Some(__field75) => __field75,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("obj-is-bitcode")?,
                            };
                        let __field76 =
                            match __field76 {
                                _serde::__private228::Some(__field76) => __field76,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("max-atomic-width")?,
                            };
                        let __field77 =
                            match __field77 {
                                _serde::__private228::Some(__field77) => __field77,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("min-atomic-width")?,
                            };
                        let __field78 =
                            match __field78 {
                                _serde::__private228::Some(__field78) => __field78,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("atomic-cas")?,
                            };
                        let __field79 =
                            match __field79 {
                                _serde::__private228::Some(__field79) => __field79,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("panic-strategy")?,
                            };
                        let __field80 =
                            match __field80 {
                                _serde::__private228::Some(__field80) => __field80,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("crt-static-allows-dylibs")?,
                            };
                        let __field81 =
                            match __field81 {
                                _serde::__private228::Some(__field81) => __field81,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("crt-static-default")?,
                            };
                        let __field82 =
                            match __field82 {
                                _serde::__private228::Some(__field82) => __field82,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("crt-static-respected")?,
                            };
                        let __field83 =
                            match __field83 {
                                _serde::__private228::Some(__field83) => __field83,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("stack-probes")?,
                            };
                        let __field84 =
                            match __field84 {
                                _serde::__private228::Some(__field84) => __field84,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("min-global-align")?,
                            };
                        let __field85 =
                            match __field85 {
                                _serde::__private228::Some(__field85) => __field85,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("default-codegen-units")?,
                            };
                        let __field86 =
                            match __field86 {
                                _serde::__private228::Some(__field86) => __field86,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("default-codegen-backend")?,
                            };
                        let __field87 =
                            match __field87 {
                                _serde::__private228::Some(__field87) => __field87,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("trap-unreachable")?,
                            };
                        let __field88 =
                            match __field88 {
                                _serde::__private228::Some(__field88) => __field88,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("requires-lto")?,
                            };
                        let __field89 =
                            match __field89 {
                                _serde::__private228::Some(__field89) => __field89,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("singlethread")?,
                            };
                        let __field90 =
                            match __field90 {
                                _serde::__private228::Some(__field90) => __field90,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("no-builtins")?,
                            };
                        let __field91 =
                            match __field91 {
                                _serde::__private228::Some(__field91) => __field91,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("default-visibility")?,
                            };
                        let __field92 =
                            match __field92 {
                                _serde::__private228::Some(__field92) => __field92,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("emit-debug-gdb-scripts")?,
                            };
                        let __field93 =
                            match __field93 {
                                _serde::__private228::Some(__field93) => __field93,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("requires-uwtable")?,
                            };
                        let __field94 =
                            match __field94 {
                                _serde::__private228::Some(__field94) => __field94,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("default-uwtable")?,
                            };
                        let __field95 =
                            match __field95 {
                                _serde::__private228::Some(__field95) => __field95,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("simd-types-indirect")?,
                            };
                        let __field96 =
                            match __field96 {
                                _serde::__private228::Some(__field96) => __field96,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("limit-rdylib-exports")?,
                            };
                        let __field97 =
                            match __field97 {
                                _serde::__private228::Some(__field97) => __field97,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("override-export-symbols")?,
                            };
                        let __field98 =
                            match __field98 {
                                _serde::__private228::Some(__field98) => __field98,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("merge-functions")?,
                            };
                        let __field99 =
                            match __field99 {
                                _serde::__private228::Some(__field99) => __field99,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("target-mcount")?,
                            };
                        let __field100 =
                            match __field100 {
                                _serde::__private228::Some(__field100) => __field100,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("llvm-mcount-intrinsic")?,
                            };
                        let __field101 =
                            match __field101 {
                                _serde::__private228::Some(__field101) => __field101,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("llvm-abiname")?,
                            };
                        let __field102 =
                            match __field102 {
                                _serde::__private228::Some(__field102) => __field102,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("llvm-floatabi")?,
                            };
                        let __field103 =
                            match __field103 {
                                _serde::__private228::Some(__field103) => __field103,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("rustc-abi")?,
                            };
                        let __field104 =
                            match __field104 {
                                _serde::__private228::Some(__field104) => __field104,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("relax-elf-relocations")?,
                            };
                        let __field105 =
                            match __field105 {
                                _serde::__private228::Some(__field105) => __field105,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("llvm-args")?,
                            };
                        let __field106 =
                            match __field106 {
                                _serde::__private228::Some(__field106) => __field106,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("use-ctors-section")?,
                            };
                        let __field107 =
                            match __field107 {
                                _serde::__private228::Some(__field107) => __field107,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("eh-frame-header")?,
                            };
                        let __field108 =
                            match __field108 {
                                _serde::__private228::Some(__field108) => __field108,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("has-thumb-interworking")?,
                            };
                        let __field109 =
                            match __field109 {
                                _serde::__private228::Some(__field109) => __field109,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("debuginfo-kind")?,
                            };
                        let __field110 =
                            match __field110 {
                                _serde::__private228::Some(__field110) => __field110,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("split-debuginfo")?,
                            };
                        let __field111 =
                            match __field111 {
                                _serde::__private228::Some(__field111) => __field111,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("supported-split-debuginfo")?,
                            };
                        let __field112 =
                            match __field112 {
                                _serde::__private228::Some(__field112) => __field112,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("supported-sanitizers")?,
                            };
                        let __field113 =
                            match __field113 {
                                _serde::__private228::Some(__field113) => __field113,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("default-sanitizers")?,
                            };
                        let __field114 =
                            match __field114 {
                                _serde::__private228::Some(__field114) => __field114,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("generate-arange-section")?,
                            };
                        let __field115 =
                            match __field115 {
                                _serde::__private228::Some(__field115) => __field115,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("supports-stack-protector")?,
                            };
                        let __field116 =
                            match __field116 {
                                _serde::__private228::Some(__field116) => __field116,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("small-data-threshold-support")?,
                            };
                        let __field117 =
                            match __field117 {
                                _serde::__private228::Some(__field117) => __field117,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("entry-name")?,
                            };
                        let __field118 =
                            match __field118 {
                                _serde::__private228::Some(__field118) => __field118,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("supports-xray")?,
                            };
                        let __field119 =
                            match __field119 {
                                _serde::__private228::Some(__field119) => __field119,
                                _serde::__private228::None =>
                                    _serde::__private228::de::missing_field("entry-abi")?,
                            };
                        _serde::__private228::Ok(TargetSpecJson {
                                llvm_target: __field0,
                                target_pointer_width: __field1,
                                data_layout: __field2,
                                arch: __field3,
                                metadata: __field4,
                                target_endian: __field5,
                                frame_pointer: __field6,
                                c_int_width: __field7,
                                c_enum_min_bits: __field8,
                                os: __field9,
                                env: __field10,
                                abi: __field11,
                                vendor: __field12,
                                linker: __field13,
                                linker_flavor_json: __field14,
                                lld_flavor_json: __field15,
                                linker_is_gnu_json: __field16,
                                pre_link_objects: __field17,
                                post_link_objects: __field18,
                                pre_link_objects_self_contained: __field19,
                                post_link_objects_self_contained: __field20,
                                link_self_contained_backwards_compatible: __field21,
                                link_self_contained: __field22,
                                pre_link_args_json: __field23,
                                late_link_args_json: __field24,
                                late_link_args_dynamic_json: __field25,
                                late_link_args_static_json: __field26,
                                post_link_args_json: __field27,
                                link_script: __field28,
                                link_env: __field29,
                                link_env_remove: __field30,
                                asm_args: __field31,
                                cpu: __field32,
                                need_explicit_cpu: __field33,
                                features: __field34,
                                dynamic_linking: __field35,
                                direct_access_external_data: __field36,
                                dll_tls_export: __field37,
                                only_cdylib: __field38,
                                executables: __field39,
                                relocation_model: __field40,
                                code_model: __field41,
                                tls_model: __field42,
                                disable_redzone: __field43,
                                function_sections: __field44,
                                dll_prefix: __field45,
                                dll_suffix: __field46,
                                exe_suffix: __field47,
                                staticlib_prefix: __field48,
                                staticlib_suffix: __field49,
                                target_family: __field50,
                                abi_return_struct_as_int: __field51,
                                is_like_aix: __field52,
                                is_like_darwin: __field53,
                                is_like_solaris: __field54,
                                is_like_windows: __field55,
                                is_like_gpu: __field56,
                                is_like_msvc: __field57,
                                is_like_wasm: __field58,
                                is_like_android: __field59,
                                is_like_vexos: __field60,
                                binary_format: __field61,
                                default_dwarf_version: __field62,
                                allows_weak_linkage: __field63,
                                has_rpath: __field64,
                                no_default_libraries: __field65,
                                position_independent_executables: __field66,
                                static_position_independent_executables: __field67,
                                plt_by_default: __field68,
                                relro_level: __field69,
                                archive_format: __field70,
                                allow_asm: __field71,
                                static_initializer_must_be_acyclic: __field72,
                                main_needs_argc_argv: __field73,
                                has_thread_local: __field74,
                                obj_is_bitcode: __field75,
                                max_atomic_width: __field76,
                                min_atomic_width: __field77,
                                atomic_cas: __field78,
                                panic_strategy: __field79,
                                crt_static_allows_dylibs: __field80,
                                crt_static_default: __field81,
                                crt_static_respected: __field82,
                                stack_probes: __field83,
                                min_global_align: __field84,
                                default_codegen_units: __field85,
                                default_codegen_backend: __field86,
                                trap_unreachable: __field87,
                                requires_lto: __field88,
                                singlethread: __field89,
                                no_builtins: __field90,
                                default_visibility: __field91,
                                emit_debug_gdb_scripts: __field92,
                                requires_uwtable: __field93,
                                default_uwtable: __field94,
                                simd_types_indirect: __field95,
                                limit_rdylib_exports: __field96,
                                override_export_symbols: __field97,
                                merge_functions: __field98,
                                mcount: __field99,
                                llvm_mcount_intrinsic: __field100,
                                llvm_abiname: __field101,
                                llvm_floatabi: __field102,
                                rustc_abi: __field103,
                                relax_elf_relocations: __field104,
                                llvm_args: __field105,
                                use_ctors_section: __field106,
                                eh_frame_header: __field107,
                                has_thumb_interworking: __field108,
                                debuginfo_kind: __field109,
                                split_debuginfo: __field110,
                                supported_split_debuginfo: __field111,
                                supported_sanitizers: __field112,
                                default_sanitizers: __field113,
                                generate_arange_section: __field114,
                                supports_stack_protector: __field115,
                                small_data_threshold_support: __field116,
                                entry_name: __field117,
                                supports_xray: __field118,
                                entry_abi: __field119,
                            })
                    }
                }
                #[doc(hidden)]
                const FIELDS: &'static [&'static str] =
                    &["llvm-target", "target-pointer-width", "data-layout",
                                "arch", "metadata", "target-endian", "frame-pointer",
                                "target-c-int-width", "c-enum-min-bits", "os", "env", "abi",
                                "vendor", "linker", "linker-flavor", "lld-flavor",
                                "linker-is-gnu", "pre-link-objects", "post-link-objects",
                                "pre-link-objects-fallback", "post-link-objects-fallback",
                                "crt-objects-fallback", "link-self-contained",
                                "pre-link-args", "late-link-args", "late-link-args-dynamic",
                                "late-link-args-static", "post-link-args", "link-script",
                                "link-env", "link-env-remove", "asm-args", "cpu",
                                "need-explicit-cpu", "features", "dynamic-linking",
                                "direct-access-external-data", "dll-tls-export",
                                "only-cdylib", "executables", "relocation-model",
                                "code-model", "tls-model", "disable-redzone",
                                "function-sections", "dll-prefix", "dll-suffix",
                                "exe-suffix", "staticlib-prefix", "staticlib-suffix",
                                "target-family", "abi-return-struct-as-int", "is-like-aix",
                                "is-like-darwin", "is-like-solaris", "is-like-windows",
                                "is-like-gpu", "is-like-msvc", "is-like-wasm",
                                "is-like-android", "is-like-vexos", "binary-format",
                                "default-dwarf-version", "allows-weak-linkage", "has-rpath",
                                "no-default-libraries", "position-independent-executables",
                                "static-position-independent-executables", "plt-by-default",
                                "relro-level", "archive-format", "allow-asm",
                                "static-initializer-must-be-acyclic",
                                "main-needs-argc-argv", "has-thread-local",
                                "obj-is-bitcode", "max-atomic-width", "min-atomic-width",
                                "atomic-cas", "panic-strategy", "crt-static-allows-dylibs",
                                "crt-static-default", "crt-static-respected",
                                "stack-probes", "min-global-align", "default-codegen-units",
                                "default-codegen-backend", "trap-unreachable",
                                "requires-lto", "singlethread", "no-builtins",
                                "default-visibility", "emit-debug-gdb-scripts",
                                "requires-uwtable", "default-uwtable",
                                "simd-types-indirect", "limit-rdylib-exports",
                                "override-export-symbols", "merge-functions",
                                "target-mcount", "llvm-mcount-intrinsic", "llvm-abiname",
                                "llvm-floatabi", "rustc-abi", "relax-elf-relocations",
                                "llvm-args", "use-ctors-section", "eh-frame-header",
                                "has-thumb-interworking", "debuginfo-kind",
                                "split-debuginfo", "supported-split-debuginfo",
                                "supported-sanitizers", "default-sanitizers",
                                "generate-arange-section", "supports-stack-protector",
                                "small-data-threshold-support", "entry-name",
                                "supports-xray", "entry-abi"];
                _serde::Deserializer::deserialize_struct(__deserializer,
                    "TargetSpecJson", FIELDS,
                    __Visitor {
                        marker: _serde::__private228::PhantomData::<TargetSpecJson>,
                        lifetime: _serde::__private228::PhantomData,
                    })
            }
        }
    };serde_derive::Deserialize, const _: () =
    {
        #[automatically_derived]
        #[allow(unused_braces)]
        impl schemars::JsonSchema for TargetSpecJson {
            fn schema_name()
                -> schemars::_private::alloc::borrow::Cow<'static, str> {
                schemars::_private::alloc::borrow::Cow::Borrowed("TargetSpecJson")
            }
            fn schema_id()
                -> schemars::_private::alloc::borrow::Cow<'static, str> {
                schemars::_private::alloc::borrow::Cow::Borrowed("rustc_target::spec::json::TargetSpecJson")
            }
            fn json_schema(generator: &mut schemars::SchemaGenerator)
                -> schemars::Schema {
                {
                    let mut schema =
                        <::schemars::Schema as
                                    ::core::convert::TryFrom<_>>::try_from(::serde_json::Value::Object({
                                        let mut object = ::serde_json::Map::new();
                                        let _ =
                                            object.insert(("type").into(),
                                                ::serde_json::to_value(&"object").unwrap());
                                        let _ =
                                            object.insert(("additionalProperties").into(),
                                                ::serde_json::Value::Bool(false));
                                        ;
                                        object
                                    })).unwrap();
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "llvm-target",
                            generator.contract().is_deserialize() &&
                                <StaticCow<str> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<StaticCow<str>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "target-pointer-width",
                            generator.contract().is_deserialize() &&
                                <u16 as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<u16>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "data-layout",
                            generator.contract().is_deserialize() &&
                                <StaticCow<str> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<StaticCow<str>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "arch",
                            generator.contract().is_deserialize() &&
                                <Arch as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Arch>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "metadata",
                            generator.contract().is_deserialize() &&
                                <Option<TargetSpecJsonMetadata> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            {
                                generator.subschema_for::<Option<TargetSpecJsonMetadata>>()
                            });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "target-endian",
                            generator.contract().is_deserialize() &&
                                <Option<EndianWrapper> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<EndianWrapper>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "frame-pointer",
                            generator.contract().is_deserialize() &&
                                <Option<FramePointer> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<FramePointer>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "target-c-int-width",
                            generator.contract().is_deserialize() &&
                                <Option<u16> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<u16>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "c-enum-min-bits",
                            generator.contract().is_deserialize() &&
                                <Option<u64> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<u64>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "os",
                            generator.contract().is_deserialize() &&
                                <Option<Os> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<Os>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "env",
                            generator.contract().is_deserialize() &&
                                <Option<Env> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<Env>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "abi",
                            generator.contract().is_deserialize() &&
                                <Option<Abi> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<Abi>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "vendor",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<str>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<StaticCow<str>>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "linker",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<str>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<StaticCow<str>>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "linker-flavor",
                            generator.contract().is_deserialize() &&
                                <Option<LinkerFlavorCli> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<LinkerFlavorCli>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "lld-flavor",
                            generator.contract().is_deserialize() &&
                                <Option<LldFlavor> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<LldFlavor>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "linker-is-gnu",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "pre-link-objects",
                            generator.contract().is_deserialize() &&
                                <Option<CrtObjects> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<CrtObjects>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "post-link-objects",
                            generator.contract().is_deserialize() &&
                                <Option<CrtObjects> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<CrtObjects>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "pre-link-objects-fallback",
                            generator.contract().is_deserialize() &&
                                <Option<CrtObjects> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<CrtObjects>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "post-link-objects-fallback",
                            generator.contract().is_deserialize() &&
                                <Option<CrtObjects> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<CrtObjects>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "crt-objects-fallback",
                            generator.contract().is_deserialize() &&
                                <Option<LinkSelfContainedDefault> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            {
                                generator.subschema_for::<Option<LinkSelfContainedDefault>>()
                            });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "link-self-contained",
                            generator.contract().is_deserialize() &&
                                <Option<LinkSelfContainedComponentsWrapper> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            {
                                generator.subschema_for::<Option<LinkSelfContainedComponentsWrapper>>()
                            });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "pre-link-args",
                            generator.contract().is_deserialize() &&
                                <Option<LinkArgsCli> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<LinkArgsCli>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "late-link-args",
                            generator.contract().is_deserialize() &&
                                <Option<LinkArgsCli> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<LinkArgsCli>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "late-link-args-dynamic",
                            generator.contract().is_deserialize() &&
                                <Option<LinkArgsCli> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<LinkArgsCli>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "late-link-args-static",
                            generator.contract().is_deserialize() &&
                                <Option<LinkArgsCli> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<LinkArgsCli>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "post-link-args",
                            generator.contract().is_deserialize() &&
                                <Option<LinkArgsCli> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<LinkArgsCli>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "link-script",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<str>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<StaticCow<str>>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "link-env",
                            generator.contract().is_deserialize() &&
                                <Option<Vec<StaticCow<str>>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            {
                                generator.subschema_for::<Option<Vec<StaticCow<str>>>>()
                            });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "link-env-remove",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<[StaticCow<str>]>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            {
                                generator.subschema_for::<Option<StaticCow<[StaticCow<str>]>>>()
                            });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "asm-args",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<[StaticCow<str>]>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            {
                                generator.subschema_for::<Option<StaticCow<[StaticCow<str>]>>>()
                            });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "cpu",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<str>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<StaticCow<str>>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "need-explicit-cpu",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "features",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<str>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<StaticCow<str>>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "dynamic-linking",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "direct-access-external-data",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "dll-tls-export",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "only-cdylib",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "executables",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "relocation-model",
                            generator.contract().is_deserialize() &&
                                <Option<RelocModel> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<RelocModel>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "code-model",
                            generator.contract().is_deserialize() &&
                                <Option<CodeModel> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<CodeModel>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "tls-model",
                            generator.contract().is_deserialize() &&
                                <Option<TlsModel> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<TlsModel>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "disable-redzone",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "function-sections",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "dll-prefix",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<str>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<StaticCow<str>>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "dll-suffix",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<str>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<StaticCow<str>>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "exe-suffix",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<str>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<StaticCow<str>>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "staticlib-prefix",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<str>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<StaticCow<str>>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "staticlib-suffix",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<str>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<StaticCow<str>>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "target-family",
                            generator.contract().is_deserialize() &&
                                <Option<TargetFamiliesJson> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            {
                                generator.subschema_for::<Option<TargetFamiliesJson>>()
                            });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "abi-return-struct-as-int",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "is-like-aix",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "is-like-darwin",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "is-like-solaris",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "is-like-windows",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "is-like-gpu",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "is-like-msvc",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "is-like-wasm",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "is-like-android",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "is-like-vexos",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "binary-format",
                            generator.contract().is_deserialize() &&
                                <Option<BinaryFormat> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<BinaryFormat>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "default-dwarf-version",
                            generator.contract().is_deserialize() &&
                                <Option<u32> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<u32>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "allows-weak-linkage",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "has-rpath",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "no-default-libraries",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "position-independent-executables",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "static-position-independent-executables",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "plt-by-default",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "relro-level",
                            generator.contract().is_deserialize() &&
                                <Option<RelroLevel> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<RelroLevel>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "archive-format",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<str>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<StaticCow<str>>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "allow-asm",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "static-initializer-must-be-acyclic",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "main-needs-argc-argv",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "has-thread-local",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "obj-is-bitcode",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "max-atomic-width",
                            generator.contract().is_deserialize() &&
                                <Option<u64> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<u64>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "min-atomic-width",
                            generator.contract().is_deserialize() &&
                                <Option<u64> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<u64>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "atomic-cas",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "panic-strategy",
                            generator.contract().is_deserialize() &&
                                <Option<PanicStrategy> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<PanicStrategy>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "crt-static-allows-dylibs",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "crt-static-default",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "crt-static-respected",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "stack-probes",
                            generator.contract().is_deserialize() &&
                                <Option<StackProbeType> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<StackProbeType>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "min-global-align",
                            generator.contract().is_deserialize() &&
                                <Option<u64> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<u64>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "default-codegen-units",
                            generator.contract().is_deserialize() &&
                                <Option<u64> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<u64>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "default-codegen-backend",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<str>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<StaticCow<str>>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "trap-unreachable",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "requires-lto",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "singlethread",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "no-builtins",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "default-visibility",
                            generator.contract().is_deserialize() &&
                                <Option<SymbolVisibility> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<SymbolVisibility>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "emit-debug-gdb-scripts",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "requires-uwtable",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "default-uwtable",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "simd-types-indirect",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "limit-rdylib-exports",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "override-export-symbols",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<[StaticCow<str>]>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            {
                                generator.subschema_for::<Option<StaticCow<[StaticCow<str>]>>>()
                            });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "merge-functions",
                            generator.contract().is_deserialize() &&
                                <Option<MergeFunctions> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<MergeFunctions>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "target-mcount",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<str>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<StaticCow<str>>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "llvm-mcount-intrinsic",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<str>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<StaticCow<str>>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "llvm-abiname",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<str>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<StaticCow<str>>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "llvm-floatabi",
                            generator.contract().is_deserialize() &&
                                <Option<FloatAbi> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<FloatAbi>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "rustc-abi",
                            generator.contract().is_deserialize() &&
                                <Option<RustcAbi> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<RustcAbi>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "relax-elf-relocations",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "llvm-args",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<[StaticCow<str>]>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            {
                                generator.subschema_for::<Option<StaticCow<[StaticCow<str>]>>>()
                            });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "use-ctors-section",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "eh-frame-header",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "has-thumb-interworking",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "debuginfo-kind",
                            generator.contract().is_deserialize() &&
                                <Option<DebuginfoKind> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<DebuginfoKind>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "split-debuginfo",
                            generator.contract().is_deserialize() &&
                                <Option<SplitDebuginfo> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<SplitDebuginfo>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "supported-split-debuginfo",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<[SplitDebuginfo]>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            {
                                generator.subschema_for::<Option<StaticCow<[SplitDebuginfo]>>>()
                            });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "supported-sanitizers",
                            generator.contract().is_deserialize() &&
                                <Option<Vec<SanitizerSet>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<Vec<SanitizerSet>>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "default-sanitizers",
                            generator.contract().is_deserialize() &&
                                <Option<Vec<SanitizerSet>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<Vec<SanitizerSet>>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "generate-arange-section",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "supports-stack-protector",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "small-data-threshold-support",
                            generator.contract().is_deserialize() &&
                                <Option<SmallDataThresholdSupport> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            {
                                generator.subschema_for::<Option<SmallDataThresholdSupport>>()
                            });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "entry-name",
                            generator.contract().is_deserialize() &&
                                <Option<StaticCow<str>> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<StaticCow<str>>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "supports-xray",
                            generator.contract().is_deserialize() &&
                                <Option<bool> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<bool>>() });
                    }
                    {
                        schemars::_private::insert_object_property(&mut schema,
                            "entry-abi",
                            generator.contract().is_deserialize() &&
                                <Option<ExternAbiWrapper> as
                                        schemars::JsonSchema>::_schemars_private_is_option(),
                            { generator.subschema_for::<Option<ExternAbiWrapper>>() });
                    }
                    schema
                }
            }
            fn inline_schema() -> bool { false }
        }
        ;
    };schemars::JsonSchema)]
491#[serde(rename_all = "kebab-case")]
492// Ensure that all unexpected fields get turned into errors.
493// This helps users stay up to date when the schema changes instead of silently
494// ignoring their old values.
495#[serde(deny_unknown_fields)]
496struct TargetSpecJson {
497    llvm_target: StaticCow<str>,
498    target_pointer_width: u16,
499    data_layout: StaticCow<str>,
500    arch: Arch,
501
502    metadata: Option<TargetSpecJsonMetadata>,
503
504    // options:
505    target_endian: Option<EndianWrapper>,
506    frame_pointer: Option<FramePointer>,
507    #[serde(rename = "target-c-int-width")]
508    c_int_width: Option<u16>,
509    c_enum_min_bits: Option<u64>,
510    os: Option<Os>,
511    env: Option<Env>,
512    abi: Option<Abi>,
513    vendor: Option<StaticCow<str>>,
514    linker: Option<StaticCow<str>>,
515    #[serde(rename = "linker-flavor")]
516    linker_flavor_json: Option<LinkerFlavorCli>,
517    #[serde(rename = "lld-flavor")]
518    lld_flavor_json: Option<LldFlavor>,
519    #[serde(rename = "linker-is-gnu")]
520    linker_is_gnu_json: Option<bool>,
521    #[serde(rename = "pre-link-objects")]
522    pre_link_objects: Option<CrtObjects>,
523    #[serde(rename = "post-link-objects")]
524    post_link_objects: Option<CrtObjects>,
525    #[serde(rename = "pre-link-objects-fallback")]
526    pre_link_objects_self_contained: Option<CrtObjects>,
527    #[serde(rename = "post-link-objects-fallback")]
528    post_link_objects_self_contained: Option<CrtObjects>,
529    #[serde(rename = "crt-objects-fallback")]
530    link_self_contained_backwards_compatible: Option<LinkSelfContainedDefault>,
531    link_self_contained: Option<LinkSelfContainedComponentsWrapper>,
532    #[serde(rename = "pre-link-args")]
533    pre_link_args_json: Option<LinkArgsCli>,
534    #[serde(rename = "late-link-args")]
535    late_link_args_json: Option<LinkArgsCli>,
536    #[serde(rename = "late-link-args-dynamic")]
537    late_link_args_dynamic_json: Option<LinkArgsCli>,
538    #[serde(rename = "late-link-args-static")]
539    late_link_args_static_json: Option<LinkArgsCli>,
540    #[serde(rename = "post-link-args")]
541    post_link_args_json: Option<LinkArgsCli>,
542    link_script: Option<StaticCow<str>>,
543    link_env: Option<Vec<StaticCow<str>>>,
544    link_env_remove: Option<StaticCow<[StaticCow<str>]>>,
545    asm_args: Option<StaticCow<[StaticCow<str>]>>,
546    cpu: Option<StaticCow<str>>,
547    need_explicit_cpu: Option<bool>,
548    features: Option<StaticCow<str>>,
549    dynamic_linking: Option<bool>,
550    direct_access_external_data: Option<bool>,
551    dll_tls_export: Option<bool>,
552    only_cdylib: Option<bool>,
553    executables: Option<bool>,
554    relocation_model: Option<RelocModel>,
555    code_model: Option<CodeModel>,
556    tls_model: Option<TlsModel>,
557    disable_redzone: Option<bool>,
558    function_sections: Option<bool>,
559    dll_prefix: Option<StaticCow<str>>,
560    dll_suffix: Option<StaticCow<str>>,
561    exe_suffix: Option<StaticCow<str>>,
562    staticlib_prefix: Option<StaticCow<str>>,
563    staticlib_suffix: Option<StaticCow<str>>,
564    target_family: Option<TargetFamiliesJson>,
565    abi_return_struct_as_int: Option<bool>,
566    is_like_aix: Option<bool>,
567    is_like_darwin: Option<bool>,
568    is_like_solaris: Option<bool>,
569    is_like_windows: Option<bool>,
570    is_like_gpu: Option<bool>,
571    is_like_msvc: Option<bool>,
572    is_like_wasm: Option<bool>,
573    is_like_android: Option<bool>,
574    is_like_vexos: Option<bool>,
575    binary_format: Option<BinaryFormat>,
576    default_dwarf_version: Option<u32>,
577    allows_weak_linkage: Option<bool>,
578    has_rpath: Option<bool>,
579    no_default_libraries: Option<bool>,
580    position_independent_executables: Option<bool>,
581    static_position_independent_executables: Option<bool>,
582    plt_by_default: Option<bool>,
583    relro_level: Option<RelroLevel>,
584    archive_format: Option<StaticCow<str>>,
585    allow_asm: Option<bool>,
586    static_initializer_must_be_acyclic: Option<bool>,
587    main_needs_argc_argv: Option<bool>,
588    has_thread_local: Option<bool>,
589    obj_is_bitcode: Option<bool>,
590    max_atomic_width: Option<u64>,
591    min_atomic_width: Option<u64>,
592    atomic_cas: Option<bool>,
593    panic_strategy: Option<PanicStrategy>,
594    crt_static_allows_dylibs: Option<bool>,
595    crt_static_default: Option<bool>,
596    crt_static_respected: Option<bool>,
597    stack_probes: Option<StackProbeType>,
598    min_global_align: Option<u64>,
599    default_codegen_units: Option<u64>,
600    default_codegen_backend: Option<StaticCow<str>>,
601    trap_unreachable: Option<bool>,
602    requires_lto: Option<bool>,
603    singlethread: Option<bool>,
604    no_builtins: Option<bool>,
605    default_visibility: Option<SymbolVisibility>,
606    emit_debug_gdb_scripts: Option<bool>,
607    requires_uwtable: Option<bool>,
608    default_uwtable: Option<bool>,
609    simd_types_indirect: Option<bool>,
610    limit_rdylib_exports: Option<bool>,
611    override_export_symbols: Option<StaticCow<[StaticCow<str>]>>,
612    merge_functions: Option<MergeFunctions>,
613    #[serde(rename = "target-mcount")]
614    mcount: Option<StaticCow<str>>,
615    llvm_mcount_intrinsic: Option<StaticCow<str>>,
616    llvm_abiname: Option<StaticCow<str>>,
617    llvm_floatabi: Option<FloatAbi>,
618    rustc_abi: Option<RustcAbi>,
619    relax_elf_relocations: Option<bool>,
620    llvm_args: Option<StaticCow<[StaticCow<str>]>>,
621    use_ctors_section: Option<bool>,
622    eh_frame_header: Option<bool>,
623    has_thumb_interworking: Option<bool>,
624    debuginfo_kind: Option<DebuginfoKind>,
625    split_debuginfo: Option<SplitDebuginfo>,
626    supported_split_debuginfo: Option<StaticCow<[SplitDebuginfo]>>,
627    supported_sanitizers: Option<Vec<SanitizerSet>>,
628    default_sanitizers: Option<Vec<SanitizerSet>>,
629    generate_arange_section: Option<bool>,
630    supports_stack_protector: Option<bool>,
631    small_data_threshold_support: Option<SmallDataThresholdSupport>,
632    entry_name: Option<StaticCow<str>>,
633    supports_xray: Option<bool>,
634    entry_abi: Option<ExternAbiWrapper>,
635}
636
637pub fn json_schema() -> schemars::Schema {
638    ::schemars::SchemaGenerator::default().into_root_schema_for::<TargetSpecJson>()schemars::schema_for!(TargetSpecJson)
639}
rustc_target/spec/json.rs

rustc_target/spec/
json.rs
