Matthew Dempsky <******@****.***> 1646087539 -0800

// RUN: tf-quant-opt %s -mark-functions-noinline='noinline-functions=noinline0' \
// RUN:     -allow-unregistered-dialect -mlir-disable-threading \
// RUN:     -split-input-file -verify-diagnostics | FileCheck %s

// Tests that the function is marked tf._noinline = true.

// CHECK-LABEL: @noinline0
// CHECK-SAME: attributes {{{.*tf._noinline = true.*}}}
func.func @noinline0() -> (tensor<0xf32>) {

    return {*this, "noinline-functions",
            llvm::cl::desc(
                "Name of the functions that should be marked "
                "tf._noinline = true to prevent inlining. The name of the "
                "function should exactly match to be marked noinline."),
            llvm::cl::list_init<std::string>(noinline_functions),
            llvm::cl::ZeroOrMore};
  }

  // Gets a set of function names from `noinline_functions_`.

// RUN: tf-opt %s -tf-strip-noinline-attribute | FileCheck %s

// CHECK-LABEL: func @strip_simple(
// CHECK-NOT: tf._noinline
func.func @strip_simple() -> tensor<2xi32> attributes {tf._noinline = true} {
  // CHECK-NEXT: %[[CST:.*]] = "tf.Const"
  %cst = "tf.Const"() { value = dense<2> : tensor<2xi32> } : () -> tensor<2xi32>
  func.return %cst : tensor<2xi32>

    }

    /**
     * Processes the descendants of the element using the preorder implementation of tree traversal.
     */
    private inline fun <reified T : PsiElement> PsiElement.forEachDescendantOfType(
        noinline predicate: (T) -> Boolean = { true },
        noinline action: (T) -> Unit,
    ) = this.accept(object : PsiRecursiveElementVisitor() {
        override fun visitElement(element: PsiElement) {

// gcc -g -O2 -freorder-blocks-and-partition

const char *arr[10000];
const char *hot = "hot";
const char *cold = "cold";

__attribute__((noinline))
void fn(int path) {
	int i;

	if (path) {
		for (i = 0; i < sizeof arr / sizeof arr[0]; i++) {
			arr[i] = hot;
		}
	} else {
		for (i = 0; i < sizeof arr / sizeof arr[0]; i++) {
			arr[i] = cold;
		}
	}
}

int main(int argc, char *argv[]) {
	fn(argc);
	return 0;

// clang -gdwarf-5 -O2 -nostdlib

__attribute__((noinline, cold))
static int sum(int i) {
  int j, s;

  s = 0;
  for (j = 0; j < i; j++) {
    s += j * i;
  }
  return s;
}

int main(int argc, char** argv) {
  if (argc == 0) {
    return 0;
  }
  return sum(argc);

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

type Value[T any] struct {
	val T
}

// The noinline directive should survive across import, and prevent instantiations
// of these functions from being inlined.

//go:noinline
func Get[T any](v *Value[T]) T {
	return v.val
}

//go:noinline

import org.gradle.vcs.VcsMapping
import org.gradle.vcs.VersionControlSpec


/**
 * Specifies the VCS location for the requested component.
 *
 * @see VcsMapping.from
 */
inline fun <reified T : VersionControlSpec> VcsMapping.from(noinline configureAction: T.() -> Unit) =

 * exists or the container does not support creating a domain object with the specified
 * type
 */
inline fun <reified U : Any> PolymorphicDomainObjectContainer<in U>.create(
    name: String,
    noinline configuration: U.() -> Unit
) =

    this.create(name, U::class.java, configuration)


/**