-- Copyright (C) 2018-2024 Jun Zhang <zhangjunphy[at]gmail[dot]com>
--
-- This file is a part of decafc.
--
-- decafc is free software: you can redistribute it and/or modify it under the
-- terms of the MIT (X11) License as described in the LICENSE file.
--
-- decafc is distributed in the hope that it will be useful, but WITHOUT ANY
-- WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-- FOR A PARTICULAR PURPOSE.  See the X11 license for more details.

module CFG.Optimizations.RemoveDeadBlock where

import CFG.Optimizations.Optimizer
import CFG.Types
import Control.Lens (use, uses, view, (%=), (%~), (&), (+=), (.=), (.~), (^.), _1, _2, _3)
import Control.Monad.Except
import Data.List (find)
import Data.Map.Strict qualified as Map
import SSA (SSA)
import SSA qualified
import Types
import Util.Graph qualified as G

removeDeadBlock :: CFGOptimizer ()
removeDeadBlock :: CFGOptimizer ()
removeDeadBlock = do
  CFG
cfg <- CFGOptimizer CFG
getCFG
  case CFG -> Maybe BBID
findDeadNode CFG
cfg of
    Maybe BBID
Nothing -> () -> CFGOptimizer ()
forall a. a -> CFGOptimizer a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
    Just BBID
bbid -> do
      GraphBuilder BBID BasicBlock CFGEdge () -> CFGOptimizer ()
forall a. GraphBuilder BBID BasicBlock CFGEdge a -> CFGOptimizer ()
updateCFG (GraphBuilder BBID BasicBlock CFGEdge () -> CFGOptimizer ())
-> GraphBuilder BBID BasicBlock CFGEdge () -> CFGOptimizer ()
forall a b. (a -> b) -> a -> b
$ BBID -> GraphBuilder BBID BasicBlock CFGEdge ()
forall ni nd ed. (Eq ni, Ord ni) => ni -> GraphBuilder ni nd ed ()
G.deleteNode BBID
bbid
      CFGOptimizer ()
removeDeadBlock

findDeadNode :: CFG -> Maybe BBID
findDeadNode :: CFG -> Maybe BBID
findDeadNode (CFG g :: Graph BBID BasicBlock CFGEdge
g@(G.Graph Map BBID BasicBlock
nodes Map (BBID, BBID) CFGEdge
_) BBID
entry BBID
_ [Var]
_ MethodSig
_) =
  (BBID, BasicBlock) -> BBID
forall a b. (a, b) -> a
fst ((BBID, BasicBlock) -> BBID)
-> Maybe (BBID, BasicBlock) -> Maybe BBID
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((BBID, BasicBlock) -> Bool)
-> [(BBID, BasicBlock)] -> Maybe (BBID, BasicBlock)
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find (\(BBID
n, BasicBlock
_) -> BBID
n BBID -> BBID -> Bool
forall a. Eq a => a -> a -> Bool
/= BBID
entry Bool -> Bool -> Bool
&& [(BBID, BBID, CFGEdge)] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (BBID -> Graph BBID BasicBlock CFGEdge -> [(BBID, BBID, CFGEdge)]
forall ni nd ed.
(Eq ni, Ord ni) =>
ni -> Graph ni nd ed -> [(ni, ni, ed)]
G.inBound BBID
n Graph BBID BasicBlock CFGEdge
g)) (Map BBID BasicBlock -> [(BBID, BasicBlock)]
forall k a. Map k a -> [(k, a)]
Map.toList Map BBID BasicBlock
nodes)