Target

// class Register is defined in Target.td
-class TargetReg : Register {
+class TargetReg<string name> : Register<name> {
   let Namespace = "Target";
 }
 
-class IntReg<bits<5> num> : TargetReg {
+class IntReg<bits<5> num, string name> : TargetReg<name> {
   field bits<5> Num = num;
 }
 
-def R0 : IntReg<0>;
+def R0 : IntReg<0, "%R0">;
 ...
 
 // class RegisterClass is defined in Target.td
@@ -238,7 +238,7 @@
   Misha Brukman

   The LLVM Compiler Infrastructure
   

-  Last modified: $Date: 2004/09/06 22:58:13 $
+  Last modified: $Date: 2004/09/18 06:28:07 $
 
 
 





From lattner at cs.uiuc.edu  Sat Sep 18 01:39:48 2004
From: lattner at cs.uiuc.edu (Chris Lattner)
Date: Sat, 18 Sep 2004 01:39:48 -0500
Subject: [llvm-commits] CVS: llvm/docs/WritingAnLLVMPass.html 
Message-ID: <200409180639.BAA31204@apoc.cs.uiuc.edu>



Changes in directory llvm/docs:

WritingAnLLVMPass.html updated: 1.30 -> 1.31
---
Log message:

Provide initial docs for CallGraphSCCPass's, and fix several grammar-o's and
other problems.


---
Diffs of the changes:  (+131 -16)

Index: llvm/docs/WritingAnLLVMPass.html
diff -u llvm/docs/WritingAnLLVMPass.html:1.30 llvm/docs/WritingAnLLVMPass.html:1.31

--- llvm/docs/WritingAnLLVMPass.html:1.30	Wed Jun 30 13:10:30 2004
+++ llvm/docs/WritingAnLLVMPass.html	Sat Sep 18 01:39:35 2004
@@ -18,7 +18,7 @@
     Setting up the build environment
     Basic code required
     Running a pass with opt
-         or analyze
+                 or analyze
     
   Pass classes and requirements
      
@@ -27,6 +27,14 @@
         
         The run method
         
+     The CallGraphSCCPass class
+        
+        The doInitialization(Module
+                                           &) method
+        The runOnSCC method
+        The doFinalization(Module
+                                           &) method
+        
      The FunctionPass class
         
         The doInitialization(Module
@@ -100,23 +108,22 @@
 
 
 The LLVM Pass Framework is an important part of the LLVM system, because LLVM
-passes are where the interesting parts of the compiler exist.  Passes perform
-the transformations and optimizations that make up the compiler, they build
-the analysis results that are used by these transformations, and they are, above
-all, a structuring technique for compiler code.
+passes are where most of the interesting parts of the compiler exist.  Passes
+perform the transformations and optimizations that make up the compiler, they
+build the analysis results that are used by these transformations, and they are,
+above all, a structuring technique for compiler code.
 
 All LLVM passes are subclasses of the Pass
 class, which implement functionality by overriding virtual methods inherited
 from Pass.  Depending on how your pass works, you may be able to
-inherit from the FunctionPass
-or BasicBlockPass,
-which gives the system more information about what your pass does, and how it
-can be combined with other passes.  One of the main features of the LLVM Pass
-Framework is that it schedules passes to run in an efficient way based on the
-constraints that your pass has.
+inherit from the CallGraphSCCPass,
+FunctionPass, or BasicBlockPass classes, which gives the system
+more information about what your pass does, and how it can be combined with
+other passes.  One of the main features of the LLVM Pass Framework is that it
+schedules passes to run in an efficient way based on the constraints that your
+pass meets (which are indicated by which class they derive from).
 
 We start by showing you how to construct a pass, everything from setting up
 the code, to compiling, loading, and executing it.  After the basics are down,
@@ -134,7 +141,7 @@
 
 
Here we describe how to write the "hello world" of passes.  The "Hello" pass
 is designed to simply print out the name of non-external functions that exist in
-the program being compiled.  It does not modify the program at all, just
+the program being compiled.  It does not modify the program at all, it just
 inspects it.  The source code and files for this pass are available in the LLVM
 source tree in the lib/Transforms/Hello directory.
 
@@ -175,7 +182,7 @@
 directory are to be compiled and linked together into a
 lib/Debug/libhello.so shared object that can be dynamically loaded by
 the opt or analyze tools.  If your operating system uses a
-suffix other than .so (such as windows of Mac OS/X), the appropriate extension
+suffix other than .so (such as windows or Mac OS/X), the appropriate extension
 will be used.
 
 Now that we have the build scripts set up, we just need to write the code for
@@ -466,6 +473,114 @@
 
 
 

+  The CallGraphSCCPass class
+
+
+
+
+The "CallGraphSCCPass"
+is used by passes that need to traverse the program bottom-up on the call graph
+(callees before callers).  Deriving from CallGraphSCCPass provides some
+mechanics for building and traversing the CallGraph, but also allows the system
+to optimize execution of CallGraphSCCPass's.  If your pass meets the
+requirements outlined below, and doesn't meet the requirements of a FunctionPass or BasicBlockPass, you should derive from
+CallGraphSCCPass.
+
+TODO: explain briefly what SCC, Tarjan's algo, and B-U mean.
+
+To be explicit, CallGraphSCCPass subclasses are:
+
+
+
+... not allowed to modify any Functions that are not in
+the current SCC.
+
+... allowed to inspect any Function's other than those in the
+current SCC and the direct callees of the SCC.
+
+... required to preserve the current CallGraph object, updating it
+to reflect any changes made to the program.
+
+... not allowed to add or remove SCC's from the current Module,
+though they may change the contents of an SCC.
+
+... allowed to add or remove global variables from the current
+Module.
+
+... allowed to maintain state across invocations of
+    runOnSCC (including global data).
+
+
+Implementing a CallGraphSCCPass is slightly tricky in some cases
+because it has to handle SCCs with more than one node in it.  All of the virtual
+methods described below should return true if they modified the program, or
+false if they didn't.
+
+
+
+
+
+  The doInitialization(Module &)
+  method
+
+
+
+
++  virtual bool doInitialization(Module &M);
+
+
+The doIninitialize method is allowed to do most of the things that
+CallGraphSCCPass's are not allowed to do.  They can add and remove
+functions, get pointers to functions, etc.  The doInitialization method
+is designed to do simple initialization type of stuff that does not depend on
+the SCCs being processed.  The doInitialization method call is not
+scheduled to overlap with any other pass executions (thus it should be very
+fast).
+
+
+
+
+
+  The runOnSCC method
+
+
+
+
++  virtual bool runOnSCC(const std::vector<CallGraphNode *> &SCCM) = 0;
+
+
+The runOnSCC method performs the interesting work of the pass, and
+should return true if the module was modified by the transformation, false
+otherwise.
+
+
+
+
+
+  The doFinalization(Module
+   &) method
+
+
+
+
++  virtual bool doFinalization(Module &M);
+
+
+The doFinalization method is an infrequently used method that is
+called when the pass framework has finished calling runOnFunction for every function in the
+program being compiled.
+
+
+
+
+
   The FunctionPass class
 
 
@@ -1481,7 +1596,7 @@
 
   Chris Lattner

   The LLVM Compiler Infrastructure

-  Last modified: $Date: 2004/06/30 18:10:30 $
+  Last modified: $Date: 2004/09/18 06:39:35 $
 
 
 





From lattner at cs.uiuc.edu  Sat Sep 18 11:16:42 2004
From: lattner at cs.uiuc.edu (Chris Lattner)
Date: Sat, 18 Sep 2004 11:16:42 -0500
Subject: [llvm-commits] CVS: llvm/docs/WritingAnLLVMPass.html 
Message-ID: <200409181616.LAA32427@apoc.cs.uiuc.edu>



Changes in directory llvm/docs:

WritingAnLLVMPass.html updated: 1.31 -> 1.32
---
Log message:

Misha implemented the ModuleProvider interface back in 9/18/2003.


---
Diffs of the changes:  (+1 -29)

Index: llvm/docs/WritingAnLLVMPass.html
diff -u llvm/docs/WritingAnLLVMPass.html:1.31 llvm/docs/WritingAnLLVMPass.html:1.32
--- llvm/docs/WritingAnLLVMPass.html:1.31	Sat Sep 18 01:39:35 2004
+++ llvm/docs/WritingAnLLVMPass.html	Sat Sep 18 11:16:28 2004
@@ -89,7 +89,6 @@
   
Future extensions planned
     
     Multithreaded LLVM
-    A new ModuleSource interface
     Passes requiring 
                                     FunctionPasses
     

@@ -1539,33 +1538,6 @@
 
 
 
-  A new ModuleSource interface
-
-
-
-
-Currently, the PassManager's run method takes a Module
-as input, and runs all of the passes on this module.  The problem with this
-approach is that none of the PassManager features can be used for
-timing and debugging the actual loading of the module from disk or
-standard input.
-
-To solve this problem, eventually the PassManager class will accept
-a ModuleSource object instead of a Module itself.  When complete, this
-will also allow for streaming of functions out of the bytecode representation,
-allowing us to avoid holding the entire program in memory at once if we only are
-dealing with FunctionPasses.
-
-As part of a different issue, eventually the bytecode loader will be extended
-to allow on-demand loading of functions from the bytecode representation, in
-order to better support the runtime reoptimizer.  The bytecode format is already
-capable of this, the loader just needs to be reworked a bit.
-
-
-
-
-
 Passes requiring FunctionPasses
 
 
@@ -1596,7 +1568,7 @@
 
   Chris Lattner

   The LLVM Compiler Infrastructure

-  Last modified: $Date: 2004/09/18 06:39:35 $
+  Last modified: $Date: 2004/09/18 16:16:28 $
 
 
 





From reid at x10sys.com  Sat Sep 18 14:25:22 2004
From: reid at x10sys.com (Reid Spencer)
Date: Sat, 18 Sep 2004 14:25:22 -0500
Subject: [llvm-commits] CVS: llvm/lib/System/Unix/Path.cpp 
Message-ID: <200409181925.OAA22184@zion.cs.uiuc.edu>



Changes in directory llvm/lib/System/Unix:

Path.cpp updated: 1.7 -> 1.8
---
Log message:

Get rid of file descriptor leak in create_file.


---
Diffs of the changes:  (+3 -1)

Index: llvm/lib/System/Unix/Path.cpp
diff -u llvm/lib/System/Unix/Path.cpp:1.7 llvm/lib/System/Unix/Path.cpp:1.8
--- llvm/lib/System/Unix/Path.cpp:1.7	Thu Sep 16 11:36:10 2004
+++ llvm/lib/System/Unix/Path.cpp	Sat Sep 18 14:25:11 2004
@@ -377,8 +377,10 @@
   if (!is_file()) return false; 
 
   // Create the file
-  if (0 != creat(path.c_str(), S_IRUSR | S_IWUSR))
+  int fd = ::creat(path.c_str(), S_IRUSR | S_IWUSR);
+  if (fd < 0)
     ThrowErrno(std::string(path.c_str()) + ": Can't create file");
+  ::close(fd);
 
   return true;
 }





From reid at x10sys.com  Sat Sep 18 14:29:26 2004
From: reid at x10sys.com (Reid Spencer)
Date: Sat, 18 Sep 2004 14:29:26 -0500
Subject: [llvm-commits] CVS: llvm/lib/System/Win32/Path.cpp 
Message-ID: <200409181929.OAA22222@zion.cs.uiuc.edu>



Changes in directory llvm/lib/System/Win32:

Path.cpp updated: 1.2 -> 1.3
---
Log message:

Porting of Unix implementation to Win32.

Patch contributed by Jeff Cohen. Thanks Jeff!


---
Diffs of the changes:  (+190 -48)

Index: llvm/lib/System/Win32/Path.cpp
diff -u llvm/lib/System/Win32/Path.cpp:1.2 llvm/lib/System/Win32/Path.cpp:1.3
--- llvm/lib/System/Win32/Path.cpp:1.2	Wed Sep 15 00:49:50 2004
+++ llvm/lib/System/Win32/Path.cpp	Sat Sep 18 14:29:16 2004
@@ -6,6 +6,7 @@
 // University of Illinois Open Source License. See LICENSE.TXT for details.
 //
 // Modified by Henrik Bach to comply with at least MinGW.
+// Ported to Win32 by Jeff Cohen.
 //
 //===----------------------------------------------------------------------===//
 //
@@ -18,18 +19,10 @@
 //===          is guaranteed to work on *all* Win32 variants.
 //===----------------------------------------------------------------------===//
 
-#include 
-#include 
-#include 
-#include 
-#include 
-#include 
+#include "Win32.h"
 #include 
-
-#include 
-#include 
-
-#define MAXPATHLEN PATH_MAX
+#include 
+#include 
 
 namespace llvm {
 namespace sys {
@@ -38,23 +31,47 @@
 Path::is_valid() const {
   if (path.empty())
     return false;
-/*hb:  char pathname[MAXPATHLEN];
-  if (0 == realpath(path.c_str(), pathname))
-    if (errno != EACCES && errno != EIO && errno != ENOENT && errno != 
-ENOTDIR)
-      return false;*/
-  return true;
+
+  // On Unix, the realpath function is used, which only requires that the
+  // directories leading up the to final file name are valid.  The file itself
+  // need not exist.  To get this behavior on Windows, we must elide the file
+  // name manually.
+  Path dir(*this);
+  dir.elide_file();
+  if (dir.path.empty())
+    return true;
+
+  DWORD attr = GetFileAttributes(dir.path.c_str());
+  return (attr != INVALID_FILE_ATTRIBUTES) && (attr & FILE_ATTRIBUTE_DIRECTORY);
 }
 
+static Path *TempDirectory = NULL;
+
 Path
 Path::GetTemporaryDirectory() {
-  char pathname[MAXPATHLEN];
-  if (0 == GetTempPath(MAXPATHLEN,pathname))
-    ThrowError(std::string(pathname) + ": Can't create temporary directory");
+  if (TempDirectory)
+    return *TempDirectory;
+
+  char pathname[MAX_PATH];
+  if (!GetTempPath(MAX_PATH, pathname))
+    ThrowError("Can't determine temporary directory");
+
   Path result;
   result.set_directory(pathname);
-  assert(result.is_valid() && "GetTempPath didn't create a valid pathname!");
-  return result;
+
+  // Append a subdirectory passed on our process id so multiple LLVMs don't
+  // step on each other's toes.
+  sprintf(pathname, "LLVM_%u", GetCurrentProcessId());
+  result.append_directory(pathname);
+
+  // If there's a directory left over from a previous LLVM execution that
+  // happened to have the same process id, get rid of it.
+  result.destroy_directory(true);
+
+  // And finally (re-)create the empty directory.
+  result.create_directory(false);
+  TempDirectory = new Path(result);
+  return *TempDirectory;
 }
 
 Path::Path(std::string unverified_path)
@@ -69,6 +86,7 @@
   ThrowError(unverified_path + ": path is not valid");
 }
 
+// FIXME: the following set of functions don't map to Windows very well.
 Path
 Path::GetRootDirectory() {
   Path result;
@@ -76,6 +94,59 @@
   return result;
 }
 
+static inline bool IsLibrary(Path& path, const std::string& basename) {
+  if (path.append_file(std::string("lib") + basename)) {
+    if (path.append_suffix(Path::GetDLLSuffix()) && path.readable())
+      return true;
+    else if (path.elide_suffix() && path.append_suffix("a") && path.readable())
+      return true;
+    else if (path.elide_suffix() && path.append_suffix("o") && path.readable())
+      return true;
+    else if (path.elide_suffix() && path.append_suffix("bc") && path.readable())
+      return true;
+  } else if (path.elide_file() && path.append_file(basename)) {
+    if (path.append_suffix(Path::GetDLLSuffix()) && path.readable())
+      return true;
+    else if (path.elide_suffix() && path.append_suffix("a") && path.readable())
+      return true;
+    else if (path.elide_suffix() && path.append_suffix("o") && path.readable())
+      return true;
+    else if (path.elide_suffix() && path.append_suffix("bc") && path.readable())
+      return true;
+  }
+  path.clear();
+  return false;
+}
+
+Path 
+Path::GetLibraryPath(const std::string& basename, 
+                     const std::vector& LibPaths) {
+  Path result;
+
+  // Try the paths provided
+  for (std::vector::const_iterator I = LibPaths.begin(),
+       E = LibPaths.end(); I != E; ++I ) {
+    if (result.set_directory(*I) && IsLibrary(result,basename))
+      return result;
+  }
+
+  // Try the LLVM lib directory in the LLVM install area
+  //if (result.set_directory(LLVM_LIBDIR) && IsLibrary(result,basename))
+  //  return result;
+
+  // Try /usr/lib
+  if (result.set_directory("/usr/lib/") && IsLibrary(result,basename))
+    return result;
+
+  // Try /lib
+  if (result.set_directory("/lib/") && IsLibrary(result,basename))
+    return result;
+
+  // Can't find it, give up and return invalid path.
+  result.clear();
+  return result;
+}
+
 Path
 Path::GetSystemLibraryPath1() {
   return Path("/lib/");
@@ -93,9 +164,6 @@
 
 Path
 Path::GetLLVMConfigDir() {
-  Path result;
-  if (result.set_directory(LLVM_ETCDIR))
-    return result;
   return GetLLVMDefaultConfigDir();
 }
 
@@ -109,25 +177,80 @@
   }
   return GetRootDirectory();
 }
+// FIXME: the above set of functions don't map to Windows very well.
+
+bool
+Path::is_file() const {
+  return (is_valid() && path[path.length()-1] != '/');
+}
+
+bool
+Path::is_directory() const {
+  return (is_valid() && path[path.length()-1] == '/');
+}
+
+std::string
+Path::get_basename() const {
+  // Find the last slash
+  size_t slash = path.rfind('/');
+  if (slash == std::string::npos)
+    slash = 0;
+  else
+    slash++;
+
+  return path.substr(slash, path.rfind('.'));
+}
+
+bool Path::has_magic_number(const std::string &Magic) const {
+  size_t len = Magic.size();
+  char *buf = reinterpret_cast(_alloca(len+1));
+  std::ifstream f(path.c_str());
+  f.read(buf, len);
+  buf[len] = '\0';
+  return Magic == buf;
+}
+
+bool 
+Path::is_bytecode_file() const {
+  if (readable()) {
+    return has_magic_number("llvm");
+  }
+  return false;
+}
+
+bool
+Path::is_archive() const {
+  if (readable()) {
+    return has_magic_number("!\012");
+  }
+  return false;
+}
 
 bool
 Path::exists() const {
-  return 0 == access(path.c_str(), F_OK );
+  DWORD attr = GetFileAttributes(path.c_str());
+  return attr != INVALID_FILE_ATTRIBUTES;
 }
 
 bool
 Path::readable() const {
-  return 0 == access(path.c_str(), F_OK | R_OK );
+  // FIXME: take security attributes into account.
+  DWORD attr = GetFileAttributes(path.c_str());
+  return attr != INVALID_FILE_ATTRIBUTES;
 }
 
 bool
 Path::writable() const {
-  return 0 == access(path.c_str(), F_OK | W_OK );
+  // FIXME: take security attributes into account.
+  DWORD attr = GetFileAttributes(path.c_str());
+  return (attr != INVALID_FILE_ATTRIBUTES) && !(attr & FILE_ATTRIBUTE_READONLY);
 }
 
 bool
 Path::executable() const {
-  return 0 == access(path.c_str(), R_OK | X_OK );
+  // FIXME: take security attributes into account.
+  DWORD attr = GetFileAttributes(path.c_str());
+  return attr != INVALID_FILE_ATTRIBUTES;
 }
 
 std::string
@@ -272,8 +395,8 @@
   if (!is_directory()) return false;
 
   // Get a writeable copy of the path name
-  char pathname[MAXPATHLEN];
-  path.copy(pathname,MAXPATHLEN);
+  char *pathname = reinterpret_cast(_alloca(path.length()+1));
+  path.copy(pathname,path.length()+1);
 
   // Null-terminate the last component
   int lastchar = path.length() - 1 ;
@@ -290,15 +413,14 @@
     // Loop through the directory components until we're done
     while ( next != 0 ) {
       *next = 0;
-      if (0 != access(pathname, F_OK | R_OK | W_OK))
-        if (0 != mkdir(pathname))
-          ThrowError(std::string(pathname) + ": Can't create directory");
+      if (!CreateDirectory(pathname, NULL))
+          ThrowError(std::string(pathname) + ": Can't create directory: ");
       char* save = next;
       next = strchr(pathname,'/');
       *save = '/';
     }
-  } else if (0 != mkdir(pathname)) {
-    ThrowError(std::string(pathname) + ": Can't create directory");
+  } else if (!CreateDirectory(pathname, NULL)) {
+    ThrowError(std::string(pathname) + ": Can't create directory: ");
   }
   return true;
 }
