--- a/components/llvm/Makefile	Thu Jul 28 16:15:45 2016 -0700
+++ b/components/llvm/Makefile	Thu Jul 28 16:25:34 2016 -0700
@@ -23,27 +23,31 @@
 # Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
 #
 export PARFAIT_BUILD=no
-BUILD_BITS= 64
-COMPILER= gcc
+BUILD_BITS=64
+COMPILER=gcc
+
 include ../../make-rules/shared-macros.mk
 
 COMPONENT_NAME=		llvm
-COMPONENT_VERSION=	3.6.2
+COMPONENT_VERSION=	3.8.1
 COMPONENT_PROJECT_URL=	http://llvm.org/
+COMPONENT_SRC=		$(COMPONENT_NAME)
+COMPONENT_BUGDB=	utility/llvm
+
 COMPONENT_SRC=		$(COMPONENT_NAME)-$(COMPONENT_VERSION)
-COMPONENT_SRC_NAME =	$(COMPONENT_SRC).src
+COMPONENT_SRC_NAME=	$(COMPONENT_SRC).src
 COMPONENT_ARCHIVE=	$(COMPONENT_SRC_NAME).tar.xz
 COMPONENT_ARCHIVE_HASH=	\
-    sha256:f60dc158bfda6822de167e87275848969f0558b3134892ff54fced87e4667b94
+    sha256:6e82ce4adb54ff3afc18053d6981b6aed1406751b8742582ed50f04b5ab475f9
 COMPONENT_ARCHIVE_URL=	$(COMPONENT_PROJECT_URL)/releases/$(COMPONENT_VERSION)/$(COMPONENT_ARCHIVE)
 
-TPNO=			24358
+TPNO=			28049
 
 COMPONENT_NAME_1 =	clang
 COMPONENT_SRC_1 =	cfe-$(COMPONENT_VERSION).src
 COMPONENT_ARCHIVE_1 =	$(COMPONENT_SRC_1).tar.xz
 COMPONENT_ARCHIVE_HASH_1 = \
-	sha256:ae9180466a23acb426d12444d866b266ff2289b266064d362462e44f8d4699f3
+	sha256:4cd3836dfb4b88b597e075341cae86d61c63ce3963e45c7fe6a8bf59bb382cdf
 COMPONENT_ARCHIVE_URL_1 = $(COMPONENT_PROJECT_URL)/releases/$(COMPONENT_VERSION)/$(COMPONENT_ARCHIVE_1)
 
 COMPONENT_POST_UNPACK_ACTION = \
@@ -54,48 +58,74 @@
 	 $(CP) -rp $(COMPONENT_SRC_1) \
 	    $(COMPONENT_SRC)/tools/$(COMPONENT_NAME_1) )
 
-COMPONENT_PRE_CONFIGURE_ACTION = \
-	 ( cd $(SOURCE_DIR) ; \
-	 $(CHMOD) 0755 ./autoconf/AutoRegen.sh ; \
-	 ./autoconf/AutoRegen.sh )
-
-COMPONENT_POST_BUILD_ACTION = \
-      if test -d $(COMPONENT_DIR)/cxa_finalize ; then \
-      $(GMAKE) -C $(COMPONENT_DIR)/cxa_finalize build ; \
-      fi
-
-COMPONENT_POST_INSTALL_ACTION = \
-	if test -d $(COMPONENT_DIR)/cxa_finalize ; then \
-	$(GMAKE) -C $(COMPONENT_DIR)/cxa_finalize install ; \
-	fi;
-
 # Depends on S12-only changes in gcc; might be able to deal with later,
 # but avoid publishing while this is under investigation.
 ifeq ($(BUILD_TYPE), evaluation)
-BUILD_64=
-INSTALL_64=
-PUBLISH_STAMP=
+  BUILD_64=
+  INSTALL_64=
+  PUBLISH_STAMP=
 endif
 
-TEST_TARGET=
+BUILD_STYLE = cmake
+CLONEY = echo
+GNUCP = /usr/gnu/bin/cp
+
 include $(WS_MAKE_RULES)/common.mk
 
 PATCH_LEVEL := 0
 DEBUG_BUILD := 0
 GCC_VERSION := 4.9
+HAVE_SPHINX := 0
 
-# We need GCC version 4.9, and not another version.
+export PATH=/usr/gnu/bin:/usr/bin:/usr/perl5/$(PERL_VERSION)/bin
+
+# We use GCC version 4.9.3, and not another version for now.
 CC=$(USRDIR)/gcc/$(GCC_VERSION)/bin/gcc
 CXX=$(USRDIR)/gcc/$(GCC_VERSION)/bin/g++
 
+# We're building with CMake
+CMAKE=/usr/bin/cmake
+CMAKE_VERSION := $(shell $(CMAKE) --version 2>&1 | head -n1 \
+  | $(GSED) 's/cmake version \{1,\}//g')
+CMAKE_MAJOR_VERSION := $(shell echo $(CMAKE_VERSION) | cut -f1 -d'.')
+CMAKE_MINOR_VERSION := $(shell echo $(CMAKE_VERSION) | cut -f2 -d'.')
+CMAKE_MICRO_VERSION := $(shell echo $(CMAKE_VERSION) | cut -f3 -d'.')
+
+# CMake prior to 3.6.0 does not define CMAKE_HOST_SOLARIS.
+# In that case, we pass it in CMAKE_OPTIONS.
+CMAKE_NEEDS_SOLARIS_HOST := 0
+ifeq ($(shell expr $(CMAKE_MAJOR_VERSION) \<= 3 \& \
+		    $(CMAKE_MINOR_VERSION) \<= 5),1)
+  CMAKE_NEEDS_SOLARIS_HOST = 1
+endif
+
+# All of these shoujld probably be in shared-macros.mk
+CMAKE_INSTALL_BINDIR.32 = bin
+CMAKE_INSTALL_BINDIR.64 = bin/$(MACH64)
+CMAKE_INSTALL_BINDIR = $(CMAKE_INSTALL_BINDIR.$(BITS))
+
+CMAKE_INSTALL_LIBDIR.32 = lib
+CMAKE_INSTALL_LIBDIR.64 = lib/$(MACH64)
+CMAKE_INSTALL_LIBDIR = $(CMAKE_INSTALL_LIBDIR.$(BITS))
+
+CMAKE_INSTALL_LIBEXECDIR.32 = libexec
+CMAKE_INSTALL_LIBEXECDIR.64 = libexec/$(MACH64)
+CMAKE_INSTALL_LIBEXECDIR = $(CMAKE_INSTALL_LIBEXECDIR.$(BITS))
+
+CMAKE_INSTALL_INCLUDEDIR = include
+CMAKE_INSTALL_DATADIR = share
+CMAKE_INSTALL_DATAROOTDIR = share
+
 # We need the specific C++ runtime that clang/llvm was built and
 # linked with, and not some random and incompatible stuff from
 # /usr/lib.
-LLVM_RUNPATH_32 = $(USRDIR)/gcc/$(GCC_VERSION)/lib
-LLVM_RUNPATH_64 = $(USRDIR)/gcc/$(GCC_VERSION)/lib/$(MACH64)
+LLVM_RUNPATH_32 = /usr/gcc/$(GCC_VERSION)/lib
+LLVM_RUNPATH_64 = /usr/gcc/$(GCC_VERSION)/lib/$(MACH64)
 LLVM_RUNPATH = $(LLVM_RUNPATH_$(BITS))
 
-# -O0 for now. Ideally we want -O2.
+# -O0. GCC on SPARC dies with an out-memory error in cc1plus when
+# building with either -O1 or -O2 (32-bit). If it manages to get
+# through with -O1 or -O2 (64-bit), the resulting bits are unusable.
 OFLAG="-O0"
 GFLAG=""
 
@@ -104,24 +134,110 @@
   GFLAG="-g3"
 endif
 
-export PATH=$(GNUBIN):$(USRDIR)/xpg4/bin:$(USRBINDIR):$(USRDIR)/perl5/5.16/bin
-
 # Because LLVM's install target doesn't install everything that
 # needs to be installed.
 EXTRA_INSTALL_BITS=llvm-lto arcmt-test c-arcmt-test c-index-test diagtool
-LLVM_BINDIR=$(BUILD_DIR_64)/Release/bin
+LLVM_INSTALL_BINDIR.32=$(PROTOUSRBINDIR)
+LLVM_INSTALL_BINDIR.64=$(PROTOUSRBINDIR64)
+LLVM_INSTALL_BINDIR=$(LLVM_INSTALL_BINDIR.$(BITS))
+LLVM_BINDIR=$(BUILD_DIR_$(BITS))/bin
+
+INSTALL_CXA_FINALIZE := 0
+ifeq ($(SOLARIS_11_ONLY),)
+  INSTALL_CXA_FINALIZE = 1
+endif
 
-ifeq ($(DEBUG_BUILD), 1)
-  LLVM_BINDIR=$(BUILD_DIR_64)/Debug+Asserts+Checks/bin
-endif
+SCAN_VIEW_FILES=Reporter.py ScanView.py
+CLANG_FORMAT_FILES=clang-format-diff.py clang-format-sublime.py \
+		   clang-format.py
+LLVM_MAN_FILES=FileCheck.1 bugpoint.1 clang.1 lit.1 llc.1 lli.1 \
+	       llvm-ar.1 llvm-as.1 llvm-bcanalyzer.1 llvm-build.1 \
+	       llvm-config.1 llvm-cov.1 llvm-diff.1 llvm-dis.1 \
+	       llvm-dwarfdump.1 llvm-extract.1 llvm-lib.1 llvm-link.1 \
+	       llvm-nm.1 llvm-profdata.1 llvm-readobj.1 llvm-stress.1 \
+	       llvm-symbolizer.1 opt.1 tblgen.1
+
+COMPONENT_POST_BUILD_ACTION = \
+      if test -d $(COMPONENT_DIR)/cxa_finalize ; then \
+      /usr/gnu/bin/touch $(COMPONENT_DIR)/cxa_finalize/.patched ; \
+      /usr/gnu/bin/touch $(COMPONENT_DIR)/cxa_finalize/.prep ; \
+      $(GMAKE) -C $(COMPONENT_DIR)/cxa_finalize build ; \
+      /usr/gnu/bin/touch $(COMPONENT_DIR)/cxa_finalize/.built ; \
+      fi
+
+COMPONENT_POST_INSTALL_ACTION = \
+	if test -d $(COMPONENT_DIR)/cxa_finalize ; then \
+	$(GMAKE) -C $(COMPONENT_DIR)/cxa_finalize install ; \
+	/usr/gnu/bin/touch $(COMPONENT_DIR)/cxa_finalize/.installed ; \
+	fi;
 
 COMPONENT_POST_INSTALL_ACTION += \
 	list1='$(EXTRA_INSTALL_BITS)' ; for f in $$list1 ; do \
-	    $(INSTALL) --mode=755 $(LLVM_BINDIR)/$$f $(PROTOUSRBINDIR)/$$f ; \
-	done;
+	    $(INSTALL) --mode=755 $(LLVM_BINDIR)/$$f \
+			$(LLVM_INSTALL_BINDIR)/$$f ; \
+	done ;
+
+COMPONENT_POST_INSTALL_ACTION += \
+	$(MKDIR) \
+	  $(PROTOUSRLIBDIR)/python$(PYTHON_VERSION)/vendor-packages ; \
+	list2='$(SCAN_VIEW_FILES)' ; for f in $$list2 ; do \
+	$(INSTALL) --mode=644 $(PROTOUSRSHAREDIR)/scan-view/$$f \
+	  $(PROTOUSRLIBDIR)/python$(PYTHON_VERSION)/vendor-packages/$$f ; \
+	done ;
+
+COMPONENT_POST_INSTALL_ACTION += \
+	list3='$(CLANG_FORMAT_FILES)' ; for f in $$list3 ; do \
+	  $(INSTALL) --mode=644 $(PROTOUSRSHAREDIR)/clang/$$f \
+	    $(PROTOUSRLIBDIR)/python$(PYTHON_VERSION)/vendor-packages/$$f ; \
+	done ;
+
+COMPONENT_POST_INSTALL_ACTION += \
+	cd $(COMPONENT_DIR) ; \
+	$(GNUCP) -rpd $(PROTOUSRLIBDIR64)/clang $(PROTOUSRLIBDIR)/ ;
+
+COMPONENT_POST_INSTALL_ACTION += \
+	cd $(PROTOUSRLIBDIR) ; \
+	$(PYTHON) -m compileall . ;
 
-# No ASLR for compilers.
-ASLR_MODE = $(ASLR_DISABLE)
+COMPONENT_POST_INSTALL_ACTION += \
+	cd $(COMPONENT_DIR) ; \
+	$(MKDIR) $(PROTOUSRSHAREMAN1DIR) ; \
+	list4='$(LLVM_MAN_FILES)' ; for f in $$list4 ; do \
+	  $(INSTALL) --mode=644 $(COMPONENT_DIR)/Solaris/man1/$$f \
+	    $(PROTOUSRSHAREMAN1DIR)/$$f ; \
+	done ;
+
+ifeq ($(INSTALL_CXA_FINALIZE),1)
+COMPONENT_POST_INSTALL_ACTION += \
+	$(INSTALL) --mode=644 \
+	  $(COMPONENT_DIR)/cxa_finalize/cxa_finalize-32.o \
+	  $(PROTOUSRLIBDIR)/clang/cxa_finalize.o ; \
+	$(INSTALL) --mode=644 \
+	  $(COMPONENT_DIR)/cxa_finalize/cxa_finalize_pic-32.o \
+	  $(PROTOUSRLIBDIR)/clang/cxa_finalize_pic.o ; \
+	$(INSTALL) --mode=644 \
+	  $(COMPONENT_DIR)/cxa_finalize/cxa_finalize-64.o \
+	  $(PROTOUSRLIBDIR)/clang/$(MACH64)/cxa_finalize.o ; \
+	$(INSTALL) --mode=644 \
+	  $(COMPONENT_DIR)/cxa_finalize/cxa_finalize_pic-64.o \
+	  $(PROTOUSRLIBDIR)/clang/$(MACH64)/cxa_finalize_pic.o ;
+endif
+
+# Results output is slightly different on Intel vs. SPARC.
+# Not enabled just yet because of problems with the way opt
+# and FileCheck emit and parse the test case results.
+COMPONENT_TEST_MASTER = \
+	$(COMPONENT_TEST_RESULTS_DIR)/results-$(MACH).master
+
+# Do not change the order of these regexp transforms.
+COMPONENT_TEST_TRANSFORMS += \
+    '-e "/gmake -f/d"' \
+    '-e "/gmake/d"' \
+    '-e "/--color=/d"' \
+    '-e "/Entering/d"' \
+    '-e "/Leaving/d"' \
+    '-e "/Built target/d"' \
+    '-e "/Nothing to be done/d"'
 
 # GCC options used:
 # -ftree-vectorize | -fno-tree-vectorize:
@@ -196,8 +312,9 @@
 #
 # -mno-sse3 -mno-ssse3:
 # Do not use SSE3/SSSE3 instructions on Intel. These might not be
-# available. Building for Opteron - which implies SSE2 - is adequate
-# for performance purposes.
+# available and they always come with side-effects.
+# Building for Opteron - which implies SSE2 - is adequate for
+# performance purposes.
 
 CFLAGS = -m$(BITS) $(GFLAG) $(OFLAG) -pthread -std=c99 -fno-strict-aliasing
 CFLAGS += -fno-tree-slp-vectorize -fno-tree-vectorize
@@ -205,9 +322,15 @@
 CFLAGS += -Wall -Wcast-align -Wno-long-long -Woverflow
 CFLAGS += -Wstack-protector -fdata-sections -fstack-protector-all
 CFLAGS += -fkeep-static-consts -ffunction-sections
-CFLAGS += -Wl,-z -Wl,relax=common -Wl,-z -Wl,relax=secadj
-CFLAGS += -Wl,-z -Wl,relax=transtls -Wl,-R -Wl,$(LLVM_RUNPATH)
+CFLAGS += -Wl,-z -Wl,relax=common
+CFLAGS += -Wl,-z -Wl,relax=secadj
+CFLAGS += -Wl,-z -Wl,relax=transtls
+CFLAGS += -Wl,-z -Wl,relax=symbound
+CFLAGS += -Wl,-R -Wl,$(LLVM_RUNPATH)
 CFLAGS.i386 += -mtune=opteron -mno-sse3 -mno-ssse3 -fno-common
+ifeq ($(DEBUG_BUILD),1)
+  CFLAGS.i386 += -fno-omit-frame-pointer
+endif
 CFLAGS.sparc += -mtune=ultrasparc -mcpu=ultrasparc -mvis -mhard-float
 CFLAGS.sparc += -mptr$(BITS) -fdata-sections -falign-functions=8
 CFLAGS.sparc += -mno-unaligned-doubles -mimpure-text
@@ -220,18 +343,22 @@
 CXXFLAGS += -Wall -Wcast-align -Wno-long-long -Woverflow
 CXXFLAGS += -Wstack-protector -fkeep-static-consts
 CXXFLAGS += -std=c++11 -fdata-sections -ffunction-sections
-CXXFLAGS += -Wl,-z -Wl,relax=common -Wl,-z -Wl,relax=secadj
-CXXFLAGS += -Wl,-z -Wl,relax=transtls -Wl,-R -Wl,$(LLVM_RUNPATH)
+CXXFLAGS += -Wl,-z -Wl,relax=common
+CXXFLAGS += -Wl,-z -Wl,relax=secadj
+CXXFLAGS += -Wl,-z -Wl,relax=transtls
+CXXFLAGS += -Wl,-z -Wl,relax=symbound
+CXXFLAGS += -Wl,-z -Wl,relax=comdat
+CXXFLAGS += -Wl,-R -Wl,$(LLVM_RUNPATH)
 CXXFLAGS.sparc += -mptr$(BITS)
 CXXFLAGS += $(CFLAGS.$(MACH))
 
