InstalledGcc gcc = new InstalledGcc(ToolFamily.GCC, version.getComponent().getVersion());
                    if (!candidate.equals(firstInPath)) {
                        // Not the first g++ in the path, needs the path variable updated
                        gcc.inPath(candidate.getParentFile());
                    }
                    toolChains.add(gcc);
                }
            }
        }

                   uint32_t *eax, uint32_t *ebx,
                   uint32_t *ecx, uint32_t *edx)
{
	return __get_cpuid_count(leaf, subleaf, eax, ebx, ecx, edx);
}

#pragma GCC diagnostic ignored "-Wunknown-pragmas"
#pragma GCC push_options
#pragma GCC target("xsave")
#pragma clang attribute push (__attribute__((target("xsave"))), apply_to=function)

// xgetbv reads the contents of an XCR (Extended Control Register)

Sterling Greene <******@****.***> 1700166003 -0500

 */

package org.gradle.nativeplatform.toolchain.internal.gcc;

import org.gradle.internal.process.ArgWriter;
import org.gradle.nativeplatform.toolchain.internal.OptionsFileArgsWriter;

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * Uses an option file for arguments passed to GCC if possible.

    #elif defined(__GNUC__) && defined(__MINGW32__)
        std::cout << "Hello from mingw!" << std::endl;
    #elif defined(__GNUC__) && defined(__CYGWIN__)
        std::cout << "Hello from gcc cygwin!" << std::endl;
    #elif defined(__GNUC__)
        std::cout << "Hello from gcc!" << std::endl;
    #elif defined(_MSC_VER)
        std::cout << "Hello from visual c++!" << std::endl;
    #else

        def newMetadata = metadataProvider(compiler).getCompilerMetaData([]) { it.executable(binary) }

        then:
        0 * _
        newMetadata.is(metadata)

        where:
        compiler << ['gcc', 'clang', 'swiftc']
    }

    def "different #compiler executables are probed and cached"() {
        def firstBinary = new File("first")
        def secondBinary = new File("second")
        when:

    VISUALCPP_2019,
    // Any available Visual Studio >= 2019
    VISUALCPP_2019_OR_NEWER,
    // Any windows GCC compatible implementation (mingw, cygwin)
    WINDOWS_GCC,
    // Any available GCC implementation (including mingw, cygwin, but not clang)
    GCC,
    // Any available GCC compatible implementation (including mingw, cygwin, and clang)
    GCC_COMPATIBLE,
    // Any available Clang
    CLANG,

//go:build cgo

package pe

import (
	"os/exec"
	"runtime"
	"testing"
)

func testCgoDWARF(t *testing.T, linktype int) {
	if _, err := exec.LookPath("gcc"); err != nil {
		t.Skip("skipping test: gcc is missing")
	}
	testDWARF(t, linktype)
}

func TestDefaultLinkerDWARF(t *testing.T) {
	testCgoDWARF(t, linkCgoDefault)
}

func TestInternalLinkerDWARF(t *testing.T) {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

/*
Linux ELF:
gcc -gdwarf-2 -m64 -c typedef.c && gcc -gdwarf-2 -m64 -o typedef.elf typedef.o

OS X Mach-O:
gcc -gdwarf-2 -m64 -c typedef.c -o typedef.macho
gcc -gdwarf-4 -m64 -c typedef.c -o typedef.macho4
*/
#include <complex.h>

typedef volatile int* t_ptr_volatile_int;

// In separate directory to isolate #pragma GCC diagnostic.

package issue27340

// We use the #pragma to avoid a compiler warning about incompatible
// pointer types, because we generate code passing a struct ptr rather
// than using the typedef. This warning is expected and does not break
// a normal build.
// We can only disable -Wincompatible-pointer-types starting with GCC 5.

// #if __GNU_MAJOR__ >= 5
//