@@ -309,9 +431,12 @@
   if (!is_file()) return false;
 
   // Create the file
-  if (0 != creat(path.c_str(), S_IRUSR | S_IWUSR))
-    ThrowError(std::string(path.c_str()) + ": Can't create file");
+  HANDLE h = CreateFile(path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
+                        FILE_ATTRIBUTE_NORMAL, NULL);
+  if (h == INVALID_HANDLE_VALUE)
+    ThrowError(std::string(path.c_str()) + ": Can't create file: ");
 
+  CloseHandle(h);
   return true;
 }
 
@@ -323,20 +448,23 @@
   // If it doesn't exist, we're done.
   if (!exists()) return true;
 
+  char *pathname = reinterpret_cast(_alloca(path.length()+1));
+  path.copy(pathname,path.length()+1);
+  int lastchar = path.length() - 1 ;
+  if (pathname[lastchar] == '/')
+    pathname[lastchar] = 0;
+
   if (remove_contents) {
     // Recursively descend the directory to remove its content
-    std::string cmd("/bin/rm -rf ");
+    // FIXME: The correct way of doing this on Windows isn't pretty...
+    // but this may work if unix-like utils are present.
+    std::string cmd("rm -rf ");
     cmd += path;
     system(cmd.c_str());
   } else {
     // Otherwise, try to just remove the one directory
-    char pathname[MAXPATHLEN];
-    path.copy(pathname,MAXPATHLEN);
-    int lastchar = path.length() - 1 ;
-    if (pathname[lastchar] == '/')
-      pathname[lastchar] = 0;
-    if ( 0 != rmdir(pathname))
-      ThrowError(std::string(pathname) + ": Can't destroy directory");
+    if (!RemoveDirectory(pathname))
+      ThrowError(std::string(pathname) + ": Can't destroy directory: ");
   }
   return true;
 }
@@ -344,8 +472,22 @@
 bool
 Path::destroy_file() {
   if (!is_file()) return false;
-  if (0 != unlink(path.c_str()))
-    ThrowError(std::string(path.c_str()) + ": Can't destroy file");
+
+  DWORD attr = GetFileAttributes(path.c_str());
+
+  // If it doesn't exist, we're done.
+  if (attr == INVALID_FILE_ATTRIBUTES)
+    return true;
+
+  // Read-only files cannot be deleted on Windows.  Must remove the read-only
+  // attribute first.
+  if (attr & FILE_ATTRIBUTE_READONLY) {
+    if (!SetFileAttributes(path.c_str(), attr & ~FILE_ATTRIBUTE_READONLY))
+      ThrowError(std::string(path.c_str()) + ": Can't destroy file: ");
+  }
+
+  if (!DeleteFile(path.c_str()))
+    ThrowError(std::string(path.c_str()) + ": Can't destroy file: ");
   return true;
 }
 





From reid at x10sys.com  Sat Sep 18 14:34:20 2004
From: reid at x10sys.com (Reid Spencer)
Date: Sat, 18 Sep 2004 14:34:20 -0500
Subject: [llvm-commits] CVS: llvm/lib/System/Interix/Memory.cpp 
Message-ID: <200409181934.OAA22292@zion.cs.uiuc.edu>



Changes in directory llvm/lib/System/Interix:

Memory.cpp updated: 1.3 -> 1.4
---
Log message:

Use the /dev/zero device as the device on which the pages are mapped.

Patch contributed by Henrik Bach. Thanks Henrik!


---
Diffs of the changes:  (+7 -1)

Index: llvm/lib/System/Interix/Memory.cpp
diff -u llvm/lib/System/Interix/Memory.cpp:1.3 llvm/lib/System/Interix/Memory.cpp:1.4
--- llvm/lib/System/Interix/Memory.cpp:1.3	Mon Sep 13 17:38:12 2004
+++ llvm/lib/System/Interix/Memory.cpp	Sat Sep 18 14:34:09 2004
@@ -15,6 +15,7 @@
 // Include the generic unix implementation
 #include "../Unix/Memory.cpp"
 #include "llvm/System/Process.h"
+#include 
 #include 
 
 namespace llvm {
@@ -30,9 +31,14 @@
 
   static const long pageSize = Process::GetPageSize();
   unsigned NumPages = (NumBytes+pageSize-1)/pageSize;
+  
+  int fd = open("/dev/zero", O_RDWR);
+  if (fd == -1) {
+    throw std::string("Can't open /dev/zero device: ") + strerror(errno);
+  }
 
   void *pa = mmap(0, pageSize*NumPages, PROT_READ|PROT_WRITE|PROT_EXEC,
-                  MAP_PRIVATE|MAP_ANON|MAP_NOCORE, -1, 0);
+                  MAP_SHARED, fd, 0);
   if (pa == (void*)-1) {
     throw std::string("Can't allocate RWX Memory: ") + strerror(errno);
   }





From lattner at cs.uiuc.edu  Sat Sep 18 16:34:34 2004
From: lattner at cs.uiuc.edu (Chris Lattner)
Date: Sat, 18 Sep 2004 16:34:34 -0500
Subject: [llvm-commits] CVS: llvm/include/llvm/Analysis/CallGraph.h 
Message-ID: <200409182134.QAA03475@apoc.cs.uiuc.edu>



Changes in directory llvm/include/llvm/Analysis:

CallGraph.h updated: 1.40 -> 1.41
---
Log message:

