// temporary to pass to the runtime conversion routine.
	case ir.OCONVIFACE:
		n := n.(*ir.ConvExpr)
		n.X = o.expr(n.X, nil)
		if n.X.Type().IsInterface() {
			return n
		}
		if _, _, needsaddr := dataWordFuncName(n.X.Type()); needsaddr || isStaticCompositeLiteral(n.X) {
			// Need a temp if we need to pass the address to the conversion function.

        });
  }
  return absl::OkStatus();
}

// The hlo->tf conversion is done in three steps; pre-quantization,
// quantization, and post-quantization. Quantization is optional, enabled only
// when `pass_config.enable_stablehlo_quantizer` is `true`. If quantization is
// not run, it only performs the hlo->tf conversion.
//
// All parameters except for `pass_config`, `pass_manager`, `status_handler`,

			APIVersion:    "foo/v1",
			ExpectObjects: nil,
		},
		{
			Name: "one-item list, in desired version",
			Object: &unstructured.UnstructuredList{
				Items: []unstructured.Unstructured{*v1Object},
			},
			APIVersion:    "foo/v1",
			ExpectObjects: nil,
		},
		{
			Name: "one-item list, not in desired version",
			Object: &unstructured.UnstructuredList{
				Items: []unstructured.Unstructured{*v2Object},
			},

	// against the claims. This is done once here so that we don't have to convert
	// the claims to unstructured multiple times in the CEL mapper for each mapping.
	// Only perform this conversion if any of the mapping or validation rules contain
	// CEL expressions.
	// TODO(aramase): In the future when we look into making distributed claims work,

	case OpPhi:
		return true
	case
		// negate
		OpNeg8, OpNeg16, OpNeg32, OpNeg64, OpNeg32F, OpNeg64F,
		OpCom8, OpCom16, OpCom32, OpCom64,
		// math
		OpFloor, OpCeil, OpTrunc, OpRoundToEven, OpSqrt,
		// conversion
		OpTrunc16to8, OpTrunc32to8, OpTrunc32to16, OpTrunc64to8,
		OpTrunc64to16, OpTrunc64to32, OpCvt32to32F, OpCvt32to64F,
		OpCvt64to32F, OpCvt64to64F, OpCvt32Fto32, OpCvt32Fto64,

// Copyright 2009 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.

// Binary to decimal floating point conversion.
// Algorithm:
//   1) store mantissa in multiprecision decimal
//   2) shift decimal by exponent
//   3) read digits out & format

package strconv

import "math"

// TODO: move elsewhere?
type floatInfo struct {
	mantbits uint

		// comparison is okay as long as one side is
		// assignable to the other.  convert so they have
		// the same type.
		//
		// the only conversion that isn't a no-op is concrete == interface.
		// in that case, check comparability of the concrete type.
		// The conversion allocates, so only do it if the concrete type is huge.
		converted := false
		if r.Type().Kind() != types.TBLANK {
			aop, _ = assignOp(l.Type(), r.Type())

      /*
       * For most values, the conversion from roundArbitrarily to roundArbitrarilyAsLong is
       * lossless. In that case we can compare x to roundArbitrarily using Longs.compare(x,
       * roundArbitrarilyAsLong). The exception is for values where the conversion to double rounds
       * up to give roundArbitrarily equal to 2^63, so the conversion back to long overflows and

	REG_ELEM_END
)

// Not registers, but flags that can be combined with regular register
// constants to indicate extended register conversion. When checking,
// you should subtract obj.RBaseARM64 first. From this difference, bit 11
// indicates extended register, bits 8-10 select the conversion mode.
// REG_LSL is the index shift specifier, bit 9 indicates shifted offset register.
const REG_LSL = obj.RBaseARM64 + 1<<9

  // ConstantOp, the quantizable_op will be rewired to the existing ConvertOp.
  // This guarantees at most one ConvertOp is created for float32 to float16
  // conversion.
  void QuantizeOpAsFloat16(PatternRewriter& rewriter, ConstantOp op,
                           const std::pair<Operation*, int> quant_op) const {
    const auto [quantizable_op, quantize_operand_num] = quant_op;