-CPPFLAGS = -D_GNU_SOURCE -DLLVM_SOLARIS -I$(USRGNUDIR)/include
+CPPFLAGS = -D_GNU_SOURCE -DLLVM_SOLARIS -I/usr/gnu/include
 
-ifeq ($(DEBUG_BUILD), 1)
+ifeq ($(DEBUG_BUILD),1)
   CPPFLAGS += -D_DEBUG
 endif
 
-CPPFLAGS += -D_REENTRANT -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64
+CPPFLAGS += -D_REENTRANT -D_LARGEFILE64_SOURCE
 CPPFLAGS += -D_FILE_OFFSET_BITS=64 -D__EXTENSIONS__=1
 CPPFLAGS += -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS
 CPPFLAGS += -D__STDC_LIMIT_MACROS -DHAVE_POSIX_MEMALIGN
@@ -240,68 +367,146 @@
 CPPFLAGS.sparc = -DLLVM_SPARC
 CPPFLAGS += $(CPPFLAGS.$(MACH))
 
-LLVM_LIBEXECDIR_32 = $(USRDIR)/libexec
-LLVM_LIBEXECDIR_64 = $(USRDIR)/libexec/$(MACH64)
+LLVM_LIBEXECDIR_32 = /usr/libexec
+LLVM_LIBEXECDIR_64 = /usr/libexec/$(MACH64)
 LLVM_LIBEXECDIR = $(LLVM_LIBEXECDIR_$(BITS))
 
-CONFIGURE_OPTIONS += --libexecdir=$(LLVM_LIBEXECDIR)
-CONFIGURE_OPTIONS += --sharedstatedir=/tmp
-CONFIGURE_OPTIONS += --localstatedir=$(VARDIR)
-CONFIGURE_OPTIONS += --enable-compiler-version-checks
-CONFIGURE_OPTIONS += --enable-clang-static-analyzer
+LIBFFI_INCDIR_32 = /usr/lib/libffi-3.0.9/include
+LIBFFI_INCDIR_64 = /usr/lib/$(MACH64)/libffi-3.0.9/include
+LIBFFI_INCDIR = $(LIBFFI_INCDIR_$(BITS))
+
+LIBFFI_LIBDIR_32 = /usr/lib
+LIBFFI_LIBDIR_64 = /usr/lib/$(MACH64)
+LIBFFI_LIBDIR = $(LIBFFI_LIBDIR_$(BITS))
+
+# -Bdirect and -M /usr/lib/ld/map.noexbss break SPARC builds.
+LD_B_DIRECT =
+LD_OPTIONS = -M /usr/lib/ld/map.noexstk
+LD_OPTIONS += -M /usr/lib/ld/map.pagealign
+LD_OPTIONS_SO = $(LD_Z_DEFS) $(LD_DEF_LIBS)
 
-ifeq ($(DEBUG_BUILD), 1)
-  CONFIGURE_OPTIONS += --enable-assertions
-  CONFIGURE_OPTIONS += --disable-optimized
-  CONFIGURE_OPTIONS += --enable-expensive-checks
-  CONFIGURE_OPTIONS += --enable-debug-runtime
-  CONFIGURE_OPTIONS += --enable-debug-symbols
-else
-  CONFIGURE_OPTIONS += --disable-assertions
-  CONFIGURE_OPTIONS += --enable-optimized
-  CONFIGURE_OPTIONS += --disable-expensive-checks
-  CONFIGURE_OPTIONS += --disable-debug-runtime
-  CONFIGURE_OPTIONS += --disable-debug-symbols
+CMAKE_OPTIONS = -DCMAKE_C_COMPILER:FILEPATH=$(CC)
+CMAKE_OPTIONS += -DCMAKE_CXX_COMPILER:FILEPATH=$(CXX)
+CMAKE_OPTIONS += -DCMAKE_C_CFLAGS:STRING="$(CPPFLAGS) $(CFLAGS)"
+CMAKE_OPTIONS += -DCMAKE_CXX_FLAGS:STRING="$(CPPFLAGS) $(CXXFLAGS)"
+CMAKE_OPTIONS += -DCMAKE_EXE_LINKER_FLAGS:STRING="$(LDFLAGS)"
+CMAKE_OPTIONS += -DCMAKE_INSTALL_PREFIX:FILEPATH=$(CMAKE_PREFIX)
+CMAKE_OPTIONS += -DCMAKE_AR:FILEPATH=/usr/bin/ar
+
+CMAKE_OPTIONS += -DCMAKE_INSTALL_BINDIR:STRING="$(CMAKE_INSTALL_BINDIR)"
+CMAKE_OPTIONS += -DCMAKE_INSTALL_LIBDIR:STRING="$(CMAKE_INSTALL_LIBDIR)"
+CMAKE_OPTIONS += -DCMAKE_INSTALL_LIBEXECDIR:STRING="$(CMAKE_INSTALL_LIBEXECDIR)"
+CMAKE_OPTIONS += -DCMAKE_INSTALL_INCLUDEDIR:STRING="$(CMAKE_INSTALL_INCLUDEDIR)"
+CMAKE_OPTIONS += -DCMAKE_INSTALL_DATADIR:STRING="$(CMAKE_INSTALL_DATADIR)"
+CMAKE_OPTIONS += -DCMAKE_INSTALL_DATAROOTDIR:STRING="$(CMAKE_INSTALL_DATAROOTDIR)"
+
+ifeq ($(MACH),sparc)
+  CMAKE_OPTIONS += -DLLVM_TARGETS_TO_BUILD:STRING="Sparc"
+endif
+ifeq ($(MACH),i386)
+  CMAKE_OPTIONS += -DLLVM_TARGETS_TO_BUILD:STRING="X86"
 endif
 
-CONFIGURE_OPTIONS += --enable-keep-symbols
-CONFIGURE_OPTIONS += --enable-jit
-CONFIGURE_OPTIONS += --disable-docs
-CONFIGURE_OPTIONS += --disable-doxygen
-CONFIGURE_OPTIONS += --enable-threads
-CONFIGURE_OPTIONS += --enable-pthreads
-CONFIGURE_OPTIONS += --enable-shared
-CONFIGURE_OPTIONS += --enable-zlib
-CONFIGURE_OPTIONS += --enable-pic
-CONFIGURE_OPTIONS += --enable-timestamps
-CONFIGURE_OPTIONS += --enable-backtraces
-CONFIGURE_OPTIONS += --enable-bindings=auto
-CONFIGURE_OPTIONS += --enable-libffi
-CONFIGURE_OPTIONS += --enable-terminfo
-CONFIGURE_OPTIONS += --disable-ltdl-install
-CONFIGURE_OPTIONS += --with-python=$(PYTHON)
+CMAKE_OPTIONS += -DCMAKE_MAKE_PROGRAM:STRING="/usr/bin/gmake"
+CMAKE_OPTIONS += -DCMAKE_ASM_COMPILER:STRING="/usr/gnu/bin/as"
+CMAKE_OPTIONS += -DCMAKE_INSTALL_RPATH:STRING="$(LLVM_RUNPATH)"
+CMAKE_OPTIONS += -DLLVM_BUILD_TOOLS:BOOL=ON
+CMAKE_OPTIONS += -DLLVM_INCLUDE_TOOLS:BOOL=ON
+CMAKE_OPTIONS += -DLLVM_BUILD_TESTS:BOOL=ON
+CMAKE_OPTIONS += -DLLVM_INCLUDE_TESTS:BOOL=ON
+CMAKE_OPTIONS += -DLLVM_ENABLE_THREADS:BOOL=ON
+CMAKE_OPTIONS += -DLLVM_BUILD_32_BITS:BOOL=OFF
+
+# CMake tries really hard to be too smart for its own good.
+ifeq ($(DEBUG_BUILD),1)
+  CMAKE_OPTIONS += -DCMAKE_BUILD_TYPE:STRING=Debug
+  CMAKE_OPTIONS += -DCMAKE_C_FLAGS_DEBUG:STRING="$(OFLAG) $(GFLAG)"
+  CMAKE_OPTIONS += -DCMAKE_CXX_FLAGS_DEBUG:STRING="$(OFLAG) $(GFLAG)"
+  CMAKE_OPTIONS += -DCMAKE_ASM_FLAGS_DEBUG:STRING="$(OFLAG) $(GFLAG)"
+  CMAKE_OPTIONS += -DCMAKE_ASM_FLAGS_RELWITHDEBINFO:STRING="$(OFLAG) $(GFLAG)"
+  CMAKE_OPTIONS += -DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING="$(OFLAG) $(GFLAG)"
+  CMAKE_OPTIONS += -DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING="$(OFLAG) $(GFLAG)"
+  CMAKE_OPTIONS += -DLLVM_BUILD_EXAMPLES:BOOL=ON
+  CMAKE_OPTIONS += -DLLVM_INCLUDE_EXAMPLES:BOOL=ON
+  CMAKE_OPTIONS += -DLLVM_ENABLE_ASSERTIONS:BOOL=ON
+  CMAKE_OPTIONS += -DLLVM_ENABLE_EXPENSIVE_CHECKS:BOOL=ON
+else
+  CMAKE_OPTIONS += -DCMAKE_BUILD_TYPE:STRING=Release
+  CMAKE_OPTIONS += -DCMAKE_C_FLAGS_DEBUG:STRING="$(OFLAG)"
+  CMAKE_OPTIONS += -DCMAKE_CXX_FLAGS_DEBUG:STRING="$(OFLAG)"
+  CMAKE_OPTIONS += -DCMAKE_ASM_FLAGS_DEBUG:STRING="$(OFLAG)"
+  CMAKE_OPTIONS += -DCMAKE_ASM_FLAGS_RELWITHDEBINFO:STRING="$(OFLAG)"
+  CMAKE_OPTIONS += -DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING="$(OFLAG)"
+  CMAKE_OPTIONS += -DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING="$(OFLAG)"
+  CMAKE_OPTIONS += -DLLVM_BUILD_EXAMPLES:BOOL=OFF
+  CMAKE_OPTIONS += -DLLVM_INCLUDE_EXAMPLES:BOOL=OFF
+  CMAKE_OPTIONS += -DLLVM_ENABLE_ASSERTIONS:BOOL=OFF
+  CMAKE_OPTIONS += -DLLVM_ENABLE_EXPENSIVE_CHECKS:BOOL=OFF
+endif
 
-ifeq ($(MACH),sparc)
-  CONFIGURE_OPTIONS += --with-extra-ld-options='-lkstat'
+CMAKE_OPTIONS += -DLLVM_ENABLE_EH:BOOL=ON
+CMAKE_OPTIONS += -DLLVM_ENABLE_PIC:BOOL=ON
+CMAKE_OPTIONS += -DLLVM_ENABLE_RTTI:BOOL=ON
+CMAKE_OPTIONS += -DLLVM_ENABLE_WARNINGS:BOOL=ON
+CMAKE_OPTIONS += -DLLVM_ENABLE_PEDANTIC:BOOL=ON
+CMAKE_OPTIONS += -DLLVM_ABI_BREAKING_CHECKS:STRING="FORCE_OFF"
+CMAKE_OPTIONS += -DLLVM_ENABLE_ZLIB:BOOL=ON
+CMAKE_OPTIONS += -DLLVM_ENABLE_FFI:BOOL=ON
+CMAKE_OPTIONS += -DFFI_INCLUDE_DIR:STRING=$(LIBFFI_INCDIR)
+CMAKE_OPTIONS += -DFFI_LIBRARY_DIR:STRING=$(LIBFFI_LIBDIR)
+
+ifeq ($(HAVE_SPHINX),1)
+  CMAKE_OPTIONS += -DSPHINX_EXECUTABLE:STRING="/usr/bin/sphinx-build"
+  CMAKE_OPTIONS += -DLLVM_ENABLE_SPHINX:BOOL=ON
+  CMAKE_OPTIONS += -DLLVM_BUILD_DOCS:BOOL=ON
+  CMAKE_OPTIONS += -DSPHINX_OUTPUT_HTML:BOOL=ON
+  CMAKE_OPTIONS += -DSPHINX_OUTPUT_MAN:BOOL=ON
 endif
-CONFIGURE_OPTIONS += --with-gcc-toolchain=$(USRDIR)/gcc/$(GCC_VERSION)
-CONFIGURE_OPTIONS += --with-optimize-option="$(OFLAG) $(GFLAG)"
+
+# Always build the libLLVM and libclang shared libraries
+CMAKE_OPTIONS += -DLLVM_BUILD_LLVM_DYLIB:BOOL=ON
+CMAKE_OPTIONS += -DLLVM_LINK_LLVM_DYLIB:BOOL=ON
+
+CMAKE_OPTIONS += -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON
+
+CMAKE_OPTIONS += -DLLVM_COMPILER_IS_GCC_COMPATIBLE:BOOL=ON
 
-# Enable the cross-compiler in 3.8.X.
-CONFIGURE_OPTIONS.i386 += --enable-targets="x86"
-CONFIGURE_OPTIONS.sparc += --enable-targets="sparc"
+ifeq ($(CMAKE_NEEDS_SOLARIS_HOST),1)
+  CMAKE_OPTIONS += -DCMAKE_HOST_SOLARIS:BOOL=TRUE
+endif
+
+COMPONENT_BUILD_ENV = CC="$(CC)"
+COMPONENT_BUILD_ENV += CXX="$(CXX)"
+COMPONENT_BUILD_ENV += CFLAGS="$(CFLAGS)"
+COMPONENT_BUILD_ENV += CXXFLAGS="$(CXXFLAGS)"
+COMPONENT_BUILD_ENV += LDFLAGS="$(LDFLAGS)"
+COMPONENT_BUILD_ENV += LD_OPTIONS="$(LD_OPTIONS)"
+COMPONENT_BUILD_ENV += PATH="$(PATH)"
+COMPONENT_BUILD_ENV += LANG="C"
+COMPONENT_BUILD_ENV += LC_ALL="C"
+COMPONENT_BUILD_ENV += LD_EXEC_OPTIONS="-zaslr=disable"
 
 # Put this here for now until the gpatch problems are resolved.
-COMPONENT_BUILD_ARGS += -j8
+COMPONENT_BUILD_ARGS += -j4
 
 # use bash(1) to run the install recipes otherwise clang header installation
 # fails
 COMPONENT_INSTALL_ARGS += SHELL=/bin/bash
 
-# common targets
-# There are no master test results yet. TBDL in 3.8.X.
+COMPONENT_PRE_BUILD_ACTION += cd $(@D) ;
+COMPONENT_PRE_BUILD_ACTION += echo BITS: $(BITS) ;
+COMPONENT_PRE_BUILD_ACTION += echo Running cmake with $(CMAKE_OPTIONS) ;
+COMPONENT_PRE_BUILD_ACTION += /usr/bin/env - $(COMPONENT_BUILD_ENV) \
+			      $(CMAKE) $(CMAKE_OPTIONS) \
+			      $(COMPONENT_DIR)/$(COMPONENT_SRC) ;
+
+
+# There are no master test results just yet. But there will be
+# very soon.
 test:
-	@echo "Tests not yet implemented (wait for 3.8.X)."
+	@echo "Tests not yet implemented - coming soon in LLVM 3.8.1."
+
+system-test:    $(SYSTEM_TESTS_NOT_IMPLEMENTED)
 
 REQUIRED_PACKAGES += developer/gcc-4/gcc-common-49
 REQUIRED_PACKAGES += developer/gnu-binutils
@@ -309,6 +514,13 @@
 REQUIRED_PACKAGES += library/libffi
 REQUIRED_PACKAGES += library/libxml2
 REQUIRED_PACKAGES += library/zlib
+REQUIRED_PACKAGES += runtime/perl-522
+REQUIRED_PACKAGES += library/perl-5/xml-libxml
+REQUIRED_PACKAGES += library/perl-5/xml-namespacesupport
+REQUIRED_PACKAGES += library/perl-5/xml-parser
+REQUIRED_PACKAGES += library/perl-5/xml-sax
+REQUIRED_PACKAGES += library/perl-5/xml-sax-base
+REQUIRED_PACKAGES += library/perl-5/xml-simple
 REQUIRED_PACKAGES += runtime/python-27
 REQUIRED_PACKAGES += system/core-os
 REQUIRED_PACKAGES += system/header