Add CallGraphNode::removeAnyCallEdgeTo method


---
Diffs of the changes:  (+5 -0)

Index: llvm/include/llvm/Analysis/CallGraph.h
diff -u llvm/include/llvm/Analysis/CallGraph.h:1.40 llvm/include/llvm/Analysis/CallGraph.h:1.41
--- llvm/include/llvm/Analysis/CallGraph.h:1.40	Fri Sep 17 19:22:43 2004
+++ llvm/include/llvm/Analysis/CallGraph.h	Sat Sep 18 16:34:21 2004
@@ -251,6 +251,11 @@
   /// used sparingly.
   void removeCallEdgeTo(CallGraphNode *Callee);
 
+  /// removeAnyCallEdgeTo - This method removes any call edges from this node to
+  /// the specified callee function.  This takes more time to execute than
+  /// removeCallEdgeTo, so it should not be used unless necessary.
+  void removeAnyCallEdgeTo(CallGraphNode *Callee);
+
 private:                    // Stuff to construct the node, used by CallGraph
   friend class CallGraph;
 





From lattner at cs.uiuc.edu  Sat Sep 18 16:34:44 2004
From: lattner at cs.uiuc.edu (Chris Lattner)
Date: Sat, 18 Sep 2004 16:34:44 -0500
Subject: [llvm-commits] CVS: llvm/lib/Analysis/IPA/CallGraph.cpp 
Message-ID: <200409182134.QAA03482@apoc.cs.uiuc.edu>



Changes in directory llvm/lib/Analysis/IPA:

CallGraph.cpp updated: 1.43 -> 1.44
---
Log message:

Add CallGraphNode::removeAnyCallEdgeTo method


---
Diffs of the changes:  (+12 -0)

Index: llvm/lib/Analysis/IPA/CallGraph.cpp
diff -u llvm/lib/Analysis/IPA/CallGraph.cpp:1.43 llvm/lib/Analysis/IPA/CallGraph.cpp:1.44
--- llvm/lib/Analysis/IPA/CallGraph.cpp:1.43	Fri Sep 17 19:27:20 2004
+++ llvm/lib/Analysis/IPA/CallGraph.cpp	Sat Sep 18 16:34:34 2004
@@ -206,3 +206,15 @@
     }
   }
 }
+
+// removeAnyCallEdgeTo - This method removes any call edges from this node to
+// the specified callee function.  This takes more time to execute than
+// removeCallEdgeTo, so it should not be used unless necessary.
+void CallGraphNode::removeAnyCallEdgeTo(CallGraphNode *Callee) {
+  for (std::vector::iterator I = CalledFunctions.begin(),
+         E = CalledFunctions.end(); I != E; ++I)
+    if (*I == Callee) {
+      CalledFunctions.erase(I);
+      E = CalledFunctions.end();
+    }
+}





From lattner at cs.uiuc.edu  Sat Sep 18 16:37:14 2004
From: lattner at cs.uiuc.edu (Chris Lattner)
Date: Sat, 18 Sep 2004 16:37:14 -0500
Subject: [llvm-commits] CVS: llvm/lib/Transforms/IPO/Inliner.cpp 
Message-ID: <200409182137.QAA03799@apoc.cs.uiuc.edu>



Changes in directory llvm/lib/Transforms/IPO:

Inliner.cpp updated: 1.22 -> 1.23
---
Log message:

Fix the inliner to always delete any edges from the external call node to
a function being deleted.  Due to optimizations done while inlining, there
can be edges from the external call node to a function node that were not
apparent any longer. 

This fixes the compiler crash while compiling 175.vpr


---
Diffs of the changes:  (+7 -8)

