// only be used as the shape-determining operand; it will not replace other
// usages of the original constant. If the operands are not constants (i.e.
// results of some other computation), then the pass recursively traverses the
// call tree upwards and duplicates all constants found in the subtree in a
// similar manner.
//
// This pass may be used to avoid placing shape-determining constants in the CPU

      Class<T> enumClass) {
    synchronized (enumConstantCache) {
      Map<String, WeakReference<? extends Enum<?>>> constants = enumConstantCache.get(enumClass);
      if (constants == null) {
        constants = populateCache(enumClass);
      }
      return constants;
    }
  }

  /**
   * Returns a serializable converter that converts between strings and {@code enum} values of type

PACKAGE blank

IMPORTPATH
	testdata/blank

IMPORTS
	os

FILENAMES
	testdata/blank.go

CONSTANTS
	// T constants counting from unexported constants. 
	const (
		tweedledee	T	= iota
		tweedledum
		C1
		C2
		alice
		C3
		redQueen	int	= iota
		C4
	)

	// Constants with a single type that is not propagated. 
	const (
		zero		os.FileMode	= 0
		Default				= 0644
		Useless				= 0312

#include "textflag.h"

// Vector register range containing CRC-32 constants

#define CONST_PERM_LE2BE        V9
#define CONST_R2R1              V10
#define CONST_R4R3              V11
#define CONST_R5                V12
#define CONST_RU_POLY           V13
#define CONST_CRC_POLY          V14


// The CRC-32 constant block contains reduction constants to fold and
// process particular chunks of the input data stream in parallel.

package constdecl

import "math"
import "unsafe"

var v int

// Const decls must be initialized by constants.
const _ = v /* ERROR "not constant" */
const _ = math /* ERROR "not constant" */ .Sin(0)
const _ = int /* ERROR "not an expression" */

func _() {
	const _ = v /* ERROR "not constant" */
	const _ = math /* ERROR "not constant" */ .Sin(0)
	const _ = int /* ERROR "not an expression" */
}

// package goos contains GOOS-specific constants.
package goos

// The next line makes 'go generate' write the zgoos*.go files with
// per-OS information, including constants named Is$GOOS for every
// known GOOS. The constant is 1 on the current system, 0 otherwise;
// multiplying by them is useful for defining GOOS-specific constants.
//

IMPORTPATH
	testdata/blank

IMPORTS
	os

FILENAMES
	testdata/blank.go

CONSTANTS
	// T constants counting from unexported constants. 
	const (
		C1	T
		C2
	
		C3
	
		C4	int
	)

	// Constants with a single type that is not propagated. 
	const (
		Default		= 0644
		Useless		= 0312
		WideOpen	= 0777
	)

	// Constants with an imported type that is propagated. 
	const (
		M1	os.FileMode
		M2

const _ = uintptr(unsafe.Pointer(uintptr(1))) // ERROR "is not (a )?constant|expression is not constant"
const _ = uintptr(myPointer(uintptr(1))) // ERROR "is not (a )?constant|expression is no constant"

const _ = []byte("") // ERROR "is not (a )?constant|invalid constant type"

      visitUsedValuesDefinedAbove(body, [&](OpOperand *use) {
        Value constant = use->get();
        auto const_op = dyn_cast_or_null<TF::ConstOp>(constant.getDefiningOp());
        if (!const_op) return;

        // Filter constants using user provided predicate function.
        if (filter && !filter(cluster, const_op.getValue())) return;

        // We found a constant, try to insert it in the map and re-use its
        // cloned value if any.

// for debugging purposes.
func (po *poset) CheckIntegrity() {
	// Record which index is a constant
	constants := newBitset(int(po.lastidx + 1))
	for _, c := range po.constants {
		constants.Set(c)
	}

	// Verify that each node appears in a single DAG, and that
	// all constants are within the first DAG
	seen := newBitset(int(po.lastidx + 1))
	for ridx, r := range po.roots {
		if r == 0 {