Note that a work-around is available.

llvm-svn: 24237

llvm/.cvsignore

@@ -4,3 +4,4 @@ config.log
 config.status
 cvs.out
 autom4te.cache
+configure.out

llvm/CREDITS.TXT

@@ -1,6 +1,7 @@
-Inspired by the CREDITS file from the Linux source tree, this file is,
-likewise, at least a partial list of people who have contributed to the LLVM
-project. The format and the next paragraph are stolen directly from that file.
+This file is a partial list of people who have contributed to the LLVM
+project.  If you have contributed a patch or made some other contribution to
+LLVM, please submit a patch to this file to add yourself, and it will be 
+done!
 
 The list is sorted by name and formatted to allow easy grepping and
 beautification by scripts.  The fields are: name (N), email (E), web-address

llvm/Makefile

@@ -7,17 +7,25 @@
 # 
 #===------------------------------------------------------------------------===#
 LEVEL = .
-DIRS = lib/System lib/Support utils lib tools 
+DIRS = lib/System lib/Support utils lib
 
-ifneq ($(MAKECMDGOALS),tools-only)
-DIRS += runtime docs
-OPTIONAL_DIRS = examples projects
+ifeq ($(MAKECMDGOALS),tools-only)
+DIRS += tools
+else
+  ifneq ($(MAKECMDGOALS),libs-only)
+    DIRS += tools runtime docs
+    OPTIONAL_DIRS = examples projects
+  endif
 endif
 
 EXTRA_DIST := test llvm.spec include
 
 include $(LEVEL)/Makefile.common
 
+# Specify options to pass to configure script when we're
+# running the dist-check target
+DIST_CHECK_CONFIG_OPTIONS = --with-llvmgccdir=$(LLVMGCCDIR)
+
 .PHONY: debug-opt-prof
 debug-opt-prof:
 	$(Echo) Building Debug Version
@@ -42,3 +50,22 @@ dist-hook::
 	  $(TopDistDir)/include/llvm/Support/ThreadSupport.h
 
 tools-only: all
+libs-only: all
+
+#------------------------------------------------------------------------
+# Make sure the generated headers are up-to-date. This must be kept in
+# sync with the AC_CONFIG_HEADER invocations in autoconf/configure.ac
+#------------------------------------------------------------------------
+FilesToConfig := \
+  include/llvm/Config/config.h \
+  include/llvm/Support/DataTypes.h \
+  include/llvm/ADT/hash_map \
+  include/llvm/ADT/hash_set \
+  include/llvm/ADT/iterator
+FilesToConfigPATH  := $(addprefix $(LLVM_OBJ_ROOT)/,$(FilesToConfig))
+
+all-local:: $(FilesToConfigPATH)
+$(FilesToConfigPATH) : $(LLVM_OBJ_ROOT)/% : $(LLVM_SRC_ROOT)/%.in 
+	$(Echo) Regenerating $*
+	$(Verb) cd $(LLVM_OBJ_ROOT) && $(ConfigStatusScript) $*
+.PRECIOUS: $(FilesToConfigPATH)

llvm/Makefile.rules

@@ -77,7 +77,7 @@ ifneq ($(MakefileConfigIn),)
 PreConditions      += $(MakefileConfig)
 endif
 
-preconditions : $(PreConditions)
+preconditions: $(PreConditions)
 
 #------------------------------------------------------------------------
 # Make sure the BUILT_SOURCES are built first
@@ -359,10 +359,13 @@ Compile.C     = $(CC) $(CPP.Flags) $(CompileCommonOpts) -c $(C.Flags)
 LTCompile.C   = $(LIBTOOL) $(LibTool.Flags) --mode=compile $(Compile.C)
 BCCompile.C   = $(LLVMGCCWITHPATH) $(CPP.Flags) $(CompileCommonOpts) \
                 $(C.Flags) -c
+Preprocess.C  = $(CC) $(CPP.Flags) $(CompileCommonOpts) -E $(C.Flags)
+
 Compile.CXX   = $(CXX) $(CPP.Flags) $(CompileCommonOpts) $(CXX.Flags) -c
 LTCompile.CXX = $(LIBTOOL) $(LibTool.Flags) --mode=compile $(Compile.CXX)
 BCCompile.CXX = $(LLVMGXXWITHPATH) $(CPP.Flags) $(CompileCommonOpts) \
                 $(CXX.Flags) -c
+Preprocess.CXX= $(CXX) $(CPP.Flags) $(CompileCommonOpts) $(CXX.Flags) -E
 Link          = $(LIBTOOL) $(LibTool.Flags) --mode=link $(CXX) $(CPP.Flags) \
 	        $(CompileCommonOpts) $(LD.Flags) $(Strip)
 Relink        = $(LIBTOOL) $(LibTool.Flags) --mode=link $(CXX) $(CPP.Flags) \
@@ -423,17 +426,10 @@ endif
 # in the file so they get built before dependencies
 #---------------------------------------------------------
 
-$(PROJ_bindir):
-	$(Verb) $(MKDIR) $(PROJ_bindir)
-
-$(PROJ_libdir):
-	$(Verb) $(MKDIR) $(PROJ_libdir)
-
-$(PROJ_includedir):
-	$(Verb) $(MKDIR) $(PROJ_includedir)
-
-$(PROJ_etcdir):
-	$(Verb) $(MKDIR) $(PROJ_etcdir)
+$(PROJ_bindir): $(PROJ_bindir)/.dir
+$(PROJ_libdir): $(PROJ_libdir)/.dir
+$(PROJ_includedir): $(PROJ_includedir)/.dir
+$(PROJ_etcdir): $(PROJ_etcdir)/.dir
 
 # To create other directories, as needed, and timestamp their creation
 %/.dir:
@@ -553,6 +549,100 @@ uninstall-local::
 
 endif
 
+###############################################################################
+# Set up variables for building libararies
+###############################################################################
+
+#---------------------------------------------------------
+# Handle the special "JIT" value for LLVM_LIBS which is a
+# shorthand for a bunch of libraries that get the correct
+# JIT support for a library or a tool that runs JIT.
+#---------------------------------------------------------
+ifeq ($(LLVMLIBS),JIT)
+
+# Make sure we can get our own symbols in the tool
+Link += -dlopen self
+
+# Generic JIT libraries
+JIT_LIBS := LLVMInterpreter LLVMJIT LLVMCodeGen LLVMExecutionEngine
+
+# You can enable the X86 JIT on a non-X86 host by setting the flag
+# ENABLE_X86_JIT on the make command line. If not, it will still be
+# enabled automagically on an X86 host.
+ifeq ($(ARCH), x86)
+  ENABLE_X86_JIT = 1
+endif
+
+# What the X86 JIT requires
+ifdef ENABLE_X86_JIT
+  JIT_LIBS += LLVMX86 LLVMSelectionDAG
+endif
+
+# You can enable the SparcV9 JIT on a non-SparcV9 host by setting the flag
+# ENABLE_SPARCV9_JIT on the make command line. If not, it will still be
+# enabled automagically on an SparcV9 host.
+ifeq ($(ARCH), Sparc)
+  ENABLE_SPARCV9_JIT = 1
+endif
+
+# What the Sparc JIT requires
+ifdef ENABLE_SPARCV9_JIT
+  JIT_LIBS += LLVMSparcV9 LLVMSparcV9ModuloSched LLVMSparcV9InstrSched \
+              LLVMSparcV9LiveVar LLVMInstrumentation.a \
+              LLVMBCWriter LLVMTransforms.a LLVMipo.a LLVMipa.a \
+              LLVMDataStructure LLVMSparcV9RegAlloc
+endif
+
+# You can enable the PowerPC JIT on a non-PowerPC host by setting the flag
+# ENABLE_PPC_JIT on the make command line. If not, it will still be
+# enabled automagically on an PowerPC host.
+ifeq ($(ARCH), PowerPC)
+  ENABLE_PPC_JIT = 1
+endif
+
+# What the PowerPC JIT requires
+ifdef ENABLE_PPC_JIT
+  JIT_LIBS += LLVMPowerPC LLVMSelectionDAG
+endif
+
+# You can enable the Alpha JIT on a non-Alpha host by setting the flag
+# ENABLE_ALPHA_JIT on the make command line. If not, it will still be
+# enabled automagically on an Alpha host.
+ifeq ($(ARCH), Alpha)
+  ENABLE_ALPHA_JIT = 1
+endif
+
+# What the Alpha JIT requires
+ifdef ENABLE_ALPHA_JIT
+  JIT_LIBS += LLVMAlpha LLVMSelectionDAG
+endif
+
+LLVMLIBS := $(JIT_LIBS) LLVMScalarOpts.a LLVMTransformUtils.a LLVMAnalysis.a \
+            LLVMBCReader LLVMCore LLVMSupport.a LLVMTarget.a LLVMbzip2 \
+            LLVMSystem.a $(PLATFORMLIBDL)
+endif
+
+#---------------------------------------------------------
+# Define various command line options pertaining to the
+# libraries needed when linking. There are "Proj" libs 
+# (defined by the user's project) and "LLVM" libs (defined 
+# by the # LLVM project).
+#---------------------------------------------------------
+# Some versions of gcc on Alpha produce too many symbols, so use a .a file
+ifeq ($(ARCH),Alpha)
+USEDLIBS :=  $(subst LLVMCore, LLVMCore.a, $(USEDLIBS))
+LLVMLIBS := $(subst LLVMCore, LLVMCore.a, $(LLVMLIBS))
+endif
+
+ProjLibsOptions := $(patsubst %.a.o, -l%, $(addsuffix .o, $(USEDLIBS)))
+ProjLibsOptions := $(patsubst %.o, $(LibDir)/%.o,  $(ProjLibsOptions))
+LLVMLibsOptions := $(patsubst %.a.o, -l%, $(addsuffix .o, $(LLVMLIBS)))
+LLVMLibsOptions := $(patsubst %.o, $(LLVMLibDir)/%.o, $(LLVMLibsOptions))
+ProjUsedLibs    := $(patsubst %.a.o, lib%.a, $(addsuffix .o, $(USEDLIBS)))
+LLVMUsedLibs    := $(patsubst %.a.o, lib%.a, $(addsuffix .o, $(LLVMLIBS)))
+ProjLibsPaths   := $(addprefix $(LibDir)/,$(ProjUsedLibs))
+LLVMLibsPaths   := $(addprefix $(LLVMLibDir)/,$(LLVMUsedLibs))
+
 ###############################################################################
 # Library Build Rules: Four ways to build a library
 ###############################################################################
@@ -634,10 +724,18 @@ ifdef SHARED_LIBRARY
 
 all-local:: $(LibName.LA)
 
+ifdef LINK_LIBS_IN_SHARED
+$(LibName.LA): $(ObjectsLO) $(LibDir)/.dir
+	$(Echo) Linking $(BuildMode) Shared Library $(LIBRARYNAME)$(SHLIBEXT)
+	$(Verb) $(Link) -o $@ $(ObjectsLO) \
+         $(ProjLibsOptions) $(LLVMLibsOptions)
+	$(Verb) $(LTInstall) $@ $(LibDir)
+else
 $(LibName.LA): $(ObjectsLO) $(LibDir)/.dir
 	$(Echo) Linking $(BuildMode) Shared Library $(LIBRARYNAME)$(SHLIBEXT)
 	$(Verb) $(Link) -o $@ $(ObjectsLO)
 	$(Verb) $(LTInstall) $@ $(LibDir)
+endif
 
 clean-local::
 ifneq ($(strip $(LibName.LA)),)
@@ -726,10 +824,18 @@ endif
 
 #---------------------------------------------------------
 # ReLinked Library Targets:
-#   If the user didn't explicitly forbid building a 
-#   relinked then we provide targets for building them.
+#   If the user explicitly requests a relinked library with
+#   BUILD_RELINKED, provide it.  Otherwise, if they specify
+#   neither of BUILD_ARCHIVE or DONT_BUILD_RELINKED, give
+#   them one.
 #---------------------------------------------------------
+ifndef BUILD_ARCHIVE
 ifndef DONT_BUILD_RELINKED
+BUILD_RELINKED = 1
+endif
+endif
+
+ifdef BUILD_RELINKED
 
 all-local:: $(LibName.O)
 
@@ -800,79 +906,14 @@ endif
 
 ifdef TOOLNAME
 
-#---------------------------------------------------------
-# Handle the special "JIT" value for LLVM_LIBS which is a
-# shorthand for a bunch of libraries that get the correct
-# JIT support for a tool that runs JIT.
-#---------------------------------------------------------
-ifeq ($(LLVMLIBS),JIT)
-
-# Make sure we can get our own symbols in the tool
-Link += -dlopen self
-
-# Generic JIT libraries
-JIT_LIBS := LLVMInterpreter LLVMJIT LLVMCodeGen LLVMExecutionEngine
-
-# You can enable the X86 JIT on a non-X86 host by setting the flag
-# ENABLE_X86_JIT on the make command line. If not, it will still be
-# enabled automagically on an X86 host.
-ifeq ($(ARCH), x86)
-  ENABLE_X86_JIT = 1
-endif
-
-# What the X86 JIT requires
-ifdef ENABLE_X86_JIT
-  JIT_LIBS += LLVMX86 LLVMSelectionDAG
-endif
-
-# You can enable the SparcV9 JIT on a non-SparcV9 host by setting the flag
-# ENABLE_SPARCV9_JIT on the make command line. If not, it will still be
-# enabled automagically on an SparcV9 host.
-ifeq ($(ARCH), Sparc)
-  ENABLE_SPARCV9_JIT = 1
-endif
-
-# What the Sparc JIT requires
-ifdef ENABLE_SPARCV9_JIT
-  JIT_LIBS += LLVMSparcV9 LLVMSparcV9ModuloSched LLVMSparcV9InstrSched \
-              LLVMSparcV9LiveVar LLVMInstrumentation.a LLVMProfilePaths \
-              LLVMBCWriter LLVMTransforms.a LLVMipo.a LLVMipa.a \
-              LLVMDataStructure.a LLVMSparcV9RegAlloc
-endif
-
-# You can enable the PowerPC JIT on a non-PowerPC host by setting the flag
-# ENABLE_PPC_JIT on the make command line. If not, it will still be
-# enabled automagically on an PowerPC host.
-ifeq ($(ARCH), PowerPC)
-  ENABLE_PPC_JIT = 1
-endif
-
-# What the PowerPC JIT requires
-ifdef ENABLE_PPC_JIT
-  JIT_LIBS += LLVMPowerPC LLVMSelectionDAG
-endif
-
-LLVMLIBS := $(JIT_LIBS) LLVMScalarOpts LLVMAnalysis.a LLVMTransformUtils.a \
-            LLVMBCReader LLVMCore LLVMSupport.a LLVMTarget.a LLVMbzip2 \
-            LLVMSystem.a $(PLATFORMLIBDL)
-endif
-
 #---------------------------------------------------------
 # Set up variables for building a tool.
 #---------------------------------------------------------
 ifdef EXAMPLE_TOOL
-ToolBuildPath   := $(ExmplDir)/$(TOOLNAME)$(EXEEXT)
+ToolBuildPath   := $(ExmplDir)/$(strip $(TOOLNAME))$(EXEEXT)
 else
-ToolBuildPath   := $(ToolDir)/$(TOOLNAME)$(EXEEXT)
+ToolBuildPath   := $(ToolDir)/$(strip $(TOOLNAME))$(EXEEXT)
 endif
-ProjLibsOptions := $(patsubst %.a.o, -l%, $(addsuffix .o, $(USEDLIBS)))
-ProjLibsOptions := $(patsubst %.o, $(LibDir)/%.o,  $(ProjLibsOptions))
-LLVMLibsOptions := $(patsubst %.a.o, -l%, $(addsuffix .o, $(LLVMLIBS)))
-LLVMLibsOptions := $(patsubst %.o, $(LLVMLibDir)/%.o, $(LLVMLibsOptions))
-ProjUsedLibs    := $(patsubst %.a.o, lib%.a, $(addsuffix .o, $(USEDLIBS)))
-LLVMUsedLibs    := $(patsubst %.a.o, lib%.a, $(addsuffix .o, $(LLVMLIBS)))
-ProjLibsPaths   := $(addprefix $(LibDir)/,$(ProjUsedLibs))
-LLVMLibsPaths   := $(addprefix $(LLVMLibDir)/,$(LLVMUsedLibs))
 
 #---------------------------------------------------------
 # Tell make that we need to rebuild subdirectories before 
@@ -972,6 +1013,20 @@ $(ObjDir)/%.o: %.c $(ObjDir)/.dir $(BUILT_SOURCES)
 
 endif
 
+## Rules for building preprocessed (.i/.ii) outputs.
+$(BuildMode)/%.ii: %.cpp $(ObjDir)/.dir $(BUILT_SOURCES)
+	$(Echo) "Compiling $*.cpp for $(BuildMode) build to .ii file"
+	$(Verb) $(Preprocess.CXX) $< -o $@
+
+$(BuildMode)/%.ii: %.cc $(ObjDir)/.dir $(BUILT_SOURCES)
+	$(Echo) "Compiling $*.cc for $(BuildMode) build to .ii file"
+	$(Verb) $(Preprocess.CXX) $< -o $@
+
+ $(BuildMode)/%.i: %.c $(ObjDir)/.dir $(BUILT_SOURCES)
+	$(Echo) "Compiling $*.c for $(BuildMode) build to .i file"
+	$(Verb) $(Preprocess.C) $< -o $@
+
+
 #---------------------------------------------------------
 # Create .bc files in the ObjDir directory from .cpp .cc and .c files...
 #---------------------------------------------------------
@@ -1053,7 +1108,7 @@ $(ObjDir)/%.bc: %.ll $(ObjDir)/.dir $(LLVMAS)
 
 ifdef TARGET
 
-TDFiles := $(strip $(wildcard $(PROJ_SRC_DIR)/*.td) $(LLVM_SRC_ROOT)/lib/Target/Target.td)
+TDFiles := $(strip $(wildcard $(PROJ_SRC_DIR)/*.td) $(LLVM_SRC_ROOT)/lib/Target/Target.td $(LLVM_SRC_ROOT)/lib/Target/TargetSelectionDAG.td)
 INCFiles := $(filter %.inc,$(BUILT_SOURCES))
 INCTMPFiles := $(INCFiles:%=$(ObjDir)/%.tmp)
 .PRECIOUS: $(INCTMPFiles) $(INCFiles)
@@ -1110,6 +1165,16 @@ $(ObjDir)/%GenCodeEmitter.inc.tmp: %.td $(ObjDir)/.dir
 	$(Echo) "Building $(<F) code emitter with tblgen"
 	$(Verb) $(TableGen) -gen-emitter -o $@ $<
 
+$(TARGET:%=$(ObjDir)/%GenDAGISel.inc.tmp): \
+$(ObjDir)/%GenDAGISel.inc.tmp : %.td $(ObjDir)/.dir
+	$(Echo) "Building $(<F) instruction selector implementation with tblgen"
+	$(Verb) $(TableGen) -gen-dag-isel -o $@ $<
+
+$(TARGET:%=$(ObjDir)/%GenSubtarget.inc.tmp): \
+$(ObjDir)/%GenSubtarget.inc.tmp : %.td $(ObjDir)/.dir
+	$(Echo) "Building $(<F) subtarget information with tblgen"
+	$(Verb) $(TableGen) -gen-subtarget -o $@ $<
+
 clean-local::
 	-$(Verb) $(RM) -f $(INCFiles)
 
@@ -1128,9 +1193,9 @@ LexFiles  := $(filter %.l,$(Sources))
 
 ifneq ($(LexFiles),)
 
-LexOutput := $(strip $(patsubst %.l,%.cpp,$(LexFiles)))
-
-.PRECIOUS: $(LexOutput)
+# Cancel built-in rules for lex
+%.c: %.l
+%.cpp: %.l
 
 # Note the extra sed filtering here, used to cut down on the warnings emited 
 # by GCC.  The last line is a gross hack to work around flex aparently not 
@@ -1138,13 +1203,17 @@ LexOutput := $(strip $(patsubst %.l,%.cpp,$(LexFiles)))
 # uninitialized string buffers in LLVM we can generate very long tokens, so 
 # this is a hack around it.
 # FIXME.  (f.e. char Buffer[10000] )
-%.cpp: %.l
+$(PROJ_SRC_DIR)/%.cpp: $(PROJ_SRC_DIR)/%.l
 	$(Echo) Flexing $*.l
-	$(Verb) $(FLEX) -t $< | \
+	$(Verb) $(FLEX) -t $(PROJ_SRC_DIR)/$*.l | \
 	$(SED) 's/void yyunput/inline void yyunput/' | \
 	$(SED) 's/void \*yy_flex_realloc/inline void *yy_flex_realloc/' | \
 	$(SED) 's/#define YY_BUF_SIZE 16384/#define YY_BUF_SIZE (16384*64)/' \
-	  > $@
+	  > $(PROJ_SRC_DIR)/$*.cpp
+	$(Echo) "*** DON'T FORGET TO CHECK IN $*.cpp (generated file)"
+
+LexObjs := $(patsubst %.l,$(ObjDir)/%.o,$(LexFiles))
+$(LexObjs): $(ObjDir)/%.o : $(PROJ_SRC_DIR)/%.cpp
 
 clean-local::
 	-$(Verb) $(RM) -f $(LexOutput)
@@ -1159,7 +1228,7 @@ endif
 
 YaccFiles  := $(filter %.y,$(Sources))
 ifneq ($(YaccFiles),)
-YaccOutput := $(addprefix $(patsubst %.y,%,$(YaccFiles)),.h .cpp .output)
+YaccOutput := $(addprefix $(patsubst %.y,%,$(YaccFiles)),.output)
 
 .PRECIOUS: $(YaccOutput)
 
@@ -1169,14 +1238,14 @@ YaccOutput := $(addprefix $(patsubst %.y,%,$(YaccFiles)),.h .cpp .output)
 %.h: %.y
 
 # Rule for building the bison parsers...
-%.cpp %.h : %.y
+$(PROJ_SRC_DIR)/%.cpp $(PROJ_SRC_DIR)/%.h : $(PROJ_SRC_DIR)/%.y
 	$(Echo) "Bisoning $*.y"
-	$(Verb) $(BISON) -v -d -p $(<F:%Parser.y=%) -o $*.tab.c  $<
-	$(Verb) $(MV) -f $*.tab.c $*.cpp
-	$(Verb) $(MV) -f $*.tab.h $*.h
+	$(Verb) $(BISON) -v -d -p $(<F:%Parser.y=%) -o $*.tab.c $<
+	$(Verb) $(MV) -f $*.tab.c $(PROJ_SRC_DIR)/$*.cpp
+	$(Verb) $(MV) -f $*.tab.h $(PROJ_SRC_DIR)/$*.h
+	$(Echo) "*** DON'T FORGET TO CHECK IN $*.cpp and $*.h (generated files)"
 
 clean-local::
-	-$(Verb) $(RM) -f $(YaccOutput)
 	$(Verb) $(RM) -f $(YaccOutput)
 endif
 
@@ -1354,7 +1423,7 @@ dist-check:: $(DistTarGZip)
 	  gunzip -c $(DistTarGZip) | $(TAR) xf - && \
 	  cd build && \
 	  ../$(DistName)/configure --prefix="$(DistCheckDir)/install" \
-	    --srcdir=../$(DistName) && \
+	    --srcdir=../$(DistName) $(DIST_CHECK_CONFIG_OPTIONS) && \
 	  $(MAKE) all && \
 	  $(MAKE) check && \
 	  $(MAKE) install && \
@@ -1420,9 +1489,16 @@ $(DistDir)/.makedistdir: $(DistSources)
 	  if test -d "$$from_dir/$$file"; then \
 	    if test -d "$(PROJ_SRC_DIR)/$$file" && \
 	       test "$$from_dir" != "$(PROJ_SRC_DIR)" ; then \
-	      $(CP) -pR "$(PROJ_SRC_DIR)/$$file" "$$to_dir" || exit 1; \
+	       cd $(PROJ_SRC_DIR) ; \
+	       $(TAR) cf - $$file --exclude .svn --exclude CVS | \
+	         ( cd $$to_dir ; $(TAR) xf - ) ; \
+	       cd $(PROJ_OBJ_DIR) ; \
+	    else \
+	       cd $$from_dir ; \
+	       $(TAR) cf - $$file --exclude .svn --exclude CVS | \
+	         ( cd $$to_dir ; $(TAR) xf - ) ; \
+	       cd $(PROJ_OBJ_DIR) ; \
 	    fi; \
-	    $(CP) -pR $$from_dir/$$file $$to_dir || exit 1; \
 	  elif test -f "$$from_dir/$$file" ; then \
 	    $(CP) -p "$$from_dir/$$file" "$(DistDir)/$$file" || exit 1; \
 	  elif test -L "$$from_dir/$$file" ; then \
@@ -1443,8 +1519,8 @@ $(DistDir)/.makedistdir: $(DistSources)
 	  fi; \
 	done
 	$(Verb) if test "$(DistDir)" = "$(TopDistDir)" ; then \
-	  $(EchoCmd) Eliminating CVS directories from distribution ; \
-	  $(RM) -rf `find $(TopDistDir) -type d -name CVS -print` ;\
+	  $(EchoCmd) Eliminating CVS/.svn directories from distribution ; \
+	  $(RM) -rf `find $(TopDistDir) -type d \( -name CVS -o -name .svn \) -print` ;\
 	  $(MAKE) dist-hook ; \
 	  $(FIND) $(TopDistDir) -type d ! -perm -777 -exec chmod a+rwx {} \; \
 	    -o ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; \
@@ -1539,3 +1615,4 @@ printvars::
 	$(Echo) "YaccFiles    : " '$(YaccFiles)'
 	$(Echo) "LexFiles     : " '$(LexFiles)'
 	$(Echo) "Module       : " '$(Module)'
+	$(Echo) "FilesToConfig: " '$(FilesToConfigPATH)'

llvm/Xcode/README.txt

@@ -0,0 +1 @@
+Xcode project files for LLVM, for Xcode 2.1

llvm/autoconf/configure.ac

@@ -31,12 +31,12 @@ dnl===
 dnl===-----------------------------------------------------------------------===
 dnl Initialize autoconf and define the package name, version number and
 dnl email address for reporting bugs.
-AC_INIT([[llvm]],[[1.5cvs]],[llvmbugs@cs.uiuc.edu])
+AC_INIT([[llvm]],[[1.6]],[llvmbugs@cs.uiuc.edu])
 
 dnl Provide a copyright substitution and ensure the copyright notice is included
 dnl in the output of --version option of the generated configure script.
 AC_SUBST(LLVM_COPYRIGHT,["Copyright (c) 2003-2005 University of Illinois at Urbana-Champaign."])
-AC_COPYRIGHT($LLVM_COPYRIGHT)
+AC_COPYRIGHT([Copyright (c) 2003-2005 University of Illinois at Urbana-Champaign.])
 
 dnl Indicate that we require autoconf 2.59 or later. Ths is needed because we
 dnl use some autoconf macros only available in 2.59.
@@ -159,14 +159,6 @@ case $llvm_cv_platform_type in
     ;;
 esac
 
-dnl If we are targetting a Sparc machine running Solaris, pretend that it is
-dnl V9, since that is all that we support at the moment, and autoconf will only
-dnl tell us we're a sparc.
-case $target in
-  sparc*-*-solaris*)  AC_SUBST(target,[[sparcv9-sun-solaris2.8]])
-  ;;
-esac
-
 dnl Determine what our target architecture is and configure accordingly.
 dnl This will allow Makefiles to make a distinction between the hardware and
 dnl the OS.
@@ -220,7 +212,7 @@ else
     Sparc)   AC_SUBST(JIT,[[TARGET_HAS_JIT=1]]) ;;
     PowerPC) AC_SUBST(JIT,[[TARGET_HAS_JIT=1]]) ;;
     x86_64)  AC_SUBST(JIT,[[]]) ;;
-    Alpha)   AC_SUBST(JIT,[[]]) ;;
+    Alpha)   AC_SUBST(JIT,[[TARGET_HAS_JIT=1]]) ;;
     IA64)    AC_SUBST(JIT,[[]]) ;;
     *)       AC_SUBST(JIT,[[]]) ;;
   esac
@@ -238,6 +230,18 @@ case "$enableval" in
   *) AC_MSG_ERROR([Invalid setting for --enable-doxygen. Use "yes" or "no"]) ;;
 esac
 
+dnl Allow disablement of threads
+AC_ARG_ENABLE(threads,
+              AS_HELP_STRING([--enable-threads],
+                             [Use threads if available (default is YES)]),,
+                             enableval=yes)
+case "$enableval" in
+  yes) AC_SUBST(ENABLE_THREADS,[1]) ;;
+  no)  AC_SUBST(ENABLE_THREADS,[0]) ;;
+  *) AC_MSG_ERROR([Invalid setting for --enable-threads. Use "yes" or "no"]) ;;
+esac
+AC_DEFINE_UNQUOTED([ENABLE_THREADS],$ENABLE_THREADS,[Define if threads enabled])
+
 dnl Allow specific targets to be specified for building (or not)
 TARGETS_TO_BUILD=""
 AC_ARG_ENABLE([targets],AS_HELP_STRING([--enable-target],
@@ -312,6 +316,18 @@ AC_PROG_RANLIB
 AC_PATH_PROG(RM,   [rm],   [rm])
 AC_PATH_PROG(SED,  [sed],  [sed])
 AC_PATH_PROG(TAR,  [tar],  [gtar])
+AC_PATH_PROG(GRAPHVIZ, [Graphviz], [echo Graphviz])
+if test "$GRAPHVIZ" != "echo Graphviz" ; then
+  AC_DEFINE([HAVE_GRAPHVIZ],[1],[Define if the Graphviz program is available])
+  AC_DEFINE_UNQUOTED([LLVM_PATH_GRAPHVIZ],"$GRAPHVIZ",
+   [Define to path to Graphviz program if found or 'echo Graphviz' otherwise])
+fi
+AC_PATH_PROG(GV, [gv], [echo gv])
+if test "$GRAPHVIZ" != "echo gv" ; then
+  AC_DEFINE([HAVE_GV],[1],[Define if the gv program is available])
+  AC_DEFINE_UNQUOTED([LLVM_PATH_GV],"$GV",
+   [Define to path to gv program if found or 'echo gv' otherwise])
+fi
 
 dnl Find the install program
 AC_PROG_INSTALL
@@ -357,11 +373,13 @@ esac
 AC_SUBST(ETAGSFLAGS,$ETAGSFLAGS)
 
 if test "$WITH_LLVMGCCDIR" = "default" ; then
-  AC_PATH_PROG(LLVMGCC, [llvm-gcc], [])
-  AC_PATH_PROG(LLVMGXX, [llvm-g++], [])
+  LLVMGCC="llvm-gcc${EXEEXT}"
+  LLVMGXX="llvm-g++${EXEEXT}"
+  AC_PATH_PROG(LLVMGCC, $LLVMGCC, [])
+  AC_PATH_PROG(LLVMGXX, $LLVMGXX, [])
 else
-  LLVMGCC=$WITH_LLVMGCCDIR/bin/llvm-gcc
-  LLVMGXX=$WITH_LLVMGCCDIR/bin/llvm-g++
+  LLVMGCC="$WITH_LLVMGCCDIR/bin/llvm-gcc${EXEEXT}"
+  LLVMGXX="$WITH_LLVMGCCDIR/bin/llvm-g++${EXEEXT}"
   AC_SUBST(LLVMGCC,$LLVMGCC)
   AC_SUBST(LLVMGXX,$LLVMGXX)
 fi
@@ -398,7 +416,7 @@ fi
 dnl Verify that GCC is version 3.0 or higher
 if test "$GCC" = "yes"
 then
-  gccmajor=`$CC --version | head -n 1 | awk '{print $NF;}' | cut -d. -f1`
+  gccmajor=`$CC --version | head -n 1 | sed 's/[[^0-9]]*\([[0-9.]]\).*/\1/'` 
   if test "$gccmajor" -lt "3"
   then
     AC_MSG_ERROR([gcc 3.x required, but you have a lower version])
@@ -423,6 +441,7 @@ dnl===-----------------------------------------------------------------------===
 dnl libelf is for sparc only; we can ignore it if we don't have it
 AC_CHECK_LIB(elf, elf_begin)
 
+
 dnl lt_dlopen may be required for plugin support.
 AC_SEARCH_LIBS(lt_dlopen,ltdl,AC_DEFINE([HAVE_LT_DLOPEN],[1],
               [Define if lt_dlopen() is available on this platform]),
@@ -440,9 +459,12 @@ AC_SEARCH_LIBS(mallinfo,malloc,AC_DEFINE([HAVE_MALLINFO],[1],
 
 dnl pthread locking functions are optional - but llvm will not be thread-safe
 dnl without locks.
-AC_SEARCH_LIBS(pthread_mutex_lock,pthread,
-               AC_DEFINE([HAVE_PTHREAD_MUTEX_LOCK],[1],
-                         [Have pthread_mutex_lock]))
+if test "$ENABLE_THREADS" -eq 1 ; then
+  AC_CHECK_LIB(pthread,pthread_mutex_init)
+  AC_SEARCH_LIBS(pthread_mutex_lock,pthread,
+                 AC_DEFINE([HAVE_PTHREAD_MUTEX_LOCK],[1],
+                           [Have pthread_mutex_lock]))
+fi
 
 dnl===-----------------------------------------------------------------------===
 dnl===
@@ -465,6 +487,9 @@ AC_CHECK_HEADERS([dlfcn.h execinfo.h fcntl.h inttypes.h limits.h link.h])
 AC_CHECK_HEADERS([malloc.h signal.h stdint.h unistd.h utime.h windows.h])
 AC_CHECK_HEADERS([sys/mman.h sys/param.h sys/resource.h sys/time.h sys/types.h])
 AC_CHECK_HEADERS([rw/stdex/hash_map.h rw/stdex/hash_set.h])
+if test "$ENABLE_THREADS" -eq 1 ; then
+  AC_CHECK_HEADERS(pthread.h)
+fi
 
 dnl===-----------------------------------------------------------------------===
 dnl===
@@ -609,20 +634,19 @@ dnl===
 dnl===-----------------------------------------------------------------------===
 
 dnl Configure header files
-AC_CONFIG_HEADERS(include/llvm/Config/config.h)
-
+dnl WARNING: dnl If you add or remove any of the following config headers, then
+dnl you MUST also update Makefile.rules so that the variable FilesToConfig
+dnl contains the same list of files as AC_CONFIG_HEADERS below. This ensures the
+dnl files can be updated automatically when their *.in sources change.
+AC_CONFIG_HEADERS([include/llvm/Config/config.h])
 AC_CONFIG_HEADERS([include/llvm/Support/DataTypes.h])
 AC_CONFIG_HEADERS([include/llvm/ADT/hash_map])
 AC_CONFIG_HEADERS([include/llvm/ADT/hash_set])
-AC_CONFIG_HEADERS([include/llvm/Support/ThreadSupport.h])
 AC_CONFIG_HEADERS([include/llvm/ADT/iterator])
 
 dnl Configure the makefile's configuration data
 AC_CONFIG_FILES([Makefile.config])
 
-dnl Configure llvmc's configuration files
-AC_CONFIG_FILES([tools/llvmc/st tools/llvmc/cpp tools/llvmc/ll tools/llvmc/c])
-
 dnl Configure doxygen's configuration file
 AC_CONFIG_FILES([docs/doxygen.cfg])
 

llvm/autoconf/m4/find_std_program.m4

@@ -0,0 +1,118 @@
+dnl Check for a standard program that has a bin, include and lib directory
+dnl 
+dnl Parameters:
+dnl   $1 - prefix directory to check
+dnl   $2 - program name to check
+dnl   $3 - header file to check 
+dnl   $4 - library file to check 
+AC_DEFUN([CHECK_STD_PROGRAM],
+[m4_define([allcapsname],translit($2,a-z,A-Z))
+if test -n "$1" -a -d "$1" -a -n "$2" -a -d "$1/bin" -a -x "$1/bin/$2" ; then
+  AC_SUBST([USE_]allcapsname(),["USE_]allcapsname()[ = 1"])
+  AC_SUBST(allcapsname(),[$1/bin/$2])
+  AC_SUBST(allcapsname()[_BIN],[$1/bin])
+  AC_SUBST(allcapsname()[_DIR],[$1])
+  if test -n "$3" -a -d "$1/include" -a -f "$1/include/$3" ; then 
+    AC_SUBST(allcapsname()[_INC],[$1/include])
+  fi
+  if test -n "$4" -a -d "$1/lib" -a -f "$1/lib/$4" ; then
+    AC_SUBST(allcapsname()[_LIB],[$1/lib])
+  fi
+fi
+])
+
+dnl Find a program via --with options, in the path, or well known places
+dnl
+dnl Parameters:
+dnl   $1 - program's executable name
+dnl   $2 - header file name to check (optional)
+dnl   $3 - library file name to check (optional)
+dnl   $4 - alternate (long) name for the program
+AC_DEFUN([FIND_STD_PROGRAM],
+[m4_define([allcapsname],translit($1,a-z,A-Z))
+m4_define([stdprog_long_name],ifelse($4,,translit($1,[ !@#$%^&*()-+={}[]:;"',./?],[-]),translit($4,[ !@#$%^&*()-+={}[]:;"',./?],[-])))
+AC_MSG_CHECKING([for ]stdprog_long_name()[ bin/lib/include locations])
+AC_ARG_WITH($1,
+  AS_HELP_STRING([--with-]stdprog_long_name()[=DIR],
+  [Specify that the ]stdprog_long_name()[ install prefix is DIR]),
+  $1[pfxdir=$withval],$1[pfxdir=nada])
+AC_ARG_WITH($1[-bin],
+  AS_HELP_STRING([--with-]stdprog_long_name()[-bin=DIR],
+  [Specify that the ]stdprog_long_name()[ binary is in DIR]),
+    $1[bindir=$withval],$1[bindir=nada])
+AC_ARG_WITH($1[-lib],
+  AS_HELP_STRING([--with-]stdprog_long_name()[-lib=DIR],
+  [Specify that ]stdprog_long_name()[ libraries are in DIR]),
+  $1[libdir=$withval],$1[libdir=nada])
+AC_ARG_WITH($1[-inc],
+  AS_HELP_STRING([--with-]stdprog_long_name()[-inc=DIR],
+  [Specify that the ]stdprog_long_name()[ includes are in DIR]),
+  $1[incdir=$withval],$1[incdir=nada])
+eval pfxval=\$\{$1pfxdir\}
+eval binval=\$\{$1bindir\}
+eval incval=\$\{$1incdir\}
+eval libvar=\$\{$1libdir\}
+if test "${pfxval}" != "nada" ; then
+  CHECK_STD_PROGRAM(${pfxval},$1,$2,$3)
+elif test "${binval}" != "nada" ; then
+  if test "${libval}" != "nada" ; then
+    if test "${incval}" != "nada" ; then
+      if test -d "${binval}" ; then
+        if test -d "${incval}" ; then
+          if test -d "${libval}" ; then
+            AC_SUBST(allcapsname(),${binval}/$1)
+            AC_SUBST(allcapsname()[_BIN],${binval})
+            AC_SUBST(allcapsname()[_INC],${incval})
+            AC_SUBST(allcapsname()[_LIB],${libval})
+            AC_SUBST([USE_]allcapsname(),[1])
+            AC_MSG_RESULT([found via --with options])
+          else
+            AC_MSG_RESULT([failed])
+            AC_MSG_ERROR([The --with-]$1[-libdir value must be a directory])
+          fi
+        else
+          AC_MSG_RESULT([failed])
+          AC_MSG_ERROR([The --with-]$1[-incdir value must be a directory])
+        fi
+      else
+        AC_MSG_RESULT([failed])
+        AC_MSG_ERROR([The --with-]$1[-bindir value must be a directory])
+      fi
+    else
+      AC_MSG_RESULT([failed])
+      AC_MSG_ERROR([The --with-]$1[-incdir option must be specified])
+    fi
+  else
+    AC_MSG_RESULT([failed])
+    AC_MSG_ERROR([The --with-]$1[-libdir option must be specified])
+  fi
+else
+  tmppfxdir=`which $1 2>&1`
+  if test -n "$tmppfxdir" -a -d "${tmppfxdir%*$1}" -a \
+          -d "${tmppfxdir%*$1}/.." ; then
+    tmppfxdir=`cd "${tmppfxdir%*$1}/.." ; pwd`
+    CHECK_STD_PROGRAM($tmppfxdir,$1,$2,$3)
+    AC_MSG_RESULT([found in PATH at ]$tmppfxdir)
+  else
+    checkresult="yes"
+    eval checkval=\$\{"USE_"allcapsname()\}
+    CHECK_STD_PROGRAM([/usr],$1,$2,$3)
+    if test -z "${checkval}" ; then
+      CHECK_STD_PROGRAM([/usr/local],$1,$2,$3)
+      if test -z "${checkval}" ; then
+        CHECK_STD_PROGRAM([/sw],$1,$2,$3)
+        if test -z "${checkval}" ; then
+          CHECK_STD_PROGRAM([/opt],$1,$2,$3)
+          if test -z "${checkval}" ; then
+            CHECK_STD_PROGRAM([/],$1,$2,$3)
+            if test -z "${checkval}" ; then
+              checkresult="no"
+            fi
+          fi
+        fi
+      fi
+    fi
+    AC_MSG_RESULT($checkresult)
+  fi
+fi
+])

llvm/autoconf/m4/sanity_check.m4

@@ -0,0 +1,22 @@
+dnl Check a program for version sanity. The test runs a program, passes it an
+dnl argument to make it print out some identification string, and filters that 
+dnl output with a regular expression. If the output is non-empty, the program
+dnl passes the sanity check.
+dnl   $1 - Name or full path of the program to run
+dnl   $2 - Argument to pass to print out identification string
+dnl   $3 - grep RE to match identification string
+AC_DEFUN([CHECK_PROGRAM_SANITY],
+[
+AC_MSG_CHECKING([sanity for program ]$1)
+sanity_path=`which $1 2>/dev/null`
+if test "$?" -eq 0 -a -x "$sanity_path" ; then
+  sanity=`$1 $2 2>&1 | grep "$3"`
+  if test -z "$sanity" ; then
+    AC_MSG_RESULT([no])
+    AC_MSG_ERROR([Program ]$1[ failed to pass sanity check.])
+  fi
+  AC_MSG_RESULT([yes])
+else
+  AC_MSG_RESULT([not found])
+fi
+])

llvm/configure

@@ -1,6 +1,6 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.59 for llvm 1.5cvs.
+# Generated by GNU Autoconf 2.59 for llvm 1.6.
 #
 # Report bugs to <llvmbugs@cs.uiuc.edu>.
 #
@@ -8,7 +8,7 @@
 # This configure script is free software; the Free Software Foundation
 # gives unlimited permission to copy, distribute and modify it.
 #
-# $LLVM_COPYRIGHT
+# Copyright (c) 2003-2005 University of Illinois at Urbana-Champaign.
 ## --------------------- ##
 ## M4sh Initialization.  ##
 ## --------------------- ##
@@ -425,8 +425,8 @@ SHELL=${CONFIG_SHELL-/bin/sh}
 # Identity of this package.
 PACKAGE_NAME='llvm'
 PACKAGE_TARNAME='-llvm-'
-PACKAGE_VERSION='1.5cvs'
-PACKAGE_STRING='llvm 1.5cvs'
+PACKAGE_VERSION='1.6'
+PACKAGE_STRING='llvm 1.6'
 PACKAGE_BUGREPORT='llvmbugs@cs.uiuc.edu'
 
 ac_unique_file="lib/VMCore/Module.cpp"
@@ -475,7 +475,7 @@ ac_includes_default="\
 # include <unistd.h>
 #endif"
 
-ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS LLVM_COPYRIGHT subdirs build build_cpu build_vendor build_os host host_cpu host_vendor host_os target target_cpu target_vendor target_os OS LLVM_ON_UNIX LLVM_ON_WIN32 ARCH ENDIAN CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT ENABLE_OPTIMIZED JIT ENABLE_DOXYGEN TARGETS_TO_BUILD CPP CXX CXXFLAGS ac_ct_CXX LEX LEXLIB LEX_OUTPUT_ROOT FLEX YACC BISON ifGNUmake LN_S CMP CP DATE FIND GREP MKDIR MV RANLIB ac_ct_RANLIB RM SED TAR INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA BZIP2 DOT DOXYGEN ETAGS GROFF GZIP POD2HTML POD2MAN RUNTEST TCLSH ZIP EGREP INSTALL_LTDL_TRUE INSTALL_LTDL_FALSE CONVENIENCE_LTDL_TRUE CONVENIENCE_LTDL_FALSE LIBADD_DL ECHO AR ac_ct_AR STRIP ac_ct_STRIP CXXCPP F77 FFLAGS ac_ct_F77 LIBTOOL ETAGSFLAGS LLVMGCC LLVMGXX ALLOCA MMAP_FILE LLVMCC1 LLVMCC1PLUS LLVMGCCDIR SHLIBEXT LLVM_PREFIX LLVM_BINDIR LLVM_LIBDIR LLVM_DATADIR LLVM_DOCSDIR LLVM_ETCDIR LLVM_INCLUDEDIR LLVM_INFODIR LLVM_MANDIR LLVM_CONFIGTIME LIBOBJS LTLIBOBJS'
+ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS LLVM_COPYRIGHT subdirs build build_cpu build_vendor build_os host host_cpu host_vendor host_os target target_cpu target_vendor target_os OS LLVM_ON_UNIX LLVM_ON_WIN32 ARCH ENDIAN CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT ENABLE_OPTIMIZED JIT ENABLE_DOXYGEN ENABLE_THREADS TARGETS_TO_BUILD CPP CXX CXXFLAGS ac_ct_CXX LEX LEXLIB LEX_OUTPUT_ROOT FLEX YACC BISON ifGNUmake LN_S CMP CP DATE FIND GREP MKDIR MV RANLIB ac_ct_RANLIB RM SED TAR GRAPHVIZ GV INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA BZIP2 DOT DOXYGEN ETAGS GROFF GZIP POD2HTML POD2MAN RUNTEST TCLSH ZIP EGREP INSTALL_LTDL_TRUE INSTALL_LTDL_FALSE CONVENIENCE_LTDL_TRUE CONVENIENCE_LTDL_FALSE LIBADD_DL ECHO AR ac_ct_AR STRIP ac_ct_STRIP CXXCPP F77 FFLAGS ac_ct_F77 LIBTOOL ETAGSFLAGS LLVMGCC LLVMGXX ALLOCA MMAP_FILE LLVMCC1 LLVMCC1PLUS LLVMGCCDIR SHLIBEXT LLVM_PREFIX LLVM_BINDIR LLVM_LIBDIR LLVM_DATADIR LLVM_DOCSDIR LLVM_ETCDIR LLVM_INCLUDEDIR LLVM_INFODIR LLVM_MANDIR LLVM_CONFIGTIME LIBOBJS LTLIBOBJS'
 ac_subst_files=''
 
 # Initialize some variables set by options.
@@ -964,7 +964,7 @@ if test "$ac_init_help" = "long"; then
   # Omit some internal or obsolete options to make the list less imposing.
   # This message is too long to be a string in the A/UX 3.1 sh.
   cat <<_ACEOF
-\`configure' configures llvm 1.5cvs to adapt to many kinds of systems.
+\`configure' configures llvm 1.6 to adapt to many kinds of systems.
 
 Usage: $0 [OPTION]... [VAR=VALUE]...
 
@@ -1026,7 +1026,7 @@ fi
 
 if test -n "$ac_init_help"; then
   case $ac_init_help in
-     short | recursive ) echo "Configuration of llvm 1.5cvs:";;
+     short | recursive ) echo "Configuration of llvm 1.6:";;
    esac
   cat <<\_ACEOF
 
@@ -1036,6 +1036,7 @@ Optional Features:
   --enable-optimized
   --enable-jit            Enable Just In Time Compiling (default is YES)
   --enable-doxygen        Build doxygen documentation (default is NO)
+  --enable-threads        Use threads if available (default is YES)
   --enable-target         Build specific host targets:
                           all,host-only,{target-name} (default=all)
   --enable-ltdl-install   install libltdl
@@ -1172,14 +1173,14 @@ fi
 test -n "$ac_init_help" && exit 0
 if $ac_init_version; then
   cat <<\_ACEOF
-llvm configure 1.5cvs
+llvm configure 1.6
 generated by GNU Autoconf 2.59
 
 Copyright (C) 2003 Free Software Foundation, Inc.
 This configure script is free software; the Free Software Foundation
 gives unlimited permission to copy, distribute and modify it.
 
-$LLVM_COPYRIGHT
+Copyright (c) 2003-2005 University of Illinois at Urbana-Champaign.
 _ACEOF
   exit 0
 fi
@@ -1188,7 +1189,7 @@ cat >&5 <<_ACEOF
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
-It was created by llvm $as_me 1.5cvs, which was
+It was created by llvm $as_me 1.6, which was
 generated by GNU Autoconf 2.59.  Invocation command line was
 
   $ $0 $@
@@ -1774,12 +1775,6 @@ _ACEOF
     ;;
 esac
 
-case $target in
-  sparc*-*-solaris*)  target=sparcv9-sun-solaris2.8
-
-  ;;
-esac
-
 echo "$as_me:$LINENO: checking target architecture" >&5
 echo $ECHO_N "checking target architecture... $ECHO_C" >&6
 if test "${llvm_cv_target_arch+set}" = set; then
@@ -3003,7 +2998,7 @@ else
  ;;
     x86_64)  JIT=
  ;;
-    Alpha)   JIT=
+    Alpha)   JIT=TARGET_HAS_JIT=1
  ;;
     IA64)    JIT=
  ;;
@@ -3031,6 +3026,28 @@ echo "$as_me: error: Invalid setting for --enable-doxygen. Use \"yes\" or \"no\"
    { (exit 1); exit 1; }; } ;;
 esac
 
+# Check whether --enable-threads or --disable-threads was given.
+if test "${enable_threads+set}" = set; then
+  enableval="$enable_threads"
+
+else
+  enableval=yes
+fi;
+case "$enableval" in
+  yes) ENABLE_THREADS=1
+ ;;
+  no)  ENABLE_THREADS=0
+ ;;
+  *) { { echo "$as_me:$LINENO: error: Invalid setting for --enable-threads. Use \"yes\" or \"no\"" >&5
+echo "$as_me: error: Invalid setting for --enable-threads. Use \"yes\" or \"no\"" >&2;}
+   { (exit 1); exit 1; }; } ;;
+esac
+
+cat >>confdefs.h <<_ACEOF
+#define ENABLE_THREADS $ENABLE_THREADS
+_ACEOF
+
+
 TARGETS_TO_BUILD=""
 # Check whether --enable-targets or --disable-targets was given.
 if test "${enable_targets+set}" = set; then
@@ -5060,6 +5077,110 @@ else
 echo "${ECHO_T}no" >&6
 fi
 
+# Extract the first word of "Graphviz", so it can be a program name with args.
+set dummy Graphviz; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_path_GRAPHVIZ+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  case $GRAPHVIZ in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_GRAPHVIZ="$GRAPHVIZ" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_path_GRAPHVIZ="$as_dir/$ac_word$ac_exec_ext"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+  test -z "$ac_cv_path_GRAPHVIZ" && ac_cv_path_GRAPHVIZ="echo Graphviz"
+  ;;
+esac
+fi
+GRAPHVIZ=$ac_cv_path_GRAPHVIZ
+
+if test -n "$GRAPHVIZ"; then
+  echo "$as_me:$LINENO: result: $GRAPHVIZ" >&5
+echo "${ECHO_T}$GRAPHVIZ" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+if test "$GRAPHVIZ" != "echo Graphviz" ; then
+
+cat >>confdefs.h <<\_ACEOF
+#define HAVE_GRAPHVIZ 1
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define LLVM_PATH_GRAPHVIZ "$GRAPHVIZ"
+_ACEOF
+
+fi
+# Extract the first word of "gv", so it can be a program name with args.
+set dummy gv; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_path_GV+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  case $GV in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_GV="$GV" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_path_GV="$as_dir/$ac_word$ac_exec_ext"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+  test -z "$ac_cv_path_GV" && ac_cv_path_GV="echo gv"
+  ;;
+esac
+fi
+GV=$ac_cv_path_GV
+
+if test -n "$GV"; then
+  echo "$as_me:$LINENO: result: $GV" >&5
+echo "${ECHO_T}$GV" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+if test "$GRAPHVIZ" != "echo gv" ; then
+
+cat >>confdefs.h <<\_ACEOF
+#define HAVE_GV 1
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define LLVM_PATH_GV "$GV"
+_ACEOF
+
+fi
 
 # Find a good install program.  We prefer a C program (faster),
 # so one script is as good as another.  But avoid the broken or
@@ -8235,7 +8356,7 @@ else
   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
   lt_status=$lt_dlunknown
   cat > conftest.$ac_ext <<EOF
-#line 8238 "configure"
+#line 8359 "configure"
 #include "confdefs.h"
 
 #if HAVE_DLFCN_H
@@ -10226,7 +10347,7 @@ ia64-*-hpux*)
   ;;
 *-*-irix6*)
   # Find out which ABI we are using.
-  echo '#line 10229 "configure"' > conftest.$ac_ext
+  echo '#line 10350 "configure"' > conftest.$ac_ext
   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
@@ -10711,7 +10832,7 @@ fi
 
 
 # Provide some information about the compiler.
-echo "$as_me:10714:" \
+echo "$as_me:10835:" \
      "checking for Fortran 77 compiler version" >&5
 ac_compiler=`set X $ac_compile; echo $2`
 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
@@ -11768,11 +11889,11 @@ else
    -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:11771: $lt_compile\"" >&5)
+   (eval echo "\"\$as_me:11892: $lt_compile\"" >&5)
    (eval "$lt_compile" 2>conftest.err)
    ac_status=$?
    cat conftest.err >&5
-   echo "$as_me:11775: \$? = $ac_status" >&5
+   echo "$as_me:11896: \$? = $ac_status" >&5
    if (exit $ac_status) && test -s "$ac_outfile"; then
      # The compiler can only warn and ignore the option if not recognized
      # So say no if there are warnings
@@ -12011,11 +12132,11 @@ else
    -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:12014: $lt_compile\"" >&5)
+   (eval echo "\"\$as_me:12135: $lt_compile\"" >&5)
    (eval "$lt_compile" 2>conftest.err)
    ac_status=$?
    cat conftest.err >&5
-   echo "$as_me:12018: \$? = $ac_status" >&5
+   echo "$as_me:12139: \$? = $ac_status" >&5
    if (exit $ac_status) && test -s "$ac_outfile"; then
      # The compiler can only warn and ignore the option if not recognized
      # So say no if there are warnings
@@ -12071,11 +12192,11 @@ else
    -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:12074: $lt_compile\"" >&5)
+   (eval echo "\"\$as_me:12195: $lt_compile\"" >&5)
    (eval "$lt_compile" 2>out/conftest.err)
    ac_status=$?
    cat out/conftest.err >&5
-   echo "$as_me:12078: \$? = $ac_status" >&5
+   echo "$as_me:12199: \$? = $ac_status" >&5
    if (exit $ac_status) && test -s out/conftest2.$ac_objext
    then
      # The compiler can only warn and ignore the option if not recognized
@@ -14256,7 +14377,7 @@ else
   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
   lt_status=$lt_dlunknown
   cat > conftest.$ac_ext <<EOF
-#line 14259 "configure"
+#line 14380 "configure"
 #include "confdefs.h"
 
 #if HAVE_DLFCN_H
@@ -14354,7 +14475,7 @@ else
   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
   lt_status=$lt_dlunknown
   cat > conftest.$ac_ext <<EOF
-#line 14357 "configure"
+#line 14478 "configure"
 #include "confdefs.h"
 
 #if HAVE_DLFCN_H
@@ -16547,11 +16668,11 @@ else
    -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:16550: $lt_compile\"" >&5)
+   (eval echo "\"\$as_me:16671: $lt_compile\"" >&5)
    (eval "$lt_compile" 2>conftest.err)
    ac_status=$?
    cat conftest.err >&5
-   echo "$as_me:16554: \$? = $ac_status" >&5
+   echo "$as_me:16675: \$? = $ac_status" >&5
    if (exit $ac_status) && test -s "$ac_outfile"; then
      # The compiler can only warn and ignore the option if not recognized
      # So say no if there are warnings
@@ -16607,11 +16728,11 @@ else
    -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:16610: $lt_compile\"" >&5)
+   (eval echo "\"\$as_me:16731: $lt_compile\"" >&5)
    (eval "$lt_compile" 2>out/conftest.err)
    ac_status=$?
    cat out/conftest.err >&5
-   echo "$as_me:16614: \$? = $ac_status" >&5
+   echo "$as_me:16735: \$? = $ac_status" >&5
    if (exit $ac_status) && test -s out/conftest2.$ac_objext
    then
      # The compiler can only warn and ignore the option if not recognized
@@ -17968,7 +18089,7 @@ else
   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
   lt_status=$lt_dlunknown
   cat > conftest.$ac_ext <<EOF
-#line 17971 "configure"
+#line 18092 "configure"
 #include "confdefs.h"
 
 #if HAVE_DLFCN_H
@@ -18066,7 +18187,7 @@ else
   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
   lt_status=$lt_dlunknown
   cat > conftest.$ac_ext <<EOF
-#line 18069 "configure"
+#line 18190 "configure"
 #include "confdefs.h"
 
 #if HAVE_DLFCN_H
@@ -18903,11 +19024,11 @@ else
    -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:18906: $lt_compile\"" >&5)
+   (eval echo "\"\$as_me:19027: $lt_compile\"" >&5)
    (eval "$lt_compile" 2>conftest.err)
    ac_status=$?
    cat conftest.err >&5
-   echo "$as_me:18910: \$? = $ac_status" >&5
+   echo "$as_me:19031: \$? = $ac_status" >&5
    if (exit $ac_status) && test -s "$ac_outfile"; then
      # The compiler can only warn and ignore the option if not recognized
      # So say no if there are warnings
@@ -18963,11 +19084,11 @@ else
    -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:18966: $lt_compile\"" >&5)
+   (eval echo "\"\$as_me:19087: $lt_compile\"" >&5)
    (eval "$lt_compile" 2>out/conftest.err)
    ac_status=$?
    cat out/conftest.err >&5
-   echo "$as_me:18970: \$? = $ac_status" >&5
+   echo "$as_me:19091: \$? = $ac_status" >&5
    if (exit $ac_status) && test -s out/conftest2.$ac_objext
    then
      # The compiler can only warn and ignore the option if not recognized
@@ -21002,11 +21123,11 @@ else
    -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:21005: $lt_compile\"" >&5)
+   (eval echo "\"\$as_me:21126: $lt_compile\"" >&5)
    (eval "$lt_compile" 2>conftest.err)
    ac_status=$?
    cat conftest.err >&5
-   echo "$as_me:21009: \$? = $ac_status" >&5
+   echo "$as_me:21130: \$? = $ac_status" >&5
    if (exit $ac_status) && test -s "$ac_outfile"; then
      # The compiler can only warn and ignore the option if not recognized
      # So say no if there are warnings
@@ -21245,11 +21366,11 @@ else
    -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:21248: $lt_compile\"" >&5)
+   (eval echo "\"\$as_me:21369: $lt_compile\"" >&5)
    (eval "$lt_compile" 2>conftest.err)
    ac_status=$?
    cat conftest.err >&5
-   echo "$as_me:21252: \$? = $ac_status" >&5
+   echo "$as_me:21373: \$? = $ac_status" >&5
    if (exit $ac_status) && test -s "$ac_outfile"; then
      # The compiler can only warn and ignore the option if not recognized
      # So say no if there are warnings
@@ -21305,11 +21426,11 @@ else
    -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:21308: $lt_compile\"" >&5)
+   (eval echo "\"\$as_me:21429: $lt_compile\"" >&5)
    (eval "$lt_compile" 2>out/conftest.err)
    ac_status=$?
    cat out/conftest.err >&5
-   echo "$as_me:21312: \$? = $ac_status" >&5
+   echo "$as_me:21433: \$? = $ac_status" >&5
    if (exit $ac_status) && test -s out/conftest2.$ac_objext
    then
      # The compiler can only warn and ignore the option if not recognized
@@ -23490,7 +23611,7 @@ else
   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
   lt_status=$lt_dlunknown
   cat > conftest.$ac_ext <<EOF
-#line 23493 "configure"
+#line 23614 "configure"
 #include "confdefs.h"
 
 #if HAVE_DLFCN_H
@@ -23588,7 +23709,7 @@ else
   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
   lt_status=$lt_dlunknown
   cat > conftest.$ac_ext <<EOF
-#line 23591 "configure"
+#line 23712 "configure"
 #include "confdefs.h"
 
 #if HAVE_DLFCN_H
@@ -24625,8 +24746,10 @@ ETAGSFLAGS=$ETAGSFLAGS
 
 
 if test "$WITH_LLVMGCCDIR" = "default" ; then
-  # Extract the first word of "llvm-gcc", so it can be a program name with args.
-set dummy llvm-gcc; ac_word=$2
+  LLVMGCC="llvm-gcc${EXEEXT}"
+  LLVMGXX="llvm-g++${EXEEXT}"
+  # Extract the first word of "$LLVMGCC", so it can be a program name with args.
+set dummy $LLVMGCC; ac_word=$2
 echo "$as_me:$LINENO: checking for $ac_word" >&5
 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 if test "${ac_cv_path_LLVMGCC+set}" = set; then
@@ -24664,8 +24787,8 @@ else
 echo "${ECHO_T}no" >&6
 fi
 
-  # Extract the first word of "llvm-g++", so it can be a program name with args.
-set dummy llvm-g++; ac_word=$2
+  # Extract the first word of "$LLVMGXX", so it can be a program name with args.
+set dummy $LLVMGXX; ac_word=$2
 echo "$as_me:$LINENO: checking for $ac_word" >&5
 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 if test "${ac_cv_path_LLVMGXX+set}" = set; then
@@ -24704,8 +24827,8 @@ echo "${ECHO_T}no" >&6
 fi
 
 else
-  LLVMGCC=$WITH_LLVMGCCDIR/bin/llvm-gcc
-  LLVMGXX=$WITH_LLVMGCCDIR/bin/llvm-g++
+  LLVMGCC="$WITH_LLVMGCCDIR/bin/llvm-gcc${EXEEXT}"
+  LLVMGXX="$WITH_LLVMGCCDIR/bin/llvm-g++${EXEEXT}"
   LLVMGCC=$LLVMGCC
 
   LLVMGXX=$LLVMGXX
@@ -24742,7 +24865,7 @@ fi
 
 if test "$GCC" = "yes"
 then
-  gccmajor=`$CC --version | head -n 1 | awk '{print $NF;}' | cut -d. -f1`
+  gccmajor=`$CC --version | head -n 1 | sed 's/[^0-9]*\([0-9.]\).*/\1/'`
   if test "$gccmajor" -lt "3"
   then
     { { echo "$as_me:$LINENO: error: gcc 3.x required, but you have a lower version" >&5
@@ -24837,6 +24960,7 @@ _ACEOF
 fi
 
 
+
 echo "$as_me:$LINENO: checking for library containing lt_dlopen" >&5
 echo $ECHO_N "checking for library containing lt_dlopen... $ECHO_C" >&6
 if test "${ac_cv_search_lt_dlopen+set}" = set; then
@@ -25238,7 +25362,82 @@ _ACEOF
 fi
 
 
-echo "$as_me:$LINENO: checking for library containing pthread_mutex_lock" >&5
+if test "$ENABLE_THREADS" -eq 1 ; then
+
+echo "$as_me:$LINENO: checking for pthread_mutex_init in -lpthread" >&5
+echo $ECHO_N "checking for pthread_mutex_init in -lpthread... $ECHO_C" >&6
+if test "${ac_cv_lib_pthread_pthread_mutex_init+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lpthread  $LIBS"
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char pthread_mutex_init ();
+int
+main ()
+{
+pthread_mutex_init ();
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_lib_pthread_pthread_mutex_init=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_lib_pthread_pthread_mutex_init=no
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+echo "$as_me:$LINENO: result: $ac_cv_lib_pthread_pthread_mutex_init" >&5
+echo "${ECHO_T}$ac_cv_lib_pthread_pthread_mutex_init" >&6
+if test $ac_cv_lib_pthread_pthread_mutex_init = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_LIBPTHREAD 1
+_ACEOF
+
+  LIBS="-lpthread $LIBS"
+
+fi
+
+  echo "$as_me:$LINENO: checking for library containing pthread_mutex_lock" >&5
 echo $ECHO_N "checking for library containing pthread_mutex_lock... $ECHO_C" >&6
 if test "${ac_cv_search_pthread_mutex_lock+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -25368,6 +25567,7 @@ _ACEOF
 
 fi
 
+fi
 
 
 
@@ -26752,6 +26952,158 @@ fi
 
 done
 
+if test "$ENABLE_THREADS" -eq 1 ; then
+
+for ac_header in pthread.h
+do
+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo "$as_me:$LINENO: checking for $ac_header" >&5
+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+else
+  # Is the header compilable?
+echo "$as_me:$LINENO: checking $ac_header usability" >&5
+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+$ac_includes_default
+#include <$ac_header>
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_header_compiler=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_header_compiler=no
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+echo "${ECHO_T}$ac_header_compiler" >&6
+
+# Is the header present?
+echo "$as_me:$LINENO: checking $ac_header presence" >&5
+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <$ac_header>
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null; then
+  if test -s conftest.err; then
+    ac_cpp_err=$ac_c_preproc_warn_flag
+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+  else
+    ac_cpp_err=
+  fi
+else
+  ac_cpp_err=yes
+fi
+if test -z "$ac_cpp_err"; then
+  ac_header_preproc=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  ac_header_preproc=no
+fi
+rm -f conftest.err conftest.$ac_ext
+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+echo "${ECHO_T}$ac_header_preproc" >&6
+
+# So?  What about this header?
+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+  yes:no: )
+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
+echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
+    ac_header_preproc=yes
+    ;;
+  no:yes:* )
+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
+echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
+echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
+echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+    (
+      cat <<\_ASBOX
+## ----------------------------------- ##
+## Report this to llvmbugs@cs.uiuc.edu ##
+## ----------------------------------- ##
+_ASBOX
+    ) |
+      sed "s/^/$as_me: WARNING:     /" >&2
+    ;;
+esac
+echo "$as_me:$LINENO: checking for $ac_header" >&5
+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  eval "$as_ac_Header=\$ac_header_preproc"
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+
+fi
+if test `eval echo '${'$as_ac_Header'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+
+done
+
+fi
 
 
 echo "$as_me:$LINENO: checking for pid_t" >&5
@@ -30268,24 +30620,18 @@ _ACEOF
 
           ac_config_headers="$ac_config_headers include/llvm/Config/config.h"
 
-
           ac_config_headers="$ac_config_headers include/llvm/Support/DataTypes.h"
 
           ac_config_headers="$ac_config_headers include/llvm/ADT/hash_map"
 
           ac_config_headers="$ac_config_headers include/llvm/ADT/hash_set"
 
-          ac_config_headers="$ac_config_headers include/llvm/Support/ThreadSupport.h"
-
           ac_config_headers="$ac_config_headers include/llvm/ADT/iterator"
 
 
           ac_config_files="$ac_config_files Makefile.config"
 
 
-                                        ac_config_files="$ac_config_files tools/llvmc/st tools/llvmc/cpp tools/llvmc/ll tools/llvmc/c"
-
-
           ac_config_files="$ac_config_files docs/doxygen.cfg"
 
 
@@ -30698,7 +31044,7 @@ _ASBOX
 } >&5
 cat >&5 <<_CSEOF
 
-This file was extended by llvm $as_me 1.5cvs, which was
+This file was extended by llvm $as_me 1.6, which was
 generated by GNU Autoconf 2.59.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
@@ -30761,7 +31107,7 @@ _ACEOF
 
 cat >>$CONFIG_STATUS <<_ACEOF
 ac_cs_version="\\
-llvm config.status 1.5cvs
+llvm config.status 1.6
 configured by $0, generated by GNU Autoconf 2.59,
   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
 
@@ -30872,10 +31218,6 @@ do
   case "$ac_config_target" in
   # Handling of arguments.
   "Makefile.config" ) CONFIG_FILES="$CONFIG_FILES Makefile.config" ;;
-  "tools/llvmc/st" ) CONFIG_FILES="$CONFIG_FILES tools/llvmc/st" ;;
-  "tools/llvmc/cpp" ) CONFIG_FILES="$CONFIG_FILES tools/llvmc/cpp" ;;
-  "tools/llvmc/ll" ) CONFIG_FILES="$CONFIG_FILES tools/llvmc/ll" ;;
-  "tools/llvmc/c" ) CONFIG_FILES="$CONFIG_FILES tools/llvmc/c" ;;
   "docs/doxygen.cfg" ) CONFIG_FILES="$CONFIG_FILES docs/doxygen.cfg" ;;
   "setup" ) CONFIG_COMMANDS="$CONFIG_COMMANDS setup" ;;
   "Makefile" ) CONFIG_COMMANDS="$CONFIG_COMMANDS Makefile" ;;
@@ -30892,7 +31234,6 @@ do
   "include/llvm/Support/DataTypes.h" ) CONFIG_HEADERS="$CONFIG_HEADERS include/llvm/Support/DataTypes.h" ;;
   "include/llvm/ADT/hash_map" ) CONFIG_HEADERS="$CONFIG_HEADERS include/llvm/ADT/hash_map" ;;
   "include/llvm/ADT/hash_set" ) CONFIG_HEADERS="$CONFIG_HEADERS include/llvm/ADT/hash_set" ;;
-  "include/llvm/Support/ThreadSupport.h" ) CONFIG_HEADERS="$CONFIG_HEADERS include/llvm/Support/ThreadSupport.h" ;;
   "include/llvm/ADT/iterator" ) CONFIG_HEADERS="$CONFIG_HEADERS include/llvm/ADT/iterator" ;;
   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
@@ -31008,6 +31349,7 @@ s,@OBJEXT@,$OBJEXT,;t t
 s,@ENABLE_OPTIMIZED@,$ENABLE_OPTIMIZED,;t t
 s,@JIT@,$JIT,;t t
 s,@ENABLE_DOXYGEN@,$ENABLE_DOXYGEN,;t t
+s,@ENABLE_THREADS@,$ENABLE_THREADS,;t t
 s,@TARGETS_TO_BUILD@,$TARGETS_TO_BUILD,;t t
 s,@CPP@,$CPP,;t t
 s,@CXX@,$CXX,;t t
@@ -31033,6 +31375,8 @@ s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
 s,@RM@,$RM,;t t
 s,@SED@,$SED,;t t
 s,@TAR@,$TAR,;t t
+s,@GRAPHVIZ@,$GRAPHVIZ,;t t
+s,@GV@,$GV,;t t
 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
 s,@INSTALL_DATA@,$INSTALL_DATA,;t t

llvm/docs/.cvsignore

@@ -1,2 +1,4 @@
 doxygen.cfg
-
+doxygen
+doxygen.out
+*.tar.gz

llvm/docs/BytecodeFormat.html

@@ -732,7 +732,7 @@ as shown in the following table.</p>
 </table>
 <p>
 Of particular note, the bytecode format number is simply a 28-bit
-monotonically increase integer that identifies the version of the bytecode
+monotonically increasing integer that identifies the version of the bytecode
 format (which is not directly related to the LLVM release number). The
 bytecode versions defined so far are (note that this document only
 describes the latest version, 1.3):</p>
@@ -740,7 +740,9 @@ describes the latest version, 1.3):</p>
   <li>#0: LLVM 1.0 &amp; 1.1</li>
   <li>#1: LLVM 1.2</li>
   <li>#2: LLVM 1.2.5 (not released)</li>
-  <li>#3: LLVM 1.3<br>
+  <li>#3: LLVM 1.3</li>
+  <li>#4: LLVM 1.3.x (not released)</li>
+  <li>#5: LLVM 1.4, 1.5, 1.6</li>
   </li>
 </ul>
 <p>Note that we plan to eventually expand the target description

llvm/docs/CFEBuildInstrs.html

@@ -68,9 +68,10 @@ located in a top-level directory (like <tt>/cygdrive/c/llvm</tt> and
 and Settings" directory).  We welcome patches to fix this issue.
 </p>
 <p>It has been found that the GCC 3.3.3 compiler provided with recent Cygwin
-versions is incapable of compiling the LLVM CFE correctly. If your Cygwin
+versions is incapable of compiling the LLVM GCC front-end correctly. If your
+Cygwin
 installation includes GCC 3.3.3, we <i>strongly</i> recommend that you download
-GCC 3.4.3, build it separately, and use it for compiling LLVM CFE. This has been
+GCC 3.4.3, build it separately, and use it for compiling the LLVM GCC front-end. This has been
 shown to work correctly.</p>
 <p>Some versions of Cygwin utilize an experimental version of GNU binutils that
 will cause the GNU <tt>ld</tt> linker to fail an assertion when linking
@@ -103,7 +104,8 @@ invalid code.  Instead, use the system assembler and linker.
 <li><p>Configure and build the LLVM libraries and tools. There are two ways to
 do this: either with <i>objdir</i> == <i>srcdir</i> or
 <i>objdir</i> != <i>srcdir</i>. It is recommended 
-that <i>srcdir</i> not be the same as <i>objdir</i>:</p>
+that <i>srcdir</i> be the same as <i>objdir</i> for your LLVM tree (but note
+that you should always use <i>srcdir</i> != <i>objdir</i> for llvm-gcc):</p>
 <ul>
   <li>With <i>objdir</i> != <i>srcdir</i>:<pre>
  % cd <i>objdir</i>
@@ -129,7 +131,7 @@ of permissions. Specify a path into which LLVM can be installed (e.g.
 </pre></li>
 
 <li><p>Unpack the C/C++ front-end source into cfrontend/src, either by
-       untar'ing an llvm-gcc.tar.gz file or checking out CVS into this
+       untar'ing a cfrontend.source.tar.gz file or checking out CVS into this
        directory.</p></li>
 
 <li><p>Make "build" and "install" directories as siblings of the "src" tree:</p>
@@ -146,6 +148,7 @@ of permissions. Specify a path into which LLVM can be installed (e.g.
 
 <p>
 <b>Linux/x86:</b><br>
+<b>Linux/IA-64:</b><br>
 <b>MacOS X/PowerPC</b> (requires dlcompat library):<br>
 <b>AIX/PowerPC:</b>
 </p>

llvm/docs/CodeGenerator.html

@@ -15,7 +15,8 @@
   <li><a href="#introduction">Introduction</a>
     <ul>
       <li><a href="#required">Required components in the code generator</a></li>
-      <li><a href="#high-level-design">The high-level design of the code generator</a></li>
+      <li><a href="#high-level-design">The high-level design of the code
+          generator</a></li>
       <li><a href="#tablegen">Using TableGen for target description</a></li>
     </ul>
   </li>
@@ -27,12 +28,16 @@
       <li><a href="#mregisterinfo">The <tt>MRegisterInfo</tt> class</a></li>
       <li><a href="#targetinstrinfo">The <tt>TargetInstrInfo</tt> class</a></li>
       <li><a href="#targetframeinfo">The <tt>TargetFrameInfo</tt> class</a></li>
+      <li><a href="#targetsubtarget">The <tt>TargetSubtarget</tt> class</a></li>
       <li><a href="#targetjitinfo">The <tt>TargetJITInfo</tt> class</a></li>
     </ul>
   </li>
   <li><a href="#codegendesc">Machine code description classes</a>
     <ul>
     <li><a href="#machineinstr">The <tt>MachineInstr</tt> class</a></li>
+    <li><a href="#machinebasicblock">The <tt>MachineBasicBlock</tt>
+                                     class</a></li>
+    <li><a href="#machinefunction">The <tt>MachineFunction</tt> class</a></li>
     </ul>
   </li>
   <li><a href="#codegenalgs">Target-independent code generation algorithms</a>
@@ -46,14 +51,21 @@
                                         Construction</a></li>
       <li><a href="#selectiondag_legalize">SelectionDAG Legalize Phase</a></li>
       <li><a href="#selectiondag_optimize">SelectionDAG Optimization
-                                           Phase</a></li>
+                                           Phase: the DAG Combiner</a></li>
       <li><a href="#selectiondag_select">SelectionDAG Select Phase</a></li>
+      <li><a href="#selectiondag_sched">SelectionDAG Scheduling and Formation
+                                        Phase</a></li>
       <li><a href="#selectiondag_future">Future directions for the
                                          SelectionDAG</a></li>
       </ul></li>
+    <li><a href="#codeemit">Code Emission</a>
+        <ul>
+        <li><a href="#codeemit_asm">Generating Assembly Code</a></li>
+        <li><a href="#codeemit_bin">Generating Binary Machine Code</a></li>
+        </ul></li>
     </ul>
   </li>
-  <li><a href="#targetimpls">Target description implementations</a>
+  <li><a href="#targetimpls">Target-specific Implementation Notes</a>
     <ul>
     <li><a href="#x86">The X86 backend</a></li>
     </ul>
@@ -159,7 +171,7 @@ LLVM machine description model: programmable FPGAs for example.</p>
 <p><b>Important Note:</b> For historical reasons, the LLVM SparcV9 code
 generator uses almost entirely different code paths than described in this
 document.  For this reason, there are some deprecated interfaces (such as
-<tt>TargetRegInfo</tt> and <tt>TargetSchedInfo</tt>), which are only used by the
+<tt>TargetSchedInfo</tt>), which are only used by the
 V9 backend and should not be used by any other targets.  Also, all code in the
 <tt>lib/Target/SparcV9</tt> directory and subdirectories should be considered
 deprecated, and should not be used as the basis for future code generator work.
@@ -181,36 +193,47 @@ quality code generation for standard register-based microprocessors.  Code
 generation in this model is divided into the following stages:</p>
 
 <ol>
-<li><b><a href="#instselect">Instruction Selection</a></b> - Determining an
-efficient implementation of the input LLVM code in the target instruction set.
+<li><b><a href="#instselect">Instruction Selection</a></b> - This phase
+determines an efficient way to express the input LLVM code in the target
+instruction set.
 This stage produces the initial code for the program in the target instruction
 set, then makes use of virtual registers in SSA form and physical registers that
 represent any required register assignments due to target constraints or calling
-conventions.</li>
+conventions.  This step turns the LLVM code into a DAG of target
+instructions.</li>
+
+<li><b><a href="#selectiondag_sched">Scheduling and Formation</a></b> - This
+phase takes the DAG of target instructions produced by the instruction selection
+phase, determines an ordering of the instructions, then emits the instructions
+as <tt><a href="#machineinstr">MachineInstr</a></tt>s with that ordering.  Note
+that we describe this in the <a href="#instselect">instruction selection
+section</a> because it operates on a <a
+href="#selectiondag_intro">SelectionDAG</a>.
+</li>
 
 <li><b><a href="#ssamco">SSA-based Machine Code Optimizations</a></b> - This 
 optional stage consists of a series of machine-code optimizations that 
 operate on the SSA-form produced by the instruction selector.  Optimizations 
-like modulo-scheduling, normal scheduling, or peephole optimization work here.
+like modulo-scheduling or peephole optimization work here.
 </li>
 
-<li><b><a name="#regalloc">Register Allocation</a></b> - The
+<li><b><a href="#regalloc">Register Allocation</a></b> - The
 target code is transformed from an infinite virtual register file in SSA form 
 to the concrete register file used by the target.  This phase introduces spill 
 code and eliminates all virtual register references from the program.</li>
 
-<li><b><a name="#proepicode">Prolog/Epilog Code Insertion</a></b> - Once the 
+<li><b><a href="#proepicode">Prolog/Epilog Code Insertion</a></b> - Once the 
 machine code has been generated for the function and the amount of stack space 
 required is known (used for LLVM alloca's and spill slots), the prolog and 
 epilog code for the function can be inserted and "abstract stack location 
 references" can be eliminated.  This stage is responsible for implementing 
 optimizations like frame-pointer elimination and stack packing.</li>
 
-<li><b><a name="latemco">Late Machine Code Optimizations</a></b> - Optimizations
+<li><b><a href="#latemco">Late Machine Code Optimizations</a></b> - Optimizations
 that operate on "final" machine code can go here, such as spill code scheduling
 and peephole optimizations.</li>
 
-<li><b><a name="codemission">Code Emission</a></b> - The final stage actually 
+<li><b><a href="#codeemit">Code Emission</a></b> - The final stage actually 
 puts out the code for the current function, either in the target assembler 
 format or in machine code.</li>
 
@@ -255,6 +278,16 @@ domain-specific and target-specific abstractions to reduce the amount of
 repetition.
 </p>
 
+<p>As LLVM continues to be developed and refined, we plan to move more and more
+of the target description to be in <tt>.td</tt> form.  Doing so gives us a
+number of advantages.  The most important is that it makes it easier to port
+LLVM, because it reduces the amount of C++ code that has to be written and the
+surface area of the code generator that needs to be understood before someone
+can get in an get something working.  Second, it is also important to us because
+it makes it easier to change things: in particular, if tables and other things
+are all emitted by tblgen, we only need to change one place (tblgen) to update
+all of the targets to a new interface.</p>
+
 </div>
 
 <!-- *********************************************************************** -->
@@ -270,8 +303,7 @@ repetition.
 target machine; independent of any particular client.  These classes are
 designed to capture the <i>abstract</i> properties of the target (such as the
 instructions and registers it has), and do not incorporate any particular pieces
-of code generation algorithms. These interfaces do not take interference graphs
-as inputs or other algorithm-specific data structures.</p>
+of code generation algorithms.</p>
 
 <p>All of the target description classes (except the <tt><a
 href="#targetdata">TargetData</a></tt> class) are designed to be subclassed by
@@ -311,8 +343,8 @@ implemented as well.</p>
 <div class="doc_text">
 
 <p>The <tt>TargetData</tt> class is the only required target description class,
-and it is the only class that is not extensible. You cannot derived  a new 
-class from it.  <tt>TargetData</tt> specifies information about how the target 
+and it is the only class that is not extensible (you cannot derived  a new 
+class from it).  <tt>TargetData</tt> specifies information about how the target 
 lays out memory for structures, the alignment requirements for various data 
 types, the size of pointers in the target, and whether the target is 
 little-endian or big-endian.</p>
@@ -329,18 +361,16 @@ little-endian or big-endian.</p>
 <p>The <tt>TargetLowering</tt> class is used by SelectionDAG based instruction
 selectors primarily to describe how LLVM code should be lowered to SelectionDAG
 operations.  Among other things, this class indicates:
-<ul><li>an initial register class to use for various ValueTypes,</li>
-  <li>which operations are natively supported by the target machine,</li>
-  <li>the return type of setcc operations, and</li>
-  <li>the type to use for shift amounts, etc</li>.
+<ul><li>an initial register class to use for various ValueTypes</li>
+  <li>which operations are natively supported by the target machine</li>
+  <li>the return type of setcc operations</li>
+  <li>the type to use for shift amounts</li>
+  <li>various high-level characteristics, like whether it is profitable to turn
+      division by a constant into a multiplication sequence</li>
 </ol></p>
 
 </div>
 
-
-    
-
-
 <!-- ======================================================================= -->
 <div class="doc_subsection">
   <a name="mregisterinfo">The <tt>MRegisterInfo</tt> class</a>
@@ -355,12 +385,12 @@ target and any interactions between the registers.</p>
 <p>Registers in the code generator are represented in the code generator by
 unsigned numbers.  Physical registers (those that actually exist in the target
 description) are unique small numbers, and virtual registers are generally
-large.</p>
+large.  Note that register #0 is reserved as a flag value.</p>
 
 <p>Each register in the processor description has an associated
-<tt>MRegisterDesc</tt> entry, which provides a textual name for the register
-(used for assembly output and debugging dumps), a set of aliases (used to
-indicate that one register overlaps with another), and some flag bits.
+<tt>TargetRegisterDesc</tt> entry, which provides a textual name for the register
+(used for assembly output and debugging dumps) and a set of aliases (used to
+indicate that one register overlaps with another).
 </p>
 
 <p>In addition to the per-register description, the <tt>MRegisterInfo</tt> class
@@ -383,11 +413,46 @@ href="TableGenFundamentals.html">TableGen</a> description of the register file.
   <a name="targetinstrinfo">The <tt>TargetInstrInfo</tt> class</a>
 </div>
 
+<div class="doc_text">
+  <p>The <tt>TargetInstrInfo</tt> class is used to describe the machine 
+  instructions supported by the target. It is essentially an array of 
+  <tt>TargetInstrDescriptor</tt> objects, each of which describes one
+  instruction the target supports. Descriptors define things like the mnemonic
+  for the opcode, the number of operands, the list of implicit register uses
+  and defs, whether the instruction has certain target-independent properties 
+  (accesses memory, is commutable, etc), and holds any target-specific flags.</p>
+</div>
+
 <!-- ======================================================================= -->
 <div class="doc_subsection">
   <a name="targetframeinfo">The <tt>TargetFrameInfo</tt> class</a>
 </div>
 
+<div class="doc_text">
+  <p>The <tt>TargetFrameInfo</tt> class is used to provide information about the
+  stack frame layout of the target. It holds the direction of stack growth, 
+  the known stack alignment on entry to each function, and the offset to the 
+  locals area.  The offset to the local area is the offset from the stack 
+  pointer on function entry to the first location where function data (local 
+  variables, spill locations) can be stored.</p>
+</div>
+
+<!-- ======================================================================= -->
+<div class="doc_subsection">
+  <a name="targetsubtarget">The <tt>TargetSubtarget</tt> class</a>
+</div>
+
+<div class="doc_text">
+  <p>
+  <p>The <tt>TargetSubtarget</tt> class is used to provide information about the
+  specific chip set being targeted.  A sub-target informs code generation of 
+  which instructions are supported, instruction latencies and instruction 
+  execution itinerary; i.e., which processing units are used, in what order, and
+  for how long.
+  </p>
+</div>
+
+
 <!-- ======================================================================= -->
 <div class="doc_subsection">
   <a name="targetjitinfo">The <tt>TargetJITInfo</tt> class</a>
@@ -403,7 +468,8 @@ href="TableGenFundamentals.html">TableGen</a> description of the register file.
 
 <p>
 At the high-level, LLVM code is translated to a machine specific representation
-formed out of MachineFunction, MachineBasicBlock, and <a 
+formed out of <a href="#machinefunction">MachineFunction</a>,
+<a href="#machinebasicblock">MachineBasicBlock</a>, and <a 
 href="#machineinstr"><tt>MachineInstr</tt></a> instances
 (defined in include/llvm/CodeGen).  This representation is completely target
 agnostic, representing instructions in their most abstract form: an opcode and a
@@ -589,6 +655,43 @@ are no virtual registers left in the code.</p>
 
 </div>
 
+<!-- ======================================================================= -->
+<div class="doc_subsection">
+  <a name="machinebasicblock">The <tt>MachineBasicBlock</tt> class</a>
+</div>
+
+<div class="doc_text">
+
+<p>The <tt>MachineBasicBlock</tt> class contains a list of machine instructions
+(<a href="#machineinstr">MachineInstr</a> instances).  It roughly corresponds to
+the LLVM code input to the instruction selector, but there can be a one-to-many
+mapping (i.e. one LLVM basic block can map to multiple machine basic blocks).
+The MachineBasicBlock class has a "<tt>getBasicBlock</tt>" method, which returns
+the LLVM basic block that it comes from.
+</p>
+
+</div>
+
+<!-- ======================================================================= -->
+<div class="doc_subsection">
+  <a name="machinefunction">The <tt>MachineFunction</tt> class</a>
+</div>
+
+<div class="doc_text">
+
+<p>The <tt>MachineFunction</tt> class contains a list of machine basic blocks
+(<a href="#machinebasicblock">MachineBasicBlock</a> instances).  It corresponds
+one-to-one with the LLVM function input to the instruction selector.  In
+addition to a list of basic blocks, the <tt>MachineFunction</tt> contains a
+the MachineConstantPool, MachineFrameInfo, MachineFunctionInfo,
+SSARegMap, and a set of live in and live out registers for the function.  See
+<tt>MachineFunction.h</tt> for more information.
+</p>
+
+</div>
+
+
+
 <!-- *********************************************************************** -->
 <div class="doc_section">
   <a name="codegenalgs">Target-independent code generation algorithms</a>
@@ -598,7 +701,7 @@ are no virtual registers left in the code.</p>
 <div class="doc_text">
 
 <p>This section documents the phases described in the <a
-href="high-level-design">high-level design of the code generator</a>.  It
+href="#high-level-design">high-level design of the code generator</a>.  It
 explains how they work and some of the rationale behind their design.</p>
 
 </div>
@@ -613,23 +716,15 @@ explains how they work and some of the rationale behind their design.</p>
 Instruction Selection is the process of translating LLVM code presented to the
 code generator into target-specific machine instructions.  There are several
 well-known ways to do this in the literature.  In LLVM there are two main forms:
-the old-style 'simple' instruction selector (which effectively peephole selects
-each LLVM instruction into a series of machine instructions), and the new
-SelectionDAG based instruction selector.
+the SelectionDAG based instruction selector framework and an old-style 'simple'
+instruction selector (which effectively peephole selects each LLVM instruction
+into a series of machine instructions).  We recommend that all targets use the
+SelectionDAG infrastructure.
 </p>
 
-<p>The 'simple' instruction selectors are tedious to write, require a lot of
-boiler plate code, and are difficult to get correct.  Additionally, any
-optimizations written for a simple instruction selector cannot be used by other
-targets.  For this reason, LLVM is moving to a new SelectionDAG based
-instruction selector, which is described in this section.  If you are starting a
-new port, we recommend that you write the instruction selector using the
-SelectionDAG infrastructure.</p>
-
-<p>In time, most of the target-specific code for instruction selection will be
-auto-generated from the target description (<tt>*.td</tt>) files.  For now, 
-however, the <a href="#selectiondag_select">Select Phase</a> must still be 
-written by hand.</p>
+<p>Portions of the DAG instruction selector are generated from the target 
+description files (<tt>*.td</tt>) files.  Eventually, we aim for the entire
+instruction selector to be generated from these <tt>.td</tt> files.</p>
 </div>
 
 <!-- _______________________________________________________________________ -->
@@ -643,8 +738,10 @@ written by hand.</p>
 The SelectionDAG provides an abstraction for code representation in a way that 
 is amenable to instruction selection using automatic techniques
 (e.g. dynamic-programming based optimal pattern matching selectors), It is also
-well suited to other phases of code generation; in particular, instruction scheduling.  Additionally, the SelectionDAG provides a host representation where a 
-large variety of very-low-level (but target-independent) 
+well suited to other phases of code generation; in particular,
+instruction scheduling (SelectionDAG's are very close to scheduling DAGs
+post-selection).  Additionally, the SelectionDAG provides a host representation
+where a large variety of very-low-level (but target-independent) 
 <a href="#selectiondag_optimize">optimizations</a> may be
 performed: ones which require extensive information about the instructions
 efficiently supported by the target.
@@ -653,11 +750,10 @@ efficiently supported by the target.
 <p>
 The SelectionDAG is a Directed-Acyclic-Graph whose nodes are instances of the
 <tt>SDNode</tt> class.  The primary payload of the <tt>SDNode</tt> is its 
-operation code (Opcode) that indicates what operation the node performs.  
+operation code (Opcode) that indicates what operation the node performs and
+the operands to the operation.
 The various operation node types are described at the top of the
-<tt>include/llvm/CodeGen/SelectionDAGNodes.h</tt> file.  Depending on the 
-operation, nodes may contain additional information (e.g. the condition code
-for a SETCC node) contained in a derived class.</p>
+<tt>include/llvm/CodeGen/SelectionDAGNodes.h</tt> file.</p>
 
 <p>Although most operations define a single value, each node in the graph may 
 define multiple values.  For example, a combined div/rem operation will define
@@ -691,8 +787,10 @@ block function, this would be the return node.
 <p>
 One important concept for SelectionDAGs is the notion of a "legal" vs. "illegal"
 DAG.  A legal DAG for a target is one that only uses supported operations and
-supported types.  On PowerPC, for example, a DAG with any values of i1, i8, i16,
-or i64 type would be illegal.  The <a href="#selectiondag_legalize">legalize</a>
+supported types.  On a 32-bit PowerPC, for example, a DAG with any values of i1,
+i8, i16,
+or i64 type would be illegal, as would a DAG that uses a SREM or UREM operation.
+The <a href="#selectiondag_legalize">legalize</a>
 phase is responsible for turning an illegal DAG into a legal DAG.
 </p>
 </div>
@@ -726,13 +824,26 @@ SelectionDAG-based instruction selection consists of the following steps:
     eliminate inefficiencies introduced by legalization.</li>
 <li><a href="#selectiondag_select">Select instructions from DAG</a> - Finally,
     the target instruction selector matches the DAG operations to target
-    instructions, emitting them and building the MachineFunction being
-    compiled.</li>
+    instructions.  This process translates the target-independent input DAG into
+    another DAG of target instructions.</li>
+<li><a href="#selectiondag_sched">SelectionDAG Scheduling and Formation</a>
+    - The last phase assigns a linear order to the instructions in the 
+    target-instruction DAG and emits them into the MachineFunction being
+    compiled.  This step uses traditional prepass scheduling techniques.</li>
 </ol>
 
 <p>After all of these steps are complete, the SelectionDAG is destroyed and the
 rest of the code generation passes are run.</p>
 
+<p>One great way to visualize what is going on here is to take advantage of a 
+few LLC command line options.  In particular, the <tt>-view-isel-dags</tt>
+option pops up a window with the SelectionDAG input to the Select phase for all
+of the code compiled (if you only get errors printed to the console while using
+this, you probably <a href="ProgrammersManual.html#ViewGraph">need to configure
+your system</a> to add support for it).  The <tt>-view-sched-dags</tt> option
+views the SelectionDAG output from the Select phase and input to the Scheduler
+phase.
+</p>
 </div>
 
 <!-- _______________________________________________________________________ -->
@@ -749,7 +860,8 @@ intent of  this pass is to expose as much low-level, target-specific details
 to the SelectionDAG as possible.  This pass is mostly hard-coded (e.g. an LLVM 
 add turns into an SDNode add while a geteelementptr is expanded into the obvious
 arithmetic). This pass requires target-specific hooks to lower calls and
-returns, varargs, etc.  For these features, the TargetLowering interface is
+returns, varargs, etc.  For these features, the <a 
+href="#targetlowering">TargetLowering</a> interface is
 used.
 </p>
 
@@ -768,34 +880,41 @@ tasks:</p>
 
 <ol>
 <li><p>Convert values of unsupported types to values of supported types.</p>
-    <p>There are two main ways of doing this: promoting a small type to a larger
-       type (e.g. f32 -&gt; f64, or i16 -&gt; i32), and breaking up large 
-       integer types
-       to smaller ones (e.g. implementing i64 with i32 operations where
-       possible).  Type conversions can insert sign and zero extensions as 
+    <p>There are two main ways of doing this: converting small types to 
+       larger types ("promoting"), and breaking up large integer types
+       into smaller ones ("expanding").  For example, a target might require
+       that all f32 values are promoted to f64 and that all i1/i8/i16 values
+       are promoted to i32.  The same target might require that all i64 values
+       be expanded into i32 values.  These changes can insert sign and zero
+       extensions as 
        needed to make sure that the final code has the same behavior as the 
        input.</p>
+    <p>A target implementation tells the legalizer which types are supported
+       (and which register class to use for them) by calling the
+       "addRegisterClass" method in its TargetLowering constructor.</p>
 </li>
 
-<li><p>Eliminate operations that are not supported by the target in a supported
-       type.</p>
-    <p>Targets often have wierd constraints, such as not supporting every
+<li><p>Eliminate operations that are not supported by the target.</p>
+    <p>Targets often have weird constraints, such as not supporting every
        operation on every supported datatype (e.g. X86 does not support byte
-       conditional moves).  Legalize takes care of either open-coding another 
-       sequence of operations to emulate the operation (this is known as
-       expansion), promoting to a larger type that supports the operation
+       conditional moves and PowerPC does not support sign-extending loads from
+       a 16-bit memory location).  Legalize takes care by open-coding
+       another sequence of operations to emulate the operation ("expansion"), by
+       promoting to a larger type that supports the operation
        (promotion), or using a target-specific hook to implement the
-       legalization.</p>
+       legalization (custom).</p>
+    <p>A target implementation tells the legalizer which operations are not
+       supported (and which of the above three actions to take) by calling the
+       "setOperationAction" method in its TargetLowering constructor.</p>
 </li>
 </ol>
 
 <p>
-Instead of using a Legalize pass, we could require that every target-specific 
-<a href="#selectiondag_optimize">selector</a> supports and expands every 
-operator and type even if they are not supported and may require many 
-instructions to implement (in fact, this is the approach taken by the 
-"simple" selectors).  However, using a Legalize pass allows all of the 
-cannonicalization patterns to be shared across targets which makes it very 
+Prior to the existance of the Legalize pass, we required that every
+target <a href="#selectiondag_optimize">selector</a> supported and handled every
+operator and type even if they are not natively supported.  The introduction of
+the Legalize phase allows all of the 
+cannonicalization patterns to be shared across targets, and makes it very 
 easy to optimize the cannonicalized code because it is still in the form of 
 a DAG.
 </p>
@@ -804,7 +923,8 @@ a DAG.
 
 <!-- _______________________________________________________________________ -->
 <div class="doc_subsubsection">
-  <a name="selectiondag_optimize">SelectionDAG Optimization Phase</a>
+  <a name="selectiondag_optimize">SelectionDAG Optimization Phase: the DAG
+  Combiner</a>
 </div>
 
 <div class="doc_text">
@@ -815,13 +935,14 @@ immediately after the DAG is built and once after legalization.  The first run
 of the pass allows the initial code to be cleaned up (e.g. performing 
 optimizations that depend on knowing that the operators have restricted type 
 inputs).  The second run of the pass cleans up the messy code generated by the 
-Legalize pass, allowing Legalize to be very simple since it can ignore many 
-special cases. 
+Legalize pass, which allows Legalize to be very simple (it can focus on making
+code legal instead of focusing on generating <i>good</i> and legal code).
 </p>
 
 <p>
-One important class of optimizations that this pass will do in the future is
-optimizing inserted sign and zero extension instructions.  Here are some good
+One important class of optimizations performed is optimizing inserted sign and
+zero extension instructions.  We currently use ad-hoc techniques, but could move
+to more rigorous techniques in the future.  Here are some good
 papers on the subject:</p>
 
 <p>
@@ -850,10 +971,155 @@ International Conference on Compiler Construction (CC) 2004
 <div class="doc_text">
 
 <p>The Select phase is the bulk of the target-specific code for instruction
-selection.  This phase takes a legal SelectionDAG as input, and does simple
-pattern matching on the DAG to generate code.  In time, the Select phase will
-be automatically generated from the target's InstrInfo.td file, which is why we
-want to make the Select phase as simple and mechanical as possible.</p>
+selection.  This phase takes a legal SelectionDAG as input,
+pattern matches the instructions supported by the target to this DAG, and
+produces a new DAG of target code.  For example, consider the following LLVM
+fragment:</p>
+
+<pre>
+   %t1 = add float %W, %X
+   %t2 = mul float %t1, %Y
+   %t3 = add float %t2, %Z
+</pre>
+
+<p>This LLVM code corresponds to a SelectionDAG that looks basically like this:
+</p>
+
+<pre>
+  (fadd:f32 (fmul:f32 (fadd:f32 W, X), Y), Z)
+</pre>
+
+<p>If a target supports floating point multiply-and-add (FMA) operations, one
+of the adds can be merged with the multiply.  On the PowerPC, for example, the
+output of the instruction selector might look like this DAG:</p>
+
+<pre>
+  (FMADDS (FADDS W, X), Y, Z)
+</pre>
+
+<p>
+The FMADDS instruction is a ternary instruction that multiplies its first two
+operands and adds the third (as single-precision floating-point numbers).  The
+FADDS instruction is a simple binary single-precision add instruction.  To
+perform this pattern match, the PowerPC backend includes the following
+instruction definitions:
+</p>
+
+<pre>
+def FMADDS : AForm_1&lt;59, 29,
+                    (ops F4RC:$FRT, F4RC:$FRA, F4RC:$FRC, F4RC:$FRB),
+                    "fmadds $FRT, $FRA, $FRC, $FRB",
+                    [<b>(set F4RC:$FRT, (fadd (fmul F4RC:$FRA, F4RC:$FRC),
+                                           F4RC:$FRB))</b>]&gt;;
+def FADDS : AForm_2&lt;59, 21,
+                    (ops F4RC:$FRT, F4RC:$FRA, F4RC:$FRB),
+                    "fadds $FRT, $FRA, $FRB",
+                    [<b>(set F4RC:$FRT, (fadd F4RC:$FRA, F4RC:$FRB))</b>]&gt;;
+</pre>
+
+<p>The portion of the instruction definition in bold indicates the pattern used
+to match the instruction.  The DAG operators (like <tt>fmul</tt>/<tt>fadd</tt>)
+are defined in the <tt>lib/Target/TargetSelectionDAG.td</tt> file.  
+"<tt>F4RC</tt>" is the register class of the input and result values.<p>
+
+<p>The TableGen DAG instruction selector generator reads the instruction 
+patterns in the .td and automatically builds parts of the pattern matching code
+for your target.  It has the following strengths:</p>
+
+<ul>
+<li>At compiler-compiler time, it analyzes your instruction patterns and tells
+    you if your patterns make sense or not.</li>
+<li>It can handle arbitrary constraints on operands for the pattern match.  In
+    particular, it is straight-forward to say things like "match any immediate
+    that is a 13-bit sign-extended value".  For examples, see the 
+    <tt>immSExt16</tt> and related tblgen classes in the PowerPC backend.</li>
+<li>It knows several important identities for the patterns defined.  For
+    example, it knows that addition is commutative, so it allows the 
+    <tt>FMADDS</tt> pattern above to match "<tt>(fadd X, (fmul Y, Z))</tt>" as
+    well as "<tt>(fadd (fmul X, Y), Z)</tt>", without the target author having
+    to specially handle this case.</li>
+<li>It has a full-featured type-inferencing system.  In particular, you should
+    rarely have to explicitly tell the system what type parts of your patterns
+    are.  In the FMADDS case above, we didn't have to tell tblgen that all of
+    the nodes in the pattern are of type 'f32'.  It was able to infer and
+    propagate this knowledge from the fact that F4RC has type 'f32'.</li>
+<li>Targets can define their own (and rely on built-in) "pattern fragments".
+    Pattern fragments are chunks of reusable patterns that get inlined into your
+    patterns during compiler-compiler time.  For example, the integer "(not x)"
+    operation is actually defined as a pattern fragment that expands as
+    "(xor x, -1)", since the SelectionDAG does not have a native 'not'
+    operation.  Targets can define their own short-hand fragments as they see
+    fit.  See the definition of 'not' and 'ineg' for examples.</li>
+<li>In addition to instructions, targets can specify arbitrary patterns that
+    map to one or more instructions, using the 'Pat' class.  For example,
+    the PowerPC has no way to load an arbitrary integer immediate into a
+    register in one instruction. To tell tblgen how to do this, it defines:
+    
+    <pre>
+    // Arbitrary immediate support.  Implement in terms of LIS/ORI.
+    def : Pat&lt;(i32 imm:$imm),
+              (ORI (LIS (HI16 imm:$imm)), (LO16 imm:$imm))&gt;;
+    </pre>
+    
+    If none of the single-instruction patterns for loading an immediate into a
+    register match, this will be used.  This rule says "match an arbitrary i32
+    immediate, turning it into an ORI ('or a 16-bit immediate') and an LIS
+    ('load 16-bit immediate, where the immediate is shifted to the left 16
+    bits') instruction".  To make this work, the LO16/HI16 node transformations
+    are used to manipulate the input immediate (in this case, take the high or
+    low 16-bits of the immediate).
+    </li>
+<li>While the system does automate a lot, it still allows you to write custom
+    C++ code to match special cases, in case there is something that is hard
+    to express.</li>
+</ul>
+
+<p>
+While it has many strengths, the system currently has some limitations,
+primarily because it is a work in progress and is not yet finished:
+</p>
+
+<ul>
+<li>Overall, there is no way to define or match SelectionDAG nodes that define
+    multiple values (e.g. ADD_PARTS, LOAD, CALL, etc).  This is the biggest
+    reason that you currently still <i>have to</i> write custom C++ code for
+    your instruction selector.</li>
+<li>There is no great way to support match complex addressing modes yet.  In the
+    future, we will extend pattern fragments to allow them to define multiple
+    values (e.g. the four operands of the <a href="#x86_memory">X86 addressing
+    mode</a>).  In addition, we'll extend fragments so that a fragment can match
+    multiple different patterns.</li>
+<li>We don't automatically infer flags like isStore/isLoad yet.</li>
+<li>We don't automatically generate the set of supported registers and
+    operations for the <a href="#"selectiondag_legalize>Legalizer</a> yet.</li>
+<li>We don't have a way of tying in custom legalized nodes yet.</li>
+</ul>
+
+<p>Despite these limitations, the instruction selector generator is still quite
+useful for most of the binary and logical operations in typical instruction
+sets.  If you run into any problems or can't figure out how to do something, 
+please let Chris know!</p>
+
+</div>
+
+<!-- _______________________________________________________________________ -->
+<div class="doc_subsubsection">
+  <a name="selectiondag_sched">SelectionDAG Scheduling and Formation Phase</a>
+</div>
+
+<div class="doc_text">
+
+<p>The scheduling phase takes the DAG of target instructions from the selection
+phase and assigns an order.  The scheduler can pick an order depending on
+various constraints of the machines (i.e. order for minimal register pressure or
+try to cover instruction latencies).  Once an order is established, the DAG is
+converted to a list of <a href="#machineinstr">MachineInstr</a>s and the
+Selection DAG is destroyed.
+</p>
+
+<p>Note that this phase is logically separate from the instruction selection
+phase, but is tied to it closely in the code because it operates on
+SelectionDAGs.</p>
 
 </div>
 
@@ -865,12 +1131,8 @@ want to make the Select phase as simple and mechanical as possible.</p>
 <div class="doc_text">
 
 <ol>
-<li>Optional whole-function selection.</li>
-<li>Select is a graph translation phase.</li>
-<li>Place the machine instructions resulting from Select according to register 
-pressure or a schedule.</li>
-<li>DAG Scheduling.</li>
-<li>Auto-generate the Select phase from the target description (*.td) files.
+<li>Optional function-at-a-time selection.</li>
+<li>Auto-generate entire selector from .td file.</li>
 </li>
 </ol>
 
@@ -898,12 +1160,33 @@ pressure or a schedule.</li>
 <div class="doc_text"><p>To Be Written</p></div>
 <!-- ======================================================================= -->
 <div class="doc_subsection">
-  <a name="codemission">Code Emission</a>
+  <a name="codeemit">Code Emission</a>
 </div>
 
+
+<!-- _______________________________________________________________________ -->
+<div class="doc_subsubsection">
+  <a name="codeemit_asm">Generating Assembly Code</a>
+</div>
+
+<div class="doc_text">
+
+</div>
+
+
+<!-- _______________________________________________________________________ -->
+<div class="doc_subsubsection">
+  <a name="codeemit_bin">Generating Binary Machine Code</a>
+</div>
+
+<div class="doc_text">
+   <p>For the JIT or .o file writer</p>
+</div>
+
+
 <!-- *********************************************************************** -->
 <div class="doc_section">
-  <a name="targetimpls">Target description implementations</a>
+  <a name="targetimpls">Target-specific Implementation Notes</a>
 </div>
 <!-- *********************************************************************** -->
 
@@ -932,6 +1215,28 @@ implementations.</p>
 
 </div>
 
+<!-- _______________________________________________________________________ -->
+<div class="doc_subsubsection">
+  <a name="x86_tt">X86 Target Triples Supported</a>
+</div>
+
+<div class="doc_text">
+<p>
+The following are the known target triples that are supported by the X86 
+backend.  This is not an exhaustive list, but it would be useful to add those
+that people test.
+</p>
+
+<ul>
+<li><b>i686-pc-linux-gnu</b> - Linux</li>
+<li><b>i386-unknown-freebsd5.3</b> - FreeBSD 5.3</li>
+<li><b>i686-pc-cygwin</b> - Cygwin on Win32</li>
+<li><b>i686-pc-mingw32</b> - MingW on Win32</li>
+<li><b>i686-apple-darwin*</b> - Apple Darwin on X86</li>
+</ul>
+
+</div>
+
 <!-- _______________________________________________________________________ -->
 <div class="doc_subsubsection">
   <a name="x86_memory">Representing X86 addressing modes in MachineInstrs</a>

llvm/docs/CommandGuide/.cvsignore

@@ -1 +1,4 @@
 pod2htm?.tmp
+*.html
+*.1
+*.ps

llvm/docs/CommandGuide/Makefile

@@ -30,7 +30,7 @@ html/%.html: %.pod
 	  --podpath=. --noindex --infile=$< --outfile=$@ --title=$*
 
 man/man1/%.1: %.pod
-	pod2man --release=1.4 --center="LLVM Command Guide" $< $@
+	pod2man --release=1.5 --center="LLVM Command Guide" $< $@
 
 ps/%.ps: man/man1/%.1
 	groff -Tps -man $< > $@

llvm/docs/CommandGuide/llvmc.pod

@@ -10,23 +10,22 @@ B<llvmc> [I<options>] [I<filenames>...]
 
 =head1 DESCRIPTION
 
-The B<llvmc> command is a configurable driver for invoking other 
-LLVM (and non-LLVM) tools in order to compile, optimize and link software
-for multiple languages. For those familiar with the GNU Compiler 
-Collection's B<gcc> tool, it is very similar. This tool has the
-following main goals or purposes:
+B<llvmc> is a configurable driver for invoking other LLVM (and non-LLVM) tools
+in order to compile, optimize and link software for multiple languages. For
+those familiar with FSF's B<gcc> tool, it is very similar.  B<llvmc> has the
+following goals:
 
 =over
 
-=item * A Single point of access to the LLVM tool set.
+=item * provide a single point of access to the LLVM tool set,
 
-=item * Hide the complexities of the LLVM tools through a single interface.
+=item * hide the complexities of the LLVM tools through a single interface,
 
-=item * Make integration of existing non-LLVM tools simple.
+=item * make integration of existing non-LLVM tools simple,
 
-=item * Extend the capabilities of minimal front ends.
+=item * extend the capabilities of minimal front ends, and
 
-=item * Make the interface for compiling consistent for all languages.
+=item * make the interface for compiling consistent for all languages.
 
 =back
 

llvm/docs/CommandLine.html

@@ -23,6 +23,7 @@
                                     set of possibilities</a></li>
       <li><a href="#namedalternatives">Named alternatives</a></li>
       <li><a href="#list">Parsing a list of options</a></li>
+      <li><a href="#bits">Collecting options as a set of flags</a></li>
       <li><a href="#description">Adding freeform text to help output</a></li>
     </ol></li>
 
@@ -61,6 +62,7 @@
             <tt>cl::ParseEnvironmentOptions</tt> function</a></li>
         <li><a href="#cl::opt">The <tt>cl::opt</tt> class</a></li>
         <li><a href="#cl::list">The <tt>cl::list</tt> class</a></li>
+        <li><a href="#cl::bits">The <tt>cl::bits</tt> class</a></li>
         <li><a href="#cl::alias">The <tt>cl::alias</tt> class</a></li>
         <li><a href="#cl::extrahelp">The <tt>cl::extrahelp</tt> class</a></li>
         </ul></li>
@@ -691,6 +693,65 @@ checking we have to do.</p>
 
 </div>
 
+<!-- ======================================================================= -->
+<div class="doc_subsection">
+  <a name="bits">Collecting options as a set of flags</a>
+</div>
+
+<div class="doc_text">
+
+<p>Instead of collecting sets of options in a list, it is also possible to
+gather information for enum values in a <b>bit vector</b>.  The represention used by
+the <a href="#bits"><tt>cl::bits</tt></a> class is an <tt>unsigned</tt>
+integer.  An enum value is represented by a 0/1 in the enum's ordinal value bit
+position. 1 indicating that the enum was specified, 0 otherwise.  As each
+specified value is parsed, the resulting enum's bit is set in the option's bit
+vector:</p>
+
+<div class="doc_code"><pre>
+  <i>bits</i> |= 1 << (unsigned)<i>enum</i>;
+</pre></div>
+
+<p>Options that are specified multiple times are redundant.  Any instances after
+the first are discarded.</p>
+
+<p>Reworking the above list example, we could replace <a href="#list">
+<tt>cl::list</tt></a> with <a href="#bits"><tt>cl::bits</tt></a>:</p>
+
+<div class="doc_code"><pre>
+<a href="#cl::bits">cl::bits</a>&lt;Opts&gt; OptimizationBits(<a href="#cl::desc">cl::desc</a>("<i>Available Optimizations:</i>"),
+  <a href="#cl::values">cl::values</a>(
+    clEnumVal(dce               , "<i>Dead Code Elimination</i>"),
+    clEnumVal(constprop         , "<i>Constant Propagation</i>"),
+   clEnumValN(inlining, "<i>inline</i>", "<i>Procedure Integration</i>"),
+    clEnumVal(strip             , "<i>Strip Symbols</i>"),
+  clEnumValEnd));
+</pre></div>
+
+<p>To test to see if <tt>constprop</tt> was specified, we can use the
+<tt>cl:bits::isSet</tt> function:</p>
+
+<div class="doc_code"><pre>
+  if (OptimizationBits.isSet(constprop)) {
+    ...
+  }
+</pre></div>
+
+<p>It's also possible to get the raw bit vector using the
+<tt>cl::bits::getBits</tt> function:</p>
+
+<div class="doc_code"><pre>
+  unsigned bits = OptimizationBits.getBits();
+</pre></div>
+
+<p>Finally, if external storage is used, then the location specified must be of
+<b>type</b> <tt>unsigned</tt>. In all other ways a <a
+href="#bits"><tt>cl::bits</tt></a> option is morally equivalent to a <a
+href="#list"> <tt>cl::list</tt></a> option.</p>
+
+</div>
+
+
 <!-- ======================================================================= -->
 <div class="doc_subsection">
   <a name="description">Adding freeform text to help output</a>
@@ -1506,6 +1567,31 @@ be used.</p>
 
 </div>
 
+<!-- _______________________________________________________________________ -->
+<div class="doc_subsubsection">
+  <a name="cl::bits">The <tt>cl::bits</tt> class</a>
+</div>
+
+<div class="doc_text">
+
+<p>The <tt>cl::bits</tt> class is the class used to represent a list of command
+line options in the form of a bit vector.  It is also a templated class which
+can take up to three arguments:</p>
+
+<div class="doc_code"><pre>
+<b>namespace</b> cl {
+  <b>template</b> &lt;<b>class</b> DataType, <b>class</b> Storage = <b>bool</b>,
+            <b>class</b> ParserClass = parser&lt;DataType&gt; &gt;
+  <b>class</b> bits;
+}
+</pre></div>
+
+<p>This class works the exact same as the <a
+href="#cl::opt"><tt>cl::lists</tt></a> class, except that the second argument
+must be of <b>type</b> <tt>unsigned</tt> if external storage is used.</p>
+
+</div>
+
 <!-- _______________________________________________________________________ -->
 <div class="doc_subsubsection">
   <a name="cl::alias">The <tt>cl::alias</tt> class</a>

llvm/docs/CompilerWriterInfo.html

@@ -143,9 +143,6 @@ branch stubs for powerpc64-linux (from binutils)</a></li>
 <!-- ======================================================================= -->
 <div class="doc_subsection"><a name="sparc">SPARC</a></div>
 
-<!-- _______________________________________________________________________ -->
-<div class="doc_subsubsection">Official manuals and docs</div>
-
 <div class="doc_text">
 
 <ul>

llvm/docs/GettingStarted.html

@@ -307,9 +307,9 @@ if necessary.</li>
 </div>
 
 <p>Note that you will need about 1-3 GB of space for a full LLVM build in Debug
-mode, depending on the system (because of all the debug info), and the libraries
-appear in more than one of the tools that get linked, so there is some
-duplication.  If you do not need many of the tools and you are space-conscious,
+mode, depending on the system (it is so large because of all the debugging
+information and the fact that the libraries are statically linked into multiple
+tools).  If you do not need many of the tools and you are space-conscious,
 you can disable them individually in <tt>llvm/tools/Makefile</tt>.  The Release
 build requires considerably less space.</p>
 
@@ -348,6 +348,12 @@ href="CFEBuildInstrs.html">try to compile it</a> on your platform.</p>
       <td>C/C++ compiler<sup><a href="#sf1">1</a></sup></td>
     </tr>
 
+    <tr>
+      <td><a href="http://www.gnu.org/software/texinfo">TeXinfo</a></td>
+      <td>4.5</td>
+      <td>For building the CFE</td>
+    </tr>
+
     <tr>
       <td><a href="http://www.gnu.org/software/flex">Flex</a></td>
       <td>2.5.4</td>
@@ -576,9 +582,10 @@ variables.
 <dl>
   <dt><tt>LLVM_LIB_SEARCH_PATH</tt>=<tt>/path/to/your/bytecode/libs</tt></dt>
   <dd>[Optional] This environment variable helps LLVM linking tools find the
-  locations of your bytecode libraries. It is provided only a
+  locations of your bytecode libraries. It is provided only as a
   convenience since you can specify the paths using the -L options of the
-  tools and the C/C++ front-end will use the bytecode files installed in its
+  tools and the C/C++ front-end will automatically use the bytecode files
+  installed in its
   <tt>lib</tt> directory.</dd>
 </dl>
 
@@ -620,7 +627,7 @@ compressed with the gzip program.
   <dt><tt>cfrontend-x.y.i386-unknown-freebsd5.1.tar.gz</tt></dt>
   <dd>Binary release of the GCC front end for FreeBSD/x86.<br/></dd>
 
-  <dt><tt>cfrontend-x.y.powerpc-apple-darwin7.6.0.tar.gz</tt></dt>
+  <dt><tt>cfrontend-x.y.powerpc-apple-darwin7.8.0.tar.gz</tt></dt>
   <dd>Binary release of the GCC front end for MacOS X/PPC.<br/></dd>
 </dl>
 
@@ -654,6 +661,7 @@ revision), you can specify a label.  The following releases have the following
 labels:</p>
 
 <ul>
+<li>Release 1.6: <b>RELEASE_16</b></li>
 <li>Release 1.5: <b>RELEASE_15</b></li>
 <li>Release 1.4: <b>RELEASE_14</b></li>
 <li>Release 1.3: <b>RELEASE_13</b></li>
@@ -788,11 +796,12 @@ script to configure the build system:</p>
   <a href="CFEBuildInstrs.html">Bootstrapping the LLVM C/C++ Front-End</a>
   for details on building the C/C++ Front End.</dd>
   <dt><i>--with-tclinclude</i></dt>
-  <dd>Path to the tcl include directory under which the <tt>tclsh</tt> can be
+  <dd>Path to the tcl include directory under which <tt>tclsh</tt> can be
   found. Use this if you have multiple tcl installations on your machine and you
   want to use a specific one (8.x) for LLVM. LLVM only uses tcl for running the
   dejagnu based test suite in <tt>llvm/test</tt>. If you don't specify this
-  option, the LLVM configure script will search for tcl 8.4 and 8.3 releases.
+  option, the LLVM configure script will search for the tcl 8.4 and 8.3
+  releases.
   <p></p>
   </dd>
   <dt><i>--enable-optimized</i></dt>
@@ -817,7 +826,7 @@ script to configure the build system:</p>
   native compiler (no cross-compiler targets available). The "native" target is 
   selected as the target of the build host. You can also specify a comma 
   separated list of target names that you want available in llc. The target 
-  names use all lower case. The current set is of targets is: <br/>
+  names use all lower case. The current set of targets is: <br/>
   <tt>alpha, ia64, powerpc, skeleton, sparc, x86</tt>.
   <p></p></dd>
   <dt><i>--enable-doxygen</i></dt>
@@ -1148,7 +1157,7 @@ different <a href="#tools">tools</a>.</p>
   <dd> This directory contains files that describe various target architectures
   for code generation.  For example, the <tt>llvm/lib/Target/SparcV9</tt> 
   directory holds the Sparc machine description while
-  <tt>llvm/lib/Target/CBackend</tt> implements the LLVM-to-C converter</dd>
+  <tt>llvm/lib/Target/CBackend</tt> implements the LLVM-to-C converter.</dd>
     
   <dt><tt><b>llvm/lib/CodeGen/</b></tt></dt>
   <dd> This directory contains the major parts of the code generator: Instruction 
@@ -1251,8 +1260,8 @@ information is in the <a href="CommandGuide/index.html">Command Guide</a>.</p>
   all from one command line. <tt>llvmc</tt> also takes care of processing the
   dependent libraries found in bytecode. This reduces the need to get the
   traditional <tt>-l&lt;name&gt;</tt> options right on the command line. Please
-  note that this tool is new in 1.4 and considered experimental. It will be
-  fully supported in 1.5.</dd>
+  note that this tool, while functional, is still experimental and not feature
+  complete.</dd>
 
   <dt><tt><b>llvm-ar</b></tt></dt>
   <dd>The archiver produces an archive containing
@@ -1271,9 +1280,8 @@ information is in the <a href="CommandGuide/index.html">Command Guide</a>.</p>
   <dd><tt>llvm-ld</tt> is very similar to gccld and provides a general purpose
   and extensible linker for LLVM. This is the linker invoked by <tt>llvmc</tt>.
   It allows optimization modules to be loaded so that language specific
-  optimizations can be applied at link time. Please note that this tool is new
-  in LLVM 1.4 and still considered experimental. It will be fully supported in
-  LLVM 1.5.</dd>
+  optimizations can be applied at link time. This tool is considered
+  experimental.</dd>
 
   <dt><tt><b>llvm-link</b></tt></dt>
   <dd><tt>llvm-link</tt>, not surprisingly, links multiple LLVM modules into 
@@ -1291,7 +1299,7 @@ information is in the <a href="CommandGuide/index.html">Command Guide</a>.</p>
 
   <dt><tt><b>llc</b></tt></dt>
   <dd> <tt>llc</tt> is the LLVM backend compiler, which
-  translates LLVM bytecode to a SPARC or x86 assembly file, or to C code (with
+  translates LLVM bytecode to a native code assembly file or to C code (with
   the -march=c option).</dd>
 
   <dt><tt><b>llvm-gcc</b></tt></dt>
@@ -1299,8 +1307,7 @@ information is in the <a href="CommandGuide/index.html">Command Guide</a>.</p>
   that has been retargeted to emit LLVM code as the machine code output.  It
   works just like any other GCC compiler, taking the typical <tt>-c, -S, -E,
   -o</tt> options that are typically used.  The source code for the
-  <tt>llvm-gcc</tt> tool is currently not included in the LLVM CVS tree
-  because it is quite large and not very interesting.
+  <tt>llvm-gcc</tt> tool is available as a separate CVS module.
   <blockquote>
     <dl>
       <dt><tt><b>gccas</b></tt></dt>

llvm/docs/GettingStartedVS.html

@@ -170,15 +170,10 @@ progress has been made since the 1.4 release.</p>
   beta, there are no guarantees and there is no support for it at this time.
   It has been reported that VC++ Express also works.</p>
 
-  <p>You will also need several open source packages:  bison, flex, and sed.
-  These must be installed in <tt>llvm/win32/tools</tt>.  These can be found at
-  <a href="http://gnuwin32.sourceforge.net">http://gnuwin32.sourceforge.net</a>
-  or
-  <a href="http://unxutils.sourceforge.net">http://unxutils.sourceforge.net</a>.
-  Bison prefers that m4 be in the path.  You must add it to the Visual Studio
-  configuration under the menu Options -&gt; Projects -&gt; VC++ Directories.
-  Alternatively, you can set the environment variable <tt>M4</tt> to point to
-  <tt>m4</tt> executable.</p>
+  <p>If you plan to modify any .y or .l files, you will need to have bison
+  and/or flex installed where Visual Studio can find them.  Otherwise, you do
+  not need them and the pre-generated files that come with the source tree
+  will be used.</p>
 
 </div>
 
@@ -279,28 +274,26 @@ All these paths are absolute:</p>
       <p><b>Note: while you cannot do this step on Windows, you can do it on a
         Unix system and transfer <tt>hello.bc</tt> to Windows.</b></p></li>
 
-  <li><p>Run the program. To make sure the program ran, execute the
-      following command:</p>
+  <li><p>Run the program using the just-in-time compiler:</p>
       
       <p><tt>% lli hello.bc</tt></p></li>
 
   <li><p>Use the <tt>llvm-dis</tt> utility to take a look at the LLVM assembly
       code:</p>
 
-      <p><tt>% llvm-dis &lt; hello.bc | less</tt><p></li>
+      <p><tt>% llvm-dis &lt; hello.bc | more</tt><p></li>
 
-  <li><p>Compile the program to native assembly using the LLC code
-      generator:</p>
+  <li><p>Compile the program to C using the LLC code generator:</p>
 
-      <p><tt>% llc hello.bc -o hello.s</tt></p>
+      <p><tt>% llc -march=c hello.bc</tt></p></li>
 
-  <li><p>Assemble the native assembly language file into a program:</p>
+  <li><p>Compile to binary using Microsoft C:</p>
 
-  <p><b>Not currently possible, but eventually will use <tt>NASMW</tt>.</b></p>
+      <p><tt>% cl hello.cbe.c</tt></p></li>
 
   <li><p>Execute the native code program:</p>
 
-      <p><tt>% ./hello.native</tt></p></li>
+      <p><tt>% hello.cbe.exe</tt></p></li>
 
 </ol>
 

llvm/docs/HistoricalNotes/2003-01-23-CygwinNotes.txt

@@ -17,15 +17,12 @@ under Cygwin and/or Mingw.
    DONT_BUILD_RELINKED. This breaks all the tools makefiles; you just need to
    change them to have .a's.
 
-5. Cygwin's math.h defines log2(); it needs to be #undefed if already defined
-   in MathExtras.h.
+5. There isn't a <values.h>.
 
-6. There isn't a <values.h>.
-
-7. There isn't a mallinfo() (or, at least, it's documented, but it doesn't seem
+6. There isn't a mallinfo() (or, at least, it's documented, but it doesn't seem
    to link).
 
-8. The version of Bison that cygwin (and newer Linux versions) comes with
+7. The version of Bison that cygwin (and newer Linux versions) comes with
    does not like = signs in rules. Burg's gram.yc source file uses them. I think
    you can just take them out.
 

llvm/docs/LangRef.html

@@ -101,7 +101,6 @@
           <li><a href="#i_cast">'<tt>cast .. to</tt>' Instruction</a></li>
           <li><a href="#i_select">'<tt>select</tt>' Instruction</a></li>
           <li><a href="#i_call">'<tt>call</tt>'  Instruction</a></li>
-          <li><a href="#i_vanext">'<tt>vanext</tt>' Instruction</a></li>
           <li><a href="#i_vaarg">'<tt>vaarg</tt>'  Instruction</a></li>
         </ol>
       </li>
@@ -144,6 +143,8 @@
           <li><a href="#i_memmove">'<tt>llvm.memmove</tt>' Intrinsic</a></li>
           <li><a href="#i_memset">'<tt>llvm.memset</tt>' Intrinsic</a></li>
           <li><a href="#i_isunordered">'<tt>llvm.isunordered</tt>' Intrinsic</a></li>
+          <li><a href="#i_sqrt">'<tt>llvm.sqrt</tt>' Intrinsic</a></li>
+
         </ol>
       </li>
       <li><a href="#int_count">Bit counting Intrinsics</a>
@@ -494,11 +495,11 @@ convention.</p>
 
 <p>Global variables define regions of memory allocated at compilation time
 instead of run-time.  Global variables may optionally be initialized.  A
-variable may be defined as a global "constant", which indicates that the
+variable may be defined as a global "constant," which indicates that the
 contents of the variable will <b>never</b> be modified (enabling better
 optimization, allowing the global data to be placed in the read-only section of
 an executable, etc).  Note that variables that need runtime initialization
-cannot be marked "constant", as there is a store to the variable.</p>
+cannot be marked "constant" as there is a store to the variable.</p>
 
 <p>
 LLVM explicitly allows <em>declarations</em> of global variables to be marked
@@ -718,6 +719,14 @@ be any type with a size.</p>
     </td>
   </tr>
 </table>
+
+<p>Note that 'variable sized arrays' can be implemented in LLVM with a zero 
+length array.  Normally, accesses past the end of an array are undefined in
+LLVM (e.g. it is illegal to access the 5th element of a 3 element array).
+As a special case, however, zero length arrays are recognized to be variable
+length.  This allows implementation of 'pascal style arrays' with the  LLVM
+type "{ int, [0 x float]}", for example.</p>
+
 </div>
 
 <!-- _______________________________________________________________________ -->
@@ -734,7 +743,7 @@ The return type of a function type cannot be an aggregate type.
 </p>
 <h5>Syntax:</h5>
 <pre>  &lt;returntype&gt; (&lt;parameter list&gt;)<br></pre>
-<p>Where '<tt>&lt;parameter list&gt;</tt>' is a comma-separated list of type
+<p>...where '<tt>&lt;parameter list&gt;</tt>' is a comma-separated list of type
 specifiers.  Optionally, the parameter list may include a type <tt>...</tt>,
 which indicates that the function takes a variable number of arguments.
 Variable argument functions can access their arguments with the <a
@@ -988,7 +997,7 @@ and smaller aggregate constants.</p>
   <dd>The string '<tt>zeroinitializer</tt>' can be used to zero initialize a
   value to zero of <em>any</em> type, including scalar and aggregate types.
   This is often used to avoid having to print large zero initializers (e.g. for
-  large arrays), and is always exactly equivalent to using explicit zero
+  large arrays) and is always exactly equivalent to using explicit zero
   initializers.
   </dd>
 </dl>
@@ -1477,7 +1486,7 @@ Both arguments must have identical types.</p>
 <p>This returns the <i>remainder</i> of a division (where the result
 has the same sign as the divisor), not the <i>modulus</i> (where the
 result has the same sign as the dividend) of a value.  For more
-information about the difference, see: <a
+information about the difference, see <a
  href="http://mathforum.org/dr.math/problems/anne.4.28.99.html">The
 Math Forum</a>.</p>
 <h5>Example:</h5>
@@ -1854,9 +1863,9 @@ Instruction</a> </div>
 <p>The '<tt>load</tt>' instruction is used to read from memory.</p>
 <h5>Arguments:</h5>
 <p>The argument to the '<tt>load</tt>' instruction specifies the memory
-address to load from.  The pointer must point to a <a
+address from which to load.  The pointer must point to a <a
  href="#t_firstclass">first class</a> type.  If the <tt>load</tt> is
-marked as <tt>volatile</tt> then the optimizer is not allowed to modify
+marked as <tt>volatile</tt>, then the optimizer is not allowed to modify
 the number or order of execution of this <tt>load</tt> with other
 volatile <tt>load</tt> and <tt><a href="#i_store">store</a></tt>
 instructions. </p>
@@ -1880,7 +1889,7 @@ Instruction</a> </div>
 <p>The '<tt>store</tt>' instruction is used to write to memory.</p>
 <h5>Arguments:</h5>
 <p>There are two arguments to the '<tt>store</tt>' instruction: a value
-to store and an address to store it into.  The type of the '<tt>&lt;pointer&gt;</tt>'
+to store and an address in which to store it.  The type of the '<tt>&lt;pointer&gt;</tt>'
 operand must be a pointer to the type of the '<tt>&lt;value&gt;</tt>'
 operand. If the <tt>store</tt> is marked as <tt>volatile</tt>, then the
 optimizer is not allowed to modify the number or order of execution of
@@ -1990,7 +1999,15 @@ the LLVM code for the given testcase is equivalent to:</p>
     ret int* %t5
   }
 </pre>
+
+<p>Note that it is undefined to access an array out of bounds: array and 
+pointer indexes must always be within the defined bounds of the array type.
+The one exception for this rules is zero length arrays.  These arrays are
+defined to be accessible as variable length arrays, which requires access
+beyond the zero'th element.</p>
+
 <h5>Example:</h5>
+
 <pre>
     <i>; yields [12 x ubyte]*:aptr</i>
     %aptr = getelementptr {int, [12 x ubyte]}* %sptr, long 0, uint 1
@@ -2209,58 +2226,6 @@ the <a href="#i_invoke">invoke</a> instruction.</p>
 
 </div>
 
-<!-- _______________________________________________________________________ -->
-<div class="doc_subsubsection">
-  <a name="i_vanext">'<tt>vanext</tt>' Instruction</a>
-</div>
-
-<div class="doc_text">
-
-<h5>Syntax:</h5>
-
-<pre>
-  &lt;resultarglist&gt; = vanext &lt;va_list&gt; &lt;arglist&gt;, &lt;argty&gt;
-</pre>
-
-<h5>Overview:</h5>
-
-<p>The '<tt>vanext</tt>' instruction is used to access arguments passed
-through the "variable argument" area of a function call.  It is used to
-implement the <tt>va_arg</tt> macro in C.</p>
-
-<h5>Arguments:</h5>
-
-<p>This instruction takes a <tt>va_list</tt> value and the type of the
-argument. It returns another <tt>va_list</tt>. The actual type of
-<tt>va_list</tt> may be defined differently for different targets.  Most targets
-use a <tt>va_list</tt> type of <tt>sbyte*</tt> or some other pointer type.</p>
-
-<h5>Semantics:</h5>
-
-<p>The '<tt>vanext</tt>' instruction advances the specified <tt>va_list</tt>
-past an argument of the specified type.  In conjunction with the <a
- href="#i_vaarg"><tt>vaarg</tt></a> instruction, it is used to implement
-the <tt>va_arg</tt> macro available in C.  For more information, see
-the variable argument handling <a href="#int_varargs">Intrinsic
-Functions</a>.</p>
-
-<p>It is legal for this instruction to be called in a function which
-does not take a variable number of arguments, for example, the <tt>vfprintf</tt>
-function.</p>
-
-<p><tt>vanext</tt> is an LLVM instruction instead of an <a
-href="#intrinsics">intrinsic function</a> because it takes a type as an
-argument.  The type refers to the current argument in the <tt>va_list</tt>; it
-tells the compiler how far on the stack it needs to advance to find the next
-argument.</p>
-
-<h5>Example:</h5>
-
-<p>See the <a href="#int_varargs">variable argument processing</a>
-section.</p>
-
-</div>
-
 <!-- _______________________________________________________________________ -->
 <div class="doc_subsubsection">
   <a name="i_vaarg">'<tt>vaarg</tt>' Instruction</a>
@@ -2271,34 +2236,35 @@ section.</p>
 <h5>Syntax:</h5>
 
 <pre>
-  &lt;resultval&gt; = vaarg &lt;va_list&gt; &lt;arglist&gt;, &lt;argty&gt;
+  &lt;resultval&gt; = va_arg &lt;va_list*&gt; &lt;arglist&gt;, &lt;argty&gt;
 </pre>
 
 <h5>Overview:</h5>
 
-<p>The '<tt>vaarg</tt>' instruction is used to access arguments passed through
+<p>The '<tt>va_arg</tt>' instruction is used to access arguments passed through
 the "variable argument" area of a function call.  It is used to implement the
 <tt>va_arg</tt> macro in C.</p>
 
 <h5>Arguments:</h5>
 
-<p>This instruction takes a <tt>va_list</tt> value and the type of the
-argument. It returns a value of the specified argument type.  Again, the actual
-type of <tt>va_list</tt> is target specific.</p>
+<p>This instruction takes a <tt>va_list*</tt> value and the type of
+the argument. It returns a value of the specified argument type and
+increments the <tt>va_list</tt> to poin to the next argument.  Again, the
+actual type of <tt>va_list</tt> is target specific.</p>
 
 <h5>Semantics:</h5>
 
-<p>The '<tt>vaarg</tt>' instruction loads an argument of the specified type from
-the specified <tt>va_list</tt>.  In conjunction with the <a
-href="#i_vanext"><tt>vanext</tt></a> instruction, it is used to implement the
-<tt>va_arg</tt> macro available in C.  For more information, see the variable
-argument handling <a href="#int_varargs">Intrinsic Functions</a>.</p>
+<p>The '<tt>va_arg</tt>' instruction loads an argument of the specified
+type from the specified <tt>va_list</tt> and causes the
+<tt>va_list</tt> to point to the next argument.  For more information,
+see the variable argument handling <a href="#int_varargs">Intrinsic
+Functions</a>.</p>
 
 <p>It is legal for this instruction to be called in a function which does not
 take a variable number of arguments, for example, the <tt>vfprintf</tt>
 function.</p>
 
-<p><tt>vaarg</tt> is an LLVM instruction instead of an <a
+<p><tt>va_arg</tt> is an LLVM instruction instead of an <a
 href="#intrinsics">intrinsic function</a> because it takes a type as an
 argument.</p>
 
@@ -2361,20 +2327,19 @@ used.</p>
 <pre>
 int %test(int %X, ...) {
   ; Initialize variable argument processing
-  %ap = call sbyte* %<a href="#i_va_start">llvm.va_start</a>()
+  %ap = alloca sbyte*
+  call void %<a href="#i_va_start">llvm.va_start</a>(sbyte** %ap)
 
   ; Read a single integer argument
-  %tmp = vaarg sbyte* %ap, int
-
-  ; Advance to the next argument
-  %ap2 = vanext sbyte* %ap, int
+  %tmp = va_arg sbyte** %ap, int
 
   ; Demonstrate usage of llvm.va_copy and llvm.va_end
-  %aq = call sbyte* %<a href="#i_va_copy">llvm.va_copy</a>(sbyte* %ap2)
-  call void %<a href="#i_va_end">llvm.va_end</a>(sbyte* %aq)
+  %aq = alloca sbyte*
+  call void %<a href="#i_va_copy">llvm.va_copy</a>(sbyte** %aq, sbyte** %ap)
+  call void %<a href="#i_va_end">llvm.va_end</a>(sbyte** %aq)
 
   ; Stop processing of arguments.
-  call void %<a href="#i_va_end">llvm.va_end</a>(sbyte* %ap2)
+  call void %<a href="#i_va_end">llvm.va_end</a>(sbyte** %ap)
   ret int %tmp
 }
 </pre>
@@ -2388,19 +2353,25 @@ int %test(int %X, ...) {
 
 <div class="doc_text">
 <h5>Syntax:</h5>
-<pre>  declare &lt;va_list&gt; %llvm.va_start()<br></pre>
+<pre>  declare void %llvm.va_start(&lt;va_list&gt;* &lt;arglist&gt;)<br></pre>
 <h5>Overview:</h5>
-<p>The '<tt>llvm.va_start</tt>' intrinsic returns a new <tt>&lt;arglist&gt;</tt>
-for subsequent use by the variable argument intrinsics.</p>
+<P>The '<tt>llvm.va_start</tt>' intrinsic initializes
+<tt>*&lt;arglist&gt;</tt> for subsequent use by <tt><a
+href="#i_va_arg">va_arg</a></tt>.</p>
+
+<h5>Arguments:</h5>
+
+<P>The argument is a pointer to a <tt>va_list</tt> element to initialize.</p>
+
 <h5>Semantics:</h5>
-<p>The '<tt>llvm.va_start</tt>' intrinsic works just like the <tt>va_start</tt>
-macro available in C.  In a target-dependent way, it initializes and
-returns a <tt>va_list</tt> element, so that the next <tt>vaarg</tt>
-will produce the first variable argument passed to the function.  Unlike
-the C <tt>va_start</tt> macro, this intrinsic does not need to know the
-last argument of the function; the compiler can figure that out.</p>
-<p>Note that this intrinsic function is only legal to be called from
-within the body of a variable argument function.</p>
+
+<P>The '<tt>llvm.va_start</tt>' intrinsic works just like the <tt>va_start</tt>
+macro available in C.  In a target-dependent way, it initializes the
+<tt>va_list</tt> element the argument points to, so that the next call to
+<tt>va_arg</tt> will produce the first variable argument passed to the function.
+Unlike the C <tt>va_start</tt> macro, this intrinsic does not need to know the
+last argument of the function, the compiler can figure that out.</p>
+
 </div>
 
 <!-- _______________________________________________________________________ -->
@@ -2410,7 +2381,7 @@ within the body of a variable argument function.</p>
 
 <div class="doc_text">
 <h5>Syntax:</h5>
-<pre>  declare void %llvm.va_end(&lt;va_list&gt; &lt;arglist&gt;)<br></pre>
+<pre>  declare void %llvm.va_end(&lt;va_list*&gt; &lt;arglist&gt;)<br></pre>
 <h5>Overview:</h5>
 <p>The '<tt>llvm.va_end</tt>' intrinsic destroys <tt>&lt;arglist&gt;</tt>
 which has been initialized previously with <tt><a href="#i_va_start">llvm.va_start</a></tt>
@@ -2435,24 +2406,27 @@ with calls to <tt>llvm.va_end</tt>.</p>
 <h5>Syntax:</h5>
 
 <pre>
-  declare &lt;va_list&gt; %llvm.va_copy(&lt;va_list&gt; &lt;destarglist&gt;)
+  declare void %llvm.va_copy(&lt;va_list&gt;* &lt;destarglist&gt;,
+                                          &lt;va_list&gt;* &lt;srcarglist&gt;)
 </pre>
 
 <h5>Overview:</h5>
 
-<p>The '<tt>llvm.va_copy</tt>' intrinsic copies the current argument position
-from the source argument list to the destination argument list.</p>
+<p>The '<tt>llvm.va_copy</tt>' intrinsic copies the current argument position from
+the source argument list to the destination argument list.</p>
 
 <h5>Arguments:</h5>
 
-<p>The argument is the <tt>va_list</tt> to copy.</p>
+<p>The first argument is a pointer to a <tt>va_list</tt> element to initialize.
+The second argument is a pointer to a <tt>va_list</tt> element to copy from.</p>
+
 
 <h5>Semantics:</h5>
 
-<p>The '<tt>llvm.va_copy</tt>' intrinsic works just like the <tt>va_copy</tt>
-macro available in C.  In a target-dependent way, it copies the source
-<tt>va_list</tt> element into the returned list.  This intrinsic is necessary
-because the <tt><a href="#i_va_start">llvm.va_start</a></tt> intrinsic may be
+<p>The '<tt>llvm.va_copy</tt>' intrinsic works just like the <tt>va_copy</tt> macro
+available in C.  In a target-dependent way, it copies the source
+<tt>va_list</tt> element into the destination list.  This intrinsic is necessary
+because the <tt><a href="i_va_begin">llvm.va_begin</a></tt> intrinsic may be
 arbitrarily complex and require memory allocation, for example.</p>
 
 </div>
@@ -3161,6 +3135,41 @@ false.
 </div>
 
 
+<!-- _______________________________________________________________________ -->
+<div class="doc_subsubsection">
+  <a name="i_sqrt">'<tt>llvm.sqrt</tt>' Intrinsic</a>
+</div>
+
+<div class="doc_text">
+
+<h5>Syntax:</h5>
+<pre>
+  declare &lt;float or double&gt; %llvm.sqrt(&lt;float or double&gt; Val)
+</pre>
+
+<h5>Overview:</h5>
+
+<p>
+The '<tt>llvm.sqrt</tt>' intrinsic returns the sqrt of the specified operand,
+returning the same value as the libm '<tt>sqrt</tt>' function would.  Unlike
+<tt>sqrt</tt> in libm, however, <tt>llvm.sqrt</tt> has undefined behavior for
+negative numbers (which allows for better optimization).
+</p>
+
+<h5>Arguments:</h5>
+
+<p>
+The argument and return value are floating point numbers of the same type.
+</p>
+
+<h5>Semantics:</h5>
+
+<p>
+This function returns the sqrt of the specified operand if it is a positive
+floating point number.
+</p>
+</div>
+
 <!-- ======================================================================= -->
 <div class="doc_subsection">
   <a name="int_count">Bit Counting Intrinsics</a>

llvm/docs/Makefile

@@ -64,3 +64,10 @@ $(PROJ_OBJ_DIR)/doxygen.tar.gz: $(DOXYFILES) $(PROJ_OBJ_DIR)/doxygen.cfg
 	$(Verb) $(TAR) cf $(PROJ_OBJ_DIR)/doxygen.tar doxygen
 	$(Verb) $(GZIP) $(PROJ_OBJ_DIR)/doxygen.tar
 
+userloc: $(LLVM_SRC_ROOT)/docs/userloc.html
+
+$(LLVM_SRC_ROOT)/docs/userloc.html:
+	$(Echo) Making User LOC Table
+	$(Verb) cd $(LLVM_SRC_ROOT) ; ./utils/userloc.pl -details -recurse \
+	  -html lib include tools runtime utils examples autoconf test > docs/userloc.html
+	  

llvm/docs/MakefileGuide.html

@@ -552,7 +552,7 @@
 <div class="doc_text">
   <p>This utility target, only available when <tt>$(PROJ_OBJ_ROOT)</tt> is not 
   the same as <tt>$(PROJ_SRC_ROOT)</tt>, will completely clean the
-  <tt>$(PROJ_OBJ_ROOT)</tt> directoy by removing its content entirely and 
+  <tt>$(PROJ_OBJ_ROOT)</tt> directory by removing its content entirely and 
   reconfiguring the directory. This returns the <tt>$(PROJ_OBJ_ROOT)</tt> 
   directory to a completely fresh state. All content in the directory except 
   configured files and top-level makefiles will be lost.</p>

llvm/docs/ProgrammersManual.html

@@ -41,6 +41,7 @@ option</a></li>
       <li>The <tt>InstVisitor</tt> template
       <li>The general graph API
 --> 
+      <li><a href="#ViewGraph">Viewing graphs while debugging code</a></li>
     </ul>
   </li>
   <li><a href="#common">Helpful Hints for Common Operations</a>
@@ -491,6 +492,44 @@ maintainable and useful.</p>
 
 </div>
 
+<!-- ======================================================================= -->
+<div class="doc_subsection">
+  <a name="ViewGraph">Viewing graphs while debugging code</a>
+</div>
+
+<div class="doc_text">
+
+<p>Several of the important data structures in LLVM are graphs: for example
+CFGs made out of LLVM <a href="#BasicBlock">BasicBlock</a>s, CFGs made out of
+LLVM <a href="CodeGenerator.html#machinebasicblock">MachineBasicBlock</a>s, and
+<a href="CodeGenerator.html#selectiondag_intro">Instruction Selection
+DAGs</a>.  In many cases, while debugging various parts of the compiler, it is
+nice to instantly visualize these graphs.</p>
+
+<p>LLVM provides several callbacks that are available in a debug build to do
+exactly that.  If you call the <tt>Function::viewCFG()</tt> method, for example,
+the current LLVM tool will pop up a window containing the CFG for the function
+where each basic block is a node in the graph, and each node contains the
+instructions in the block.  Similarly, there also exists 
+<tt>Function::viewCFGOnly()</tt> (does not include the instructions), the
+<tt>MachineFunction::viewCFG()</tt> and <tt>MachineFunction::viewCFGOnly()</tt>,
+and the <tt>SelectionDAG::viewGraph()</tt> methods.  Within GDB, for example,
+you can usually use something like "<tt>call DAG.viewGraph()</tt>" to pop
+up a window.  Alternatively, you can sprinkle calls to these functions in your
+code in places you want to debug.</p>
+
+<p>Getting this to work requires a small amount of configuration.  On Unix
+systems with X11, install the <a href="http://www.graphviz.org">graphviz</a>
+toolkit, and make sure 'dot' and 'gv' are in your path.  If you are running on
+Mac OS/X, download and install the Mac OS/X <a 
+href="http://www.pixelglow.com/graphviz/">Graphviz program</a>, and add
+<tt>/Applications/Graphviz.app/Contents/MacOS/</tt> (or whereever you install
+it) to your path.  Once in your system and path are set up, rerun the LLVM
+configure script and rebuild LLVM to enable this functionality.</p>
+
+</div>
+
+
 <!-- *********************************************************************** -->
 <div class="doc_section">
   <a name="common">Helpful Hints for Common Operations</a>

llvm/docs/Projects.html

@@ -87,6 +87,12 @@ provide enough information on how to write your own Makefiles.</p>
 choosing.  You can place it anywhere you like.  Rename the directory to match
 the name of your project.</li>
 
+<li>
+If you downloaded LLVM using CVS, remove all the directories named CVS (and all
+the files therein) from your project's new source tree.  This will keep CVS
+from thinking that your project is inside <tt>llvm/projects/sample</tt>.
+</li>
+
 <li>Add your source code and Makefiles to your source tree.</li>
 
 <li>If you want your project to be configured with the <tt>configure</tt> script

llvm/docs/ReleaseNotes.html

@@ -4,11 +4,11 @@
 <head>
   <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
   <link rel="stylesheet" href="llvm.css" type="text/css">
-  <title>LLVM 1.5 Release Notes</title>
+  <title>LLVM 1.6 Release Notes</title>
 </head>
 <body>
 
-<div class="doc_title">LLVM 1.5 Release Notes</div>
+<div class="doc_title">LLVM 1.6 Release Notes</div>
  
 <ol>
   <li><a href="#intro">Introduction</a></li>
@@ -20,7 +20,7 @@
 </ol>
 
 <div class="doc_author">
-  <p>Written by the <a href="http://llvm.cs.uiuc.edu">LLVM Team</a><p>
+  <p>Written by the <a href="http://llvm.org">LLVM Team</a><p>
 </div>
 
 <!-- *********************************************************************** -->
@@ -32,15 +32,15 @@
 <div class="doc_text">
 
 <p>This document contains the release notes for the LLVM compiler
-infrastructure, release 1.5.  Here we describe the status of LLVM, including any
+infrastructure, release 1.6.  Here we describe the status of LLVM, including any
 known problems and major improvements from the previous release.  The most
 up-to-date version of this document can be found on the <a
-href="http://llvm.cs.uiuc.edu/releases/1.5/">LLVM 1.5 web site</a>.  If you are
+href="http://llvm.org/releases/1.6/">LLVM 1.6 web site</a>.  If you are
 not reading this on the LLVM web pages, you should probably go there because
 this document may be updated after the release.</p>
 
 <p>For more information about LLVM, including information about the latest
-release, please check out the <a href="http://llvm.cs.uiuc.edu">main LLVM
+release, please check out the <a href="http://llvm.org/">main LLVM
 web site</a>.  If you have questions or comments, the <a
 href="http://mail.cs.uiuc.edu/mailman/listinfo/llvmdev">LLVM developer's mailing
 list</a> is a good place to send them.</p>
@@ -48,7 +48,7 @@ list</a> is a good place to send them.</p>
 <p>Note that if you are reading this file from CVS or the main LLVM web page,
 this document applies to the <i>next</i> release, not the current one.  To see
 the release notes for the current or previous releases, see the <a
-href="http://llvm.cs.uiuc.edu/releases/">releases page</a>.</p>
+href="http://llvm.org/releases/">releases page</a>.</p>
 
 </div>
 
@@ -60,286 +60,191 @@ href="http://llvm.cs.uiuc.edu/releases/">releases page</a>.</p>
 
 <div class="doc_text">
 
-<p>This is the sixth public release of the LLVM Compiler Infrastructure.</p>
-
-<p>LLVM 1.5 is known to correctly compile a wide range of C and C++ programs,
-includes bug fixes for those problems found since the 1.4 release, and includes
-a large number of new features and enhancements, described below.</p>
+<p>This is the seventh public release of the LLVM Compiler Infrastructure. This
+release incorporates a large number of enhancements and additions (primarily in
+the code generator), which combine to improve the quality of the code generated
+by LLVM by up to 30% in some cases.  This release is also the first release to
+have first-class support for Mac OS/X: all of the major bugs have been shaken
+out and it is now as well supported as Linux on X86.</p>
 
 </div>
 
 <!--=========================================================================-->
 <div class="doc_subsection">
-<a name="newfeatures">New Features in LLVM 1.5</a>
+<a name="newfeatures">New Features in LLVM 1.6</a>
 </div>
 
 <!--_________________________________________________________________________-->
-<div class="doc_subsubsection"><a name="newcg">New Native Code
-Generators</a></div>
+<div class="doc_subsubsection"><a name="iselgen">Instruction Selector
+Generation from Target Description</a></div>
 
 <div class="doc_text">
-<p>
-This release includes new native code generators for <a
-href="#alpha-be">Alpha</a>, <a href="#ia64-be">IA-64</a>, and <a
-href="#sparcv8">SPARC-V8</a> (32-bit SPARC).  These code generators are still
-beta quality, but are progressing rapidly.  The Alpha backend is implemented
-with an eye towards being compatible with the widely used SimpleScalar
-simulator.
-</p>
-</div>
+<p>LLVM now includes support for auto-generating large portions of the
+instruction selectors from target descriptions.  This allows us to
+write patterns in the target .td file, instead of writing lots of
+nasty C++ code.  Most of the PowerPC instruction selector is now
+generated from the PowerPC target description files and other targets
+are adding support that will be live for LLVM 1.7.</p>
 
-<!--_________________________________________________________________________-->
-<div class="doc_subsubsection"><a name="selectiondag">New Instruction
-Selector Framework</a></div>
+<p>For example, here are some patterns used by the PowerPC backend.  A 
+floating-point multiply then subtract instruction (FMSUBS):</p>
 
-<div class="doc_text">
-<p>This release includes a <a href="CodeGenerator.html#instselect">new framework
-for building instruction selectors</a>, which has long been the hardest part of
-building a new LLVM target.  This framework handles a lot of the mundane (but
-easy to get wrong) details of writing the instruction selector, such as
-generating efficient code for <a
-href="LangRef.html#i_getelementptr">getelementptr</a> instructions, promoting
-small integer types to larger types (e.g.  for RISC targets with one size of
-integer registers), expanding 64-bit integer operations for 32-bit targets, etc.
-Currently, the X86, PowerPC, Alpha, and IA-64 backends use this framework.  The
-SPARC backends will be migrated when time permits.
-</p>
-</div>
+<div class="doc_code"><p>
+<tt>(set F4RC:$FRT, (fsub (fmul F4RC:$FRA, F4RC:$FRC), F4RC:$FRB))</tt>
+</p></div>
 
-<!--_________________________________________________________________________-->
-<div class="doc_subsubsection"><a name="customccs">New Support for Per-Function
-Calling Conventions</a></div>
+<p>Exclusive-or by 16-bit immediate (XORI):</p>
 
-<div class="doc_text">
-<p>LLVM 1.5 adds supports for <a href="LangRef.html#callingconv">per-function
-calling conventions</a>.  Traditionally, the LLVM code generators match the
-native C calling conventions for a target.  This is important for compatibility,
-but is not very flexible.  This release allows custom calling conventions to be
-established for functions, and defines three target-independent conventions (<a
-href="LangRef.html#callingconv">C call, fast call, and cold call</a>) which may
-be supported by code generators.  When possible, the LLVM optimizer promotes C
-functions to use the "fastcc" convention, allowing the use of more efficient
-calling sequences (e.g., parameters are passed in registers in the X86 target).
-</p>
+<div class="doc_code"><p>
+<tt>(set GPRC:$dst, (xor GPRC:$src1, immZExt16:$src2))</tt>
+</p></div>
 
-<p>Targets may now also define target-specific calling conventions, allowing
-LLVM to fully support calling convention altering options (e.g. GCC's
-<tt>-mregparm</tt> flag) and well-defined target conventions (e.g. stdcall and
-fastcall on X86).</p>
-</div>
+<p>Exclusive-or by 16-bit immediate shifted right 16-bits (XORIS):</p>
 
-<!--_________________________________________________________________________-->
-<div class="doc_subsubsection"><a name="tailcalls">New Support for
-Proper Tail Calls</a></div>
+<div class="doc_code"><p>
+<tt>(set GPRC:$dst, (xor GPRC:$src1, imm16Shifted:$src2))</tt>
+</p></div>
 
-<div class="doc_text">
-<p>The release now includes support for <a
-href="http://doi.acm.org/10.1145/277650.277719">proper tail calls</a>, as
-required to implement languages like Scheme.  Tail calls make use of two
-features: custom calling conventions (described above), which allow the code
-generator to use a convention where the caller deallocates its stack before it
-returns.  The second feature is a flag on the <a href="LangRef.html#i_call">call
-instruction</a>, which indicates that the callee does not access the caller's
-stack frame (indicating that it is acceptable to deallocate the caller stack
-before invoking the callee).  LLVM proper tail calls run on the system stack (as
-do normal calls), supports indirect tail calls, tail calls with arbitrary
-numbers of arguments, tail calls where the callee requires more argument space
-than the caller, etc.  The only case not supported are varargs calls, but that
-could be added if desired.
-</p>
+<p>With these definitions, we teach the code generator how to combine these two
+instructions to xor an abitrary 32-bit immediate with the following
+definition.  The first line specifies what to match (a xor with an arbitrary
+immediate) the second line specifies what to produce:</p>
 
-<p>In order for a front-end to get a guaranteed tail call, it must mark
-functions as "fastcc", mark calls with the 'tail' marker, and follow the call
-with a return of the called value (or void).  The optimizer and code generator
-attempt to handle more general cases, but the simple case will always work if
-the code generator supports tail calls.  Here is an example:</p>
-
-<pre>
-    fastcc int %bar(int %X, int(double, int)* %FP) {       ;<i> fastcc</i>
-        %Y = tail call fastcc int %FP(double 0.0, int %X)  ;<i> tail, fastcc</i>
-        ret int %Y
-    }
+<div class="doc_code"><p>
+<pre>def : Pat&lt;(xor GPRC:$in, imm:$imm),
+          (XORIS (XORI GPRC:$in, (LO16 imm:$imm)), (HI16 imm:$imm))&gt;;
 </pre>
-
-<p>In LLVM 1.5, the X86 code generator is the only target that has been enhanced
-to support proper tail calls (other targets will be enhanced in future).
-Further, because this support was added very close to the release, it is
-disabled by default.  Pass <tt>-enable-x86-fastcc</tt> to llc to enable it (this
-will be enabled by default in the next release).  The example above compiles to:
-</p>
-
-<pre>
-    bar:
-        sub ESP, 8                   # Callee uses more space than the caller
-        mov ECX, DWORD PTR [ESP + 8] # Get the old return address
-        mov DWORD PTR [ESP + 4], 0   # First half of 0.0
-        mov DWORD PTR [ESP + 8], 0   # Second half of 0.0
-        mov DWORD PTR [ESP], ECX     # Put the return address where it belongs
-        jmp EDX                      # Tail call "FP"
-</pre>
-
-<p>
-With fastcc on X86, the first two integer arguments are passed in EAX/EDX, the
-callee pops its arguments off the stack, and the argument area is always a
-multiple of 8 bytes in size.
-</p>
+</p></div>
 
 </div>
 
 <!--_________________________________________________________________________-->
-<div class="doc_subsubsection">Other New Features</div>
+<div class="doc_subsubsection"><a name="sched">Instruction Scheduling
+Support</a></div>
+
+<div class="doc_text">
+
+<p>Instruction selectors using the refined <a 
+href="CodeGenerator.html#instselect">instruction selection framework</a> can now
+use a simple pre-pass scheduler included with LLVM 1.6.  This scheduler is 
+currently simple (cannot be configured much by the targets), but will be
+extended in the future.</p>
+</div>
+
+<!--_________________________________________________________________________-->
+<div class="doc_subsubsection"><a name="subtarget">Code Generator Subtarget
+Support</a></div>
+
+<div class="doc_text">
+<p>It is now straight-forward to parameterize a target implementation, and
+provide a mapping from CPU names to sets of target parameters.  LLC now supports
+a <tt>-mcpu=cpu</tt> option that lets you choose a subtarget by CPU name: use 
+"<tt>llvm-as &lt; /dev/null | llc -march=XXX -mcpu=help</tt>" to get a list of 
+supported CPUs for target "XXX".  It also provides a 
+<tt>-mattr=+attr1,-attr2</tt> option that can be used to control individual 
+features of a target (the previous command will list available features as
+well).</p>
+
+<p>This functionality is nice when you want tell LLC something like "compile to
+code that is specialized for the PowerPC G5, but doesn't use altivec code.  In
+this case, using "<tt>llc -march=ppc32 -mcpu=g5 -mattr=-altivec</tt>".</p>
+
+</div>
+
+<!--_________________________________________________________________________-->
+<div class="doc_subsubsection"><a name="jitlock">Other New Features</a></div>
 
 <div class="doc_text">
 <ol>
-  <li>LLVM now includes an <a href="http://llvm.cs.uiuc.edu/PR415">
-      Interprocedural Sparse Conditional Constant Propagation</a> pass, named
-     -ipsccp, which is run by default at link-time.</li>
-  <li>LLVM 1.5 is now about 15% faster than LLVM 1.4 and its core data 
-      structures use about 30% less memory.</li>
-  <li>Support for Microsoft Visual Studio is improved, and <a 
-      href="GettingStartedVS.html">now documented</a>.  Most LLVM tools build
-      natively with Visual C++ now.</li>
-  <li><a href="GettingStarted.html#config">Configuring LLVM to build a subset
-      of the available targets</a> is now implemented, via the
-      <tt>--enable-targets=</tt> option.</li>
-   <li>LLVM can now create native shared libraries with '<tt>llvm-gcc ...
-       -shared -Wl,-native</tt>' (or with <tt>-Wl,-native-cbe</tt>).</li>
-   <li>LLVM now supports a new "<a href="LangRef.html#i_prefetch">llvm.prefetch
-       </a>" intrinsic, and llvm-gcc now supports __builtin_prefetch.
-  <li>LLVM now supports intrinsics for <a href="LangRef.html#int_count">bit
-      counting</a> and llvm-gcc now implements the GCC
-      <tt>__builtin_popcount</tt>, <tt>__builtin_ctz</tt>, and
-      <tt>__builtin_clz</tt> builtins.</li>
-  <li>LLVM now mostly builds on HP-UX with the HP aCC Compiler.</li>
-  <li>The LLVM X86 backend can now emit Cygwin-compatible .s files.</li>
-  <li>LLVM now includes workarounds in the code generator generator which
-      reduces the likelyhood of <a href="http://llvm.cs.uiuc.edu/PR448">GCC
-      hitting swap during optimized builds</a>.</li>
-  <li>The <a href="http://llvm.cs.uiuc.edu/ProjectsWithLLVM/#llvmtv">LLVM
-      Transformation Visualizer</a> (llvm-tv) project has been updated to
-      work with LLVM CVS.</li>
-  <li>Nightly tester output is now archived on the <a
-      href="http://mail.cs.uiuc.edu/pipermail/llvm-testresults/">
-      llvm-testresults</a> mailing list.</li>
-
+  <li>The JIT now uses mutexes to protect its internal data structures. This
+  allows multi-threaded programs to be run from the JIT or interpreter without
+  corruption of the internal data structures. See 
+  <a href="http://llvm.org/PR418">PR418</a> and
+  <a href="http://llvm.org/PR540">PR540</a> for the details.
+  </li>
+  <li>LLVM on Win32 <a href="http://llvm.org/PR614">no longer requires sed,
+      flex, or bison when compiling with Visual C++</a>.</li>
+  <li>The llvm-test suite can now use the NAG Fortran to C compiler to compile
+    SPEC FP programs if available (allowing us to test all of SPEC'95 &amp; 
+    2000).</li>
+  <li>When bugpoint is grinding away and the user hits ctrl-C, it now
+    gracefully stops and gives what it has reduced so far, instead of
+    giving up completely.  In addition, <a href="http://llvm.org/PR576">the JIT
+    debugging mode of bugpoint is much faster</a>.</li>
+  <li>LLVM now includes Xcode project files in the llvm/Xcode directory.</li>
+  <li>LLVM now supports Mac OS/X on Intel.</li>
+  <li>LLVM now builds cleanly with GCC 4.1.</li>
 </ol>
 </div>
 
 <!--=========================================================================-->
 <div class="doc_subsection">
-<a name="codequality">Code Quality Improvements in LLVM 1.5</a>
+<a name="codequality">Code Quality Improvements in LLVM 1.6</a>
 </div>
 
 <div class="doc_text">
 <ol>
-<li>The new -simplify-libcalls pass improves code generated for well-known
-library calls. The pass optimizes calls to many of the string, memory, and
-standard I/O functions (e.g. replace the calls with simpler/faster calls) when
-possible, given information known statically about the arguments to the call.
-</li>
-
-<li>The -globalopt pass now promotes non-address-taken static globals that are
-only accessed in main to SSA registers.</li>
-
-<li>Loops with trip counts based on array pointer comparisons (e.g. "<tt>for (i
-= 0; &amp;A[i] != &amp;A[n]; ++i) ...</tt>") are optimized better than before,
-which primarily helps iterator-intensive C++ codes.</li>
-
-<li>The optimizer now eliminates simple cases where redundant conditions exist
-    between neighboring blocks.</li>
-
-<li>The reassociation pass (which turns (1+X+3) into (X+1+3) among other
-things), is more aggressive and intelligent.</li>
-
-<li>The -prune-eh pass now detects no-return functions in addition to the
-    no-unwind functions it did before.</li>
-
-<li>The -globalsmodref alias analysis generates more precise results in some
-    cases.</li>
+  <li>The <tt>-globalopt</tt> pass can now statically evaluate C++ static
+      constructors when they are simple enough.  For example, it can
+    now statically initialize "<tt>struct X { int a; X() : a(4) {} } g;</tt>".
+  </li>
+  <li>The Loop Strength Reduction pass has been completely rewritten, is far
+      more aggressive, and is turned on by default in the RISC targets.  On PPC,
+      we find that it often speeds up programs from 10-40% depending on the
+      program.</li>
+  <li>The code produced when exception handling is enabled is far more
+      efficient in some cases, particularly on Mac OS/X.</li>
 </ol>
 </div>
 
 
 <!--=========================================================================-->
 <div class="doc_subsection">
-<a name="codequality">Code Generator Improvements in LLVM 1.5</a>
+<a name="codequality">Code Generator Improvements in LLVM 1.6</a>
 </div>
 
 <div class="doc_text">
 <ol>
-<li>The code generator now can provide and use information about commutative
-    two-address instructions when performing register allocation.</li>
-
-<li>The code generator now tracks function live-in registers explicitly, 
-    instead of requiring the target to generate 'implicit defs' at the
-    entry to a function.</li>
-
-<li>The code generator can lower integer division by a constant to
-    multiplication by a magic constant and multiplication by a constant into
-    shift/add sequences.</li>
-
-<li>The code generator compiles fabs/fneg/sin/cos/sqrt to assembly instructions
-    when possible.</li>
-
-<li>The PowerPC backend generates better code in many cases, making use of 
-    FMA instructions and the recording ("dot") forms of various PowerPC
-    instructions.</li>
+<li>The Alpha backend is substantially more stable and robust than in LLVM 1.5.
+    For example, it now fully supports varargs functions.  The Alpha backend
+    also now features beta JIT support.</li>
+<li>The code generator contains a new component, the DAG Combiner.  This allows
+    us to optimize lowered code (e.g. after 64-bit operations have been lowered
+    to use 32-bit registers on 32-bit targets) and do fine-grained bit-twiddling
+    optimizations for the backend.</li>
+<li>The SelectionDAG infrastructure is far more capable and mature, able to
+    handle many new target peculiarities in a target-independent way.</li>
+<li>The default <a href="http://llvm.org/PR547">register allocator is now far
+    faster on some testcases</a>,
+    particularly on targets with a large number of registers (e.g. IA64
+    and PPC).</li>
 </ol>
 </div>
 
-
 <!--=========================================================================-->
 <div class="doc_subsection">
-<a name="bugfix">Significant Bugs Fixed in LLVM 1.5</a>
+<a name="bugfix">Significant Bugs Fixed in LLVM 1.6</a>
 </div>
 
 <div class="doc_text">
-
-
-<p>Bugs fixed in the LLVM Core:</p>
 <ol>
-   <li><a href="http://llvm.cs.uiuc.edu/PR491">[dse] DSE deletes stores that 
-       are partially overwritten by smaller stores</a></li>
-   <li><a href="http://llvm.cs.uiuc.edu/PR548">[instcombine] miscompilation of 
-       setcc or setcc in one case</a></li>
-   <li>Transition code for LLVM 1.0 style varargs was removed from the .ll file
-       parser.  LLVM 1.0 bytecode files are still supported. </li>
+  <li>A vast number of bugs have been fixed in the PowerPC backend and in
+      llvm-gcc when configured for Mac OS/X (particularly relating to ABI
+      issues).  For example:
+      <a href="http://llvm.org/PR603">PR449</a>,
+      <a href="http://llvm.org/PR594">PR594</a>, 
+      <a href="http://llvm.org/PR603">PR603</a>,
+      <a href="http://llvm.org/PR609">PR609</a>, 
+      <a href="http://llvm.org/PR630">PR630</a>, 
+      <a href="http://llvm.org/PR643">PR643</a>, 
+      and several others without bugzilla bugs.</li>
+  <li>Several bugs in tail call support have been fixed.</li>
+  <li><a href="http://llvm.org/PR608">configure does not correctly detect gcc 
+      version on cygwin</a>.</li>
+  <li>Many many other random bugs have been fixed.  Query <a 
+      href="http://llvm.org/bugs">our bugzilla</a> with a target of 1.6 for more
+      information.</li>
 </ol>
-
-<p>Code Generator Bugs:</p>
-<ol>
-   <li><a href="http://llvm.cs.uiuc.edu/PR490">[cbackend] Logical constant 
-       expressions (and/or/xor) not implemented</a>.</li>
-   <li><a href="http://llvm.cs.uiuc.edu/PR511">[cbackend] C backend does not 
-       respect 'volatile'</a>.</li>
-   <li>The JIT sometimes miscompiled globals and constant pool entries for
-       64-bit integer constants on 32-bit hosts.</li>
-   <li>The C backend should no longer produce code that crashes ICC 8.1.</li>
-</ol>
-
-<p>Bugs in the C/C++ front-end:</p>
-<ol>
-   <li><a href="http://llvm.cs.uiuc.edu/PR487">[llvmgcc] llvm-gcc incorrectly 
-       rejects some constant initializers involving the addresses of array 
-       elements</a></li>
-   <li><a href="http://llvm.cs.uiuc.edu/PR501">[llvm-g++] Crash compiling 
-       anonymous union</a></li>
-   <li><a href="http://llvm.cs.uiuc.edu/PR509">[llvm-g++] Do not use dynamic 
-       initialization where static init will do</a></li>
-   <li><a href="http://llvm.cs.uiuc.edu/PR510">[llvmgcc] Field offset 
-       miscalculated for some structure fields following bit fields</a></li>
-   <li><a href="http://llvm.cs.uiuc.edu/PR513">[llvm-g++] Temporary lifetimes 
-       incorrect for short circuit logical operations</a></li>
-   <li><a href="http://llvm.cs.uiuc.edu/PR517">[llvm-gcc] Crash compiling 
-       bitfield &lt;-&gt; aggregate assignment</a></li>
-   <li><a href="http://llvm.cs.uiuc.edu/PR520">[llvm-g++] Error compiling 
-       virtual function thunk with an unnamed argument</a></li>
-   <li><a href="http://llvm.cs.uiuc.edu/PR522">[llvm-gcc] Crash on certain 
-       C99 complex number routines</a></li>
-   <li><a href="http://llvm.cs.uiuc.edu/PR529">[llvm-g++] Crash using placement
-       new on an array type</a></li>
-</ol>
-
 </div>
 
 <!-- *********************************************************************** -->
@@ -353,12 +258,12 @@ things), is more aggressive and intelligent.</li>
 <p>LLVM is known to work on the following platforms:</p>
 
 <ul>
-<li>Intel and AMD machines running Red Hat Linux and FreeBSD (and probably 
-    other unix-like systems).</li>
+  <li>Intel and AMD machines running Red Hat Linux, Fedora Core and FreeBSD 
+      (and probably other unix-like systems).</li>
 <li>Sun UltraSPARC workstations running Solaris 8.</li>
 <li>Intel and AMD machines running on Win32 with the Cygwin libraries (limited
     support is available for native builds with Visual C++).</li>
-<li>PowerPC-based Mac OS X systems, running 10.2 and above.</li>
+<li>PowerPC and X86-based Mac OS X systems, running 10.2 and above.</li>
 <li>Alpha-based machines running Debian GNU/Linux.</li>
 <li>Itanium-based machines running Linux and HP-UX.</li>
 </ul>
@@ -382,7 +287,7 @@ portability patches and reports of successful builds or error messages.</p>
 <p>This section contains all known problems with the LLVM system, listed by
 component.  As new problems are discovered, they will be added to these
 sections.  If you run into a problem, please check the <a
-href="http://llvm.cs.uiuc.edu/bugs/">LLVM bug database</a> and submit a bug if
+href="http://llvm.org/bugs/">LLVM bug database</a> and submit a bug if
 there isn't already one.</p>
 
 </div>
@@ -402,16 +307,28 @@ components, please contact us on the llvmdev list.</p>
 
 <ul>
 <li>The following passes are incomplete or buggy, and may be removed in future
-    releases: <tt>-cee, -branch-combine, -instloops, -paths, -pre</tt></li>
+    releases: <tt>-cee, -pre</tt></li>
 <li>The <tt>llvm-db</tt> tool is in a very early stage of development, but can
     be used to step through programs and inspect the stack.</li>
-<li>The "iterative scan" register allocator (enabled with 
-    <tt>-regalloc=iterativescan</tt>) is not stable.</li>
-<li>The SparcV8, Alpha, and IA64 code generators are experimental.</li>
+<li>The SparcV8 and IA64 code generators are experimental.</li>
+<li>The Alpha JIT is experimental.</li>
 </ul>
 
 </div>
 
+<!-- ======================================================================= -->
+<div class="doc_subsection">
+  <a name="build">Known problems with the Build System</a>
+</div>
+
+<div class="doc_text">
+
+<ul>
+  <li>The <a href="http://llvm.org/PR656">configure script sometimes fails on Solaris/Sparc</a>. A work around is documented in <a href="http://llvm.org/PR656">PR656.</a></li>
+</ul>
+</div>
+
+
 <!-- ======================================================================= -->
 <div class="doc_subsection">
   <a name="core">Known problems with the LLVM Core</a>
@@ -422,14 +339,6 @@ components, please contact us on the llvmdev list.</p>
 <ul>
   <li>In the JIT, <tt>dlsym()</tt> on a symbol compiled by the JIT will not
   work.</li>
-  <li>The JIT does not use mutexes to protect its internal data structures. As
-  such, execution of a threaded program could cause these data structures to be
-  corrupted.
-  </li>
-  <li><a href="http://llvm.cs.uiuc.edu/PR240">The lower-invoke pass does not 
-    mark values live across a setjmp as volatile</a>. This missing feature 
-  only affects targets whose setjmp/longjmp libraries do not save and restore 
-  the entire register file.</li>
 </ul>
 </div>
 
@@ -453,7 +362,7 @@ components, please contact us on the llvmdev list.</p>
 </pre></li>
 
 <li>Initialization of global union variables can only be done <a
-href="http://llvm.cs.uiuc.edu/PR162">with the largest union member</a>.</li>
+href="http://llvm.org/PR162">with the largest union member</a>.</li>
 
 </ul>
 </div>
@@ -678,7 +587,7 @@ Analysis rules.  As such, special options may be necessary to compile the code
 (for example, GCC requires the <tt>-fno-strict-aliasing</tt> option).  This
 problem probably cannot be fixed.</li>
 
-<li><a href="http://llvm.cs.uiuc.edu/PR56">Zero arg vararg functions are not 
+<li><a href="http://llvm.org/PR56">Zero arg vararg functions are not 
 supported</a>.  This should not affect LLVM produced by the C or C++ 
 frontends.</li>
 
@@ -694,7 +603,8 @@ frontends.</li>
 <div class="doc_text">
 
 <ul>
-  <li>None yet</li>
+<li><a href="http://llvm.org/PR566">Memory Mapped I/O Intrinsics do not fence 
+memory</a></li>
 </ul>
 
 </div>
@@ -720,7 +630,7 @@ frontends.</li>
 <div class="doc_text">
 
 <ul>
-<li><a href="http://llvm.cs.uiuc.edu/PR60">[sparcv9] SparcV9 backend miscompiles
+<li><a href="http://llvm.org/PR60">[sparcv9] SparcV9 backend miscompiles
 several programs in the LLVM test suite</a></li>
 </ul>
 
@@ -738,10 +648,6 @@ several programs in the LLVM test suite</a></li>
 <li>On 21164s, some rare FP arithmetic sequences which may trap do not have the
 appropriate nops inserted to ensure restartability.</li>
 
-<li>Defining vararg functions is not supported (but calling them is ok).</li>
-
-<li>Due to the vararg problems, C++ exceptions do not work.  Small changes are required to the CFE (which break correctness in the exception handler) to compile the exception handling library (and thus the C++ standard library).</li>
-
 </ul>
 
 </div>
@@ -760,7 +666,7 @@ made where the argument is not 16-byte aligned, as required on IA64. (Strictly
 speaking this is not a bug in the IA64 back-end; it will also be encountered
 when building C++ programs using the C back-end.)</li>
 
-<li>The C++ front-end does not use <a href="http://llvm.cs.uiuc.edu/PR406">IA64
+<li>The C++ front-end does not use <a href="http://llvm.org/PR406">IA64
 ABI compliant layout of v-tables</a>.  In particular, it just stores function
 pointers instead of function descriptors in the vtable.  This bug prevents
 mixing C++ code compiled with LLVM with C++ objects compiled by other C++
@@ -785,12 +691,8 @@ programs.</li>
 
 <ul>
 <li>Many features are still missing (e.g. support for 64-bit integer
-arithmetic).</li>
-
-<li>This backend needs to be updated to use the SelectionDAG instruction
-selection framework.</li>
+arithmetic).  This back-end is in pre-beta state.</li>
 </ul>
-
 </div>
 
 <!-- *********************************************************************** -->
@@ -802,16 +704,16 @@ selection framework.</li>
 <div class="doc_text">
 
 <p>A wide variety of additional information is available on the <a
-href="http://llvm.cs.uiuc.edu">LLVM web page</a>, including <a
-href="http://llvm.cs.uiuc.edu/docs/">documentation</a> and <a
-href="http://llvm.cs.uiuc.edu/pubs/">publications describing algorithms and
+href="http://llvm.org">LLVM web page</a>, including <a
+href="http://llvm.org/docs/">documentation</a> and <a
+href="http://llvm.org/pubs/">publications describing algorithms and
 components implemented in LLVM</a>.  The web page also contains versions of the
 API documentation which is up-to-date with the CVS version of the source code.
 You can access versions of these documents specific to this release by going
 into the "<tt>llvm/doc/</tt>" directory in the LLVM tree.</p>
 
 <p>If you have any questions or comments about LLVM, please feel free to contact
-us via the <a href="http://llvm.cs.uiuc.edu/docs/#maillist"> mailing
+us via the <a href="http://llvm.org/docs/#maillist"> mailing
 lists</a>.</p>
 
 </div>
@@ -825,7 +727,7 @@ lists</a>.</p>
   <a href="http://validator.w3.org/check/referer"><img
   src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!" /></a>
 
-  <a href="http://llvm.cs.uiuc.edu">The LLVM Compiler Infrastructure</a><br>
+  <a href="http://llvm.org/">The LLVM Compiler Infrastructure</a><br>
   Last modified: $Date$
 </address>
 

llvm/docs/TableGenFundamentals.html

@@ -309,6 +309,8 @@ supported include:</p>
 <li><tt>value{17}</tt> - access to one bit of a value</li>
 <li><tt>value{15-17}</tt> - access to multiple bits of a value</li>
 <li><tt>DEF</tt> - reference to a record definition</li>
+<li><tt>CLASS&lt;val list&gt;</tt> - reference to a new anonymous definition of
+        CLASS with the specified template arguments.</li>
 <li><tt>X.Y</tt> - reference to the subfield of a value</li>
 <li><tt>list[4-7,17,2-3]</tt> - A slice of the 'list' list, including elements 
 4,5,6,7,17,2, and 3 from it.  Elements may be included multiple times.</li>
@@ -335,7 +337,7 @@ for different types.  These rules allow you to assign a value like "7" to a
 information that TableGen collects.  Records are defined with a <tt>def</tt> or
 <tt>class</tt> keyword, the record name, and an optional list of "<a
 href="#templateargs">template arguments</a>".  If the record has superclasses,
-they are specified as a comma seperated list that starts with a colon character
+they are specified as a comma separated list that starts with a colon character
 (":").  If <a href="#valuedef">value definitions</a> or <a href="#recordlet">let
 expressions</a> are needed for the class, they are enclosed in curly braces
 ("{}"); otherwise, the record ends with a semicolon.  Here is a simple TableGen
@@ -515,7 +517,7 @@ multiple records at a time, and may be useful in certain other cases.
 File-scope let expressions are really just another way that TableGen allows the
 end-user to factor out commonality from the records.</p>
 
-<p>File-scope "let" expressions take a comma-seperated list of bindings to
+<p>File-scope "let" expressions take a comma-separated list of bindings to
 apply, and one of more records to bind the values in.  Here are some
 examples:</p>
 

llvm/docs/WritingAnLLVMBackend.html

@@ -68,21 +68,21 @@ convert the LLVM representation to machine assembly code or other languages.</p>
 implement the following:</p>
 
 <ul>
-<li>Describe the register set
+<li>Describe the register set.
   <ul>
   <li>Create a <a href="TableGenFundamentals.html">TableGen</a> description of
       the register set and register classes</li>
   <li>Implement a subclass of <tt><a
       href="CodeGenerator.html#mregisterinfo">MRegisterInfo</a></tt></li>
   </ul></li>
-<li>Describe the instruction set
+<li>Describe the instruction set.
   <ul>
   <li>Create a <a href="TableGenFundamentals.html">TableGen</a> description of
       the instruction set</li>
   <li>Implement a subclass of <tt><a
       href="CodeGenerator.html#targetinstrinfo">TargetInstrInfo</a></tt></li>
   </ul></li>
-<li>Describe the target machine
+<li>Describe the target machine.
   <ul>
   <li>Create a <a href="TableGenFundamentals.html">TableGen</a> description of
       the target that describes the pointer size and references the instruction
@@ -104,37 +104,37 @@ RegisterTarget&lt;<em>MyTargetMachine</em>&gt; M("short_name", "  Target name");
       is the description of your target to appear in <tt>-help</tt>
       listing.</li>
   </ul></li>
-<li>Implement the assembly printer for the architecture.  Usually, if you have
-described the instruction set with the assembly printer generator in mind, that
-step can be almost automated.</li>
-</ul>
-
-<p>Now, for static code generation you also need to write an instruction
-selector for your platform: see <tt>lib/Target/*/*ISelSimple.cpp</tt> which
-is no longer "simple" but it gives you the idea: you have to be able to create
-MachineInstrs for any given LLVM instruction using the <tt>InstVisitor</tt>
-pattern, and produce a <tt>MachineFunction</tt> with
-<tt>MachineBasicBlock</tt>s full of <tt><a
-href="CodeGenerator.html#machineinstr">MachineInstr</a></tt>s for a
-corresponding LLVM Function.  Creating an instruction selector is perhaps the
-most time-consuming part of creating a back-end.</p> 
-
-<p>To create a JIT for your platform:</p>
-
+<li>Implement the assembly printer for the architecture.
+  <ul>
+  <li>Define all of the assembly strings for your target, adding them to the
+      instructions in your *InstrInfo.td file.</li>
+  <li>Implement the <tt>llvm::AsmPrinter</tt> interface.</li>
+  </ul>
+</li>
+<li>Implement an instruction selector for the architecture.
+  <ul>
+  <li>The recommended method is the <a href="CodeGenerator.html#instselect">
+      pattern-matching DAG-to-DAG instruction selector</a> (for example, see
+      the PowerPC backend in PPCISelDAGtoDAG.cpp).  Parts of instruction
+      selector creation can be performed by adding patterns to the instructions
+      in your <tt>.td</tt> file.</li>
+  </ul>
+</li>
+<li>Optionally, add subtarget support.
 <ul>
-<li>Create a subclass of <tt><a
-    href="CodeGenerator.html#targetjitinfo">TargetJITInfo</a></tt></li>
-<li>Create a machine code emitter that will be used to emit binary code
-    directly into memory, given <tt>MachineInstr</tt>s</li>
+  <li>If your target has multiple subtargets (e.g. variants with different
+      capabilities), implement the <tt>llvm::TargetSubtarget</tt> interface
+      for your architecture.  This allows you to add <tt>-mcpu=</tt> and 
+      <tt>-mattr=</tt> options.</li>
+</ul>
+<li>Optionally, add JIT support.
+  <ul>
+  <li>Create a subclass of <tt><a
+      href="CodeGenerator.html#targetjitinfo">TargetJITInfo</a></tt></li>
+  <li>Create a machine code emitter that will be used to emit binary code
+      directly into memory, given <tt>MachineInstr</tt>s</li>
+  </ul>
 </ul>
-
-<p>Note that <tt>lib/target/Skeleton</tt> is a clean skeleton for a new target,
-so you might want to start with that and adapt it for your target, and if you
-are wondering how things are done, peek in the X86 or PowerPC target.</p>
-
-<p>The Skeleton target is non-functional but provides the basic building blocks
-you will need for your endeavor.</p>
-
 </div>
 
 <!-- _______________________________________________________________________ -->
@@ -229,10 +229,13 @@ how the C backend is written.</p>
 <ul>
 <li><a href="CodeGenerator.html">Code generator</a> -
     describes some of the classes in code generation at a high level, but
-    it is not (yet) complete.</li>
+    it is not (yet) complete</li>
 <li><a href="TableGenFundamentals.html">TableGen fundamentals</a> -
-    describes how to use TableGen to describe your target information succinctly
-</li>
+    describes how to use TableGen to describe your target information
+    succinctly</li>
+<li><a href="HowToSubmitABug.html#codegen">Debugging code generation with
+    bugpoint</a> - shows bugpoint usage scenarios to simplify backend
+    development</li>
 </ul>
 
 </div>

llvm/docs/WritingAnLLVMPass.html

@@ -471,9 +471,9 @@ following signature:</p>
   <b>virtual bool</b> runOnModule(Module &amp;M) = 0;
 </pre>
 
-<p>The <tt>runOnModule</tt> method performs the interesting work of the pass,
-and should return true if the module was modified by the transformation, false
-otherwise.</p>
+<p>The <tt>runOnModule</tt> method performs the interesting work of the pass.
+It should return true if the module was modified by the transformation and
+false otherwise.</p>
 
 </div>
 

llvm/examples/Fibonacci/fibonacci.cpp

@@ -37,7 +37,8 @@ using namespace llvm;
 static Function *CreateFibFunction(Module *M) {
   // Create the fib function and insert it into module M.  This function is said
   // to return an int and take an int parameter.
-  Function *FibF = M->getOrInsertFunction("fib", Type::IntTy, Type::IntTy, 0);
+  Function *FibF = M->getOrInsertFunction("fib", Type::IntTy, Type::IntTy,
+                                          (Type *)0);
 
   // Add a basic block to the function.
   BasicBlock *BB = new BasicBlock("EntryBlock", FibF);

llvm/examples/HowToUseJIT/HowToUseJIT.cpp

@@ -51,7 +51,8 @@ int main() {
   // Create the add1 function entry and insert this entry into module M.  The
   // function will have a return type of "int" and take an argument of "int".
   // The '0' terminates the list of argument types.
-  Function *Add1F = M->getOrInsertFunction("add1", Type::IntTy, Type::IntTy, 0);
+  Function *Add1F = M->getOrInsertFunction("add1", Type::IntTy, Type::IntTy,
+                                           (Type *)0);
 
   // Add a basic block to the function. As before, it automatically inserts
   // because of the last argument.
@@ -76,7 +77,7 @@ int main() {
 
   // Now we going to create function `foo', which returns an int and takes no
   // arguments.
-  Function *FooF = M->getOrInsertFunction("foo", Type::IntTy, 0);
+  Function *FooF = M->getOrInsertFunction("foo", Type::IntTy, (Type *)0);
 
   // Add a basic block to the FooF function.
   BB = new BasicBlock("EntryBlock", FooF);

llvm/examples/Makefile

@@ -11,6 +11,6 @@ LEVEL=..
 include $(LEVEL)/Makefile.config
 
 #PARALLEL_DIRS:= $(patsubst %/Makefile,%,$(wildcard $(SourceDir)/*/Makefile))
-PARALLEL_DIRS:= Fibonacci HowToUseJIT ModuleMaker BFtoLLVM
+PARALLEL_DIRS:= ParallelJIT Fibonacci HowToUseJIT ModuleMaker BFtoLLVM
 
 include $(LEVEL)/Makefile.common

llvm/examples/ParallelJIT/Makefile

@@ -0,0 +1,18 @@
+##===- examples/ParallelJIT/Makefile -----------------------*- Makefile -*-===##
+# 
+#                     The LLVM Compiler Infrastructure
+#
+# This file was developed by Reid A. Spencer and is distributed under
+# the University of Illinois Open Source License. See LICENSE.TXT for details.
+# 
+##===----------------------------------------------------------------------===##
+LEVEL = ../..
+TOOLNAME = ParallelJIT
+EXAMPLE_TOOL = 1
+
+# Enable JIT support
+LLVMLIBS := JIT
+
+include $(LEVEL)/Makefile.common
+
+LIBS += -lpthread

llvm/examples/ParallelJIT/ParallelJIT.cpp

@@ -0,0 +1,297 @@
+//===-- examples/ParallelJIT/ParallelJIT.cpp - Exercise threaded-safe JIT -===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by Evan Jones and is distributed under the
+// University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Parallel JIT
+//
+// This test program creates two LLVM functions then calls them from three
+// separate threads.  It requires the pthreads library.
+// The three threads are created and then block waiting on a condition variable.
+// Once all threads are blocked on the conditional variable, the main thread
+// wakes them up. This complicated work is performed so that all three threads
+// call into the JIT at the same time (or the best possible approximation of the
+// same time). This test had assertion errors until I got the locking right.
+
+#include <pthread.h>
+#include "llvm/Module.h"
+#include "llvm/Constants.h"
+#include "llvm/Type.h"
+#include "llvm/Instructions.h"
+#include "llvm/ModuleProvider.h"
+#include "llvm/ExecutionEngine/ExecutionEngine.h"
+#include "llvm/ExecutionEngine/GenericValue.h"
+#include <iostream>
+using namespace llvm;
+
+static Function* createAdd1(Module* M)
+{
+  // Create the add1 function entry and insert this entry into module M.  The
+  // function will have a return type of "int" and take an argument of "int".
+  // The '0' terminates the list of argument types.
+  Function *Add1F = M->getOrInsertFunction("add1", Type::IntTy, Type::IntTy,
+                                           (Type *)0);
+
+  // Add a basic block to the function. As before, it automatically inserts
+  // because of the last argument.
+  BasicBlock *BB = new BasicBlock("EntryBlock", Add1F);
+
+  // Get pointers to the constant `1'.
+  Value *One = ConstantSInt::get(Type::IntTy, 1);
+
+  // Get pointers to the integer argument of the add1 function...
+  assert(Add1F->arg_begin() != Add1F->arg_end()); // Make sure there's an arg
+  Argument *ArgX = Add1F->arg_begin();  // Get the arg
+  ArgX->setName("AnArg");            // Give it a nice symbolic name for fun.
+
+  // Create the add instruction, inserting it into the end of BB.
+  Instruction *Add = BinaryOperator::createAdd(One, ArgX, "addresult", BB);
+
+  // Create the return instruction and add it to the basic block
+  new ReturnInst(Add, BB);
+
+  // Now, function add1 is ready.
+  return Add1F;
+}
+
+static Function *CreateFibFunction(Module *M)
+{
+  // Create the fib function and insert it into module M.  This function is said
+  // to return an int and take an int parameter.
+  Function *FibF = M->getOrInsertFunction("fib", Type::IntTy, Type::IntTy,
+                                          (Type *)0);
+
+  // Add a basic block to the function.
+  BasicBlock *BB = new BasicBlock("EntryBlock", FibF);
+
+  // Get pointers to the constants.
+  Value *One = ConstantSInt::get(Type::IntTy, 1);
+  Value *Two = ConstantSInt::get(Type::IntTy, 2);
+
+  // Get pointer to the integer argument of the add1 function...
+  Argument *ArgX = FibF->arg_begin();   // Get the arg.
+  ArgX->setName("AnArg");            // Give it a nice symbolic name for fun.
+
+  // Create the true_block.
+  BasicBlock *RetBB = new BasicBlock("return", FibF);
+  // Create an exit block.
+  BasicBlock* RecurseBB = new BasicBlock("recurse", FibF);
+
+  // Create the "if (arg < 2) goto exitbb"
+  Value *CondInst = BinaryOperator::createSetLE(ArgX, Two, "cond", BB);
+  new BranchInst(RetBB, RecurseBB, CondInst, BB);
+
+  // Create: ret int 1
+  new ReturnInst(One, RetBB);
+
+  // create fib(x-1)
+  Value *Sub = BinaryOperator::createSub(ArgX, One, "arg", RecurseBB);
+  Value *CallFibX1 = new CallInst(FibF, Sub, "fibx1", RecurseBB);
+
+  // create fib(x-2)
+  Sub = BinaryOperator::createSub(ArgX, Two, "arg", RecurseBB);
+  Value *CallFibX2 = new CallInst(FibF, Sub, "fibx2", RecurseBB);
+
+  // fib(x-1)+fib(x-2)
+  Value *Sum =
+    BinaryOperator::createAdd(CallFibX1, CallFibX2, "addresult", RecurseBB);
+
+  // Create the return instruction and add it to the basic block
+  new ReturnInst(Sum, RecurseBB);
+
+  return FibF;
+}
+
+struct threadParams {
+  ExecutionEngine* EE;
+  Function* F;
+  int value;
+};
+
+// We block the subthreads just before they begin to execute:
+// we want all of them to call into the JIT at the same time,
+// to verify that the locking is working correctly.
+class WaitForThreads
+{
+public:
+  WaitForThreads()
+  {
+    n = 0;
+    waitFor = 0;
+
+    int result = pthread_cond_init( &condition, NULL );
+    assert( result == 0 );
+
+    result = pthread_mutex_init( &mutex, NULL );
+    assert( result == 0 );
+  }
+
+  ~WaitForThreads()
+  {
+    int result = pthread_cond_destroy( &condition );
+    assert( result == 0 );
+
+    result = pthread_mutex_destroy( &mutex );
+    assert( result == 0 );
+  }
+
+  // All threads will stop here until another thread calls releaseThreads
+  void block()
+  {
+    int result = pthread_mutex_lock( &mutex );
+    assert( result == 0 );
+    n ++;
+    //~ std::cout << "block() n " << n << " waitFor " << waitFor << std::endl;
+
+    assert( waitFor == 0 || n <= waitFor );
+    if ( waitFor > 0 && n == waitFor )
+    {
+      // There are enough threads blocked that we can release all of them
+      std::cout << "Unblocking threads from block()" << std::endl;
+      unblockThreads();
+    }
+    else
+    {
+      // We just need to wait until someone unblocks us
+      result = pthread_cond_wait( &condition, &mutex );
+      assert( result == 0 );
+    }
+
+    // unlock the mutex before returning
+    result = pthread_mutex_unlock( &mutex );
+    assert( result == 0 );
+  }
+
+  // If there are num or more threads blocked, it will signal them all
+  // Otherwise, this thread blocks until there are enough OTHER threads
+  // blocked
+  void releaseThreads( size_t num )
+  {
+    int result = pthread_mutex_lock( &mutex );
+    assert( result == 0 );
+
+    if ( n >= num ) {
+      std::cout << "Unblocking threads from releaseThreads()" << std::endl;
+      unblockThreads();
+    }
+    else
+    {
+      waitFor = num;
+      pthread_cond_wait( &condition, &mutex );
+    }
+
+    // unlock the mutex before returning
+    result = pthread_mutex_unlock( &mutex );
+    assert( result == 0 );
+  }
+
+private:
+  void unblockThreads()
+  {
+    // Reset the counters to zero: this way, if any new threads
+    // enter while threads are exiting, they will block instead
+    // of triggering a new release of threads
+    n = 0;
+
+    // Reset waitFor to zero: this way, if waitFor threads enter
+    // while threads are exiting, they will block instead of
+    // triggering a new release of threads
+    waitFor = 0;
+
+    int result = pthread_cond_broadcast( &condition );
+    assert( result == 0 );
+  }
+
+  size_t n;
+  size_t waitFor;
+  pthread_cond_t condition;
+  pthread_mutex_t mutex;
+};
+
+static WaitForThreads synchronize;
+
+void* callFunc( void* param )
+{
+  struct threadParams* p = (struct threadParams*) param;
+
+  // Call the `foo' function with no arguments:
+  std::vector<GenericValue> Args(1);
+  Args[0].IntVal = p->value;
+
+  synchronize.block(); // wait until other threads are at this point
+  GenericValue gv = p->EE->runFunction(p->F, Args);
+
+  return (void*) intptr_t(gv.IntVal);
+}
+
+int main()
+{
+  // Create some module to put our function into it.
+  Module *M = new Module("test");
+
+  Function* add1F = createAdd1( M );
+  Function* fibF = CreateFibFunction( M );
+
+  // Now we create the JIT.
+  ExistingModuleProvider* MP = new ExistingModuleProvider(M);
+  ExecutionEngine* EE = ExecutionEngine::create(MP, false);
+
+  //~ std::cout << "We just constructed this LLVM module:\n\n" << *M;
+  //~ std::cout << "\n\nRunning foo: " << std::flush;
+
+  // Create one thread for add1 and two threads for fib
+  struct threadParams add1 = { EE, add1F, 1000 };
+  struct threadParams fib1 = { EE, fibF, 39 };
+  struct threadParams fib2 = { EE, fibF, 42 };
+
+  pthread_t add1Thread;
+  int result = pthread_create( &add1Thread, NULL, callFunc, &add1 );
+  if ( result != 0 ) {
+          std::cerr << "Could not create thread" << std::endl;
+          return 1;
+  }
+
+  pthread_t fibThread1;
+  result = pthread_create( &fibThread1, NULL, callFunc, &fib1 );
+  if ( result != 0 ) {
+          std::cerr << "Could not create thread" << std::endl;
+          return 1;
+  }
+
+  pthread_t fibThread2;
+  result = pthread_create( &fibThread2, NULL, callFunc, &fib2 );
+  if ( result != 0 ) {
+          std::cerr << "Could not create thread" << std::endl;
+          return 1;
+  }
+
+  synchronize.releaseThreads(3); // wait until other threads are at this point
+
+  void* returnValue;
+  result = pthread_join( add1Thread, &returnValue );
+  if ( result != 0 ) {
+          std::cerr << "Could not join thread" << std::endl;
+          return 1;
+  }
+  std::cout << "Add1 returned " << intptr_t(returnValue) << std::endl;
+
+  result = pthread_join( fibThread1, &returnValue );
+  if ( result != 0 ) {
+          std::cerr << "Could not join thread" << std::endl;
+          return 1;
+  }
+  std::cout << "Fib1 returned " << intptr_t(returnValue) << std::endl;
+
+  result = pthread_join( fibThread2, &returnValue );
+  if ( result != 0 ) {
+          std::cerr << "Could not join thread" << std::endl;
+          return 1;
+  }
+  std::cout << "Fib2 returned " << intptr_t(returnValue) << std::endl;
+
+  return 0;
+}

llvm/include/llvm/ADT/EquivalenceClasses.h

@@ -138,6 +138,8 @@ public:
   iterator begin() const { return TheMapping.begin(); }
   iterator end() const { return TheMapping.end(); }
 
+  bool empty() const { return TheMapping.empty(); }
+
   /// member_* Iterate over the members of an equivalence class.
   ///
   class member_iterator;

llvm/include/llvm/ADT/hash_map.in

@@ -24,7 +24,7 @@
 //  3.0.4       std      ext/hash_map
 //  3.1      __gnu_cxx   ext/hash_map
 //  HP aCC6     std      stdex/rw/hashm*ap.h
-//
+//  MS VC++    stdext      hash_map
 
 #undef HAVE_GNU_EXT_HASH_MAP
 #undef HAVE_STD_EXT_HASH_MAP
@@ -63,6 +63,14 @@
 #  define HASH_NAMESPACE std
 # endif
 
+// Support Microsoft VC++.
+#elif defined(_MSC_VER)
+# include <hash_map>
+# ifndef HASH_NAMESPACE
+#  define HASH_NAMESPACE stdext
+   using std::_Distance;
+# endif
+
 // Give a warning if we couldn't find it, instead of (or in addition to)
 // randomly doing something dumb.
 #else
@@ -84,7 +92,8 @@ template <typename KeyType,
           class _HashFcn = hash<KeyType>,
           class _EqualKey = equal_to<KeyType>,
           class _A = allocator <ValueType> >
-class hash_map : public rw_hashmap<KeyType, ValueType, class _HashFcn, class _EqualKey, class _A> {
+class hash_map : public rw_hashmap<KeyType, ValueType, class _HashFcn, 
+                                   class _EqualKey, class _A> {
 };
 
 template <typename KeyType,
@@ -92,16 +101,13 @@ template <typename KeyType,
           class _HashFcn = hash<KeyType>,
           class _EqualKey = equal_to<KeyType>,
           class _A = allocator <ValueType> >
-class hash_multimap : public rw_hashmultimap<KeyType, ValueType, class _HashFcn, class _EqualKey, class _A> {
+class hash_multimap : public rw_hashmultimap<KeyType, ValueType, class _HashFcn,
+                                             class _EqualKey, class _A> {
 };
 
 } // end HASH_NAMESPACE;
 #endif
 
-using HASH_NAMESPACE::hash_map;
-using HASH_NAMESPACE::hash_multimap;
-using HASH_NAMESPACE::hash;
-
 // Include vector because ext/hash_map includes stl_vector.h and leaves
 // out specializations like stl_bvector.h, causing link conflicts.
 #include <vector>
@@ -135,6 +141,10 @@ namespace stdext {
 
 #endif
 
+using HASH_NAMESPACE::hash_map;
+using HASH_NAMESPACE::hash_multimap;
+using HASH_NAMESPACE::hash;
+
 #include "llvm/ADT/HashExtras.h"
 
 #endif

llvm/include/llvm/ADT/hash_set.in

@@ -25,7 +25,7 @@
 //  3.0.4       std      ext/hash_set
 //  3.1      __gnu_cxx   ext/hash_set
 //  HP aCC6     std      stdex/rw/hashset.h
-//
+//  MS VC++    stdext      hash_set
 
 #undef HAVE_GNU_EXT_HASH_SET
 #undef HAVE_STD_EXT_HASH_SET
@@ -64,6 +64,13 @@
 #  define HASH_NAMESPACE std
 # endif
 
+// Support Microsoft VC++.
+#elif defined(_MSC_VER)
+# include <hash_set>
+# ifndef HASH_NAMESPACE
+#  define HASH_NAMESPACE stdext
+# endif
+
 // Give a warning if we couldn't find it, instead of (or in addition to)
 // randomly doing something dumb.
 #else
@@ -83,17 +90,17 @@ template <class DataType> struct hash {
 */
 
 template <typename ValueType,
-	  class _HashFcn = hash<ValueType>,
-	  class _EqualKey = equal_to<ValueType>,
-	  class _A = allocator <ValueType> >
-class hash_set : public rw_hashset<ValueType, class _HashFcn, class _EqualKey, class _A> {
+  class _HashFcn = hash<ValueType>,
+  class _EqualKey = equal_to<ValueType>,
+  class _A = allocator <ValueType> >
+class hash_set : 
+  public rw_hashset<ValueType, class _HashFcn, class _EqualKey, class _A> {
 };
 
 } // end HASH_NAMESPACE;
 #endif
 
 using HASH_NAMESPACE::hash_set;
-using HASH_NAMESPACE::hash;
 
 // Include vector because ext/hash_set includes stl_vector.h and leaves
 // out specializations like stl_bvector.h, causing link conflicts.

llvm/include/llvm/ADT/ilist

@@ -169,6 +169,26 @@ void operator+(int, ilist_iterator<T>);
 template<typename T>
 void operator+(ilist_iterator<T>,int);
 
+// operator!=/operator== - Allow mixed comparisons without dereferencing
+// the iterator, which could very likely be pointing to end().
+template<typename T>
+bool operator!=(const T* LHS, const ilist_iterator<const T> &RHS) {
+  return LHS != RHS.getNodePtrUnchecked();
+}
+template<typename T>
+bool operator==(const T* LHS, const ilist_iterator<const T> &RHS) {
+  return LHS == RHS.getNodePtrUnchecked();
+}
+template<typename T>
+bool operator!=(T* LHS, const ilist_iterator<T> &RHS) {
+  return LHS != RHS.getNodePtrUnchecked();
+}
+template<typename T>
+bool operator==(T* LHS, const ilist_iterator<T> &RHS) {
+  return LHS == RHS.getNodePtrUnchecked();
+}
+
+
 // Allow ilist_iterators to convert into pointers to a node automatically when
 // used by the dyn_cast, cast, isa mechanisms...
 

llvm/include/llvm/ADT/iterator.in

@@ -34,6 +34,12 @@
 #undef HAVE_STD_ITERATOR
 #undef HAVE_FWD_ITERATOR
 
+#ifdef _MSC_VER
+#  define HAVE_BI_ITERATOR 0
+#  define HAVE_STD_ITERATOR 1
+#  define HAVE_FWD_ITERATOR 0
+#endif
+
 #if !HAVE_BI_ITERATOR
 # if HAVE_STD_ITERATOR
 /// If the bidirectional iterator is not defined, we attempt to define it in

llvm/include/llvm/Analysis/AliasAnalysis.h

@@ -37,6 +37,7 @@ namespace llvm {
 
 class LoadInst;
 class StoreInst;
+class VAArgInst;
 class TargetData;
 
 class AliasAnalysis {
@@ -254,8 +255,12 @@ public:
   ModRefResult getModRefInfo(InvokeInst *I, Value *P, unsigned Size) {
     return getModRefInfo(CallSite(I), P, Size);
   }
+  ModRefResult getModRefInfo(VAArgInst* I, Value* P, unsigned Size) {
+    return AliasAnalysis::Mod;
+  }
   ModRefResult getModRefInfo(Instruction *I, Value *P, unsigned Size) {
     switch (I->getOpcode()) {
+    case Instruction::VAArg:  return getModRefInfo((VAArgInst*)I, P, Size);
     case Instruction::Load:   return getModRefInfo((LoadInst*)I, P, Size);
     case Instruction::Store:  return getModRefInfo((StoreInst*)I, P, Size);
     case Instruction::Call:   return getModRefInfo((CallInst*)I, P, Size);

llvm/include/llvm/Analysis/ConstantFolding.h

@@ -0,0 +1,36 @@
+//===-- ConstantFolding.h - Analyze constant folding possibilities --------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This family of functions determines the possibility of performing constant
+// folding.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Constants.h"
+#include "llvm/Function.h"
+using namespace llvm;
+
+namespace llvm {
+
+/// canConstantFoldCallTo - Return true if its even possible to fold a call to
+/// the specified function.
+extern
+bool canConstantFoldCallTo(Function *F);
+
+/// ConstantFoldFP - Given a function that evaluates the constant, return an
+///                  LLVM Constant that represents the evaluated constant
+extern Constant *
+ConstantFoldFP(double (*NativeFP)(double), double V, const Type *Ty);
+
+/// ConstantFoldCall - Attempt to constant fold a call to the specified function
+/// with the specified arguments, returning null if unsuccessful.
+extern Constant *
+ConstantFoldCall(Function *F, const std::vector<Constant*> &Operands);
+}
+

llvm/include/llvm/Analysis/DataStructure/DataStructure.h

@@ -31,6 +31,10 @@ class DSCallSite;
 class DSNode;
 class DSNodeHandle;
 
+FunctionPass *createDataStructureStatsPass();
+FunctionPass *createDataStructureGraphCheckerPass();
+
+
 // FIXME: move this stuff to a private header
 namespace DataStructureAnalysis {
   /// isPointerType - Return true if this first class type is big enough to hold

llvm/include/llvm/Analysis/Expressions.h

@@ -1,63 +0,0 @@
-//===- llvm/Analysis/Expressions.h - Expression Analysis Utils --*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines a package of expression analysis utilties:
-//
-// ClassifyExpr: Analyze an expression to determine the complexity of the
-// expression, and which other variables it depends on.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ANALYSIS_EXPRESSIONS_H
-#define LLVM_ANALYSIS_EXPRESSIONS_H
-
-namespace llvm {
-
-class Type;
-class Value;
-class ConstantInt;
-
-struct ExprType;
-
-/// ClassifyExpr - Analyze an expression to determine the complexity of the
-/// expression, and which other values it depends on.
-///
-ExprType ClassifyExpr(Value *Expr);
-
-/// ExprType Class - Represent an expression of the form CONST*VAR+CONST
-/// or simpler.  The expression form that yields the least information about the
-/// expression is just the Linear form with no offset.
-///
-struct ExprType {
-  enum ExpressionType {
-    Constant,            // Expr is a simple constant, Offset is value
-    Linear,              // Expr is linear expr, Value is Var+Offset
-    ScaledLinear,        // Expr is scaled linear exp, Value is Scale*Var+Offset
-  } ExprTy;
-
-  const ConstantInt *Offset;  // Offset of expr, or null if 0
-  Value             *Var;     // Var referenced, if Linear or above (null if 0)
-  const ConstantInt *Scale;   // Scale of var if ScaledLinear expr (null if 1)
-
-  inline ExprType(const ConstantInt *CPV = 0) {
-    Offset = CPV; Var = 0; Scale = 0;
-    ExprTy = Constant;
-  }
-  ExprType(Value *Val);        // Create a linear or constant expression
-  ExprType(const ConstantInt *scale, Value *var, const ConstantInt *offset);
-
-  /// If this expression has an intrinsic type, return it.  If it is zero,
-  /// return the specified type.
-  ///
-  const Type *getExprType(const Type *Default) const;
-};
-
-} // End llvm namespace
-
-#endif

llvm/include/llvm/Analysis/FindUnsafePointerTypes.h

@@ -1,62 +0,0 @@
-//===- llvm/Analysis/FindUnsafePointerTypes.h - Unsafe pointers -*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines a pass that can be used to determine, interprocedurally,
-// which pointer types are accessed unsafely in a program.  If there is an
-// "unsafe" access to a specific pointer type, transformations that depend on
-// type safety cannot be permitted.
-//
-// The result of running this analysis over a program is a set of unsafe pointer
-// types that cannot be transformed.  Safe pointer types are not tracked.
-//
-// Additionally, this analysis exports a hidden command line argument that (when
-// enabled) prints out the reasons a type was determined to be unsafe.  Just add
-// -printunsafeptrinst to the command line of the tool you want to get it.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ANALYSIS_UNSAFEPOINTERTYPES_H
-#define LLVM_ANALYSIS_UNSAFEPOINTERTYPES_H
-
-#include "llvm/Pass.h"
-#include <set>
-
-namespace llvm {
-
-class PointerType;
-
-struct FindUnsafePointerTypes : public ModulePass {
-  // UnsafeTypes - Set of types that are not safe to transform.
-  std::set<PointerType*> UnsafeTypes;
-public:
-  // Accessor for underlying type set...
-  inline const std::set<PointerType*> &getUnsafeTypes() const {
-    return UnsafeTypes;
-  }
-
-  /// run - Inspect the operations that the specified module does on
-  /// values of various types.  If they are deemed to be 'unsafe' note that the
-  /// type is not safe to transform.
-  ///
-  virtual bool runOnModule(Module &M);
-
-  /// print - Loop over the results of the analysis, printing out unsafe types.
-  ///
-  void print(std::ostream &o, const Module *Mod) const;
-
-  /// getAnalysisUsage - Of course, we provide ourself...
-  ///
-  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
-    AU.setPreservesAll();
-  }
-};
-
-} // End llvm namespace
-
-#endif

llvm/include/llvm/Analysis/Interval.h

@@ -110,7 +110,7 @@ inline Interval::succ_iterator succ_begin(Interval *I) {
 inline Interval::succ_iterator succ_end(Interval *I)   {
   return I->Successors.end();
 }
-  
+
 /// pred_begin/pred_end - define methods so that Intervals may be used
 /// just like BasicBlocks can with the pred_* functions, and *::pred_iterator.
 ///
@@ -128,7 +128,7 @@ template <> struct GraphTraits<Interval*> {
   static NodeType *getEntryNode(Interval *I) { return I; }
 
   /// nodes_iterator/begin/end - Allow iteration over all nodes in the graph
-  static inline ChildIteratorType child_begin(NodeType *N) { 
+  static inline ChildIteratorType child_begin(NodeType *N) {
     return succ_begin(N);
   }
   static inline ChildIteratorType child_end(NodeType *N) {

llvm/include/llvm/Analysis/LinkAllAnalyses.h

@@ -0,0 +1,62 @@
+//===- LinkAllAnalyses.h - Reference All Analysis Passes --------*- C++ -*-===//
+//
+//                      The LLVM Compiler Infrastructure
+//
+// This file was developed by Chris Lattner and is distributed under the
+// University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This header file pulls in all analysis passes for tools like analyze and
+// bugpoint that need this functionality.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_LINKALLANALYSES_H
+#define LLVM_ANALYSIS_LINKALLANALYSES_H
+
+#include "llvm/Analysis/AliasSetTracker.h"
+#include "llvm/Analysis/CallGraph.h"
+#include "llvm/Analysis/FindUsedTypes.h"
+#include "llvm/Analysis/IntervalPartition.h"
+#include "llvm/Analysis/PostDominators.h"
+#include "llvm/Analysis/Passes.h"
+#include "llvm/Analysis/ScalarEvolution.h"
+#include "llvm/Analysis/DataStructure/DataStructure.h"
+#include "llvm/Function.h"
+#include <cstdlib>
+
+namespace {
+  struct ForceAnalysisPassLinking {
+    ForceAnalysisPassLinking() {
+      // We must reference the passes in such a way that compilers will not
+      // delete it all as dead code, even with whole program optimization,
+      // yet is effectively a NO-OP. As the compiler isn't smart enough
+      // to know that getenv() never returns -1, this will do the job.
+      if (std::getenv("bar") != (char*) -1)
+        return;
+
+      (void)new llvm::LocalDataStructures();
+      (void)new llvm::BUDataStructures();
+      (void)new llvm::TDDataStructures();
+      (void)new llvm::CompleteBUDataStructures();
+      (void)new llvm::EquivClassGraphs();
+      (void)llvm::createDataStructureStatsPass();
+      (void)llvm::createDataStructureGraphCheckerPass();
+      (void)llvm::createProfileLoaderPass();
+      (void)llvm::createNoProfileInfoPass();
+      (void)llvm::createInstCountPass();
+      (void)new llvm::IntervalPartition();
+      (void)new llvm::ImmediateDominators();
+      (void)new llvm::PostDominatorSet();
+      (void)new llvm::CallGraph();
+      (void)new llvm::FindUsedTypes();
+      (void)new llvm::ScalarEvolution();
+      ((llvm::Function*)0)->viewCFGOnly();
+      llvm::AliasSetTracker X(*(llvm::AliasAnalysis*)0);
+      X.add((llvm::Value*)0, 0);  // for -print-alias-sets
+    }
+  } ForceAnalysisPassLinking;
+};
+
+#endif

llvm/include/llvm/Analysis/LoopInfo.h

@@ -121,6 +121,12 @@ public:
   ///
   BasicBlock *getLoopPreheader() const;
 
+  /// getLoopLatch - If there is a latch block for this loop, return it.  A
+  /// latch block is the canonical backedge for a loop.  A loop header in normal
+  /// form has two edges into it: one from a preheader and one from a latch
+  /// block.
+  BasicBlock *getLoopLatch() const;
+  
   /// getCanonicalInductionVariable - Check to see if the loop has a canonical
   /// induction variable: an integer recurrence that starts at 0 and increments
   /// by one each time through the loop.  If so, return the phi node that
@@ -250,7 +256,8 @@ public:
 
   // isLoopHeader - True if the block is a loop header node
   bool isLoopHeader(BasicBlock *BB) const {
-    return getLoopFor(BB)->getHeader() == BB;
+    const Loop *L = getLoopFor(BB);
+    return L && L->getHeader() == BB;
   }
 
   /// runOnFunction - Calculate the natural loop information.

llvm/include/llvm/Analysis/Passes.h

@@ -102,6 +102,10 @@ namespace llvm {
   // simple context insensitive alias analysis.
   //
   ModulePass *createSteensgaardPass();
+  
+  // Minor pass prototypes, allowing us to expose them through bugpoint and
+  // analyze.
+  FunctionPass *createInstCountPass();
 }
 
 #endif

llvm/include/llvm/Analysis/ScalarEvolution.h

@@ -195,6 +195,14 @@ namespace llvm {
     /// specified expression.
     SCEVHandle getSCEV(Value *V) const;
 
+    /// hasSCEV - Return true if the SCEV for this value has already been
+    /// computed.
+    bool hasSCEV(Value *V) const;
+
+    /// setSCEV - Insert the specified SCEV into the map of current SCEVs for
+    /// the specified value.
+    void setSCEV(Value *V, const SCEVHandle &H);
+
     /// getSCEVAtScope - Return a SCEV expression handle for the specified value
     /// at the specified scope in the program.  The L value specifies a loop
     /// nest to evaluate the expression at, where null is the top-level or a

llvm/include/llvm/Analysis/ScalarEvolutionExpander.h

@@ -0,0 +1,180 @@
+//===---- llvm/Analysis/ScalarEvolutionExpander.h - SCEV Exprs --*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the classes used to generate code from scalar expressions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_SCALAREVOLUTION_EXPANDER_H
+#define LLVM_ANALYSIS_SCALAREVOLUTION_EXPANDER_H
+
+#include "llvm/BasicBlock.h"
+#include "llvm/Constants.h"
+#include "llvm/Instructions.h"
+#include "llvm/Type.h"
+#include "llvm/Analysis/ScalarEvolution.h"
+#include "llvm/Analysis/ScalarEvolutionExpressions.h"
+#include "llvm/Support/CFG.h"
+
+namespace llvm {
+  /// SCEVExpander - This class uses information about analyze scalars to
+  /// rewrite expressions in canonical form.
+  ///
+  /// Clients should create an instance of this class when rewriting is needed,
+  /// and destroying it when finished to allow the release of the associated
+  /// memory.
+  struct SCEVExpander : public SCEVVisitor<SCEVExpander, Value*> {
+    ScalarEvolution &SE;
+    LoopInfo &LI;
+    std::map<SCEVHandle, Value*> InsertedExpressions;
+    std::set<Instruction*> InsertedInstructions;
+
+    Instruction *InsertPt;
+
+    friend struct SCEVVisitor<SCEVExpander, Value*>;
+  public:
+    SCEVExpander(ScalarEvolution &se, LoopInfo &li) : SE(se), LI(li) {}
+
+    /// clear - Erase the contents of the InsertedExpressions map so that users
+    /// trying to expand the same expression into multiple BasicBlocks or
+    /// different places within the same BasicBlock can do so.
+    void clear() { InsertedExpressions.clear(); }
+
+    /// isInsertedInstruction - Return true if the specified instruction was
+    /// inserted by the code rewriter.  If so, the client should not modify the
+    /// instruction.
+    bool isInsertedInstruction(Instruction *I) const {
+      return InsertedInstructions.count(I);
+    }
+
+    /// getOrInsertCanonicalInductionVariable - This method returns the
+    /// canonical induction variable of the specified type for the specified
+    /// loop (inserting one if there is none).  A canonical induction variable
+    /// starts at zero and steps by one on each iteration.
+    Value *getOrInsertCanonicalInductionVariable(const Loop *L, const Type *Ty){
+      assert((Ty->isInteger() || Ty->isFloatingPoint()) &&
+             "Can only insert integer or floating point induction variables!");
+      SCEVHandle H = SCEVAddRecExpr::get(SCEVUnknown::getIntegerSCEV(0, Ty),
+                                         SCEVUnknown::getIntegerSCEV(1, Ty), L);
+      return expand(H);
+    }
+
+    /// addInsertedValue - Remember the specified instruction as being the
+    /// canonical form for the specified SCEV.
+    void addInsertedValue(Instruction *I, SCEV *S) {
+      InsertedExpressions[S] = (Value*)I;
+      InsertedInstructions.insert(I);
+    }
+
+    /// expandCodeFor - Insert code to directly compute the specified SCEV
+    /// expression into the program.  The inserted code is inserted into the
+    /// specified block.
+    ///
+    /// If a particular value sign is required, a type may be specified for the
+    /// result.
+    Value *expandCodeFor(SCEVHandle SH, Instruction *IP, const Type *Ty = 0) {
+      // Expand the code for this SCEV.
+      this->InsertPt = IP;
+      return expandInTy(SH, Ty);
+    }
+
+  protected:
+    Value *expand(SCEV *S) {
+      // Check to see if we already expanded this.
+      std::map<SCEVHandle, Value*>::iterator I = InsertedExpressions.find(S);
+      if (I != InsertedExpressions.end())
+        return I->second;
+
+      Value *V = visit(S);
+      InsertedExpressions[S] = V;
+      return V;
+    }
+
+    Value *expandInTy(SCEV *S, const Type *Ty) {
+      Value *V = expand(S);
+      if (Ty && V->getType() != Ty) {
+        // FIXME: keep track of the cast instruction.
+        if (Constant *C = dyn_cast<Constant>(V))
+          return ConstantExpr::getCast(C, Ty);
+        else if (Instruction *I = dyn_cast<Instruction>(V)) {
+          // Check to see if there is already a cast.  If there is, use it.
+          for (Value::use_iterator UI = I->use_begin(), E = I->use_end();
+               UI != E; ++UI) {
+            if ((*UI)->getType() == Ty)
+              if (CastInst *CI = dyn_cast<CastInst>(cast<Instruction>(*UI))) {
+                BasicBlock::iterator It = I; ++It;
+                if (isa<InvokeInst>(I))
+                  It = cast<InvokeInst>(I)->getNormalDest()->begin();
+                while (isa<PHINode>(It)) ++It;
+                if (It != BasicBlock::iterator(CI)) {
+                  // Splice the cast immediately after the operand in question.
+                  BasicBlock::InstListType &InstList =
+                    It->getParent()->getInstList();
+                  InstList.splice(It, CI->getParent()->getInstList(), CI);
+                }
+                return CI;
+              }
+          }
+          BasicBlock::iterator IP = I; ++IP;
+          if (InvokeInst *II = dyn_cast<InvokeInst>(I))
+            IP = II->getNormalDest()->begin();
+          while (isa<PHINode>(IP)) ++IP;
+          return new CastInst(V, Ty, V->getName(), IP);
+        } else {
+          // FIXME: check to see if there is already a cast!
+          return new CastInst(V, Ty, V->getName(), InsertPt);
+        }
+      }
+      return V;
+    }
+
+    Value *visitConstant(SCEVConstant *S) {
+      return S->getValue();
+    }
+
+    Value *visitTruncateExpr(SCEVTruncateExpr *S) {
+      Value *V = expand(S->getOperand());
+      return new CastInst(V, S->getType(), "tmp.", InsertPt);
+    }
+
+    Value *visitZeroExtendExpr(SCEVZeroExtendExpr *S) {
+      Value *V = expandInTy(S->getOperand(),S->getType()->getUnsignedVersion());
+      return new CastInst(V, S->getType(), "tmp.", InsertPt);
+    }
+
+    Value *visitAddExpr(SCEVAddExpr *S) {
+      const Type *Ty = S->getType();
+      Value *V = expandInTy(S->getOperand(S->getNumOperands()-1), Ty);
+
+      // Emit a bunch of add instructions
+      for (int i = S->getNumOperands()-2; i >= 0; --i)
+        V = BinaryOperator::createAdd(V, expandInTy(S->getOperand(i), Ty),
+                                      "tmp.", InsertPt);
+      return V;
+    }
+
+    Value *visitMulExpr(SCEVMulExpr *S);
+
+    Value *visitUDivExpr(SCEVUDivExpr *S) {
+      const Type *Ty = S->getType();
+      Value *LHS = expandInTy(S->getLHS(), Ty);
+      Value *RHS = expandInTy(S->getRHS(), Ty);
+      return BinaryOperator::createDiv(LHS, RHS, "tmp.", InsertPt);
+    }
+
+    Value *visitAddRecExpr(SCEVAddRecExpr *S);
+
+    Value *visitUnknown(SCEVUnknown *S) {
+      return S->getValue();
+    }
+  };
+}
+
+#endif
+

llvm/include/llvm/Assembly/Parser.h

@@ -28,6 +28,7 @@ class ParseException;
 // the verifier after parsing the file to check that it's ok.
 //
 Module *ParseAssemblyFile(const std::string &Filename);// throw (ParseException)
+Module *ParseAssemblyString(const char * AsmString, Module * M);// throw (ParseException)
 
 //===------------------------------------------------------------------------===
 //                              Helper Classes

llvm/include/llvm/BasicBlock.h

@@ -101,6 +101,11 @@ public:
   /// and deletes it.
   ///
   void eraseFromParent();
+  
+  /// moveBefore - Unlink this instruction from its current function and
+  /// insert it into the function that MovePos lives in, right before
+  /// MovePos.
+  void moveBefore(BasicBlock *MovePos);
 
   /// getSinglePredecessor - If this basic block has a single predecessor block,
   /// return the block, otherwise return a null pointer.
@@ -134,7 +139,7 @@ public:
   void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const BasicBlock *BB) { return true; }
+  static inline bool classof(const BasicBlock *) { return true; }
   static inline bool classof(const Value *V) {
     return V->getValueType() == Value::BasicBlockVal;
   }
@@ -160,7 +165,7 @@ public:
   /// splitBasicBlock - This splits a basic block into two at the specified
   /// instruction.  Note that all instructions BEFORE the specified iterator
   /// stay as part of the original basic block, an unconditional branch is added
-  /// to the original BB, and the rest of the instructions in the BB are moved 
+  /// to the original BB, and the rest of the instructions in the BB are moved
   /// to the new BB, including the old terminator.  The newly formed BasicBlock
   /// is returned.  This function invalidates the specified iterator.
   ///

llvm/include/llvm/CodeGen/ELFWriter.h

@@ -0,0 +1,323 @@
+//===-- ELFWriter.h - Target-independent ELF writer support -----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by Chris Lattner and is distributed under the
+// University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the ELFWriter class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_ELFWRITER_H
+#define LLVM_CODEGEN_ELFWRITER_H
+
+#include "llvm/CodeGen/MachineFunctionPass.h"
+#include <list>
+
+namespace llvm {
+  class GlobalVariable;
+  class Mangler;
+  class MachineCodeEmitter;
+  class ELFCodeEmitter;
+
+  /// ELFWriter - This class implements the common target-independent code for
+  /// writing ELF files.  Targets should derive a class from this to
+  /// parameterize the output format.
+  ///
+  class ELFWriter : public MachineFunctionPass {
+    friend class ELFCodeEmitter;
+  public:
+    MachineCodeEmitter &getMachineCodeEmitter() const {
+      return *(MachineCodeEmitter*)MCE;
+    }
+
+    ~ELFWriter();
+
+    typedef std::vector<unsigned char> DataBuffer;
+
+  protected:
+    ELFWriter(std::ostream &O, TargetMachine &TM);
+
+    /// Output stream to send the resultant object file to.
+    ///
+    std::ostream &O;
+
+    /// Target machine description.
+    ///
+    TargetMachine &TM;
+
+    /// Mang - The object used to perform name mangling for this module.
+    ///
+    Mangler *Mang;
+
+    /// MCE - The MachineCodeEmitter object that we are exposing to emit machine
+    /// code for functions to the .o file.
+    ELFCodeEmitter *MCE;
+
+    //===------------------------------------------------------------------===//
+    // Properties to be set by the derived class ctor, used to configure the
+    // ELFWriter.
+
+    // e_machine - This field is the target specific value to emit as the
+    // e_machine member of the ELF header.
+    unsigned short e_machine;
+
+    // e_flags - The machine flags for the target.  This defaults to zero.
+    unsigned e_flags;
+
+    //===------------------------------------------------------------------===//
+    // Properties inferred automatically from the target machine.
+    //
+
+    /// is64Bit/isLittleEndian - This information is inferred from the target
+    /// machine directly, indicating whether to emit a 32- or 64-bit ELF file.
+    bool is64Bit, isLittleEndian;
+
+    /// doInitialization - Emit the file header and all of the global variables
+    /// for the module to the ELF file.
+    bool doInitialization(Module &M);
+
+    bool runOnMachineFunction(MachineFunction &MF);
+
+
+    /// doFinalization - Now that the module has been completely processed, emit
+    /// the ELF file to 'O'.
+    bool doFinalization(Module &M);
+
+  private:
+    // The buffer we accumulate the file header into.  Note that this should be
+    // changed into something much more efficient later (and the bytecode writer
+    // as well!).
+    DataBuffer FileHeader;
+
+    /// ELFSection - This struct contains information about each section that is
+    /// emitted to the file.  This is eventually turned into the section header
+    /// table at the end of the file.
+    struct ELFSection {
+      std::string Name;       // Name of the section.
+      unsigned NameIdx;       // Index in .shstrtab of name, once emitted.
+      unsigned Type;
+      unsigned Flags;
+      uint64_t Addr;
+      unsigned Offset;
+      unsigned Size;
+      unsigned Link;
+      unsigned Info;
+      unsigned Align;
+      unsigned EntSize;
+
+      /// SectionIdx - The number of the section in the Section Table.
+      ///
+      unsigned short SectionIdx;
+
+      /// SectionData - The actual data for this section which we are building
+      /// up for emission to the file.
+      DataBuffer SectionData;
+
+      enum { SHT_NULL = 0, SHT_PROGBITS = 1, SHT_SYMTAB = 2, SHT_STRTAB = 3,
+             SHT_RELA = 4, SHT_HASH = 5, SHT_DYNAMIC = 6, SHT_NOTE = 7,
+             SHT_NOBITS = 8, SHT_REL = 9, SHT_SHLIB = 10, SHT_DYNSYM = 11 };
+      enum { SHN_UNDEF = 0, SHN_ABS = 0xFFF1, SHN_COMMON = 0xFFF2 };
+      enum {   // SHF - ELF Section Header Flags
+        SHF_WRITE            = 1 << 0, // Writable
+        SHF_ALLOC            = 1 << 1, // Mapped into the process addr space
+        SHF_EXECINSTR        = 1 << 2, // Executable
+        SHF_MERGE            = 1 << 4, // Might be merged if equal
+        SHF_STRINGS          = 1 << 5, // Contains null-terminated strings
+        SHF_INFO_LINK        = 1 << 6, // 'sh_info' contains SHT index
+        SHF_LINK_ORDER       = 1 << 7, // Preserve order after combining
+        SHF_OS_NONCONFORMING = 1 << 8, // nonstandard OS support required
+        SHF_GROUP            = 1 << 9, // Section is a member of a group
+        SHF_TLS              = 1 << 10,// Section holds thread-local data
+      };
+
+      ELFSection(const std::string &name)
+        : Name(name), Type(0), Flags(0), Addr(0), Offset(0), Size(0),
+          Link(0), Info(0), Align(0), EntSize(0) {
+      }
+    };
+
+    /// SectionList - This is the list of sections that we have emitted to the
+    /// file.  Once the file has been completely built, the section header table
+    /// is constructed from this info.
+    std::list<ELFSection> SectionList;
+    unsigned NumSections;   // Always = SectionList.size()
+
+    /// SectionLookup - This is a mapping from section name to section number in
+    /// the SectionList.
+    std::map<std::string, ELFSection*> SectionLookup;
+
+    /// getSection - Return the section with the specified name, creating a new
+    /// section if one does not already exist.
+    ELFSection &getSection(const std::string &Name,
+                           unsigned Type, unsigned Flags = 0) {
+      ELFSection *&SN = SectionLookup[Name];
+      if (SN) return *SN;
+
+      SectionList.push_back(Name);
+      SN = &SectionList.back();
+      SN->SectionIdx = NumSections++;
+      SN->Type = Type;
+      SN->Flags = Flags;
+      return *SN;
+    }
+
+    ELFSection &getDataSection() {
+      return getSection(".data", ELFSection::SHT_PROGBITS,
+                        ELFSection::SHF_WRITE | ELFSection::SHF_ALLOC);
+    }
+    ELFSection &getBSSSection() {
+      return getSection(".bss", ELFSection::SHT_NOBITS,
+                        ELFSection::SHF_WRITE | ELFSection::SHF_ALLOC);
+    }
+
+    /// ELFSym - This struct contains information about each symbol that is
+    /// added to logical symbol table for the module.  This is eventually
+    /// turned into a real symbol table in the file.
+    struct ELFSym {
+      const GlobalValue *GV;    // The global value this corresponds to.
+      unsigned NameIdx;         // Index in .strtab of name, once emitted.
+      uint64_t Value;
+      unsigned Size;
+      unsigned char Info;
+      unsigned char Other;
+      unsigned short SectionIdx;
+
+      enum { STB_LOCAL = 0, STB_GLOBAL = 1, STB_WEAK = 2 };
+      enum { STT_NOTYPE = 0, STT_OBJECT = 1, STT_FUNC = 2, STT_SECTION = 3,
+             STT_FILE = 4 };
+      ELFSym(const GlobalValue *gv) : GV(gv), Value(0), Size(0), Info(0),
+                                      Other(0), SectionIdx(0) {}
+
+      void SetBind(unsigned X) {
+        assert(X == (X & 0xF) && "Bind value out of range!");
+        Info = (Info & 0x0F) | (X << 4);
+      }
+      void SetType(unsigned X) {
+        assert(X == (X & 0xF) && "Type value out of range!");
+        Info = (Info & 0xF0) | X;
+      }
+    };
+
+    /// SymbolTable - This is the list of symbols we have emitted to the file.
+    /// This actually gets rearranged before emission to the file (to put the
+    /// local symbols first in the list).
+    std::vector<ELFSym> SymbolTable;
+
+    // As we complete the ELF file, we need to update fields in the ELF header
+    // (e.g. the location of the section table).  These members keep track of
+    // the offset in ELFHeader of these various pieces to update and other
+    // locations in the file.
+    unsigned ELFHeader_e_shoff_Offset;     // e_shoff    in ELF header.
+    unsigned ELFHeader_e_shstrndx_Offset;  // e_shstrndx in ELF header.
+    unsigned ELFHeader_e_shnum_Offset;     // e_shnum    in ELF header.
+
+
+    // align - Emit padding into the file until the current output position is
+    // aligned to the specified power of two boundary.
+    static void align(DataBuffer &Output, unsigned Boundary) {
+      assert(Boundary && (Boundary & (Boundary-1)) == 0 &&
+             "Must align to 2^k boundary");
+      size_t Size = Output.size();
+      if (Size & (Boundary-1)) {
+        // Add padding to get alignment to the correct place.
+        size_t Pad = Boundary-(Size & (Boundary-1));
+        Output.resize(Size+Pad);
+      }
+    }
+
+    static void outbyte(DataBuffer &Output, unsigned char X) {
+      Output.push_back(X);
+    }
+    void outhalf(DataBuffer &Output, unsigned short X) {
+      if (isLittleEndian) {
+        Output.push_back(X&255);
+        Output.push_back(X >> 8);
+      } else {
+        Output.push_back(X >> 8);
+        Output.push_back(X&255);
+      }
+    }
+    void outword(DataBuffer &Output, unsigned X) {
+      if (isLittleEndian) {
+        Output.push_back((X >>  0) & 255);
+        Output.push_back((X >>  8) & 255);
+        Output.push_back((X >> 16) & 255);
+        Output.push_back((X >> 24) & 255);
+      } else {
+        Output.push_back((X >> 24) & 255);
+        Output.push_back((X >> 16) & 255);
+        Output.push_back((X >>  8) & 255);
+        Output.push_back((X >>  0) & 255);
+      }
+    }
+    void outxword(DataBuffer &Output, uint64_t X) {
+      if (isLittleEndian) {
+        Output.push_back((X >>  0) & 255);
+        Output.push_back((X >>  8) & 255);
+        Output.push_back((X >> 16) & 255);
+        Output.push_back((X >> 24) & 255);
+        Output.push_back((X >> 32) & 255);
+        Output.push_back((X >> 40) & 255);
+        Output.push_back((X >> 48) & 255);
+        Output.push_back((X >> 56) & 255);
+      } else {
+        Output.push_back((X >> 56) & 255);
+        Output.push_back((X >> 48) & 255);
+        Output.push_back((X >> 40) & 255);
+        Output.push_back((X >> 32) & 255);
+        Output.push_back((X >> 24) & 255);
+        Output.push_back((X >> 16) & 255);
+        Output.push_back((X >>  8) & 255);
+        Output.push_back((X >>  0) & 255);
+      }
+    }
+    void outaddr32(DataBuffer &Output, unsigned X) {
+      outword(Output, X);
+    }
+    void outaddr64(DataBuffer &Output, uint64_t X) {
+      outxword(Output, X);
+    }
+    void outaddr(DataBuffer &Output, uint64_t X) {
+      if (!is64Bit)
+        outword(Output, (unsigned)X);
+      else
+        outxword(Output, X);
+    }
+
+    // fix functions - Replace an existing entry at an offset.
+    void fixhalf(DataBuffer &Output, unsigned short X, unsigned Offset) {
+      unsigned char *P = &Output[Offset];
+      P[0] = (X >> (isLittleEndian ?  0 : 8)) & 255;
+      P[1] = (X >> (isLittleEndian ?  8 : 0)) & 255;
+    }
+
+    void fixword(DataBuffer &Output, unsigned X, unsigned Offset) {
+      unsigned char *P = &Output[Offset];
+      P[0] = (X >> (isLittleEndian ?  0 : 24)) & 255;
+      P[1] = (X >> (isLittleEndian ?  8 : 16)) & 255;
+      P[2] = (X >> (isLittleEndian ? 16 :  8)) & 255;
+      P[3] = (X >> (isLittleEndian ? 24 :  0)) & 255;
+    }
+
+    void fixaddr(DataBuffer &Output, uint64_t X, unsigned Offset) {
+      if (!is64Bit)
+        fixword(Output, (unsigned)X, Offset);
+      else
+        assert(0 && "Emission of 64-bit data not implemented yet!");
+    }
+
+  private:
+    void EmitGlobal(GlobalVariable *GV);
+
+    void EmitSymbolTable();
+
+    void EmitSectionTableStringTable();
+    void OutputSectionsAndSectionTable();
+  };
+}
+
+#endif

llvm/include/llvm/CodeGen/LiveInterval.h

@@ -143,6 +143,11 @@ namespace llvm {
     /// only overlaps with one value in the source interval.
     bool joinable(const LiveInterval& other, unsigned CopyIdx) const;
 
+    /// getOverlapingRanges - Given another live interval which is defined as a
+    /// copy from this one, return a list of all of the live ranges where the
+    /// two overlap and have different value numbers.
+    void getOverlapingRanges(const LiveInterval &Other, unsigned CopyIdx,
+                             std::vector<LiveRange*> &Ranges);
 
     /// overlaps - Return true if the intersection of the two live intervals is
     /// not empty.

llvm/include/llvm/CodeGen/LiveIntervalAnalysis.h

@@ -22,7 +22,7 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
-#include "LiveInterval.h"
+#include "llvm/CodeGen/LiveInterval.h"
 
 namespace llvm {
 
@@ -164,12 +164,17 @@ namespace llvm {
     void handlePhysicalRegisterDef(MachineBasicBlock* mbb,
                                    MachineBasicBlock::iterator mi,
                                    LiveInterval& interval,
-                                   unsigned SrcReg, unsigned DestReg);
+                                   unsigned SrcReg, unsigned DestReg,
+                                   bool isLiveIn = false);
 
     /// Return true if the two specified registers belong to different
     /// register classes.  The registers may be either phys or virt regs.
     bool differingRegisterClasses(unsigned RegA, unsigned RegB) const;
 
+    bool AdjustIfAllOverlappingRangesAreCopiesFrom(LiveInterval &IntA,
+                                                   LiveInterval &IntB,
+                                                   unsigned CopyIdx);
+
     bool overlapsAliases(const LiveInterval *lhs,
                          const LiveInterval *rhs) const;
 

llvm/include/llvm/CodeGen/LiveVariables.h

@@ -40,7 +40,8 @@ class LiveVariables : public MachineFunctionPass {
 public:
   struct VarInfo {
     /// DefInst - The machine instruction that defines this register.
-    MachineInstr      *DefInst;
+    ///
+    MachineInstr *DefInst;
 
     /// AliveBlocks - Set of blocks of which this value is alive completely
     /// through.  This is a bit set which uses the basic block number as an
@@ -76,18 +77,22 @@ private:
   ///
   std::vector<VarInfo> VirtRegInfo;
 
-  /// RegistersKilled - This multimap keeps track of all of the registers that
+  /// RegistersKilled - This map keeps track of all of the registers that
   /// are dead immediately after an instruction reads its operands.  If an
   /// instruction does not have an entry in this map, it kills no registers.
   ///
-  std::multimap<MachineInstr*, unsigned> RegistersKilled;
+  std::map<MachineInstr*, std::vector<unsigned> > RegistersKilled;
 
-  /// RegistersDead - This multimap keeps track of all of the registers that are
+  /// RegistersDead - This map keeps track of all of the registers that are
   /// dead immediately after an instruction executes, which are not dead after
   /// the operands are evaluated.  In practice, this only contains registers
   /// which are defined by an instruction, but never used.
   ///
-  std::multimap<MachineInstr*, unsigned> RegistersDead;
+  std::map<MachineInstr*, std::vector<unsigned> > RegistersDead;
+  
+  /// Dummy - An always empty vector used for instructions without dead or
+  /// killed operands.
+  std::vector<unsigned> Dummy;
 
   /// AllocatablePhysicalRegisters - This vector keeps track of which registers
   /// are actually register allocatable by the target machine.  We can not track
@@ -110,42 +115,54 @@ public:
 
   /// killed_iterator - Iterate over registers killed by a machine instruction
   ///
-  typedef std::multimap<MachineInstr*, unsigned>::iterator killed_iterator;
+  typedef std::vector<unsigned>::iterator killed_iterator;
 
+  std::vector<unsigned> &getKillsVector(MachineInstr *MI) {
+    std::map<MachineInstr*, std::vector<unsigned> >::iterator I = 
+      RegistersKilled.find(MI);
+    return I != RegistersKilled.end() ? I->second : Dummy;
+  }
+  std::vector<unsigned> &getDeadDefsVector(MachineInstr *MI) {
+    std::map<MachineInstr*, std::vector<unsigned> >::iterator I = 
+      RegistersDead.find(MI);
+    return I != RegistersDead.end() ? I->second : Dummy;
+  }
+  
+    
   /// killed_begin/end - Get access to the range of registers killed by a
   /// machine instruction.
   killed_iterator killed_begin(MachineInstr *MI) {
-    return RegistersKilled.lower_bound(MI);
+    return getKillsVector(MI).begin();
   }
   killed_iterator killed_end(MachineInstr *MI) {
-    return RegistersKilled.upper_bound(MI);
+    return getKillsVector(MI).end();
   }
   std::pair<killed_iterator, killed_iterator>
   killed_range(MachineInstr *MI) {
-    return RegistersKilled.equal_range(MI);
+    std::vector<unsigned> &V = getKillsVector(MI);
+    return std::make_pair(V.begin(), V.end());
   }
 
   /// KillsRegister - Return true if the specified instruction kills the
   /// specified register.
-  bool KillsRegister(MachineInstr *MI, unsigned Reg) {
-    std::pair<killed_iterator, killed_iterator> KIP = killed_range(MI);
-    for (; KIP.first != KIP.second; ++KIP.first)
-      if (KIP.first->second == Reg)
-        return true;
-    return false;
-  }
-
+  bool KillsRegister(MachineInstr *MI, unsigned Reg) const;
+  
   killed_iterator dead_begin(MachineInstr *MI) {
-    return RegistersDead.lower_bound(MI);
+    return getDeadDefsVector(MI).begin();
   }
   killed_iterator dead_end(MachineInstr *MI) {
-    return RegistersDead.upper_bound(MI);
+    return getDeadDefsVector(MI).end();
   }
   std::pair<killed_iterator, killed_iterator>
   dead_range(MachineInstr *MI) {
-    return RegistersDead.equal_range(MI);
+    std::vector<unsigned> &V = getDeadDefsVector(MI);
+    return std::make_pair(V.begin(), V.end());
   }
-
+  
+  /// RegisterDefIsDead - Return true if the specified instruction defines the
+  /// specified register, but that definition is dead.
+  bool RegisterDefIsDead(MachineInstr *MI, unsigned Reg) const;
+  
   //===--------------------------------------------------------------------===//
   //  API to update live variable information
 
@@ -160,7 +177,17 @@ public:
   /// instruction.
   ///
   void addVirtualRegisterKilled(unsigned IncomingReg, MachineInstr *MI) {
-    RegistersKilled.insert(std::make_pair(MI, IncomingReg));
+    std::vector<unsigned> &V = RegistersKilled[MI];
+    // Insert in a sorted order.
+    if (V.empty() || IncomingReg > V.back()) {
+      V.push_back(IncomingReg);
+    } else {
+      std::vector<unsigned>::iterator I = V.begin();
+      for (; *I < IncomingReg; ++I)
+        /*empty*/;
+      if (*I != IncomingReg)   // Don't insert duplicates.
+        V.insert(I, IncomingReg);
+    }
     getVarInfo(IncomingReg).Kills.push_back(MI);
   }
 
@@ -173,30 +200,46 @@ public:
                                    MachineInstr *MI) {
     if (!getVarInfo(reg).removeKill(MI))
       return false;
-    for (killed_iterator i = killed_begin(MI), e = killed_end(MI); i != e; ) {
-      if (i->second == reg)
-        RegistersKilled.erase(i++);
-      else
-        ++i;
-    }
+
+    std::vector<unsigned> &V = getKillsVector(MI);
+    for (unsigned i = 0, e = V.size(); i != e; ++i)
+      if (V[i] == reg) {
+        V.erase(V.begin()+i);
+        return true;
+      }
     return true;
   }
 
-  /// removeVirtualRegistersKilled - Remove all of the specified killed
-  /// registers from the live variable information.
-  void removeVirtualRegistersKilled(killed_iterator B, killed_iterator E) {
-    for (killed_iterator I = B; I != E; ++I) { // Remove VarInfo entries...
-      bool removed = getVarInfo(I->second).removeKill(I->first);
-      assert(removed && "kill not in register's VarInfo?");
+  /// removeVirtualRegistersKilled - Remove all killed info for the specified
+  /// instruction.
+  void removeVirtualRegistersKilled(MachineInstr *MI) {
+    std::map<MachineInstr*, std::vector<unsigned> >::iterator I = 
+      RegistersKilled.find(MI);
+    if (I != RegistersKilled.end()) {
+      std::vector<unsigned> &Regs = I->second;
+      for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
+        bool removed = getVarInfo(Regs[i]).removeKill(MI);
+        assert(removed && "kill not in register's VarInfo?");
+      }
+      RegistersKilled.erase(I);
     }
-    RegistersKilled.erase(B, E);
   }
 
   /// addVirtualRegisterDead - Add information about the fact that the specified
   /// register is dead after being used by the specified instruction.
   ///
   void addVirtualRegisterDead(unsigned IncomingReg, MachineInstr *MI) {
-    RegistersDead.insert(std::make_pair(MI, IncomingReg));
+    std::vector<unsigned> &V = RegistersDead[MI];
+    // Insert in a sorted order.
+    if (V.empty() || IncomingReg > V.back()) {
+      V.push_back(IncomingReg);
+    } else {
+      std::vector<unsigned>::iterator I = V.begin();
+      for (; *I < IncomingReg; ++I)
+        /*empty*/;
+      if (*I != IncomingReg)   // Don't insert duplicates.
+        V.insert(I, IncomingReg);
+    }
     getVarInfo(IncomingReg).Kills.push_back(MI);
   }
 
@@ -210,21 +253,28 @@ public:
     if (!getVarInfo(reg).removeKill(MI))
       return false;
 
-    for (killed_iterator i = killed_begin(MI), e = killed_end(MI); i != e; ) {
-      if (i->second == reg)
-        RegistersKilled.erase(i++);
-      else
-        ++i;
-    }
+    std::vector<unsigned> &V = getDeadDefsVector(MI);
+    for (unsigned i = 0, e = V.size(); i != e; ++i)
+      if (V[i] == reg) {
+        V.erase(V.begin()+i);
+        return true;
+      }
     return true;
   }
 
   /// removeVirtualRegistersDead - Remove all of the specified dead
   /// registers from the live variable information.
-  void removeVirtualRegistersDead(killed_iterator B, killed_iterator E) {
-    for (killed_iterator I = B; I != E; ++I)  // Remove VarInfo entries...
-      getVarInfo(I->second).removeKill(I->first);
-    RegistersDead.erase(B, E);
+  void removeVirtualRegistersDead(MachineInstr *MI) {
+    std::map<MachineInstr*, std::vector<unsigned> >::iterator I = 
+      RegistersDead.find(MI);
+    if (I != RegistersDead.end()) {
+      std::vector<unsigned> &Regs = I->second;
+      for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
+        bool removed = getVarInfo(Regs[i]).removeKill(MI);
+        assert(removed && "kill not in register's VarInfo?");
+      }
+      RegistersDead.erase(I);
+    }
   }
 
   virtual void getAnalysisUsage(AnalysisUsage &AU) const {

llvm/include/llvm/CodeGen/MachineCodeEmitter.h

@@ -94,6 +94,9 @@ public:
   //
   virtual uint64_t getConstantPoolEntryAddress(unsigned Index) = 0;
 
+  // allocateGlobal - Allocate some space for a global variable.
+  virtual unsigned char* allocateGlobal(unsigned size, unsigned alignment) = 0;
+
   /// createDebugEmitter - Return a dynamically allocated machine
   /// code emitter, which just prints the opcodes and fields out the cout.  This
   /// can be used for debugging users of the MachineCodeEmitter interface.

llvm/include/llvm/CodeGen/MachineConstantPool.h

@@ -46,6 +46,10 @@ public:
     return Constants.size()-1;
   }
 
+  /// isEmpty - Return true if this constant pool contains no constants.
+  ///
+  bool isEmpty() const { return Constants.empty(); }
+
   const std::vector<Constant*> &getConstants() const { return Constants; }
 
   /// print - Used by the MachineFunction printer to print information about

llvm/include/llvm/CodeGen/MachineFunction.h

@@ -143,8 +143,7 @@ public:
   MachineConstantPool *getConstantPool() const { return ConstantPool; }
 
   /// MachineFunctionInfo - Keep track of various per-function pieces of
-  /// information for backends that would like to do so. (Currently,
-  /// SPARC and IA64.)
+  /// information for backends that would like to do so.
   ///
   template<typename Ty>
   Ty *getInfo() {

llvm/include/llvm/CodeGen/MachineInstr.h

@@ -503,10 +503,10 @@ public:
   void dump() const;
   friend std::ostream& operator<<(std::ostream& os, const MachineInstr& minstr);
 
-  //
   // Define iterators to access the Value operands of the Machine Instruction.
   // Note that these iterators only enumerate the explicit operands.
-  // begin() and end() are defined to produce these iterators...
+  // begin() and end() are defined to produce these iterators.  NOTE, these are
+  // SparcV9 specific!
   //
   template<class _MI, class _V> class ValOpIterator;
   typedef ValOpIterator<const MachineInstr*,const Value*> const_val_op_iterator;
@@ -711,7 +711,7 @@ public:
   void SetRegForImplicitRef(unsigned i, int regNum);
 
   //
-  // Iterator to enumerate machine operands.
+  // Iterator to enumerate machine operands.  NOTE, this is SPARCV9 specific!
   //
   template<class MITy, class VTy>
   class ValOpIterator : public forward_iterator<VTy, ptrdiff_t> {
@@ -763,10 +763,9 @@ public:
     }
   };
 
-  // define begin() and end()
+  // Note: These are Sparc-V9 specific!
   val_op_iterator begin() { return val_op_iterator::begin(this); }
   val_op_iterator end()   { return val_op_iterator::end(this); }
-
   const_val_op_iterator begin() const {
     return const_val_op_iterator::begin(this);
   }

llvm/include/llvm/CodeGen/MachineRelocation.h

@@ -32,23 +32,33 @@ class GlobalValue;
 ///   4. An optional constant value to be added to the reference.
 ///   5. A bit, CanRewrite, which indicates to the JIT that a function stub is
 ///      not needed for the relocation.
+///   6. An index into the GOT, if the target uses a GOT
 ///
 class MachineRelocation {
   /// OffsetTypeExternal - The low 24-bits of this value is the offset from the
   /// start of the code buffer of the relocation to perform.  Bit 24 of this is
   /// set if Target should use ExtSym instead of GV, Bit 25 is the CanRewrite
   /// bit, and the high 6 bits hold the relocation type.
+  // FIXME: with the additional types of relocatable things, rearrange the
+  // storage of things to be a bit more effiecient
   unsigned OffsetTypeExternal;
   union {
     GlobalValue *GV;     // If this is a pointer to an LLVM global
     const char *ExtSym;  // If this is a pointer to a named symbol
     void *Result;        // If this has been resolved to a resolved pointer
+    unsigned GOTIndex;   // Index in the GOT of this symbol/global
+    unsigned CPool;      // Index in the Constant Pool
   } Target;
   intptr_t ConstantVal;
+  bool GOTRelative; //out of bits in OffsetTypeExternal
+  bool isConstPool;
+
 public:
   MachineRelocation(unsigned Offset, unsigned RelocationType, GlobalValue *GV,
-                    intptr_t cst = 0, bool DoesntNeedFunctionStub = 0)
-    : OffsetTypeExternal(Offset + (RelocationType << 26)), ConstantVal(cst) {
+                    intptr_t cst = 0, bool DoesntNeedFunctionStub = 0,
+                    bool GOTrelative = 0)
+    : OffsetTypeExternal(Offset + (RelocationType << 26)), ConstantVal(cst),
+      GOTRelative(GOTrelative), isConstPool(0) {
     assert((Offset & ~((1 << 24)-1)) == 0 && "Code offset too large!");
     assert((RelocationType & ~63) == 0 && "Relocation type too large!");
     Target.GV = GV;
@@ -57,14 +67,23 @@ public:
   }
 
   MachineRelocation(unsigned Offset, unsigned RelocationType, const char *ES,
-                    intptr_t cst = 0)
+                    intptr_t cst = 0, bool GOTrelative = 0)
     : OffsetTypeExternal(Offset + (1 << 24) + (RelocationType << 26)),
-    ConstantVal(cst) {
+      ConstantVal(cst), GOTRelative(GOTrelative), isConstPool(0) {
     assert((Offset & ~((1 << 24)-1)) == 0 && "Code offset too large!");
     assert((RelocationType & ~63) == 0 && "Relocation type too large!");
     Target.ExtSym = ES;
   }
 
+  MachineRelocation(unsigned Offset, unsigned RelocationType, unsigned CPI,
+                    intptr_t cst = 0)
+    : OffsetTypeExternal(Offset + (RelocationType << 26)),
+      ConstantVal(cst), GOTRelative(0), isConstPool(1) {
+    assert((Offset & ~((1 << 24)-1)) == 0 && "Code offset too large!");
+    assert((RelocationType & ~63) == 0 && "Relocation type too large!");
+    Target.CPool = CPI;
+  }
+
   /// getMachineCodeOffset - Return the offset into the code buffer that the
   /// relocation should be performed.
   unsigned getMachineCodeOffset() const {
@@ -87,13 +106,25 @@ public:
   /// isGlobalValue - Return true if this relocation is a GlobalValue, as
   /// opposed to a constant string.
   bool isGlobalValue() const {
-    return (OffsetTypeExternal & (1 << 24)) == 0;
+    return (OffsetTypeExternal & (1 << 24)) == 0 && !isConstantPoolIndex();
   }
 
   /// isString - Return true if this is a constant string.
   ///
   bool isString() const {
-    return !isGlobalValue();
+    return !isGlobalValue() && !isConstantPoolIndex();
+  }
+
+  /// isConstantPoolIndex - Return true if this is a constant pool reference.
+  ///
+  bool isConstantPoolIndex() const {
+    return isConstPool;
+  }
+
+  /// isGOTRelative - Return true the target wants the index into the GOT of
+  /// the symbol rather than the address of the symbol.
+  bool isGOTRelative() const {
+    return GOTRelative;
   }
 
   /// doesntNeedFunctionStub - This function returns true if the JIT for this
@@ -119,6 +150,13 @@ public:
     return Target.ExtSym;
   }
 
+  /// getConstantPoolIndex - If this is a const pool reference, return
+  /// the index into the constant pool.
+  unsigned getConstantPoolIndex() const {
+    assert(isConstantPoolIndex() && "This is not a constant pool reference!");
+    return Target.CPool;
+  }
+
   /// getResultPointer - Once this has been resolved to point to an actual
   /// address, this returns the pointer.
   void *getResultPointer() const {
@@ -130,6 +168,19 @@ public:
   void setResultPointer(void *Ptr) {
     Target.Result = Ptr;
   }
+
+  /// setGOTIndex - Set the GOT index to a specific value.
+  void setGOTIndex(unsigned idx) {
+    Target.GOTIndex = idx;
+  }
+
+  /// getGOTIndex - Once this has been resolved to an entry in the GOT,
+  /// this returns that index.  The index is from the lowest address entry
+  /// in the GOT.
+  unsigned getGOTIndex() const {
+    return Target.GOTIndex;
+  }
+
 };
 
 }

llvm/include/llvm/CodeGen/Passes.h

@@ -70,11 +70,6 @@ namespace llvm {
   ///
   FunctionPass *createLinearScanRegisterAllocator();
 
-  /// IterativeScanRegisterAllocation Pass - This pass implements the iterative
-  /// scan register allocation algorithm, a global register allocator.
-  ///
-  FunctionPass *createIterativeScanRegisterAllocator();
-
   /// PrologEpilogCodeInserter Pass - This pass inserts prolog and epilog code,
   /// and eliminates abstract frame references.
   ///

llvm/include/llvm/CodeGen/SelectionDAG.h

@@ -66,6 +66,7 @@ public:
   typedef std::vector<SDNode*>::const_iterator allnodes_iterator;
   allnodes_iterator allnodes_begin() const { return AllNodes.begin(); }
   allnodes_iterator allnodes_end() const { return AllNodes.end(); }
+  unsigned allnodes_size() const { return AllNodes.size(); }
 
   /// getRoot - Return the root tag of the SelectionDAG.
   ///
@@ -79,6 +80,12 @@ public:
   ///
   const SDOperand &setRoot(SDOperand N) { return Root = N; }
 
+  /// Combine - This iterates over the nodes in the SelectionDAG, folding
+  /// certain types of nodes together, or eliminating superfluous nodes.  When
+  /// the AfterLegalize argument is set to 'true', Combine takes care not to
+  /// generate any nodes that will be illegal on the target.
+  void Combine(bool AfterLegalize);
+  
   /// Legalize - This transforms the SelectionDAG into a SelectionDAG that is
   /// compatible with the target instruction selector, as indicated by the
   /// TargetLowering object.
@@ -94,36 +101,69 @@ public:
   void RemoveDeadNodes(SDNode *N = 0);
 
   SDOperand getConstant(uint64_t Val, MVT::ValueType VT);
+  SDOperand getTargetConstant(uint64_t Val, MVT::ValueType VT);
   SDOperand getConstantFP(double Val, MVT::ValueType VT);
   SDOperand getGlobalAddress(const GlobalValue *GV, MVT::ValueType VT);
+  SDOperand getTargetGlobalAddress(const GlobalValue *GV, MVT::ValueType VT);
   SDOperand getFrameIndex(int FI, MVT::ValueType VT);
-  SDOperand getConstantPool(unsigned CPIdx, MVT::ValueType VT);
+  SDOperand getTargetFrameIndex(int FI, MVT::ValueType VT);
+  SDOperand getConstantPool(Constant *C, MVT::ValueType VT);
+  SDOperand getTargetConstantPool(Constant *C, MVT::ValueType VT);
   SDOperand getBasicBlock(MachineBasicBlock *MBB);
   SDOperand getExternalSymbol(const char *Sym, MVT::ValueType VT);
+  SDOperand getTargetExternalSymbol(const char *Sym, MVT::ValueType VT);
+  SDOperand getValueType(MVT::ValueType);
+  SDOperand getRegister(unsigned Reg, MVT::ValueType VT);
 
-  SDOperand getCopyToReg(SDOperand Chain, SDOperand N, unsigned Reg) {
-    // Note: these are auto-CSE'd because the caller doesn't make requests that
-    // could cause duplicates to occur.
-    SDNode *NN = new RegSDNode(ISD::CopyToReg, Chain, N, Reg);
-    NN->setValueTypes(MVT::Other);
-    AllNodes.push_back(NN);
-    return SDOperand(NN, 0);
+  SDOperand getCopyToReg(SDOperand Chain, unsigned Reg, SDOperand N) {
+    return getNode(ISD::CopyToReg, MVT::Other, Chain,
+                   getRegister(Reg, N.getValueType()), N);
   }
 
-  SDOperand getCopyFromReg(unsigned Reg, MVT::ValueType VT, SDOperand Chain) {
-    // Note: These nodes are auto-CSE'd by the caller of this method.
-    SDNode *NN = new RegSDNode(ISD::CopyFromReg, Chain, Reg);
-    NN->setValueTypes(VT, MVT::Other);
-    AllNodes.push_back(NN);
-    return SDOperand(NN, 0);
+  // This version of the getCopyToReg method takes an extra operand, which
+  // indicates that there is potentially an incoming flag value (if Flag is not
+  // null) and that there should be a flag result.
+  SDOperand getCopyToReg(SDOperand Chain, unsigned Reg, SDOperand N,
+                         SDOperand Flag) {
+    std::vector<MVT::ValueType> VTs;
+    VTs.push_back(MVT::Other);
+    VTs.push_back(MVT::Flag);
+    std::vector<SDOperand> Ops;
+    Ops.push_back(Chain);
+    Ops.push_back(getRegister(Reg, N.getValueType()));
+    Ops.push_back(N);
+    if (Flag.Val) Ops.push_back(Flag);
+    return getNode(ISD::CopyToReg, VTs, Ops);
+  }
+  
+  SDOperand getCopyFromReg(SDOperand Chain, unsigned Reg, MVT::ValueType VT) {
+    std::vector<MVT::ValueType> ResultTys;
+    ResultTys.push_back(VT);
+    ResultTys.push_back(MVT::Other);
+    std::vector<SDOperand> Ops;
+    Ops.push_back(Chain);
+    Ops.push_back(getRegister(Reg, VT));
+    return getNode(ISD::CopyFromReg, ResultTys, Ops);
+  }
+  
+  // This version of the getCopyFromReg method takes an extra operand, which
+  // indicates that there is potentially an incoming flag value (if Flag is not
+  // null) and that there should be a flag result.
+  SDOperand getCopyFromReg(SDOperand Chain, unsigned Reg, MVT::ValueType VT,
+                           SDOperand Flag) {
+    std::vector<MVT::ValueType> ResultTys;
+    ResultTys.push_back(VT);
+    ResultTys.push_back(MVT::Other);
+    ResultTys.push_back(MVT::Flag);
+    std::vector<SDOperand> Ops;
+    Ops.push_back(Chain);
+    Ops.push_back(getRegister(Reg, VT));
+    if (Flag.Val) Ops.push_back(Flag);
+    return getNode(ISD::CopyFromReg, ResultTys, Ops);
   }
 
-  SDOperand getImplicitDef(SDOperand Chain, unsigned Reg) {
-    // Note: These nodes are auto-CSE'd by the caller of this method.
-    SDNode *NN = new RegSDNode(ISD::ImplicitDef, Chain, Reg);
-    NN->setValueTypes(MVT::Other);
-    AllNodes.push_back(NN);
-    return SDOperand(NN, 0);
+  SDOperand getImplicitDef(SDOperand Chain, unsigned Reg, MVT::ValueType VT) {
+    return getNode(ISD::ImplicitDef, MVT::Other, Chain, getRegister(Reg, VT));
   }
 
   /// getCall - Note that this destroys the vector of RetVals passed in.
@@ -151,9 +191,7 @@ public:
     return NN;
   }
 
-
-  SDOperand getSetCC(ISD::CondCode, MVT::ValueType VT,
-                     SDOperand LHS, SDOperand RHS);
+  SDOperand getCondCode(ISD::CondCode Cond);
 
   /// getZeroExtendInReg - Return the expression required to zero extend the Op
   /// value assuming it was the smaller SrcTy value.
@@ -169,62 +207,186 @@ public:
                     SDOperand N1, SDOperand N2, SDOperand N3);
   SDOperand getNode(unsigned Opcode, MVT::ValueType VT,
                     SDOperand N1, SDOperand N2, SDOperand N3, SDOperand N4);
+  SDOperand getNode(unsigned Opcode, MVT::ValueType VT,
+                    SDOperand N1, SDOperand N2, SDOperand N3, SDOperand N4,
+                    SDOperand N5);
   SDOperand getNode(unsigned Opcode, MVT::ValueType VT,
                     std::vector<SDOperand> &Children);
   SDOperand getNode(unsigned Opcode, std::vector<MVT::ValueType> &ResultTys,
                     std::vector<SDOperand> &Ops);
 
-  // getNode - These versions take an extra value type for extending and
-  // truncating loads, stores, rounds, extends etc.
-  SDOperand getNode(unsigned Opcode, MVT::ValueType VT, SDOperand N1,
-                    SDOperand N2, MVT::ValueType EVT);
-  SDOperand getNode(unsigned Opcode, MVT::ValueType VT,
-                    SDOperand N, MVT::ValueType EVT);
-  SDOperand getNode(unsigned Opcode, MVT::ValueType VT, SDOperand N1,
-                    SDOperand N2, SDOperand N3, MVT::ValueType EVT);
-  SDOperand getNode(unsigned Opcode, MVT::ValueType VT, SDOperand N1,
-                    SDOperand N2, SDOperand N3, SDOperand N4,
-                    MVT::ValueType EVT);
+  /// getSetCC - Helper function to make it easier to build SetCC's if you just
+  /// have an ISD::CondCode instead of an SDOperand.
+  ///
+  SDOperand getSetCC(MVT::ValueType VT, SDOperand LHS, SDOperand RHS,
+                     ISD::CondCode Cond) {
+    return getNode(ISD::SETCC, VT, LHS, RHS, getCondCode(Cond));
+  }
 
+  /// getSelectCC - Helper function to make it easier to build SelectCC's if you
+  /// just have an ISD::CondCode instead of an SDOperand.
+  ///
+  SDOperand getSelectCC(SDOperand LHS, SDOperand RHS,
+                        SDOperand True, SDOperand False, ISD::CondCode Cond) {
+    MVT::ValueType VT = True.getValueType();
+    return getNode(ISD::SELECT_CC, VT, LHS, RHS, True, False,getCondCode(Cond));
+  }
+  
+  /// getBR2Way_CC - Helper function to make it easier to build BRTWOWAY_CC
+  /// nodes.
+  ///
+  SDOperand getBR2Way_CC(SDOperand Chain, SDOperand CCNode, SDOperand LHS, 
+                         SDOperand RHS, SDOperand True, SDOperand False) {
+    std::vector<SDOperand> Ops;
+    Ops.push_back(Chain);
+    Ops.push_back(CCNode);
+    Ops.push_back(LHS);
+    Ops.push_back(RHS);
+    Ops.push_back(True);
+    Ops.push_back(False);
+    return getNode(ISD::BRTWOWAY_CC, MVT::Other, Ops);
+  }
 
   /// getLoad - Loads are not normal binary operators: their result type is not
   /// determined by their operands, and they produce a value AND a token chain.
   ///
   SDOperand getLoad(MVT::ValueType VT, SDOperand Chain, SDOperand Ptr,
                     SDOperand SV);
+  SDOperand getExtLoad(unsigned Opcode, MVT::ValueType VT, SDOperand Chain,
+                       SDOperand Ptr, SDOperand SV, MVT::ValueType EVT);
 
   // getSrcValue - construct a node to track a Value* through the backend
   SDOperand getSrcValue(const Value* I, int offset = 0);
 
-  void replaceAllUsesWith(SDOperand Old, SDOperand New) {
-    assert(Old != New && "RAUW self!");
-    assert(0 && "Unimplemented!");
-  }
+  
+  /// SelectNodeTo - These are used for target selectors to *mutate* the
+  /// specified node to have the specified return type, Target opcode, and
+  /// operands.  Note that target opcodes are stored as
+  /// ISD::BUILTIN_OP_END+TargetOpcode in the node opcode field.
+  void SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT);
+  void SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT, 
+                    SDOperand Op1);
+  void SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT, 
+                    SDOperand Op1, SDOperand Op2);
+  void SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT, 
+                    SDOperand Op1, SDOperand Op2, SDOperand Op3);
+  void SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT, 
+                    SDOperand Op1, SDOperand Op2, SDOperand Op3, SDOperand Op4);
+  void SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT, 
+                    SDOperand Op1, SDOperand Op2, SDOperand Op3, SDOperand Op4,
+                    SDOperand Op5);
+  void SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT1, 
+                    MVT::ValueType VT2, SDOperand Op1, SDOperand Op2);
+  void SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT1,
+                    MVT::ValueType VT2, SDOperand Op1, SDOperand Op2,
+                    SDOperand Op3);
 
+  SDOperand getTargetNode(unsigned Opcode, MVT::ValueType VT) {
+    return getNode(ISD::BUILTIN_OP_END+Opcode, VT);
+  }
+  SDOperand getTargetNode(unsigned Opcode, MVT::ValueType VT,
+                          SDOperand Op1) {
+    return getNode(ISD::BUILTIN_OP_END+Opcode, VT, Op1);
+  }
+  SDOperand getTargetNode(unsigned Opcode, MVT::ValueType VT,
+                          SDOperand Op1, SDOperand Op2) {
+    return getNode(ISD::BUILTIN_OP_END+Opcode, VT, Op1, Op2);
+  }
+  SDOperand getTargetNode(unsigned Opcode, MVT::ValueType VT1,
+                          MVT::ValueType VT2, SDOperand Op1, SDOperand Op2) {
+    std::vector<MVT::ValueType> ResultTys;
+    ResultTys.push_back(VT1);
+    ResultTys.push_back(VT2);
+    std::vector<SDOperand> Ops;
+    Ops.push_back(Op1);
+    Ops.push_back(Op2);
+    return getNode(ISD::BUILTIN_OP_END+Opcode, ResultTys, Ops);
+  }
+  SDOperand getTargetNode(unsigned Opcode, MVT::ValueType VT,
+                          SDOperand Op1, SDOperand Op2, SDOperand Op3) {
+    return getNode(ISD::BUILTIN_OP_END+Opcode, VT, Op1, Op2, Op3);
+  }
+  SDOperand getTargetNode(unsigned Opcode, MVT::ValueType VT,
+                          SDOperand Op1, SDOperand Op2, SDOperand Op3,
+                          SDOperand Op4) {
+    return getNode(ISD::BUILTIN_OP_END+Opcode, VT, Op1, Op2, Op3, Op4);
+  }
+  SDOperand getTargetNode(unsigned Opcode, MVT::ValueType VT,
+                          SDOperand Op1, SDOperand Op2, SDOperand Op3,
+                          SDOperand Op4, SDOperand Op5) {
+    return getNode(ISD::BUILTIN_OP_END+Opcode, VT, Op1, Op2, Op3, Op4, Op5);
+  }
+  SDOperand getTargetNode(unsigned Opcode, MVT::ValueType VT,
+                          std::vector<SDOperand> &Ops) {
+    return getNode(ISD::BUILTIN_OP_END+Opcode, VT, Ops);
+  }
+  SDOperand getTargetNode(unsigned Opcode, MVT::ValueType VT1, 
+                          MVT::ValueType VT2, std::vector<SDOperand> &Ops) {
+    std::vector<MVT::ValueType> ResultTys;
+    ResultTys.push_back(VT1);
+    ResultTys.push_back(VT2);
+    return getNode(ISD::BUILTIN_OP_END+Opcode, ResultTys, Ops);
+  }
+  
+  /// ReplaceAllUsesWith - Modify anything using 'From' to use 'To' instead.
+  /// This can cause recursive merging of nodes in the DAG.  Use the first
+  /// version if 'From' is known to have a single result, use the second
+  /// if you have two nodes with identical results, use the third otherwise.
+  ///
+  /// These methods all take an optional vector, which (if not null) is 
+  /// populated with any nodes that are deleted from the SelectionDAG, due to
+  /// new equivalences that are discovered.
+  ///
+  void ReplaceAllUsesWith(SDOperand From, SDOperand Op,
+                          std::vector<SDNode*> *Deleted = 0);
+  void ReplaceAllUsesWith(SDNode *From, SDNode *To,
+                          std::vector<SDNode*> *Deleted = 0);
+  void ReplaceAllUsesWith(SDNode *From, const std::vector<SDOperand> &To,
+                          std::vector<SDNode*> *Deleted = 0);
+  
+  
+  /// DeleteNode - Remove the specified node from the system.  This node must
+  /// have no referrers.
+  void DeleteNode(SDNode *N);
+  
   void dump() const;
 
 private:
+  void RemoveNodeFromCSEMaps(SDNode *N);
+  SDNode *AddNonLeafNodeToCSEMaps(SDNode *N);
   void DeleteNodeIfDead(SDNode *N, void *NodeSet);
+  void DeleteNodeNotInCSEMaps(SDNode *N);
+  
+  /// SimplifySetCC - Try to simplify a setcc built with the specified operands 
+  /// and cc.  If unable to simplify it, return a null SDOperand.
+  SDOperand SimplifySetCC(MVT::ValueType VT, SDOperand N1,
+                          SDOperand N2, ISD::CondCode Cond);
 
   // Maps to auto-CSE operations.
+  std::map<std::pair<unsigned, MVT::ValueType>, SDNode *> NullaryOps;
   std::map<std::pair<unsigned, std::pair<SDOperand, MVT::ValueType> >,
            SDNode *> UnaryOps;
   std::map<std::pair<unsigned, std::pair<SDOperand, SDOperand> >,
            SDNode *> BinaryOps;
 
-  std::map<std::pair<std::pair<SDOperand, SDOperand>,
-                     std::pair<ISD::CondCode, MVT::ValueType> >,
-           SetCCSDNode*> SetCCs;
+  std::map<std::pair<unsigned, MVT::ValueType>, RegisterSDNode*> RegNodes;
+  std::vector<CondCodeSDNode*> CondCodeNodes;
 
   std::map<std::pair<SDOperand, std::pair<SDOperand, MVT::ValueType> >,
            SDNode *> Loads;
 
   std::map<const GlobalValue*, SDNode*> GlobalValues;
+  std::map<const GlobalValue*, SDNode*> TargetGlobalValues;
   std::map<std::pair<uint64_t, MVT::ValueType>, SDNode*> Constants;
+  std::map<std::pair<uint64_t, MVT::ValueType>, SDNode*> TargetConstants;
   std::map<std::pair<uint64_t, MVT::ValueType>, SDNode*> ConstantFPs;
-  std::map<int, SDNode*> FrameIndices;
-  std::map<unsigned, SDNode*> ConstantPoolIndices;
+  std::map<int, SDNode*> FrameIndices, TargetFrameIndices;
+  std::map<Constant *, SDNode*> ConstantPoolIndices;
+  std::map<Constant *, SDNode*> TargetConstantPoolIndices;
   std::map<MachineBasicBlock *, SDNode*> BBNodes;
+  std::vector<SDNode*> ValueTypeNodes;
+  std::map<std::string, SDNode*> ExternalSymbols;
+  std::map<std::string, SDNode*> TargetExternalSymbols;
   std::map<std::pair<unsigned,
                      std::pair<MVT::ValueType, std::vector<SDOperand> > >,
            SDNode*> OneResultNodes;
@@ -232,23 +394,6 @@ private:
                      std::pair<std::vector<MVT::ValueType>,
                                std::vector<SDOperand> > >,
            SDNode*> ArbitraryNodes;
-
-  std::map<std::string, SDNode*> ExternalSymbols;
-  struct EVTStruct {
-    unsigned Opcode;
-    MVT::ValueType VT, EVT;
-    std::vector<SDOperand> Ops;
-    bool operator<(const EVTStruct &RHS) const {
-      if (Opcode < RHS.Opcode) return true;
-      if (Opcode > RHS.Opcode) return false;
-      if (VT < RHS.VT) return true;
-      if (VT > RHS.VT) return false;
-      if (EVT < RHS.EVT) return true;
-      if (EVT > RHS.EVT) return false;
-      return Ops < RHS.Ops;
-    }
-  };
-  std::map<EVTStruct, SDNode*> MVTSDNodes;
 };
 
 template <> struct GraphTraits<SelectionDAG*> : public GraphTraits<SDNode*> {

llvm/include/llvm/CodeGen/SelectionDAGISel.h

@@ -40,9 +40,7 @@ public:
 
   SelectionDAGISel(TargetLowering &tli) : TLI(tli) {}
 
-  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
-    AU.setPreservesAll();
-  }
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const;
 
   virtual bool runOnFunction(Function &Fn);
 
@@ -51,6 +49,11 @@ public:
   virtual void EmitFunctionEntryCode(Function &Fn, MachineFunction &MF) {}
   virtual void InstructionSelectBasicBlock(SelectionDAG &SD) = 0;
 
+protected:
+  /// Pick a safe ordering and emit instructions for each target node in the
+  /// graph.
+  void ScheduleAndEmitDAG(SelectionDAG &SD);
+  
 private:
   SDOperand CopyValueToVirtualRegister(SelectionDAGLowering &SDL,
                                        Value *V, unsigned Reg);

llvm/include/llvm/CodeGen/SelectionDAGNodes.h

@@ -48,19 +48,36 @@ namespace ISD {
     // EntryToken - This is the marker used to indicate the start of the region.
     EntryToken,
 
-    // Token factor - This node is takes multiple tokens as input and produces a
+    // Token factor - This node takes multiple tokens as input and produces a
     // single token result.  This is used to represent the fact that the operand
     // operators are independent of each other.
     TokenFactor,
+    
+    // AssertSext, AssertZext - These nodes record if a register contains a 
+    // value that has already been zero or sign extended from a narrower type.  
+    // These nodes take two operands.  The first is the node that has already 
+    // been extended, and the second is a value type node indicating the width
+    // of the extension
+    AssertSext, AssertZext,
 
     // Various leaf nodes.
     Constant, ConstantFP, GlobalAddress, FrameIndex, ConstantPool,
-    BasicBlock, ExternalSymbol,
+    BasicBlock, ExternalSymbol, VALUETYPE, CONDCODE, Register,
+    
+    // TargetConstant - Like Constant, but the DAG does not do any folding or
+    // simplification of the constant.  This is used by the DAG->DAG selector.
+    TargetConstant,
+    
+    // TargetGlobalAddress - Like GlobalAddress, but the DAG does no folding or
+    // anything else with this node, and this is valid in the target-specific
+    // dag, turning into a GlobalAddress operand.
+    TargetGlobalAddress,
+    TargetFrameIndex,
+    TargetConstantPool,
+    TargetExternalSymbol,
 
-    // CopyToReg - This node has chain and child nodes, and an associated
-    // register number.  The instruction selector must guarantee that the value
-    // of the value node is available in the register stored in the RegSDNode
-    // object.
+    // CopyToReg - This node has three operands: a chain, a register number to
+    // set to this value, and a value.  
     CopyToReg,
 
     // CopyFromReg - This node indicates that the input value is a virtual or
@@ -69,10 +86,9 @@ namespace ISD {
     CopyFromReg,
 
     // ImplicitDef - This node indicates that the specified register is
-    // implicitly defined by some operation (e.g. its a live-in argument).  This
-    // register is indicated in the RegSDNode object.  The only operand to this
-    // is the token chain coming in, the only result is the token chain going
-    // out.
+    // implicitly defined by some operation (e.g. its a live-in argument).  The
+    // two operands to this are the token chain coming in and the register.
+    // The only result is the token chain going out.
     ImplicitDef,
 
     // UNDEF - An undefined node
@@ -90,8 +106,11 @@ namespace ISD {
     BUILD_PAIR,
 
 
-    // Simple binary arithmetic operators.
+    // Simple integer binary arithmetic operators.
     ADD, SUB, MUL, SDIV, UDIV, SREM, UREM,
+    
+    // Simple binary floating point operators.
+    FADD, FSUB, FMUL, FDIV, FREM,
 
     // MULHU/MULHS - Multiply high - Multiply two integers of type iN, producing
     // an unsigned/signed value of type i[2*n], then return the top part.
@@ -103,13 +122,19 @@ namespace ISD {
     // Counting operators
     CTTZ, CTLZ, CTPOP,
 
-    // Select operator.
-    SELECT,
+    // Select
+    SELECT, 
+    
+    // Select with condition operator - This selects between a true value and 
+    // a false value (ops #2 and #3) based on the boolean result of comparing
+    // the lhs and rhs (ops #0 and #1) of a conditional expression with the 
+    // condition code in op #4, a CondCodeSDNode.
+    SELECT_CC,
 
     // SetCC operator - This evaluates to a boolean (i1) true value if the
-    // condition is true.  These nodes are instances of the
-    // SetCCSDNode class, which contains the condition code as extra
-    // state.
+    // condition is true.  The operands to this are the left and right operands
+    // to compare (ops #0, and #1) and the condition code to compare them with
+    // (op #2) as a CondCodeSDNode.
     SETCC,
 
     // ADD_PARTS/SUB_PARTS - These operators take two logical operands which are
@@ -137,6 +162,9 @@ namespace ISD {
     // ZERO_EXTEND - Used for integer types, zeroing the new bits.
     ZERO_EXTEND,
 
+    // ANY_EXTEND - Used for integer types.  The high bits are undefined.
+    ANY_EXTEND,
+    
     // TRUNCATE - Completely drop the high bits.
     TRUNCATE,
 
@@ -148,8 +176,8 @@ namespace ISD {
     // SIGN_EXTEND_INREG - This operator atomically performs a SHL/SRA pair to
     // sign extend a small value in a large integer register (e.g. sign
     // extending the low 8 bits of a 32-bit register to fill the top 24 bits
-    // with the 7th bit).  The size of the smaller type is indicated by the
-    // ExtraValueType in the MVTSDNode for the operator.
+    // with the 7th bit).  The size of the smaller type is indicated by the 1th
+    // operand, a ValueType node.
     SIGN_EXTEND_INREG,
 
     // FP_TO_[US]INT - Convert a floating point value to a signed or unsigned
@@ -164,8 +192,8 @@ namespace ISD {
     // FP_ROUND_INREG - This operator takes a floating point register, and
     // rounds it to a floating point value.  It then promotes it and returns it
     // in a register of the same size.  This operation effectively just discards
-    // excess precision.  The type to round down to is specified by the
-    // ExtraValueType in the MVTSDNode (currently always 64->32->64).
+    // excess precision.  The type to round down to is specified by the 1th
+    // operation, a VTSDNode (currently always 64->32->64).
     FP_ROUND_INREG,
 
     // FP_EXTEND - Extend a smaller FP type into a larger FP type.
@@ -176,14 +204,15 @@ namespace ISD {
     FNEG, FABS, FSQRT, FSIN, FCOS,
 
     // Other operators.  LOAD and STORE have token chains as their first
-    // operand, then the same operands as an LLVM load/store instruction.
+    // operand, then the same operands as an LLVM load/store instruction, then a
+    // SRCVALUE node that provides alias analysis information.
     LOAD, STORE,
 
-    // EXTLOAD, SEXTLOAD, ZEXTLOAD - These three operators are instances of the
-    // MVTSDNode.  All of these load a value from memory and extend them to a
-    // larger value (e.g. load a byte into a word register).  All three of these
-    // have two operands, a chain and a pointer to load from.  The extra value
-    // type is the source type being loaded.
+    // EXTLOAD, SEXTLOAD, ZEXTLOAD - These three operators all load a value from
+    // memory and extend them to a larger value (e.g. load a byte into a word
+    // register).  All three of these have four operands, a token chain, a
+    // pointer to load from, a SRCVALUE for alias analysis, and a VALUETYPE node
+    // indicating the type to load.
     //
     // SEXTLOAD loads the integer operand and sign extends it to a larger
     //          integer result type.
@@ -197,15 +226,17 @@ namespace ISD {
 
     // TRUNCSTORE - This operators truncates (for integer) or rounds (for FP) a
     // value and stores it to memory in one operation.  This can be used for
-    // either integer or floating point operands, and the stored type
-    // represented as the 'extra' value type in the MVTSDNode representing the
-    // operator.  This node has the same three operands as a standard store.
+    // either integer or floating point operands.  The first four operands of
+    // this are the same as a standard store.  The fifth is the ValueType to
+    // store it as (which will be smaller than the source value).
     TRUNCSTORE,
 
     // DYNAMIC_STACKALLOC - Allocate some number of bytes on the stack aligned
     // to a specified boundary.  The first operand is the token chain, the
     // second is the number of bytes to allocate, and the third is the alignment
-    // boundary.
+    // boundary.  The size is guaranteed to be a multiple of the stack 
+    // alignment, and the alignment is guaranteed to be bigger than the stack 
+    // alignment (if required) or 0 to get standard stack alignment.
     DYNAMIC_STACKALLOC,
 
     // Control flow instructions.  These all have token chains.
@@ -226,6 +257,18 @@ namespace ISD {
     // operation to BRCOND/BR pairs when necessary.
     BRCONDTWOWAY,
 
+    // BR_CC - Conditional branch.  The behavior is like that of SELECT_CC, in
+    // that the condition is represented as condition code, and two nodes to
+    // compare, rather than as a combined SetCC node.  The operands in order are
+    // chain, cc, lhs, rhs, block to branch to if condition is true.
+    BR_CC,
+    
+    // BRTWOWAY_CC - Two-way conditional branch.  The operands in order are
+    // chain, cc, lhs, rhs, block to branch to if condition is true, block to
+    // branch to if condition is false.  Targets usually do not implement this,
+    // preferring to have legalize demote the operation to BRCOND/BR pairs.
+    BRTWOWAY_CC,
+    
     // RET - Return from function.  The first operand is the chain,
     // and any subsequent operands are the return values for the
     // function.  This operation can have variable number of operands.
@@ -267,6 +310,9 @@ namespace ISD {
     // other operands match the intrinsic.  These produce a token chain in
     // addition to a value (if any).
     READPORT, WRITEPORT, READIO, WRITEIO,
+    
+    // HANDLENODE node - Used as a handle for various purposes.
+    HANDLENODE,
 
     // BUILTIN_OP_END - This must be the last enum value in this list.
     BUILTIN_OP_END,
@@ -408,6 +454,8 @@ public:
   inline unsigned getNodeDepth() const;
   inline unsigned getNumOperands() const;
   inline const SDOperand &getOperand(unsigned i) const;
+  inline bool isTargetOpcode() const;
+  inline unsigned getTargetOpcode() const;
 
   /// hasOneUse - Return true if there is exactly one operation using this
   /// result value of the defining operator.
@@ -460,6 +508,11 @@ public:
   //  Accessors
   //
   unsigned getOpcode()  const { return NodeType; }
+  bool isTargetOpcode() const { return NodeType >= ISD::BUILTIN_OP_END; }
+  unsigned getTargetOpcode() const {
+    assert(isTargetOpcode() && "Not a target opcode!");
+    return NodeType - ISD::BUILTIN_OP_END;
+  }
 
   size_t use_size() const { return Uses.size(); }
   bool use_empty() const { return Uses.empty(); }
@@ -507,22 +560,23 @@ public:
     assert(ResNo < Values.size() && "Illegal result number!");
     return Values[ResNo];
   }
-  
+
   typedef std::vector<MVT::ValueType>::const_iterator value_iterator;
   value_iterator value_begin() const { return Values.begin(); }
   value_iterator value_end() const { return Values.end(); }
 
   /// getOperationName - Return the opcode of this operation for printing.
   ///
-  const char* getOperationName() const;
+  const char* getOperationName(const SelectionDAG *G = 0) const;
   void dump() const;
+  void dump(const SelectionDAG *G) const;
 
   static bool classof(const SDNode *) { return true; }
 
 
   /// setAdjCallChain - This method should only be used by the legalizer.
   void setAdjCallChain(SDOperand N);
-  
+
 protected:
   friend class SelectionDAG;
 
@@ -585,10 +639,24 @@ protected:
     NodeDepth = ND+1;
   }
 
-  virtual ~SDNode() {
-    // FIXME: Drop uses.
-  }
+  virtual ~SDNode() {}
 
+  /// MorphNodeTo - This clears the return value and operands list, and sets the
+  /// opcode of the node to the specified value.  This should only be used by
+  /// the SelectionDAG class.
+  void MorphNodeTo(unsigned Opc) {
+    NodeType = Opc;
+    Values.clear();
+    
+    // Clear the operands list, updating used nodes to remove this from their
+    // use list.
+    while (!Operands.empty()) {
+      SDNode *O = Operands.back().Val;
+      Operands.pop_back();
+      O->removeUser(this);
+    }
+  }
+  
   void setValueTypes(MVT::ValueType VT) {
     Values.reserve(1);
     Values.push_back(VT);
@@ -602,14 +670,58 @@ protected:
   void setValueTypes(std::vector<MVT::ValueType> &VTs) {
     std::swap(Values, VTs);
   }
-
+  
+  void setOperands(SDOperand Op0) {
+    Operands.reserve(1);
+    Operands.push_back(Op0);
+    Op0.Val->Uses.push_back(this);
+  }
+  void setOperands(SDOperand Op0, SDOperand Op1) {
+    Operands.reserve(2);
+    Operands.push_back(Op0);
+    Operands.push_back(Op1);
+    Op0.Val->Uses.push_back(this); Op1.Val->Uses.push_back(this);
+  }
+  void setOperands(SDOperand Op0, SDOperand Op1, SDOperand Op2) {
+    Operands.reserve(3);
+    Operands.push_back(Op0);
+    Operands.push_back(Op1);
+    Operands.push_back(Op2);
+    Op0.Val->Uses.push_back(this); Op1.Val->Uses.push_back(this);
+    Op2.Val->Uses.push_back(this);
+  }
+  void setOperands(SDOperand Op0, SDOperand Op1, SDOperand Op2, SDOperand Op3) {
+    Operands.reserve(4);
+    Operands.push_back(Op0);
+    Operands.push_back(Op1);
+    Operands.push_back(Op2);
+    Operands.push_back(Op3);
+    Op0.Val->Uses.push_back(this); Op1.Val->Uses.push_back(this);
+    Op2.Val->Uses.push_back(this); Op3.Val->Uses.push_back(this);
+  }
+  void setOperands(SDOperand Op0, SDOperand Op1, SDOperand Op2, SDOperand Op3,
+                   SDOperand Op4) {
+    Operands.reserve(5);
+    Operands.push_back(Op0);
+    Operands.push_back(Op1);
+    Operands.push_back(Op2);
+    Operands.push_back(Op3);
+    Operands.push_back(Op4);
+    Op0.Val->Uses.push_back(this); Op1.Val->Uses.push_back(this);
+    Op2.Val->Uses.push_back(this); Op3.Val->Uses.push_back(this);
+    Op4.Val->Uses.push_back(this);
+  }
+  void addUser(SDNode *User) {
+    Uses.push_back(User);
+  }
   void removeUser(SDNode *User) {
     // Remove this user from the operand's use list.
     for (unsigned i = Uses.size(); ; --i) {
       assert(i != 0 && "Didn't find user!");
       if (Uses[i-1] == User) {
-        Uses.erase(Uses.begin()+i-1);
-        break;
+        Uses[i-1] = Uses.back();
+        Uses.pop_back();
+        return;
       }
     }
   }
@@ -633,17 +745,37 @@ inline unsigned SDOperand::getNumOperands() const {
 inline const SDOperand &SDOperand::getOperand(unsigned i) const {
   return Val->getOperand(i);
 }
+inline bool SDOperand::isTargetOpcode() const {
+  return Val->isTargetOpcode();
+}
+inline unsigned SDOperand::getTargetOpcode() const {
+  return Val->getTargetOpcode();
+}
 inline bool SDOperand::hasOneUse() const {
   return Val->hasNUsesOfValue(1, ResNo);
 }
 
+/// HandleSDNode - This class is used to form a handle around another node that
+/// is persistant and is updated across invocations of replaceAllUsesWith on its
+/// operand.  This node should be directly created by end-users and not added to
+/// the AllNodes list.
+class HandleSDNode : public SDNode {
+public:
+  HandleSDNode(SDOperand X) : SDNode(ISD::HANDLENODE, X) {}
+  ~HandleSDNode() {
+    MorphNodeTo(ISD::HANDLENODE);  // Drops operand uses.
+  }
+  
+  SDOperand getValue() const { return getOperand(0); }
+};
+
 
 class ConstantSDNode : public SDNode {
   uint64_t Value;
 protected:
   friend class SelectionDAG;
-  ConstantSDNode(uint64_t val, MVT::ValueType VT)
-    : SDNode(ISD::Constant, VT), Value(val) {
+  ConstantSDNode(bool isTarget, uint64_t val, MVT::ValueType VT)
+    : SDNode(isTarget ? ISD::TargetConstant : ISD::Constant, VT), Value(val) {
   }
 public:
 
@@ -663,7 +795,8 @@ public:
 
   static bool classof(const ConstantSDNode *) { return true; }
   static bool classof(const SDNode *N) {
-    return N->getOpcode() == ISD::Constant;
+    return N->getOpcode() == ISD::Constant ||
+           N->getOpcode() == ISD::TargetConstant;
   }
 };
 
@@ -682,19 +815,7 @@ public:
   /// it returns true for things that are clearly not equal, like -0.0 and 0.0.
   /// As such, this method can be used to do an exact bit-for-bit comparison of
   /// two floating point values.
-  bool isExactlyValue(double V) const {
-    union {
-      double V;
-      uint64_t I;
-    } T1;
-    T1.V = Value;
-    union {
-      double V;
-      uint64_t I;
-    } T2;
-    T2.V = V;
-    return T1.I == T2.I;
-  }
+  bool isExactlyValue(double V) const;
 
   static bool classof(const ConstantFPSDNode *) { return true; }
   static bool classof(const SDNode *N) {
@@ -706,8 +827,8 @@ class GlobalAddressSDNode : public SDNode {
   GlobalValue *TheGlobal;
 protected:
   friend class SelectionDAG;
-  GlobalAddressSDNode(const GlobalValue *GA, MVT::ValueType VT)
-    : SDNode(ISD::GlobalAddress, VT) {
+  GlobalAddressSDNode(bool isTarget, const GlobalValue *GA, MVT::ValueType VT)
+    : SDNode(isTarget ? ISD::TargetGlobalAddress : ISD::GlobalAddress, VT) {
     TheGlobal = const_cast<GlobalValue*>(GA);
   }
 public:
@@ -716,7 +837,8 @@ public:
 
   static bool classof(const GlobalAddressSDNode *) { return true; }
   static bool classof(const SDNode *N) {
-    return N->getOpcode() == ISD::GlobalAddress;
+    return N->getOpcode() == ISD::GlobalAddress ||
+           N->getOpcode() == ISD::TargetGlobalAddress;
   }
 };
 
@@ -725,31 +847,34 @@ class FrameIndexSDNode : public SDNode {
   int FI;
 protected:
   friend class SelectionDAG;
-  FrameIndexSDNode(int fi, MVT::ValueType VT)
-    : SDNode(ISD::FrameIndex, VT), FI(fi) {}
+  FrameIndexSDNode(int fi, MVT::ValueType VT, bool isTarg)
+    : SDNode(isTarg ? ISD::TargetFrameIndex : ISD::FrameIndex, VT), FI(fi) {}
 public:
 
   int getIndex() const { return FI; }
 
   static bool classof(const FrameIndexSDNode *) { return true; }
   static bool classof(const SDNode *N) {
-    return N->getOpcode() == ISD::FrameIndex;
+    return N->getOpcode() == ISD::FrameIndex ||
+           N->getOpcode() == ISD::TargetFrameIndex;
   }
 };
 
 class ConstantPoolSDNode : public SDNode {
-  unsigned CPI;
+  Constant *C;
 protected:
   friend class SelectionDAG;
-  ConstantPoolSDNode(unsigned cpi, MVT::ValueType VT)
-    : SDNode(ISD::ConstantPool, VT), CPI(cpi) {}
+  ConstantPoolSDNode(Constant *c, MVT::ValueType VT, bool isTarget)
+    : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, VT),
+    C(c) {}
 public:
 
-  unsigned getIndex() const { return CPI; }
+  Constant *get() const { return C; }
 
   static bool classof(const ConstantPoolSDNode *) { return true; }
   static bool classof(const SDNode *N) {
-    return N->getOpcode() == ISD::ConstantPool;
+    return N->getOpcode() == ISD::ConstantPool ||
+           N->getOpcode() == ISD::TargetConstantPool;
   }
 };
 
@@ -788,24 +913,19 @@ public:
 };
 
 
-class RegSDNode : public SDNode {
+class RegisterSDNode : public SDNode {
   unsigned Reg;
 protected:
   friend class SelectionDAG;
-  RegSDNode(unsigned Opc, SDOperand Chain, SDOperand Src, unsigned reg)
-    : SDNode(Opc, Chain, Src), Reg(reg) {
-  }
-  RegSDNode(unsigned Opc, SDOperand Chain, unsigned reg)
-    : SDNode(Opc, Chain), Reg(reg) {}
+  RegisterSDNode(unsigned reg, MVT::ValueType VT)
+    : SDNode(ISD::Register, VT), Reg(reg) {}
 public:
 
   unsigned getReg() const { return Reg; }
 
-  static bool classof(const RegSDNode *) { return true; }
+  static bool classof(const RegisterSDNode *) { return true; }
   static bool classof(const SDNode *N) {
-    return N->getOpcode() == ISD::CopyToReg ||
-           N->getOpcode() == ISD::CopyFromReg ||
-           N->getOpcode() == ISD::ImplicitDef;
+    return N->getOpcode() == ISD::Register;
   }
 };
 
@@ -813,8 +933,9 @@ class ExternalSymbolSDNode : public SDNode {
   const char *Symbol;
 protected:
   friend class SelectionDAG;
-  ExternalSymbolSDNode(const char *Sym, MVT::ValueType VT)
-    : SDNode(ISD::ExternalSymbol, VT), Symbol(Sym) {
+  ExternalSymbolSDNode(bool isTarget, const char *Sym, MVT::ValueType VT)
+    : SDNode(isTarget ? ISD::TargetExternalSymbol : ISD::ExternalSymbol, VT),
+      Symbol(Sym) {
     }
 public:
 
@@ -822,64 +943,47 @@ public:
 
   static bool classof(const ExternalSymbolSDNode *) { return true; }
   static bool classof(const SDNode *N) {
-    return N->getOpcode() == ISD::ExternalSymbol;
+    return N->getOpcode() == ISD::ExternalSymbol ||
+           N->getOpcode() == ISD::TargetExternalSymbol;
   }
 };
 
-class SetCCSDNode : public SDNode {
+class CondCodeSDNode : public SDNode {
   ISD::CondCode Condition;
 protected:
   friend class SelectionDAG;
-  SetCCSDNode(ISD::CondCode Cond, SDOperand LHS, SDOperand RHS)
-    : SDNode(ISD::SETCC, LHS, RHS), Condition(Cond) {
+  CondCodeSDNode(ISD::CondCode Cond)
+    : SDNode(ISD::CONDCODE, MVT::Other), Condition(Cond) {
   }
 public:
 
-  ISD::CondCode getCondition() const { return Condition; }
+  ISD::CondCode get() const { return Condition; }
 
-  static bool classof(const SetCCSDNode *) { return true; }
+  static bool classof(const CondCodeSDNode *) { return true; }
   static bool classof(const SDNode *N) {
-    return N->getOpcode() == ISD::SETCC;
+    return N->getOpcode() == ISD::CONDCODE;
   }
 };
 
-/// MVTSDNode - This class is used for operators that require an extra
-/// value-type to be kept with the node.
-class MVTSDNode : public SDNode {
-  MVT::ValueType ExtraValueType;
+/// VTSDNode - This class is used to represent MVT::ValueType's, which are used
+/// to parameterize some operations.
+class VTSDNode : public SDNode {
+  MVT::ValueType ValueType;
 protected:
   friend class SelectionDAG;
-  MVTSDNode(unsigned Opc, MVT::ValueType VT1, SDOperand Op0, MVT::ValueType EVT)
-    : SDNode(Opc, Op0), ExtraValueType(EVT) {
-    setValueTypes(VT1);
-  }
-  MVTSDNode(unsigned Opc, MVT::ValueType VT1, MVT::ValueType VT2,
-            SDOperand Op0, SDOperand Op1, SDOperand Op2, MVT::ValueType EVT)
-    : SDNode(Opc, Op0, Op1, Op2), ExtraValueType(EVT) {
-    setValueTypes(VT1, VT2);
-  }
-
-  MVTSDNode(unsigned Opc, MVT::ValueType VT,
-            SDOperand Op0, SDOperand Op1, SDOperand Op2, SDOperand Op3, MVT::ValueType EVT)
-    : SDNode(Opc, Op0, Op1, Op2, Op3), ExtraValueType(EVT) {
-    setValueTypes(VT);
-  }
+  VTSDNode(MVT::ValueType VT)
+    : SDNode(ISD::VALUETYPE, MVT::Other), ValueType(VT) {}
 public:
 
-  MVT::ValueType getExtraValueType() const { return ExtraValueType; }
+  MVT::ValueType getVT() const { return ValueType; }
 
-  static bool classof(const MVTSDNode *) { return true; }
+  static bool classof(const VTSDNode *) { return true; }
   static bool classof(const SDNode *N) {
-    return
-      N->getOpcode() == ISD::SIGN_EXTEND_INREG ||
-      N->getOpcode() == ISD::FP_ROUND_INREG ||
-      N->getOpcode() == ISD::EXTLOAD  ||
-      N->getOpcode() == ISD::SEXTLOAD ||
-      N->getOpcode() == ISD::ZEXTLOAD ||
-      N->getOpcode() == ISD::TRUNCSTORE;
+    return N->getOpcode() == ISD::VALUETYPE;
   }
 };
 
+
 class SDNodeIterator : public forward_iterator<SDNode, ptrdiff_t> {
   SDNode *Node;
   unsigned Operand;
@@ -931,9 +1035,6 @@ template <> struct GraphTraits<SDNode*> {
   }
 };
 
-
-
-
 } // end llvm namespace
 
 #endif

llvm/include/llvm/CodeGen/ValueTypes.h

@@ -40,8 +40,9 @@ namespace MVT {  // MVT = Machine Value Types
     f64             =  8,   // This is a 64 bit floating point value
     f80             =  9,   // This is a 80 bit floating point value
     f128            = 10,   // This is a 128 bit floating point value
+    Flag           =  11,   // This is a condition code or machine flag.
 
-    isVoid          = 11,   // This has no value
+    isVoid          = 12,   // This has no value
 
     LAST_VALUETYPE,         // This always remains at the end of the list.
   };

llvm/include/llvm/Config/config.h.in

@@ -11,6 +11,9 @@
 /* Define to 1 if using `alloca.c'. */
 #undef C_ALLOCA
 
+/* Define if threads enabled */
+#undef ENABLE_THREADS
+
 /* Define to 1 if you have `alloca', as a function or macro. */
 #undef HAVE_ALLOCA
 
@@ -121,6 +124,12 @@
 /* Does not have hash_set in gnu namespace */
 #undef HAVE_GNU_EXT_HASH_SET
 
+/* Define if the Graphviz program is available */
+#undef HAVE_GRAPHVIZ
+
+/* Define if the gv program is available */
+#undef HAVE_GV
+
 /* Define to 1 if you have the `index' function. */
 #undef HAVE_INDEX
 
@@ -151,6 +160,9 @@
 /* Define to 1 if you have the `elf' library (-lelf). */
 #undef HAVE_LIBELF
 
+/* Define to 1 if you have the `pthread' library (-lpthread). */
+#undef HAVE_LIBPTHREAD
+
 /* Define to 1 if you have the <limits.h> header file. */
 #undef HAVE_LIMITS_H
 
@@ -216,6 +228,9 @@
 /* Define to have the %a format string */
 #undef HAVE_PRINTF_A
 
+/* Define to 1 if you have the <pthread.h> header file. */
+#undef HAVE_PTHREAD_H
+
 /* Have pthread_mutex_lock */
 #undef HAVE_PTHREAD_MUTEX_LOCK
 
@@ -383,6 +398,12 @@
 /* Define if this is Win32ish platform */
 #undef LLVM_ON_WIN32
 
+/* Define to path to Graphviz program if found or 'echo Graphviz' otherwise */
+#undef LLVM_PATH_GRAPHVIZ
+
+/* Define to path to gv program if found or 'echo gv' otherwise */
+#undef LLVM_PATH_GV
+
 /* Installation prefix directory */
 #undef LLVM_PREFIX
 

llvm/include/llvm/Constant.h

@@ -61,12 +61,8 @@ public:
   static inline bool classof(const Constant *) { return true; }
   static inline bool classof(const GlobalValue *) { return true; }
   static inline bool classof(const Value *V) {
-    return V->getValueType() == Value::SimpleConstantVal ||
-           V->getValueType() == Value::ConstantExprVal ||
-           V->getValueType() == Value::ConstantAggregateZeroVal ||
-           V->getValueType() == Value::FunctionVal ||
-           V->getValueType() == Value::GlobalVariableVal ||
-           V->getValueType() == Value::UndefValueVal;
+    return V->getValueType() >= ConstantFirstVal &&
+           V->getValueType() <= ConstantLastVal;
   }
 
   /// replaceUsesOfWithOnConstant - This method is a special form of
@@ -79,8 +75,7 @@ public:
   /// use Value::replaceAllUsesWith, which automatically dispatches to this
   /// method as needed.
   ///
-  virtual void replaceUsesOfWithOnConstant(Value *From, Value *To,
-                                           bool DisableChecking = false) {
+  virtual void replaceUsesOfWithOnConstant(Value *, Value *, Use *) {
     // Provide a default implementation for constants (like integers) that
     // cannot use any other values.  This cannot be called at runtime, but needs
     // to be here to avoid link errors.

llvm/include/llvm/Constants.h

@@ -47,14 +47,28 @@ protected:
     int64_t  Signed;
     uint64_t Unsigned;
   } Val;
-  ConstantIntegral(const Type *Ty, uint64_t V);
+  ConstantIntegral(const Type *Ty, ValueTy VT, uint64_t V);
 public:
 
   /// getRawValue - return the underlying value of this constant as a 64-bit
   /// unsigned integer value.
   ///
   inline uint64_t getRawValue() const { return Val.Unsigned; }
+  
+  /// getZExtValue - Return the constant zero extended as appropriate for this
+  /// type.
+  inline uint64_t getZExtValue() const {
+    unsigned Size = getType()->getPrimitiveSizeInBits();
+    return Val.Unsigned & (~0ULL >> (64-Size));
+  }
 
+  /// getSExtValue - Return the constant sign extended as appropriate for this
+  /// type.
+  inline int64_t getSExtValue() const {
+    unsigned Size = getType()->getPrimitiveSizeInBits();
+    return (Val.Signed << (64-Size)) >> (64-Size);
+  }
+  
   /// isNullValue - Return true if this is the value that would be returned by
   /// getNullValue.
   ///
@@ -84,8 +98,9 @@ public:
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ConstantIntegral *) { return true; }
   static bool classof(const Value *V) {
-    return V->getValueType() == SimpleConstantVal &&
-           V->getType()->isIntegral();
+    return V->getValueType() == ConstantBoolVal ||
+           V->getValueType() == ConstantSIntVal ||
+           V->getValueType() == ConstantUIntVal;
   }
 };
 
@@ -120,7 +135,7 @@ public:
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ConstantBool *) { return true; }
   static bool classof(const Value *V) {
-    return (V == True) | (V == False);
+    return V->getValueType() == ConstantBoolVal;
   }
 };
 
@@ -132,7 +147,7 @@ public:
 class ConstantInt : public ConstantIntegral {
 protected:
   ConstantInt(const ConstantInt &);      // DO NOT IMPLEMENT
-  ConstantInt(const Type *Ty, uint64_t V);
+  ConstantInt(const Type *Ty, ValueTy VT, uint64_t V);
 public:
   /// equalsInt - Provide a helper method that can be used to determine if the
   /// constant contained within is equal to a constant.  This only works for
@@ -159,8 +174,8 @@ public:
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ConstantInt *) { return true; }
   static bool classof(const Value *V) {
-    return V->getValueType() == SimpleConstantVal &&
-           V->getType()->isInteger();
+    return V->getValueType() == ConstantSIntVal ||
+           V->getValueType() == ConstantUIntVal;
   }
 };
 
@@ -213,8 +228,7 @@ public:
   ///
   static inline bool classof(const ConstantSInt *) { return true; }
   static bool classof(const Value *V) {
-    return V->getValueType() == SimpleConstantVal &&
-           V->getType()->isSigned();
+    return V->getValueType() == ConstantSIntVal;
   }
 };
 
@@ -249,8 +263,7 @@ public:
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ConstantUInt *) { return true; }
   static bool classof(const Value *V) {
-    return V->getValueType() == SimpleConstantVal &&
-           V->getType()->isUnsigned();
+    return V->getValueType() == ConstantUIntVal;
   }
 };
 
@@ -276,38 +289,18 @@ public:
   /// isNullValue - Return true if this is the value that would be returned by
   /// getNullValue.  Don't depend on == for doubles to tell us it's zero, it
   /// considers -0.0 to be null as well as 0.0.  :(
-  virtual bool isNullValue() const {
-    union {
-      double V;
-      uint64_t I;
-    } T;
-    T.V = Val;
-    return T.I == 0;
-  }
+  virtual bool isNullValue() const;
 
   /// isExactlyValue - We don't rely on operator== working on double values, as
   /// it returns true for things that are clearly not equal, like -0.0 and 0.0.
   /// As such, this method can be used to do an exact bit-for-bit comparison of
   /// two floating point values.
-  bool isExactlyValue(double V) const {
-    union {
-      double V;
-      uint64_t I;
-    } T1;
-    T1.V = Val;
-    union {
-      double V;
-      uint64_t I;
-    } T2;
-    T2.V = V;
-    return T1.I == T2.I;
-  }
+  bool isExactlyValue(double V) const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ConstantFP *) { return true; }
   static bool classof(const Value *V) {
-    return V->getValueType() == SimpleConstantVal &&
-           V->getType()->isFloatingPoint();
+    return V->getValueType() == ConstantFPVal;
   }
 };
 
@@ -330,8 +323,6 @@ public:
   virtual bool isNullValue() const { return true; }
 
   virtual void destroyConstant();
-  virtual void replaceUsesOfWithOnConstant(Value *From, Value *To,
-                                           bool DisableChecking = false);
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   ///
@@ -379,14 +370,12 @@ public:
   virtual bool isNullValue() const { return false; }
 
   virtual void destroyConstant();
-  virtual void replaceUsesOfWithOnConstant(Value *From, Value *To,
-                                           bool DisableChecking = false);
+  virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U);
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ConstantArray *) { return true; }
   static bool classof(const Value *V) {
-    return V->getValueType() == SimpleConstantVal &&
-           V->getType()->getTypeID() == Type::ArrayTyID;
+    return V->getValueType() == ConstantArrayVal;
   }
 };
 
@@ -421,14 +410,12 @@ public:
   }
 
   virtual void destroyConstant();
-  virtual void replaceUsesOfWithOnConstant(Value *From, Value *To,
-                                           bool DisableChecking = false);
+  virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U);
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ConstantStruct *) { return true; }
   static bool classof(const Value *V) {
-    return V->getValueType() == SimpleConstantVal &&
-           V->getType()->getTypeID() == Type::StructTyID;
+    return V->getValueType() == ConstantStructVal;
   }
 };
 
@@ -460,14 +447,12 @@ public:
   virtual bool isNullValue() const { return false; }
 
   virtual void destroyConstant();
-  virtual void replaceUsesOfWithOnConstant(Value *From, Value *To,
-                                           bool DisableChecking = false);
+  virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U);
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ConstantPacked *) { return true; }
   static bool classof(const Value *V) {
-    return V->getValueType() == SimpleConstantVal &&
-           V->getType()->getTypeID() == Type::PackedTyID;
+    return V->getValueType() == ConstantPackedVal;
   }
 };
 
@@ -480,7 +465,7 @@ class ConstantPointerNull : public Constant {
 protected:
   ConstantPointerNull(const PointerType *T)
     : Constant(reinterpret_cast<const Type*>(T),
-               Value::SimpleConstantVal, 0, 0) {}
+               Value::ConstantPointerNullVal, 0, 0) {}
 
 public:
 
@@ -503,8 +488,7 @@ public:
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const ConstantPointerNull *) { return true; }
   static bool classof(const Value *V) {
-    return V->getValueType() == SimpleConstantVal &&
-           isa<PointerType>(V->getType());
+    return V->getValueType() == ConstantPointerNullVal;
   }
 };
 
@@ -615,8 +599,7 @@ public:
   const char *getOpcodeName() const;
 
   virtual void destroyConstant();
-  virtual void replaceUsesOfWithOnConstant(Value *From, Value *To,
-                                           bool DisableChecking = false);
+  virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U);
 
   /// Override methods to provide more type information...
   inline Constant *getOperand(unsigned i) {

llvm/include/llvm/ExecutionEngine/ExecutionEngine.h

@@ -19,6 +19,7 @@
 #include <map>
 #include <cassert>
 #include <string>
+#include "llvm/Support/MutexGuard.h"
 
 namespace llvm {
 
@@ -33,10 +34,9 @@ class TargetData;
 class Type;
 class IntrinsicLowering;
 
-class ExecutionEngine {
-  Module &CurMod;
-  const TargetData *TD;
 
+class ExecutionEngineState {
+private:
   /// GlobalAddressMap - A mapping between LLVM global values and their
   /// actualized version...
   std::map<const GlobalValue*, void *> GlobalAddressMap;
@@ -46,6 +46,24 @@ class ExecutionEngine {
   /// at the address.  This map is not computed unless getGlobalValueAtAddress
   /// is called at some point.
   std::map<void *, const GlobalValue*> GlobalAddressReverseMap;
+
+public:
+  std::map<const GlobalValue*, void *>& getGlobalAddressMap(const MutexGuard& locked) {
+    return GlobalAddressMap;
+  }
+
+  std::map<void *, const GlobalValue*>& getGlobalAddressReverseMap(const MutexGuard& locked) {
+    return GlobalAddressReverseMap;
+  }
+};
+
+
+class ExecutionEngine {
+  Module &CurMod;
+  const TargetData *TD;
+
+  ExecutionEngineState state;
+
 protected:
   ModuleProvider *MP;
 
@@ -54,6 +72,10 @@ protected:
   }
 
 public:
+  /// lock - This lock is protects the ExecutionEngine, JIT, JITResolver and JITEmitter classes.
+  /// It must be held while changing the internal state of any of those classes.
+  sys::Mutex lock; // Used to make this class and subclasses thread-safe
+
   ExecutionEngine(ModuleProvider *P);
   ExecutionEngine(Module *M);
   virtual ~ExecutionEngine();
@@ -81,13 +103,15 @@ public:
 
 
   void addGlobalMapping(const GlobalValue *GV, void *Addr) {
-    void *&CurVal = GlobalAddressMap[GV];
+    MutexGuard locked(lock);
+
+    void *&CurVal = state.getGlobalAddressMap(locked)[GV];
     assert((CurVal == 0 || Addr == 0) && "GlobalMapping already established!");
     CurVal = Addr;
 
     // If we are using the reverse mapping, add it too
-    if (!GlobalAddressReverseMap.empty()) {
-      const GlobalValue *&V = GlobalAddressReverseMap[Addr];
+    if (!state.getGlobalAddressReverseMap(locked).empty()) {
+      const GlobalValue *&V = state.getGlobalAddressReverseMap(locked)[Addr];
       assert((V == 0 || GV == 0) && "GlobalMapping already established!");
       V = GV;
     }
@@ -96,21 +120,25 @@ public:
   /// clearAllGlobalMappings - Clear all global mappings and start over again
   /// use in dynamic compilation scenarios when you want to move globals
   void clearAllGlobalMappings() {
-    GlobalAddressMap.clear();
-    GlobalAddressReverseMap.clear();
+    MutexGuard locked(lock);
+
+    state.getGlobalAddressMap(locked).clear();
+    state.getGlobalAddressReverseMap(locked).clear();
   }
 
   /// updateGlobalMapping - Replace an existing mapping for GV with a new
   /// address.  This updates both maps as required.
   void updateGlobalMapping(const GlobalValue *GV, void *Addr) {
-    void *&CurVal = GlobalAddressMap[GV];
-    if (CurVal && !GlobalAddressReverseMap.empty())
-      GlobalAddressReverseMap.erase(CurVal);
+    MutexGuard locked(lock);
+
+    void *&CurVal = state.getGlobalAddressMap(locked)[GV];
+    if (CurVal && !state.getGlobalAddressReverseMap(locked).empty())
+      state.getGlobalAddressReverseMap(locked).erase(CurVal);
     CurVal = Addr;
 
     // If we are using the reverse mapping, add it too
-    if (!GlobalAddressReverseMap.empty()) {
-      const GlobalValue *&V = GlobalAddressReverseMap[Addr];
+    if (!state.getGlobalAddressReverseMap(locked).empty()) {
+      const GlobalValue *&V = state.getGlobalAddressReverseMap(locked)[Addr];
       assert((V == 0 || GV == 0) && "GlobalMapping already established!");
       V = GV;
     }
@@ -120,8 +148,10 @@ public:
   /// global value if it is available, otherwise it returns null.
   ///
   void *getPointerToGlobalIfAvailable(const GlobalValue *GV) {
-    std::map<const GlobalValue*, void*>::iterator I = GlobalAddressMap.find(GV);
-    return I != GlobalAddressMap.end() ? I->second : 0;
+    MutexGuard locked(lock);
+
+    std::map<const GlobalValue*, void*>::iterator I = state.getGlobalAddressMap(locked).find(GV);
+    return I != state.getGlobalAddressMap(locked).end() ? I->second : 0;
   }
 
   /// getPointerToGlobal - This returns the address of the specified global

llvm/include/llvm/Function.h

@@ -57,8 +57,6 @@ public:
 
   typedef ArgumentListType::iterator arg_iterator;
   typedef ArgumentListType::const_iterator const_arg_iterator;
-  typedef arg_iterator aiterator; // legacy, deprecated
-  typedef const_arg_iterator const_aiterator; // legacy, deprecated
 
 private:
   // Important things that make up a function!

llvm/include/llvm/GlobalValue.h

@@ -101,7 +101,7 @@ public:
   void removeDeadConstantUsers();
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const GlobalValue *T) { return true; }
+  static inline bool classof(const GlobalValue *) { return true; }
   static inline bool classof(const Value *V) {
     return V->getValueType() == Value::FunctionVal ||
            V->getValueType() == Value::GlobalVariableVal;

llvm/include/llvm/GlobalVariable.h

@@ -113,8 +113,7 @@ public:
 
   /// Override Constant's implementation of this method so we can
   /// replace constant initializers.
-  virtual void replaceUsesOfWithOnConstant(Value *From, Value *To,
-                                           bool DisableChecking = false);
+  virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U);
 
   virtual void print(std::ostream &OS) const;
 

llvm/include/llvm/Instruction.def

@@ -128,13 +128,14 @@ HANDLE_OTHER_INST(29, Call   , CallInst   )  // Call a function
 
 HANDLE_OTHER_INST(30, Shl    , ShiftInst  )  // Shift operations
 HANDLE_OTHER_INST(31, Shr    , ShiftInst  )
-HANDLE_OTHER_INST(32, VANext , VANextInst )  // vanext instruction
-HANDLE_OTHER_INST(33, VAArg  , VAArgInst  )  // vaarg  instruction
+// 32 -> Empty slot used to be used for vanext in llvm 1.5 and before.
+// 33 -> Empty slot used to be used for vaarg in llvm 1.5 and before.
 HANDLE_OTHER_INST(34, Select , SelectInst )  // select instruction
 
 HANDLE_OTHER_INST(35, UserOp1, Instruction)  // May be used internally in a pass
 HANDLE_OTHER_INST(36, UserOp2, Instruction)
-  LAST_OTHER_INST(36)
+HANDLE_OTHER_INST(37, VAArg  , VAArgInst  )  // vaarg instruction
+  LAST_OTHER_INST(37)
 
 #undef  FIRST_TERM_INST
 #undef HANDLE_TERM_INST

llvm/include/llvm/Instruction.h

@@ -93,6 +93,11 @@ public:
   ///
   void eraseFromParent();
 
+  /// moveBefore - Unlink this instruction from its current basic block and
+  /// insert it into the basic block that MovePos lives in, right before
+  /// MovePos.
+  void moveBefore(Instruction *MovePos);
+
   // ---------------------------------------------------------------------------
   /// Subclass classification... getOpcode() returns a member of
   /// one of the enums that is coming soon (down below)...
@@ -152,7 +157,7 @@ public:
   void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const Instruction *I) { return true; }
+  static inline bool classof(const Instruction *) { return true; }
   static inline bool classof(const Value *V) {
     return V->getValueType() >= Value::InstructionVal;
   }

llvm/include/llvm/Instructions.h

@@ -660,55 +660,12 @@ public:
   }
 };
 
-
-//===----------------------------------------------------------------------===//
-//                                VANextInst Class
-//===----------------------------------------------------------------------===//
-
-/// VANextInst - This class represents the va_next llvm instruction, which
-/// advances a vararg list passed an argument of the specified type, returning
-/// the resultant list.
-///
-class VANextInst : public UnaryInstruction {
-  PATypeHolder ArgTy;
-  VANextInst(const VANextInst &VAN)
-    : UnaryInstruction(VAN.getType(), VANext, VAN.getOperand(0)),
-      ArgTy(VAN.getArgType()) {
-  }
-
-public:
-  VANextInst(Value *List, const Type *Ty, const std::string &Name = "",
-             Instruction *InsertBefore = 0)
-    : UnaryInstruction(List->getType(), VANext, List, Name, InsertBefore),
-      ArgTy(Ty) {
-  }
-  VANextInst(Value *List, const Type *Ty, const std::string &Name,
-             BasicBlock *InsertAtEnd)
-    : UnaryInstruction(List->getType(), VANext, List, Name, InsertAtEnd),
-      ArgTy(Ty) {
-  }
-
-  const Type *getArgType() const { return ArgTy; }
-
-  virtual VANextInst *clone() const;
-
-  // Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const VANextInst *) { return true; }
-  static inline bool classof(const Instruction *I) {
-    return I->getOpcode() == VANext;
-  }
-  static inline bool classof(const Value *V) {
-    return isa<Instruction>(V) && classof(cast<Instruction>(V));
-  }
-};
-
-
 //===----------------------------------------------------------------------===//
 //                                VAArgInst Class
 //===----------------------------------------------------------------------===//
 
 /// VAArgInst - This class represents the va_arg llvm instruction, which returns
-/// an argument of the specified type given a va_list.
+/// an argument of the specified type given a va_list and increments that list
 ///
 class VAArgInst : public UnaryInstruction {
   VAArgInst(const VAArgInst &VAA)
@@ -724,6 +681,7 @@ public:
   }
 
   virtual VAArgInst *clone() const;
+  bool mayWriteToMemory() const { return true; }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const VAArgInst *) { return true; }
@@ -846,6 +804,11 @@ public:
     return getIncomingValue(getBasicBlockIndex(BB));
   }
 
+  /// hasConstantValue - If the specified PHI node always merges together the 
+  /// same value, return the value, otherwise return null.
+  ///
+  Value *hasConstantValue(bool AllowNonDominatingInstruction = false) const;
+  
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const PHINode *) { return true; }
   static inline bool classof(const Instruction *I) {

llvm/include/llvm/Module.h

@@ -22,6 +22,7 @@
 #include "llvm/Function.h"
 #include "llvm/GlobalVariable.h"
 #include "llvm/ADT/SetVector.h"
+#include "llvm/Support/DataTypes.h"
 
 namespace llvm {
 
@@ -51,17 +52,15 @@ public:
   typedef iplist<Function> FunctionListType;
   typedef SetVector<std::string> LibraryListType;
 
-  // Global Variable iterators...
-  typedef GlobalListType::iterator                                   global_iterator;
-  typedef GlobalListType::const_iterator                       const_global_iterator;
-  typedef global_iterator giterator; // these are legacy, deprecated
-  typedef const_global_iterator const_giterator;
+  // Global Variable iterators.
+  typedef GlobalListType::iterator                     global_iterator;
+  typedef GlobalListType::const_iterator         const_global_iterator;
 
-  // Function iterators...
+  // Function iterators.
   typedef FunctionListType::iterator                          iterator;
   typedef FunctionListType::const_iterator              const_iterator;
 
-  // Library list iterators
+  // Library list iterators.
   typedef LibraryListType::const_iterator lib_iterator;
 
   enum Endianness  { AnyEndianness, LittleEndian, BigEndian };
@@ -86,9 +85,11 @@ public:
   Module(const std::string &ModuleID);
   ~Module();
 
-  const std::string& getModuleIdentifier() const { return ModuleID; }
-  const std::string& getTargetTriple() const { return TargetTriple; }
-  void setTargetTriple(const std::string& T) { TargetTriple = T; }
+  const std::string &getModuleIdentifier() const { return ModuleID; }
+  void setModuleIdentifier(const std::string &ID) { ModuleID = ID; }
+
+  const std::string &getTargetTriple() const { return TargetTriple; }
+  void setTargetTriple(const std::string &T) { TargetTriple = T; }
 
   /// Target endian information...
   Endianness getEndianness() const { return Endian; }
@@ -111,7 +112,8 @@ public:
   /// table.  If it does not exist, add a prototype for the function and return
   /// it.  This version of the method takes a null terminated list of function
   /// arguments, which makes it easier for clients to use.
-  Function *getOrInsertFunction(const std::string &Name, const Type *RetTy,...);
+  Function *getOrInsertFunction(const std::string &Name, const Type *RetTy,...)
+    END_WITH_NULL;
 
   /// getFunction - Look up the specified function in the module symbol table.
   /// If it does not exist, return null.

llvm/include/llvm/Support/Annotation.h

@@ -81,8 +81,7 @@ public:
 //===----------------------------------------------------------------------===//
 //
 // Annotable - This class is used as a base class for all objects that would
-// like to have annotation capability.  One notable subclass is Value, which
-// means annotations can be attached to almost everything in LLVM.
+// like to have annotation capability.
 //
 // Annotable objects keep their annotation list sorted as annotations are
 // inserted and deleted.  This is used to ensure that annotations with identical

llvm/include/llvm/Support/CommandLine.h

@@ -21,6 +21,7 @@
 #define LLVM_SUPPORT_COMMANDLINE_H
 
 #include "llvm/Support/type_traits.h"
+#include "llvm/Support/DataTypes.h"
 #include <string>
 #include <vector>
 #include <utility>
@@ -66,21 +67,21 @@ enum NumOccurrences {          // Flags for the number of occurrences allowed
   //
   ConsumeAfter    = 0x05,
 
-  OccurrencesMask  = 0x07,
+  OccurrencesMask  = 0x07
 };
 
 enum ValueExpected {           // Is a value required for the option?
   ValueOptional   = 0x08,      // The value can appear... or not
   ValueRequired   = 0x10,      // The value is required to appear!
   ValueDisallowed = 0x18,      // A value may not be specified (for flags)
-  ValueMask       = 0x18,
+  ValueMask       = 0x18
 };
 
 enum OptionHidden {            // Control whether -help shows this option
   NotHidden       = 0x20,      // Option included in --help & --help-hidden
   Hidden          = 0x40,      // -help doesn't, but --help-hidden does
   ReallyHidden    = 0x60,      // Neither --help nor --help-hidden show this arg
-  HiddenMask      = 0x60,
+  HiddenMask      = 0x60
 };
 
 // Formatting flags - This controls special features that the option might have
@@ -103,13 +104,13 @@ enum FormattingFlags {
   Positional       = 0x080,     // Is a positional argument, no '-' required
   Prefix           = 0x100,     // Can this option directly prefix its value?
   Grouping         = 0x180,     // Can this option group with other options?
-  FormattingMask   = 0x180,     // Union of the above flags.
+  FormattingMask   = 0x180      // Union of the above flags.
 };
 
 enum MiscFlags {               // Miscellaneous flags to adjust argument
   CommaSeparated     = 0x200,  // Should this cl::list split between commas?
   PositionalEatsArgs = 0x400,  // Should this positional cl::list eat -args?
-  MiscMask           = 0x600,  // Union of the above flags.
+  MiscMask           = 0x600   // Union of the above flags.
 };
 
 
@@ -334,8 +335,8 @@ public:
 };
 
 template<class DataType>
-ValuesClass<DataType> values(const char *Arg, DataType Val, const char *Desc,
-                             ...) {
+ValuesClass<DataType> END_WITH_NULL values(const char *Arg, DataType Val, 
+                                           const char *Desc, ...) {
     va_list ValueArgs;
     va_start(ValueArgs, Desc);
     ValuesClass<DataType> Vals(Arg, Val, Desc, ValueArgs);
@@ -734,7 +735,8 @@ class opt : public Option,
 
   virtual bool handleOccurrence(unsigned pos, const char *ArgName,
                                 const std::string &Arg) {
-    typename ParserClass::parser_data_type Val;
+    typename ParserClass::parser_data_type Val =
+       typename ParserClass::parser_data_type();
     if (Parser.parse(*this, ArgName, Arg, Val))
       return true;                            // Parse error!
     setValue(Val);
@@ -893,7 +895,8 @@ class list : public Option, public list_storage<DataType, Storage> {
 
   virtual bool handleOccurrence(unsigned pos, const char *ArgName,
                                 const std::string &Arg) {
-    typename ParserClass::parser_data_type Val;
+    typename ParserClass::parser_data_type Val =
+      typename ParserClass::parser_data_type();
     if (Parser.parse(*this, ArgName, Arg, Val))
       return true;  // Parse Error!
     addValue(Val);
@@ -981,6 +984,188 @@ public:
   }
 };
 
+//===----------------------------------------------------------------------===//
+// bits_storage class
+
+// Default storage class definition: external storage.  This implementation
+// assumes the user will specify a variable to store the data into with the
+// cl::location(x) modifier.
+//
+template<class DataType, class StorageClass>
+class bits_storage {
+  unsigned *Location;   // Where to store the bits...
+  
+  template<class T>
+  static unsigned Bit(const T &V) {
+    unsigned BitPos = (unsigned)V;
+    assert(BitPos < sizeof(unsigned) * 8 &&
+          "enum exceeds width of bit vector!");
+    return 1 << BitPos;
+  }
+
+public:
+  bits_storage() : Location(0) {}
+
+  bool setLocation(Option &O, unsigned &L) {
+    if (Location)
+      return O.error(": cl::location(x) specified more than once!");
+    Location = &L;
+    return false;
+  }
+
+  template<class T>
+  void addValue(const T &V) {
+    assert(Location != 0 && "cl::location(...) not specified for a command "
+           "line option with external storage!");
+    *Location |= Bit(V);
+  }
+  
+  unsigned getBits() { return *Location; }
+  
+  template<class T>
+  bool isSet(const T &V) {
+    return (*Location & Bit(V)) != 0;
+  }
+};
+
+
+// Define how to hold bits.  Since we can inherit from a class, we do so. 
+// This makes us exactly compatible with the bits in all cases that it is used.
+//
+template<class DataType>
+class bits_storage<DataType, bool> {
+  unsigned Bits;   // Where to store the bits...
+  
+  template<class T>
+  static unsigned Bit(const T &V) {
+    unsigned BitPos = (unsigned)V;
+    assert(BitPos < sizeof(unsigned) * 8 &&
+          "enum exceeds width of bit vector!");
+    return 1 << BitPos;
+  }
+  
+public:
+  template<class T>
+  void addValue(const T &V) {
+    Bits |=  Bit(V);
+  }
+  
+  unsigned getBits() { return Bits; }
+  
+  template<class T>
+  bool isSet(const T &V) {
+    return (Bits & Bit(V)) != 0;
+  }
+};
+
+
+//===----------------------------------------------------------------------===//
+// bits - A bit vector of command options.
+//
+template <class DataType, class Storage = bool,
+          class ParserClass = parser<DataType> >
+class bits : public Option, public bits_storage<DataType, Storage> {
+  std::vector<unsigned> Positions;
+  ParserClass Parser;
+
+  virtual enum NumOccurrences getNumOccurrencesFlagDefault() const {
+    return ZeroOrMore;
+  }
+  virtual enum ValueExpected getValueExpectedFlagDefault() const {
+    return Parser.getValueExpectedFlagDefault();
+  }
+
+  virtual bool handleOccurrence(unsigned pos, const char *ArgName,
+                                const std::string &Arg) {
+    typename ParserClass::parser_data_type Val =
+      typename ParserClass::parser_data_type();
+    if (Parser.parse(*this, ArgName, Arg, Val))
+      return true;  // Parse Error!
+    addValue(Val);
+    setPosition(pos);
+    Positions.push_back(pos);
+    return false;
+  }
+
+  // Forward printing stuff to the parser...
+  virtual unsigned getOptionWidth() const {return Parser.getOptionWidth(*this);}
+  virtual void printOptionInfo(unsigned GlobalWidth) const {
+    Parser.printOptionInfo(*this, GlobalWidth);
+  }
+
+  void done() {
+    addArgument(ArgStr);
+    Parser.initialize(*this);
+  }
+public:
+  ParserClass &getParser() { return Parser; }
+
+  unsigned getPosition(unsigned optnum) const {
+    assert(optnum < this->size() && "Invalid option index");
+    return Positions[optnum];
+  }
+
+  // One option...
+  template<class M0t>
+  bits(const M0t &M0) {
+    apply(M0, this);
+    done();
+  }
+  // Two options...
+  template<class M0t, class M1t>
+  bits(const M0t &M0, const M1t &M1) {
+    apply(M0, this); apply(M1, this);
+    done();
+  }
+  // Three options...
+  template<class M0t, class M1t, class M2t>
+  bits(const M0t &M0, const M1t &M1, const M2t &M2) {
+    apply(M0, this); apply(M1, this); apply(M2, this);
+    done();
+  }
+  // Four options...
+  template<class M0t, class M1t, class M2t, class M3t>
+  bits(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3) {
+    apply(M0, this); apply(M1, this); apply(M2, this); apply(M3, this);
+    done();
+  }
+  // Five options...
+  template<class M0t, class M1t, class M2t, class M3t, class M4t>
+  bits(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3,
+       const M4t &M4) {
+    apply(M0, this); apply(M1, this); apply(M2, this); apply(M3, this);
+    apply(M4, this);
+    done();
+  }
+  // Six options...
+  template<class M0t, class M1t, class M2t, class M3t,
+           class M4t, class M5t>
+  bits(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3,
+       const M4t &M4, const M5t &M5) {
+    apply(M0, this); apply(M1, this); apply(M2, this); apply(M3, this);
+    apply(M4, this); apply(M5, this);
+    done();
+  }
+  // Seven options...
+  template<class M0t, class M1t, class M2t, class M3t,
+           class M4t, class M5t, class M6t>
+  bits(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3,
+      const M4t &M4, const M5t &M5, const M6t &M6) {
+    apply(M0, this); apply(M1, this); apply(M2, this); apply(M3, this);
+    apply(M4, this); apply(M5, this); apply(M6, this);
+    done();
+  }
+  // Eight options...
+  template<class M0t, class M1t, class M2t, class M3t,
+           class M4t, class M5t, class M6t, class M7t>
+  bits(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3,
+      const M4t &M4, const M5t &M5, const M6t &M6, const M7t &M7) {
+    apply(M0, this); apply(M1, this); apply(M2, this); apply(M3, this);
+    apply(M4, this); apply(M5, this); apply(M6, this); apply(M7, this);
+    done();
+  }
+};
+
 //===----------------------------------------------------------------------===//
 // Aliased command line option (alias this name to a preexisting name)
 //

llvm/include/llvm/Support/DOTGraphTraits.h

@@ -51,6 +51,12 @@ struct DefaultDOTGraphTraits {
   static std::string getNodeLabel(const void *Node, const void *Graph) {
     return "";
   }
+  
+  /// hasNodeAddressLabel - If this method returns true, the address of the node
+  /// is added to the label of the node.
+  static bool hasNodeAddressLabel(const void *Node, const void *Graph) {
+    return false;
+  }
 
   /// If you want to specify custom node attributes, this is the place to do so
   ///

llvm/include/llvm/Support/DataTypes.h.in

@@ -1,10 +1,10 @@
 //===-- include/Support/DataTypes.h - Define fixed size types ---*- C++ -*-===//
-// 
+//
 //                     The LLVM Compiler Infrastructure
 //
 // This file was developed by the LLVM research group and is distributed under
 // the University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
+//
 //===----------------------------------------------------------------------===//
 //
 // This file contains definitions to figure out the size of _HOST_ data types.
@@ -67,6 +67,7 @@ typedef u_int64_t uint64_t;
 // Visual C++ doesn't provide standard integer headers, but it does provide
 // built-in data types.
 #include <stddef.h>
+#include <sys/types.h>
 typedef __int64 int64_t;
 typedef unsigned __int64 uint64_t;
 typedef signed int int32_t;
@@ -98,4 +99,10 @@ typedef signed int ssize_t;
 # define UINT64_MAX 0xffffffffffffffffULL
 #endif
 
+#if __GNUC__ > 3
+#define END_WITH_NULL __attribute__((sentinel))
+#else
+#define END_WITH_NULL
+#endif
+
 #endif  /* SUPPORT_DATATYPES_H */

llvm/include/llvm/Support/FileUtilities.h

@@ -45,7 +45,7 @@ namespace llvm {
     ~FileRemover() {
       if (DeleteIt)
         try {
-          Filename.destroyFile();
+          Filename.eraseFromDisk();
         } catch (...) {}             // Ignore problems deleting the file.
     }
 

llvm/include/llvm/Support/GraphWriter.h

@@ -111,9 +111,14 @@ public:
     if (!NodeAttributes.empty()) O << NodeAttributes << ",";
     O << "label=\"{";
 
-    if (!DOTTraits::renderGraphFromBottomUp())
+    if (!DOTTraits::renderGraphFromBottomUp()) {
       O << DOT::EscapeString(DOTTraits::getNodeLabel(Node, G));
 
+      // If we should include the address of the node in the label, do so now.
+      if (DOTTraits::hasNodeAddressLabel(Node, G))
+        O << "|" << (void*)Node;
+    }
+
     // Print out the fields of the current node...
     child_iterator EI = GTraits::child_begin(Node);
     child_iterator EE = GTraits::child_end(Node);
@@ -131,9 +136,15 @@ public:
       O << "}";
       if (DOTTraits::renderGraphFromBottomUp()) O << "|";
     }
-    if (DOTTraits::renderGraphFromBottomUp())
+
+    if (DOTTraits::renderGraphFromBottomUp()) {
       O << DOT::EscapeString(DOTTraits::getNodeLabel(Node, G));
 
+      // If we should include the address of the node in the label, do so now.
+      if (DOTTraits::hasNodeAddressLabel(Node, G))
+        O << "|" << (void*)Node;
+    }
+
     O << "}\"];\n";   // Finish printing the "node" line
 
     // Output all of the edges now

llvm/include/llvm/Support/InstVisitor.h

@@ -174,7 +174,6 @@ public:
   RetTy visitSelectInst(SelectInst &I)              { DELEGATE(Instruction); }
   RetTy visitCallInst(CallInst     &I)              { DELEGATE(Instruction); }
   RetTy visitShiftInst(ShiftInst   &I)              { DELEGATE(Instruction); }
-  RetTy visitVANextInst(VANextInst &I)              { DELEGATE(Instruction); }
   RetTy visitVAArgInst(VAArgInst   &I)              { DELEGATE(Instruction); }
 
   // Next level propagators... if the user does not overload a specific

llvm/include/llvm/Support/Mangler.h

@@ -64,7 +64,8 @@ public:
   /// does this for you, so there's no point calling it on the result
   /// from getValueName.
   ///
-  static std::string makeNameProper(const std::string &x);
+  static std::string makeNameProper(const std::string &x,
+                                    const char *Prefix = "");
 };
 
 } // End llvm namespace

llvm/include/llvm/Support/MathExtras.h

@@ -18,32 +18,231 @@
 
 namespace llvm {
 
-#if defined(log2)
-# undef log2
+// NOTE: The following support functions use the _32/_64 extensions instead of  
+// type overloading so that signed and unsigned integers can be used without
+// ambiguity.
+
+
+// Hi_32 - This function returns the high 32 bits of a 64 bit value.
+inline unsigned Hi_32(uint64_t Value) {
+  return (unsigned)(Value >> 32);
+}
+
+// Lo_32 - This function returns the low 32 bits of a 64 bit value.
+inline unsigned Lo_32(uint64_t Value) {
+  return (unsigned)Value;
+}
+
+// is?Type - these functions produce optimal testing for integer data types.
+inline bool isInt8  (int Value)     { return (  signed char )Value == Value; }
+inline bool isUInt8 (int Value)     { return (unsigned char )Value == Value; }
+inline bool isInt16 (int Value)     { return (  signed short)Value == Value; }
+inline bool isUInt16(int Value)     { return (unsigned short)Value == Value; }
+inline bool isInt32 (int64_t Value) { return (  signed int  )Value == Value; }
+inline bool isUInt32(int64_t Value) { return (unsigned int  )Value == Value; }
+
+// isMask_32 - This function returns true if the argument is a sequence of ones  
+// starting at the least significant bit with the remainder zero (32 bit version.)
+// Ex. isMask_32(0x0000FFFFU) == true.
+inline const bool isMask_32(unsigned Value) {
+  return Value && ((Value + 1) & Value) == 0;
+}
+
+// isMask_64 - This function returns true if the argument is a sequence of ones  
+// starting at the least significant bit with the remainder zero (64 bit version.)
+inline const bool isMask_64(uint64_t Value) {
+  return Value && ((Value + 1) & Value) == 0;
+}
+
+// isShiftedMask_32 - This function returns true if the argument contains a  
+// sequence of ones with the remainder zero (32 bit version.)
+// Ex. isShiftedMask_32(0x0000FF00U) == true.
+inline const bool isShiftedMask_32(unsigned Value) {
+  return isMask_32((Value - 1) | Value);
+}
+
+// isShiftedMask_64 - This function returns true if the argument contains a  
+// sequence of ones with the remainder zero (64 bit version.)
+inline const bool isShiftedMask_64(uint64_t Value) {
+  return isMask_64((Value - 1) | Value);
+}
+
+// isPowerOf2_32 - This function returns true if the argument is a power of 
+// two > 0. Ex. isPowerOf2_32(0x00100000U) == true (32 bit edition.)
+inline bool isPowerOf2_32(unsigned Value) {
+  return Value && !(Value & (Value - 1));
+}
+
+// isPowerOf2_64 - This function returns true if the argument is a power of two
+// > 0 (64 bit edition.)
+inline bool isPowerOf2_64(uint64_t Value) {
+  return Value && !(Value & (Value - 1LL));
+}
+
+// CountLeadingZeros_32 - this function performs the platform optimal form of
+// counting the number of zeros from the most significant bit to the first one
+// bit.  Ex. CountLeadingZeros_32(0x00F000FF) == 8.
+// Returns 32 if the word is zero.
+inline unsigned CountLeadingZeros_32(unsigned Value) {
+  unsigned Count; // result
+#if __GNUC__ >= 4
+  // PowerPC is defined for __builtin_clz(0)
+#if !defined(__ppc__) && !defined(__ppc64__)
+  if (!Value) return 32;
 #endif
-
-inline unsigned log2(uint64_t C) {
-  unsigned getPow;
-  for (getPow = 0; C > 1; ++getPow)
-    C >>= 1;
-  return getPow;
-}
-
-inline unsigned log2(unsigned C) {
-  unsigned getPow;
-  for (getPow = 0; C > 1; ++getPow)
-    C >>= 1;
-  return getPow;
-}
-
-inline bool isPowerOf2(int64_t C, unsigned &getPow) {
-  if (C < 0) C = -C;
-  if (C > 0 && C == (C & ~(C - 1))) {
-    getPow = log2(static_cast<uint64_t>(C));
-    return true;
+  Count = __builtin_clz(Value);
+#else
+  if (!Value) return 32;
+  Count = 0;
+  // bisecton method for count leading zeros
+  for (unsigned Shift = 32 >> 1; Shift; Shift >>= 1) {
+    unsigned Tmp = Value >> Shift;
+    if (Tmp) {
+      Value = Tmp;
+    } else {
+      Count |= Shift;
+    }
   }
+#endif
+  return Count;
+}
 
-  return false;
+// CountLeadingZeros_64 - This function performs the platform optimal form
+// of counting the number of zeros from the most significant bit to the first 
+// one bit (64 bit edition.)
+// Returns 64 if the word is zero.
+inline unsigned CountLeadingZeros_64(uint64_t Value) {
+  unsigned Count; // result
+#if __GNUC__ >= 4
+  // PowerPC is defined for __builtin_clzll(0)
+#if !defined(__ppc__) && !defined(__ppc64__)
+  if (!Value) return 64;
+#endif
+  Count = __builtin_clzll(Value);
+#else
+  if (sizeof(long) == sizeof(int64_t)) {
+    if (!Value) return 64;
+    Count = 0;
+    // bisecton method for count leading zeros
+    for (uint64_t Shift = 64 >> 1; Shift; Shift >>= 1) {
+      uint64_t Tmp = Value >> Shift;
+      if (Tmp) {
+        Value = Tmp;
+      } else {
+        Count |= Shift;
+      }
+    }
+  } else {
+    // get hi portion
+    unsigned Hi = Hi_32(Value);
+
+    // if some bits in hi portion
+    if (Hi) {
+        // leading zeros in hi portion plus all bits in lo portion
+        Count = CountLeadingZeros_32(Hi);
+    } else {
+        // get lo portion
+        unsigned Lo = Lo_32(Value);
+        // same as 32 bit value
+        Count = CountLeadingZeros_32(Lo)+32;
+    }
+  }
+#endif
+  return Count;
+}
+
+// CountTrailingZeros_32 - this function performs the platform optimal form of
+// counting the number of zeros from the least significant bit to the first one
+// bit.  Ex. CountTrailingZeros_32(0xFF00FF00) == 8.
+// Returns 32 if the word is zero.
+inline unsigned CountTrailingZeros_32(unsigned Value) {
+  return 32 - CountLeadingZeros_32(~Value & (Value - 1));
+}
+
+// CountTrailingZeros_64 - This function performs the platform optimal form
+// of counting the number of zeros from the least significant bit to the first 
+// one bit (64 bit edition.)
+// Returns 64 if the word is zero.
+inline unsigned CountTrailingZeros_64(uint64_t Value) {
+  return 64 - CountLeadingZeros_64(~Value & (Value - 1));
+}
+
+// CountPopulation_32 - this function counts the number of set bits in a value.
+// Ex. CountPopulation(0xF000F000) = 8
+// Returns 0 if the word is zero.
+inline unsigned CountPopulation_32(unsigned Value) {
+  unsigned x, t;
+  x = Value - ((Value >> 1) & 0x55555555);
+  t = ((x >> 2) & 0x33333333);
+  x = (x & 0x33333333) + t;
+  x = (x + (x >> 4)) & 0x0F0F0F0F;
+  x = x + (x << 8);
+  x = x + (x << 16);
+  return x >> 24;
+}
+
+// CountPopulation_64 - this function counts the number of set bits in a value,
+// (64 bit edition.)
+inline unsigned CountPopulation_64(uint64_t Value) {
+  return CountPopulation_32(unsigned(Value >> 32)) +
+         CountPopulation_32(unsigned(Value));
+}
+
+// Log2_32 - This function returns the floor log base 2 of the specified value, 
+// -1 if the value is zero. (32 bit edition.)
+// Ex. Log2_32(32) == 5, Log2_32(1) == 0, Log2_32(0) == -1
+inline unsigned Log2_32(unsigned Value) {
+    return 31 - CountLeadingZeros_32(Value);
+}
+
+// Log2_64 - This function returns the floor log base 2 of the specified value, 
+// -1 if the value is zero. (64 bit edition.)
+inline unsigned Log2_64(uint64_t Value) {
+    return 63 - CountLeadingZeros_64(Value);
+}
+
+// BitsToDouble - This function takes a 64-bit integer and returns the bit
+// equivalent double.
+inline double BitsToDouble(uint64_t Bits) {
+  union {
+    uint64_t L;
+    double D;
+  } T;
+  T.L = Bits;
+  return T.D;
+}
+
+// BitsToFloat - This function takes a 32-bit integer and returns the bit
+// equivalent float.
+inline float BitsToFloat(uint32_t Bits) {
+  union {
+    uint32_t I;
+    float F;
+  } T;
+  T.I = Bits;
+  return T.F;
+}
+
+// DoubleToBits - This function takes a double and returns the bit
+// equivalent 64-bit integer.
+inline uint64_t DoubleToBits(double Double) {
+  union {
+    uint64_t L;
+    double D;
+  } T;
+  T.D = Double;
+  return T.L;
+}
+
+// FloatToBits - This function takes a float and returns the bit
+// equivalent 32-bit integer.
+inline uint32_t FloatToBits(float Float) {
+  union {
+    uint32_t I;
+    float F;
+  } T;
+  T.F = Float;
+  return T.I;
 }
 
 // Platform-independent wrappers for the C99 isnan() function.

llvm/include/llvm/Support/MutexGuard.h

@@ -0,0 +1,41 @@
+//===-- Support/MutexGuard.h - Acquire/Release Mutex In Scope ---*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines a guard for a block of code that ensures a Mutex is locked
+// upon construction and released upon destruction.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_MUTEXGUARD_H
+#define LLVM_SUPPORT_MUTEXGUARD_H
+
+#include <llvm/System/Mutex.h>
+
+namespace llvm {
+  /// Instances of this class acquire a given Mutex Lock when constructed and
+  /// hold that lock until destruction. The intention is to instantiate one of
+  /// these on the stack at the top of some scope to be assured that C++
+  /// destruction of the object will always release the Mutex and thus avoid
+  /// a host of nasty multi-threading problems in the face of exceptions, etc.
+  /// @brief Guard a section of code with a Mutex.
+  class MutexGuard {
+    sys::Mutex &M;
+    MutexGuard(const MutexGuard &);    // DO NOT IMPLEMENT
+    void operator=(const MutexGuard &); // DO NOT IMPLEMENT
+  public:
+    MutexGuard(sys::Mutex &m) : M(m) { M.acquire(); }
+    ~MutexGuard() { M.release(); }
+    /// holds - Returns true if this locker instance holds the specified lock.
+    /// This is mostly used in assertions to validate that the correct mutex
+    /// is held.
+    bool holds(const sys::Mutex& lock) const { return &M == &lock; }
+  };
+}
+
+#endif // LLVM_SUPPORT_MUTEXGUARD_H

llvm/include/llvm/Support/PatternMatch.h

@@ -71,7 +71,8 @@ inline bind_ty<ConstantInt> m_ConstantInt(ConstantInt *&CI) { return CI; }
 // Matchers for specific binary operators
 //
 
-template<typename LHS_t, typename RHS_t, unsigned Opcode>
+template<typename LHS_t, typename RHS_t, 
+         unsigned Opcode, typename ConcreteTy = BinaryOperator>
 struct BinaryOp_match {
   LHS_t L;
   RHS_t R;
@@ -80,9 +81,11 @@ struct BinaryOp_match {
 
   template<typename OpTy>
   bool match(OpTy *V) {
-    if (Instruction *I = dyn_cast<Instruction>(V))
+    if (V->getValueType() == Value::InstructionVal + Opcode) {
+      ConcreteTy *I = cast<ConcreteTy>(V);
       return I->getOpcode() == Opcode && L.match(I->getOperand(0)) &&
              R.match(I->getOperand(1));
+    }
     if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
       return CE->getOpcode() == Opcode && L.match(CE->getOperand(0)) &&
              R.match(CE->getOperand(1));
@@ -139,15 +142,15 @@ inline BinaryOp_match<LHS, RHS, Instruction::Xor> m_Xor(const LHS &L,
 }
 
 template<typename LHS, typename RHS>
-inline BinaryOp_match<LHS, RHS, Instruction::Shl> m_Shl(const LHS &L,
-                                                        const RHS &R) {
-  return BinaryOp_match<LHS, RHS, Instruction::Shl>(L, R);
+inline BinaryOp_match<LHS, RHS, Instruction::Shl, 
+                      ShiftInst> m_Shl(const LHS &L, const RHS &R) {
+  return BinaryOp_match<LHS, RHS, Instruction::Shl, ShiftInst>(L, R);
 }
 
 template<typename LHS, typename RHS>
-inline BinaryOp_match<LHS, RHS, Instruction::Shr> m_Shr(const LHS &L,
-                                                        const RHS &R) {
-  return BinaryOp_match<LHS, RHS, Instruction::Shr>(L, R);
+inline BinaryOp_match<LHS, RHS, Instruction::Shr, 
+                      ShiftInst> m_Shr(const LHS &L, const RHS &R) {
+  return BinaryOp_match<LHS, RHS, Instruction::Shr, ShiftInst>(L, R);
 }
 
 //===----------------------------------------------------------------------===//

llvm/include/llvm/Support/ThreadSupport-NoSupport.h

@@ -1,34 +0,0 @@
-//===-- llvm/Support/ThreadSupport-NoSupport.h - Generic Impl ---*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines a generic ThreadSupport implementation used when there is
-// no supported threading mechanism on the current system.  Users should never
-// #include this file directly!
-//
-//===----------------------------------------------------------------------===//
-
-// Users should never #include this file directly!  As such, no include guards
-// are needed.
-
-#ifndef LLVM_SUPPORT_THREADSUPPORT_H
-#error "Code should not #include Support/ThreadSupport-NoSupport.h directly!"
-#endif
-
-namespace llvm {
-  /// Mutex - This class allows user code to protect variables shared between
-  /// threads.  It implements a "recursive" mutex, to simplify user code.
-  ///
-  /// Since there is no platform support for _creating threads_, the non-thread
-  /// implementation of this class is a noop.
-  ///
-  struct Mutex {
-    void acquire () {}
-    void release () {}
-  };
-}

llvm/include/llvm/Support/ThreadSupport-PThreads.h

@@ -1,65 +0,0 @@
-//===-- llvm/Support/ThreadSupport-PThreads.h - PThreads support *- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines pthreads implementations of the generic threading
-// mechanisms.  Users should never #include this file directly!
-//
-//===----------------------------------------------------------------------===//
-
-// Users should never #include this file directly!  As such, no include guards
-// are needed.
-
-#ifndef LLVM_SUPPORT_THREADSUPPORT_H
-#error "Code should not #include Support/ThreadSupport/PThreads.h directly!"
-#endif
-
-#include <pthread.h>
-
-namespace llvm {
-
-  /// Mutex - This class allows user code to protect variables shared between
-  /// threads.  It implements a "recursive" mutex, to simplify user code.
-  ///
-  class Mutex {
-    pthread_mutex_t mutex;
-    Mutex(const Mutex &);           // DO NOT IMPLEMENT
-    void operator=(const Mutex &);  // DO NOT IMPLEMENT
-  public:
-    Mutex() {
-      // Initialize the mutex as a recursive mutex
-      pthread_mutexattr_t Attr;
-      int errorcode = pthread_mutexattr_init(&Attr);
-      assert(errorcode == 0);
-
-      errorcode = pthread_mutexattr_settype(&Attr, PTHREAD_MUTEX_RECURSIVE);
-      assert(errorcode == 0);
-
-      errorcode = pthread_mutex_init(&mutex, &Attr);
-      assert(errorcode == 0);
-
-      errorcode = pthread_mutexattr_destroy(&Attr);
-      assert(errorcode == 0);
-    }
-
-    ~Mutex() {
-      int errorcode = pthread_mutex_destroy(&mutex);
-      assert(errorcode == 0);
-    }
-
-    void acquire () {
-      int errorcode = pthread_mutex_lock(&mutex);
-      assert(errorcode == 0);
-    }
-
-    void release () {
-      int errorcode = pthread_mutex_unlock(&mutex);
-      assert(errorcode == 0);
-    }
-  };
-} // end namespace llvm

llvm/include/llvm/Support/ThreadSupport.h.in

@@ -1,42 +0,0 @@
-//===-- Support/ThreadSupport.h - Generic threading support -----*- C++ -*-===//
-// 
-//                     The LLVM Compiler Infrastructure
-//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
-//===----------------------------------------------------------------------===//
-//
-// This file defines platform-agnostic interfaces that can be used to write
-// multi-threaded programs.  Autoconf is used to chose the correct
-// implementation of these interfaces, or default to a non-thread-capable system
-// if no matching system support is available.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_THREADSUPPORT_H
-#define LLVM_SUPPORT_THREADSUPPORT_H
-
-#undef HAVE_PTHREAD_MUTEX_LOCK
-
-#ifdef HAVE_PTHREAD_MUTEX_LOCK
-#include "llvm/Support/ThreadSupport-PThreads.h"
-#else
-#include "llvm/Support/ThreadSupport-NoSupport.h"
-#endif // If no system support is available
-
-namespace llvm {
-  /// MutexLocker - Instances of this class acquire a given Lock when
-  /// constructed and hold that lock until destruction.
-  ///
-  class MutexLocker {
-    Mutex &M;
-    MutexLocker(const MutexLocker &);    // DO NOT IMPLEMENT
-    void operator=(const MutexLocker &); // DO NOT IMPLEMENT
-  public:
-    MutexLocker(Mutex &m) : M(m) { M.acquire(); }
-    ~MutexLocker() { M.release(); }
-  };
-}
-
-#endif // SUPPORT_THREADSUPPORT_H

llvm/include/llvm/System/Memory.h

@@ -43,9 +43,11 @@ namespace sys {
       /// This method allocates a block of Read/Write/Execute memory that is
       /// suitable for executing dynamically generated code (e.g. JIT). An
       /// attempt to allocate \p NumBytes bytes of virtual memory is made.
+      /// \p NearBlock may point to an existing allocation in which case
+      /// an attempt is made to allocate more memory near the existing block.
       /// @throws std::string if an error occurred.
       /// @brief Allocate Read/Write/Execute memory.
-      static MemoryBlock AllocateRWX(unsigned NumBytes);
+      static MemoryBlock AllocateRWX(unsigned NumBytes, const MemoryBlock* NearBlock);
 
       /// This method releases a block of Read/Write/Execute memory that was
       /// allocated with the AllocateRWX method. It should not be used to

llvm/include/llvm/System/Mutex.h

@@ -0,0 +1,84 @@
+//===- llvm/System/Mutex.h - Mutex Operating System Concept -----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by Reid Spencer and is distributed under the
+// University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the llvm::sys::Mutex class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SYSTEM_MUTEX_H
+#define LLVM_SYSTEM_MUTEX_H
+
+namespace llvm
+{
+  namespace sys
+  {
+    /// @brief Platform agnostic Mutex class.
+    class Mutex
+    {
+    /// @name Constructors
+    /// @{
+    public:
+
+      /// Initializes the lock but doesn't acquire it. if \p recursive is set
+      /// to false, the lock will not be recursive which makes it cheaper but
+      /// also more likely to deadlock (same thread can't acquire more than
+      /// once).
+      /// @brief Default Constructor.
+      Mutex ( bool recursive = true );
+
+      /// Releases and removes the lock
+      /// @brief Destructor
+      ~Mutex ( void );
+
+    /// @}
+    /// @name Methods
+    /// @{
+    public:
+
+      /// Attempts to unconditionally acquire the lock. If the lock is held by
+      /// another thread, this method will wait until it can acquire the lock.
+      /// @returns false if any kind of error occurs, true otherwise.
+      /// @brief Unconditionally acquire the lock.
+      bool acquire();
+
+      /// Attempts to release the lock. If the lock is held by the current
+      /// thread, the lock is released allowing other threads to acquire the
+      /// lock.
+      /// @returns false if any kind of error occurs, true otherwise.
+      /// @brief Unconditionally release the lock.
+      bool release(void);
+
+      /// Attempts to acquire the lock without blocking. If the lock is not
+      /// available, this function returns false quickly (without blocking). If
+      /// the lock is available, it is acquired.
+      /// @returns false if any kind of error occurs or the lock is not
+      /// available, true otherwise.
+      /// @brief Try to acquire the lock.
+      bool tryacquire();
+
+    //@}
+    /// @name Platform Dependent Data
+    /// @{
+    private:
+#ifdef ENABLE_THREADS
+      void* data_; ///< We don't know what the data will be
+#endif
+
+    /// @}
+    /// @name Do Not Implement
+    /// @{
+    private:
+      Mutex(const Mutex & original);
+      void operator=(const Mutex &);
+    /// @}
+    };
+  }
+}
+
+#endif

llvm/include/llvm/System/Path.h

@@ -27,21 +27,28 @@ namespace sys {
   /// in the operating system's filesystem and provides various basic operations
   /// on it.  Note that this class only represents the name of a path to a file
   /// or directory which may or may not be valid for a given machine's file
-  /// system. A Path ensures that the name it encapsulates is syntactical valid
-  /// for the operating system it is running on but does not ensure correctness
-  /// for any particular file system. A Path either references a file or a
-  /// directory and the distinction is consistently maintained. Most operations
-  /// on the class have invariants that require the Path object to be either a
-  /// file path or a directory path, but not both. Those operations will also
-  /// leave the object as either a file path or object path. There is exactly
-  /// one invalid Path which is the empty path. The class should never allow any
-  /// other syntactically invalid non-empty path name to be assigned. Empty
-  /// paths are required in order to indicate an error result. If the path is
-  /// empty, the isValid operation will return false. All operations will fail
-  /// if isValid is false. Operations that change the path will either return
-  /// false if it would cause a syntactically invalid path name (in which case
-  /// the Path object is left unchanged) or throw an std::string exception
-  /// indicating the error.
+  /// system. The class is patterned after the java.io.File class with various
+  /// extensions and several omissions (not relevant to LLVM).  A Path object
+  /// ensures that the path it encapsulates is syntactically valid for the
+  /// operating system it is running on but does not ensure correctness for
+  /// any particular file system. That is, a syntactically valid path might
+  /// specify path components that do not exist in the file system and using
+  /// such a Path to act on the file system could produce errors. There is one
+  /// invalid Path value which is permitted: the empty path.  The class should
+  /// never allow a syntactically invalid non-empty path name to be assigned.
+  /// Empty paths are required in order to indicate an error result in some
+  /// situations. If the path is empty, the isValid operation will return
+  /// false. All operations will fail if isValid is false. Operations that
+  /// change the path will either return false if it would cause a syntactically
+  /// invalid path name (in which case the Path object is left unchanged) or
+  /// throw an std::string exception indicating the error. The methods are
+  /// grouped into four basic categories: Path Accessors (provide information
+  /// about the path without accessing disk), Disk Accessors (provide
+  /// information about the underlying file or directory), Path Mutators
+  /// (change the path information, not the disk), and Disk Mutators (change
+  /// the disk file/directory referenced by the path). The Disk Mutator methods
+  /// all have the word "disk" embedded in their method name to reinforce the
+  /// notion that the operation modifies the file system.
   /// @since 1.4
   /// @brief An abstraction for operating system paths.
   class Path {
@@ -76,8 +83,8 @@ namespace sys {
       /// directory is a top level directory above which there are no more
       /// directories. For example, on UNIX, the root directory is /. On Windows
       /// it is C:\. Other operating systems may have different notions of
-      /// what the root directory is.
-      /// @throws nothing
+      /// what the root directory is or none at all. In that case, a consistent
+      /// default root directory will be used.
       static Path GetRootDirectory();
 
       /// Construct a path to a unique temporary directory that is created in
@@ -93,8 +100,7 @@ namespace sys {
       /// library paths suitable for linking into programs. This function *must*
       /// return the value of LLVM_LIB_SEARCH_PATH as the first item in \p Paths
       /// if that environment variable is set and it references a directory.
-      /// @throws nothing
-      /// @brief Construct a path to the first system library directory
+      /// @brief Construct a path to the system library directory
       static void GetSystemLibraryPaths(std::vector<sys::Path>& Paths);
 
       /// Construct a vector of sys::Path that contains the "standard" bytecode
@@ -116,7 +122,6 @@ namespace sys {
       /// implementation must ensure that this is a well-known (same on many
       /// systems) directory in which llvm configuration files exist. For
       /// example, on Unix, the /etc/llvm directory has been selected.
-      /// @throws nothing
       /// @brief Construct a path to the default LLVM configuration directory
       static Path GetLLVMDefaultConfigDir();
 
@@ -124,7 +129,6 @@ namespace sys {
       /// implementation must ensure that this refers to the "etc" directory of
       /// the LLVM installation. This is the location where configuration files
       /// will be located for a particular installation of LLVM on a machine.
-      /// @throws nothing
       /// @brief Construct a path to the LLVM installed configuration directory
       static Path GetLLVMConfigDir();
 
@@ -134,7 +138,6 @@ namespace sys {
       /// variable "HOME" could be used on Unix. If a given operating system
       /// does not have the concept of a user's home directory, this static
       /// constructor must provide the same result as GetRootDirectory.
-      /// @throws nothing
       /// @brief Construct a path to the current user's "home" directory
       static Path GetUserHomeDirectory();
 
@@ -151,16 +154,15 @@ namespace sys {
       /// empty one. Other invalid names are not permitted. Empty paths are
       /// provided so that they can be used to indicate null or error results in
       /// other lib/System functionality.
-      /// @throws nothing
       /// @brief Construct an empty (and invalid) path.
       Path() : path() {}
 
-      /// This constructor will accept a std::string as a path but if verifies
+      /// This constructor will accept a std::string as a path but it verifies
       /// that the path string has a legal syntax for the operating system on
       /// which it is running. This allows a path to be taken in from outside
       /// the program. However, if the path is not valid, the Path object will
       /// be set to an empty string and an exception will be thrown.
-      /// @throws std::string if the path string is not legal.
+      /// @throws std::string if \p unverified_path is not legal.
       /// @param unverified_path The path to verify and assign.
       /// @brief Construct a Path from a string.
       explicit Path(const std::string& unverified_path);
@@ -171,7 +173,6 @@ namespace sys {
     public:
       /// Makes a copy of \p that to \p this.
       /// @returns \p this
-      /// @throws nothing
       /// @brief Assignment Operator
       Path & operator = ( const Path & that ) {
         path = that.path;
@@ -180,7 +181,6 @@ namespace sys {
 
       /// Compares \p this Path with \p that Path for equality.
       /// @returns true if \p this and \p that refer to the same thing.
-      /// @throws nothing
       /// @brief Equality Operator
       bool operator == (const Path& that) const {
         return 0 == path.compare(that.path) ;
@@ -188,7 +188,6 @@ namespace sys {
 
       /// Compares \p this Path with \p that Path for inequality.
       /// @returns true if \p this and \p that refer to different things.
-      /// @throws nothing
       /// @brief Inequality Operator
       bool operator !=( const Path & that ) const {
         return 0 != path.compare( that.path );
@@ -199,14 +198,13 @@ namespace sys {
       /// std::map). The comparison is done lexicographically as defined by
       /// the std::string::compare method.
       /// @returns true if \p this path is lexicographically less than \p that.
-      /// @throws nothing
       /// @brief Less Than Operator
       bool operator< (const Path& that) const {
         return 0 > path.compare( that.path );
       }
 
     /// @}
-    /// @name Accessors
+    /// @name Path Accessors
     /// @{
     public:
       /// This function will use an operating system specific algorithm to
@@ -219,28 +217,64 @@ namespace sys {
       bool isValid() const;
 
       /// This function determines if the contents of the path name are
-      /// empty. That is, the path has a zero length.
+      /// empty. That is, the path has a zero length. This does NOT determine if
+      /// if the file is empty. Use the getSize method for that.
       /// @returns true iff the path is empty.
       /// @brief Determines if the path name is empty (invalid).
       bool isEmpty() const { return path.empty(); }
 
-      /// This function determines if the path name in this object is intended
-      /// to reference a legal file name (as opposed to a directory name). This
-      /// function does not verify anything with the file system, it merely
-      /// determines if the syntax of the path represents a file name or not.
+      /// This function returns the current contents of the path as a
+      /// std::string. This allows the underlying path string to be manipulated.
+      /// @returns std::string containing the path name.
+      /// @brief Returns the path as a std::string.
+      const std::string& toString() const { return path; }
+
+      /// This function returns the last component of the path name. The last
+      /// component is the file or directory name occuring after the last
+      /// directory separator. If no directory separator is present, the entire
+      /// path name is returned (i.e. same as toString).
+      /// @returns std::string containing the last component of the path name.
+      /// @brief Returns the last component of the path name.
+      std::string getLast() const;
+
+      /// This function strips off the path and suffix of the file or directory
+      /// name and returns just the basename. For example /a/foo.bar would cause
+      /// this function to return "foo".
+      /// @returns std::string containing the basename of the path
+      /// @brief Get the base name of the path
+      std::string getBasename() const;
+
+      /// Obtain a 'C' string for the path name.
+      /// @returns a 'C' string containing the path name.
+      /// @brief Returns the path as a C string.
+      const char* const c_str() const { return path.c_str(); }
+
+    /// @}
+    /// @name Disk Accessors
+    /// @{
+    public:
+      /// This function determines if the object referenced by this path is
+      /// a file or not. This function accesses the underlying file system to
+      /// determine the type of entity referenced by the path.
       /// @returns true if this path name references a file.
       /// @brief Determines if the path name references a file.
       bool isFile() const;
 
-      /// This function determines if the path name in this object is intended
-      /// to reference a legal directory name (as opposed to a file name). This
-      /// function does not verify anything with the file system, it merely
-      /// determines if the syntax of the path represents a directory name or
-      /// not.
+      /// This function determines if the object referenced by this path is a
+      /// directory or not. This function accesses the underlying file system to
+      /// determine the type of entity referenced by the path.
       /// @returns true if the path name references a directory
       /// @brief Determines if the path name references a directory.
       bool isDirectory() const;
 
+      /// This function determines if the path refers to a hidden file. The
+      /// notion of hidden files is defined by  the underlying system. The
+      /// system may not support hidden files in which case this function always
+      /// returns false on such systems. Hidden files have the "hidden"
+      /// attribute set on Win32. On Unix, hidden files start with a period.
+      /// @brief Determines if the path name references a hidden file.
+      bool isHidden() const;
+
       /// This function determines if the path name in this object references
       /// the root (top level directory) of the file system. The details of what
       /// is considered the "root" may vary from system to system so this method
@@ -289,62 +323,38 @@ namespace sys {
       bool isDynamicLibrary() const;
 
       /// This function determines if the path name references an existing file
-      /// or directory in the file system. Unlike isFile and isDirectory, this
-      /// function actually checks for the existence of the file or directory.
-      /// @returns true if the pathname references an existing file.
+      /// or directory in the file system.
+      /// @returns true if the pathname references an existing file or
+      /// directory.
       /// @brief Determines if the path is a file or directory in
       /// the file system.
       bool exists() const;
 
       /// This function determines if the path name references a readable file
-      /// or directory in the file system. Unlike isFile and isDirectory, this
-      /// function actually checks for the existence and readability (by the
-      /// current program) of the file or directory.
+      /// or directory in the file system. This function checks for
+      /// the existence and readability (by the current program) of the file
+      /// or directory.
       /// @returns true if the pathname references a readable file.
       /// @brief Determines if the path is a readable file or directory
       /// in the file system.
-      bool readable() const;
+      bool canRead() const;
 
       /// This function determines if the path name references a writable file
-      /// or directory in the file system. Unlike isFile and isDirectory, this
-      /// function actually checks for the existence and writability (by the
-      /// current program) of the file or directory.
+      /// or directory in the file system. This function checks for the
+      /// existence and writability (by the current program) of the file or
+      /// directory.
       /// @returns true if the pathname references a writable file.
       /// @brief Determines if the path is a writable file or directory
       /// in the file system.
-      bool writable() const;
+      bool canWrite() const;
 
       /// This function determines if the path name references an executable
-      /// file in the file system. Unlike isFile and isDirectory, this
-      /// function actually checks for the existence and executability (by
-      /// the current program) of the file.
+      /// file in the file system. This function checks for the existence and
+      /// executability (by the current program) of the file.
       /// @returns true if the pathname references an executable file.
       /// @brief Determines if the path is an executable file in the file
       /// system.
-      bool executable() const;
-
-      /// This function returns the current contents of the path as a
-      /// std::string. This allows the underlying path string to be manipulated
-      /// by other software.
-      /// @returns std::string containing the path name.
-      /// @brief Returns the path as a std::string.
-      const std::string& toString() const { return path; }
-
-      /// This function returns the last component of the path name. If the
-      /// isDirectory() function would return true then this returns the name
-      /// of the last directory in the path. If the isFile() function would
-      /// return true then this function returns the name of the file without
-      /// any of the preceding directories.
-      /// @returns std::string containing the last component of the path name.
-      /// @brief Returns the last component of the path name.
-      std::string getLast() const;
-
-      /// This function strips off the path and suffix of the file name and
-      /// returns just the basename.
-      /// @returns std::string containing the basename of the path
-      /// @throws nothing
-      /// @brief Get the base name of the path
-      std::string getBasename() const;
+      bool canExecute() const;
 
       /// This function builds a list of paths that are the names of the
       /// files and directories in a directory.
@@ -353,46 +363,10 @@ namespace sys {
       /// @brief Build a list of directory's contents.
       bool getDirectoryContents(std::set<Path>& paths) const;
 
-      /// This method attempts to destroy the directory named by the last in
-      /// the Path name.  If \p remove_contents is false, an attempt will be
-      /// made to remove just the directory that this Path object refers to
-      /// (the final Path component). If \p remove_contents is true, an attempt
-      /// will be made to remove the entire contents of the directory,
-      /// recursively.
-      /// @param destroy_contents Indicates whether the contents of a destroyed
-      /// directory should also be destroyed (recursively).
-      /// @returns false if the Path does not refer to a directory, true
-      /// otherwise.
-      /// @throws std::string if there is an error.
-      /// @brief Removes the file or directory from the filesystem.
-      bool destroyDirectory( bool destroy_contents = false ) const;
-
-      /// This method attempts to destroy the file named by the last item in the
-      /// Path name.
-      /// @returns false if the Path does not refer to a file, true otherwise.
-      /// @throws std::string if there is an error.
-      /// @brief Destroy the file this Path refers to.
-      bool destroyFile() const;
-
-      /// Obtain a 'C' string for the path name.
-      /// @returns a 'C' string containing the path name.
-      /// @brief Returns the path as a C string.
-      const char* const c_str() const { return path.c_str(); }
-
-    /// @}
-    /// @name Mutators
-    /// @{
-    public:
-      /// The path name is cleared and becomes empty. This is an invalid
-      /// path name but is the *only* invalid path name. This is provided
-      /// so that path objects can be used to indicate the lack of a
-      /// valid path being found.
-      void clear() { path.clear(); }
-
       /// This function returns status information about the file. The type of
       /// path (file or directory) is updated to reflect the actual contents
       /// of the file system. If the file does not exist, false is returned.
-      /// For other (hard I/O) errors, a std::string is throwing indicating the
+      /// For other (hard I/O) errors, a std::string is thrown indicating the
       /// problem.
       /// @throws std::string if an error occurs.
       /// @brief Get file status.
@@ -413,80 +387,40 @@ namespace sys {
         StatusInfo info; getStatusInfo(info); return info.fileSize;
       }
 
-      /// This method attempts to make the file referenced by the Path object
-      /// available for reading so that the readable() method will return true.
-      /// @brief Make the file readable;
-      void makeReadable();
+    /// @}
+    /// @name Path Mutators
+    /// @{
+    public:
+      /// The path name is cleared and becomes empty. This is an invalid
+      /// path name but is the *only* invalid path name. This is provided
+      /// so that path objects can be used to indicate the lack of a
+      /// valid path being found.
+      /// @brief Make the path empty.
+      void clear() { path.clear(); }
 
-      /// This method attempts to make the file referenced by the Path object
-      /// available for writing so that the writable() method will return true.
-      /// @brief Make the file writable;
-      void makeWriteable();
-
-      /// This method attempts to make the file referenced by the Path object
-      /// available for execution so that the executable() method will return
-      /// true.
-      /// @brief Make the file readable;
-      void makeExecutable();
-
-      /// This method attempts to set the Path object to \p unverified_path
-      /// and interpret the name as a directory name.  The \p unverified_path
-      /// is verified. If verification succeeds then \p unverified_path
-      /// is accepted as a directory and true is returned. Otherwise,
-      /// the Path object remains unchanged and false is returned.
+      /// This method sets the Path object to \p unverified_path. This can fail
+      /// if the \p unverified_path does not pass the syntactic checks of the
+      /// isValid() method. If verification fails, the Path object remains
+      /// unchanged and false is returned. Otherwise true is returned and the
+      /// Path object takes on the path value of \p unverified_path
       /// @returns true if the path was set, false otherwise.
       /// @param unverified_path The path to be set in Path object.
-      /// @throws nothing
       /// @brief Set a full path from a std::string
-      bool setDirectory(const std::string& unverified_path);
+      bool set(const std::string& unverified_path);
 
-      /// This method attempts to set the Path object to \p unverified_path
-      /// and interpret the name as a file name.  The \p unverified_path
-      /// is verified. If verification succeeds then \p unverified_path
-      /// is accepted as a file name and true is returned. Otherwise,
-      /// the Path object remains unchanged and false is returned.
-      /// @returns true if the path was set, false otherwise.
-      /// @param unverified_path The path to be set in Path object.
-      /// @throws nothing
-      /// @brief Set a full path from a std::string
-      bool setFile(const std::string& unverified_path);
-
-      /// The \p dirname is added to the end of the Path if it is a legal
-      /// directory name for the operating system. The precondition for this
-      /// function is that the Path must reference a directory name (i.e.
-      /// isDirectory() returns true).
-      /// @param dirname A string providing the directory name to
-      /// be added to the end of the path.
-      /// @returns false if the directory name could not be added
-      /// @throws nothing
-      /// @brief Adds the name of a directory to a Path.
-      bool appendDirectory( const std::string& dirname );
-
-      /// One directory component is removed from the Path name. The Path must
-      /// refer to a non-root directory name (i.e. isDirectory() returns true
-      /// but isRootDirectory() returns false). Upon exit, the Path will
-      /// refer to the directory above it.
-      /// @throws nothing
-      /// @returns false if the directory name could not be removed.
+      /// One path component is removed from the Path. If only one component is
+      /// present in the path, the Path object becomes empty. If the Path object
+      /// is empty, no change is made.
+      /// @returns false if the path component could not be removed.
       /// @brief Removes the last directory component of the Path.
-      bool elideDirectory();
+      bool eraseComponent();
 
-      /// The \p filename is added to the end of the Path if it is a legal
-      /// directory name for the operating system. The precondition for this
-      /// function is that the Path reference a directory name (i.e.
-      /// isDirectory() returns true).
-      /// @throws nothing
-      /// @returns false if the file name could not be added.
-      /// @brief Appends the name of a file.
-      bool appendFile( const std::string& filename );
-
-      /// One file component is removed from the Path name. The Path must
-      /// refer to a file (i.e. isFile() returns true). Upon exit,
-      /// the Path will refer to the directory above it.
-      /// @throws nothing
-      /// @returns false if the file name could not be removed
-      /// @brief Removes the last file component of the path.
-      bool elideFile();
+      /// The \p component is added to the end of the Path if it is a legal
+      /// name for the operating system. A directory separator will be added if
+      /// needed.
+      /// @returns false if the path component could not be added.
+      /// @brief Appends one path component to the Path.
+      bool appendComponent( const std::string& component );
 
       /// A period and the \p suffix are appended to the end of the pathname.
       /// The precondition for this function is that the Path reference a file
@@ -494,20 +428,18 @@ namespace sys {
       /// action is taken and the function returns false. If the path would
       /// become invalid for the host operating system, false is returned.
       /// @returns false if the suffix could not be added, true if it was.
-      /// @throws nothing
       /// @brief Adds a period and the \p suffix to the end of the pathname.
       bool appendSuffix(const std::string& suffix);
 
-      /// The suffix of the filename is removed. The suffix begins with and
+      /// The suffix of the filename is erased. The suffix begins with and
       /// includes the last . character in the filename after the last directory
       /// separator and extends until the end of the name. If no . character is
       /// after the last directory separator, then the file name is left
       /// unchanged (i.e. it was already without a suffix) but the function
       /// returns false.
       /// @returns false if there was no suffix to remove, true otherwise.
-      /// @throws nothing
       /// @brief Remove the suffix from a path name.
-      bool elideSuffix();
+      bool eraseSuffix();
 
       /// The current Path name is made unique in the file system. Upon return,
       /// the Path will have been changed to make a unique file in the file
@@ -517,30 +449,57 @@ namespace sys {
       /// @brief Make the current path name unique in the file system.
       void makeUnique( bool reuse_current = true );
 
+    /// @}
+    /// @name Disk Mutators
+    /// @{
+    public:
+      /// This method attempts to make the file referenced by the Path object
+      /// available for reading so that the canRead() method will return true.
+      /// @brief Make the file readable;
+      void makeReadableOnDisk();
+
+      /// This method attempts to make the file referenced by the Path object
+      /// available for writing so that the canWrite() method will return true.
+      /// @brief Make the file writable;
+      void makeWriteableOnDisk();
+
+      /// This method attempts to make the file referenced by the Path object
+      /// available for execution so that the canExecute() method will return
+      /// true.
+      /// @brief Make the file readable;
+      void makeExecutableOnDisk();
+
+      /// This method allows the last modified time stamp and permission bits
+      /// to be set on the disk object referenced by the Path.
+      /// @throws std::string if an error occurs.
+      /// @returns true
+      /// @brief Set the status information.
+      bool setStatusInfoOnDisk(const StatusInfo& si) const;
+
       /// This method attempts to create a directory in the file system with the
       /// same name as the Path object. The \p create_parents parameter controls
       /// whether intermediate directories are created or not. if \p
       /// create_parents is true, then an attempt will be made to create all
-      /// intermediate directories. If \p create_parents is false, then only the
-      /// final directory component of the Path name will be created. The
-      /// created directory will have no entries.
+      /// intermediate directories, as needed. If \p create_parents is false,
+      /// then only the final directory component of the Path name will be
+      /// created. The created directory will have no entries.
       /// @returns false if the Path does not reference a directory, true
       /// otherwise.
       /// @param create_parents Determines whether non-existent directory
       /// components other than the last one (the "parents") are created or not.
       /// @throws std::string if an error occurs.
       /// @brief Create the directory this Path refers to.
-      bool createDirectory( bool create_parents = false );
+      bool createDirectoryOnDisk( bool create_parents = false );
 
       /// This method attempts to create a file in the file system with the same
       /// name as the Path object. The intermediate directories must all exist
-      /// at the time this method is called. Use createDirectories to
+      /// at the time this method is called. Use createDirectoriesOnDisk to
       /// accomplish that. The created file will be empty upon return from this
       /// function.
       /// @returns false if the Path does not reference a file, true otherwise.
       /// @throws std::string if an error occurs.
       /// @brief Create the file this Path refers to.
-      bool createFile();
+      bool createFileOnDisk();
 
       /// This is like createFile except that it creates a temporary file. A
       /// unique temporary file name is generated based on the contents of
@@ -548,24 +507,37 @@ namespace sys {
       /// file is created.  Note that this will both change the Path object
       /// *and* create the corresponding file. This function will ensure that
       /// the newly generated temporary file name is unique in the file system.
-      /// @throws std::string if there is an error
+      /// @param reuse_current When set to true, this parameter indicates that
+      /// if the current file name does not exist then it will be used without
+      /// modification.
+      /// @returns true if successful, false if the file couldn't be created.
+      /// @throws std::string if there is a hard error creating the temp file
+      /// name.
       /// @brief Create a unique temporary file
-      bool createTemporaryFile(bool reuse_current = false);
+      bool createTemporaryFileOnDisk(bool reuse_current = false);
 
-
-      /// This method renames the file referenced by \p this as \p newName. Both
-      /// files must exist before making this call.
-      /// @returns false if the Path does not refer to a file, true otherwise.
+      /// This method renames the file referenced by \p this as \p newName. The
+      /// file referenced by \p this must exist. The file referenced by
+      /// \p newName does not need to exist.
+      /// @returns true
       /// @throws std::string if there is an file system error.
       /// @brief Rename one file as another.
-      bool renameFile(const Path& newName);
+      bool renamePathOnDisk(const Path& newName);
 
-      /// This method sets the access time, modification time, and permission
-      /// mode of the file associated with \p this as given by \p si.
-      /// @returns false if the Path does not refer to a file, true otherwise.
-      /// @throws std::string if the file could not be modified
-      /// @brief Set file times and mode.
-      bool setStatusInfo(const StatusInfo& si ) const ;
+      /// This method attempts to destroy the file or directory named by the
+      /// last component of the Path. If the Path refers to a directory and the
+      /// \p destroy_contents is false, an attempt will be made to remove just
+      /// the directory (the final Path component). If \p destroy_contents is
+      /// true, an attempt will be made to remove the entire contents of the
+      /// directory, recursively. If the Path refers to a file, the
+      /// \p destroy_contents parameter is ignored.
+      /// @param destroy_contents Indicates whether the contents of a destroyed
+      /// directory should also be destroyed (recursively).
+      /// @returns true if the file/directory was destroyed, false if the path
+      /// refers to something that is neither a file nor a directory.
+      /// @throws std::string if there is an error.
+      /// @brief Removes the file or directory from the filesystem.
+      bool eraseFromDisk( bool destroy_contents = false ) const;
 
     /// @}
     /// @name Data
@@ -602,5 +574,4 @@ inline std::ostream& operator<<(std::ostream& strm, const sys::Path& aPath) {
 
 }
 
-
 #endif

llvm/include/llvm/System/Process.h

@@ -67,7 +67,7 @@ namespace sys {
       /// Not all operating systems support this feature. Where it is not
       /// supported, the function should return 65536 as the value.
       static int GetCurrentUserId();
-      
+
       /// This static function will return the process' current group id number.
       /// Not all operating systems support this feature. Where it is not
       /// supported, the function should return 65536 as the value.

llvm/include/llvm/System/Signals.h

@@ -36,6 +36,16 @@ namespace sys {
   /// @brief Print a stack trace if a fatal signal occurs.
   void PrintStackTraceOnErrorSignal();
 
+  /// This function registers a function to be called when the user "interrupts"
+  /// the program (typically by pressing ctrl-c).  When the user interrupts the
+  /// program, the specified interrupt function is called instead of the program
+  /// being killed, and the interrupt function automatically disabled.  Note
+  /// that interrupt functions are not allowed to call any non-reentrant
+  /// functions.  An null interrupt function pointer disables the current
+  /// installed function.  Note also that the handler may be executed on a
+  /// different thread on some platforms.
+  /// @brief Register a function to be called when ctrl-c is pressed.
+  void SetInterruptFunction(void (*IF)());
 } // End sys namespace
 } // End llvm namespace
 

llvm/include/llvm/Target/MRegisterInfo.h

@@ -17,6 +17,7 @@
 #define LLVM_TARGET_MREGISTERINFO_H
 
 #include "llvm/CodeGen/MachineBasicBlock.h"
+#include "llvm/CodeGen/ValueTypes.h"
 #include <cassert>
 #include <functional>
 
@@ -25,18 +26,17 @@ namespace llvm {
 class Type;
 class MachineFunction;
 class MachineInstr;
+class TargetRegisterClass;
 
-/// MRegisterDesc - This record contains all of the information known about a
-/// particular register.  The AliasSet field (if not null) contains a pointer to
-/// a Zero terminated array of registers that this register aliases.  This is
+/// TargetRegisterDesc - This record contains all of the information known about
+/// a particular register.  The AliasSet field (if not null) contains a pointer
+/// to a Zero terminated array of registers that this register aliases.  This is
 /// needed for architectures like X86 which have AL alias AX alias EAX.
 /// Registers that this does not apply to simply should set this to null.
 ///
-struct MRegisterDesc {
+struct TargetRegisterDesc {
   const char     *Name;         // Assembly language name for the register
   const unsigned *AliasSet;     // Register Alias Set, described above
-  unsigned char SpillSize;      // Size of this register in bytes
-  unsigned char SpillAlignment; // Alignment of stack slot for this reg
 };
 
 class TargetRegisterClass {
@@ -45,13 +45,18 @@ public:
   typedef const unsigned* const_iterator;
 
 private:
+  const MVT::ValueType VT;
   const unsigned RegSize, Alignment;    // Size & Alignment of register in bytes
   const iterator RegsBegin, RegsEnd;
 public:
-  TargetRegisterClass(unsigned RS, unsigned Al, iterator RB, iterator RE)
-    : RegSize(RS), Alignment(Al), RegsBegin(RB), RegsEnd(RE) {}
+  TargetRegisterClass(MVT::ValueType vt, unsigned RS, unsigned Al, iterator RB, iterator RE)
+    : VT(vt), RegSize(RS), Alignment(Al), RegsBegin(RB), RegsEnd(RE) {}
   virtual ~TargetRegisterClass() {}     // Allow subclasses
 
+  /// getType - Return the declared value type for this register class.
+  ///
+  MVT::ValueType getType() const { return VT; }
+  
   // begin/end - Return all of the registers in this class.
   iterator       begin() const { return RegsBegin; }
   iterator         end() const { return RegsEnd; }
@@ -106,22 +111,22 @@ public:
 
 
 /// MRegisterInfo base class - We assume that the target defines a static array
-/// of MRegisterDesc objects that represent all of the machine registers that
-/// the target has.  As such, we simply have to track a pointer to this array so
-/// that we can turn register number into a register descriptor.
+/// of TargetRegisterDesc objects that represent all of the machine registers
+/// that the target has.  As such, we simply have to track a pointer to this
+/// array so that we can turn register number into a register descriptor.
 ///
 class MRegisterInfo {
 public:
   typedef const TargetRegisterClass * const * regclass_iterator;
 private:
-  const MRegisterDesc *Desc;                  // Pointer to the descriptor array
+  const TargetRegisterDesc *Desc;             // Pointer to the descriptor array
   unsigned NumRegs;                           // Number of entries in the array
 
   regclass_iterator RegClassBegin, RegClassEnd;   // List of regclasses
 
   int CallFrameSetupOpcode, CallFrameDestroyOpcode;
 protected:
-  MRegisterInfo(const MRegisterDesc *D, unsigned NR,
+  MRegisterInfo(const TargetRegisterDesc *D, unsigned NR,
                 regclass_iterator RegClassBegin, regclass_iterator RegClassEnd,
                 int CallFrameSetupOpcode = -1, int CallFrameDestroyOpcode = -1);
   virtual ~MRegisterInfo();
@@ -163,7 +168,7 @@ public:
   /// indicating if a register is allocatable or not.
   std::vector<bool> getAllocatableSet(MachineFunction &MF) const;
 
-  const MRegisterDesc &operator[](unsigned RegNo) const {
+  const TargetRegisterDesc &operator[](unsigned RegNo) const {
     assert(RegNo < NumRegs &&
            "Attempting to access record for invalid register number!");
     return Desc[RegNo];
@@ -172,7 +177,9 @@ public:
   /// Provide a get method, equivalent to [], but more useful if we have a
   /// pointer to this object.
   ///
-  const MRegisterDesc &get(unsigned RegNo) const { return operator[](RegNo); }
+  const TargetRegisterDesc &get(unsigned RegNo) const {
+    return operator[](RegNo);
+  }
 
   /// getAliasSet - Return the set of registers aliased by the specified
   /// register, or a null list of there are none.  The list returned is zero
@@ -188,18 +195,6 @@ public:
     return get(RegNo).Name;
   }
 
-  /// getSpillSize - Return the size in bits required of a stack slot used to
-  /// spill register into.
-  unsigned getSpillSize(unsigned RegNo) const {
-    return get(RegNo).SpillSize;
-  }
-
-  /// getSpillAlignment - Return the alignment required by a stack slot used to
-  /// spill register into.
-  unsigned getSpillAlignment(unsigned RegNo) const {
-    return get(RegNo).SpillAlignment;
-  }
-
   /// getNumRegs - Return the number of registers this target has
   /// (useful for sizing arrays holding per register information)
   unsigned getNumRegs() const {
@@ -214,8 +209,14 @@ public:
     return false;
   }
 
+  /// getCalleeSaveRegs - Return a null-terminated list of all of the
+  /// callee-save registers on this target.
   virtual const unsigned* getCalleeSaveRegs() const = 0;
 
+  /// getCalleeSaveRegClasses - Return a null-terminated list of the preferred
+  /// register classes to spill each callee-saved register with.  The order and
+  /// length of this list match the getCalleeSaveRegs() list.
+  virtual const TargetRegisterClass* const *getCalleeSaveRegClasses() const = 0;
 
   //===--------------------------------------------------------------------===//
   // Register Class Information
@@ -239,17 +240,27 @@ public:
 
   virtual void storeRegToStackSlot(MachineBasicBlock &MBB,
                                    MachineBasicBlock::iterator MI,
-                                   unsigned SrcReg, int FrameIndex) const = 0;
+                                   unsigned SrcReg, int FrameIndex,
+                                   const TargetRegisterClass *RC) const = 0;
 
   virtual void loadRegFromStackSlot(MachineBasicBlock &MBB,
                                     MachineBasicBlock::iterator MI,
-                                    unsigned DestReg, int FrameIndex) const = 0;
+                                    unsigned DestReg, int FrameIndex,
+                                    const TargetRegisterClass *RC) const = 0;
 
   virtual void copyRegToReg(MachineBasicBlock &MBB,
                             MachineBasicBlock::iterator MI,
                             unsigned DestReg, unsigned SrcReg,
                             const TargetRegisterClass *RC) const = 0;
 
+  /// isLoadFromStackSlot - If the specified machine instruction is a direct
+  /// load from a stack slot, return the virtual or physical register number of
+  /// the destination along with the FrameIndex of the loaded stack slot.  If
+  /// not, return 0.  This predicate must return false if the instruction has
+  /// any side effects other than loading from the stack slot.
+  virtual unsigned isLoadFromStackSlot(MachineInstr *MI, int &FrameIndex) const{
+    return 0;
+  }
 
   /// foldMemoryOperand - Attempt to fold a load or store of the
   /// specified stack slot into the specified machine instruction for

llvm/include/llvm/Target/SubtargetFeature.h

@@ -0,0 +1,108 @@
+//===-- llvm/Target/SubtargetFeature.h - CPU characteristics ----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by Jim Laskey and is distributed under the 
+// University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines and manages user or tool specified CPU characteristics.
+// The intent is to be able to package specific features that should or should
+// not be used on a specific target processor.  A tool, such as llc, could, as
+// as example, gather chip info from the command line, a long with features
+// that should be used on that chip.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TARGET_SUBTARGETFEATURE_H
+#define LLVM_TARGET_SUBTARGETFEATURE_H
+
+#include <string>
+#include <vector>
+#include <iosfwd>
+#include "llvm/Support/DataTypes.h"
+
+namespace llvm {
+
+//===----------------------------------------------------------------------===//
+///
+/// SubtargetFeatureKV - Used to provide key value pairs for feature and
+/// CPU bit flags.
+//
+struct SubtargetFeatureKV {
+  const char *Key;                      // K-V key string
+  const char *Desc;                     // Help descriptor
+  uint32_t Value;                       // K-V integer value
+  
+  // Compare routine for std binary search
+  bool operator<(const std::string &S) const {
+    return strcmp(Key, S.c_str()) < 0;
+  }
+};
+  
+//===----------------------------------------------------------------------===//
+///
+/// SubtargetInfoKV - Used to provide key value pairs for CPU and arbitrary
+/// pointers.
+//
+struct SubtargetInfoKV {
+  const char *Key;                      // K-V key string
+  void *Value;                          // K-V pointer value
+  
+  // Compare routine for std binary search
+  bool operator<(const std::string &S) const {
+    return strcmp(Key, S.c_str()) < 0;
+  }
+};
+  
+//===----------------------------------------------------------------------===//
+///
+/// SubtargetFeatures - Manages the enabling and disabling of subtarget 
+/// specific features.  Features are encoded as a string of the form
+///   "cpu,+attr1,+attr2,-attr3,...,+attrN"
+/// A comma separates each feature from the next (all lowercase.)
+/// The first feature is always the CPU subtype (eg. pentiumm).  If the CPU
+/// value is "generic" then the CPU subtype should be generic for the target.
+/// Each of the remaining features is prefixed with + or - indicating whether
+/// that feature should be enabled or disabled contrary to the cpu
+/// specification.
+///
+
+class SubtargetFeatures {
+  std::vector<std::string> Features;    // Subtarget features as a vector
+public:
+  SubtargetFeatures(const std::string &Initial = std::string());
+
+  /// Features string accessors.
+  std::string getString() const;
+  void setString(const std::string &Initial);
+
+  /// Set the CPU string.  Replaces previous setting.  Setting to "" clears CPU.
+  void setCPU(const std::string &String);
+  
+  /// Setting CPU string only if no string is set.
+  void setCPUIfNone(const std::string &String);
+  
+  /// Adding Features.
+  void AddFeature(const std::string &String, bool IsEnabled = true);
+           
+  /// Get feature bits.
+  uint32_t getBits(const SubtargetFeatureKV *CPUTable,
+                         size_t CPUTableSize,
+                   const SubtargetFeatureKV *FeatureTable,
+                         size_t FeatureTableSize);
+                         
+  /// Get info pointer
+  void *getInfo(const SubtargetInfoKV *Table, size_t TableSize);
+  
+  /// Print feature string.
+  void print(std::ostream &OS) const;
+  
+  // Dump feature info.
+  void dump() const;
+};
+
+} // End namespace llvm
+
+#endif