Index: llvm/lib/Transforms/IPO/Inliner.cpp
diff -u llvm/lib/Transforms/IPO/Inliner.cpp:1.22 llvm/lib/Transforms/IPO/Inliner.cpp:1.23
--- llvm/lib/Transforms/IPO/Inliner.cpp:1.22	Wed Sep  1 17:55:36 2004
+++ llvm/lib/Transforms/IPO/Inliner.cpp	Sat Sep 18 16:37:03 2004
@@ -168,22 +168,21 @@
   for (CallGraph::iterator I = CG.begin(), E = CG.end(); I != E; ++I) {
     CallGraphNode *CGN = I->second;
     if (Function *F = CGN ? CGN->getFunction() : 0) {
-      // If the only remaining users of the function are dead constants,
-      // remove them.
-      bool HadDeadConstantUsers = !F->use_empty();
+      // If the only remaining users of the function are dead constants, remove
+      // them.
       F->removeDeadConstantUsers();
 
       if ((F->hasLinkOnceLinkage() || F->hasInternalLinkage()) &&
           F->use_empty()) {
+
         // Remove any call graph edges from the function to its callees.
         while (CGN->begin() != CGN->end())
           CGN->removeCallEdgeTo(*(CGN->end()-1));
         
-        // If the function has external linkage (basically if it's a linkonce
-        // function) remove the edge from the external node to the callee
-        // node.
-        if (!F->hasInternalLinkage() || HadDeadConstantUsers)
-          CG.getExternalCallingNode()->removeCallEdgeTo(CGN);
+        // Remove any edges from the external node to the function's call graph
+        // node.  These edges might have been made irrelegant due to
+        // optimization of the program.
+        CG.getExternalCallingNode()->removeAnyCallEdgeTo(CGN);
         
         // Removing the node for callee from the call graph and delete it.
         FunctionsToRemove.insert(CGN);





From lattner at cs.uiuc.edu  Sat Sep 18 20:05:29 2004
From: lattner at cs.uiuc.edu (Chris Lattner)
Date: Sat, 18 Sep 2004 20:05:29 -0500
Subject: [llvm-commits] CVS: llvm/lib/Transforms/IPO/ArgumentPromotion.cpp 
Message-ID: <200409190105.UAA05200@apoc.cs.uiuc.edu>



Changes in directory llvm/lib/Transforms/IPO:

ArgumentPromotion.cpp updated: 1.11 -> 1.12
---
Log message:

Add comment


---
Diffs of the changes:  (+1 -1)

Index: llvm/lib/Transforms/IPO/ArgumentPromotion.cpp
diff -u llvm/lib/Transforms/IPO/ArgumentPromotion.cpp:1.11 llvm/lib/Transforms/IPO/ArgumentPromotion.cpp:1.12
--- llvm/lib/Transforms/IPO/ArgumentPromotion.cpp:1.11	Fri Sep 17 19:34:13 2004
+++ llvm/lib/Transforms/IPO/ArgumentPromotion.cpp	Sat Sep 18 20:05:16 2004
@@ -82,7 +82,7 @@
 bool ArgPromotion::runOnSCC(const std::vector &SCC) {
   bool Changed = false, LocalChange;
 
-  do {
+  do {  // Iterate until we stop promoting from this SCC.
     LocalChange = false;
     // Attempt to promote arguments from all functions in this SCC.
     for (unsigned i = 0, e = SCC.size(); i != e; ++i)





From reid at x10sys.com  Sun Sep 19 00:37:50 2004
From: reid at x10sys.com (Reid Spencer)
Date: Sun, 19 Sep 2004 00:37:50 -0500
Subject: [llvm-commits] CVS: llvm/lib/System/Win32/Signals.cpp 
Message-ID: <200409190537.AAA26427@zion.cs.uiuc.edu>



Changes in directory llvm/lib/System/Win32:

Signals.cpp updated: 1.3 -> 1.4
---
Log message:

Minor correction to Signals implementation.

Patch submitted by Jeff Cohen. Thanks Jeff!


---
Diffs of the changes:  (+24 -14)

Index: llvm/lib/System/Win32/Signals.cpp
diff -u llvm/lib/System/Win32/Signals.cpp:1.3 llvm/lib/System/Win32/Signals.cpp:1.4
--- llvm/lib/System/Win32/Signals.cpp:1.3	Thu Sep 16 22:02:27 2004
+++ llvm/lib/System/Win32/Signals.cpp	Sun Sep 19 00:37:39 2004
@@ -28,6 +28,8 @@
 static std::vector *FilesToRemove = NULL;
 static std::vector *DirectoriesToRemove = NULL;
 static bool RegisteredUnhandledExceptionFilter = false;
+static bool CleanupExecuted = false;
+static PTOP_LEVEL_EXCEPTION_FILTER OldFilter = NULL;
 
 // Windows creates a new thread to execute the console handler when an event
 // (such as CTRL/C) occurs.  This causes concurrency issues with the above
@@ -43,8 +45,7 @@
 
 
 static void RegisterHandler() { 
-  if (RegisteredUnhandledExceptionFilter)
-  {
+  if (RegisteredUnhandledExceptionFilter) {
     EnterCriticalSection(&CriticalSection);
     return;
   }
@@ -58,7 +59,7 @@
   EnterCriticalSection(&CriticalSection);
 
   RegisteredUnhandledExceptionFilter = true;
-  SetUnhandledExceptionFilter(LLVMUnhandledExceptionFilter);
+  OldFilter = SetUnhandledExceptionFilter(LLVMUnhandledExceptionFilter);
   SetConsoleCtrlHandler(LLVMConsoleCtrlHandler, TRUE);
 
   // IMPORTANT NOTE: Caller must call LeaveCriticalSection(&CriticalSection) or
@@ -69,6 +70,9 @@
 void sys::RemoveFileOnSignal(const std::string &Filename) {
   RegisterHandler();
 
+  if (CleanupExecuted)
+    throw std::string("Process terminating -- cannot register for removal");
+
   if (FilesToRemove == NULL)
     FilesToRemove = new std::vector;
 
@@ -81,6 +85,9 @@
 void sys::RemoveDirectoryOnSignal(const sys::Path& path) {
   RegisterHandler();
 
+  if (CleanupExecuted)
+    throw std::string("Process terminating -- cannot register for removal");
+
   if (path.is_directory()) {
     if (DirectoriesToRemove == NULL)
       DirectoriesToRemove = new std::vector;
@@ -103,6 +110,12 @@
 static void Cleanup() {
   EnterCriticalSection(&CriticalSection);
 
+  // Prevent other thread from registering new files and directories for
+  // removal, should we be executing because of the console handler callback.
+  CleanupExecuted = true;
+
+  // FIXME: open files cannot be deleted.
+
   if (FilesToRemove != NULL)
     while (!FilesToRemove->empty()) {
       try {
@@ -144,7 +157,7 @@
 
     // Initialize the symbol handler.
     SymSetOptions(SYMOPT_DEFERRED_LOADS|SYMOPT_LOAD_LINES);
-    SymInitialize(GetCurrentProcess(), NULL, TRUE);
+    SymInitialize(hProcess, NULL, TRUE);
 
     while (true) {
       if (!StackWalk(IMAGE_FILE_MACHINE_I386, hProcess, hThread, &StackFrame,
@@ -158,7 +171,7 @@
 
       // Print the PC in hexadecimal.
       DWORD PC = StackFrame.AddrPC.Offset;
-      fprintf(stderr, "%04X:%08X", ep->ContextRecord->SegCs, PC);
+      fprintf(stderr, "%08X", PC);
 
       // Print the parameters.  Assume there are four.
       fprintf(stderr, " (0x%08X 0x%08X 0x%08X 0x%08X)", StackFrame.Params[0],
@@ -166,7 +179,7 @@
 
       // Verify the PC belongs to a module in this process.
       if (!SymGetModuleBase(hProcess, PC)) {
-        fputc('\n', stderr);
+        fputs(" \n", stderr);
         continue;
       }
 
@@ -201,21 +214,18 @@
 
       fputc('\n', stderr);
     }
-  }
-  catch (...)
-  {
+  } catch (...) {
       assert(!"Crashed in LLVMUnhandledExceptionFilter");
   }
 
   // Allow dialog box to pop up allowing choice to start debugger.
-  return EXCEPTION_CONTINUE_SEARCH;
+  if (OldFilter)
+    return (*OldFilter)(ep);
+  else
+    return EXCEPTION_CONTINUE_SEARCH;
 }
 
 static BOOL WINAPI LLVMConsoleCtrlHandler(DWORD dwCtrlType) {
-  // FIXME: This handler executes on a different thread.  The main thread
-  // is still running, potentially creating new files to be cleaned up
-  // in the tiny window between the call to Cleanup() and process termination.
-  // Also, any files currently open cannot be deleted.
   Cleanup();
 
   // Allow normal processing to take place; i.e., the process dies.





From alkis at cs.uiuc.edu  Sun Sep 19 01:05:58 2004
From: alkis at cs.uiuc.edu (Alkis Evlogimenos)
Date: Sun, 19 Sep 2004 01:05:58 -0500
Subject: [llvm-commits] CVS: llvm-java/lib/Compiler/Compiler.cpp 
Message-ID: <200409190605.BAA26930@zion.cs.uiuc.edu>



Changes in directory llvm-java/lib/Compiler:

Compiler.cpp updated: 1.103 -> 1.104
---
Log message:

Fix type for member functions.


---
Diffs of the changes:  (+8 -3)

Index: llvm-java/lib/Compiler/Compiler.cpp
diff -u llvm-java/lib/Compiler/Compiler.cpp:1.103 llvm-java/lib/Compiler/Compiler.cpp:1.104
--- llvm-java/lib/Compiler/Compiler.cpp:1.103	Wed Sep 15 19:09:36 2004
+++ llvm-java/lib/Compiler/Compiler.cpp	Sun Sep 19 01:05:48 2004
@@ -343,6 +343,8 @@
 
       const Methods& methods = cf->getMethods();
 
+      const ClassInfo& ci = getClassInfo(cf);
+
       // add member functions to the vtable
       for (unsigned i = 0, e = methods.size(); i != e; ++i) {
         Method* method = methods[i];
@@ -355,7 +357,7 @@
 
           std::string funcName = "java/lang/Object/" + methodDescr;
           const FunctionType* funcTy = cast(
-            getType(method->getDescriptor(), getClassInfo(cf).type));
+            getType(method->getDescriptor(), ci.type));
 
           Function* vfun = module_->getOrInsertFunction(funcName, funcTy);
           toCompileFunctions_.insert(vfun);
@@ -723,14 +725,17 @@
     Function* compileMethodOnly(const std::string& classMethodDesc) {
       Method* method;
       tie(cf_, method) = findClassAndMethod(classMethodDesc);
+      const ClassInfo& ci = getClassInfo(cf_);
 
       std::string name = cf_->getThisClass()->getName()->str();
       name += '/';
       name += method->getName()->str();
       name += method->getDescriptor()->str();
 
-      Function* function = module_->getOrInsertFunction
-        (name, cast(getType(method->getDescriptor())));
+      FunctionType* funcTy = cast(
+        getType(method->getDescriptor(), method->isStatic() ? NULL : ci.type));
+
+      Function* function = module_->getOrInsertFunction(name, funcTy);
       function->setLinkage(method->isPrivate() ?
                            Function::InternalLinkage :
                            Function::ExternalLinkage);





From lattner at cs.uiuc.edu  Sun Sep 19 13:43:15 2004
From: lattner at cs.uiuc.edu (Chris Lattner)
Date: Sun, 19 Sep 2004 13:43:15 -0500
Subject: [llvm-commits] 
	CVS: llvm/test/Regression/Transforms/InstCombine/load.ll
Message-ID: <200409191843.NAA06981@apoc.cs.uiuc.edu>



Changes in directory llvm/test/Regression/Transforms/InstCombine:

load.ll updated: 1.6 -> 1.7
---
Log message:

Add two new testcases that instcombine should handle


---
Diffs of the changes:  (+23 -0)

Index: llvm/test/Regression/Transforms/InstCombine/load.ll
diff -u llvm/test/Regression/Transforms/InstCombine/load.ll:1.6 llvm/test/Regression/Transforms/InstCombine/load.ll:1.7
--- llvm/test/Regression/Transforms/InstCombine/load.ll:1.6	Thu May 27 12:43:33 2004
+++ llvm/test/Regression/Transforms/InstCombine/load.ll	Sun Sep 19 13:43:01 2004
@@ -4,6 +4,7 @@
 ; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep load
 
 %X = constant int 42
+%X2 = constant int 47
 %Y = constant [2 x { int, float }] [ { int, float } { int 12, float 1.0 }, 
                                      { int, float } { int 37, float 1.2312 } ]
 %Z = constant [2 x { int, float }] zeroinitializer
@@ -31,3 +32,25 @@
 	%B = load int* %A
 	ret int %B
 }
+
+; load (select (Cond, &V1, &V2))  --> select(Cond, load &V1, load &V2)
+int %test5(bool %C) {
+	%Y = select bool %C, int* %X, int* %X2
+	%Z = load int* %Y
+	ret int %Z
+}
+
+; load (phi (&V1, &V2, &V3))  --> phi(load &V1, load &V2, load &V3)
+int %test6(bool %C) {
+entry:
+        br bool %C, label %cond_true.i, label %cond_continue.i
+
+cond_true.i:
+        br label %cond_continue.i
+
+cond_continue.i:
+        %mem_tmp.i.0 = phi int* [ %X, %cond_true.i ], [ %X2, %entry ]
+        %tmp.3 = load int* %mem_tmp.i.0
+        ret int %tmp.3
+}
+





From lattner at cs.uiuc.edu  Sun Sep 19 13:43:57 2004
From: lattner at cs.uiuc.edu (Chris Lattner)
Date: Sun, 19 Sep 2004 13:43:57 -0500
Subject: [llvm-commits] 
	CVS: llvm/lib/Transforms/Scalar/InstructionCombining.cpp
Message-ID: <200409191843.NAA06992@apoc.cs.uiuc.edu>



Changes in directory llvm/lib/Transforms/Scalar:

InstructionCombining.cpp updated: 1.240 -> 1.241
---
Log message:

Make instruction combining a bit more aggressive in the face of volatile
loads, and implement two new transforms: InstCombine/load.ll:test[56].



---
Diffs of the changes:  (+60 -3)

Index: llvm/lib/Transforms/Scalar/InstructionCombining.cpp
diff -u llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.240 llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.241
--- llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.240	Wed Sep  1 17:55:36 2004
+++ llvm/lib/Transforms/Scalar/InstructionCombining.cpp	Sun Sep 19 13:43:46 2004
@@ -2983,7 +2983,8 @@
       // the same size.  Instead of casting the pointer before the load, cast
       // the result of the loaded value.
       Value *NewLoad = IC.InsertNewInstBefore(new LoadInst(CI->getOperand(0),
-                                                           CI->getName()), LI);
+                                                           CI->getName(),
+                                                           LI.isVolatile()),LI);
       // Now cast the result of the load.
       return new CastInst(NewLoad, LI.getType());
     }
@@ -2991,12 +2992,17 @@
   return 0;
 }
 
+/// isSafeToLoadUnconditionally - Return true if we know that executing a load
+/// from this value cannot trap.
+static bool isSafeToLoadUnconditionally(Value *V) {
+  return isa(V) || isa(V);
+}
+
 Instruction *InstCombiner::visitLoadInst(LoadInst &LI) {
   Value *Op = LI.getOperand(0);
-  if (LI.isVolatile()) return 0;
 
   if (Constant *C = dyn_cast(Op))
-    if (C->isNullValue())  // load null -> 0
+    if (C->isNullValue() && !LI.isVolatile())  // load null -> 0
       return ReplaceInstUsesWith(LI, Constant::getNullValue(LI.getType()));
 
   // Instcombine load (constant global) into the value loaded...
@@ -3021,6 +3027,57 @@
     if (Instruction *Res = InstCombineLoadCast(*this, LI))
       return Res;
 
+  if (!LI.isVolatile() && Op->hasOneUse()) {
+    // Change select and PHI nodes to select values instead of addresses: this
+    // helps alias analysis out a lot, allows many others simplifications, and
+    // exposes redundancy in the code.
+    //
+    // Note that we cannot do the transformation unless we know that the
+    // introduced loads cannot trap!  Something like this is valid as long as
+    // the condition is always false: load (select bool %C, int* null, int* %G),
+    // but it would not be valid if we transformed it to load from null
+    // unconditionally.
+    //
+    if (SelectInst *SI = dyn_cast(Op)) {
+      // load (select (Cond, &V1, &V2))  --> select(Cond, load &V1, load &V2).
+      if (isSafeToLoadUnconditionally(SI->getOperand(1)) &&
+          isSafeToLoadUnconditionally(SI->getOperand(2))) {
+        Value *V1 = InsertNewInstBefore(new LoadInst(SI->getOperand(1),
+                                     SI->getOperand(1)->getName()+".val"), *SI);
+        Value *V2 = InsertNewInstBefore(new LoadInst(SI->getOperand(2),
+                                     SI->getOperand(2)->getName()+".val"), *SI);
+        return new SelectInst(SI->getCondition(), V1, V2);
+      }
+
+    } else if (PHINode *PN = dyn_cast(Op)) {
+      // load (phi (&V1, &V2, &V3))  --> phi(load &V1, load &V2, load &V3)
+      bool Safe = true;
+      for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
+        if (!isSafeToLoadUnconditionally(PN->getIncomingValue(i))) {
+          Safe = false;
+          break;
+        }
+      if (Safe) {
+        // Create the PHI.
+        PHINode *NewPN = new PHINode(LI.getType(), PN->getName());
+        InsertNewInstBefore(NewPN, *PN);
+        std::map LoadMap;  // Don't insert duplicate loads
+
+        for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
+          BasicBlock *BB = PN->getIncomingBlock(i);
+          Value *&TheLoad = LoadMap[BB];
+          if (TheLoad == 0) {
+            Value *InVal = PN->getIncomingValue(i);
+            TheLoad = InsertNewInstBefore(new LoadInst(InVal,
+                                                       InVal->getName()+".val"),
+                                          *BB->getTerminator());
+          }
+          NewPN->addIncoming(TheLoad, BB);
+        }
+        return ReplaceInstUsesWith(LI, NewPN);
+      }
+    }
+  }
   return 0;
 }
 





From lattner at cs.uiuc.edu  Sun Sep 19 13:45:56 2004
From: lattner at cs.uiuc.edu (Chris Lattner)
Date: Sun, 19 Sep 2004 13:45:56 -0500
Subject: [llvm-commits] 
	CVS: llvm/test/Regression/Transforms/ScalarRepl/phinodepromote.ll
	select_promote.ll 
Message-ID: <200409191845.NAA07021@apoc.cs.uiuc.edu>



Changes in directory llvm/test/Regression/Transforms/ScalarRepl:

phinodepromote.ll updated: 1.1 -> 1.2
select_promote.ll updated: 1.1 -> 1.2
---
Log message:

Instcombine now helps out with these


---
Diffs of the changes:  (+7 -4)

Index: llvm/test/Regression/Transforms/ScalarRepl/phinodepromote.ll
diff -u llvm/test/Regression/Transforms/ScalarRepl/phinodepromote.ll:1.1 llvm/test/Regression/Transforms/ScalarRepl/phinodepromote.ll:1.2
--- llvm/test/Regression/Transforms/ScalarRepl/phinodepromote.ll:1.1	Sun Jan 11 19:17:42 2004
+++ llvm/test/Regression/Transforms/ScalarRepl/phinodepromote.ll	Sun Sep 19 13:45:45 2004
@@ -1,4 +1,4 @@
-; RUN: llvm-as < %s | opt -mem2reg | llvm-dis | not grep alloca
+; RUN: llvm-as < %s | opt -instcombine -mem2reg | llvm-dis | not grep alloca
 ;
 ; This tests to see if mem2reg can promote alloca instructions whose addresses
 ; are used by PHI nodes that are immediately loaded.  The LLVM C++ front-end
@@ -6,12 +6,14 @@
 ; lvalues), so handling this simple extension is quite useful.
 ;
 ; This testcase is what the following program looks like when it reaches
-; mem2reg:
+; instcombine:
 ;
 ; template
 ; const T& max(const T& a1, const T& a2) { return a1 < a2 ? a1 : a2; }
 ; int main() { return max(0, 1); }
 ;
+; This test checks to make sure the combination of instcombine and mem2reg
+; perform the transformation.
 
 int %main() {
 entry:


Index: llvm/test/Regression/Transforms/ScalarRepl/select_promote.ll
diff -u llvm/test/Regression/Transforms/ScalarRepl/select_promote.ll:1.1 llvm/test/Regression/Transforms/ScalarRepl/select_promote.ll:1.2
--- llvm/test/Regression/Transforms/ScalarRepl/select_promote.ll:1.1	Thu Apr  8 14:59:22 2004
+++ llvm/test/Regression/Transforms/ScalarRepl/select_promote.ll	Sun Sep 19 13:45:45 2004
@@ -1,6 +1,7 @@
-; Test promotion of loads that use the result of a select instruction.
+; Test promotion of loads that use the result of a select instruction.  This
+; should be simplified by the instcombine pass.
 
-; RUN: llvm-as < %s | opt -mem2reg | llvm-dis | not grep alloca
+; RUN: llvm-as < %s | opt -instcombine -mem2reg | llvm-dis | not grep alloca
 
 int %main() {
         %mem_tmp.0 = alloca int         ;  [#uses=3]





From lattner at cs.uiuc.edu  Sun Sep 19 13:52:04 2004
From: lattner at cs.uiuc.edu (Chris Lattner)
Date: Sun, 19 Sep 2004 13:52:04 -0500
Subject: [llvm-commits] 
	CVS: llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
Message-ID: <200409191852.NAA07554@apoc.cs.uiuc.edu>



Changes in directory llvm/lib/Transforms/Utils:

PromoteMemoryToRegister.cpp updated: 1.69 -> 1.70
---
Log message:

Remove a whole bunch of horrible hacky code that was used to promote allocas
whose addresses where used by trivial phi nodes and select instructions.  This
is now performed by the instcombine pass, which is more powerful, is much
simpler, and is faster.  This allows the deletion of a bunch of code, two
FIXME's and two gotos.



---
Diffs of the changes:  (+7 -145)

Index: llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
diff -u llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp:1.69 llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp:1.70
--- llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp:1.69	Fri Sep 17 19:32:40 2004
+++ llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp	Sun Sep 19 13:51:51 2004
@@ -8,11 +8,11 @@
 //===----------------------------------------------------------------------===//
 //
 // This file promote memory references to be register references.  It promotes
-// alloca instructions which only have loads and stores as uses (or that have
-// PHI nodes which are only loaded from).  An alloca is transformed by using
-// dominator frontiers to place PHI nodes, then traversing the function in
-// depth-first order to rewrite loads and stores as appropriate.  This is just
-// the standard SSA construction algorithm to construct "pruned" SSA form.
+// alloca instructions which only have loads and stores as uses.  An alloca is
+// transformed by using dominator frontiers to place PHI nodes, then traversing
+// the function in depth-first order to rewrite loads and stores as appropriate.
+// This is just the standard SSA construction algorithm to construct "pruned"
+// SSA form.
 //
 //===----------------------------------------------------------------------===//
 
@@ -30,8 +30,7 @@
 using namespace llvm;
 
 /// isAllocaPromotable - Return true if this alloca is legal for promotion.
-/// This is true if there are only loads and stores to the alloca... of if there
-/// is a PHI node using the address which can be trivially transformed.
+/// This is true if there are only loads and stores to the alloca.
 ///
 bool llvm::isAllocaPromotable(const AllocaInst *AI, const TargetData &TD) {
   // FIXME: If the memory unit is of pointer or integer type, we can permit
@@ -45,72 +44,8 @@
     } else if (const StoreInst *SI = dyn_cast(*UI)) {
       if (SI->getOperand(0) == AI)
         return false;   // Don't allow a store OF the AI, only INTO the AI.
-    } else if (const PHINode *PN = dyn_cast(*UI)) {
-      // We only support PHI nodes in a few simple cases.  The PHI node is only
-      // allowed to have one use, which must be a load instruction, and can only
-      // use alloca instructions (no random pointers).  Also, there cannot be
-      // any accesses to AI between the PHI node and the use of the PHI.
-      if (!PN->hasOneUse()) return false;
-
-      // Our transformation causes the unconditional loading of all pointer
-      // operands to the PHI node.  Because this could cause a fault if there is
-      // a critical edge in the CFG and if one of the pointers is illegal, we
-      // refuse to promote PHI nodes unless they are obviously safe.  For now,
-      // obviously safe means that all of the operands are allocas.
-      //
-      // If we wanted to extend this code to break critical edges, this
-      // restriction could be relaxed, and we could even handle uses of the PHI
-      // node that are volatile loads or stores.
-      //
-      for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
-        if (!isa(PN->getIncomingValue(i)))
-          return false;
-      
-      // Now make sure the one user instruction is in the same basic block as
-      // the PHI, and that there are no loads or stores between the PHI node and
-      // the access.
-      BasicBlock::const_iterator UI = cast(PN->use_back());
-      if (!isa(UI) || cast(UI)->isVolatile()) return false;
-      
-      // Scan looking for memory accesses.
-      // FIXME: this should REALLY use alias analysis.
-      for (--UI; !isa(UI); --UI)
-        if (isa(UI) || isa(UI) || isa(UI))
-          return false;
-
-      // If we got this far, we can promote the PHI use.
-    } else if (const SelectInst *SI = dyn_cast(*UI)) {
-      // We only support selects in a few simple cases.  The select is only
-      // allowed to have one use, which must be a load instruction, and can only
-      // use alloca instructions (no random pointers).  Also, there cannot be
-      // any accesses to AI between the PHI node and the use of the PHI.
-      if (!SI->hasOneUse()) return false;
-
-      // Our transformation causes the unconditional loading of all pointer
-      // operands of the select.  Because this could cause a fault if there is a
-      // critical edge in the CFG and if one of the pointers is illegal, we
-      // refuse to promote the select unless it is obviously safe.  For now,
-      // obviously safe means that all of the operands are allocas.
-      //
-      if (!isa(SI->getOperand(1)) ||
-          !isa(SI->getOperand(2)))
-        return false;
-      
-      // Now make sure the one user instruction is in the same basic block as
-      // the PHI, and that there are no loads or stores between the PHI node and
-      // the access.
-      BasicBlock::const_iterator UI = cast(SI->use_back());
-      if (!isa(UI) || cast(UI)->isVolatile()) return false;
-      
-      // Scan looking for memory accesses.
-      // FIXME: this should REALLY use alias analysis.
-      for (--UI; &*UI != SI; --UI)
-        if (isa(UI) || isa(UI) || isa(UI))
-          return false;
-
-      // If we got this far, we can promote the select use.
     } else {
-      return false;   // Not a load, store, or promotable PHI?
+      return false;   // Not a load or store.
     }
   
   return true;
@@ -216,7 +151,6 @@
     // As we scan the uses of the alloca instruction, keep track of stores, and
     // decide whether all of the loads and stores to the alloca are within the
     // same basic block.
-  RestartUseScan:
     Value *AllocaPointerVal = 0;
     for (Value::use_iterator U =AI->use_begin(), E = AI->use_end(); U != E;++U){
       Instruction *User = cast(*U);
@@ -228,78 +162,6 @@
         // Otherwise it must be a load instruction, keep track of variable reads
         UsingBlocks.push_back(LI->getParent());
         AllocaPointerVal = LI;
-      } else if (SelectInst *SI = dyn_cast(User)) {
-        // Because of the restrictions we placed on Select instruction uses
-        // above things are very simple.  Transform the select of addresses into
-        // a select of loaded values.
-        LoadInst *Load = cast(SI->use_back());
-        std::string LoadName = Load->getName(); Load->setName("");
-
-        Value *TrueVal = new LoadInst(SI->getOperand(1), 
-                                      SI->getOperand(1)->getName()+".val", SI);
-        Value *FalseVal = new LoadInst(SI->getOperand(2), 
-                                       SI->getOperand(2)->getName()+".val", SI);
-
-        Value *NewSI = new SelectInst(SI->getOperand(0), TrueVal,
-                                      FalseVal, Load->getName(), SI);
-        if (AST && isa(Load->getType())) {
-          AST->copyValue(Load, TrueVal);
-          AST->copyValue(Load, FalseVal);
-          AST->copyValue(Load, NewSI);
-          AST->deleteValue(Load);
-          AST->deleteValue(SI);
-        }
-
-        Load->replaceAllUsesWith(NewSI);
-        Load->getParent()->getInstList().erase(Load);
-        SI->getParent()->getInstList().erase(SI);
-
-        // Restart our scan of uses...
-        DefiningBlocks.clear();
-        UsingBlocks.clear();
-        goto RestartUseScan;
-      } else {
-        // Because of the restrictions we placed on PHI node uses above, the PHI
-        // node reads the block in any using predecessors.  Transform the PHI of
-        // addresses into a PHI of loaded values.
-        PHINode *PN = cast(User);
-        assert(PN->hasOneUse() && "Cannot handle PHI Node with != 1 use!");
-        LoadInst *PNUser = cast(PN->use_back());
-        std::string PNUserName = PNUser->getName(); PNUser->setName("");
-
-        // Create the new PHI node and insert load instructions as appropriate.
-        PHINode *NewPN = new PHINode(AI->getAllocatedType(), PNUserName, PN);
-        std::map NewLoads;
-        for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
-          BasicBlock *Pred = PN->getIncomingBlock(i);
-          LoadInst *&NewLoad = NewLoads[Pred];
-          if (NewLoad == 0)  // Insert the new load in the predecessor
-            NewLoad = new LoadInst(PN->getIncomingValue(i),
-                                   PN->getIncomingValue(i)->getName()+".val",
-                                   Pred->getTerminator());
-          NewPN->addIncoming(NewLoad, Pred);
-        }
-
-        if (AST && isa(NewPN->getType())) {
-          for (std::map::iterator I = NewLoads.begin(),
-                 E = NewLoads.end(); I != E; ++I)
-            AST->copyValue(PNUser, I->second);
-          AST->copyValue(PNUser, NewPN);
-          AST->deleteValue(PNUser);
-          AST->deleteValue(PN);
-        }
-
-        // Remove the old load.
-        PNUser->replaceAllUsesWith(NewPN);
-        PNUser->getParent()->getInstList().erase(PNUser);
-
-        // Remove the old PHI node.
-        PN->getParent()->getInstList().erase(PN);
-
-        // Restart our scan of uses...
-        DefiningBlocks.clear();
-        UsingBlocks.clear();
-        goto RestartUseScan;
       }
 
       if (OnlyUsedInOneBlock) {





From lattner at cs.uiuc.edu  Sun Sep 19 14:01:19 2004
From: lattner at cs.uiuc.edu (Chris Lattner)
Date: Sun, 19 Sep 2004 14:01:19 -0500
Subject: [llvm-commits] CVS: llvm/lib/Analysis/IPA/CallGraph.cpp 
Message-ID: <200409191901.OAA08783@apoc.cs.uiuc.edu>



Changes in directory llvm/lib/Analysis/IPA:

CallGraph.cpp updated: 1.44 -> 1.45
---
Log message:

Fix a nasty iterator invalidation problem I introduced yesterday.  This
unfortunately is the cause of a bunch of failures from tonight, and the
reason the tester is running so slow :(


---
Diffs of the changes:  (+5 -5)

Index: llvm/lib/Analysis/IPA/CallGraph.cpp
diff -u llvm/lib/Analysis/IPA/CallGraph.cpp:1.44 llvm/lib/Analysis/IPA/CallGraph.cpp:1.45
--- llvm/lib/Analysis/IPA/CallGraph.cpp:1.44	Sat Sep 18 16:34:34 2004
+++ llvm/lib/Analysis/IPA/CallGraph.cpp	Sun Sep 19 14:01:06 2004
@@ -211,10 +211,10 @@
 // the specified callee function.  This takes more time to execute than
 // removeCallEdgeTo, so it should not be used unless necessary.
 void CallGraphNode::removeAnyCallEdgeTo(CallGraphNode *Callee) {
-  for (std::vector::iterator I = CalledFunctions.begin(),
-         E = CalledFunctions.end(); I != E; ++I)
-    if (*I == Callee) {
-      CalledFunctions.erase(I);
-      E = CalledFunctions.end();
+  for (unsigned i = 0, e = CalledFunctions.size(); i != e; ++i)
+    if (CalledFunctions[i] == Callee) {
+      CalledFunctions[i] = CalledFunctions.back();
+      CalledFunctions.pop_back();
+      --i; --e;
     }
 }





From lattner at cs.uiuc.edu  Sun Sep 19 14:17:23 2004
From: lattner at cs.uiuc.edu (Chris Lattner)
Date: Sun, 19 Sep 2004 14:17:23 -0500
Subject: [llvm-commits] 
	CVS: llvm/test/Regression/Transforms/InstCombine/CPP_min_max.llx
Message-ID: <200409191917.OAA09504@apoc.cs.uiuc.edu>



Changes in directory llvm/test/Regression/Transforms/InstCombine:

CPP_min_max.llx added (r1.1)
---
Log message:

New testcase for PR362: http://llvm.cs.uiuc.edu/PR362 : Icky code generated for std::min/std::max


---
Diffs of the changes:  (+34 -0)

Index: llvm/test/Regression/Transforms/InstCombine/CPP_min_max.llx
diff -c /dev/null llvm/test/Regression/Transforms/InstCombine/CPP_min_max.llx:1.1
*** /dev/null	Sun Sep 19 14:17:20 2004
--- llvm/test/Regression/Transforms/InstCombine/CPP_min_max.llx	Sun Sep 19 14:17:10 2004
***************
*** 0 ****
--- 1,34 ----
+ ; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep select | not grep 'int\*'
+ 
+ ; This testcase corresponds to PR362, which notices that this horrible code
+ ; is generated by the C++ front-end and LLVM optimizers, which has lots of
+ ; loads and other stuff that are unneeded.
+ ;
+ ; Instcombine should propagate the load through the select instructions to
+ ; allow elimination of the extra stuff by the mem2reg pass.
+ 
+ implementation   ; Functions:
+ 
+ void %_Z5test1RiS_(int* %x, int* %y) {
+ entry:
+ 	%tmp.1.i = load int* %y		;  [#uses=1]
+ 	%tmp.3.i = load int* %x		;  [#uses=1]
+ 	%tmp.4.i = setlt int %tmp.1.i, %tmp.3.i		;  [#uses=1]
+ 	%retval.i = select bool %tmp.4.i, int* %y, int* %x		;  [#uses=1]
+ 	%tmp.4 = load int* %retval.i		;  [#uses=1]
+ 	store int %tmp.4, int* %x
+ 	ret void
+ }
+ 
+ void %_Z5test2RiS_(int* %x, int* %y) {
+ entry:
+ 	%tmp.0 = alloca int		;  [#uses=2]
+ 	%tmp.2 = load int* %x		;  [#uses=2]
+ 	store int %tmp.2, int* %tmp.0
+ 	%tmp.3.i = load int* %y		;  [#uses=1]
+ 	%tmp.4.i = setlt int %tmp.2, %tmp.3.i		;  [#uses=1]
+ 	%retval.i = select bool %tmp.4.i, int* %y, int* %tmp.0		;  [#uses=1]
+ 	%tmp.6 = load int* %retval.i		;  [#uses=1]
+ 	store int %tmp.6, int* %y
+ 	ret void
+ }





From lattner at cs.uiuc.edu  Sun Sep 19 14:18:21 2004
From: lattner at cs.uiuc.edu (Chris Lattner)
Date: Sun, 19 Sep 2004 14:18:21 -0500
Subject: [llvm-commits] 
	CVS: llvm/lib/Transforms/Scalar/InstructionCombining.cpp
Message-ID: <200409191918.OAA09515@apoc.cs.uiuc.edu>



Changes in directory llvm/lib/Transforms/Scalar:

InstructionCombining.cpp updated: 1.241 -> 1.242
---
Log message:

Make isSafeToLoadUnconditionally a bit smarter, implementing PR362: http://llvm.cs.uiuc.edu/PR362  and
Regression/Transforms/InstCombine/CPP_min_max.llx


---
Diffs of the changes:  (+28 -6)

Index: llvm/lib/Transforms/Scalar/InstructionCombining.cpp
diff -u llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.241 llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.242
--- llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.241	Sun Sep 19 13:43:46 2004
+++ llvm/lib/Transforms/Scalar/InstructionCombining.cpp	Sun Sep 19 14:18:10 2004
@@ -2993,9 +2993,30 @@
 }
 
 /// isSafeToLoadUnconditionally - Return true if we know that executing a load
-/// from this value cannot trap.
-static bool isSafeToLoadUnconditionally(Value *V) {
-  return isa(V) || isa(V);
+/// from this value cannot trap.  If it is not obviously safe to load from the
+/// specified pointer, we do a quick local scan of the basic block containing
+/// ScanFrom, to determine if the address is already accessed.
+static bool isSafeToLoadUnconditionally(Value *V, Instruction *ScanFrom) {
+  // If it is an alloca or global variable, it is always safe to load from.
+  if (isa(V) || isa(V)) return true;
+
+  // Otherwise, be a little bit agressive by scanning the local block where we
+  // want to check to see if the pointer is already being loaded or stored
+  // from/to.  If so, the previous load or store would hav already trapped, so
+  // there is no harm doing an extra load (also, CSE will later eliminate the
+  // load entirely).
+  BasicBlock::iterator BBI = ScanFrom, E = ScanFrom->getParent()->begin();
+
+  do {
+    --BBI;
+
+    if (LoadInst *LI = dyn_cast(BBI)) {
+      if (LI->getOperand(0) == V) return true;
+    } else if (StoreInst *SI = dyn_cast(BBI))
+      if (SI->getOperand(1) == V) return true;
+    
+  } while (BBI != E);
+  return false;
 }
 
 Instruction *InstCombiner::visitLoadInst(LoadInst &LI) {
@@ -3040,8 +3061,8 @@
     //
     if (SelectInst *SI = dyn_cast(Op)) {
       // load (select (Cond, &V1, &V2))  --> select(Cond, load &V1, load &V2).
-      if (isSafeToLoadUnconditionally(SI->getOperand(1)) &&
-          isSafeToLoadUnconditionally(SI->getOperand(2))) {
+      if (isSafeToLoadUnconditionally(SI->getOperand(1), SI) &&
+          isSafeToLoadUnconditionally(SI->getOperand(2), SI)) {
         Value *V1 = InsertNewInstBefore(new LoadInst(SI->getOperand(1),
                                      SI->getOperand(1)->getName()+".val"), *SI);
         Value *V2 = InsertNewInstBefore(new LoadInst(SI->getOperand(2),
@@ -3053,7 +3074,8 @@
       // load (phi (&V1, &V2, &V3))  --> phi(load &V1, load &V2, load &V3)
       bool Safe = true;
       for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
-        if (!isSafeToLoadUnconditionally(PN->getIncomingValue(i))) {
+        if (!isSafeToLoadUnconditionally(PN->getIncomingValue(i),
+                                    PN->getIncomingBlock(i)->getTerminator())) {
           Safe = false;
           break;
         }





From lattner at cs.uiuc.edu  Sun Sep 19 14:21:39 2004
From: lattner at cs.uiuc.edu (Chris Lattner)
Date: Sun, 19 Sep 2004 14:21:39 -0500
Subject: [llvm-commits] CVS: llvm/docs/ReleaseNotes.html 
Message-ID: <200409191921.OAA09541@apoc.cs.uiuc.edu>



Changes in directory llvm/docs:

ReleaseNotes.html updated: 1.238 -> 1.239
---
Log message:

better code
Move other things to the right sections


---
Diffs of the changes:  (+7 -5)

Index: llvm/docs/ReleaseNotes.html
diff -u llvm/docs/ReleaseNotes.html:1.238 llvm/docs/ReleaseNotes.html:1.239
--- llvm/docs/ReleaseNotes.html:1.238	Tue Sep 14 20:09:25 2004
+++ llvm/docs/ReleaseNotes.html	Sun Sep 19 14:21:26 2004
@@ -86,6 +86,8 @@
 
 
 
+  move test/Programs out of the main llvm
+    tree
 
 
 
@@ -117,6 +119,8 @@
 
 [llvmg++] Tons of warnings are spewed when 
     linking to libstdc++
+include/{Support,Config} -> 
+    include/llvm/{Support,Config}
 
 
 
@@ -140,10 +144,8 @@
 
 
 
-  move test/Programs out of the main llvm
-    tree
-  include/{Support,Config} -> 
-    include/llvm/{Support,Config}
+Ugly code generator for  
+    std::min/std::max
 
 
 
@@ -615,7 +617,7 @@
   src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!" />
 
   The LLVM Compiler Infrastructure

-  Last modified: $Date: 2004/09/15 01:09:25 $
+  Last modified: $Date: 2004/09/19 19:21:26 $
 
 
 





From reid at x10sys.com  Sun Sep 19 16:47:58 2004
From: reid at x10sys.com (Reid Spencer)
Date: Sun, 19 Sep 2004 16:47:58 -0500
Subject: [llvm-commits] CVS: llvm/autoconf/m4/libtool.m4 
Message-ID: <200409192147.QAA12152@zion.cs.uiuc.edu>



Changes in directory llvm/autoconf/m4:

libtool.m4 added (r1.1)
---
Log message:

Add our own version of libtool.m4 instead of relying on the installed one.
This is a potential version mismatch problem because this file came from
libtool 1.5.10. If you're running a different version of libtool, the 
checks in this file may not be quite right. Having our own version of this
file violates the spirit of libtool and is only provided to change the name
of "libtool" to "mklib". This is done so that the name "libtool" does not 
conflict with the "lib" directory when doing tab completion and your 
$objdir == $srcdir.


---
Diffs of the changes:  (+6010 -0)

Index: llvm/autoconf/m4/libtool.m4
diff -c /dev/null llvm/autoconf/m4/libtool.m4:1.1
*** /dev/null	Sun Sep 19 16:47:57 2004
--- llvm/autoconf/m4/libtool.m4	Sun Sep 19 16:47:47 2004
***************
*** 0 ****
--- 1,6010 ----
+ ###############################################################################
+ ###############################################################################
+ ############ READ THIS:
+ ############ The only difference between this version of libtool.m4 and the one
+ ############ provided with libtool 1.5.10 is this warning header and changing
+ ############ the name of libtool to mklib. AutoRegen.sh checks for version 
+ ############ 1.5.10 of libtool so attempts to use another version with this
+ ############ AC_PROG_LIBTOOL definition should fail. You've been warned.
+ ###############################################################################
+ ###############################################################################
+ # libtool.m4 - Configure libtool for the host system. -*-Autoconf-*-
+ ## Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004
+ ## Free Software Foundation, Inc.
+ ## Originally by Gordon Matzigkeit , 1996
+ ##
+ ## This program is free software; you can redistribute it and/or modify
+ ## it under the terms of the GNU General Public License as published by
+ ## the Free Software Foundation; either version 2 of the License, or
+ ## (at your option) any later version.
+ ##
+ ## This program is distributed in the hope that it will be useful, but
+ ## WITHOUT ANY WARRANTY; without even the implied warranty of
+ ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ ## General Public License for more details.
+ ##
+ ## You should have received a copy of the GNU General Public License
+ ## along with this program; if not, write to the Free Software
+ ## Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ ##
+ ## As a special exception to the GNU General Public License, if you
+ ## distribute this file as part of a program that contains a
+ ## configuration script generated by Autoconf, you may include it under
+ ## the same distribution terms that you use for the rest of that program.
+ 
+ # serial 47 AC_PROG_LIBTOOL
+ 
+ 
+ # AC_PROVIDE_IFELSE(MACRO-NAME, IF-PROVIDED, IF-NOT-PROVIDED)
+ # -----------------------------------------------------------
+ # If this macro is not defined by Autoconf, define it here.
+ m4_ifdef([AC_PROVIDE_IFELSE],
+          [],
+          [m4_define([AC_PROVIDE_IFELSE],
+ 	         [m4_ifdef([AC_PROVIDE_$1],
+ 		           [$2], [$3])])])
+ 
+ 
+ # AC_PROG_LIBTOOL
+ # ---------------
+ AC_DEFUN([AC_PROG_LIBTOOL],
+ [AC_REQUIRE([_AC_PROG_LIBTOOL])dnl
+ dnl If AC_PROG_CXX has already been expanded, run AC_LIBTOOL_CXX
+ dnl immediately, otherwise, hook it in at the end of AC_PROG_CXX.
+   AC_PROVIDE_IFELSE([AC_PROG_CXX],
+     [AC_LIBTOOL_CXX],
+     [define([AC_PROG_CXX], defn([AC_PROG_CXX])[AC_LIBTOOL_CXX
+   ])])
+ dnl And a similar setup for Fortran 77 support
+   AC_PROVIDE_IFELSE([AC_PROG_F77],
+     [AC_LIBTOOL_F77],
+     [define([AC_PROG_F77], defn([AC_PROG_F77])[AC_LIBTOOL_F77
+ ])])
+ 
+ dnl Quote A][M_PROG_GCJ so that aclocal doesn't bring it in needlessly.
+ dnl If either AC_PROG_GCJ or A][M_PROG_GCJ have already been expanded, run
+ dnl AC_LIBTOOL_GCJ immediately, otherwise, hook it in at the end of both.
+   AC_PROVIDE_IFELSE([AC_PROG_GCJ],
+     [AC_LIBTOOL_GCJ],
+     [AC_PROVIDE_IFELSE([A][M_PROG_GCJ],
+       [AC_LIBTOOL_GCJ],
+       [AC_PROVIDE_IFELSE([LT_AC_PROG_GCJ],
+ 	[AC_LIBTOOL_GCJ],
+       [ifdef([AC_PROG_GCJ],
+ 	     [define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[AC_LIBTOOL_GCJ])])
+        ifdef([A][M_PROG_GCJ],
+ 	     [define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[AC_LIBTOOL_GCJ])])
+        ifdef([LT_AC_PROG_GCJ],
+ 	     [define([LT_AC_PROG_GCJ],
+ 		defn([LT_AC_PROG_GCJ])[AC_LIBTOOL_GCJ])])])])
+ ])])# AC_PROG_LIBTOOL
+ 
+ 
+ # _AC_PROG_LIBTOOL
+ # ----------------
+ AC_DEFUN([_AC_PROG_LIBTOOL],
+ [AC_REQUIRE([AC_LIBTOOL_SETUP])dnl
+ AC_BEFORE([$0],[AC_LIBTOOL_CXX])dnl
+ AC_BEFORE([$0],[AC_LIBTOOL_F77])dnl
+ AC_BEFORE([$0],[AC_LIBTOOL_GCJ])dnl
+ 
+ # This can be used to rebuild libtool when needed
+ LIBTOOL_DEPS="$ac_aux_dir/ltmain.sh"
+ 
+ # Always use our own libtool.
+ LIBTOOL='$(SHELL) $(top_builddir)/mklib'
+ AC_SUBST(LIBTOOL)dnl
+ 
+ # Prevent multiple expansion
+ define([AC_PROG_LIBTOOL], [])
+ ])# _AC_PROG_LIBTOOL
+ 
+ 
+ # AC_LIBTOOL_SETUP
+ # ----------------
+ AC_DEFUN([AC_LIBTOOL_SETUP],
+ [AC_PREREQ(2.50)dnl
+ AC_REQUIRE([AC_ENABLE_SHARED])dnl
+ AC_REQUIRE([AC_ENABLE_STATIC])dnl
+ AC_REQUIRE([AC_ENABLE_FAST_INSTALL])dnl
+ AC_REQUIRE([AC_CANONICAL_HOST])dnl
+ AC_REQUIRE([AC_CANONICAL_BUILD])dnl
+ AC_REQUIRE([AC_PROG_CC])dnl
+ AC_REQUIRE([AC_PROG_LD])dnl
+ AC_REQUIRE([AC_PROG_LD_RELOAD_FLAG])dnl
+ AC_REQUIRE([AC_PROG_NM])dnl
+ 
+ AC_REQUIRE([AC_PROG_LN_S])dnl
+ AC_REQUIRE([AC_DEPLIBS_CHECK_METHOD])dnl
+ # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
+ AC_REQUIRE([AC_OBJEXT])dnl
+ AC_REQUIRE([AC_EXEEXT])dnl
+ dnl
+ 
+ AC_LIBTOOL_SYS_MAX_CMD_LEN
+ AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE
+ AC_LIBTOOL_OBJDIR
+ 
+ AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl
+ _LT_AC_PROG_ECHO_BACKSLASH
+ 
+ case $host_os in
+ aix3*)
+   # AIX sometimes has problems with the GCC collect2 program.  For some
+   # reason, if we set the COLLECT_NAMES environment variable, the problems
+   # vanish in a puff of smoke.
+   if test "X${COLLECT_NAMES+set}" != Xset; then
+     COLLECT_NAMES=
+     export COLLECT_NAMES
+   fi
+   ;;
+ esac
+ 
+ # Sed substitution that helps us do robust quoting.  It backslashifies
+ # metacharacters that are still active within double-quoted strings.
+ Xsed='sed -e s/^X//'
+ [sed_quote_subst='s/\([\\"\\`$\\\\]\)/\\\1/g']
+ 
+ # Same as above, but do not quote variable references.
+ [double_quote_subst='s/\([\\"\\`\\\\]\)/\\\1/g']
+ 
+ # Sed substitution to delay expansion of an escaped shell variable in a
+ # double_quote_subst'ed string.
+ delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
+ 
+ # Sed substitution to avoid accidental globbing in evaled expressions
+ no_glob_subst='s/\*/\\\*/g'
+ 
+ # Constants:
+ rm="rm -f"
+ 
+ # Global variables:
+ default_ofile=libtool
+ can_build_shared=yes
+ 
+ # All known linkers require a `.a' archive for static linking (except M$VC,
+ # which needs '.lib').
+ libext=a
+ ltmain="$ac_aux_dir/ltmain.sh"
+ ofile="$default_ofile"
+ with_gnu_ld="$lt_cv_prog_gnu_ld"
+ 
+ AC_CHECK_TOOL(AR, ar, false)
+ AC_CHECK_TOOL(RANLIB, ranlib, :)
+ AC_CHECK_TOOL(STRIP, strip, :)
+ 
+ old_CC="$CC"
+ old_CFLAGS="$CFLAGS"
+ 
+ # Set sane defaults for various variables
+ test -z "$AR" && AR=ar
+ test -z "$AR_FLAGS" && AR_FLAGS=cru
+ test -z "$AS" && AS=as
+ test -z "$CC" && CC=cc
+ test -z "$LTCC" && LTCC=$CC
+ test -z "$DLLTOOL" && DLLTOOL=dlltool
+ test -z "$LD" && LD=ld
+ test -z "$LN_S" && LN_S="ln -s"
+ test -z "$MAGIC_CMD" && MAGIC_CMD=file
+ test -z "$NM" && NM=nm
+ test -z "$SED" && SED=sed
+ test -z "$OBJDUMP" && OBJDUMP=objdump
+ test -z "$RANLIB" && RANLIB=:
+ test -z "$STRIP" && STRIP=:
+ test -z "$ac_objext" && ac_objext=o
+ 
+ # Determine commands to create old-style static archives.
+ old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs'
+ old_postinstall_cmds='chmod 644 $oldlib'
+ old_postuninstall_cmds=
+ 
+ if test -n "$RANLIB"; then
+   case $host_os in
+   openbsd*)
+     old_postinstall_cmds="\$RANLIB -t \$oldlib~$old_postinstall_cmds"
+     ;;
+   *)
+     old_postinstall_cmds="\$RANLIB \$oldlib~$old_postinstall_cmds"
+     ;;
+   esac
+   old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"
+ fi
+ 
+ cc_basename=`$echo X"$compiler" | $Xsed -e 's%^.*/%%'`
+ 
+ # Only perform the check for file, if the check method requires it
+ case $deplibs_check_method in
+ file_magic*)
+   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
+     AC_PATH_MAGIC
+   fi
+   ;;
+ esac
+ 
+ AC_PROVIDE_IFELSE([AC_LIBTOOL_DLOPEN], enable_dlopen=yes, enable_dlopen=no)
+ AC_PROVIDE_IFELSE([AC_LIBTOOL_WIN32_DLL],
+ enable_win32_dll=yes, enable_win32_dll=no)
+ 
+ AC_ARG_ENABLE([libtool-lock],
+     [AC_HELP_STRING([--disable-libtool-lock],
+ 	[avoid locking (might break parallel builds)])])
+ test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
+ 
+ AC_ARG_WITH([pic],
+     [AC_HELP_STRING([--with-pic],
+ 	[try to use only PIC/non-PIC objects @<:@default=use both@:>@])],
+     [pic_mode="$withval"],
+     [pic_mode=default])
+ test -z "$pic_mode" && pic_mode=default
+ 
+ # Use C for the default configuration in the libtool script
+ tagname=
+ AC_LIBTOOL_LANG_C_CONFIG
+ _LT_AC_TAGCONFIG
+ ])# AC_LIBTOOL_SETUP
+ 
+ 
+ # _LT_AC_SYS_COMPILER
+ # -------------------
+ AC_DEFUN([_LT_AC_SYS_COMPILER],
+ [AC_REQUIRE([AC_PROG_CC])dnl
+ 
+ # If no C compiler was specified, use CC.
+ LTCC=${LTCC-"$CC"}
+ 
+ # Allow CC to be a program name with arguments.
+ compiler=$CC
+ ])# _LT_AC_SYS_COMPILER
+ 
+ 
+ # _LT_AC_SYS_LIBPATH_AIX
+ # ----------------------
+ # Links a minimal program and checks the executable
+ # for the system default hardcoded library path. In most cases,
+ # this is /usr/lib:/lib, but when the MPI compilers are used
+ # the location of the communication and MPI libs are included too.
+ # If we don't find anything, use the default library path according
+ # to the aix ld manual.
+ AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX],
+ [AC_LINK_IFELSE(AC_LANG_PROGRAM,[
+ aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+ }'`
+ # Check for a 64-bit object if we didn't find anything.
+ if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+ }'`; fi],[])
+ if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+ ])# _LT_AC_SYS_LIBPATH_AIX
+ 
+ 
+ # _LT_AC_SHELL_INIT(ARG)
+ # ----------------------
+ AC_DEFUN([_LT_AC_SHELL_INIT],
+ [ifdef([AC_DIVERSION_NOTICE],
+ 	     [AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)],
+ 	 [AC_DIVERT_PUSH(NOTICE)])
+ $1
+ AC_DIVERT_POP
+ ])# _LT_AC_SHELL_INIT
+ 
+ 
+ # _LT_AC_PROG_ECHO_BACKSLASH
+ # --------------------------
+ # Add some code to the start of the generated configure script which
+ # will find an echo command which doesn't interpret backslashes.
+ AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH],
+ [_LT_AC_SHELL_INIT([
+ # Check that we are running under the correct shell.
+ SHELL=${CONFIG_SHELL-/bin/sh}
+ 
+ case X$ECHO in
+ X*--fallback-echo)
+   # Remove one level of quotation (which was required for Make).
+   ECHO=`echo "$ECHO" | sed 's,\\\\\[$]\\[$]0,'[$]0','`
+   ;;
+ esac
+ 
+ echo=${ECHO-echo}
+ if test "X[$]1" = X--no-reexec; then
+   # Discard the --no-reexec flag, and continue.
+   shift
+ elif test "X[$]1" = X--fallback-echo; then
+   # Avoid inline document here, it may be left over
+   :
+ elif test "X`($echo '\t') 2>/dev/null`" = 'X\t' ; then
+   # Yippee, $echo works!
+   :
+ else
+   # Restart under the correct shell.
+   exec $SHELL "[$]0" --no-reexec ${1+"[$]@"}
+ fi
+ 
+ if test "X[$]1" = X--fallback-echo; then
+   # used as fallback echo
+   shift
+   cat </dev/null 2>&1 && unset CDPATH
+ 
+ if test -z "$ECHO"; then
+ if test "X${echo_test_string+set}" != Xset; then
+ # find a string as large as possible, as long as the shell can cope with it
+   for cmd in 'sed 50q "[$]0"' 'sed 20q "[$]0"' 'sed 10q "[$]0"' 'sed 2q "[$]0"' 'echo test'; do
+     # expected sizes: less than 2Kb, 1Kb, 512 bytes, 16 bytes, ...
+     if (echo_test_string="`eval $cmd`") 2>/dev/null &&
+        echo_test_string="`eval $cmd`" &&
+        (test "X$echo_test_string" = "X$echo_test_string") 2>/dev/null
+     then
+       break
+     fi
+   done
+ fi
+ 
+ if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&
+    echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` &&
+    test "X$echo_testing_string" = "X$echo_test_string"; then
+   :
+ else
+   # The Solaris, AIX, and Digital Unix default echo programs unquote
+   # backslashes.  This makes it impossible to quote backslashes using
+   #   echo "$something" | sed 's/\\/\\\\/g'
+   #
+   # So, first we look for a working echo in the user's PATH.
+ 
+   lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+   for dir in $PATH /usr/ucb; do
+     IFS="$lt_save_ifs"
+     if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&
+        test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&
+        echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` &&
+        test "X$echo_testing_string" = "X$echo_test_string"; then
+       echo="$dir/echo"
+       break
+     fi
+   done
+   IFS="$lt_save_ifs"
+ 
+   if test "X$echo" = Xecho; then
+     # We didn't find a better echo, so look for alternatives.
+     if test "X`(print -r '\t') 2>/dev/null`" = 'X\t' &&
+        echo_testing_string=`(print -r "$echo_test_string") 2>/dev/null` &&
+        test "X$echo_testing_string" = "X$echo_test_string"; then
+       # This shell has a builtin print -r that does the trick.
+       echo='print -r'
+     elif (test -f /bin/ksh || test -f /bin/ksh$ac_exeext) &&
+ 	 test "X$CONFIG_SHELL" != X/bin/ksh; then
+       # If we have ksh, try running configure again with it.
+       ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
+       export ORIGINAL_CONFIG_SHELL
+       CONFIG_SHELL=/bin/ksh
+       export CONFIG_SHELL
+       exec $CONFIG_SHELL "[$]0" --no-reexec ${1+"[$]@"}
+     else
+       # Try using printf.
+       echo='printf %s\n'
+       if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&
+ 	 echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` &&
+ 	 test "X$echo_testing_string" = "X$echo_test_string"; then
+ 	# Cool, printf works
+ 	:
+       elif echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` &&
+ 	   test "X$echo_testing_string" = 'X\t' &&
+ 	   echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
+ 	   test "X$echo_testing_string" = "X$echo_test_string"; then
+ 	CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL
+ 	export CONFIG_SHELL
+ 	SHELL="$CONFIG_SHELL"
+ 	export SHELL
+ 	echo="$CONFIG_SHELL [$]0 --fallback-echo"
+       elif echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` &&
+ 	   test "X$echo_testing_string" = 'X\t' &&
+ 	   echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
+ 	   test "X$echo_testing_string" = "X$echo_test_string"; then
+ 	echo="$CONFIG_SHELL [$]0 --fallback-echo"
+       else
+ 	# maybe with a smaller string...
+ 	prev=:
+ 
+ 	for cmd in 'echo test' 'sed 2q "[$]0"' 'sed 10q "[$]0"' 'sed 20q "[$]0"' 'sed 50q "[$]0"'; do
+ 	  if (test "X$echo_test_string" = "X`eval $cmd`") 2>/dev/null
+ 	  then
+ 	    break
+ 	  fi
+ 	  prev="$cmd"
+ 	done
+ 
+ 	if test "$prev" != 'sed 50q "[$]0"'; then
+ 	  echo_test_string=`eval $prev`
+ 	  export echo_test_string
+ 	  exec ${ORIGINAL_CONFIG_SHELL-${CONFIG_SHELL-/bin/sh}} "[$]0" ${1+"[$]@"}
+ 	else
+ 	  # Oops.  We lost completely, so just stick with echo.
+ 	  echo=echo
+ 	fi
+       fi
+     fi
+   fi
+ fi
+ fi
+ 
+ # Copy echo and quote the copy suitably for passing to libtool from
+ # the Makefile, instead of quoting the original, which is used later.
+ ECHO=$echo
+ if test "X$ECHO" = "X$CONFIG_SHELL [$]0 --fallback-echo"; then
+    ECHO="$CONFIG_SHELL \\\$\[$]0 --fallback-echo"
+ fi
+ 
+ AC_SUBST(ECHO)
+ ])])# _LT_AC_PROG_ECHO_BACKSLASH
+ 
+ 
+ # _LT_AC_LOCK
+ # -----------
+ AC_DEFUN([_LT_AC_LOCK],
+ [AC_ARG_ENABLE([libtool-lock],
+     [AC_HELP_STRING([--disable-libtool-lock],
+ 	[avoid locking (might break parallel builds)])])
+ test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
+ 
+ # Some flags need to be propagated to the compiler or linker for good
+ # libtool support.
+ case $host in
+ ia64-*-hpux*)
+   # Find out which ABI we are using.
+   echo 'int i;' > conftest.$ac_ext
+   if AC_TRY_EVAL(ac_compile); then
+     case `/usr/bin/file conftest.$ac_objext` in
+     *ELF-32*)
+       HPUX_IA64_MODE="32"
+       ;;
+     *ELF-64*)
+       HPUX_IA64_MODE="64"
+       ;;
+     esac
+   fi
+   rm -rf conftest*
+   ;;
+ *-*-irix6*)
+   # Find out which ABI we are using.
+   echo '[#]line __oline__ "configure"' > conftest.$ac_ext
+   if AC_TRY_EVAL(ac_compile); then
+    if test "$lt_cv_prog_gnu_ld" = yes; then
+     case `/usr/bin/file conftest.$ac_objext` in
+     *32-bit*)
+       LD="${LD-ld} -melf32bsmip"
+       ;;
+     *N32*)
+       LD="${LD-ld} -melf32bmipn32"
+       ;;
+     *64-bit*)
+       LD="${LD-ld} -melf64bmip"
+       ;;
+     esac
+    else
+     case `/usr/bin/file conftest.$ac_objext` in
+     *32-bit*)
+       LD="${LD-ld} -32"
+       ;;
+     *N32*)
+       LD="${LD-ld} -n32"
+       ;;
+     *64-bit*)
+       LD="${LD-ld} -64"
+       ;;
+     esac
+    fi
+   fi
+   rm -rf conftest*
+   ;;
+ 
+ x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)
+   # Find out which ABI we are using.
+   echo 'int i;' > conftest.$ac_ext
+   if AC_TRY_EVAL(ac_compile); then
+     case "`/usr/bin/file conftest.o`" in
+     *32-bit*)
+       case $host in
+         x86_64-*linux*)
+           LD="${LD-ld} -m elf_i386"
+           ;;
+         ppc64-*linux*|powerpc64-*linux*)
+           LD="${LD-ld} -m elf32ppclinux"
+           ;;
+         s390x-*linux*)
+           LD="${LD-ld} -m elf_s390"
+           ;;
+         sparc64-*linux*)
+           LD="${LD-ld} -m elf32_sparc"
+           ;;
+       esac
+       ;;
+     *64-bit*)
+       case $host in
+         x86_64-*linux*)
+           LD="${LD-ld} -m elf_x86_64"
+           ;;
+         ppc*-*linux*|powerpc*-*linux*)
+           LD="${LD-ld} -m elf64ppc"
+           ;;
+         s390*-*linux*)
+           LD="${LD-ld} -m elf64_s390"
+           ;;
+         sparc*-*linux*)
+           LD="${LD-ld} -m elf64_sparc"
+           ;;
+       esac
+       ;;
+     esac
+   fi
+   rm -rf conftest*
+   ;;
+ 
+ *-*-sco3.2v5*)
+   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
+   SAVE_CFLAGS="$CFLAGS"
+   CFLAGS="$CFLAGS -belf"
+   AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,
+     [AC_LANG_PUSH(C)
+      AC_TRY_LINK([],[],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])
+      AC_LANG_POP])
+   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
+     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
+     CFLAGS="$SAVE_CFLAGS"
+   fi
+   ;;
+ AC_PROVIDE_IFELSE([AC_LIBTOOL_WIN32_DLL],
+ [*-*-cygwin* | *-*-mingw* | *-*-pw32*)
+   AC_CHECK_TOOL(DLLTOOL, dlltool, false)
+   AC_CHECK_TOOL(AS, as, false)
+   AC_CHECK_TOOL(OBJDUMP, objdump, false)
+   ;;
+   ])
+ esac
+ 
+ need_locks="$enable_libtool_lock"
+ 
+ ])# _LT_AC_LOCK
+ 
+ 
+ # AC_LIBTOOL_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
+ #		[OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE])
+ # ----------------------------------------------------------------
+ # Check whether the given compiler option works
+ AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION],
+ [AC_REQUIRE([LT_AC_PROG_SED])
+ AC_CACHE_CHECK([$1], [$2],
+   [$2=no
+   ifelse([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4])
+    printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+    lt_compiler_flag="$3"
+    # Insert the option either (1) after the last *FLAGS variable, or
+    # (2) before a word containing "conftest.", or (3) at the end.
+    # Note that $ac_compile itself does not contain backslashes and begins
+    # with a dollar sign (not a hyphen), so the echo should work correctly.
+    # The option is referenced via a variable to avoid confusing sed.
+    lt_compile=`echo "$ac_compile" | $SED \
+    -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
+    -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
+    -e 's:$: $lt_compiler_flag:'`
+    (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
+    (eval "$lt_compile" 2>conftest.err)
+    ac_status=$?
+    cat conftest.err >&AS_MESSAGE_LOG_FD
+    echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
+    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
+      if test ! -s conftest.err; then
+        $2=yes
+      fi
+    fi
+    $rm conftest*
+ ])
+ 
+ if test x"[$]$2" = xyes; then
+     ifelse([$5], , :, [$5])
+ else
+     ifelse([$6], , :, [$6])
+ fi
+ ])# AC_LIBTOOL_COMPILER_OPTION
+ 
+ 
+ # AC_LIBTOOL_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
+ #                          [ACTION-SUCCESS], [ACTION-FAILURE])
+ # ------------------------------------------------------------
+ # Check whether the given compiler option works
+ AC_DEFUN([AC_LIBTOOL_LINKER_OPTION],
+ [AC_CACHE_CHECK([$1], [$2],
+   [$2=no
+    save_LDFLAGS="$LDFLAGS"
+    LDFLAGS="$LDFLAGS $3"
+    printf "$lt_simple_link_test_code" > conftest.$ac_ext
+    if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+      # The compiler can only warn and ignore the option if not recognized
+      # So say no if there are warnings
+      if test -s conftest.err; then
+        # Append any errors to the config.log.
+        cat conftest.err 1>&AS_MESSAGE_LOG_FD
+      else
+        $2=yes
+      fi
+    fi
+    $rm conftest*
+    LDFLAGS="$save_LDFLAGS"
+ ])
+ 
+ if test x"[$]$2" = xyes; then
+     ifelse([$4], , :, [$4])
+ else
+     ifelse([$5], , :, [$5])
+ fi
+ ])# AC_LIBTOOL_LINKER_OPTION
+ 
+ 
+ # AC_LIBTOOL_SYS_MAX_CMD_LEN
+ # --------------------------
+ AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN],
+ [# find the maximum length of command line arguments
+ AC_MSG_CHECKING([the maximum length of command line arguments])
+ AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl
+   i=0
+   teststring="ABCD"
+ 
+   case $build_os in
+   msdosdjgpp*)
+     # On DJGPP, this test can blow up pretty badly due to problems in libc
+     # (any single argument exceeding 2000 bytes causes a buffer overrun
+     # during glob expansion).  Even if it were fixed, the result of this
+     # check would be larger than it should be.
+     lt_cv_sys_max_cmd_len=12288;    # 12K is about right
+     ;;
+ 
+   gnu*)
+     # Under GNU Hurd, this test is not required because there is
+     # no limit to the length of command line arguments.
+     # Libtool will interpret -1 as no limit whatsoever
+     lt_cv_sys_max_cmd_len=-1;
+     ;;
+ 
+   cygwin* | mingw*)
+     # On Win9x/ME, this test blows up -- it succeeds, but takes
+     # about 5 minutes as the teststring grows exponentially.
+     # Worse, since 9x/ME are not pre-emptively multitasking,
+     # you end up with a "frozen" computer, even though with patience
+     # the test eventually succeeds (with a max line length of 256k).
+     # Instead, let's just punt: use the minimum linelength reported by
+     # all of the supported platforms: 8192 (on NT/2K/XP).
+     lt_cv_sys_max_cmd_len=8192;
+     ;;
+ 
+   amigaos*)
+     # On AmigaOS with pdksh, this test takes hours, literally.
+     # So we just punt and use a minimum line length of 8192.
+     lt_cv_sys_max_cmd_len=8192;
+     ;;
+ 
+   netbsd* | freebsd* | openbsd* | darwin* )
+     # This has been around since 386BSD, at least.  Likely further.
+     if test -x /sbin/sysctl; then
+       lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
+     elif test -x /usr/sbin/sysctl; then
+       lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
+     else
+       lt_cv_sys_max_cmd_len=65536 # usable default for *BSD
+     fi
+     # And add a safety zone
+     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+     ;;
+ 
+  *)
+     # If test is not a shell built-in, we'll probably end up computing a
+     # maximum length that is only half of the actual maximum length, but
+     # we can't tell.
+     SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
+     while (test "X"`$SHELL [$]0 --fallback-echo "X$teststring" 2>/dev/null` \
+ 	       = "XX$teststring") >/dev/null 2>&1 &&
+ 	    new_result=`expr "X$teststring" : ".*" 2>&1` &&
+ 	    lt_cv_sys_max_cmd_len=$new_result &&
+ 	    test $i != 17 # 1/2 MB should be enough
+     do
+       i=`expr $i + 1`
+       teststring=$teststring$teststring
+     done
+     teststring=
+     # Add a significant safety factor because C++ compilers can tack on massive
+     # amounts of additional arguments before passing them to the linker.
+     # It appears as though 1/2 is a usable value.
+     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
+     ;;
+   esac
+ ])
+ if test -n $lt_cv_sys_max_cmd_len ; then
+   AC_MSG_RESULT($lt_cv_sys_max_cmd_len)
+ else
+   AC_MSG_RESULT(none)
+ fi
+ ])# AC_LIBTOOL_SYS_MAX_CMD_LEN
+ 
+ 
+ # _LT_AC_CHECK_DLFCN
+ # --------------------
+ AC_DEFUN([_LT_AC_CHECK_DLFCN],
+ [AC_CHECK_HEADERS(dlfcn.h)dnl
+ ])# _LT_AC_CHECK_DLFCN
+ 
+ 
+ # _LT_AC_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE,
+ #                           ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING)
+ # ------------------------------------------------------------------
+ AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF],
+ [AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl
+ if test "$cross_compiling" = yes; then :
+   [$4]
+ else
+   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
+   lt_status=$lt_dlunknown
+   cat > conftest.$ac_ext <
+ #endif
+ 
+ #include 
+ 
+ #ifdef RTLD_GLOBAL
+ #  define LT_DLGLOBAL		RTLD_GLOBAL
+ #else
+ #  ifdef DL_GLOBAL
+ #    define LT_DLGLOBAL		DL_GLOBAL
+ #  else
+ #    define LT_DLGLOBAL		0
+ #  endif
+ #endif
+ 
+ /* We may have to define LT_DLLAZY_OR_NOW in the command line if we
+    find out it does not work in some platform. */
+ #ifndef LT_DLLAZY_OR_NOW
+ #  ifdef RTLD_LAZY
+ #    define LT_DLLAZY_OR_NOW		RTLD_LAZY
+ #  else
+ #    ifdef DL_LAZY
+ #      define LT_DLLAZY_OR_NOW		DL_LAZY
+ #    else
+ #      ifdef RTLD_NOW
+ #        define LT_DLLAZY_OR_NOW	RTLD_NOW
+ #      else
+ #        ifdef DL_NOW
+ #          define LT_DLLAZY_OR_NOW	DL_NOW
+ #        else
+ #          define LT_DLLAZY_OR_NOW	0
+ #        endif
+ #      endif
+ #    endif
+ #  endif
+ #endif
+ 
+ #ifdef __cplusplus
+ extern "C" void exit (int);
+ #endif
+ 
+ void fnord() { int i=42;}
+ int main ()
+ {
+   void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
+   int status = $lt_dlunknown;
+ 
+   if (self)
+     {
+       if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
+       else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;
+       /* dlclose (self); */
+     }
+ 
+     exit (status);
+ }]
+ EOF
+   if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then
+     (./conftest; exit; ) 2>/dev/null
+     lt_status=$?
+     case x$lt_status in
+       x$lt_dlno_uscore) $1 ;;
+       x$lt_dlneed_uscore) $2 ;;
+       x$lt_unknown|x*) $3 ;;
+     esac
+   else :
+     # compilation failed
+     $3
+   fi
+ fi
+ rm -fr conftest*
+ ])# _LT_AC_TRY_DLOPEN_SELF
+ 
+ 
+ # AC_LIBTOOL_DLOPEN_SELF
+ # -------------------
+ AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF],
+ [AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl
+ if test "x$enable_dlopen" != xyes; then
+   enable_dlopen=unknown
+   enable_dlopen_self=unknown
+   enable_dlopen_self_static=unknown
+ else
+   lt_cv_dlopen=no
+   lt_cv_dlopen_libs=
+ 
+   case $host_os in
+   beos*)
+     lt_cv_dlopen="load_add_on"
+     lt_cv_dlopen_libs=
+     lt_cv_dlopen_self=yes
+     ;;
+ 
+   mingw* | pw32*)
+     lt_cv_dlopen="LoadLibrary"
+     lt_cv_dlopen_libs=
+    ;;
+ 
+   cygwin*)
+     lt_cv_dlopen="dlopen"