// RUN: tf-opt %s -unfold-large-splat-constant | FileCheck %s

// CHECK-LABEL: @unfold_large_constant_splat
func.func @unfold_large_constant_splat() -> (tensor<10x10xf32>, tensor<1000x1000xf32>) {
  %0 = arith.constant dense<0.00000e+00> : tensor<10x10xf32>
  %1 = arith.constant dense<1.00000e+00> : tensor<1000x1000xf32>
  func.return %0, %1 : tensor<10x10xf32>, tensor<1000x1000xf32>

  // CHECK-DAG: %cst = arith.constant dense<0.000000e+00> : tensor<10x10xf32>

apiVersion: release-notes/v2
kind: feature
area: istioctl
issue:
  - 50248
releaseNotes:
- |

            .assertTestPassed("$testMethod [param: value1, #0]")
            .assertTestPassed("$testMethod [param: value2, #1]")

        where:
        testMethod << ["sub unrolled test", "super unrolled test", "super super unrolled test"]
    }

    def "can filter unrolled tests with parameter name in test header"() {
        when:
        succeeds("test", "--tests", "SubClass.$testMethod param=#param")

        then:

apiVersion: release-notes/v2
kind: feature
area: traffic-management
issue:
- 50355
releaseNotes:
- |

            "rule before", "setup", "unrolled test: 1: isFluid: false", "cleanup", "rule after",
            "rule before", "setup", "unrolled test: 1: isFluid: true", "cleanup", "rule after",
            "rule before", "setup", "unrolled test: 2: isFluid: false", "cleanup", "rule after",
            "rule before", "setup", "unrolled test: 2: isFluid: true", "cleanup", "rule after",

apiVersion: release-notes/v2
kind: feature
area: istioctl
issue:
  - 50396
releaseNotes:
- |

package bigmod

import "internal/cpu"

// amd64 assembly uses ADCX/ADOX/MULX if ADX is available to run two carry
// chains in the flags in parallel across the whole operation, and aggressively
// unrolls loops. arm64 processes four words at a time.
//
// It's unclear why the assembly for all other architectures, as well as for
// amd64 without ADX, perform better than the compiler output.

package schema

import (
	"testing"
)

// TestStructuralUnfoldNilValueValidation tests that Unfold() does not crash
// on a IntOrString pattern with nil ValueValidation.
func TestStructuralUnfoldIntOrString(t *testing.T) {
	schema := Structural{
		Extensions: Extensions{
			XIntOrString: true,
		},
	}
	schema.Unfold()

            return FormatType.FAVORITES;
        }
        if (FormatType.PING.name().equals(type)) {
            return FormatType.PING;
        }
        if (FormatType.SCROLL.name().equals(type)) {
            return FormatType.SCROLL;
        }
        if (FormatType.SUGGEST.name().equals(type)) {
            return FormatType.SUGGEST;
        }

        // default
        return FormatType.OTHER;
    }

	MOVQ x+24(FP), R8
	MOVQ y+48(FP), R9
	MOVQ z+0(FP), R10

	MOVQ $0, CX		// c = 0
	MOVQ $0, SI		// i = 0

	// s/JL/JMP/ below to disable the unrolled loop
	SUBQ $4, DI		// n -= 4
	JL V1			// if n < 0 goto V1

U1:	// n >= 0
	// regular loop body unrolled 4x
	ADDQ CX, CX		// restore CF
	MOVQ 0(R8)(SI*8), R11
	MOVQ 8(R8)(SI*8), R12
	MOVQ 16(R8)(SI*8), R13
	MOVQ 24(R8)(SI*8), R14
	ADCQ 0(R9)(SI*8), R11