package shift

// Simplified dead code detector.
// Used for skipping shift checks on unreachable arch-specific code.

import (
	"go/ast"
	"go/constant"
	"go/types"
)

// updateDead puts unreachable "if" and "case" nodes into dead.
func updateDead(info *types.Info, dead map[ast.Node]bool, node ast.Node) {
	if dead[node] {
		// The node is already marked as dead.
		return
	}

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

package main

func fail() // unimplemented, to test dead code elimination

// Test dead code elimination in if statements
func init() {
	if false {
		fail()
	}
	if 0 == 1 {
		fail()
	}
}

// Test dead code elimination in ordinary switch statements
func init() {
	const x = 0
	switch x {
	case 1:
		fail()
	}

	switch 1 {

unfinished work which they who fought here have thus far so nobly advanced. It is rather for us to be here dedicated to the great task remaining before us - that from these honored dead we take increased devotion to that cause for which they gave the last full measure of devotion - that we here highly resolve that these dead shall not have died in vain - that this nation, under God, shall have a new birth of freedom - and that government of the people, by the people, for the people, shall not perish...

input (control and non-control) is dead, all the outputs (control and
non-control) are dead as well. For `tf_executor.Merge`, the output is dead only
when either an input control token is dead or all of the regular inputs are
dead. For `tf_executor.ControlTrigger`, a live control output is always produced
even when some control inputs are dead.

### `tf_executor.graph` Operation

.dead-block.highlight-palegreen,
.dead-value span.highlight-skyblue,
.dead-block.highlight-skyblue,
.dead-value span.highlight-lightgray,
.dead-block.highlight-lightgray,
.dead-value span.highlight-yellow,
.dead-block.highlight-yellow,
.dead-value span.highlight-lime,
.dead-block.highlight-lime,
.dead-value span.highlight-khaki,
.dead-block.highlight-khaki,
.dead-value span.highlight-aqua,

			Goto("exit")),
		Bloc("exit",
			Exit("mem")),
		// dead loop
		Bloc("deadblock",
			// dead value in dead block
			Valu("deadval", OpConstBool, c.config.Types.Bool, 1, nil),
			If("deadval", "deadblock", "exit")))

	CheckFunc(fun.f)
	Deadcode(fun.f)
	CheckFunc(fun.f)

	for _, b := range fun.f.Blocks {
		if b == fun.blocks["deadblock"] {
			t.Errorf("dead block not removed")
		}
		for _, v := range b.Values {

	// Do a complete pass to compute dead nodes.
	dead := make(map[ast.Node]bool)
	nodeFilter := []ast.Node{
		(*ast.IfStmt)(nil),
		(*ast.SwitchStmt)(nil),
	}
	inspect.Preorder(nodeFilter, func(n ast.Node) {
		// TODO(adonovan): move updateDead into this file.
		updateDead(pass.TypesInfo, dead, n)
	})

	nodeFilter = []ast.Node{
		(*ast.AssignStmt)(nil),

	// heap.
	runtime.GC()
	// At this point x's dead stack slot points to dead memory.

	// Trigger a sigpanic. Since this is an implicit panic, we
	// don't have an explicit liveness map here.
	// Traceback used to use the liveness map of the most recent defer,
	// but in that liveness map, x will be live again even though
	// it points to dead memory. The fix is to use the liveness
	// map of a deferreturn call instead.

		}
	})

	// Remove dead values from blocks' value list. Return dead
	// values to the allocator.
	for _, b := range f.Blocks {
		i := 0
		for _, v := range b.Values {
			if live[v.ID] {
				b.Values[i] = v
				i++
			} else {
				f.freeValue(v)
			}
		}
		b.truncateValues(i)
	}

	// Remove unreachable blocks. Return dead blocks to allocator.
	i = 0

    captured by a `tf_executor.island` is dead, the whole region does not
    execute and every produced value is marked as dead as well.
    An arbitrary number of `tf_executor.control` operands are accepted by a
    `tf_executor.island` operation.
    If any operand or implicitly captured value are dead, the region is not
    executed and dead values are immediately returned for every result.
  }];