L4.Tail: add EndOfMain marker; fix codegen to not generate two returns

We already always add a printing statement to the main expression, so
the main expression is already special. Now we have a dedicated marker
for the end of main, so that we can add some more specialty in the
codegen. In particular, we don't generate a return statement for main in
the generic codegen pass (`codegenTail`). Instead, a shutdown code for
the whole program is generated elsewhere. This has been done before,
but the main pass generated an extra return for main (because it looked
like a regular function) and the shutdown code was never executed. The
new special marker allows to tell between a regular function and main,
and to skip the return statement in the latter case.

Fix #242

Author: ulysses4ever

gibbon-compiler/src/Gibbon/L4/Syntax.hs

@@ -117,6 +117,9 @@ data DataConInfo = DataConInfo
 
 data Tail
     = RetValsT [Triv] -- ^ Only in tail position, for returning from a function.
+
+    | EndOfMain -- ^ A marker for an end of the main expression.
+
     | AssnValsT { upd       :: [(Var,Ty,Triv)]
                 , bod_maybe :: Maybe Tail
                 }
@@ -397,6 +400,7 @@ withTail (tl0,retty) fn =
   let go x = withTail (x,retty) fn in -- Warning: assumes same type.
   case tl0 of
     Goto{} -> return tl0
+    EndOfMain{} -> return tl0
     RetValsT ls -> return $ fn ls
     (ErrT x)    -> return $ ErrT x
     (AssnValsT _ _) -> error $ "withTail: expected tail expression returning values, not: "++show tl0
@@ -455,6 +459,7 @@ inlineTrivL4 (Prog info_tbl sym_tbl fundefs mb_main) =
     inline_tail :: M.Map Var Triv -> Tail -> Tail
     inline_tail env tl =
       case tl of
+        EndOfMain                -> tl
         RetValsT trvs            -> RetValsT (map (inline env) trvs)
         AssnValsT assns mb_bod   -> AssnValsT
                                       (map (\(v,ty,trv) -> (v,ty,inline env trv)) assns)

gibbon-compiler/src/Gibbon/Passes/Codegen.hs

@@ -78,6 +78,7 @@ harvestStructTys (Prog _ _ funs mtal) =
    where
     go tl =
      case tl of
+       EndOfMain -> []
        (RetValsT _)  -> []
        (AssnValsT ls bod_maybe) ->
          case bod_maybe of
@@ -146,6 +147,7 @@ sortFns (Prog _ _ funs mtal) = foldl go S.empty allTails
 
     go acc tl =
       case tl of
+        EndOfMain -> acc
         RetValsT{} -> acc
         AssnValsT _ mb_bod -> case mb_bod of
                                 Just bod -> go acc bod
@@ -421,6 +423,7 @@ rewriteReturns :: Tail -> [(Var,Ty)] -> Tail
 rewriteReturns tl bnds =
  let go x = rewriteReturns x bnds in
  case tl of
+   EndOfMain -> tl
    (RetValsT ls) -> AssnValsT [ (v,t,e) | (v,t) <- bnds | e <- ls ] Nothing
    (Goto _) -> tl
 
@@ -504,6 +507,7 @@ ssDecls =
 -- | The central codegen function.
 codegenTail :: VEnv -> FEnv -> S.Set Var -> Tail -> Ty -> SyncDeps -> PassM [C.BlockItem]
 
+codegenTail _ _ _ EndOfMain _ty _   = return []
 -- Void type:
 codegenTail _ _ _ (RetValsT []) _ty _   = return [ C.BlockStm [cstm| return 0; |] ]
 -- Single return:

gibbon-compiler/src/Gibbon/Passes/Lower.hs

@@ -324,7 +324,7 @@ addPrintToTail ty tl0 = do
         -- Always print a trailing newline at the end of execution:
         T.LetPrimCallT [] (T.PrintString "\n") [] $
           -- T.LetPrimCallT [] T.FreeSymTable [] $
-          T.RetValsT []  -- Void return after printing.
+          T.EndOfMain  -- marker of the end of main expression
 
 -- | Look up the numeric tag for a dataCon
 getTagOfDataCon :: Out a => DDefs a -> DataCon -> Tag

gibbon-compiler/src/Gibbon/Passes/RearrangeFree.hs

@@ -26,6 +26,7 @@ rearrangeFreeFn f@FunDecl{funBody} = do
 rearrangeFreeExp :: Bool -> Maybe (Tail -> Tail) -> Tail -> PassM Tail
 rearrangeFreeExp is_main frees tail =
   case tail of
+    EndOfMain -> return tail
     LetPrimCallT binds prim rands bod ->
       case prim of
         FreeBuffer -> do

gibbon-compiler/src/Gibbon/Passes/Simplifier.hs

@@ -246,6 +246,7 @@ lateInlineTriv (L4.Prog info_tbl sym_tbl fundefs mainExp) = do
                 L4.IntAlts ls -> L4.IntAlts $ map (\(t,tl) -> (t,go env tl)) ls
         go env tl =
               case tl of
+                   L4.EndOfMain -> L4.EndOfMain
                    L4.RetValsT trvs ->
                        L4.RetValsT (map (gotriv env) trvs)
                    L4.AssnValsT upd mb_bod ->