diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6c25321..ccab33d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,6 +13,7 @@
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
 
 include(CmakeUtils)
+include(AddGollvm)
 
 # So that we can issue "make -jN" cmds in externalproject_add
 processorcount(PROCESSOR_COUNT)
@@ -67,6 +68,10 @@
   LOG_INSTALL 1
   )
 
+# Top level targets for building, installing
+add_custom_target(gollvm ALL)
+add_custom_target(install-gollvm)
+
 # In most use cases, we want to force a rebuild of all objects built
 # from Go source if the compiler changes.
 set(gocdep llvm-goc llvm-goc-token)
diff --git a/cmake/modules/AddGollvm.cmake b/cmake/modules/AddGollvm.cmake
new file mode 100644
index 0000000..954965c
--- /dev/null
+++ b/cmake/modules/AddGollvm.cmake
@@ -0,0 +1,66 @@
+
+# Library subdir within installation.
+# FIXME: select 32/64 based on default target triple
+set(libsubdir "lib64")
+
+# Set version number string (used by install rules)
+set(libversion ${LLVM_VERSION_MAJOR})
+if (NOT ${LLVM_VERSION_MINOR} EQUAL 0 AND NOT ${LLVM_VERSION_PATCH} EQUAL 0)
+  set(libversion "${libversion}.${LLVM_VERSION_MINOR}")
+endif()
+if (NOT ${LLVM_VERSION_PATCH} EQUAL 0)
+  set(libversion "${libversion}.${LLVM_VERSION_PATCH}")
+endif()
+
+# These are incorporated into GollvmConfig.h
+set(GOLLVM_LIBVERSION "${libversion}")
+set(GOLLVM_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}")
+set(GOLLVM_INSTALL_LIBDIR "${CMAKE_INSTALL_PREFIX}/${libsubdir}")
+
+macro(add_gollvm_library name)
+  llvm_add_library(${name} ${ARGN})
+
+  # Configure for install.
+  install(TARGETS ${name}
+    COMPONENT ${name}
+    LIBRARY DESTINATION ${libsubdir}
+    ARCHIVE DESTINATION ${libsubdir}
+    RUNTIME DESTINATION bin)
+
+  # Add an install target.
+  add_custom_target(install-${name}
+    DEPENDS ${name}
+    COMMAND "${CMAKE_COMMAND}"
+    -DCMAKE_INSTALL_COMPONENT=${name}
+    -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
+  add_dependencies(install-gollvm install-${name})
+
+  set_target_properties(${name} PROPERTIES FOLDER "Gollvm libraries")
+endmacro(add_gollvm_library)
+
+macro(add_gollvm_executable name)
+  add_llvm_executable(${name} ${ARGN} )
+  set_target_properties(${name} PROPERTIES FOLDER "Gollvm executables")
+endmacro(add_gollvm_executable)
+
+macro(add_gollvm_tool name)
+
+  add_gollvm_executable(${name} ${ARGN})
+
+  # Configure for install.
+  install(TARGETS ${name}
+    COMPONENT ${name}
+    LIBRARY DESTINATION ${libsubdir}
+    ARCHIVE DESTINATION ${libsubdir}
+    RUNTIME DESTINATION bin)
+
+  # Add an install target.
+  add_custom_target(install-${name}
+    DEPENDS ${name}
+    COMMAND "${CMAKE_COMMAND}"
+    -DCMAKE_INSTALL_COMPONENT=${name}
+    -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
+  add_dependencies(install-gollvm install-${name})
+
+  set_target_properties(${name} PROPERTIES FOLDER "Gollvm tools")
+endmacro()
diff --git a/cmake/modules/AutoGenGo.cmake b/cmake/modules/AutoGenGo.cmake
index ab5d51f..a93df0f 100644
--- a/cmake/modules/AutoGenGo.cmake
+++ b/cmake/modules/AutoGenGo.cmake
@@ -18,13 +18,14 @@
   file(REMOVE ${outfile})
   file(WRITE ${outfile} "package sys\n")
 
-  # FIXME: normally DefaultGoRoot is set to the --prefix option used
-  # when configuring (assuming that "configure" is run), but with
-  # cmake it's possible to do a build first and then later on install
-  # that build with a second run of cmake. For this reason looking at
-  # things like CMAKE_INSTALL_PREFIX doesn't make much sense (it will
-  # simply be set to /usr/local). This area needs some work.
-  file(APPEND ${outfile} "func init() { DefaultGoroot = \"${bindir}\" }\n")
+  # FIXME: typical LLVM usage allows for performing a build without
+  # CMAKE_INSTALL_PREFIX set, then doing an install from the build
+  # using a newly chosen CMAKE_INSTALL_PREFIX value. This mode is
+  # not currently supported -- the install prefix has to be set properly
+  # as part of the original build.
+
+  # Tools subdir within the install.
+  file(APPEND ${outfile} "func init() { DefaultGoroot = \"${CMAKE_INSTALL_PREFIX}\" }\n")
 
   # Compiler version
   file(STRINGS "${srcroot}/../VERSION" rawver)
@@ -39,7 +40,7 @@
   # executables. Where things like "cgo" will live hasn't been ironed
   # out yet, so just pick a spot in the bin directory for now. See also
   # 'DefaultGoRoot' above.
-  file(APPEND ${outfile} "const GccgoToolDir = \"${bindir}\"\n")
+  file(APPEND ${outfile} "const GccgoToolDir = \"${CMAKE_INSTALL_PREFIX}/tools\"\n")
 
   # FIXME: add a real switch base on configuration params here.
 
@@ -200,9 +201,7 @@
   file(WRITE ${outfile} "package objabi\n\n")
   file(APPEND ${outfile} "import \"runtime\"\n")
 
-  # FIXME: see the comment in mkversion above relating to the GoRoot
-  # setting (we may not know installation dir at time of cmake run).
-  file(APPEND ${outfile} "func init() { defaultGOROOT = \"${binroot}\" }\n")
+  file(APPEND ${outfile} "func init() { defaultGOROOT = \"${GOLLVM_INSTALL_DIR}\" }\n")
 
   file(APPEND ${outfile} "const defaultGO386 = `sse2`\n")
   file(APPEND ${outfile} "const defaultGOARM = `5`\n")
@@ -245,7 +244,6 @@
 #
 #   * package to use for generated Go code
 #   * output file to target
-#   * path to gollvm driver binary
 #   * C compiler path
 #   * C++ compiler path
 #
@@ -253,17 +251,15 @@
 #
 # EXPORT    Generated public functions (ex: DefaultCC not defaultCC).
 #
-function(mkzdefaultcc package outfile driverpath ccpath cxxpath)
+function(mkzdefaultcc package outfile ccpath cxxpath)
   CMAKE_PARSE_ARGUMENTS(ARG "EXPORT" "" "" ${ARGN})
 
+  # Construct default driver path
+  set(driverpath "${GOLLVM_INSTALL_DIR}/bin/llvm-goc")
+
   file(REMOVE ${outfile})
   file(WRITE ${outfile} "package ${package}\n\n")
 
-  # FIXME: once again, this is a problematic function since in theory
-  # we don't yet know yet where things are going to be installed. For
-  # the time being, just use that paths of the host build C/C++
-  # compiler and the gollvm driver executable.
-
   set(f1 "defaultGCCGO")
   set(f2 "defaultCC")
   set(f3 "defaultCXX")
diff --git a/cmake/modules/GoPackage.cmake b/cmake/modules/GoPackage.cmake
index c22a419..7e9e065 100644
--- a/cmake/modules/GoPackage.cmake
+++ b/cmake/modules/GoPackage.cmake
@@ -105,12 +105,27 @@
   # Create target
   add_custom_target(${pkgtarget} ALL DEPENDS ${pkg_outputs})
   set_target_properties(${pkgtarget} PROPERTIES FOLDER "Object Libraries")
+  add_dependencies(gollvm ${pkgtarget})
 
   # Caller needs to know these.
   set(package_ofile ${package_ofile} PARENT_SCOPE)
   set(package_picofile ${package_picofile} PARENT_SCOPE)
   set(package_goxfile ${package_goxfile} PARENT_SCOPE)
 
-  # TODO: add install rules
+  # *.gox files are installed in <lib>/go/<ver>/<triple>
+  set(goxinstalldest "lib${library_suffix}/go/${libversion}/${LLVM_DEFAULT_TARGET_TRIPLE}/${pdir}")
+
+  # Configure for install.
+  install(PROGRAMS ${package_goxfile}
+    COMPONENT ${pkgtarget}
+    DESTINATION ${goxinstalldest})
+
+  # Add an install target.
+  add_custom_target(install-${pkgtarget}
+    DEPENDS ${pkgtarget}
+    COMMAND "${CMAKE_COMMAND}"
+    -DCMAKE_INSTALL_COMPONENT=${pkgtarget}
+    -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
+  add_dependencies(install-gollvm install-${pkgtarget})
 
 endfunction()
diff --git a/cmake/modules/GoProgram.cmake b/cmake/modules/GoProgram.cmake
index 98fa81f..c20fb77 100644
--- a/cmake/modules/GoProgram.cmake
+++ b/cmake/modules/GoProgram.cmake
@@ -20,9 +20,10 @@
 # GOLIB     Libraries to link against.
 # GODEP     Targets on which this program should be dependent.
 # GOCFLAGS  Additional arguments passed to Go compiler.
+# ISUBDIR   Installation subdir (e.g. "tools" or "bin")
 
 function(add_go_program progname target libgodir destdir)
-  CMAKE_PARSE_ARGUMENTS(ARG "" "" "GOSRC;GOLIB;GODEP;GOCFLAGS" ${ARGN})
+  CMAKE_PARSE_ARGUMENTS(ARG "" "" "GOSRC;GOLIB;GODEP;GOCFLAGS;ISUBDIR" ${ARGN})
 
   set(object "${progname}_.o")
 
@@ -38,7 +39,7 @@
     OUTPUT ${object}
     COMMAND "${gocompiler}" "-c" "-o" ${object} ${ARG_GOSRC} ${ARG_GOCFLAGS}
             -I ${libgodir} -L ${libgodir}
-    DEPENDS ${deps}
+    DEPENDS ${deps} ${gocdep}
     COMMENT "Building object for go program ${progname}"
     VERBATIM)
 
@@ -53,8 +54,20 @@
 
   # Create target
   add_custom_target(${target} ALL DEPENDS ${program_exe})
-  set_target_properties(${target} PROPERTIES FOLDER "Tools")
 
-  # TODO: add install rules
+  # Configure for install.
+  install(PROGRAMS ${program_exe}
+    COMPONENT ${target}
+    DESTINATION ${ARG_ISUBDIR})
+
+  # Add an install target.
+  add_custom_target(install-${target}
+    DEPENDS ${target}
+    COMMAND "${CMAKE_COMMAND}"
+    -DCMAKE_INSTALL_COMPONENT=${target}
+    -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
+  add_dependencies(install-gollvm install-${target})
+
+  set_target_properties(${target} PROPERTIES FOLDER "Gollvm gotools")
 
 endfunction()
diff --git a/cmake/modules/GoVars.cmake b/cmake/modules/GoVars.cmake
index 4fa05a1..f6735cb 100644
--- a/cmake/modules/GoVars.cmake
+++ b/cmake/modules/GoVars.cmake
@@ -2,12 +2,14 @@
 # Set goarch/goos based on what we see in the LLVM triple.
 string(REGEX REPLACE "-" " " lht_components ${LLVM_DEFAULT_TARGET_TRIPLE})
 separate_arguments(lht_components)
-list(GET lht_components 0 goarch)
+list(GET lht_components 0 llarch)
 list(GET lht_components 2 goos)
 
 # LLVM's "x86_64" is the same as Go's "amd64".
-if( ${goarch} STREQUAL "x86_64" )
+if( ${llarch} STREQUAL "x86_64" )
   set(goarch "amd64")
+else()
+  message(SEND_ERROR "Arch ${llarch} not yet supported")
 endif()
 
 # List of all architectures, families, os flavors.
@@ -15,6 +17,13 @@
 set(allgoarchfamily "I386" "ALPHA" "AMD64" "ARM" "ARM64" "IA64" "M68K" "MIPS" "MIPS64" "PPC" "PPC64" "S390" "S390X" "SPARC" "SPARC64")
 set(allgoos "aix" "android" "darwin" "dragonfly" "freebsd" "irix" "linux" "netbsd" "openbsd" "plan9" "rtems" "solaris" "windows")
 
+# Set library suffix based on target triple
+if( ${llarch} STREQUAL "x86_64" )
+  set(library_suffix "64")
+else()
+  message(SEND_ERROR "Arch ${llarch} not yet supported")
+endif()
+
 # FIXME: write code to insure that this is set and that the shell
 # in question behaves properly.
 set(shell $ENV{SHELL})
diff --git a/driver-main/CMakeLists.txt b/driver-main/CMakeLists.txt
index 9ac9449..685b5ac 100644
--- a/driver-main/CMakeLists.txt
+++ b/driver-main/CMakeLists.txt
@@ -30,7 +30,7 @@
 include_directories(${EXTINSTALLDIR}/include)
 
 # The llvm-goc executable itself
-add_llvm_tool(llvm-goc
+add_gollvm_tool(llvm-goc
   llvm-goc.cpp)
 
 # Record the fact that llvm-goc depends on these libs
@@ -60,3 +60,7 @@
 # Token target.
 add_custom_target(llvm-goc-token ALL DEPENDS ${llvm_goc_token})
 
+# Add a symlink to llvm-goc named "gccgo" in install dir, for
+# compatibility with gccgo.
+install(CODE "execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink \"llvm-goc\" \"${CMAKE_INSTALL_PREFIX}/bin/gccgo\")"
+  COMPONENT llvm-goc)
diff --git a/driver/CMakeLists.txt b/driver/CMakeLists.txt
index d96d067..d1b13bd 100644
--- a/driver/CMakeLists.txt
+++ b/driver/CMakeLists.txt
@@ -7,6 +7,10 @@
 tablegen(LLVM GollvmOptions.inc -gen-opt-parser-defs)
 add_public_tablegen_target(GollvmDriverOptions)
 
+configure_file(
+    ${CMAKE_CURRENT_SOURCE_DIR}/GollvmConfig.h.cmake
+    ${CMAKE_CURRENT_BINARY_DIR}/GollvmConfig.h)
+
 # Include directories needed for this lib.
 include_directories(${GOFRONTEND_SOURCE_DIR})
 include_directories(${BRIDGE_SOURCE_DIR})
diff --git a/driver/CompileGo.cpp b/driver/CompileGo.cpp
index c4bc427..2c0b094 100644
--- a/driver/CompileGo.cpp
+++ b/driver/CompileGo.cpp
@@ -1,4 +1,4 @@
-//===-- CompileGo.cpp ------------------------------------------------------===//
+//===-- CompileGo.cpp -----------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -19,6 +19,7 @@
 #include "go-c.h"
 #include "mpfr.h"
 #include "GollvmOptions.h"
+#include "GollvmConfig.h"
 
 #include "Action.h"
 #include "Artifact.h"
@@ -29,6 +30,7 @@
 #include "llvm/ADT/Triple.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Bitcode/BitcodeWriterPass.h"
+#include "llvm/Config/llvm-config.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/IRPrintingPasses.h"
@@ -60,6 +62,8 @@
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
 
+#include <sstream>
+
 using namespace llvm;
 
 namespace gollvm {
@@ -458,14 +462,27 @@
       go_add_search_path(dir.c_str());
   }
 
-  // Library dirs
-  // TODO: add version, architecture dirs
+  // Start with list of user-provided -L directories, then append an
+  // entry corresponing to the lib dir for the install.
   std::vector<std::string> libargs =
       args_.getAllArgValues(gollvm::options::OPT_L);
+  libargs.push_back(GOLLVM_INSTALL_LIBDIR);
+
+  // Populate Go package search path based on -L options.
   for (auto &dir : libargs) {
-    struct stat st;
-    if (stat (dir.c_str(), &st) == 0 && S_ISDIR (st.st_mode))
-      go_add_search_path(dir.c_str());
+    if (!sys::fs::is_directory(dir))
+      continue;
+
+    std::stringstream b1;
+    b1 << dir << sys::path::get_separator().str() << "go"
+       << sys::path::get_separator().str() << GOLLVM_LIBVERSION;
+    if (sys::fs::is_directory(b1.str()))
+      go_add_search_path(b1.str().c_str());
+
+    std::stringstream b2;
+    b2 << b1.str() << sys::path::get_separator().str() << triple_.str();
+    if (sys::fs::is_directory(b2.str()))
+      go_add_search_path(b2.str().c_str());
   }
 
   return true;
diff --git a/driver/GnuTools.cpp b/driver/GnuTools.cpp
index a3d669e..67d10ac 100644
--- a/driver/GnuTools.cpp
+++ b/driver/GnuTools.cpp
@@ -16,6 +16,7 @@
 #include "Compilation.h"
 #include "Driver.h"
 #include "ToolChain.h"
+#include "GollvmConfig.h"
 
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/Path.h"
@@ -302,7 +303,8 @@
   }
 
   // Pick up correct directory for Go libraries.
-  std::string golib(llvm::Twine("-L" + compilation.driver().installDir() + "/../libgo/" + toolchain().driver().triple().str()).str());
+  std::string golib("-L");
+  golib += GOLLVM_INSTALL_LIBDIR;
   cmdArgs.push_back(args.MakeArgString(golib.c_str()));
 
   // Incorporate linker arguments needed for Go.
diff --git a/driver/GollvmConfig.h.cmake b/driver/GollvmConfig.h.cmake
new file mode 100644
index 0000000..bb0e56d
--- /dev/null
+++ b/driver/GollvmConfig.h.cmake
@@ -0,0 +1,17 @@
+
+#ifndef GOLLVM_CONFIG_H
+#define GOLLVM_CONFIG_H
+
+// Root of gollvm install
+#cmakedefine GOLLVM_INSTALL_DIR "@GOLLVM_INSTALL_DIR@"
+
+// Library subdir within install
+#cmakedefine GOLLVM_INSTALL_LIBDIR "@GOLLVM_INSTALL_LIBDIR@"
+
+// Library version (e.g. 7, 4.5, 8.0.1)
+#cmakedefine GOLLVM_LIBVERSION "@GOLLVM_LIBVERSION@"
+
+// Compiler version. Same as library version currently.
+#define GOLLVM_COMPILERVERSION GOLLVM_LIBVERSION
+
+#endif // GOLLVM_CONFIG_H
diff --git a/gotools/CMakeLists.txt b/gotools/CMakeLists.txt
index ad655dc..efeb26c 100644
--- a/gotools/CMakeLists.txt
+++ b/gotools/CMakeLists.txt
@@ -27,7 +27,7 @@
 # Cgo needs a copy of the defaultCC function in the "main" package.
 set(cgozdefaultccdotgo "${gotools_binroot}/zdefaultcc.go")
 set(cgozdefaultcctmp "${gotools_binroot}/zdefaultcc.go.tmp")
-mkzdefaultcc("main" ${cgozdefaultcctmp} ${gollvm_driver}
+mkzdefaultcc("main" ${cgozdefaultcctmp}
              ${CMAKE_C_COMPILER} ${CMAKE_CXX_COMPILER})
 copy_if_different(${cgozdefaultcctmp} ${cgozdefaultccdotgo})
 
@@ -73,17 +73,24 @@
       list(APPEND toolfiles "${${tool}_extra_go_files}")
     endif()
 
+    set(isubdir "tools")
+    if("${tool}" STREQUAL "go")
+      set(isubdir "bin")
+    endif()
+
     # Create target for program.
     add_go_program(${tool} ${tool_target}
       ${libgo_binroot} ${gotools_binroot}
       GOSRC ${toolfiles}
       GOLIB ${libgotool_archive}
+      ISUBDIR ${isubdir}
       GODEP libgotool libgo_shared libgo_static)
     list(APPEND allgotools ${tool_target})
   endif()
 endforeach()
 
 add_custom_target(gotools_all DEPENDS ${allgotools})
+add_dependencies(gollvm gotools_all)
 
 message(STATUS "gotools: generating check targets")
 
diff --git a/libgo/CMakeLists.txt b/libgo/CMakeLists.txt
index 83ee5df..4584503 100644
--- a/libgo/CMakeLists.txt
+++ b/libgo/CMakeLists.txt
@@ -222,7 +222,7 @@
 # Rules for zdefaultcc.go
 set(zdefaultccdotgo "${libgo_binroot}/zdefaultcc.go")
 set(zdefaultcctmp "${libgo_binroot}/zdefaultcc.go.tmp")
-mkzdefaultcc("cfg" ${zdefaultcctmp} ${gollvm_driver}
+mkzdefaultcc("cfg" ${zdefaultcctmp}
              ${CMAKE_C_COMPILER} ${CMAKE_CXX_COMPILER} EXPORT)
 copy_if_different(${zdefaultcctmp} ${zdefaultccdotgo})
 
@@ -456,7 +456,7 @@
 add_dependencies(libgo_c_nonpiclib runtimeinctarg)
 
 # Static libgo -- combines non-pic C objects and non-pic Go objects
-add_library(libgo_static STATIC
+add_gollvm_library(libgo_static STATIC
   $<TARGET_OBJECTS:libgo_c_nonpiclib>
   ${libgo_go_nonpicobjects}
   $<TARGET_OBJECTS:libbacktrace_nonpiclib>
@@ -470,7 +470,7 @@
     "${CMAKE_SHARED_LINKER_FLAGS}")
 
 # Shared libgo -- combines pic C objects and non-pic Go objects.
-add_library(libgo_shared SHARED
+add_gollvm_library(libgo_shared SHARED
   $<TARGET_OBJECTS:libgo_c_piclib>
   ${libgo_go_picobjects}
   $<TARGET_OBJECTS:libbacktrace_piclib>
@@ -484,7 +484,7 @@
 set(libgobegincfiles
   "${libgo_csrcroot}/runtime/go-main.c")
 # libgobegin.a (static library only)
-add_library(libgobegin STATIC
+add_gollvm_library(libgobegin STATIC
   ${libgobegincfiles})
 add_dependencies(libgobegin runtimeinctarg)
 target_include_directories(libgobegin PUBLIC
@@ -500,7 +500,7 @@
 set(libgolibbegincfiles
   "${libgo_csrcroot}/runtime/go-libmain.c")
 # libgolibbegin.a (static library only)
-add_library(libgolibbegin STATIC
+add_gollvm_library(libgolibbegin STATIC
   ${libgolibbegincfiles})
 add_dependencies(libgolibbegin runtimeinctarg)
 target_include_directories(libgolibbegin PUBLIC
@@ -516,6 +516,7 @@
 # Pseudo-target for all libgo buildables.
 add_custom_target(libgo_all DEPENDS
   llvm-goc libgo_static libgo_shared libgobegin libgolibbegin)
+add_dependencies(gollvm libgo_all)
 
 # Create a target-specific symlink to the Go library dir. This is
 # an interim solution; ideally we want to key off of CMAKE_INSTALL_PREFIX.