import xsbti.T2;
import xsbti.VirtualFile;
import xsbti.compile.AnalysisContents;
import xsbti.compile.AnalysisStore;
import xsbti.compile.ClassFileManagerType;
import xsbti.compile.ClasspathOptionsUtil;
import xsbti.compile.CompileAnalysis;
import xsbti.compile.CompileOptions;
import xsbti.compile.CompileResult;
import xsbti.compile.CompilerCache;
import xsbti.compile.Compilers;
import xsbti.compile.DefinesClass;
import xsbti.compile.IncOptions;

	MOVD chain+8(FP), R1
	LMG  src+16(FP), R2, R3 // R2=base, R3=len

continue:
	WORD $0xB93E0002 // KIMD --, R2
	BVS  continue    // continue if interrupted
	MOVD $0, R0      // reset R0 for pre-go1.8 compilers
	RET

// func klmd(function code, chain *[200]byte, dst, src []byte)
TEXT ·klmd(SB), NOFRAME|NOSPLIT, $0-64
	// TODO: SHAKE support
	MOVD function+0(FP), R0
	MOVD chain+8(FP), R1

            List<ToolChainCandidate> compilers = new ArrayList<>();
            if (OperatingSystem.current().isWindows()) {
                compilers.addAll(findVisualCpps());
                compilers.add(findMinGW());
            } else if (OperatingSystem.current().isMacOsX()) {
                compilers.addAll(findClangs(true));
                compilers.addAll(findGccs(false));

 * limitations under the License.
 */

package org.gradle.nativeplatform.toolchain;

import org.gradle.internal.HasInternalProtocol;
import org.gradle.platform.base.ToolChain;

/**
 * A set of compilers and linkers that are used together to construct a native binary.
 */
@HasInternalProtocol
public interface NativeToolChain extends ToolChain {

import org.gradle.internal.service.scopes.ServiceScope;
import org.gradle.language.base.internal.compile.CompileSpec;
import org.gradle.language.base.internal.compile.Compiler;

/**
 * Creates Java compilers based on the provided compile options.
 */
@ServiceScope(Scope.Project.class)
public interface JavaCompilerFactory {
    <T extends CompileSpec> Compiler<T> create(Class<T> type);

 * limitations under the License.
 */

package org.gradle.platform.base;

import org.gradle.api.Named;
import org.gradle.internal.HasInternalProtocol;

/**
 * A set of compilers that are used together to construct binaries.
 */
@HasInternalProtocol
public interface ToolChain extends Named {
    /**
     * Returns a human consumable name for this tool chain.
     *
     * @since 1.11

			continue
		}

		for GOARCH := range allGOARCH {
			context := build.Context{
				GOOS:      "linux", // darwin has custom assembly
				GOARCH:    GOARCH,
				GOROOT:    testenv.GOROOT(t),
				Compiler:  build.Default.Compiler,
				BuildTags: []string{"purego", "math_big_pure_go"},
			}

			pkg, err := context.Import(pkgName, "", 0)
			if err != nil {
				t.Fatal(err)
			}
			if len(pkg.SFiles) == 0 {
				continue

==============================================================================*/
#include "tensorflow/compiler/mlir/quantization/tensorflow/passes/remove_identity_op_pattern.h"

#include "mlir/IR/PatternMatch.h"  // from @llvm-project
#include "mlir/Support/LLVM.h"  // from @llvm-project
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.h"

namespace mlir {
namespace quant {

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

// This file defines flags attached to various functions
// and data objects. The compilers, assemblers, and linker must
// all agree on these values.
//
// Keep in sync with src/cmd/internal/obj/textflag.go.

// Don't profile the marked routine. This flag is deprecated.
#define NOPROF	1

// Determine whether the compiler supports Microsoft's Structured Exception
// Handling.  This is supported by several Windows compilers but generally
// does not exist on any other system.
#ifndef GTEST_HAS_SEH
// The user didn't tell us, so we need to figure it out.

# if defined(_MSC_VER) || defined(__BORLANDC__)
// These two compilers are known to support SEH.
#  define GTEST_HAS_SEH 1
# else