@@ -318,3 +530,4 @@
 REQUIRED_PACKAGES += system/library/gcc/gcc-gobjc-runtime-49
 REQUIRED_PACKAGES += system/library/math
 REQUIRED_PACKAGES += system/linker
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/components/llvm/Solaris/man1/FileCheck.1	Thu Jul 28 16:25:34 2016 -0700
@@ -0,0 +1,555 @@
+.\" Man page generated from reStructuredText.
+.
+.TH "FILECHECK" "1" "2016-07-10" "3.8" "LLVM"
+.SH NAME
+FileCheck \- Flexible pattern matching file verifier
+.
+.nr rst2man-indent-level 0
+.
+.de1 rstReportMargin
+\\$1 \\n[an-margin]
+level \\n[rst2man-indent-level]
+level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
+-
+\\n[rst2man-indent0]
+\\n[rst2man-indent1]
+\\n[rst2man-indent2]
+..
+.de1 INDENT
+.\" .rstReportMargin pre:
+. RS \\$1
+. nr rst2man-indent\\n[rst2man-indent-level] \\n[an-margin]
+. nr rst2man-indent-level +1
+.\" .rstReportMargin post:
+..
+.de UNINDENT
+. RE
+.\" indent \\n[an-margin]
+.\" old: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.nr rst2man-indent-level -1
+.\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.in \\n[rst2man-indent\\n[rst2man-indent-level]]u
+..
+.SH SYNOPSIS
+.sp
+\fBFileCheck\fP \fImatch\-filename\fP [\fI\-\-check\-prefix=XXX\fP] [\fI\-\-strict\-whitespace\fP]
+.SH DESCRIPTION
+.sp
+\fBFileCheck\fP reads two files (one from standard input, and one
+specified on the command line) and uses one to verify the other.  This
+behavior is particularly useful for the testsuite, which wants to verify that
+the output of some tool (e.g. \fBllc\fP) contains the expected information
+(for example, a movsd from esp or whatever is interesting).  This is similar to
+using \fBgrep\fP, but it is optimized for matching multiple different
+inputs in one file in a specific order.
+.sp
+The \fBmatch\-filename\fP file specifies the file that contains the patterns to
+match.  The file to verify is read from standard input unless the
+\fI\%\-\-input\-file\fP option is used.
+.SH OPTIONS
+.INDENT 0.0
+.TP
+.B \-help
+Print a summary of command line options.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-check\-prefix prefix
+FileCheck searches the contents of \fBmatch\-filename\fP for patterns to
+match.  By default, these patterns are prefixed with "\fBCHECK:\fP".
+If you\(aqd like to use a different prefix (e.g. because the same input
+file is checking multiple different tool or options), the
+\fI\%\-\-check\-prefix\fP argument allows you to specify one or more
+prefixes to match. Multiple prefixes are useful for tests which might
+change for different run options, but most lines remain the same.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-input\-file filename
+File to check (defaults to stdin).
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-strict\-whitespace
+By default, FileCheck canonicalizes input horizontal whitespace (spaces and
+tabs) which causes it to ignore these differences (a space will match a tab).
+The \fI\%\-\-strict\-whitespace\fP argument disables this behavior. End\-of\-line
+sequences are canonicalized to UNIX\-style \fB\en\fP in all modes.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-implicit\-check\-not check\-pattern
+Adds implicit negative checks for the specified patterns between positive
+checks. The option allows writing stricter tests without stuffing them with
+\fBCHECK\-NOT\fPs.
+.sp
+For example, "\fB\-\-implicit\-check\-not warning:\fP" can be useful when testing
+diagnostic messages from tools that don\(aqt have an option similar to \fBclang
+\-verify\fP\&. With this option FileCheck will verify that input does not contain
+warnings not covered by any \fBCHECK:\fP patterns.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-version
+Show the version number of this program.
+.UNINDENT
+.SH EXIT STATUS
+.sp
+If \fBFileCheck\fP verifies that the file matches the expected contents,
+it exits with 0.  Otherwise, if not, or if an error occurs, it will exit with a
+non\-zero value.
+.SH TUTORIAL
+.sp
+FileCheck is typically used from LLVM regression tests, being invoked on the RUN
+line of the test.  A simple example of using FileCheck from a RUN line looks
+like this:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+; RUN: llvm\-as < %s | llc \-march=x86\-64 | FileCheck %s
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+This syntax says to pipe the current file ("\fB%s\fP") into \fBllvm\-as\fP, pipe
+that into \fBllc\fP, then pipe the output of \fBllc\fP into \fBFileCheck\fP\&.  This
+means that FileCheck will be verifying its standard input (the llc output)
+against the filename argument specified (the original \fB\&.ll\fP file specified by
+"\fB%s\fP").  To see how this works, let\(aqs look at the rest of the \fB\&.ll\fP file
+(after the RUN line):
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+define void @sub1(i32* %p, i32 %v) {
+entry:
+; CHECK: sub1:
+; CHECK: subl
+        %0 = tail call i32 @llvm.atomic.load.sub.i32.p0i32(i32* %p, i32 %v)
+        ret void
+}
+
+define void @inc4(i64* %p) {
+entry:
+; CHECK: inc4:
+; CHECK: incq
+        %0 = tail call i64 @llvm.atomic.load.add.i64.p0i64(i64* %p, i64 1)
+        ret void
+}
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+Here you can see some "\fBCHECK:\fP" lines specified in comments.  Now you can
+see how the file is piped into \fBllvm\-as\fP, then \fBllc\fP, and the machine code
+output is what we are verifying.  FileCheck checks the machine code output to
+verify that it matches what the "\fBCHECK:\fP" lines specify.
+.sp
+The syntax of the "\fBCHECK:\fP" lines is very simple: they are fixed strings that
+must occur in order.  FileCheck defaults to ignoring horizontal whitespace
+differences (e.g. a space is allowed to match a tab) but otherwise, the contents
+of the "\fBCHECK:\fP" line is required to match some thing in the test file exactly.
+.sp
+One nice thing about FileCheck (compared to grep) is that it allows merging
+test cases together into logical groups.  For example, because the test above
+is checking for the "\fBsub1:\fP" and "\fBinc4:\fP" labels, it will not match
+unless there is a "\fBsubl\fP" in between those labels.  If it existed somewhere
+else in the file, that would not count: "\fBgrep subl\fP" matches if "\fBsubl\fP"
+exists anywhere in the file.
+.SS The FileCheck \-check\-prefix option
+.sp
+The FileCheck \fB\-check\-prefix\fP option allows multiple test
+configurations to be driven from one \fI\&.ll\fP file.  This is useful in many
+circumstances, for example, testing different architectural variants with
+\fBllc\fP\&.  Here\(aqs a simple example:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+; RUN: llvm\-as < %s | llc \-mtriple=i686\-apple\-darwin9 \-mattr=sse41 \e
+; RUN:              | FileCheck %s \-check\-prefix=X32
+; RUN: llvm\-as < %s | llc \-mtriple=x86_64\-apple\-darwin9 \-mattr=sse41 \e
+; RUN:              | FileCheck %s \-check\-prefix=X64
+
+define <4 x i32> @pinsrd_1(i32 %s, <4 x i32> %tmp) nounwind {
+        %tmp1 = insertelement <4 x i32>; %tmp, i32 %s, i32 1
+        ret <4 x i32> %tmp1
+; X32: pinsrd_1:
+; X32:    pinsrd $1, 4(%esp), %xmm0
+
+; X64: pinsrd_1:
+; X64:    pinsrd $1, %edi, %xmm0
+}
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+In this case, we\(aqre testing that we get the expected code generation with
+both 32\-bit and 64\-bit code generation.
+.SS The "CHECK\-NEXT:" directive
+.sp
+Sometimes you want to match lines and would like to verify that matches
+happen on exactly consecutive lines with no other lines in between them.  In
+this case, you can use "\fBCHECK:\fP" and "\fBCHECK\-NEXT:\fP" directives to specify
+this.  If you specified a custom check prefix, just use "\fB<PREFIX>\-NEXT:\fP".
+For example, something like this works as you\(aqd expect:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+define void @t2(<2 x double>* %r, <2 x double>* %A, double %B) {
+     %tmp3 = load <2 x double>* %A, align 16
+     %tmp7 = insertelement <2 x double> undef, double %B, i32 0
+     %tmp9 = shufflevector <2 x double> %tmp3,
+                            <2 x double> %tmp7,
+                            <2 x i32> < i32 0, i32 2 >
+     store <2 x double> %tmp9, <2 x double>* %r, align 16
+     ret void
+
+; CHECK:          t2:
+; CHECK:             movl    8(%esp), %eax
+; CHECK\-NEXT:        movapd  (%eax), %xmm0
+; CHECK\-NEXT:        movhpd  12(%esp), %xmm0
+; CHECK\-NEXT:        movl    4(%esp), %eax
+; CHECK\-NEXT:        movapd  %xmm0, (%eax)
+; CHECK\-NEXT:        ret
+}
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+"\fBCHECK\-NEXT:\fP" directives reject the input unless there is exactly one
+newline between it and the previous directive.  A "\fBCHECK\-NEXT:\fP" cannot be
+the first directive in a file.
+.SS The "CHECK\-SAME:" directive
+.sp
+Sometimes you want to match lines and would like to verify that matches happen
+on the same line as the previous match.  In this case, you can use "\fBCHECK:\fP"
+and "\fBCHECK\-SAME:\fP" directives to specify this.  If you specified a custom
+check prefix, just use "\fB<PREFIX>\-SAME:\fP".
+.sp
+"\fBCHECK\-SAME:\fP" is particularly powerful in conjunction with "\fBCHECK\-NOT:\fP"
+(described below).
+.sp
+For example, the following works like you\(aqd expect:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+!0 = !DILocation(line: 5, scope: !1, inlinedAt: !2)
+
+; CHECK:       !DILocation(line: 5,
+; CHECK\-NOT:               column:
+; CHECK\-SAME:              scope: ![[SCOPE:[0\-9]+]]
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+"\fBCHECK\-SAME:\fP" directives reject the input if there are any newlines between
+it and the previous directive.  A "\fBCHECK\-SAME:\fP" cannot be the first
+directive in a file.
+.SS The "CHECK\-NOT:" directive
+.sp
+The "\fBCHECK\-NOT:\fP" directive is used to verify that a string doesn\(aqt occur
+between two matches (or before the first match, or after the last match).  For
+example, to verify that a load is removed by a transformation, a test like this
+can be used:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+define i8 @coerce_offset0(i32 %V, i32* %P) {
+  store i32 %V, i32* %P
+
+  %P2 = bitcast i32* %P to i8*
+  %P3 = getelementptr i8* %P2, i32 2
+
+  %A = load i8* %P3
+  ret i8 %A
+; CHECK: @coerce_offset0
+; CHECK\-NOT: load
+; CHECK: ret i8
+}
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.SS The "CHECK\-DAG:" directive
+.sp
+If it\(aqs necessary to match strings that don\(aqt occur in a strictly sequential
+order, "\fBCHECK\-DAG:\fP" could be used to verify them between two matches (or
+before the first match, or after the last match). For example, clang emits
+vtable globals in reverse order. Using \fBCHECK\-DAG:\fP, we can keep the checks
+in the natural order:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+// RUN: %clang_cc1 %s \-emit\-llvm \-o \- | FileCheck %s
+
+struct Foo { virtual void method(); };
+Foo f;  // emit vtable
+// CHECK\-DAG: @_ZTV3Foo =
+
+struct Bar { virtual void method(); };
+Bar b;
+// CHECK\-DAG: @_ZTV3Bar =
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+\fBCHECK\-NOT:\fP directives could be mixed with \fBCHECK\-DAG:\fP directives to
+exclude strings between the surrounding \fBCHECK\-DAG:\fP directives. As a result,
+the surrounding \fBCHECK\-DAG:\fP directives cannot be reordered, i.e. all
+occurrences matching \fBCHECK\-DAG:\fP before \fBCHECK\-NOT:\fP must not fall behind
+occurrences matching \fBCHECK\-DAG:\fP after \fBCHECK\-NOT:\fP\&. For example,
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+; CHECK\-DAG: BEFORE
+; CHECK\-NOT: NOT
+; CHECK\-DAG: AFTER
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+This case will reject input strings where \fBBEFORE\fP occurs after \fBAFTER\fP\&.
+.sp
+With captured variables, \fBCHECK\-DAG:\fP is able to match valid topological
+orderings of a DAG with edges from the definition of a variable to its use.
+It\(aqs useful, e.g., when your test cases need to match different output
+sequences from the instruction scheduler. For example,
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+; CHECK\-DAG: add [[REG1:r[0\-9]+]], r1, r2
+; CHECK\-DAG: add [[REG2:r[0\-9]+]], r3, r4
+; CHECK:     mul r5, [[REG1]], [[REG2]]
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+In this case, any order of that two \fBadd\fP instructions will be allowed.
+.sp
+If you are defining \fIand\fP using variables in the same \fBCHECK\-DAG:\fP block,
+be aware that the definition rule can match \fIafter\fP its use.
+.sp
+So, for instance, the code below will pass:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+; CHECK\-DAG: vmov.32 [[REG2:d[0\-9]+]][0]
+; CHECK\-DAG: vmov.32 [[REG2]][1]
+vmov.32 d0[1]
+vmov.32 d0[0]
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+While this other code, will not:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+; CHECK\-DAG: vmov.32 [[REG2:d[0\-9]+]][0]
+; CHECK\-DAG: vmov.32 [[REG2]][1]
+vmov.32 d1[1]
+vmov.32 d0[0]
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+While this can be very useful, it\(aqs also dangerous, because in the case of
+register sequence, you must have a strong order (read before write, copy before
+use, etc). If the definition your test is looking for doesn\(aqt match (because
+of a bug in the compiler), it may match further away from the use, and mask
+real bugs away.
+.sp
+In those cases, to enforce the order, use a non\-DAG directive between DAG\-blocks.
+.SS The "CHECK\-LABEL:" directive
+.sp
+Sometimes in a file containing multiple tests divided into logical blocks, one
+or more \fBCHECK:\fP directives may inadvertently succeed by matching lines in a
+later block. While an error will usually eventually be generated, the check
+flagged as causing the error may not actually bear any relationship to the
+actual source of the problem.
+.sp
+In order to produce better error messages in these cases, the "\fBCHECK\-LABEL:\fP"
+directive can be used. It is treated identically to a normal \fBCHECK\fP
+directive except that FileCheck makes an additional assumption that a line
+matched by the directive cannot also be matched by any other check present in
+\fBmatch\-filename\fP; this is intended to be used for lines containing labels or
+other unique identifiers. Conceptually, the presence of \fBCHECK\-LABEL\fP divides
+the input stream into separate blocks, each of which is processed independently,
+preventing a \fBCHECK:\fP directive in one block matching a line in another block.
+For example,
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+define %struct.C* @C_ctor_base(%struct.C* %this, i32 %x) {
+entry:
+; CHECK\-LABEL: C_ctor_base:
+; CHECK: mov [[SAVETHIS:r[0\-9]+]], r0
+; CHECK: bl A_ctor_base
+; CHECK: mov r0, [[SAVETHIS]]
+  %0 = bitcast %struct.C* %this to %struct.A*
+  %call = tail call %struct.A* @A_ctor_base(%struct.A* %0)
+  %1 = bitcast %struct.C* %this to %struct.B*
+  %call2 = tail call %struct.B* @B_ctor_base(%struct.B* %1, i32 %x)
+  ret %struct.C* %this
+}
+
+define %struct.D* @D_ctor_base(%struct.D* %this, i32 %x) {
+entry:
+; CHECK\-LABEL: D_ctor_base:
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+The use of \fBCHECK\-LABEL:\fP directives in this case ensures that the three
+\fBCHECK:\fP directives only accept lines corresponding to the body of the
+\fB@C_ctor_base\fP function, even if the patterns match lines found later in
+the file. Furthermore, if one of these three \fBCHECK:\fP directives fail,
+FileCheck will recover by continuing to the next block, allowing multiple test
+failures to be detected in a single invocation.
+.sp
+There is no requirement that \fBCHECK\-LABEL:\fP directives contain strings that
+correspond to actual syntactic labels in a source or output language: they must
+simply uniquely match a single line in the file being verified.
+.sp
+\fBCHECK\-LABEL:\fP directives cannot contain variable definitions or uses.
+.SS FileCheck Pattern Matching Syntax
+.sp
+All FileCheck directives take a pattern to match.
+For most uses of FileCheck, fixed string matching is perfectly sufficient.  For
+some things, a more flexible form of matching is desired.  To support this,
+FileCheck allows you to specify regular expressions in matching strings,
+surrounded by double braces: \fB{{yourregex}}\fP\&.  Because we want to use fixed
+string matching for a majority of what we do, FileCheck has been designed to
+support mixing and matching fixed string matching with regular expressions.
+This allows you to write things like this:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+; CHECK: movhpd      {{[0\-9]+}}(%esp), {{%xmm[0\-7]}}
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+In this case, any offset from the ESP register will be allowed, and any xmm
+register will be allowed.
+.sp
+Because regular expressions are enclosed with double braces, they are
+visually distinct, and you don\(aqt need to use escape characters within the double
+braces like you would in C.  In the rare case that you want to match double
+braces explicitly from the input, you can use something ugly like
+\fB{{[{][{]}}\fP as your pattern.
+.SS FileCheck Variables
+.sp
+It is often useful to match a pattern and then verify that it occurs again
+later in the file.  For codegen tests, this can be useful to allow any register,
+but verify that that register is used consistently later.  To do this,
+\fBFileCheck\fP allows named variables to be defined and substituted into
+patterns.  Here is a simple example:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+; CHECK: test5:
+; CHECK:    notw     [[REGISTER:%[a\-z]+]]
+; CHECK:    andw     {{.*}}[[REGISTER]]
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+The first check line matches a regex \fB%[a\-z]+\fP and captures it into the
+variable \fBREGISTER\fP\&.  The second line verifies that whatever is in
+\fBREGISTER\fP occurs later in the file after an "\fBandw\fP".  \fBFileCheck\fP
+variable references are always contained in \fB[[ ]]\fP pairs, and their names can
+be formed with the regex \fB[a\-zA\-Z][a\-zA\-Z0\-9]*\fP\&.  If a colon follows the name,
+then it is a definition of the variable; otherwise, it is a use.
+.sp
+\fBFileCheck\fP variables can be defined multiple times, and uses always
+get the latest value.  Variables can also be used later on the same line they
+were defined on. For example:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+; CHECK: op [[REG:r[0\-9]+]], [[REG]]
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+Can be useful if you want the operands of \fBop\fP to be the same register,
+and don\(aqt care exactly which register it is.
+.SS FileCheck Expressions
+.sp
+Sometimes there\(aqs a need to verify output which refers line numbers of the
+match file, e.g. when testing compiler diagnostics.  This introduces a certain
+fragility of the match file structure, as "\fBCHECK:\fP" lines contain absolute
+line numbers in the same file, which have to be updated whenever line numbers
+change due to text addition or deletion.
+.sp
+To support this case, FileCheck allows using \fB[[@LINE]]\fP,
+\fB[[@LINE+<offset>]]\fP, \fB[[@LINE\-<offset>]]\fP expressions in patterns. These
+expressions expand to a number of the line where a pattern is located (with an
+optional integer offset).
+.sp
+This way match patterns can be put near the relevant test lines and include
+relative line number references, for example:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+// CHECK: test.cpp:[[@LINE+4]]:6: error: expected \(aq;\(aq after top level declarator
+// CHECK\-NEXT: {{^int a}}
+// CHECK\-NEXT: {{^     \e^}}
+// CHECK\-NEXT: {{^     ;}}
+int a
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.SH AUTHOR
+Maintained by The LLVM Team (http://llvm.org/).
+.SH COPYRIGHT
+2003-2016, LLVM Project
+.\" Generated by docutils manpage writer.
+.

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/components/llvm/Solaris/man1/bugpoint.1	Thu Jul 28 16:25:34 2016 -0700
@@ -0,0 +1,292 @@
+.\" Man page generated from reStructuredText.
+.
+.TH "BUGPOINT" "1" "2016-07-10" "3.8" "LLVM"
+.SH NAME
+bugpoint \- automatic test case reduction tool
+.
+.nr rst2man-indent-level 0
+.
+.de1 rstReportMargin
+\\$1 \\n[an-margin]
+level \\n[rst2man-indent-level]
+level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
+-
+\\n[rst2man-indent0]
+\\n[rst2man-indent1]
+\\n[rst2man-indent2]
+..
+.de1 INDENT
+.\" .rstReportMargin pre:
+. RS \\$1
+. nr rst2man-indent\\n[rst2man-indent-level] \\n[an-margin]
+. nr rst2man-indent-level +1
+.\" .rstReportMargin post:
+..
+.de UNINDENT
+. RE
+.\" indent \\n[an-margin]
+.\" old: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.nr rst2man-indent-level -1
+.\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.in \\n[rst2man-indent\\n[rst2man-indent-level]]u
+..
+.SH SYNOPSIS
+.sp
+\fBbugpoint\fP [\fIoptions\fP] [\fIinput LLVM ll/bc files\fP] [\fILLVM passes\fP] \fB\-\-args\fP
+\fIprogram arguments\fP
+.SH DESCRIPTION
+.sp
+\fBbugpoint\fP narrows down the source of problems in LLVM tools and passes.  It
+can be used to debug three types of failures: optimizer crashes, miscompilations
+by optimizers, or bad native code generation (including problems in the static
+and JIT compilers).  It aims to reduce large test cases to small, useful ones.
+For more information on the design and inner workings of \fBbugpoint\fP, as well as
+advice for using bugpoint, see \fIllvm/docs/Bugpoint.html\fP in the LLVM
+distribution.
+.SH OPTIONS
+.sp
+\fB\-\-additional\-so\fP \fIlibrary\fP
+.INDENT 0.0
+.INDENT 3.5
+Load the dynamic shared object \fIlibrary\fP into the test program whenever it is
+run.  This is useful if you are debugging programs which depend on non\-LLVM
+libraries (such as the X or curses libraries) to run.
+.UNINDENT
+.UNINDENT
+.sp
+\fB\-\-append\-exit\-code\fP=\fI{true,false}\fP
+.INDENT 0.0
+.INDENT 3.5
+Append the test programs exit code to the output file so that a change in exit
+code is considered a test failure. Defaults to false.
+.UNINDENT
+.UNINDENT
+.sp
+\fB\-\-args\fP \fIprogram args\fP
+.INDENT 0.0
+.INDENT 3.5
+Pass all arguments specified after \fB\-\-args\fP to the test program whenever it runs.
+Note that if any of the \fIprogram args\fP start with a "\fB\-\fP", you should use:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+bugpoint [bugpoint args] \-\-args \-\- [program args]
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+The "\fB\-\-\fP" right after the \fB\-\-args\fP option tells \fBbugpoint\fP to consider
+any options starting with "\fB\-\fP" to be part of the \fB\-\-args\fP option, not as
+options to \fBbugpoint\fP itself.
+.UNINDENT
+.UNINDENT
+.sp
+\fB\-\-tool\-args\fP \fItool args\fP
+.INDENT 0.0
+.INDENT 3.5
+Pass all arguments specified after \fB\-\-tool\-args\fP to the LLVM tool under test
+(\fBllc\fP, \fBlli\fP, etc.) whenever it runs.  You should use this option in the
+following way:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+bugpoint [bugpoint args] \-\-tool\-args \-\- [tool args]
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+The "\fB\-\-\fP" right after the \fB\-\-tool\-args\fP option tells \fBbugpoint\fP to
+consider any options starting with "\fB\-\fP" to be part of the \fB\-\-tool\-args\fP
+option, not as options to \fBbugpoint\fP itself. (See \fB\-\-args\fP, above.)
+.UNINDENT
+.UNINDENT
+.sp
+\fB\-\-safe\-tool\-args\fP \fItool args\fP
+.INDENT 0.0
+.INDENT 3.5
+Pass all arguments specified after \fB\-\-safe\-tool\-args\fP to the "safe" execution
+tool.
+.UNINDENT
+.UNINDENT
+.sp
+\fB\-\-gcc\-tool\-args\fP \fIgcc tool args\fP
+.INDENT 0.0
+.INDENT 3.5
+Pass all arguments specified after \fB\-\-gcc\-tool\-args\fP to the invocation of
+\fBgcc\fP\&.
+.UNINDENT
+.UNINDENT
+.sp
+\fB\-\-opt\-args\fP \fIopt args\fP
+.INDENT 0.0
+.INDENT 3.5
+Pass all arguments specified after \fB\-\-opt\-args\fP to the invocation of \fBopt\fP\&.
+.UNINDENT
+.UNINDENT
+.sp
+\fB\-\-disable\-{dce,simplifycfg}\fP
+.INDENT 0.0
+.INDENT 3.5
+Do not run the specified passes to clean up and reduce the size of the test
+program. By default, \fBbugpoint\fP uses these passes internally when attempting to
+reduce test programs.  If you\(aqre trying to find a bug in one of these passes,
+\fBbugpoint\fP may crash.
+.UNINDENT
+.UNINDENT
+.sp
+\fB\-\-enable\-valgrind\fP
+.INDENT 0.0
+.INDENT 3.5
+Use valgrind to find faults in the optimization phase. This will allow
+bugpoint to find otherwise asymptomatic problems caused by memory
+mis\-management.
+.UNINDENT
+.UNINDENT
+.sp
+\fB\-find\-bugs\fP
+.INDENT 0.0
+.INDENT 3.5
+Continually randomize the specified passes and run them on the test program
+until a bug is found or the user kills \fBbugpoint\fP\&.
+.UNINDENT
+.UNINDENT
+.sp
+\fB\-help\fP
+.INDENT 0.0
+.INDENT 3.5
+Print a summary of command line options.
+.UNINDENT
+.UNINDENT
+.sp
+\fB\-\-input\fP \fIfilename\fP
+.INDENT 0.0
+.INDENT 3.5
+Open \fIfilename\fP and redirect the standard input of the test program, whenever
+it runs, to come from that file.
+.UNINDENT
+.UNINDENT
+.sp
+\fB\-\-load\fP \fIplugin\fP
+.INDENT 0.0
+.INDENT 3.5
+Load the dynamic object \fIplugin\fP into \fBbugpoint\fP itself.  This object should
+register new optimization passes.  Once loaded, the object will add new command
+line options to enable various optimizations.  To see the new complete list of
+optimizations, use the \fB\-help\fP and \fB\-\-load\fP options together; for example:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+bugpoint \-\-load myNewPass.so \-help
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.UNINDENT
+.UNINDENT
+.sp
+\fB\-\-mlimit\fP \fImegabytes\fP
+.INDENT 0.0
+.INDENT 3.5
+Specifies an upper limit on memory usage of the optimization and codegen. Set
+to zero to disable the limit.
+.UNINDENT
+.UNINDENT
+.sp
+\fB\-\-output\fP \fIfilename\fP
+.INDENT 0.0
+.INDENT 3.5
+Whenever the test program produces output on its standard output stream, it
+should match the contents of \fIfilename\fP (the "reference output"). If you
+do not use this option, \fBbugpoint\fP will attempt to generate a reference output
+by compiling the program with the "safe" backend and running it.
+.UNINDENT
+.UNINDENT
+.sp
+\fB\-\-run\-{int,jit,llc,custom}\fP
+.INDENT 0.0
+.INDENT 3.5
+Whenever the test program is compiled, \fBbugpoint\fP should generate code for it
+using the specified code generator.  These options allow you to choose the
+interpreter, the JIT compiler, the static native code compiler, or a
+custom command (see \fB\-\-exec\-command\fP) respectively.
+.UNINDENT
+.UNINDENT
+.sp
+\fB\-\-safe\-{llc,custom}\fP
+.INDENT 0.0
+.INDENT 3.5
+When debugging a code generator, \fBbugpoint\fP should use the specified code
+generator as the "safe" code generator. This is a known\-good code generator
+used to generate the "reference output" if it has not been provided, and to
+compile portions of the program that as they are excluded from the testcase.
+These options allow you to choose the
+static native code compiler, or a custom command, (see \fB\-\-exec\-command\fP)
+respectively. The interpreter and the JIT backends cannot currently
+be used as the "safe" backends.
+.UNINDENT
+.UNINDENT
+.sp
+\fB\-\-exec\-command\fP \fIcommand\fP
+.INDENT 0.0
+.INDENT 3.5
+This option defines the command to use with the \fB\-\-run\-custom\fP and
+\fB\-\-safe\-custom\fP options to execute the bitcode testcase. This can
+be useful for cross\-compilation.
+.UNINDENT
+.UNINDENT
+.sp
+\fB\-\-compile\-command\fP \fIcommand\fP
+.INDENT 0.0
+.INDENT 3.5
+This option defines the command to use with the \fB\-\-compile\-custom\fP
+option to compile the bitcode testcase. This can be useful for
+testing compiler output without running any link or execute stages. To
+generate a reduced unit test, you may add CHECK directives to the
+testcase and pass the name of an executable compile\-command script in this form:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+#!/bin/sh
+llc "$@"
+not FileCheck [bugpoint input file].ll < bugpoint\-test\-program.s
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+This script will "fail" as long as FileCheck passes. So the result
+will be the minimum bitcode that passes FileCheck.
+.UNINDENT
+.UNINDENT
+.sp
+\fB\-\-safe\-path\fP \fIpath\fP
+.INDENT 0.0
+.INDENT 3.5
+This option defines the path to the command to execute with the
+\fB\-\-safe\-{int,jit,llc,custom}\fP
+option.
+.UNINDENT
+.UNINDENT
+.SH EXIT STATUS
+.sp
+If \fBbugpoint\fP succeeds in finding a problem, it will exit with 0.  Otherwise,
+if an error occurs, it will exit with a non\-zero value.
+.SH SEE ALSO
+.sp
+opt|opt
+.SH AUTHOR
+Maintained by The LLVM Team (http://llvm.org/).
+.SH COPYRIGHT
+2003-2016, LLVM Project
+.\" Generated by docutils manpage writer.
+.

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/components/llvm/Solaris/man1/clang.1	Thu Jul 28 16:25:34 2016 -0700
@@ -0,0 +1,583 @@
+.\" Man page generated from reStructuredText.
+.
+.TH "CLANG" "1" "Jul 10, 2016" "3.8" "Clang"
+.SH NAME
+clang \- the Clang C, C++, and Objective-C compiler
+.
+.nr rst2man-indent-level 0
+.
+.de1 rstReportMargin
+\\$1 \\n[an-margin]
+level \\n[rst2man-indent-level]
+level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
+-
+\\n[rst2man-indent0]
+\\n[rst2man-indent1]
+\\n[rst2man-indent2]
+..
+.de1 INDENT
+.\" .rstReportMargin pre:
+. RS \\$1
+. nr rst2man-indent\\n[rst2man-indent-level] \\n[an-margin]
+. nr rst2man-indent-level +1
+.\" .rstReportMargin post:
+..
+.de UNINDENT
+. RE
+.\" indent \\n[an-margin]
+.\" old: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.nr rst2man-indent-level -1
+.\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.in \\n[rst2man-indent\\n[rst2man-indent-level]]u
+..
+.SH SYNOPSIS
+.sp
+\fBclang\fP [\fIoptions\fP] \fIfilename ...\fP
+.SH DESCRIPTION
+.sp
+\fBclang\fP is a C, C++, and Objective\-C compiler which encompasses
+preprocessing, parsing, optimization, code generation, assembly, and linking.
+Depending on which high\-level mode setting is passed, Clang will stop before
+doing a full link.  While Clang is highly integrated, it is important to
+understand the stages of compilation, to understand how to invoke it.  These
+stages are:
+.INDENT 0.0
+.TP
+.B Driver
+The clang executable is actually a small driver which controls the overall
+execution of other tools such as the compiler, assembler and linker.
+Typically you do not need to interact with the driver, but you
+transparently use it to run the other tools.
+.TP
+.B Preprocessing
+This stage handles tokenization of the input source file, macro expansion,
+#include expansion and handling of other preprocessor directives.  The
+output of this stage is typically called a ".i" (for C), ".ii" (for C++),
+".mi" (for Objective\-C), or ".mii" (for Objective\-C++) file.
+.TP
+.B Parsing and Semantic Analysis
+This stage parses the input file, translating preprocessor tokens into a
+parse tree.  Once in the form of a parse tree, it applies semantic
+analysis to compute types for expressions as well and determine whether
+the code is well formed. This stage is responsible for generating most of
+the compiler warnings as well as parse errors. The output of this stage is
+an "Abstract Syntax Tree" (AST).
+.TP
+.B Code Generation and Optimization
+This stage translates an AST into low\-level intermediate code (known as
+"LLVM IR") and ultimately to machine code.  This phase is responsible for
+optimizing the generated code and handling target\-specific code generation.
+The output of this stage is typically called a ".s" file or "assembly" file.
+.sp
+Clang also supports the use of an integrated assembler, in which the code
+generator produces object files directly. This avoids the overhead of
+generating the ".s" file and of calling the target assembler.
+.TP
+.B Assembler
+This stage runs the target assembler to translate the output of the
+compiler into a target object file. The output of this stage is typically
+called a ".o" file or "object" file.
+.TP
+.B Linker
+This stage runs the target linker to merge multiple object files into an
+executable or dynamic library. The output of this stage is typically called
+an "a.out", ".dylib" or ".so" file.
+.UNINDENT
+.sp
+\fBClang Static Analyzer\fP
+.sp
+The Clang Static Analyzer is a tool that scans source code to try to find bugs
+through code analysis.  This tool uses many parts of Clang and is built into
+the same driver.  Please see <\fI\%http://clang\-analyzer.llvm.org\fP> for more details
+on how to use the static analyzer.
+.SH OPTIONS
+.SS Stage Selection Options
+.INDENT 0.0
+.TP
+.B \-E
+Run the preprocessor stage.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-fsyntax\-only
+Run the preprocessor, parser and type checking stages.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-S
+Run the previous stages as well as LLVM generation and optimization stages
+and target\-specific code generation, producing an assembly file.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-c
+Run all of the above, plus the assembler, generating a target ".o" object file.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B no stage selection option
+If no stage selection option is specified, all stages above are run, and the
+linker is run to combine the results into an executable or shared library.
+.UNINDENT
+.SS Language Selection and Mode Options
+.INDENT 0.0
+.TP
+.B \-x <language>
+Treat subsequent input files as having type language.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-std=<language>
+Specify the language standard to compile for.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-stdlib=<library>
+Specify the C++ standard library to use; supported options are libstdc++ and
+libc++.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-ansi
+Same as \-std=c89.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-ObjC, \-ObjC++
+Treat source input files as Objective\-C and Object\-C++ inputs respectively.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-trigraphs
+Enable trigraphs.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-ffreestanding
+Indicate that the file should be compiled for a freestanding, not a hosted,
+environment.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-fno\-builtin
+Disable special handling and optimizations of builtin functions like
+\fBstrlen()\fP and \fBmalloc()\fP\&.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-fmath\-errno
+Indicate that math functions should be treated as updating \fBerrno\fP\&.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-fpascal\-strings
+Enable support for Pascal\-style strings with "\epfoo".
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-fms\-extensions
+Enable support for Microsoft extensions.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-fmsc\-version=
+Set _MSC_VER. Defaults to 1300 on Windows. Not set otherwise.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-fborland\-extensions
+Enable support for Borland extensions.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-fwritable\-strings
+Make all string literals default to writable.  This disables uniquing of
+strings and other optimizations.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-flax\-vector\-conversions
+Allow loose type checking rules for implicit vector conversions.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-fblocks
+Enable the "Blocks" language feature.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-fobjc\-gc\-only
+Indicate that Objective\-C code should be compiled in GC\-only mode, which only
+works when Objective\-C Garbage Collection is enabled.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-fobjc\-gc
+Indicate that Objective\-C code should be compiled in hybrid\-GC mode, which
+works with both GC and non\-GC mode.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-fobjc\-abi\-version=version
+Select the Objective\-C ABI version to use. Available versions are 1 (legacy
+"fragile" ABI), 2 (non\-fragile ABI 1), and 3 (non\-fragile ABI 2).
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-fobjc\-nonfragile\-abi\-version=<version>
+Select the Objective\-C non\-fragile ABI version to use by default. This will
+only be used as the Objective\-C ABI when the non\-fragile ABI is enabled
+(either via \fI\%\-fobjc\-nonfragile\-abi\fP, or because it is the platform
+default).
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-fobjc\-nonfragile\-abi
+Enable use of the Objective\-C non\-fragile ABI. On platforms for which this is
+the default ABI, it can be disabled with \fB\-fno\-objc\-nonfragile\-abi\fP\&.
+.UNINDENT
+.SS Target Selection Options
+.sp
+Clang fully supports cross compilation as an inherent part of its design.
+Depending on how your version of Clang is configured, it may have support for a
+number of cross compilers, or may only support a native target.
+.INDENT 0.0
+.TP
+.B \-arch <architecture>
+Specify the architecture to build for.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-mmacosx\-version\-min=<version>
+When building for Mac OS X, specify the minimum version supported by your
+application.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-miphoneos\-version\-min
+When building for iPhone OS, specify the minimum version supported by your
+application.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-march=<cpu>
+Specify that Clang should generate code for a specific processor family
+member and later.  For example, if you specify \-march=i486, the compiler is
+allowed to generate instructions that are valid on i486 and later processors,
+but which may not exist on earlier ones.
+.UNINDENT
+.SS Code Generation Options
+.INDENT 0.0
+.TP
+.B \-O0, \-O1, \-O2, \-O3, \-Ofast, \-Os, \-Oz, \-O, \-O4
+Specify which optimization level to use:
+.INDENT 7.0
+.INDENT 3.5
+\fI\%\-O0\fP Means "no optimization": this level compiles the fastest and
+generates the most debuggable code.
+.sp
+\fI\%\-O1\fP Somewhere between \fI\%\-O0\fP and \fI\%\-O2\fP\&.
+.sp
+\fI\%\-O2\fP Moderate level of optimization which enables most
+optimizations.
+.sp
+\fI\%\-O3\fP Like \fI\%\-O2\fP, except that it enables optimizations that
+take longer to perform or that may generate larger code (in an attempt to
+make the program run faster).
+.sp
+\fI\%\-Ofast\fP Enables all the optimizations from \fI\%\-O3\fP along
+with other aggressive optimizations that may violate strict compliance with
+language standards.
+.sp
+\fI\%\-Os\fP Like \fI\%\-O2\fP with extra optimizations to reduce code
+size.
+.sp
+\fI\%\-Oz\fP Like \fI\%\-Os\fP (and thus \fI\%\-O2\fP), but reduces code
+size further.
+.sp
+\fI\%\-O\fP Equivalent to \fI\%\-O2\fP\&.
+.sp
+\fI\%\-O4\fP and higher
+.INDENT 0.0
+.INDENT 3.5
+Currently equivalent to \fI\%\-O3\fP
+.UNINDENT
+.UNINDENT
+.UNINDENT
+.UNINDENT
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-g
+Generate debug information.  Note that Clang debug information works best at \-O0.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-gmodules
+Generate debug information that contains external references to
+types defined in clang modules or precompiled headers instead of
+emitting redundant debug type information into every object file.
+This option implies \fB\-fmodule\-format=obj\fP\&.
+.sp
+This option should not be used when building static libraries for
+distribution to other machines because the debug info will contain
+references to the module cache on the machine the object files in
+the library were built on.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-fstandalone\-debug \-fno\-standalone\-debug
+Clang supports a number of optimizations to reduce the size of debug
+information in the binary. They work based on the assumption that the
+debug type information can be spread out over multiple compilation units.
+For instance, Clang will not emit type definitions for types that are not
+needed by a module and could be replaced with a forward declaration.
+Further, Clang will only emit type info for a dynamic C++ class in the
+module that contains the vtable for the class.
+.sp
+The \fB\-fstandalone\-debug\fP option turns off these optimizations.
+This is useful when working with 3rd\-party libraries that don\(aqt come with
+debug information.  This is the default on Darwin.  Note that Clang will
+never emit type information for types that are not referenced at all by the
+program.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-fexceptions
+Enable generation of unwind information. This allows exceptions to be thrown
+through Clang compiled stack frames.  This is on by default in x86\-64.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-ftrapv
+Generate code to catch integer overflow errors.  Signed integer overflow is
+undefined in C. With this flag, extra code is generated to detect this and
+abort when it happens.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-fvisibility
+This flag sets the default visibility level.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-fcommon
+This flag specifies that variables without initializers get common linkage.
+It can be disabled with \fB\-fno\-common\fP\&.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-ftls\-model=<model>
+Set the default thread\-local storage (TLS) model to use for thread\-local
+variables. Valid values are: "global\-dynamic", "local\-dynamic",
+"initial\-exec" and "local\-exec". The default is "global\-dynamic". The default
+model can be overridden with the tls_model attribute. The compiler will try
+to choose a more efficient model if possible.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-flto, \-emit\-llvm
+Generate output files in LLVM formats, suitable for link time optimization.
+When used with \fI\%\-S\fP this generates LLVM intermediate language
+assembly files, otherwise this generates LLVM bitcode format object files
+(which may be passed to the linker depending on the stage selection options).
+.UNINDENT
+.SS Driver Options
+.INDENT 0.0
+.TP
+.B \-###
+Print (but do not run) the commands to run for this compilation.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-help
+Display available options.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-Qunused\-arguments
+Do not emit any warnings for unused driver arguments.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-Wa,<args>
+Pass the comma separated arguments in args to the assembler.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-Wl,<args>
+Pass the comma separated arguments in args to the linker.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-Wp,<args>
+Pass the comma separated arguments in args to the preprocessor.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-Xanalyzer <arg>
+Pass arg to the static analyzer.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-Xassembler <arg>
+Pass arg to the assembler.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-Xlinker <arg>
+Pass arg to the linker.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-Xpreprocessor <arg>
+Pass arg to the preprocessor.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-o <file>
+Write output to file.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-print\-file\-name=<file>
+Print the full library path of file.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-print\-libgcc\-file\-name
+Print the library path for "libgcc.a".
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-print\-prog\-name=<name>
+Print the full program path of name.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-print\-search\-dirs
+Print the paths used for finding libraries and programs.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-save\-temps
+Save intermediate compilation results.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-integrated\-as, \-no\-integrated\-as
+Used to enable and disable, respectively, the use of the integrated
+assembler. Whether the integrated assembler is on by default is target
+dependent.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-time
+Time individual commands.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-ftime\-report
+Print timing summary of each stage of compilation.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-v
+Show commands to run and use verbose output.
+.UNINDENT
+.SS Diagnostics Options
+.INDENT 0.0
+.TP
+.B \-fshow\-column, \-fshow\-source\-location, \-fcaret\-diagnostics, \-fdiagnostics\-fixit\-info, \-fdiagnostics\-parseable\-fixits, \-fdiagnostics\-print\-source\-range\-info, \-fprint\-source\-range\-info, \-fdiagnostics\-show\-option, \-fmessage\-length
+These options control how Clang prints out information about diagnostics
+(errors and warnings). Please see the Clang User\(aqs Manual for more information.
+.UNINDENT
+.SS Preprocessor Options
+.INDENT 0.0
+.TP
+.B \-D<macroname>=<value>
+Adds an implicit #define into the predefines buffer which is read before the
+source file is preprocessed.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-U<macroname>
+Adds an implicit #undef into the predefines buffer which is read before the
+source file is preprocessed.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-include <filename>
+Adds an implicit #include into the predefines buffer which is read before the
+source file is preprocessed.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-I<directory>
+Add the specified directory to the search path for include files.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-F<directory>
+Add the specified directory to the search path for framework include files.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-nostdinc
+Do not search the standard system directories or compiler builtin directories
+for include files.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-nostdlibinc
+Do not search the standard system directories for include files, but do
+search compiler builtin include directories.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-nobuiltininc
+Do not search clang\(aqs builtin directory for include files.
+.UNINDENT
+.SH ENVIRONMENT
+.INDENT 0.0
+.TP
+.B TMPDIR, TEMP, TMP
+These environment variables are checked, in order, for the location to write
+temporary files used during the compilation process.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B CPATH
+If this environment variable is present, it is treated as a delimited list of
+paths to be added to the default system include path list. The delimiter is
+the platform dependent delimiter, as used in the PATH environment variable.
+.sp
+Empty components in the environment variable are ignored.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B C_INCLUDE_PATH, OBJC_INCLUDE_PATH, CPLUS_INCLUDE_PATH, OBJCPLUS_INCLUDE_PATH
+These environment variables specify additional paths, as for \fI\%CPATH\fP, which are
+only used when processing the appropriate language.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B MACOSX_DEPLOYMENT_TARGET
+If \fI\%\-mmacosx\-version\-min\fP is unspecified, the default deployment
+target is read from this environment variable. This option only affects
+Darwin targets.
+.UNINDENT
+.SH BUGS
+.sp
+To report bugs, please visit <\fI\%http://llvm.org/bugs/\fP>.  Most bug reports should
+include preprocessed source files (use the \fI\%\-E\fP option) and the full
+output of the compiler, along with information to reproduce.
+.SH SEE ALSO
+.sp
+\fBas(1)\fP, \fBld(1)\fP
+.SH AUTHOR
+Maintained by the Clang / LLVM Team (<http://clang.llvm.org>)
+.SH COPYRIGHT
+2007-2016, The Clang Team
+.\" Generated by docutils manpage writer.
+.

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/components/llvm/Solaris/man1/lit.1	Thu Jul 28 16:25:34 2016 -0700
@@ -0,0 +1,471 @@
+.\" Man page generated from reStructuredText.
+.
+.TH "LIT" "1" "2016-07-10" "3.8" "LLVM"
+.SH NAME
+lit \- LLVM Integrated Tester
+.
+.nr rst2man-indent-level 0
+.
+.de1 rstReportMargin
+\\$1 \\n[an-margin]
+level \\n[rst2man-indent-level]
+level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
+-
+\\n[rst2man-indent0]
+\\n[rst2man-indent1]
+\\n[rst2man-indent2]
+..
+.de1 INDENT
+.\" .rstReportMargin pre:
+. RS \\$1
+. nr rst2man-indent\\n[rst2man-indent-level] \\n[an-margin]
+. nr rst2man-indent-level +1
+.\" .rstReportMargin post:
+..
+.de UNINDENT
+. RE
+.\" indent \\n[an-margin]
+.\" old: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.nr rst2man-indent-level -1
+.\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.in \\n[rst2man-indent\\n[rst2man-indent-level]]u
+..
+.SH SYNOPSIS
+.sp
+\fBlit\fP [\fIoptions\fP] [\fItests\fP]
+.SH DESCRIPTION
+.sp
+\fBlit\fP is a portable tool for executing LLVM and Clang style test
+suites, summarizing their results, and providing indication of failures.
+\fBlit\fP is designed to be a lightweight testing tool with as simple a
+user interface as possible.
+.sp
+\fBlit\fP should be run with one or more \fItests\fP to run specified on the
+command line.  Tests can be either individual test files or directories to
+search for tests (see \fI\%TEST DISCOVERY\fP).
+.sp
+Each specified test will be executed (potentially in parallel) and once all
+tests have been run \fBlit\fP will print summary information on the number
+of tests which passed or failed (see \fI\%TEST STATUS RESULTS\fP).  The
+\fBlit\fP program will execute with a non\-zero exit code if any tests
+fail.
+.sp
+By default \fBlit\fP will use a succinct progress display and will only
+print summary information for test failures.  See \fI\%OUTPUT OPTIONS\fP for
+options controlling the \fBlit\fP progress display and output.
+.sp
+\fBlit\fP also includes a number of options for controlling how tests are
+executed (specific features may depend on the particular test format).  See
+\fI\%EXECUTION OPTIONS\fP for more information.
+.sp
+Finally, \fBlit\fP also supports additional options for only running a
+subset of the options specified on the command line, see
+\fI\%SELECTION OPTIONS\fP for more information.
+.sp
+Users interested in the \fBlit\fP architecture or designing a
+\fBlit\fP testing implementation should see \fI\%LIT INFRASTRUCTURE\fP\&.
+.SH GENERAL OPTIONS
+.INDENT 0.0
+.TP
+.B \-h, \-\-help
+Show the \fBlit\fP help message.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-j N, \-\-threads=N
+Run \fBN\fP tests in parallel.  By default, this is automatically chosen to
+match the number of detected available CPUs.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-config\-prefix=NAME
+Search for \fB\fINAME\fP\fP\fB\&.cfg\fP and \fB\fINAME\fP\fP\fB\&.site.cfg\fP when searching for
+test suites, instead of \fBlit.cfg\fP and \fBlit.site.cfg\fP\&.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-D NAME, \-D NAME=VALUE, \-\-param NAME, \-\-param NAME=VALUE
+Add a user defined parameter \fBNAME\fP with the given \fBVALUE\fP (or the empty
+string if not given).  The meaning and use of these parameters is test suite
+dependent.
+.UNINDENT
+.SH OUTPUT OPTIONS
+.INDENT 0.0
+.TP
+.B \-q, \-\-quiet
+Suppress any output except for test failures.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-s, \-\-succinct
+Show less output, for example don\(aqt show information on tests that pass.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-v, \-\-verbose
+Show more information on test failures, for example the entire test output
+instead of just the test result.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-a, \-\-show\-all
+Show more information about all tests, for example the entire test
+commandline and output.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-no\-progress\-bar
+Do not use curses based progress bar.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-show\-unsupported
+Show the names of unsupported tests.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-show\-xfail
+Show the names of tests that were expected to fail.
+.UNINDENT
+.SH EXECUTION OPTIONS
+.INDENT 0.0
+.TP
+.B \-\-path=PATH
+Specify an additional \fBPATH\fP to use when searching for executables in tests.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-vg
+Run individual tests under valgrind (using the memcheck tool).  The
+\fB\-\-error\-exitcode\fP argument for valgrind is used so that valgrind failures
+will cause the program to exit with a non\-zero status.
+.sp
+When this option is enabled, \fBlit\fP will also automatically provide a
+"\fBvalgrind\fP" feature that can be used to conditionally disable (or expect
+failure in) certain tests.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-vg\-arg=ARG
+When \fI\%\-\-vg\fP is used, specify an additional argument to pass to
+\fBvalgrind\fP itself.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-vg\-leak
+When \fI\%\-\-vg\fP is used, enable memory leak checks.  When this option is
+enabled, \fBlit\fP will also automatically provide a "\fBvg_leak\fP"
+feature that can be used to conditionally disable (or expect failure in)
+certain tests.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-time\-tests
+Track the wall time individual tests take to execute and includes the results
+in the summary output.  This is useful for determining which tests in a test
+suite take the most time to execute.  Note that this option is most useful
+with \fB\-j 1\fP\&.
+.UNINDENT
+.SH SELECTION OPTIONS
+.INDENT 0.0
+.TP
+.B \-\-max\-tests=N
+Run at most \fBN\fP tests and then terminate.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-max\-time=N
+Spend at most \fBN\fP seconds (approximately) running tests and then terminate.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-shuffle
+Run the tests in a random order.
+.UNINDENT
+.SH ADDITIONAL OPTIONS
+.INDENT 0.0
+.TP
+.B \-\-debug
+Run \fBlit\fP in debug mode, for debugging configuration issues and
+\fBlit\fP itself.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-show\-suites
+List the discovered test suites and exit.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-show\-tests
+List all of the discovered tests and exit.
+.UNINDENT
+.SH EXIT STATUS
+.sp
+\fBlit\fP will exit with an exit code of 1 if there are any FAIL or XPASS
+results.  Otherwise, it will exit with the status 0.  Other exit codes are used
+for non\-test related failures (for example a user error or an internal program
+error).
+.SH TEST DISCOVERY
+.sp
+The inputs passed to \fBlit\fP can be either individual tests, or entire
+directories or hierarchies of tests to run.  When \fBlit\fP starts up, the
+first thing it does is convert the inputs into a complete list of tests to run
+as part of \fItest discovery\fP\&.
+.sp
+In the \fBlit\fP model, every test must exist inside some \fItest suite\fP\&.
+\fBlit\fP resolves the inputs specified on the command line to test suites
+by searching upwards from the input path until it finds a \fBlit.cfg\fP or
+\fBlit.site.cfg\fP file.  These files serve as both a marker of test suites
+and as configuration files which \fBlit\fP loads in order to understand
+how to find and run the tests inside the test suite.
+.sp
+Once \fBlit\fP has mapped the inputs into test suites it traverses the
+list of inputs adding tests for individual files and recursively searching for
+tests in directories.
+.sp
+This behavior makes it easy to specify a subset of tests to run, while still
+allowing the test suite configuration to control exactly how tests are
+interpreted.  In addition, \fBlit\fP always identifies tests by the test
+suite they are in, and their relative path inside the test suite.  For
+appropriately configured projects, this allows \fBlit\fP to provide
+convenient and flexible support for out\-of\-tree builds.
+.SH TEST STATUS RESULTS
+.sp
+Each test ultimately produces one of the following six results:
+.sp
+\fBPASS\fP
+.INDENT 0.0
+.INDENT 3.5
+The test succeeded.
+.UNINDENT
+.UNINDENT
+.sp
+\fBXFAIL\fP
+.INDENT 0.0
+.INDENT 3.5
+The test failed, but that is expected.  This is used for test formats which allow
+specifying that a test does not currently work, but wish to leave it in the test
+suite.
+.UNINDENT
+.UNINDENT
+.sp
+\fBXPASS\fP
+.INDENT 0.0
+.INDENT 3.5
+The test succeeded, but it was expected to fail.  This is used for tests which
+were specified as expected to fail, but are now succeeding (generally because
+the feature they test was broken and has been fixed).
+.UNINDENT
+.UNINDENT
+.sp
+\fBFAIL\fP
+.INDENT 0.0
+.INDENT 3.5
+The test failed.
+.UNINDENT
+.UNINDENT
+.sp
+\fBUNRESOLVED\fP
+.INDENT 0.0
+.INDENT 3.5
+The test result could not be determined.  For example, this occurs when the test
+could not be run, the test itself is invalid, or the test was interrupted.
+.UNINDENT
+.UNINDENT
+.sp
+\fBUNSUPPORTED\fP
+.INDENT 0.0
+.INDENT 3.5
+The test is not supported in this environment.  This is used by test formats
+which can report unsupported tests.
+.UNINDENT
+.UNINDENT
+.sp
+Depending on the test format tests may produce additional information about
+their status (generally only for failures).  See the \fI\%OUTPUT OPTIONS\fP
+section for more information.
+.SH LIT INFRASTRUCTURE
+.sp
+This section describes the \fBlit\fP testing architecture for users interested in
+creating a new \fBlit\fP testing implementation, or extending an existing one.
+.sp
+\fBlit\fP proper is primarily an infrastructure for discovering and running
+arbitrary tests, and to expose a single convenient interface to these
+tests. \fBlit\fP itself doesn\(aqt know how to run tests, rather this logic is
+defined by \fItest suites\fP\&.
+.SS TEST SUITES
+.sp
+As described in \fI\%TEST DISCOVERY\fP, tests are always located inside a \fItest
+suite\fP\&.  Test suites serve to define the format of the tests they contain, the
+logic for finding those tests, and any additional information to run the tests.
+.sp
+\fBlit\fP identifies test suites as directories containing \fBlit.cfg\fP or
+\fBlit.site.cfg\fP files (see also \fI\%\-\-config\-prefix\fP).  Test suites are
+initially discovered by recursively searching up the directory hierarchy for
+all the input files passed on the command line.  You can use
+\fI\%\-\-show\-suites\fP to display the discovered test suites at startup.
+.sp
+Once a test suite is discovered, its config file is loaded.  Config files
+themselves are Python modules which will be executed.  When the config file is
+executed, two important global variables are predefined:
+.sp
+\fBlit_config\fP
+.INDENT 0.0
+.INDENT 3.5
+The global \fBlit\fP configuration object (a \fILitConfig\fP instance), which defines
+the builtin test formats, global configuration parameters, and other helper
+routines for implementing test configurations.
+.UNINDENT
+.UNINDENT
+.sp
+\fBconfig\fP
+.INDENT 0.0
+.INDENT 3.5
+This is the config object (a \fITestingConfig\fP instance) for the test suite,
+which the config file is expected to populate.  The following variables are also
+available on the \fIconfig\fP object, some of which must be set by the config and
+others are optional or predefined:
+.sp
+\fBname\fP \fI[required]\fP The name of the test suite, for use in reports and
+diagnostics.
+.sp
+\fBtest_format\fP \fI[required]\fP The test format object which will be used to
+discover and run tests in the test suite.  Generally this will be a builtin test
+format available from the \fIlit.formats\fP module.
+.sp
+\fBtest_source_root\fP The filesystem path to the test suite root.  For out\-of\-dir
+builds this is the directory that will be scanned for tests.
+.sp
+\fBtest_exec_root\fP For out\-of\-dir builds, the path to the test suite root inside
+the object directory.  This is where tests will be run and temporary output files
+placed.
+.sp
+\fBenvironment\fP A dictionary representing the environment to use when executing
+tests in the suite.
+.sp
+\fBsuffixes\fP For \fBlit\fP test formats which scan directories for tests, this
+variable is a list of suffixes to identify test files.  Used by: \fIShTest\fP\&.
+.sp
+\fBsubstitutions\fP For \fBlit\fP test formats which substitute variables into a test
+script, the list of substitutions to perform.  Used by: \fIShTest\fP\&.
+.sp
+\fBunsupported\fP Mark an unsupported directory, all tests within it will be
+reported as unsupported.  Used by: \fIShTest\fP\&.
+.sp
+\fBparent\fP The parent configuration, this is the config object for the directory
+containing the test suite, or None.
+.sp
+\fBroot\fP The root configuration.  This is the top\-most \fBlit\fP configuration in
+the project.
+.sp
+\fBpipefail\fP Normally a test using a shell pipe fails if any of the commands
+on the pipe fail. If this is not desired, setting this variable to false
+makes the test fail only if the last command in the pipe fails.
+.UNINDENT
+.UNINDENT
+.SS TEST DISCOVERY
+.sp
+Once test suites are located, \fBlit\fP recursively traverses the source
+directory (following \fItest_source_root\fP) looking for tests.  When \fBlit\fP
+enters a sub\-directory, it first checks to see if a nested test suite is
+defined in that directory.  If so, it loads that test suite recursively,
+otherwise it instantiates a local test config for the directory (see
+\fI\%LOCAL CONFIGURATION FILES\fP).
+.sp
+Tests are identified by the test suite they are contained within, and the
+relative path inside that suite.  Note that the relative path may not refer to
+an actual file on disk; some test formats (such as \fIGoogleTest\fP) define
+"virtual tests" which have a path that contains both the path to the actual
+test file and a subpath to identify the virtual test.
+.SS LOCAL CONFIGURATION FILES
+.sp
+When \fBlit\fP loads a subdirectory in a test suite, it instantiates a
+local test configuration by cloning the configuration for the parent directory
+\-\-\- the root of this configuration chain will always be a test suite.  Once the
+test configuration is cloned \fBlit\fP checks for a \fIlit.local.cfg\fP file
+in the subdirectory.  If present, this file will be loaded and can be used to
+specialize the configuration for each individual directory.  This facility can
+be used to define subdirectories of optional tests, or to change other
+configuration parameters \-\-\- for example, to change the test format, or the
+suffixes which identify test files.
+.SS TEST RUN OUTPUT FORMAT
+.sp
+The \fBlit\fP output for a test run conforms to the following schema, in
+both short and verbose modes (although in short mode no PASS lines will be
+shown).  This schema has been chosen to be relatively easy to reliably parse by
+a machine (for example in buildbot log scraping), and for other tools to
+generate.
+.sp
+Each test result is expected to appear on a line that matches:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+<result code>: <test name> (<progress info>)
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+where \fB<result\-code>\fP is a standard test result such as PASS, FAIL, XFAIL,
+XPASS, UNRESOLVED, or UNSUPPORTED.  The performance result codes of IMPROVED and
+REGRESSED are also allowed.
+.sp
+The \fB<test name>\fP field can consist of an arbitrary string containing no
+newline.
+.sp
+The \fB<progress info>\fP field can be used to report progress information such
+as (1/300) or can be empty, but even when empty the parentheses are required.
+.sp
+Each test result may include additional (multiline) log information in the
+following format:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+<log delineator> TEST \(aq(<test name>)\(aq <trailing delineator>
+\&... log message ...
+<log delineator>
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.sp
+where \fB<test name>\fP should be the name of a preceding reported test, \fB<log
+delineator>\fP is a string of "*" characters \fIat least\fP four characters long
+(the recommended length is 20), and \fB<trailing delineator>\fP is an arbitrary
+(unparsed) string.
+.sp
+The following is an example of a test run output which consists of four tests A,
+B, C, and D, and a log message for the failing test C:
+.INDENT 0.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+PASS: A (1 of 4)
+PASS: B (2 of 4)
+FAIL: C (3 of 4)
+******************** TEST \(aqC\(aq FAILED ********************
+Test \(aqC\(aq failed as a result of exit code 1.
+********************
+PASS: D (4 of 4)
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.SS LIT EXAMPLE TESTS
+.sp
+The \fBlit\fP distribution contains several example implementations of
+test suites in the \fIExampleTests\fP directory.
+.SH SEE ALSO
+.sp
+valgrind(1)
+.SH AUTHOR
+Maintained by The LLVM Team (http://llvm.org/).
+.SH COPYRIGHT
+2003-2016, LLVM Project
+.\" Generated by docutils manpage writer.
+.

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/components/llvm/Solaris/man1/llc.1	Thu Jul 28 16:25:34 2016 -0700
@@ -0,0 +1,264 @@
+.\" Man page generated from reStructuredText.
+.
+.TH "LLC" "1" "2016-07-10" "3.8" "LLVM"
+.SH NAME
+llc \- LLVM static compiler
+.
+.nr rst2man-indent-level 0
+.
+.de1 rstReportMargin
+\\$1 \\n[an-margin]
+level \\n[rst2man-indent-level]
+level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
+-
+\\n[rst2man-indent0]
+\\n[rst2man-indent1]
+\\n[rst2man-indent2]
+..
+.de1 INDENT
+.\" .rstReportMargin pre:
+. RS \\$1
+. nr rst2man-indent\\n[rst2man-indent-level] \\n[an-margin]
+. nr rst2man-indent-level +1
+.\" .rstReportMargin post:
+..
+.de UNINDENT
+. RE
+.\" indent \\n[an-margin]
+.\" old: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.nr rst2man-indent-level -1
+.\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.in \\n[rst2man-indent\\n[rst2man-indent-level]]u
+..
+.SH SYNOPSIS
+.sp
+\fBllc\fP [\fIoptions\fP] [\fIfilename\fP]
+.SH DESCRIPTION
+.sp
+The \fBllc\fP command compiles LLVM source inputs into assembly language
+for a specified architecture.  The assembly language output can then be passed
+through a native assembler and linker to generate a native executable.
+.sp
+The choice of architecture for the output assembly code is automatically
+determined from the input file, unless the \fB\-march\fP option is used to
+override the default.
+.SH OPTIONS
+.sp
+If \fBfilename\fP is "\fB\-\fP" or omitted, \fBllc\fP reads from standard input.
+Otherwise, it will from \fBfilename\fP\&.  Inputs can be in either the LLVM assembly
+language format (\fB\&.ll\fP) or the LLVM bitcode format (\fB\&.bc\fP).
+.sp
+If the \fB\-o\fP option is omitted, then \fBllc\fP will send its output
+to standard output if the input is from standard input.  If the \fB\-o\fP
+option specifies "\fB\-\fP", then the output will also be sent to standard output.
+.sp
+If no \fB\-o\fP option is specified and an input file other than "\fB\-\fP" is
+specified, then \fBllc\fP creates the output filename by taking the input
+filename, removing any existing \fB\&.bc\fP extension, and adding a \fB\&.s\fP suffix.
+.sp
+Other \fBllc\fP options are described below.
+.SS End\-user Options
+.INDENT 0.0
+.TP
+.B \-help
+Print a summary of command line options.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-O=uint
+Generate code at different optimization levels.  These correspond to the
+\fB\-O0\fP, \fB\-O1\fP, \fB\-O2\fP, and \fB\-O3\fP optimization levels used by
+\fBclang\fP\&.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-mtriple=<target triple>
+Override the target triple specified in the input file with the specified
+string.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-march=<arch>
+Specify the architecture for which to generate assembly, overriding the target
+encoded in the input file.  See the output of \fBllc \-help\fP for a list of
+valid architectures.  By default this is inferred from the target triple or
+autodetected to the current architecture.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-mcpu=<cpuname>
+Specify a specific chip in the current architecture to generate code for.
+By default this is inferred from the target triple and autodetected to
+the current architecture.  For a list of available CPUs, use:
+.INDENT 7.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+llvm\-as < /dev/null | llc \-march=xyz \-mcpu=help
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-filetype=<output file type>
+Specify what kind of output \fBllc\fP should generated.  Options are: \fBasm\fP
+for textual assembly ( \fB\(aq.s\(aq\fP), \fBobj\fP for native object files (\fB\(aq.o\(aq\fP)
+and \fBnull\fP for not emitting anything (for performance testing).
+.sp
+Note that not all targets support all options.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-mattr=a1,+a2,\-a3,...
+Override or control specific attributes of the target, such as whether SIMD
+operations are enabled or not.  The default set of attributes is set by the
+current CPU.  For a list of available attributes, use:
+.INDENT 7.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+llvm\-as < /dev/null | llc \-march=xyz \-mattr=help
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-disable\-fp\-elim
+Disable frame pointer elimination optimization.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-disable\-excess\-fp\-precision
+Disable optimizations that may produce excess precision for floating point.
+Note that this option can dramatically slow down code on some systems
+(e.g. X86).
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-enable\-no\-infs\-fp\-math
+Enable optimizations that assume no Inf values.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-enable\-no\-nans\-fp\-math
+Enable optimizations that assume no NAN values.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-enable\-unsafe\-fp\-math
+Enable optimizations that make unsafe assumptions about IEEE math (e.g. that
+addition is associative) or may not work for all input ranges.  These
+optimizations allow the code generator to make use of some instructions which
+would otherwise not be usable (such as \fBfsin\fP on X86).
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-stats
+Print statistics recorded by code\-generation passes.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-time\-passes
+Record the amount of time needed for each pass and print a report to standard
+error.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-load=<dso_path>
+Dynamically load \fBdso_path\fP (a path to a dynamically shared object) that
+implements an LLVM target.  This will permit the target name to be used with
+the \fB\-march\fP option so that code can be generated for that target.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-meabi=[default|gnu|4|5]
+Specify which EABI version should conform to.  Valid EABI versions are \fIgnu\fP,
+\fI4\fP and \fI5\fP\&.  Default value (\fIdefault\fP) depends on the triple.
+.UNINDENT
+.SS Tuning/Configuration Options
+.INDENT 0.0
+.TP
+.B \-\-print\-machineinstrs
+Print generated machine code between compilation phases (useful for debugging).
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-regalloc=<allocator>
+Specify the register allocator to use.
+Valid register allocators are:
+.sp
+\fIbasic\fP
+.INDENT 7.0
+.INDENT 3.5
+Basic register allocator.
+.UNINDENT
+.UNINDENT
+.sp
+\fIfast\fP
+.INDENT 7.0
+.INDENT 3.5
+Fast register allocator. It is the default for unoptimized code.
+.UNINDENT
+.UNINDENT
+.sp
+\fIgreedy\fP
+.INDENT 7.0
+.INDENT 3.5
+Greedy register allocator. It is the default for optimized code.
+.UNINDENT
+.UNINDENT
+.sp
+\fIpbqp\fP
+.INDENT 7.0
+.INDENT 3.5
+Register allocator based on \(aqPartitioned Boolean Quadratic Programming\(aq.
+.UNINDENT
+.UNINDENT
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-\-spiller=<spiller>
+Specify the spiller to use for register allocators that support it.  Currently
+this option is used only by the linear scan register allocator.  The default
+\fBspiller\fP is \fIlocal\fP\&.  Valid spillers are:
+.sp
+\fIsimple\fP
+.INDENT 7.0
+.INDENT 3.5
+Simple spiller
+.UNINDENT
+.UNINDENT
+.sp
+\fIlocal\fP
+.INDENT 7.0
+.INDENT 3.5
+Local spiller
+.UNINDENT
+.UNINDENT
+.UNINDENT
+.SS Intel IA\-32\-specific Options
+.INDENT 0.0
+.TP
+.B \-\-x86\-asm\-syntax=[att|intel]
+Specify whether to emit assembly code in AT&T syntax (the default) or Intel
+syntax.
+.UNINDENT
+.SH EXIT STATUS
+.sp
+If \fBllc\fP succeeds, it will exit with 0.  Otherwise, if an error
+occurs, it will exit with a non\-zero value.
+.SH SEE ALSO
+.sp
+lli
+.SH AUTHOR
+Maintained by The LLVM Team (http://llvm.org/).
+.SH COPYRIGHT
+2003-2016, LLVM Project
+.\" Generated by docutils manpage writer.
+.

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/components/llvm/Solaris/man1/lli.1	Thu Jul 28 16:25:34 2016 -0700
@@ -0,0 +1,297 @@
+.\" Man page generated from reStructuredText.
+.
+.TH "LLI" "1" "2016-07-10" "3.8" "LLVM"
+.SH NAME
+lli \- directly execute programs from LLVM bitcode
+.
+.nr rst2man-indent-level 0
+.
+.de1 rstReportMargin
+\\$1 \\n[an-margin]
+level \\n[rst2man-indent-level]
+level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
+-
+\\n[rst2man-indent0]
+\\n[rst2man-indent1]
+\\n[rst2man-indent2]
+..
+.de1 INDENT
+.\" .rstReportMargin pre:
+. RS \\$1
+. nr rst2man-indent\\n[rst2man-indent-level] \\n[an-margin]
+. nr rst2man-indent-level +1
+.\" .rstReportMargin post:
+..
+.de UNINDENT
+. RE
+.\" indent \\n[an-margin]
+.\" old: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.nr rst2man-indent-level -1
+.\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.in \\n[rst2man-indent\\n[rst2man-indent-level]]u
+..
+.SH SYNOPSIS
+.sp
+\fBlli\fP [\fIoptions\fP] [\fIfilename\fP] [\fIprogram args\fP]
+.SH DESCRIPTION
+.sp
+\fBlli\fP directly executes programs in LLVM bitcode format.  It takes a program
+in LLVM bitcode format and executes it using a just\-in\-time compiler or an
+interpreter.
+.sp
+\fBlli\fP is \fInot\fP an emulator. It will not execute IR of different architectures
+and it can only interpret (or JIT\-compile) for the host architecture.
+.sp
+The JIT compiler takes the same arguments as other tools, like \fBllc\fP,
+but they don\(aqt necessarily work for the interpreter.
+.sp
+If \fIfilename\fP is not specified, then \fBlli\fP reads the LLVM bitcode for the
+program from standard input.
+.sp
+The optional \fIargs\fP specified on the command line are passed to the program as
+arguments.
+.SH GENERAL OPTIONS
+.INDENT 0.0
+.TP
+.B \-fake\-argv0=executable
+Override the \fBargv[0]\fP value passed into the executing program.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-force\-interpreter={false,true}
+If set to true, use the interpreter even if a just\-in\-time compiler is available
+for this architecture. Defaults to false.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-help
+Print a summary of command line options.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-load=pluginfilename
+Causes \fBlli\fP to load the plugin (shared object) named \fIpluginfilename\fP and use
+it for optimization.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-stats
+Print statistics from the code\-generation passes. This is only meaningful for
+the just\-in\-time compiler, at present.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-time\-passes
+Record the amount of time needed for each code\-generation pass and print it to
+standard error.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-version
+Print out the version of \fBlli\fP and exit without doing anything else.
+.UNINDENT
+.SH TARGET OPTIONS
+.INDENT 0.0
+.TP
+.B \-mtriple=target triple
+Override the target triple specified in the input bitcode file with the
+specified string.  This may result in a crash if you pick an
+architecture which is not compatible with the current system.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-march=arch
+Specify the architecture for which to generate assembly, overriding the target
+encoded in the bitcode file.  See the output of \fBllc \-help\fP for a list of
+valid architectures.  By default this is inferred from the target triple or
+autodetected to the current architecture.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-mcpu=cpuname
+Specify a specific chip in the current architecture to generate code for.
+By default this is inferred from the target triple and autodetected to
+the current architecture.  For a list of available CPUs, use:
+\fBllvm\-as < /dev/null | llc \-march=xyz \-mcpu=help\fP
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-mattr=a1,+a2,\-a3,...
+Override or control specific attributes of the target, such as whether SIMD
+operations are enabled or not.  The default set of attributes is set by the
+current CPU.  For a list of available attributes, use:
+\fBllvm\-as < /dev/null | llc \-march=xyz \-mattr=help\fP
+.UNINDENT
+.SH FLOATING POINT OPTIONS
+.INDENT 0.0
+.TP
+.B \-disable\-excess\-fp\-precision
+Disable optimizations that may increase floating point precision.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-enable\-no\-infs\-fp\-math
+Enable optimizations that assume no Inf values.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-enable\-no\-nans\-fp\-math
+Enable optimizations that assume no NAN values.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-enable\-unsafe\-fp\-math
+Causes \fBlli\fP to enable optimizations that may decrease floating point
+precision.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-soft\-float
+Causes \fBlli\fP to generate software floating point library calls instead of
+equivalent hardware instructions.
+.UNINDENT
+.SH CODE GENERATION OPTIONS
+.INDENT 0.0
+.TP
+.B \-code\-model=model
+Choose the code model from:
+.INDENT 7.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+default: Target default code model
+small: Small code model
+kernel: Kernel code model
+medium: Medium code model
+large: Large code model
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-disable\-post\-RA\-scheduler
+Disable scheduling after register allocation.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-disable\-spill\-fusing
+Disable fusing of spill code into instructions.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-jit\-enable\-eh
+Exception handling should be enabled in the just\-in\-time compiler.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-join\-liveintervals
+Coalesce copies (default=true).
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-nozero\-initialized\-in\-bss
+Don\(aqt place zero\-initialized symbols into the BSS section.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-pre\-RA\-sched=scheduler
+Instruction schedulers available (before register allocation):
+.INDENT 7.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+=default: Best scheduler for the target
+=none: No scheduling: breadth first sequencing
+=simple: Simple two pass scheduling: minimize critical path and maximize processor utilization
+=simple\-noitin: Simple two pass scheduling: Same as simple except using generic latency
+=list\-burr: Bottom\-up register reduction list scheduling
+=list\-tdrr: Top\-down register reduction list scheduling
+=list\-td: Top\-down list scheduler \-print\-machineinstrs \- Print generated machine code
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-regalloc=allocator
+Register allocator to use (default=linearscan)
+.INDENT 7.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+=bigblock: Big\-block register allocator
+=linearscan: linear scan register allocator =local \-   local register allocator
+=simple: simple register allocator
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-relocation\-model=model
+Choose relocation model from:
+.INDENT 7.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+=default: Target default relocation model
+=static: Non\-relocatable code =pic \-   Fully relocatable, position independent code
+=dynamic\-no\-pic: Relocatable external references, non\-relocatable code
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-spiller
+Spiller to use (default=local)
+.INDENT 7.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+=simple: simple spiller
+=local: local spiller
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-x86\-asm\-syntax=syntax
+Choose style of code to emit from X86 backend:
+.INDENT 7.0
+.INDENT 3.5
+.sp
+.nf
+.ft C
+=att: Emit AT&T\-style assembly
+=intel: Emit Intel\-style assembly
+.ft P
+.fi
+.UNINDENT
+.UNINDENT
+.UNINDENT
+.SH EXIT STATUS
+.sp
+If \fBlli\fP fails to load the program, it will exit with an exit code of 1.
+Otherwise, it will return the exit code of the program it executes.
+.SH SEE ALSO
+.sp
+\fBllc\fP
+.SH AUTHOR
+Maintained by The LLVM Team (http://llvm.org/).
+.SH COPYRIGHT
+2003-2016, LLVM Project
+.\" Generated by docutils manpage writer.
+.

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/components/llvm/Solaris/man1/llvm-ar.1	Thu Jul 28 16:25:34 2016 -0700
@@ -0,0 +1,389 @@
+.\" Man page generated from reStructuredText.
+.
+.TH "LLVM-AR" "1" "2016-07-10" "3.8" "LLVM"
+.SH NAME
+llvm-ar \- LLVM archiver
+.
+.nr rst2man-indent-level 0
+.
+.de1 rstReportMargin
+\\$1 \\n[an-margin]
+level \\n[rst2man-indent-level]
+level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
+-
+\\n[rst2man-indent0]
+\\n[rst2man-indent1]
+\\n[rst2man-indent2]
+..
+.de1 INDENT
+.\" .rstReportMargin pre:
+. RS \\$1
+. nr rst2man-indent\\n[rst2man-indent-level] \\n[an-margin]
+. nr rst2man-indent-level +1
+.\" .rstReportMargin post:
+..
+.de UNINDENT
+. RE
+.\" indent \\n[an-margin]
+.\" old: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.nr rst2man-indent-level -1
+.\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.in \\n[rst2man-indent\\n[rst2man-indent-level]]u
+..
+.SH SYNOPSIS
+.sp
+\fBllvm\-ar\fP [\-]{dmpqrtx}[Rabfikou] [relpos] [count] <archive> [files...]
+.SH DESCRIPTION
+.sp
+The \fBllvm\-ar\fP command is similar to the common Unix utility, \fBar\fP\&. It
+archives several files together into a single file. The intent for this is
+to produce archive libraries by LLVM bitcode that can be linked into an
+LLVM program. However, the archive can contain any kind of file. By default,
+\fBllvm\-ar\fP generates a symbol table that makes linking faster because
+only the symbol table needs to be consulted, not each individual file member
+of the archive.
+.sp
+The \fBllvm\-ar\fP command can be used to \fIread\fP SVR4, GNU and BSD style archive
+files. However, right now it can only write in the GNU format. If an
+SVR4 or BSD style archive is used with the \fBr\fP (replace) or \fBq\fP (quick
+update) operations, the archive will be reconstructed in GNU format.
+.sp
+Here\(aqs where \fBllvm\-ar\fP departs from previous \fBar\fP implementations:
+.sp
+\fISymbol Table\fP
+.INDENT 0.0
+.INDENT 3.5
+Since \fBllvm\-ar\fP supports bitcode files. The symbol table it creates
+is in GNU format and includes both native and bitcode files.
+.UNINDENT
+.UNINDENT
+.sp
+\fILong Paths\fP
+.INDENT 0.0
+.INDENT 3.5
+Currently \fBllvm\-ar\fP can read GNU and BSD long file names, but only writes
+archives with the GNU format.
+.UNINDENT
+.UNINDENT
+.SH OPTIONS
+.sp
+The options to \fBllvm\-ar\fP are compatible with other \fBar\fP implementations.
+However, there are a few modifiers (\fIR\fP) that are not found in other \fBar\fP
+implementations. The options to \fBllvm\-ar\fP specify a single basic operation to
+perform on the archive, a variety of modifiers for that operation, the name of
+the archive file, and an optional list of file names. These options are used to
+determine how \fBllvm\-ar\fP should process the archive file.
+.sp
+The Operations and Modifiers are explained in the sections below. The minimal
+set of options is at least one operator and the name of the archive. Typically
+archive files end with a \fB\&.a\fP suffix, but this is not required. Following
+the \fIarchive\-name\fP comes a list of \fIfiles\fP that indicate the specific members
+of the archive to operate on. If the \fIfiles\fP option is not specified, it
+generally means either "none" or "all" members, depending on the operation.
+.SS Operations
+.sp
+d
+.INDENT 0.0
+.INDENT 3.5
+Delete files from the archive. No modifiers are applicable to this operation.
+The \fIfiles\fP options specify which members should be removed from the
+archive. It is not an error if a specified file does not appear in the archive.
+If no \fIfiles\fP are specified, the archive is not modified.
+.UNINDENT
+.UNINDENT
+.sp
+m[abi]
+.INDENT 0.0
+.INDENT 3.5
+Move files from one location in the archive to another. The \fIa\fP, \fIb\fP, and
+\fIi\fP modifiers apply to this operation. The \fIfiles\fP will all be moved
+to the location given by the modifiers. If no modifiers are used, the files
+will be moved to the end of the archive. If no \fIfiles\fP are specified, the
+archive is not modified.
+.UNINDENT
+.UNINDENT
+.sp
+p
+.INDENT 0.0
+.INDENT 3.5
+Print files to the standard output. This operation simply prints the
+\fIfiles\fP indicated to the standard output. If no \fIfiles\fP are
+specified, the entire  archive is printed.  Printing bitcode files is
+ill\-advised as they might confuse your terminal settings. The \fIp\fP
+operation never modifies the archive.
+.UNINDENT
+.UNINDENT
+.sp
+q
+.INDENT 0.0
+.INDENT 3.5
+Quickly append files to the end of the archive.  This operation quickly adds the
+\fIfiles\fP to the archive without checking for duplicates that should be
+removed first. If no \fIfiles\fP are specified, the archive is not modified.
+Because of the way that \fBllvm\-ar\fP constructs the archive file, its dubious
+whether the \fIq\fP operation is any faster than the \fIr\fP operation.
+.UNINDENT
+.UNINDENT
+.sp
+r[abu]
+.INDENT 0.0
+.INDENT 3.5
+Replace or insert file members. The \fIa\fP, \fIb\fP,  and \fIu\fP
+modifiers apply to this operation. This operation will replace existing
+\fIfiles\fP or insert them at the end of the archive if they do not exist. If no
+\fIfiles\fP are specified, the archive is not modified.
+.UNINDENT
+.UNINDENT
+.sp
+t[v]
+.INDENT 0.0
+.INDENT 3.5
+Print the table of contents. Without any modifiers, this operation just prints
+the names of the members to the standard output. With the \fIv\fP modifier,
+\fBllvm\-ar\fP also prints out the file type (B=bitcode, S=symbol
+table, blank=regular file), the permission mode, the owner and group, the
+size, and the date. If any \fIfiles\fP are specified, the listing is only for
+those files. If no \fIfiles\fP are specified, the table of contents for the
+whole archive is printed.
+.UNINDENT
+.UNINDENT
+.sp
+x[oP]
+.INDENT 0.0
+.INDENT 3.5
+Extract archive members back to files. The \fIo\fP modifier applies to this
+operation. This operation retrieves the indicated \fIfiles\fP from the archive
+and writes them back to the operating system\(aqs file system. If no
+\fIfiles\fP are specified, the entire archive is extract.
+.UNINDENT
+.UNINDENT
+.SS Modifiers (operation specific)
+.sp
+The modifiers below are specific to certain operations. See the Operations
+section (above) to determine which modifiers are applicable to which operations.
+.sp
+[a]
+.INDENT 0.0
+.INDENT 3.5
+When inserting or moving member files, this option specifies the destination of
+the new files as being after the \fIrelpos\fP member. If \fIrelpos\fP is not found,
+the files are placed at the end of the archive.
+.UNINDENT
+.UNINDENT
+.sp
+[b]
+.INDENT 0.0
+.INDENT 3.5
+When inserting or moving member files, this option specifies the destination of
+the new files as being before the \fIrelpos\fP member. If \fIrelpos\fP is not
+found, the files are placed at the end of the archive. This modifier is
+identical to the \fIi\fP modifier.
+.UNINDENT
+.UNINDENT
+.sp
+[i]
+.INDENT 0.0
+.INDENT 3.5
+A synonym for the \fIb\fP option.
+.UNINDENT
+.UNINDENT
+.sp
+[o]
+.INDENT 0.0
+.INDENT 3.5
+When extracting files, this option will cause \fBllvm\-ar\fP to preserve the
+original modification times of the files it writes.
+.UNINDENT
+.UNINDENT
+.sp
+[u]
+.INDENT 0.0
+.INDENT 3.5
+When replacing existing files in the archive, only replace those files that have
+a time stamp than the time stamp of the member in the archive.
+.UNINDENT
+.UNINDENT
+.SS Modifiers (generic)
+.sp
+The modifiers below may be applied to any operation.
+.sp
+[c]
+.INDENT 0.0
+.INDENT 3.5
+For all operations, \fBllvm\-ar\fP will always create the archive if it doesn\(aqt
+exist. Normally, \fBllvm\-ar\fP will print a warning message indicating that the
+archive is being created. Using this modifier turns off that warning.
+.UNINDENT
+.UNINDENT
+.sp
+[s]
+.INDENT 0.0
+.INDENT 3.5
+This modifier requests that an archive index (or symbol table) be added to the
+archive. This is the default mode of operation. The symbol table will contain
+all the externally visible functions and global variables defined by all the
+bitcode files in the archive.
+.UNINDENT
+.UNINDENT
+.sp
+[S]
+.INDENT 0.0
+.INDENT 3.5
+This modifier is the opposite of the \fIs\fP modifier. It instructs \fBllvm\-ar\fP to
+not build the symbol table. If both \fIs\fP and \fIS\fP are used, the last modifier to
+occur in the options will prevail.
+.UNINDENT
+.UNINDENT
+.sp
+[v]
+.INDENT 0.0
+.INDENT 3.5
+This modifier instructs \fBllvm\-ar\fP to be verbose about what it is doing. Each
+editing operation taken against the archive will produce a line of output saying
+what is being done.
+.UNINDENT
+.UNINDENT
+.SH STANDARDS
+.sp
+The \fBllvm\-ar\fP utility is intended to provide a superset of the IEEE Std 1003.2
+(POSIX.2) functionality for \fBar\fP\&. \fBllvm\-ar\fP can read both SVR4 and BSD4.4 (or
+Mac OS X) archives. If the \fBf\fP modifier is given to the \fBx\fP or \fBr\fP operations
+then \fBllvm\-ar\fP will write SVR4 compatible archives. Without this modifier,
+\fBllvm\-ar\fP will write BSD4.4 compatible archives that have long names
+immediately after the header and indicated using the "#1/ddd" notation for the
+name in the header.
+.SH FILE FORMAT
+.sp
+The file format for LLVM Archive files is similar to that of BSD 4.4 or Mac OSX
+archive files. In fact, except for the symbol table, the \fBar\fP commands on those
+operating systems should be able to read LLVM archive files. The details of the
+file format follow.
+.sp
+Each archive begins with the archive magic number which is the eight printable
+characters "!<arch>n" where n represents the newline character (0x0A).
+Following the magic number, the file is composed of even length members that
+begin with an archive header and end with a n padding character if necessary
+(to make the length even). Each file member is composed of a header (defined
+below), an optional newline\-terminated "long file name" and the contents of
+the file.
+.sp
+The fields of the header are described in the items below. All fields of the
+header contain only ASCII characters, are left justified and are right padded
+with space characters.
+.sp
+name \- char[16]
+.INDENT 0.0
+.INDENT 3.5
+This field of the header provides the name of the archive member. If the name is
+longer than 15 characters or contains a slash (/) character, then this field
+contains \fB#1/nnn\fP where \fBnnn\fP provides the length of the name and the \fB#1/\fP
+is literal.  In this case, the actual name of the file is provided in the \fBnnn\fP
+bytes immediately following the header. If the name is 15 characters or less, it
+is contained directly in this field and terminated with a slash (/) character.
+.UNINDENT
+.UNINDENT
+.sp
+date \- char[12]
+.INDENT 0.0
+.INDENT 3.5
+This field provides the date of modification of the file in the form of a
+decimal encoded number that provides the number of seconds since the epoch
+(since 00:00:00 Jan 1, 1970) per Posix specifications.
+.UNINDENT
+.UNINDENT
+.sp
+uid \- char[6]
+.INDENT 0.0
+.INDENT 3.5
+This field provides the user id of the file encoded as a decimal ASCII string.
+This field might not make much sense on non\-Unix systems. On Unix, it is the
+same value as the st_uid field of the stat structure returned by the stat(2)
+operating system call.
+.UNINDENT
+.UNINDENT
+.sp
+gid \- char[6]
+.INDENT 0.0
+.INDENT 3.5
+This field provides the group id of the file encoded as a decimal ASCII string.
+This field might not make much sense on non\-Unix systems. On Unix, it is the
+same value as the st_gid field of the stat structure returned by the stat(2)
+operating system call.
+.UNINDENT
+.UNINDENT
+.sp
+mode \- char[8]
+.INDENT 0.0
+.INDENT 3.5
+This field provides the access mode of the file encoded as an octal ASCII
+string. This field might not make much sense on non\-Unix systems. On Unix, it
+is the same value as the st_mode field of the stat structure returned by the
+stat(2) operating system call.
+.UNINDENT
+.UNINDENT
+.sp
+size \- char[10]
+.INDENT 0.0
+.INDENT 3.5
+This field provides the size of the file, in bytes, encoded as a decimal ASCII
+string.
+.UNINDENT
+.UNINDENT
+.sp
+fmag \- char[2]
+.INDENT 0.0
+.INDENT 3.5
+This field is the archive file member magic number. Its content is always the
+two characters back tick (0x60) and newline (0x0A). This provides some measure
+utility in identifying archive files that have been corrupted.
+.UNINDENT
+.UNINDENT
+.sp
+offset \- vbr encoded 32\-bit integer
+.INDENT 0.0
+.INDENT 3.5
+The offset item provides the offset into the archive file where the bitcode
+member is stored that is associated with the symbol. The offset value is 0
+based at the start of the first "normal" file member. To derive the actual
+file offset of the member, you must add the number of bytes occupied by the file
+signature (8 bytes) and the symbol tables. The value of this item is encoded
+using variable bit rate encoding to reduce the size of the symbol table.
+Variable bit rate encoding uses the high bit (0x80) of each byte to indicate
+if there are more bytes to follow. The remaining 7 bits in each byte carry bits
+from the value. The final byte does not have the high bit set.
+.UNINDENT
+.UNINDENT
+.sp
+length \- vbr encoded 32\-bit integer
+.INDENT 0.0
+.INDENT 3.5
+The length item provides the length of the symbol that follows. Like this
+\fIoffset\fP item, the length is variable bit rate encoded.
+.UNINDENT
+.UNINDENT
+.sp
+symbol \- character array
+.INDENT 0.0
+.INDENT 3.5
+The symbol item provides the text of the symbol that is associated with the
+\fIoffset\fP\&. The symbol is not terminated by any character. Its length is provided
+by the \fIlength\fP field. Note that is allowed (but unwise) to use non\-printing
+characters (even 0x00) in the symbol. This allows for multiple encodings of
+symbol names.
+.UNINDENT
+.UNINDENT
+.SH EXIT STATUS
+.sp
+If \fBllvm\-ar\fP succeeds, it will exit with 0.  A usage error, results
+in an exit code of 1. A hard (file system typically) error results in an
+exit code of 2. Miscellaneous or unknown errors result in an
+exit code of 3.
+.SH SEE ALSO
+.sp
+ar(1)
+.SH AUTHOR
+Maintained by The LLVM Team (http://llvm.org/).
+.SH COPYRIGHT
+2003-2016, LLVM Project
+.\" Generated by docutils manpage writer.
+.

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/components/llvm/Solaris/man1/llvm-as.1	Thu Jul 28 16:25:34 2016 -0700
@@ -0,0 +1,86 @@
+.\" Man page generated from reStructuredText.
+.
+.TH "LLVM-AS" "1" "2016-07-10" "3.8" "LLVM"
+.SH NAME
+llvm-as \- LLVM assembler
+.
+.nr rst2man-indent-level 0
+.
+.de1 rstReportMargin
+\\$1 \\n[an-margin]
+level \\n[rst2man-indent-level]
+level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
+-
+\\n[rst2man-indent0]
+\\n[rst2man-indent1]
+\\n[rst2man-indent2]
+..
+.de1 INDENT
+.\" .rstReportMargin pre:
+. RS \\$1
+. nr rst2man-indent\\n[rst2man-indent-level] \\n[an-margin]
+. nr rst2man-indent-level +1
+.\" .rstReportMargin post:
+..
+.de UNINDENT
+. RE
+.\" indent \\n[an-margin]
+.\" old: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.nr rst2man-indent-level -1
+.\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.in \\n[rst2man-indent\\n[rst2man-indent-level]]u
+..
+.SH SYNOPSIS
+.sp
+\fBllvm\-as\fP [\fIoptions\fP] [\fIfilename\fP]
+.SH DESCRIPTION
+.sp
+\fBllvm\-as\fP is the LLVM assembler.  It reads a file containing human\-readable
+LLVM assembly language, translates it to LLVM bitcode, and writes the result
+into a file or to standard output.
+.sp
+If \fIfilename\fP is omitted or is \fB\-\fP, then \fBllvm\-as\fP reads its input from
+standard input.
+.sp
+If an output file is not specified with the \fB\-o\fP option, then
+\fBllvm\-as\fP sends its output to a file or standard output by following
+these rules:
+.INDENT 0.0
+.IP \(bu 2
+If the input is standard input, then the output is standard output.
+.IP \(bu 2
+If the input is a file that ends with \fB\&.ll\fP, then the output file is of the
+same name, except that the suffix is changed to \fB\&.bc\fP\&.
+.IP \(bu 2
+If the input is a file that does not end with the \fB\&.ll\fP suffix, then the
+output file has the same name as the input file, except that the \fB\&.bc\fP
+suffix is appended.
+.UNINDENT
+.SH OPTIONS
+.INDENT 0.0
+.TP
+\fB\-f\fP
+Enable binary output on terminals.  Normally, \fBllvm\-as\fP will refuse to
+write raw bitcode output if the output stream is a terminal. With this option,
+\fBllvm\-as\fP will write raw bitcode regardless of the output device.
+.TP
+\fB\-help\fP
+Print a summary of command line options.
+.TP
+\fB\-o\fP \fIfilename\fP
+Specify the output file name.  If \fIfilename\fP is \fB\-\fP, then \fBllvm\-as\fP
+sends its output to standard output.
+.UNINDENT
+.SH EXIT STATUS
+.sp
+If \fBllvm\-as\fP succeeds, it will exit with 0.  Otherwise, if an error occurs, it
+will exit with a non\-zero value.
+.SH SEE ALSO
+.sp
+llvm\-dis|llvm\-dis, gccas|gccas
+.SH AUTHOR
+Maintained by The LLVM Team (http://llvm.org/).
+.SH COPYRIGHT
+2003-2016, LLVM Project
+.\" Generated by docutils manpage writer.
+.

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/components/llvm/Solaris/man1/llvm-bcanalyzer.1	Thu Jul 28 16:25:34 2016 -0700
@@ -0,0 +1,475 @@
+.\" Man page generated from reStructuredText.
+.
+.TH "LLVM-BCANALYZER" "1" "2016-07-10" "3.8" "LLVM"
+.SH NAME
+llvm-bcanalyzer \- LLVM bitcode analyzer
+.
+.nr rst2man-indent-level 0
+.
+.de1 rstReportMargin
+\\$1 \\n[an-margin]
+level \\n[rst2man-indent-level]
+level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
+-
+\\n[rst2man-indent0]
+\\n[rst2man-indent1]
+\\n[rst2man-indent2]
+..
+.de1 INDENT
+.\" .rstReportMargin pre:
+. RS \\$1
+. nr rst2man-indent\\n[rst2man-indent-level] \\n[an-margin]
+. nr rst2man-indent-level +1
+.\" .rstReportMargin post:
+..
+.de UNINDENT
+. RE
+.\" indent \\n[an-margin]
+.\" old: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.nr rst2man-indent-level -1
+.\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
+.in \\n[rst2man-indent\\n[rst2man-indent-level]]u
+..
+.SH SYNOPSIS
+.sp
+\fBllvm\-bcanalyzer\fP [\fIoptions\fP] [\fIfilename\fP]
+.SH DESCRIPTION
+.sp
+The \fBllvm\-bcanalyzer\fP command is a small utility for analyzing bitcode
+files.  The tool reads a bitcode file (such as generated with the
+\fBllvm\-as\fP tool) and produces a statistical report on the contents of
+the bitcode file.  The tool can also dump a low level but human readable
+version of the bitcode file.  This tool is probably not of much interest or
+utility except for those working directly with the bitcode file format.  Most
+LLVM users can just ignore this tool.
+.sp
+If \fIfilename\fP is omitted or is \fB\-\fP, then \fBllvm\-bcanalyzer\fP reads its
+input from standard input.  This is useful for combining the tool into a
+pipeline.  Output is written to the standard output.
+.SH OPTIONS
+.INDENT 0.0
+.TP
+.B \-nodetails
+Causes \fBllvm\-bcanalyzer\fP to abbreviate its output by writing out only
+a module level summary.  The details for individual functions are not
+displayed.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-dump
+Causes \fBllvm\-bcanalyzer\fP to dump the bitcode in a human readable
+format.  This format is significantly different from LLVM assembly and
+provides details about the encoding of the bitcode file.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-verify
+Causes \fBllvm\-bcanalyzer\fP to verify the module produced by reading the
+bitcode.  This ensures that the statistics generated are based on a consistent
+module.
+.UNINDENT
+.INDENT 0.0
+.TP
+.B \-help
+Print a summary of command line options.
+.UNINDENT
+.SH EXIT STATUS
+.sp
+If \fBllvm\-bcanalyzer\fP succeeds, it will exit with 0.  Otherwise, if an
+error occurs, it will exit with a non\-zero value, usually 1.
+.SH SUMMARY OUTPUT DEFINITIONS
+.sp
+The following items are always printed by llvm\-bcanalyzer.  They comprize the
+summary output.
+.sp
+\fBBitcode Analysis Of Module\fP
+.INDENT 0.0
+.INDENT 3.5
+This just provides the name of the module for which bitcode analysis is being
+generated.
+.UNINDENT
+.UNINDENT
+.sp
+\fBBitcode Version Number\fP
+.INDENT 0.0
+.INDENT 3.5
+The bitcode version (not LLVM version) of the file read by the analyzer.
+.UNINDENT
+.UNINDENT
+.sp
+\fBFile Size\fP
+.INDENT 0.0
+.INDENT 3.5
+The size, in bytes, of the entire bitcode file.
+.UNINDENT
+.UNINDENT
+.sp
+\fBModule Bytes\fP
+.INDENT 0.0
+.INDENT 3.5
+The size, in bytes, of the module block.  Percentage is relative to File Size.
+.UNINDENT
+.UNINDENT
+.sp
+\fBFunction Bytes\fP
+.INDENT 0.0
+.INDENT 3.5
+The size, in bytes, of all the function blocks.  Percentage is relative to File
+Size.
+.UNINDENT
+.UNINDENT
+.sp
+\fBGlobal Types Bytes\fP
+.INDENT 0.0
+.INDENT 3.5
+The size, in bytes, of the Global Types Pool.  Percentage is relative to File
+Size.  This is the size of the definitions of all types in the bitcode file.
+.UNINDENT
+.UNINDENT
+.sp
+\fBConstant Pool Bytes\fP
+.INDENT 0.0
+.INDENT 3.5
+The size, in bytes, of the Constant Pool Blocks Percentage is relative to File
+Size.
+.UNINDENT
+.UNINDENT
+.sp
+\fBModule Globals Bytes\fP
+.INDENT 0.0
+.INDENT 3.5
+Ths size, in bytes, of the Global Variable Definitions and their initializers.
+Percentage is relative to File Size.
+.UNINDENT
+.UNINDENT
+.sp
+\fBInstruction List Bytes\fP
+.INDENT 0.0
+.INDENT 3.5
+The size, in bytes, of all the instruction lists in all the functions.
+Percentage is relative to File Size.  Note that this value is also included in
+the Function Bytes.
+.UNINDENT
+.UNINDENT
+.sp
+\fBCompaction Table Bytes\fP
+.INDENT 0.0
+.INDENT 3.5
+The size, in bytes, of all the compaction tables in all the functions.
+Percentage is relative to File Size.  Note that this value is also included in
+the Function Bytes.
+.UNINDENT
+.UNINDENT
+.sp
+\fBSymbol Table Bytes\fP
+.INDENT 0.0
+.INDENT 3.5
+The size, in bytes, of all the symbol tables in all the functions.  Percentage is
+relative to File Size.  Note that this value is also included in the Function
+Bytes.
+.UNINDENT
+.UNINDENT
+.sp
+\fBDependent Libraries Bytes\fP
+.INDENT 0.0
+.INDENT 3.5
+The size, in bytes, of the list of dependent libraries in the module.  Percentage
+is relative to File Size.  Note that this value is also included in the Module
+Global Bytes.
+.UNINDENT
+.UNINDENT
+.sp
+\fBNumber Of Bitcode Blocks\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of blocks of any kind in the bitcode file.
+.UNINDENT
+.UNINDENT
+.sp
+\fBNumber Of Functions\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of function definitions in the bitcode file.
+.UNINDENT
+.UNINDENT
+.sp
+\fBNumber Of Types\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of types defined in the Global Types Pool.
+.UNINDENT
+.UNINDENT
+.sp
+\fBNumber Of Constants\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of constants (of any type) defined in the Constant Pool.
+.UNINDENT
+.UNINDENT
+.sp
+\fBNumber Of Basic Blocks\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of basic blocks defined in all functions in the bitcode file.
+.UNINDENT
+.UNINDENT
+.sp
+\fBNumber Of Instructions\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of instructions defined in all functions in the bitcode file.
+.UNINDENT
+.UNINDENT
+.sp
+\fBNumber Of Long Instructions\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of long instructions defined in all functions in the bitcode
+file.  Long instructions are those taking greater than 4 bytes.  Typically long
+instructions are GetElementPtr with several indices, PHI nodes, and calls to
+functions with large numbers of arguments.
+.UNINDENT
+.UNINDENT
+.sp
+\fBNumber Of Operands\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of operands used in all instructions in the bitcode file.
+.UNINDENT
+.UNINDENT
+.sp
+\fBNumber Of Compaction Tables\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of compaction tables in all functions in the bitcode file.
+.UNINDENT
+.UNINDENT
+.sp
+\fBNumber Of Symbol Tables\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of symbol tables in all functions in the bitcode file.
+.UNINDENT
+.UNINDENT
+.sp
+\fBNumber Of Dependent Libs\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of dependent libraries found in the bitcode file.
+.UNINDENT
+.UNINDENT
+.sp
+\fBTotal Instruction Size\fP
+.INDENT 0.0
+.INDENT 3.5
+The total size of the instructions in all functions in the bitcode file.
+.UNINDENT
+.UNINDENT
+.sp
+\fBAverage Instruction Size\fP
+.INDENT 0.0
+.INDENT 3.5
+The average number of bytes per instruction across all functions in the bitcode
+file.  This value is computed by dividing Total Instruction Size by Number Of
+Instructions.
+.UNINDENT
+.UNINDENT
+.sp
+\fBMaximum Type Slot Number\fP
+.INDENT 0.0
+.INDENT 3.5
+The maximum value used for a type\(aqs slot number.  Larger slot number values take
+more bytes to encode.
+.UNINDENT
+.UNINDENT
+.sp
+\fBMaximum Value Slot Number\fP
+.INDENT 0.0
+.INDENT 3.5
+The maximum value used for a value\(aqs slot number.  Larger slot number values take
+more bytes to encode.
+.UNINDENT
+.UNINDENT
+.sp
+\fBBytes Per Value\fP
+.INDENT 0.0
+.INDENT 3.5
+The average size of a Value definition (of any type).  This is computed by
+dividing File Size by the total number of values of any type.
+.UNINDENT
+.UNINDENT
+.sp
+\fBBytes Per Global\fP
+.INDENT 0.0
+.INDENT 3.5
+The average size of a global definition (constants and global variables).
+.UNINDENT
+.UNINDENT
+.sp
+\fBBytes Per Function\fP
+.INDENT 0.0
+.INDENT 3.5
+The average number of bytes per function definition.  This is computed by
+dividing Function Bytes by Number Of Functions.
+.UNINDENT
+.UNINDENT
+.sp
+\fB# of VBR 32\-bit Integers\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of 32\-bit integers encoded using the Variable Bit Rate
+encoding scheme.
+.UNINDENT
+.UNINDENT
+.sp
+\fB# of VBR 64\-bit Integers\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of 64\-bit integers encoded using the Variable Bit Rate encoding
+scheme.
+.UNINDENT
+.UNINDENT
+.sp
+\fB# of VBR Compressed Bytes\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of bytes consumed by the 32\-bit and 64\-bit integers that use
+the Variable Bit Rate encoding scheme.
+.UNINDENT
+.UNINDENT
+.sp
+\fB# of VBR Expanded Bytes\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of bytes that would have been consumed by the 32\-bit and 64\-bit
+integers had they not been compressed with the Variable Bit Rage encoding
+scheme.
+.UNINDENT
+.UNINDENT
+.sp
+\fBBytes Saved With VBR\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of bytes saved by using the Variable Bit Rate encoding scheme.
+The percentage is relative to # of VBR Expanded Bytes.
+.UNINDENT
+.UNINDENT
+.SH DETAILED OUTPUT DEFINITIONS
+.sp
+The following definitions occur only if the \-nodetails option was not given.
+The detailed output provides additional information on a per\-function basis.
+.sp
+\fBType\fP
+.INDENT 0.0
+.INDENT 3.5
+The type signature of the function.
+.UNINDENT
+.UNINDENT
+.sp
+\fBByte Size\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of bytes in the function\(aqs block.
+.UNINDENT
+.UNINDENT
+.sp
+\fBBasic Blocks\fP
+.INDENT 0.0
+.INDENT 3.5
+The number of basic blocks defined by the function.
+.UNINDENT
+.UNINDENT
+.sp
+\fBInstructions\fP
+.INDENT 0.0
+.INDENT 3.5
+The number of instructions defined by the function.
+.UNINDENT
+.UNINDENT
+.sp
+\fBLong Instructions\fP
+.INDENT 0.0
+.INDENT 3.5
+The number of instructions using the long instruction format in the function.
+.UNINDENT
+.UNINDENT
+.sp
+\fBOperands\fP
+.INDENT 0.0
+.INDENT 3.5
+The number of operands used by all instructions in the function.
+.UNINDENT
+.UNINDENT
+.sp
+\fBInstruction Size\fP
+.INDENT 0.0
+.INDENT 3.5
+The number of bytes consumed by instructions in the function.
+.UNINDENT
+.UNINDENT
+.sp
+\fBAverage Instruction Size\fP
+.INDENT 0.0
+.INDENT 3.5
+The average number of bytes consumed by the instructions in the function.
+This value is computed by dividing Instruction Size by Instructions.
+.UNINDENT
+.UNINDENT
+.sp
+\fBBytes Per Instruction\fP
+.INDENT 0.0
+.INDENT 3.5
+The average number of bytes used by the function per instruction.  This value
+is computed by dividing Byte Size by Instructions.  Note that this is not the
+same as Average Instruction Size.  It computes a number relative to the total
+function size not just the size of the instruction list.
+.UNINDENT
+.UNINDENT
+.sp
+\fBNumber of VBR 32\-bit Integers\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of 32\-bit integers found in this function (for any use).
+.UNINDENT
+.UNINDENT
+.sp
+\fBNumber of VBR 64\-bit Integers\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of 64\-bit integers found in this function (for any use).
+.UNINDENT
+.UNINDENT
+.sp
+\fBNumber of VBR Compressed Bytes\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of bytes in this function consumed by the 32\-bit and 64\-bit
+integers that use the Variable Bit Rate encoding scheme.
+.UNINDENT
+.UNINDENT
+.sp
+\fBNumber of VBR Expanded Bytes\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of bytes in this function that would have been consumed by
+the 32\-bit and 64\-bit integers had they not been compressed with the Variable
+Bit Rate encoding scheme.
+.UNINDENT
+.UNINDENT
+.sp
+\fBBytes Saved With VBR\fP
+.INDENT 0.0
+.INDENT 3.5
+The total number of bytes saved in this function by using the Variable Bit
+Rate encoding scheme.  The percentage is relative to # of VBR Expanded Bytes.
+.UNINDENT
+.UNINDENT
+.SH SEE ALSO
+.sp
+/CommandGuide/llvm\-dis, /BitCodeFormat
+.SH AUTHOR
+Maintained by The LLVM Team (http://llvm.org/).
+.SH COPYRIGHT
+2003-2016, LLVM Project
+.\" Generated by docutils manpage writer.
+.