Comment puis-je analyser le cœur du GHC?

Question

J'essaye d'analyser le code de noyau de ghc obtenu d'exécuter ghc -c -ddump-simpl myfile.hs. Je connais extcore et bibliothèques sont mes options.

Je cherche un exemple simple illustrant l'utilisation de ces bibliothèques. [EDIT] Le résultat d'analyse devrait être une structure de données à partir de laquelle il devrait être facile de tracer différents chemins qu'une fonction peut prendre.

Tenir compte d'une simple fonction not

not True = False 
not False = True 

GHC transformer cela en expressions de cas (considérer la sortie de ghc -c -ddump-simple uniquement). Je cherche à analyser cette sortie du noyau GHC.

Answer 1

Je pense que le moyen le plus simple est de renoncer à ces bibliothèques Core externes et d'utiliser directement GHC en tant que bibliothèque. Sur la base de this example from the Haskell wiki, nous pouvons faire une simple fonction qui transforme un module dans le noyau:

import GHC 
import GHC.Paths (libdir) 
import HscTypes (mg_binds) 
import CoreSyn 
import DynFlags 
import Control.Monad ((<=<)) 

compileToCore :: String -> IO [CoreBind] 
compileToCore modName = runGhc (Just libdir) $ do 
    setSessionDynFlags =<< getSessionDynFlags 
    target <- guessTarget (modName ++ ".hs") Nothing 
    setTargets [target] 
    load LoadAllTargets 
    ds <- desugarModule <=< typecheckModule <=< parseModule <=< getModSummary $ mkModuleName modName 
    return $ mg_binds . coreModule $ ds 

Voici un exemple d'utilisation stupide qui traite sa production à compter le nombre de cas:

-- Silly example function that analyzes Core 
countCases :: [CoreBind] -> Int 
countCases = sum . map countBind 
    where 
    countBind (NonRec _ e) = countExpr e 
    countBind (Rec bs) = sum . map (countExpr . snd) $ bs 

    countExpr (Case e _ _ alts) = countExpr e + sum (map countAlt alts) 
    countExpr (App f e) = countExpr f + countExpr e 
    countExpr (Lam _ e) = countExpr e 
    countExpr (Let b e) = countBind b + countExpr e 
    countExpr (Cast e _) = countExpr e 
    countExpr (Tick _ e) = countExpr e 
    countExpr _ = 0 

    countAlt (_, _, rhs) = 1 + countExpr rhs 

Lançons il sur votre exemple:

main :: IO() 
main = do 
    core <- compileToCore "MyNot" 
    print $ countCases core 

Cette sortie 2, comme prévu.