// compile

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

// Used to crash when a type switch was present in dead code
// in an inlineable function.

package p

func Then() {
	var i interface{}
	if false {
		switch i.(type) {
		}
	}
}

func Else() {
	var i interface{}
	if true {
		_ = i
	} else {

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

package ssa

import (
	"cmd/compile/internal/ir"
	"cmd/compile/internal/types"
)

// dse does dead-store elimination on the Function.
// Dead stores are those which are unconditionally followed by
// another store to the same location, with no intervening load.
// This implementation only works within a basic block. TODO: use something more global.

    // the NodeDef inputs to the function call nodes.
    g->AddEdge(new_node, edge->src_output(), edge->dst(), edge->dst_input());
    g->RemoveEdge(edge);
  }
}

// Returns a data value that is dead iff `control` is dead.
Output ControlToData(const Scope& scope, Node* control) {
  // The choice of data type here is important.
  //
  // We implement a "control merge", which is a control edge that is alive if

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

package main

import "./a"

func main() {
	var x a.I = &a.T{}
	x.M() // call to the wrapper (*T).M
	a.F() // make sure a.F is not dead, which also calls (*T).M inside package a

	defer println(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20)
	// Disabled so the test doesn't crash but left here for reference.
	// defer panic("dead")
	defer print("printing: ")

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

// Issue 17918: slice out-of-bounds in ssa/cse

package dead

import (
	"fmt"
	"time"
)

var (
	units = []struct {
		divisor time.Duration
		unit    rune
	}{
		{1000000, 's'},
		{60, 'm'},
		{60, 'h'},
		{24, 'd'},
		{7, 'w'},
	}
)

        s = "a"
        for p {
                p = false == (true != q)
                s = ""
        }
        _ = s == "bbb"
}

// Another case: load from negative offset of a symbol
// in dead code (issue 30257).
func g() {
	var i int
	var s string

	if true {
		s = "a"
	}

	if f := 0.0; -f < 0 {
		i = len(s[:4])
	}

	_ = s[i-1:0] != "bb" && true

// compile

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

// Issue 48916: expand_calls pass crashes due to a (dead)
// use of an OpInvalid value.

package p

type T struct {
	num int64
}

func foo(vs map[T]struct{}, d T) error {
	_, ok := vs[d]
	if !ok {
		return nil
	}

	switch d.num {
	case 0:

// compile -N -d=softfloat

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

// Issue 26163: dead store generated in late opt messes
// up store chain calculation.

package p

var i int
var A = ([]*int{})[i]

var F func(float64, complex128) int
var C chan complex128

package calloc

// This package contains a simple "batch" allocator for allocating
// coverage counters (slices of uint32 basically), for working with
// coverage data files. Collections of counter arrays tend to all be
// live/dead over the same time period, so a good fit for batch
// allocation.

type BatchCounterAlloc struct {
	pool []uint32
}

func (ca *BatchCounterAlloc) AllocateCounters(n int) []uint32 {
	const chunk = 8192