// Broadcast without memory operand.
	VADDPD.BCST X3, X2, K1, X1       // ERROR "illegal broadcast without memory argument"
	VADDPD.BCST X3, X2, K1, X1       // ERROR "illegal broadcast without memory argument"
	VADDPD.BCST X3, X2, K1, X1       // ERROR "illegal broadcast without memory argument"
	// CLWB instructions:
	CLWB BX                          // ERROR "invalid instruction"

// errorcheck

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

// Verify that it is illegal to take the address of a function.
// Does not compile.

package main

var notmain func()

func main() {
	var x = &main		// ERROR "address of|invalid"
	main = notmain	// ERROR "assign to|invalid"
	_ = x

package main

type A []int;
type M map[int] int;

func main() {
	var a *A = &A{0};
	var m *M = &M{0 : 0};  // should be legal to use & here for consistency with other composite constructors (prev. line)
	_, _ = a, m;
}

/*
uetli:~/Source/go1/test/bugs gri$ 6g bug098.go && 6l bug098.6 && 6.out
bug098.go:10: illegal types for operand: AS
	(*MAP[<int32>INT32]<int32>INT32)
	(**MAP[<int32>INT32]<int32>INT32)

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

package main

func main() {
	var _ string = nil // ERROR "illegal|invalid|incompatible|cannot"

// compile

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

// /tmp/x.go:5: illegal constant expression: bool == interface {}

package p

var m = map[interface{}]struct{}{
	nil:  {},
	true: {},

	_, _, _, _ = a0, a1, a2, b2;
}

/*
uetli:~/Source/go1/test/bugs/bug088.dir gri$ 6g bug0.go && 6g bug1.go
bug1.go:8: shape error across :=
bug1.go:8: a2: undefined
bug1.go:8: b2: undefined
bug1.go:8: illegal types for operand: AS
	(<(bug0)P.int32>INT32)

type I interface {
	M()
}

type PI interface {
	PM()
}

func main() {
	var t lib.T
	t.M()
	t.PM()

	// This is still an error.
	// var i1 I = t
	// i1.M()
	
	// This combination is illegal because
	// PM requires a pointer receiver.
	// var pi1 PI = t
	// pi1.PM()

	var pt = &t
	pt.M()
	pt.PM()

	var i2 I = pt
	i2.M()

	var pi2 PI = pt
	pi2.PM()

// license that can be found in the LICENSE file.

package main

type T struct {
	x, y *T
}

func main() {
	// legal composite literals
	_ = struct{}{}
	_ = [42]int{}
	_ = [...]int{}
	_ = []int{}
	_ = map[int]int{}
	_ = T{}

	// illegal composite literals: parentheses not allowed around literal type
	_ = (struct{}){}    // ERROR "parenthesize"
	_ = ([42]int){}     // ERROR "parenthesize"

// RUN: tf-tfrt-opt -tf-to-tfrt %s -split-input-file -verify-diagnostics

// expected-error @+1 {{failed to legalize operation 'func.func' that was explicitly marked illegal}}
func.func @test_identity_wrong_type(%arg0: tensor<4x2x!tf_type.string>) -> tensor<4x2x!tf_type.stringref> {
  %0 = "tf.SomeOp"(%arg0) : (tensor<4x2x!tf_type.string>) -> tensor<4x2x!tf_type.stringref>
  func.return %0 : tensor<4x2x!tf_type.stringref>

// errorcheck -d=panic

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

// Verify that illegal character literals are detected.
// Does not compile.

package main

const (
	// check that surrogate pair elements are invalid
	// (d800-dbff, dc00-dfff).
	_ = '\ud7ff' // ok
	_ = '\ud800'  // ERROR "Unicode|unicode"