Move `iserv` into `utils` and change package name from `iserv-bin` to `iserv`

This is done for consistency. We usually call the package file the same name the
folder has.  The move into `utils` is done so that we can move the library into
`libraries/iserv` and the proxy into `utils/iserv-proxy` and then break the
`iserv.cabal` apart.  This will make building the cross compiler with TH
simpler, because we can build the library and proxy as separate packages.

Test Plan: ./validate

Reviewers: bgamari, goldfire, erikd

Reviewed By: bgamari

Subscribers: rwbarton, thomie, carter

Differential Revision: https://phabricator.haskell.org/D4436

5 files changed, 252 insertions, 0 deletions

diff --git a/utils/iserv/Makefile b/utils/iserv/Makefile
new file mode 100644
index 0000000000..361985852f
--- /dev/null
+++ b/utils/iserv/Makefile
@@ -0,0 +1,15 @@
+# -----------------------------------------------------------------------------
+#
+# (c) 2009 The University of Glasgow
+#
+# This file is part of the GHC build system.
+#
+# To understand how the build system works and how to modify it, see
+#      http://ghc.haskell.org/trac/ghc/wiki/Building/Architecture
+#      http://ghc.haskell.org/trac/ghc/wiki/Building/Modifying
+#
+# -----------------------------------------------------------------------------
+
+dir = utils/iserv
+TOP = ../..
+include $(TOP)/mk/sub-makefile.mk
diff --git a/utils/iserv/cbits/iservmain.c b/utils/iserv/cbits/iservmain.c
new file mode 100644
index 0000000000..daefd35251
--- /dev/null
+++ b/utils/iserv/cbits/iservmain.c
@@ -0,0 +1,17 @@
+#include "../rts/PosixSource.h"
+#include "Rts.h"
+
+#include "HsFFI.h"
+
+int main (int argc, char *argv[])
+{
+    RtsConfig conf = defaultRtsConfig;
+
+    // We never know what symbols GHC will look up in the future, so
+    // we must retain CAFs for running interpreted code.
+    conf.keep_cafs = 1;
+
+    conf.rts_opts_enabled = RtsOptsAll;
+    extern StgClosure ZCMain_main_closure;
+    hs_main(argc, argv, &ZCMain_main_closure, conf);
+}
diff --git a/utils/iserv/ghc.mk b/utils/iserv/ghc.mk
new file mode 100644
index 0000000000..194621a85c
--- /dev/null
+++ b/utils/iserv/ghc.mk
@@ -0,0 +1,113 @@
+# -----------------------------------------------------------------------------
+#
+# (c) 2009-2012 The University of Glasgow
+#
+# This file is part of the GHC build system.
+#
+# To understand how the build system works and how to modify it, see
+#      http://ghc.haskell.org/trac/ghc/wiki/Building/Architecture
+#      http://ghc.haskell.org/trac/ghc/wiki/Building/Modifying
+#
+# -----------------------------------------------------------------------------
+
+utils/iserv_USES_CABAL = YES
+utils/iserv_PACKAGE = iserv
+utils/iserv_EXECUTABLE = iserv
+
+ifeq "$(GhcDebugged)" "YES"
+utils/iserv_stage2_MORE_HC_OPTS += -debug
+utils/iserv_stage2_p_MORE_HC_OPTS += -debug
+utils/iserv_stage2_dyn_MORE_HC_OPTS += -debug
+endif
+
+ifeq "$(GhcThreaded)" "YES"
+utils/iserv_stage2_MORE_HC_OPTS += -threaded
+utils/iserv_stage2_p_MORE_HC_OPTS += -threaded
+utils/iserv_stage2_dyn_MORE_HC_OPTS += -threaded
+endif
+
+# Add -Wl,--export-dynamic enables GHCi to load dynamic objects that
+# refer to the RTS.  This is harmless if you don't use it (adds a bit
+# of overhead to startup and increases the binary sizes) but if you
+# need it there's no alternative.
+ifeq "$(TargetElf)" "YES"
+ifneq "$(TargetOS_CPP)" "solaris2"
+# The Solaris linker does not support --export-dynamic option. It also
+# does not need it since it exports all dynamic symbols by default
+utils/iserv_stage2_MORE_HC_OPTS += -optl-Wl,--export-dynamic
+utils/iserv_stage2_p_MORE_HC_OPTS += -optl-Wl,--export-dynamic
+utils/iserv_stage2_dyn_MORE_HC_OPTS += -optl-Wl,--export-dynamic
+endif
+endif
+
+# Override the default way, because we want a specific version of this
+# program for each way.  Note that it's important to do this even for
+# the vanilla version, otherwise we get a dynamic executable when
+# DYNAMIC_GHC_PROGRAMS=YES.
+utils/iserv_stage2_PROGRAM_WAY = v
+utils/iserv_stage2_p_PROGRAM_WAY = p
+utils/iserv_stage2_dyn_PROGRAM_WAY = dyn
+
+utils/iserv_stage2_PROGNAME = ghc-iserv
+utils/iserv_stage2_p_PROGNAME = ghc-iserv-prof
+utils/iserv_stage2_dyn_PROGNAME = ghc-iserv-dyn
+
+utils/iserv_stage2_MORE_HC_OPTS += -no-hs-main
+utils/iserv_stage2_p_MORE_HC_OPTS += -no-hs-main
+utils/iserv_stage2_dyn_MORE_HC_OPTS += -no-hs-main
+
+utils/iserv_stage2_INSTALL = YES
+utils/iserv_stage2_p_INSTALL = YES
+utils/iserv_stage2_dyn_INSTALL = YES
+
+# Install in $(libexec), not in $(bindir)
+utils/iserv_stage2_TOPDIR = YES
+utils/iserv_stage2_p_TOPDIR = YES
+utils/iserv_stage2_dyn_TOPDIR = YES
+
+utils/iserv_stage2_INSTALL_INPLACE = YES
+utils/iserv_stage2_p_INSTALL_INPLACE = YES
+utils/iserv_stage2_dyn_INSTALL_INPLACE = YES
+
+ifeq "$(CLEANING)" "YES"
+
+NEED_iserv = YES
+NEED_iserv_p = YES
+NEED_iserv_dyn = YES
+
+else
+
+ifneq "$(findstring v, $(GhcLibWays))" ""
+NEED_iserv = YES
+else
+NEED_iserv = NO
+endif
+
+ifneq "$(findstring p, $(GhcLibWays))" ""
+NEED_iserv_p = YES
+else
+NEED_iserv_p = NO
+endif
+
+ifneq "$(findstring dyn, $(GhcLibWays))" ""
+NEED_iserv_dyn = YES
+else
+NEED_iserv_dyn = NO
+endif
+endif
+
+ifeq "$(NEED_iserv)" "YES"
+$(eval $(call build-prog,utils/iserv,stage2,1))
+endif
+
+ifeq "$(NEED_iserv_p)" "YES"
+$(eval $(call build-prog,utils/iserv,stage2_p,1))
+endif
+
+ifeq "$(NEED_iserv_dyn)" "YES"
+$(eval $(call build-prog,utils/iserv,stage2_dyn,1))
+endif
+
+all_ghc_stage2 : $(iserv-stage2_INPLACE)
+all_ghc_stage2 : $(iserv-stage2_p_INPLACE)
+all_ghc_stage2 : $(iserv-stage2_dyn_INPLACE)
diff --git a/utils/iserv/iserv.cabal b/utils/iserv/iserv.cabal
new file mode 100644
index 0000000000..f02d208262
--- /dev/null
+++ b/utils/iserv/iserv.cabal
@@ -0,0 +1,44 @@
+Name: iserv
+Version: 8.5
+Copyright: XXX
+License: BSD3
+-- XXX License-File: LICENSE
+Author: XXX
+Maintainer: XXX
+Synopsis: iserv allows GHC to delegate Tempalte Haskell computations
+Description:
+  GHC can be provided with a path to the iserv binary with
+  @-pgmi=/path/to/iserv-bin@, and will in combination with
+  @-fexternal-interpreter@, compile Template Haskell though the
+  @iserv-bin@ delegate. This is very similar to how ghcjs has been
+  compiling Template Haskell, by spawning a separate delegate (so
+  called runner on the javascript vm) and evaluating the splices
+  there.
+  .
+  To use iserv with cross compilers, please see @libraries/libiserv@
+  and @utils/iserv-proxy@.
+
+Category: Development
+build-type: Simple
+cabal-version: >=1.10
+
+Executable iserv
+    Default-Language: Haskell2010
+    ghc-options: -no-hs-main
+    Main-Is: Main.hs
+    C-Sources: cbits/iservmain.c
+    Hs-Source-Dirs: src
+    include-dirs: .
+    Build-Depends: array      >= 0.5 && < 0.6,
+                   base       >= 4   && < 5,
+                   binary     >= 0.7 && < 0.9,
+                   bytestring >= 0.10 && < 0.11,
+                   containers >= 0.5 && < 0.6,
+                   deepseq    >= 1.4 && < 1.5,
+                   ghci       == 8.5.*,
+                   libiserv   == 8.5
+
+    if os(windows)
+        Cpp-Options: -DWINDOWS
+    else
+        Build-Depends: unix   >= 2.7 && < 2.9
diff --git a/utils/iserv/src/Main.hs b/utils/iserv/src/Main.hs
new file mode 100644
index 0000000000..858cee8e94
--- /dev/null
+++ b/utils/iserv/src/Main.hs
@@ -0,0 +1,63 @@
+{-# LANGUAGE CPP, GADTs #-}
+
+-- |
+-- The Remote GHCi server.
+--
+-- For details on Remote GHCi, see Note [Remote GHCi] in
+-- compiler/ghci/GHCi.hs.
+--
+module Main (main) where
+
+import Lib (serv)
+
+import GHCi.Message
+import GHCi.Signals
+import GHCi.Utils
+
+import Control.Exception
+import Control.Monad
+import Data.IORef
+import System.Environment
+import System.Exit
+import Text.Printf
+
+dieWithUsage :: IO a
+dieWithUsage = do
+    prog <- getProgName
+    die $ prog ++ ": " ++ msg
+  where
+#ifdef WINDOWS
+    msg = "usage: iserv <write-handle> <read-handle> [-v]"
+#else
+    msg = "usage: iserv <write-fd> <read-fd> [-v]"
+#endif
+
+main :: IO ()
+main = do
+  args <- getArgs
+  (wfd1, rfd2, rest) <-
+      case args of
+        arg0:arg1:rest -> do
+            let wfd1 = read arg0
+                rfd2 = read arg1
+            return (wfd1, rfd2, rest)
+        _ -> dieWithUsage
+
+  verbose <- case rest of
+    ["-v"] -> return True
+    []     -> return False
+    _      -> dieWithUsage
+  when verbose $
+    printf "GHC iserv starting (in: %d; out: %d)\n"
+      (fromIntegral rfd2 :: Int) (fromIntegral wfd1 :: Int)
+  inh  <- getGhcHandle rfd2
+  outh <- getGhcHandle wfd1
+  installSignalHandlers
+  lo_ref <- newIORef Nothing
+  let pipe = Pipe{pipeRead = inh, pipeWrite = outh, pipeLeftovers = lo_ref}
+  uninterruptibleMask $ serv verbose hook pipe
+
+  where hook = return -- empty hook
+    -- we cannot allow any async exceptions while communicating, because
+    -- we will lose sync in the protocol, hence uninterruptibleMask.
+