#ifdef LLVM_ON_WIN32
-#include "Win32/DynamicLibrary.cpp"
+#include "Win32/DynamicLibrary.inc"
#else
// Include the platform-specific parts of this class.
#ifdef LLVM_ON_UNIX
-#include "Unix/MappedFile.cpp"
+#include "Unix/MappedFile.inc"
#endif
#ifdef LLVM_ON_WIN32
-#include "Win32/MappedFile.cpp"
+#include "Win32/MappedFile.inc"
#endif
// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
// Include the platform-specific parts of this class.
#ifdef LLVM_ON_UNIX
-#include "Unix/Memory.cpp"
+#include "Unix/Memory.inc"
#endif
#ifdef LLVM_ON_WIN32
-#include "Win32/Memory.cpp"
+#include "Win32/Memory.inc"
#endif
// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
// Include the truly platform-specific parts of this class.
#if defined(LLVM_ON_UNIX)
-#include "Unix/Path.cpp"
+#include "Unix/Path.inc"
#endif
#if defined(LLVM_ON_WIN32)
-#include "Win32/Path.cpp"
+#include "Win32/Path.inc"
#endif
// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
// Include the platform-specific parts of this class.
#ifdef LLVM_ON_UNIX
-#include "Unix/Process.cpp"
+#include "Unix/Process.inc"
#endif
#ifdef LLVM_ON_WIN32
-#include "Win32/Process.cpp"
+#include "Win32/Process.inc"
#endif
// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
// Include the platform-specific parts of this class.
#ifdef LLVM_ON_UNIX
-#include "Unix/Program.cpp"
+#include "Unix/Program.inc"
#endif
#ifdef LLVM_ON_WIN32
-#include "Win32/Program.cpp"
+#include "Win32/Program.inc"
#endif
// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
// Include the platform-specific parts of this class.
#ifdef LLVM_ON_UNIX
-#include "Unix/Signals.cpp"
+#include "Unix/Signals.inc"
#endif
#ifdef LLVM_ON_WIN32
-#include "Win32/Signals.cpp"
+#include "Win32/Signals.inc"
#endif
// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
/// Include the platform specific portion of TimeValue class
#ifdef LLVM_ON_UNIX
-#include "Unix/TimeValue.cpp"
+#include "Unix/TimeValue.inc"
#endif
#ifdef LLVM_ON_WIN32
-#include "Win32/TimeValue.cpp"
+#include "Win32/TimeValue.inc"
#endif
// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
+++ /dev/null
-//===- Unix/MappedFile.cpp - Unix MappedFile Implementation -----*- 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 provides the generic Unix implementation of the MappedFile concept.
-//
-//===----------------------------------------------------------------------===//
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only generic UNIX code that
-//=== is guaranteed to work on *all* UNIX variants.
-//===----------------------------------------------------------------------===//
-
-#include "Unix.h"
-#include "llvm/System/Process.h"
-
-#ifdef HAVE_FCNTL_H
-#include <fcntl.h>
-#endif
-
-#ifdef HAVE_SYS_MMAN_H
-#include <sys/mman.h>
-#endif
-
-#ifdef HAVE_SYS_STAT_H
-#include <sys/stat.h>
-#endif
-
-namespace llvm {
-using namespace sys;
-
-struct sys::MappedFileInfo {
- int fd_;
- struct stat sbuf_;
-};
-
-void MappedFile::initialize() {
- if (path_.exists()) {
- info_ = new MappedFileInfo;
- int mode = 0;
- if (options_&READ_ACCESS)
- if (options_&WRITE_ACCESS)
- mode = O_RDWR;
- else
- mode = O_RDONLY;
- else if (options_&WRITE_ACCESS)
- mode = O_WRONLY;
- info_->fd_ = ::open(path_.c_str(),mode);
- if (info_->fd_ < 0) {
- delete info_;
- info_ = 0;
- ThrowErrno(std::string("Can't open file: ") + path_.toString());
- }
- struct stat sbuf;
- if(::fstat(info_->fd_, &info_->sbuf_) < 0) {
- ::close(info_->fd_);
- delete info_;
- info_ = 0;
- ThrowErrno(std::string("Can't stat file: ") + path_.toString());
- }
- } else {
- throw std::string("Can't open file: ") + path_.toString();
- }
-}
-
-void MappedFile::terminate() {
- assert(info_ && "MappedFile not initialized");
- if (info_->fd_ >= 0)
- ::close(info_->fd_);
- delete info_;
- info_ = 0;
-}
-
-void MappedFile::unmap() {
- assert(info_ && "MappedFile not initialized");
- if (isMapped()) {
- if (options_ & WRITE_ACCESS)
- ::msync(base_, info_->sbuf_.st_size, MS_SYNC);
- ::munmap(base_, info_->sbuf_.st_size);
- }
-}
-
-void* MappedFile::map() {
- assert(info_ && "MappedFile not initialized");
- if (!isMapped()) {
- int prot = PROT_NONE;
- int flags = 0;
-#ifdef MAP_FILE
- flags |= MAP_FILE;
-#endif
- if (options_ == 0) {
- prot = PROT_READ;
- flags = MAP_PRIVATE;
- } else {
- if (options_ & READ_ACCESS)
- prot |= PROT_READ;
- if (options_ & WRITE_ACCESS)
- prot |= PROT_WRITE;
- if (options_ & EXEC_ACCESS)
- prot |= PROT_EXEC;
- if (options_ & SHARED_MAPPING)
- flags |= MAP_SHARED;
- else
- flags |= MAP_PRIVATE;
- }
- size_t map_size = ((info_->sbuf_.st_size / Process::GetPageSize())+1) *
- Process::GetPageSize();
-
- base_ = ::mmap(0, map_size, prot, flags, info_->fd_, 0);
- if (base_ == MAP_FAILED)
- ThrowErrno(std::string("Can't map file:") + path_.toString());
- }
- return base_;
-}
-
-size_t MappedFile::size() const {
- assert(info_ && "MappedFile not initialized");
- return info_->sbuf_.st_size;
-}
-
-void MappedFile::size(size_t new_size) {
- assert(info_ && "MappedFile not initialized");
-
- // Take the mapping out of memory
- this->unmap();
-
- // Adjust the current size to a page boundary
- size_t cur_size = ((info_->sbuf_.st_size / Process::GetPageSize())+1) *
- Process::GetPageSize();
-
- // Adjust the new_size to a page boundary
- new_size = ((new_size / Process::GetPageSize())+1) *
- Process::GetPageSize();
-
- // If the file needs to be extended
- if (new_size > cur_size) {
- // Ensure we can allocate at least the idodes necessary to handle the
- // file size requested.
- ::lseek(info_->fd_, new_size, SEEK_SET);
- ::write(info_->fd_, "\0", 1);
- }
-
- // Seek to current end of file.
- this->map();
-}
-
-}
-
-// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
+++ /dev/null
-//===- Unix/Memory.cpp - Generic UNIX System Configuration ------*- 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 defines some functions for various memory management utilities.
-//
-//===----------------------------------------------------------------------===//
-
-#include "Unix.h"
-#include "llvm/System/Process.h"
-
-#ifdef HAVE_SYS_MMAN_H
-#include <sys/mman.h>
-#endif
-
-namespace llvm {
-
-/// AllocateRWXMemory - Allocate a slab of memory with read/write/execute
-/// permissions. This is typically used for JIT applications where we want
-/// to emit code to the memory then jump to it. Getting this type of memory
-/// is very OS specific.
-///
-MemoryBlock Memory::AllocateRWX(unsigned NumBytes) {
- if (NumBytes == 0) return MemoryBlock();
-
- long pageSize = Process::GetPageSize();
- unsigned NumPages = (NumBytes+pageSize-1)/pageSize;
-
- int fd = -1;
-#ifdef NEED_DEV_ZERO_FOR_MMAP
- static int zero_fd = open("/dev/zero", O_RDWR);
- if (zero_fd == -1) {
- ThrowErrno("Can't open /dev/zero device");
- }
- fd = zero_fd;
-#endif
-
- int flags = MAP_PRIVATE |
-#ifdef HAVE_MMAP_ANONYMOUS
- MAP_ANONYMOUS
-#else
- MAP_ANON
-#endif
- ;
- void *pa = ::mmap(0, pageSize*NumPages, PROT_READ|PROT_WRITE|PROT_EXEC,
- flags, fd, 0);
- if (pa == MAP_FAILED) {
- ThrowErrno("Can't allocate RWX Memory");
- }
- MemoryBlock result;
- result.Address = pa;
- result.Size = NumPages*pageSize;
- return result;
-}
-
-void Memory::ReleaseRWX(MemoryBlock& M) {
- if (M.Address == 0 || M.Size == 0) return;
- if (0 != ::munmap(M.Address, M.Size)) {
- ThrowErrno("Can't release RWX Memory");
- }
-}
-
-}
-
-// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
+++ /dev/null
-//===- llvm/System/Unix/Path.cpp - Unix Path Implementation -----*- 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 implements the Unix specific portion of the Path class.
-//
-//===----------------------------------------------------------------------===//
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only generic UNIX code that
-//=== is guaranteed to work on *all* UNIX variants.
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Config/alloca.h"
-#include "Unix.h"
-#if HAVE_SYS_STAT_H
-#include <sys/stat.h>
-#endif
-#if HAVE_FCNTL_H
-#include <fcntl.h>
-#endif
-#if HAVE_UTIME_H
-#include <utime.h>
-#endif
-#if HAVE_TIME_H
-#include <time.h>
-#endif
-#if HAVE_DIRENT_H
-# include <dirent.h>
-# define NAMLEN(dirent) strlen((dirent)->d_name)
-#else
-# define dirent direct
-# define NAMLEN(dirent) (dirent)->d_namlen
-# if HAVE_SYS_NDIR_H
-# include <sys/ndir.h>
-# endif
-# if HAVE_SYS_DIR_H
-# include <sys/dir.h>
-# endif
-# if HAVE_NDIR_H
-# include <ndir.h>
-# endif
-#endif
-
-
-namespace llvm {
-using namespace sys;
-
-Path::Path(const std::string& unverified_path) : path(unverified_path) {
- if (unverified_path.empty())
- return;
- if (this->isValid())
- return;
- // oops, not valid.
- path.clear();
- ThrowErrno(unverified_path + ": path is not valid");
-}
-
-bool
-Path::isValid() const {
- if (path.empty())
- return false;
- else if (path.length() >= MAXPATHLEN)
- return false;
-#if defined(HAVE_REALPATH)
- char pathname[MAXPATHLEN];
- if (0 == realpath(path.c_str(), pathname))
- if (errno != EACCES && errno != EIO && errno != ENOENT && errno != ENOTDIR)
- return false;
-#endif
- return true;
-}
-
-Path
-Path::GetRootDirectory() {
- Path result;
- result.setDirectory("/");
- return result;
-}
-
-Path
-Path::GetTemporaryDirectory() {
-#if defined(HAVE_MKDTEMP)
- // The best way is with mkdtemp but that's not available on many systems,
- // Linux and FreeBSD have it. Others probably won't.
- char pathname[MAXPATHLEN];
- strcpy(pathname,"/tmp/llvm_XXXXXX");
- if (0 == mkdtemp(pathname))
- ThrowErrno(std::string(pathname) + ": Can't create temporary directory");
- Path result;
- result.setDirectory(pathname);
- assert(result.isValid() && "mkdtemp didn't create a valid pathname!");
- return result;
-#elif defined(HAVE_MKSTEMP)
- // If no mkdtemp is available, mkstemp can be used to create a temporary file
- // which is then removed and created as a directory. We prefer this over
- // mktemp because of mktemp's inherent security and threading risks. We still
- // have a slight race condition from the time the temporary file is created to
- // the time it is re-created as a directoy.
- char pathname[MAXPATHLEN];
- strcpy(pathname, "/tmp/llvm_XXXXXX");
- int fd = 0;
- if (-1 == (fd = mkstemp(pathname)))
- ThrowErrno(std::string(pathname) + ": Can't create temporary directory");
- ::close(fd);
- ::unlink(pathname); // start race condition, ignore errors
- if (-1 == ::mkdir(pathname, S_IRWXU)) // end race condition
- ThrowErrno(std::string(pathname) + ": Can't create temporary directory");
- Path result;
- result.setDirectory(pathname);
- assert(result.isValid() && "mkstemp didn't create a valid pathname!");
- return result;
-#elif defined(HAVE_MKTEMP)
- // If a system doesn't have mkdtemp(3) or mkstemp(3) but it does have
- // mktemp(3) then we'll assume that system (e.g. AIX) has a reasonable
- // implementation of mktemp(3) and doesn't follow BSD 4.3's lead of replacing
- // the XXXXXX with the pid of the process and a letter. That leads to only
- // twenty six temporary files that can be generated.
- char pathname[MAXPATHLEN];
- strcpy(pathname, "/tmp/llvm_XXXXXX");
- char *TmpName = ::mktemp(pathname);
- if (TmpName == 0)
- throw std::string(TmpName) + ": Can't create unique directory name";
- if (-1 == ::mkdir(TmpName, S_IRWXU))
- ThrowErrno(std::string(TmpName) + ": Can't create temporary directory");
- Path result;
- result.setDirectory(TmpName);
- assert(result.isValid() && "mktemp didn't create a valid pathname!");
- return result;
-#else
- // This is the worst case implementation. tempnam(3) leaks memory unless its
- // on an SVID2 (or later) system. On BSD 4.3 it leaks. tmpnam(3) has thread
- // issues. The mktemp(3) function doesn't have enough variability in the
- // temporary name generated. So, we provide our own implementation that
- // increments an integer from a random number seeded by the current time. This
- // should be sufficiently unique that we don't have many collisions between
- // processes. Generally LLVM processes don't run very long and don't use very
- // many temporary files so this shouldn't be a big issue for LLVM.
- static time_t num = ::time(0);
- char pathname[MAXPATHLEN];
- do {
- num++;
- sprintf(pathname, "/tmp/llvm_%010u", unsigned(num));
- } while ( 0 == access(pathname, F_OK ) );
- if (-1 == ::mkdir(pathname, S_IRWXU))
- ThrowErrno(std::string(pathname) + ": Can't create temporary directory");
- Path result;
- result.setDirectory(pathname);
- assert(result.isValid() && "mkstemp didn't create a valid pathname!");
- return result;
-#endif
-}
-
-static void getPathList(const char*path, std::vector<sys::Path>& Paths) {
- const char* at = path;
- const char* delim = strchr(at, ':');
- Path tmpPath;
- while( delim != 0 ) {
- std::string tmp(at, size_t(delim-at));
- if (tmpPath.setDirectory(tmp))
- if (tmpPath.readable())
- Paths.push_back(tmpPath);
- at = delim + 1;
- delim = strchr(at, ':');
- }
- if (*at != 0)
- if (tmpPath.setDirectory(std::string(at)))
- if (tmpPath.readable())
- Paths.push_back(tmpPath);
-
-}
-
-void
-Path::GetSystemLibraryPaths(std::vector<sys::Path>& Paths) {
-#ifdef LTDL_SHLIBPATH_VAR
- char* env_var = getenv(LTDL_SHLIBPATH_VAR);
- if (env_var != 0) {
- getPathList(env_var,Paths);
- }
-#endif
- // FIXME: Should this look at LD_LIBRARY_PATH too?
- Paths.push_back(sys::Path("/usr/local/lib/"));
- Paths.push_back(sys::Path("/usr/X11R6/lib/"));
- Paths.push_back(sys::Path("/usr/lib/"));
- Paths.push_back(sys::Path("/lib/"));
-}
-
-void
-Path::GetBytecodeLibraryPaths(std::vector<sys::Path>& Paths) {
- char * env_var = getenv("LLVM_LIB_SEARCH_PATH");
- if (env_var != 0) {
- getPathList(env_var,Paths);
- }
-#ifdef LLVM_LIBDIR
- {
- Path tmpPath;
- if (tmpPath.setDirectory(LLVM_LIBDIR))
- if (tmpPath.readable())
- Paths.push_back(tmpPath);
- }
-#endif
- GetSystemLibraryPaths(Paths);
-}
-
-Path
-Path::GetLLVMDefaultConfigDir() {
- return Path("/etc/llvm/");
-}
-
-Path
-Path::GetUserHomeDirectory() {
- const char* home = getenv("HOME");
- if (home) {
- Path result;
- if (result.setDirectory(home))
- return result;
- }
- return GetRootDirectory();
-}
-
-bool
-Path::isFile() const {
- return (isValid() && path[path.length()-1] != '/');
-}
-
-bool
-Path::isDirectory() const {
- return (isValid() && path[path.length()-1] == '/');
-}
-
-std::string
-Path::getBasename() 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::hasMagicNumber(const std::string &Magic) const {
- size_t len = Magic.size();
- assert(len < 1024 && "Request for magic string too long");
- char* buf = (char*) alloca(1 + len);
- int fd = ::open(path.c_str(),O_RDONLY);
- if (fd < 0)
- return false;
- size_t read_len = ::read(fd, buf, len);
- close(fd);
- if (len != read_len)
- return false;
- buf[len] = '\0';
- return Magic == buf;
-}
-
-bool Path::getMagicNumber(std::string& Magic, unsigned len) const {
- if (!isFile())
- return false;
- assert(len < 1024 && "Request for magic string too long");
- char* buf = (char*) alloca(1 + len);
- int fd = ::open(path.c_str(),O_RDONLY);
- if (fd < 0)
- return false;
- ssize_t bytes_read = ::read(fd, buf, len);
- ::close(fd);
- if (ssize_t(len) != bytes_read) {
- Magic.clear();
- return false;
- }
- Magic.assign(buf,len);
- return true;
-}
-
-bool
-Path::isBytecodeFile() const {
- char buffer[ 4];
- buffer[0] = 0;
- int fd = ::open(path.c_str(),O_RDONLY);
- if (fd < 0)
- return false;
- ssize_t bytes_read = ::read(fd, buffer, 4);
- ::close(fd);
- if (4 != bytes_read)
- return false;
-
- return (buffer[0] == 'l' && buffer[1] == 'l' && buffer[2] == 'v' &&
- (buffer[3] == 'c' || buffer[3] == 'm'));
-}
-
-bool
-Path::exists() const {
- return 0 == access(path.c_str(), F_OK );
-}
-
-bool
-Path::readable() const {
- return 0 == access(path.c_str(), F_OK | R_OK );
-}
-
-bool
-Path::writable() const {
- return 0 == access(path.c_str(), F_OK | W_OK );
-}
-
-bool
-Path::executable() const {
- return 0 == access(path.c_str(), R_OK | X_OK );
-}
-
-std::string
-Path::getLast() const {
- // Find the last slash
- size_t pos = path.rfind('/');
-
- // Handle the corner cases
- if (pos == std::string::npos)
- return path;
-
- // If the last character is a slash
- if (pos == path.length()-1) {
- // Find the second to last slash
- size_t pos2 = path.rfind('/', pos-1);
- if (pos2 == std::string::npos)
- return path.substr(0,pos);
- else
- return path.substr(pos2+1,pos-pos2-1);
- }
- // Return everything after the last slash
- return path.substr(pos+1);
-}
-
-void
-Path::getStatusInfo(StatusInfo& info) const {
- struct stat buf;
- if (0 != stat(path.c_str(), &buf)) {
- ThrowErrno(std::string("Can't get status: ")+path);
- }
- info.fileSize = buf.st_size;
- info.modTime.fromEpochTime(buf.st_mtime);
- info.mode = buf.st_mode;
- info.user = buf.st_uid;
- info.group = buf.st_gid;
- info.isDir = S_ISDIR(buf.st_mode);
- if (info.isDir && path[path.length()-1] != '/')
- path += '/';
-}
-
-static bool AddPermissionBits(const std::string& Filename, int bits) {
- // Get the umask value from the operating system. We want to use it
- // when changing the file's permissions. Since calling umask() sets
- // the umask and returns its old value, we must call it a second
- // time to reset it to the user's preference.
- int mask = umask(0777); // The arg. to umask is arbitrary.
- umask(mask); // Restore the umask.
-
- // Get the file's current mode.
- struct stat st;
- if ((stat(Filename.c_str(), &st)) == -1)
- return false;
-
- // Change the file to have whichever permissions bits from 'bits'
- // that the umask would not disable.
- if ((chmod(Filename.c_str(), (st.st_mode | (bits & ~mask)))) == -1)
- return false;
-
- return true;
-}
-
-void Path::makeReadable() {
- if (!AddPermissionBits(path,0444))
- ThrowErrno(path + ": can't make file readable");
-}
-
-void Path::makeWriteable() {
- if (!AddPermissionBits(path,0222))
- ThrowErrno(path + ": can't make file writable");
-}
-
-void Path::makeExecutable() {
- if (!AddPermissionBits(path,0111))
- ThrowErrno(path + ": can't make file executable");
-}
-
-bool
-Path::getDirectoryContents(std::set<Path>& result) const {
- if (!isDirectory())
- return false;
- DIR* direntries = ::opendir(path.c_str());
- if (direntries == 0)
- ThrowErrno(path + ": can't open directory");
-
- result.clear();
- struct dirent* de = ::readdir(direntries);
- while (de != 0) {
- if (de->d_name[0] != '.') {
- Path aPath(path + (const char*)de->d_name);
- struct stat buf;
- if (0 != stat(aPath.path.c_str(), &buf))
- ThrowErrno(aPath.path + ": can't get status");
- if (S_ISDIR(buf.st_mode))
- aPath.path += "/";
- result.insert(aPath);
- }
- de = ::readdir(direntries);
- }
-
- closedir(direntries);
- return true;
-}
-
-bool
-Path::setDirectory(const std::string& a_path) {
- if (a_path.size() == 0)
- return false;
- Path save(*this);
- path = a_path;
- size_t last = a_path.size() -1;
- if (a_path[last] != '/')
- path += '/';
- if (!isValid()) {
- path = save.path;
- return false;
- }
- return true;
-}
-
-bool
-Path::setFile(const std::string& a_path) {
- if (a_path.size() == 0)
- return false;
- Path save(*this);
- path = a_path;
- size_t last = a_path.size() - 1;
- while (last > 0 && a_path[last] == '/')
- last--;
- path.erase(last+1);
- if (!isValid()) {
- path = save.path;
- return false;
- }
- return true;
-}
-
-bool
-Path::appendDirectory(const std::string& dir) {
- if (isFile())
- return false;
- Path save(*this);
- path += dir;
- path += "/";
- if (!isValid()) {
- path = save.path;
- return false;
- }
- return true;
-}
-
-bool
-Path::elideDirectory() {
- if (isFile())
- return false;
- size_t slashpos = path.rfind('/',path.size());
- if (slashpos == 0 || slashpos == std::string::npos)
- return false;
- if (slashpos == path.size() - 1)
- slashpos = path.rfind('/',slashpos-1);
- if (slashpos == std::string::npos)
- return false;
- path.erase(slashpos);
- return true;
-}
-
-bool
-Path::appendFile(const std::string& file) {
- if (!isDirectory())
- return false;
- Path save(*this);
- path += file;
- if (!isValid()) {
- path = save.path;
- return false;
- }
- return true;
-}
-
-bool
-Path::elideFile() {
- if (isDirectory())
- return false;
- size_t slashpos = path.rfind('/',path.size());
- if (slashpos == std::string::npos)
- return false;
- path.erase(slashpos+1);
- return true;
-}
-
-bool
-Path::appendSuffix(const std::string& suffix) {
- if (isDirectory())
- return false;
- Path save(*this);
- path.append(".");
- path.append(suffix);
- if (!isValid()) {
- path = save.path;
- return false;
- }
- return true;
-}
-
-bool
-Path::elideSuffix() {
- if (isDirectory()) return false;
- size_t dotpos = path.rfind('.',path.size());
- size_t slashpos = path.rfind('/',path.size());
- if (slashpos != std::string::npos && dotpos != std::string::npos &&
- dotpos > slashpos) {
- path.erase(dotpos, path.size()-dotpos);
- return true;
- }
- return false;
-}
-
-
-bool
-Path::createDirectory( bool create_parents) {
- // Make sure we're dealing with a directory
- if (!isDirectory()) return false;
-
- // Get a writeable copy of the path name
- char pathname[MAXPATHLEN];
- path.copy(pathname,MAXPATHLEN);
-
- // Null-terminate the last component
- int lastchar = path.length() - 1 ;
- if (pathname[lastchar] == '/')
- pathname[lastchar] = 0;
- else
- pathname[lastchar+1] = 0;
-
- // If we're supposed to create intermediate directories
- if ( create_parents ) {
- // Find the end of the initial name component
- char * next = strchr(pathname,'/');
- if ( pathname[0] == '/')
- next = strchr(&pathname[1],'/');
-
- // 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, S_IRWXU | S_IRWXG))
- ThrowErrno(std::string(pathname) + ": Can't create directory");
- char* save = next;
- next = strchr(next+1,'/');
- *save = '/';
- }
- }
-
- if (0 != access(pathname, F_OK | R_OK))
- if (0 != mkdir(pathname, S_IRWXU | S_IRWXG))
- ThrowErrno(std::string(pathname) + ": Can't create directory");
- return true;
-}
-
-bool
-Path::createFile() {
- // Make sure we're dealing with a file
- if (!isFile()) return false;
-
- // Create the file
- int fd = ::creat(path.c_str(), S_IRUSR | S_IWUSR);
- if (fd < 0)
- ThrowErrno(path + ": Can't create file");
- ::close(fd);
-
- return true;
-}
-
-bool
-Path::createTemporaryFile(bool reuse_current) {
- // Make sure we're dealing with a file
- if (!isFile())
- return false;
-
- // Make this into a unique file name
- makeUnique( reuse_current );
-
- // create the file
- int outFile = ::open(path.c_str(), O_WRONLY|O_CREAT|O_TRUNC, 0666);
- if (outFile != -1) {
- ::close(outFile);
- return true;
- }
- return false;
-}
-
-bool
-Path::destroyDirectory(bool remove_contents) const {
- // Make sure we're dealing with a directory
- if (!isDirectory()) return false;
-
- // If it doesn't exist, we're done.
- if (!exists()) return true;
-
- if (remove_contents) {
- // Recursively descend the directory to remove its content
- std::string cmd("/bin/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;
- else
- pathname[lastchar+1] = 0;
- if ( 0 != rmdir(pathname))
- ThrowErrno(std::string(pathname) + ": Can't destroy directory");
- }
- return true;
-}
-
-bool
-Path::destroyFile() const {
- if (!isFile()) return false;
- if (0 != unlink(path.c_str()))
- ThrowErrno(path + ": Can't destroy file");
- return true;
-}
-
-bool
-Path::renameFile(const Path& newName) {
- if (!isFile()) return false;
- if (0 != rename(path.c_str(), newName.c_str()))
- ThrowErrno(std::string("can't rename ") + path + " as " +
- newName.toString());
- return true;
-}
-
-bool
-Path::setStatusInfo(const StatusInfo& si) const {
- if (!isFile()) return false;
- struct utimbuf utb;
- utb.actime = si.modTime.toPosixTime();
- utb.modtime = utb.actime;
- if (0 != ::utime(path.c_str(),&utb))
- ThrowErrno(path + ": can't set file modification time");
- if (0 != ::chmod(path.c_str(),si.mode))
- ThrowErrno(path + ": can't set mode");
- return true;
-}
-
-void
-sys::CopyFile(const sys::Path &Dest, const sys::Path &Src) {
- int inFile = -1;
- int outFile = -1;
- try {
- inFile = ::open(Src.c_str(), O_RDONLY);
- if (inFile == -1)
- ThrowErrno("Cannnot open source file to copy: " + Src.toString());
-
- outFile = ::open(Dest.c_str(), O_WRONLY|O_CREAT, 0666);
- if (outFile == -1)
- ThrowErrno("Cannnot create destination file for copy: " +Dest.toString());
-
- char Buffer[16*1024];
- while (ssize_t Amt = ::read(inFile, Buffer, 16*1024)) {
- if (Amt == -1) {
- if (errno != EINTR && errno != EAGAIN)
- ThrowErrno("Can't read source file: " + Src.toString());
- } else {
- char *BufPtr = Buffer;
- while (Amt) {
- ssize_t AmtWritten = ::write(outFile, BufPtr, Amt);
- if (AmtWritten == -1) {
- if (errno != EINTR && errno != EAGAIN)
- ThrowErrno("Can't write destination file: " + Dest.toString());
- } else {
- Amt -= AmtWritten;
- BufPtr += AmtWritten;
- }
- }
- }
- }
- ::close(inFile);
- ::close(outFile);
- } catch (...) {
- if (inFile != -1)
- ::close(inFile);
- if (outFile != -1)
- ::close(outFile);
- throw;
- }
-}
-
-void
-Path::makeUnique(bool reuse_current) {
- if (reuse_current && !exists())
- return; // File doesn't exist already, just use it!
-
- // Append an XXXXXX pattern to the end of the file for use with mkstemp,
- // mktemp or our own implementation.
- char *FNBuffer = (char*) alloca(path.size()+8);
- path.copy(FNBuffer,path.size());
- strcpy(FNBuffer+path.size(), "-XXXXXX");
-
-#if defined(HAVE_MKSTEMP)
- int TempFD;
- if ((TempFD = mkstemp(FNBuffer)) == -1) {
- ThrowErrno("Cannot make unique filename for '" + path + "'");
- }
-
- // We don't need to hold the temp file descriptor... we will trust that no one
- // will overwrite/delete the file before we can open it again.
- close(TempFD);
-
- // Save the name
- path = FNBuffer;
-#elif defined(HAVE_MKTEMP)
- // If we don't have mkstemp, use the old and obsolete mktemp function.
- if (mktemp(FNBuffer) == 0) {
- ThrowErrno("Cannot make unique filename for '" + path + "'");
- }
-
- // Save the name
- path = FNBuffer;
-#else
- // Okay, looks like we have to do it all by our lonesome.
- static unsigned FCounter = 0;
- unsigned offset = path.size() + 1;
- while ( FCounter < 999999 && exists()) {
- sprintf(FNBuffer+offset,"%06u",++FCounter);
- path = FNBuffer;
- }
- if (FCounter > 999999)
- throw std::string("Cannot make unique filename for '" + path + "'");
-#endif
-
-}
-}
-
-// vim: sw=2
+++ /dev/null
-//===- Unix/Process.cpp - Unix Process Implementation --------- -*- 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 provides the generic Unix implementation of the Process class.
-//
-//===----------------------------------------------------------------------===//
-
-#include "Unix.h"
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-#ifdef HAVE_SYS_RESOURCE_H
-#include <sys/resource.h>
-#endif
-#ifdef HAVE_MALLOC_H
-#include <malloc.h>
-#endif
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only generic UNIX code that
-//=== is guaranteed to work on *all* UNIX variants.
-//===----------------------------------------------------------------------===//
-
-namespace llvm {
-using namespace sys;
-
-unsigned
-Process::GetPageSize()
-{
-#if defined(HAVE_GETPAGESIZE)
- static const int page_size = ::getpagesize();
-#elif defined(HAVE_SYSCONF)
- static long page_size = ::sysconf(_SC_PAGE_SIZE);
-#else
-#warning Cannot get the page size on this machine
-#endif
- return static_cast<unsigned>(page_size);
-}
-
-#if defined(HAVE_SBRK)
-static char* som = reinterpret_cast<char*>(::sbrk(0));
-#endif
-
-size_t
-Process::GetMallocUsage()
-{
-#if defined(HAVE_MALLINFO)
- struct mallinfo mi;
- mi = ::mallinfo();
- return mi.uordblks;
-#elif defined(HAVE_SBRK)
- // Note this is only an approximation and more closely resembles
- // the value returned by mallinfo in the arena field.
- char * eom = (char*) sbrk(0);
- if (eom != ((char*)-1) && som != ((char*)-1))
- return eom - som;
- else
- return 0;
-#else
-#warning Cannot get malloc info on this platform
- return 0;
-#endif
-}
-
-size_t
-Process::GetTotalMemoryUsage()
-{
-#if defined(HAVE_MALLINFO)
- struct mallinfo mi = ::mallinfo();
- return mi.uordblks + mi.hblkhd;
-#elif defined(HAVE_GETRUSAGE)
- struct rusage usage;
- ::getrusage(RUSAGE_SELF, &usage);
- return usage.ru_maxrss;
-#else
-#warning Cannot get total memory size on this platform
- return 0;
-#endif
-}
-
-void
-Process::GetTimeUsage(TimeValue& elapsed, TimeValue& user_time,
- TimeValue& sys_time)
-{
- elapsed = TimeValue::now();
-#if defined(HAVE_GETRUSAGE)
- struct rusage usage;
- ::getrusage(RUSAGE_SELF, &usage);
- user_time = TimeValue(
- static_cast<TimeValue::SecondsType>( usage.ru_utime.tv_sec ),
- static_cast<TimeValue::NanoSecondsType>( usage.ru_utime.tv_usec *
- TimeValue::NANOSECONDS_PER_MICROSECOND ) );
- sys_time = TimeValue(
- static_cast<TimeValue::SecondsType>( usage.ru_stime.tv_sec ),
- static_cast<TimeValue::NanoSecondsType>( usage.ru_stime.tv_usec *
- TimeValue::NANOSECONDS_PER_MICROSECOND ) );
-#else
-#warning Cannot get usage times on this platform
- user_time.seconds(0);
- user_time.microseconds(0);
- sys_time.seconds(0);
- sys_time.microseconds(0);
-#endif
-}
-
-// Some LLVM programs such as bugpoint produce core files as a normal part of
-// their operation. To prevent the disk from filling up, this function
-// does what's necessary to prevent their generation.
-void Process::PreventCoreFiles() {
-#if HAVE_SETRLIMIT
- struct rlimit rlim;
- rlim.rlim_cur = rlim.rlim_max = 0;
- int res = setrlimit(RLIMIT_CORE, &rlim);
- if (res != 0)
- ThrowErrno("Can't prevent core file generation");
-#endif
-}
-
-bool Process::StandardInIsUserInput() {
-#if HAVE_ISATTY
- return isatty(0);
-#endif
- // If we don't have isatty, just return false.
- return false;
-}
-
-bool Process::StandardOutIsDisplayed() {
-#if HAVE_ISATTY
- return isatty(1);
-#endif
- // If we don't have isatty, just return false.
- return false;
-}
-
-bool Process::StandardErrIsDisplayed() {
-#if HAVE_ISATTY
- return isatty(2);
-#endif
- // If we don't have isatty, just return false.
- return false;
-}
-
-}
-// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
+++ /dev/null
-//===- llvm/System/Unix/Program.cpp -----------------------------*- 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 implements the Unix specific portion of the Program class.
-//
-//===----------------------------------------------------------------------===//
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only generic UNIX code that
-//=== is guaranteed to work on *all* UNIX variants.
-//===----------------------------------------------------------------------===//
-
-#include <llvm/Config/config.h>
-#include "Unix.h"
-#include <iostream>
-#if HAVE_SYS_STAT_H
-#include <sys/stat.h>
-#endif
-#if HAVE_SIGNAL_H
-#include <signal.h>
-#endif
-#if HAVE_FCNTL_H
-#include <fcntl.h>
-#endif
-
-extern char** environ;
-
-namespace llvm {
-using namespace sys;
-
-// This function just uses the PATH environment variable to find the program.
-Path
-Program::FindProgramByName(const std::string& progName) {
-
- // Check some degenerate cases
- if (progName.length() == 0) // no program
- return Path();
- Path temp;
- if (!temp.setFile(progName)) // invalid name
- return Path();
- if (temp.executable()) // already executable as is
- return temp;
-
- // At this point, the file name is valid and its not executable
-
- // Get the path. If its empty, we can't do anything to find it.
- const char *PathStr = getenv("PATH");
- if (PathStr == 0)
- return Path();
-
- // Now we have a colon separated list of directories to search; try them.
- unsigned PathLen = strlen(PathStr);
- while (PathLen) {
- // Find the first colon...
- const char *Colon = std::find(PathStr, PathStr+PathLen, ':');
-
- // Check to see if this first directory contains the executable...
- Path FilePath;
- if (FilePath.setDirectory(std::string(PathStr,Colon))) {
- FilePath.appendFile(progName);
- if (FilePath.executable())
- return FilePath; // Found the executable!
- }
-
- // Nope it wasn't in this directory, check the next path in the list!
- PathLen -= Colon-PathStr;
- PathStr = Colon;
-
- // Advance past duplicate colons
- while (*PathStr == ':') {
- PathStr++;
- PathLen--;
- }
- }
- return Path();
-}
-
-static void RedirectFD(const std::string &File, int FD) {
- if (File.empty()) return; // Noop
-
- // Open the file
- int InFD = open(File.c_str(), FD == 0 ? O_RDONLY : O_WRONLY|O_CREAT, 0666);
- if (InFD == -1) {
- ThrowErrno("Cannot open file '" + File + "' for "
- + (FD == 0 ? "input" : "output") + "!\n");
- }
-
- dup2(InFD, FD); // Install it as the requested FD
- close(InFD); // Close the original FD
-}
-
-static bool Timeout = false;
-static void TimeOutHandler(int Sig) {
- Timeout = true;
-}
-
-int
-Program::ExecuteAndWait(const Path& path,
- const char** args,
- const char** envp,
- const Path** redirects,
- unsigned secondsToWait
-) {
- if (!path.executable())
- throw path.toString() + " is not executable";
-
-#ifdef HAVE_SYS_WAIT_H
- // Create a child process.
- int child = fork();
- switch (child) {
- // An error occured: Return to the caller.
- case -1:
- ThrowErrno(std::string("Couldn't execute program '") + path.toString() +
- "'");
- break;
-
- // Child process: Execute the program.
- case 0: {
- // Redirect file descriptors...
- if (redirects) {
- if (redirects[0])
- if (redirects[0]->isEmpty())
- RedirectFD("/dev/null",0);
- else
- RedirectFD(redirects[0]->toString(), 0);
- if (redirects[1])
- if (redirects[1]->isEmpty())
- RedirectFD("/dev/null",1);
- else
- RedirectFD(redirects[1]->toString(), 1);
- if (redirects[1] && redirects[2] &&
- *(redirects[1]) != *(redirects[2])) {
- if (redirects[2]->isEmpty())
- RedirectFD("/dev/null",2);
- else
- RedirectFD(redirects[2]->toString(), 2);
- } else {
- dup2(1, 2);
- }
- }
-
- // Set up the environment
- char** env = environ;
- if (envp != 0)
- env = (char**) envp;
-
- // Execute!
- execve (path.c_str(), (char** const)args, env);
- // If the execve() failed, we should exit and let the parent pick up
- // our non-zero exit status.
- exit (errno);
- }
-
- // Parent process: Break out of the switch to do our processing.
- default:
- break;
- }
-
- // Make sure stderr and stdout have been flushed
- std::cerr << std::flush;
- std::cout << std::flush;
- fsync(1);
- fsync(2);
-
- struct sigaction Act, Old;
-
- // Install a timeout handler.
- if (secondsToWait) {
- Timeout = false;
- Act.sa_sigaction = 0;
- Act.sa_handler = TimeOutHandler;
- sigemptyset(&Act.sa_mask);
- Act.sa_flags = 0;
- sigaction(SIGALRM, &Act, &Old);
- alarm(secondsToWait);
- }
-
- // Parent process: Wait for the child process to terminate.
- int status;
- while (wait(&status) != child)
- if (secondsToWait && errno == EINTR) {
- // Kill the child.
- kill(child, SIGKILL);
-
- // Turn off the alarm and restore the signal handler
- alarm(0);
- sigaction(SIGALRM, &Old, 0);
-
- // Wait for child to die
- if (wait(&status) != child)
- ThrowErrno("Child timedout but wouldn't die");
-
- return -1; // Timeout detected
- } else {
- ThrowErrno("Error waiting for child process");
- }
-
- // We exited normally without timeout, so turn off the timer.
- if (secondsToWait) {
- alarm(0);
- sigaction(SIGALRM, &Old, 0);
- }
-
- // If the program exited normally with a zero exit status, return success!
- if (WIFEXITED (status))
- return WEXITSTATUS(status);
- else if (WIFSIGNALED(status))
- throw std::string("Program '") + path.toString() +
- "' received terminating signal.";
-
-#else
- throw std::string(
- "Program::ExecuteAndWait not implemented on this platform!\n");
-#endif
- return 0;
-}
-
-}
-// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
+++ /dev/null
-//===- Signals.cpp - Generic Unix Signals Implementation -----*- 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 some helpful functions for dealing with the possibility of
-// Unix signals occuring while your program is running.
-//
-//===----------------------------------------------------------------------===//
-
-#include "Unix.h"
-#include <vector>
-#include <algorithm>
-#if HAVE_EXECINFO_H
-# include <execinfo.h> // For backtrace().
-#endif
-#if HAVE_SIGNAL_H
-#include <signal.h>
-#endif
-
-namespace {
-
-std::vector<std::string> *FilesToRemove = 0 ;
-std::vector<llvm::sys::Path> *DirectoriesToRemove = 0;
-
-// IntSigs - Signals that may interrupt the program at any time.
-const int IntSigs[] = {
- SIGHUP, SIGINT, SIGQUIT, SIGPIPE, SIGTERM, SIGUSR1, SIGUSR2
-};
-const int *IntSigsEnd = IntSigs + sizeof(IntSigs)/sizeof(IntSigs[0]);
-
-// KillSigs - Signals that are synchronous with the program that will cause it
-// to die.
-const int KillSigs[] = {
- SIGILL, SIGTRAP, SIGABRT, SIGFPE, SIGBUS, SIGSEGV, SIGSYS, SIGXCPU, SIGXFSZ
-#ifdef SIGEMT
- , SIGEMT
-#endif
-};
-const int *KillSigsEnd = KillSigs + sizeof(KillSigs)/sizeof(KillSigs[0]);
-
-#ifdef HAVE_BACKTRACE
-void* StackTrace[256];
-#endif
-
-// PrintStackTrace - In the case of a program crash or fault, print out a stack
-// trace so that the user has an indication of why and where we died.
-//
-// On glibc systems we have the 'backtrace' function, which works nicely, but
-// doesn't demangle symbols. In order to backtrace symbols, we fork and exec a
-// 'c++filt' process to do the demangling. This seems like the simplest and
-// most robust solution when we can't allocate memory (such as in a signal
-// handler). If we can't find 'c++filt', we fallback to printing mangled names.
-//
-void PrintStackTrace() {
-#ifdef HAVE_BACKTRACE
- // Use backtrace() to output a backtrace on Linux systems with glibc.
- int depth = backtrace(StackTrace, sizeof(StackTrace)/sizeof(StackTrace[0]));
-
- // Create a one-way unix pipe. The backtracing process writes to PipeFDs[1],
- // the c++filt process reads from PipeFDs[0].
- int PipeFDs[2];
- if (pipe(PipeFDs)) {
- backtrace_symbols_fd(StackTrace, depth, STDERR_FILENO);
- return;
- }
-
- switch (pid_t ChildPID = fork()) {
- case -1: // Error forking, print mangled stack trace
- close(PipeFDs[0]);
- close(PipeFDs[1]);
- backtrace_symbols_fd(StackTrace, depth, STDERR_FILENO);
- return;
- default: // backtracing process
- close(PipeFDs[0]); // Close the reader side.
-
- // Print the mangled backtrace into the pipe.
- backtrace_symbols_fd(StackTrace, depth, PipeFDs[1]);
- close(PipeFDs[1]); // We are done writing.
- while (waitpid(ChildPID, 0, 0) == -1)
- if (errno != EINTR) break;
- return;
-
- case 0: // c++filt process
- close(PipeFDs[1]); // Close the writer side.
- dup2(PipeFDs[0], 0); // Read from standard input
- close(PipeFDs[0]); // Close the old descriptor
- dup2(2, 1); // Revector stdout -> stderr
-
- // Try to run c++filt or gc++filt. If neither is found, call back on 'cat'
- // to print the mangled stack trace. If we can't find cat, just exit.
- execlp("c++filt", "c++filt", 0);
- execlp("gc++filt", "gc++filt", 0);
- execlp("cat", "cat", 0);
- execlp("/bin/cat", "cat", 0);
- exit(0);
- }
-#endif
-}
-
-// SignalHandler - The signal handler that runs...
-RETSIGTYPE SignalHandler(int Sig) {
- if (FilesToRemove != 0)
- while (!FilesToRemove->empty()) {
- std::remove(FilesToRemove->back().c_str());
- FilesToRemove->pop_back();
- }
-
- if (DirectoriesToRemove != 0)
- while (!DirectoriesToRemove->empty()) {
- DirectoriesToRemove->back().destroyDirectory(true);
- DirectoriesToRemove->pop_back();
- }
-
- if (std::find(IntSigs, IntSigsEnd, Sig) != IntSigsEnd)
- exit(1); // If this is an interrupt signal, exit the program
-
- // Otherwise if it is a fault (like SEGV) output the stacktrace to
- // STDERR (if we can) and reissue the signal to die...
- PrintStackTrace();
- signal(Sig, SIG_DFL);
-}
-
-// Just call signal
-void RegisterHandler(int Signal) {
- signal(Signal, SignalHandler);
-}
-
-}
-
-namespace llvm {
-
-// RemoveFileOnSignal - The public API
-void sys::RemoveFileOnSignal(const sys::Path &Filename) {
- if (FilesToRemove == 0)
- FilesToRemove = new std::vector<std::string>;
-
- FilesToRemove->push_back(Filename.toString());
-
- std::for_each(IntSigs, IntSigsEnd, RegisterHandler);
- std::for_each(KillSigs, KillSigsEnd, RegisterHandler);
-}
-
-// RemoveDirectoryOnSignal - The public API
-void sys::RemoveDirectoryOnSignal(const llvm::sys::Path& path) {
- if (!path.isDirectory())
- return;
-
- if (DirectoriesToRemove == 0)
- DirectoriesToRemove = new std::vector<sys::Path>;
-
- DirectoriesToRemove->push_back(path);
-
- std::for_each(IntSigs, IntSigsEnd, RegisterHandler);
- std::for_each(KillSigs, KillSigsEnd, RegisterHandler);
-}
-
-/// PrintStackTraceOnErrorSignal - When an error signal (such as SIBABRT or
-/// SIGSEGV) is delivered to the process, print a stack trace and then exit.
-void sys::PrintStackTraceOnErrorSignal() {
- std::for_each(KillSigs, KillSigsEnd, RegisterHandler);
-}
-
-}
-
-// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
+++ /dev/null
-//===- Unix/TimeValue.cpp - Unix TimeValue Implementation -------*- 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 implements the Unix specific portion of the TimeValue class.
-//
-//===----------------------------------------------------------------------===//
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only generic UNIX code that
-//=== is guaranteed to work on *all* UNIX variants.
-//===----------------------------------------------------------------------===//
-
-#include "Unix.h"
-
-namespace llvm {
- using namespace sys;
-
-std::string TimeValue::toString() const {
- char buffer[32];
-
- time_t ourTime = time_t(this->toEpochTime());
- ::asctime_r(::localtime(&ourTime), buffer);
-
- std::string result(buffer);
- return result.substr(0,24);
-}
-
-TimeValue TimeValue::now() {
- struct timeval the_time;
- timerclear(&the_time);
- if (0 != ::gettimeofday(&the_time,0))
- ThrowErrno("Couldn't obtain time of day");
-
- return TimeValue(
- static_cast<TimeValue::SecondsType>( the_time.tv_sec ),
- static_cast<TimeValue::NanoSecondsType>( the_time.tv_usec *
- NANOSECONDS_PER_MICROSECOND ) );
-}
-
-}
-// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
+++ /dev/null
-//===- Win32/DynamicLibrary.cpp - Win32 DL Implementation -------*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file was developed by Jeff Cohen and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file provides the Win32 specific implementation of DynamicLibrary.
-//
-//===----------------------------------------------------------------------===//
-
-#include "Win32.h"
-
-#ifdef __MINGW
-#include <imagehlp.h>
-#else
-#include <dbghelp.h>
-#endif
-
-#pragma comment(lib, "dbghelp.lib")
-
-namespace llvm {
-using namespace sys;
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only Win32 specific code
-//=== and must not be UNIX code.
-//===----------------------------------------------------------------------===//
-
-static std::vector<HMODULE> OpenedHandles;
-
-extern "C" {
- static BOOL CALLBACK ELM_Callback(PSTR ModuleName,
- ULONG ModuleBase,
- ULONG ModuleSize,
- PVOID UserContext)
- {
- // Ignore VC++ runtimes prior to 7.1. Somehow some of them get loaded
- // into the process.
- if (stricmp(ModuleName, "msvci70") != 0 &&
- stricmp(ModuleName, "msvcirt") != 0 &&
- stricmp(ModuleName, "msvcp50") != 0 &&
- stricmp(ModuleName, "msvcp60") != 0 &&
- stricmp(ModuleName, "msvcp70") != 0 &&
- stricmp(ModuleName, "msvcr70") != 0 &&
- stricmp(ModuleName, "msvcrt") != 0 &&
- stricmp(ModuleName, "msvcrt20") != 0 &&
- stricmp(ModuleName, "msvcrt40") != 0) {
- OpenedHandles.push_back((HMODULE)ModuleBase);
- }
- return TRUE;
- }
-}
-
-DynamicLibrary::DynamicLibrary() : handle(0) {
- handle = GetModuleHandle(NULL);
- OpenedHandles.push_back((HMODULE)handle);
-}
-
-DynamicLibrary::DynamicLibrary(const char*filename) : handle(0) {
- HMODULE a_handle = LoadLibrary(filename);
-
- if (a_handle == 0)
- ThrowError(std::string(filename) + ": Can't open : ");
-
- handle = a_handle;
- OpenedHandles.push_back(a_handle);
-}
-
-DynamicLibrary::~DynamicLibrary() {
- if (handle == 0)
- return;
-
- // GetModuleHandle() does not increment the ref count, so we must not free
- // the handle to the executable.
- if (handle != GetModuleHandle(NULL))
- FreeLibrary((HMODULE)handle);
- handle = 0;
-
- for (std::vector<HMODULE>::iterator I = OpenedHandles.begin(),
- E = OpenedHandles.end(); I != E; ++I) {
- if (*I == handle) {
- // Note: don't use the swap/pop_back trick here. Order is important.
- OpenedHandles.erase(I);
- }
- }
-}
-
-void DynamicLibrary::LoadLibraryPermanently(const char* filename) {
- if (filename) {
- HMODULE a_handle = LoadLibrary(filename);
-
- if (a_handle == 0)
- ThrowError(std::string(filename) + ": Can't open : ");
-
- OpenedHandles.push_back(a_handle);
- } else {
- // When no file is specified, enumerate all DLLs and EXEs in the
- // process.
- EnumerateLoadedModules(GetCurrentProcess(), ELM_Callback, 0);
- }
-
- // Because we don't remember the handle, we will never free it; hence,
- // it is loaded permanently.
-}
-
-void* DynamicLibrary::SearchForAddressOfSymbol(const char* symbolName) {
- for (std::vector<HMODULE>::iterator I = OpenedHandles.begin(),
- E = OpenedHandles.end(); I != E; ++I) {
- FARPROC ptr = GetProcAddress((HMODULE)*I, symbolName);
- if (ptr)
- return (void *) ptr;
- }
-
- return 0;
-}
-
-void *DynamicLibrary::GetAddressOfSymbol(const char *symbolName) {
- assert(handle != 0 && "Invalid DynamicLibrary handle");
- return (void *) GetProcAddress((HMODULE)handle, symbolName);
-}
-
-}
-
-// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
+++ /dev/null
-//===- Win32/MappedFile.cpp - Win32 MappedFile Implementation ---*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file was developed by Jeff Cohen and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file provides the Win32 implementation of the MappedFile concept.
-//
-//===----------------------------------------------------------------------===//
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only Win32 code.
-//===----------------------------------------------------------------------===//
-
-#include "Win32.h"
-#include "llvm/System/Process.h"
-
-namespace llvm {
-using namespace sys;
-
-struct sys::MappedFileInfo {
- HANDLE hFile;
- HANDLE hMapping;
- size_t size;
-};
-
-void MappedFile::initialize() {
- assert(!info_);
- info_ = new MappedFileInfo;
- info_->hFile = INVALID_HANDLE_VALUE;
- info_->hMapping = NULL;
-
- DWORD mode = options_ & WRITE_ACCESS ? GENERIC_WRITE : GENERIC_READ;
- DWORD disposition = options_ & WRITE_ACCESS ? OPEN_ALWAYS : OPEN_EXISTING;
- DWORD share = options_ & WRITE_ACCESS ? FILE_SHARE_WRITE : FILE_SHARE_READ;
- share = options_ & SHARED_MAPPING ? share : 0;
- info_->hFile = CreateFile(path_.c_str(), mode, share, NULL, disposition,
- FILE_ATTRIBUTE_NORMAL, NULL);
- if (info_->hFile == INVALID_HANDLE_VALUE) {
- delete info_;
- info_ = NULL;
- ThrowError(std::string("Can't open file: ") + path_.toString());
- }
-
- LARGE_INTEGER size;
- if (!GetFileSizeEx(info_->hFile, &size) ||
- (info_->size = size_t(size.QuadPart), info_->size != size.QuadPart)) {
- CloseHandle(info_->hFile);
- delete info_;
- info_ = NULL;
- ThrowError(std::string("Can't get size of file: ") + path_.toString());
- }
-}
-
-void MappedFile::terminate() {
- unmap();
- if (info_->hFile != INVALID_HANDLE_VALUE)
- CloseHandle(info_->hFile);
- delete info_;
- info_ = NULL;
-}
-
-void MappedFile::unmap() {
- assert(info_ && "MappedFile not initialized");
- if (isMapped()) {
- UnmapViewOfFile(base_);
- base_ = NULL;
- }
- if (info_->hMapping != INVALID_HANDLE_VALUE) {
- CloseHandle(info_->hMapping);
- info_->hMapping = NULL;
- }
-}
-
-void* MappedFile::map() {
- if (!isMapped()) {
- DWORD prot = PAGE_READONLY;
- if (options_ & EXEC_ACCESS)
- prot = SEC_IMAGE;
- else if (options_ & WRITE_ACCESS)
- prot = PAGE_READWRITE;
- info_->hMapping = CreateFileMapping(info_->hFile, NULL, prot, 0, 0, NULL);
- if (info_->hMapping == NULL)
- ThrowError(std::string("Can't map file: ") + path_.toString());
-
- prot = (options_ & WRITE_ACCESS) ? FILE_MAP_WRITE : FILE_MAP_READ;
- base_ = MapViewOfFileEx(info_->hMapping, prot, 0, 0, 0, NULL);
- if (base_ == NULL) {
- CloseHandle(info_->hMapping);
- info_->hMapping = NULL;
- ThrowError(std::string("Can't map file: ") + path_.toString());
- }
- }
- return base_;
-}
-
-size_t MappedFile::size() const {
- assert(info_ && "MappedFile not initialized");
- return info_->size;
-}
-
-void MappedFile::size(size_t new_size) {
- assert(info_ && "MappedFile not initialized");
-
- // Take the mapping out of memory.
- unmap();
-
- // Adjust the new_size to a page boundary.
- size_t pagesizem1 = Process::GetPageSize() - 1;
- new_size = (new_size + pagesizem1) & ~pagesizem1;
-
- // If the file needs to be extended, do so.
- if (new_size > info_->size) {
- LARGE_INTEGER eof;
- eof.QuadPart = new_size;
- if (!SetFilePointerEx(info_->hFile, eof, NULL, FILE_BEGIN))
- ThrowError(std::string("Can't set end of file: ") + path_.toString());
- if (!SetEndOfFile(info_->hFile))
- ThrowError(std::string("Can't set end of file: ") + path_.toString());
- info_->size = new_size;
- }
-
- // Remap the file.
- map();
-}
-
-}
-
-// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
+++ /dev/null
-//===- Win32/Memory.cpp - Win32 Memory Implementation -----------*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file was developed by Jeff Cohen and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file provides the Win32 specific implementation of various Memory
-// management utilities
-//
-//===----------------------------------------------------------------------===//
-
-#include "Win32.h"
-#include "llvm/System/Process.h"
-
-namespace llvm {
-using namespace sys;
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only Win32 specific code
-//=== and must not be UNIX code
-//===----------------------------------------------------------------------===//
-
-MemoryBlock Memory::AllocateRWX(unsigned NumBytes) {
- if (NumBytes == 0) return MemoryBlock();
-
- static const long pageSize = Process::GetPageSize();
- unsigned NumPages = (NumBytes+pageSize-1)/pageSize;
-
- void *pa = VirtualAlloc(NULL, NumPages*pageSize, MEM_COMMIT,
- PAGE_EXECUTE_READWRITE);
- if (pa == NULL) {
- ThrowError("Can't allocate RWX Memory: ");
- }
-
- MemoryBlock result;
- result.Address = pa;
- result.Size = NumPages*pageSize;
- return result;
-}
-
-void Memory::ReleaseRWX(MemoryBlock& M) {
- if (M.Address == 0 || M.Size == 0) return;
- if (!VirtualFree(M.Address, 0, MEM_RELEASE)) {
- ThrowError("Can't release RWX Memory: ");
- }
-}
-
-}
-
-// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
+++ /dev/null
-//===- llvm/System/Linux/Path.cpp - Linux Path Implementation ---*- 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.
-//
-// Modified by Henrik Bach to comply with at least MinGW.
-// Ported to Win32 by Jeff Cohen.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file provides the Win32 specific implementation of the Path class.
-//
-//===----------------------------------------------------------------------===//
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only generic Win32 code that
-//=== is guaranteed to work on *all* Win32 variants.
-//===----------------------------------------------------------------------===//
-
-#include "Win32.h"
-#include <malloc.h>
-
-// We need to undo a macro defined in Windows.h, otherwise we won't compile:
-#undef CopyFile
-
-static void FlipBackSlashes(std::string& s) {
- for (size_t i = 0; i < s.size(); i++)
- if (s[i] == '\\')
- s[i] = '/';
-}
-
-namespace llvm {
-namespace sys {
-
-bool
-Path::isValid() const {
- if (path.empty())
- return false;
-
- // If there is a colon, it must be the second character, preceded by a letter
- // and followed by something.
- size_t len = path.size();
- size_t pos = path.rfind(':',len);
- if (pos != std::string::npos) {
- if (pos != 1 || !isalpha(path[0]) || len < 3)
- return false;
- }
-
- // Check for illegal characters.
- if (path.find_first_of("\\<>\"|\001\002\003\004\005\006\007\010\011\012"
- "\013\014\015\016\017\020\021\022\023\024\025\026"
- "\027\030\031\032\033\034\035\036\037")
- != std::string::npos)
- return false;
-
- // A file or directory name may not end in a period.
- if (path[len-1] == '.')
- return false;
- if (len >= 2 && path[len-2] == '.' && path[len-1] == '/')
- return false;
-
- // A file or directory name may not end in a space.
- if (path[len-1] == ' ')
- return false;
- if (len >= 2 && path[len-2] == ' ' && path[len-1] == '/')
- return false;
-
- return true;
-}
-
-static Path *TempDirectory = NULL;
-
-Path
-Path::GetTemporaryDirectory() {
- if (TempDirectory)
- return *TempDirectory;
-
- char pathname[MAX_PATH];
- if (!GetTempPath(MAX_PATH, pathname))
- throw std::string("Can't determine temporary directory");
-
- Path result;
- result.setDirectory(pathname);
-
- // 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.appendDirectory(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.destroyDirectory(true);
-
- // And finally (re-)create the empty directory.
- result.createDirectory(false);
- TempDirectory = new Path(result);
- return *TempDirectory;
-}
-
-Path::Path(const std::string& unverified_path)
- : path(unverified_path)
-{
- FlipBackSlashes(path);
- if (unverified_path.empty())
- return;
- if (this->isValid())
- return;
- // oops, not valid.
- path.clear();
- throw std::string(unverified_path + ": path is not valid");
-}
-
-// FIXME: the following set of functions don't map to Windows very well.
-Path
-Path::GetRootDirectory() {
- Path result;
- result.setDirectory("/");
- return result;
-}
-
-static void getPathList(const char*path, std::vector<sys::Path>& Paths) {
- const char* at = path;
- const char* delim = strchr(at, ';');
- Path tmpPath;
- while( delim != 0 ) {
- std::string tmp(at, size_t(delim-at));
- if (tmpPath.setDirectory(tmp))
- if (tmpPath.readable())
- Paths.push_back(tmpPath);
- at = delim + 1;
- delim = strchr(at, ';');
- }
- if (*at != 0)
- if (tmpPath.setDirectory(std::string(at)))
- if (tmpPath.readable())
- Paths.push_back(tmpPath);
-
-}
-
-void
-Path::GetSystemLibraryPaths(std::vector<sys::Path>& Paths) {
- Paths.push_back(sys::Path("C:\\WINDOWS\\SYSTEM32\\"));
- Paths.push_back(sys::Path("C:\\WINDOWS\\"));
-}
-
-void
-Path::GetBytecodeLibraryPaths(std::vector<sys::Path>& Paths) {
- char * env_var = getenv("LLVM_LIB_SEARCH_PATH");
- if (env_var != 0) {
- getPathList(env_var,Paths);
- }
-#ifdef LLVM_LIBDIR
- {
- Path tmpPath;
- if (tmpPath.setDirectory(LLVM_LIBDIR))
- if (tmpPath.readable())
- Paths.push_back(tmpPath);
- }
-#endif
- GetSystemLibraryPaths(Paths);
-}
-
-Path
-Path::GetLLVMDefaultConfigDir() {
- // TODO: this isn't going to fly on Windows
- return Path("/etc/llvm/");
-}
-
-Path
-Path::GetUserHomeDirectory() {
- // TODO: Typical Windows setup doesn't define HOME.
- const char* home = getenv("HOME");
- if (home) {
- Path result;
- if (result.setDirectory(home))
- return result;
- }
- return GetRootDirectory();
-}
-// FIXME: the above set of functions don't map to Windows very well.
-
-bool
-Path::isFile() const {
- return (isValid() && path[path.length()-1] != '/');
-}
-
-bool
-Path::isDirectory() const {
- return (isValid() && path[path.length()-1] == '/');
-}
-
-std::string
-Path::getBasename() 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::hasMagicNumber(const std::string &Magic) const {
- std::string actualMagic;
- if (getMagicNumber(actualMagic, Magic.size()))
- return Magic == actualMagic;
- return false;
-}
-
-bool
-Path::isBytecodeFile() const {
- std::string actualMagic;
- if (!getMagicNumber(actualMagic, 4))
- return false;
- return actualMagic == "llvc" || actualMagic == "llvm";
-}
-
-bool
-Path::exists() const {
- DWORD attr = GetFileAttributes(path.c_str());
- return attr != INVALID_FILE_ATTRIBUTES;
-}
-
-bool
-Path::readable() const {
- // FIXME: take security attributes into account.
- DWORD attr = GetFileAttributes(path.c_str());
- return attr != INVALID_FILE_ATTRIBUTES;
-}
-
-bool
-Path::writable() const {
- // 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 {
- // FIXME: take security attributes into account.
- DWORD attr = GetFileAttributes(path.c_str());
- return attr != INVALID_FILE_ATTRIBUTES;
-}
-
-std::string
-Path::getLast() const {
- // Find the last slash
- size_t pos = path.rfind('/');
-
- // Handle the corner cases
- if (pos == std::string::npos)
- return path;
-
- // If the last character is a slash
- if (pos == path.length()-1) {
- // Find the second to last slash
- size_t pos2 = path.rfind('/', pos-1);
- if (pos2 == std::string::npos)
- return path.substr(0,pos);
- else
- return path.substr(pos2+1,pos-pos2-1);
- }
- // Return everything after the last slash
- return path.substr(pos+1);
-}
-
-void
-Path::getStatusInfo(StatusInfo& info) const {
- WIN32_FILE_ATTRIBUTE_DATA fi;
- if (!GetFileAttributesEx(path.c_str(), GetFileExInfoStandard, &fi))
- ThrowError(std::string(path) + ": Can't get status: ");
-
- info.fileSize = fi.nFileSizeHigh;
- info.fileSize <<= 32;
- info.fileSize += fi.nFileSizeLow;
-
- info.mode = fi.dwFileAttributes & FILE_ATTRIBUTE_READONLY ? 0555 : 0777;
- info.user = 9999; // Not applicable to Windows, so...
- info.group = 9999; // Not applicable to Windows, so...
-
- __int64 ft = *reinterpret_cast<__int64*>(&fi.ftLastWriteTime);
- info.modTime.fromWin32Time(ft);
-
- info.isDir = fi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
- if (info.isDir && path[path.length() - 1] != '/')
- path += '/';
- else if (!info.isDir && path[path.length() - 1] == '/')
- path.erase(path.length() - 1);
-}
-
-static bool AddPermissionBits(const std::string& Filename, int bits) {
- DWORD attr = GetFileAttributes(Filename.c_str());
-
- // If it doesn't exist, we're done.
- if (attr == INVALID_FILE_ATTRIBUTES)
- return false;
-
- // The best we can do to interpret Unix permission bits is to use
- // the owner writable bit.
- if ((attr & FILE_ATTRIBUTE_READONLY) && (bits & 0200)) {
- if (!SetFileAttributes(Filename.c_str(), attr & ~FILE_ATTRIBUTE_READONLY))
- ThrowError(Filename + ": SetFileAttributes: ");
- }
- return true;
-}
-
-void Path::makeReadable() {
- // All files are readable on Windows (ignoring security attributes).
-}
-
-void Path::makeWriteable() {
- DWORD attr = GetFileAttributes(path.c_str());
-
- // If it doesn't exist, we're done.
- if (attr == INVALID_FILE_ATTRIBUTES)
- return;
-
- if (attr & FILE_ATTRIBUTE_READONLY) {
- if (!SetFileAttributes(path.c_str(), attr & ~FILE_ATTRIBUTE_READONLY))
- ThrowError(std::string(path) + ": Can't make file writable: ");
- }
-}
-
-void Path::makeExecutable() {
- // All files are executable on Windows (ignoring security attributes).
-}
-
-bool
-Path::getDirectoryContents(std::set<Path>& result) const {
- if (!isDirectory())
- return false;
-
- result.clear();
- WIN32_FIND_DATA fd;
- HANDLE h = FindFirstFile(path.c_str(), &fd);
- if (h == INVALID_HANDLE_VALUE) {
- if (GetLastError() == ERROR_NO_MORE_FILES)
- return true; // not really an error, now is it?
- ThrowError(path + ": Can't read directory: ");
- }
-
- do {
- if (fd.cFileName[0] == '.')
- continue;
- Path aPath(path + &fd.cFileName[0]);
- if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
- aPath.path += "/";
- result.insert(aPath);
- } while (FindNextFile(h, &fd));
-
- DWORD err = GetLastError();
- FindClose(h);
- if (err != ERROR_NO_MORE_FILES) {
- SetLastError(err);
- ThrowError(path + ": Can't read directory: ");
- }
- return true;
-}
-
-bool
-Path::setDirectory(const std::string& a_path) {
- if (a_path.size() == 0)
- return false;
- Path save(*this);
- path = a_path;
- FlipBackSlashes(path);
- size_t last = a_path.size() -1;
- if (a_path[last] != '/')
- path += '/';
- if (!isValid()) {
- path = save.path;
- return false;
- }
- return true;
-}
-
-bool
-Path::setFile(const std::string& a_path) {
- if (a_path.size() == 0)
- return false;
- Path save(*this);
- path = a_path;
- FlipBackSlashes(path);
- size_t last = a_path.size() - 1;
- while (last > 0 && a_path[last] == '/')
- last--;
- path.erase(last+1);
- if (!isValid()) {
- path = save.path;
- return false;
- }
- return true;
-}
-
-bool
-Path::appendDirectory(const std::string& dir) {
- if (isFile())
- return false;
- Path save(*this);
- path += dir;
- path += "/";
- if (!isValid()) {
- path = save.path;
- return false;
- }
- return true;
-}
-
-bool
-Path::elideDirectory() {
- if (isFile())
- return false;
- size_t slashpos = path.rfind('/',path.size());
- if (slashpos == 0 || slashpos == std::string::npos)
- return false;
- if (slashpos == path.size() - 1)
- slashpos = path.rfind('/',slashpos-1);
- if (slashpos == std::string::npos)
- return false;
- path.erase(slashpos);
- return true;
-}
-
-bool
-Path::appendFile(const std::string& file) {
- if (!isDirectory())
- return false;
- Path save(*this);
- path += file;
- if (!isValid()) {
- path = save.path;
- return false;
- }
- return true;
-}
-
-bool
-Path::elideFile() {
- if (isDirectory())
- return false;
- size_t slashpos = path.rfind('/',path.size());
- if (slashpos == std::string::npos)
- return false;
- path.erase(slashpos+1);
- return true;
-}
-
-bool
-Path::appendSuffix(const std::string& suffix) {
- if (isDirectory())
- return false;
- Path save(*this);
- path.append(".");
- path.append(suffix);
- if (!isValid()) {
- path = save.path;
- return false;
- }
- return true;
-}
-
-bool
-Path::elideSuffix() {
- if (isDirectory()) return false;
- size_t dotpos = path.rfind('.',path.size());
- size_t slashpos = path.rfind('/',path.size());
- if (slashpos != std::string::npos && dotpos != std::string::npos &&
- dotpos > slashpos) {
- path.erase(dotpos, path.size()-dotpos);
- return true;
- }
- return false;
-}
-
-
-bool
-Path::createDirectory( bool create_parents) {
- // Make sure we're dealing with a directory
- if (!isDirectory()) return false;
-
- // Get a writeable copy of the path name
- char *pathname = reinterpret_cast<char *>(_alloca(path.length()+1));
- path.copy(pathname,path.length());
- pathname[path.length()] = 0;
-
- // Determine starting point for initial / search.
- char *next = pathname;
- if (pathname[0] == '/' && pathname[1] == '/') {
- // Skip host name.
- next = strchr(pathname+2, '/');
- if (next == NULL)
- throw std::string(pathname) + ": badly formed remote directory";
- // Skip share name.
- next = strchr(next+1, '/');
- if (next == NULL)
- throw std::string(pathname) + ": badly formed remote directory";
- next++;
- if (*next == 0)
- throw std::string(pathname) + ": badly formed remote directory";
- } else {
- if (pathname[1] == ':')
- next += 2; // skip drive letter
- if (*next == '/')
- next++; // skip root directory
- }
-
- // If we're supposed to create intermediate directories
- if (create_parents) {
- // Loop through the directory components until we're done
- while (*next) {
- next = strchr(next, '/');
- *next = 0;
- if (!CreateDirectory(pathname, NULL))
- ThrowError(std::string(pathname) + ": Can't create directory: ");
- *next++ = '/';
- }
- } else {
- // Drop trailing slash.
- pathname[path.size()-1] = 0;
- if (!CreateDirectory(pathname, NULL)) {
- ThrowError(std::string(pathname) + ": Can't create directory: ");
- }
- }
- return true;
-}
-
-bool
-Path::createFile() {
- // Make sure we're dealing with a file
- if (!isFile()) return false;
-
- // Create the file
- HANDLE h = CreateFile(path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_NEW,
- FILE_ATTRIBUTE_NORMAL, NULL);
- if (h == INVALID_HANDLE_VALUE)
- ThrowError(path + ": Can't create file: ");
-
- CloseHandle(h);
- return true;
-}
-
-bool
-Path::destroyDirectory(bool remove_contents) const {
- // Make sure we're dealing with a directory
- if (!isDirectory()) return false;
-
- // If it doesn't exist, we're done.
- if (!exists()) return true;
-
- char *pathname = reinterpret_cast<char *>(_alloca(path.length()+1));
- path.copy(pathname,path.length()+1);
- int lastchar = path.length() - 1 ;
- if (pathname[lastchar] == '/')
- pathname[lastchar] = 0;
-
- if (remove_contents) {
- WIN32_FIND_DATA fd;
- HANDLE h = FindFirstFile(path.c_str(), &fd);
-
- // It's a bad idea to alter the contents of a directory while enumerating
- // its contents. So build a list of its contents first, then destroy them.
-
- if (h != INVALID_HANDLE_VALUE) {
- std::vector<Path> list;
-
- do {
- if (strcmp(fd.cFileName, ".") == 0)
- continue;
- if (strcmp(fd.cFileName, "..") == 0)
- continue;
-
- Path aPath(path + &fd.cFileName[0]);
- if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
- aPath.path += "/";
- list.push_back(aPath);
- } while (FindNextFile(h, &fd));
-
- DWORD err = GetLastError();
- FindClose(h);
- if (err != ERROR_NO_MORE_FILES) {
- SetLastError(err);
- ThrowError(path + ": Can't read directory: ");
- }
-
- for (std::vector<Path>::iterator I = list.begin(); I != list.end(); ++I) {
- Path &aPath = *I;
- if (aPath.isDirectory())
- aPath.destroyDirectory(true);
- else
- aPath.destroyFile();
- }
- } else {
- if (GetLastError() != ERROR_NO_MORE_FILES)
- ThrowError(path + ": Can't read directory: ");
- }
- }
-
- if (!RemoveDirectory(pathname))
- ThrowError(std::string(pathname) + ": Can't destroy directory: ");
- return true;
-}
-
-bool
-Path::destroyFile() const {
- if (!isFile()) return false;
-
- 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(path + ": Can't destroy file: ");
- }
-
- if (!DeleteFile(path.c_str()))
- ThrowError(path + ": Can't destroy file: ");
- return true;
-}
-
-bool Path::getMagicNumber(std::string& Magic, unsigned len) const {
- if (!isFile())
- return false;
- assert(len < 1024 && "Request for magic string too long");
- char* buf = (char*) alloca(1 + len);
-
- HANDLE h = CreateFile(path.c_str(),
- GENERIC_READ,
- FILE_SHARE_READ,
- NULL,
- OPEN_EXISTING,
- FILE_ATTRIBUTE_NORMAL,
- NULL);
- if (h == INVALID_HANDLE_VALUE)
- return false;
-
- DWORD nRead = 0;
- BOOL ret = ReadFile(h, buf, len, &nRead, NULL);
- CloseHandle(h);
-
- if (!ret || nRead != len)
- return false;
-
- buf[len] = '\0';
- Magic = buf;
- return true;
-}
-
-bool
-Path::renameFile(const Path& newName) {
- if (!isFile()) return false;
- if (!MoveFile(path.c_str(), newName.c_str()))
- ThrowError("Can't move '" + path +
- "' to '" + newName.path + "': ");
- return true;
-}
-
-bool
-Path::setStatusInfo(const StatusInfo& si) const {
- if (!isFile()) return false;
-
- HANDLE h = CreateFile(path.c_str(),
- FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES,
- FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
- NULL,
- OPEN_EXISTING,
- FILE_ATTRIBUTE_NORMAL,
- NULL);
- if (h == INVALID_HANDLE_VALUE)
- return false;
-
- BY_HANDLE_FILE_INFORMATION bhfi;
- if (!GetFileInformationByHandle(h, &bhfi)) {
- DWORD err = GetLastError();
- CloseHandle(h);
- SetLastError(err);
- ThrowError(path + ": GetFileInformationByHandle: ");
- }
-
- FILETIME ft;
- (uint64_t&)ft = si.modTime.toWin32Time();
- BOOL ret = SetFileTime(h, NULL, &ft, &ft);
- DWORD err = GetLastError();
- CloseHandle(h);
- if (!ret) {
- SetLastError(err);
- ThrowError(path + ": SetFileTime: ");
- }
-
- // Best we can do with Unix permission bits is to interpret the owner
- // writable bit.
- if (si.mode & 0200) {
- if (bhfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
- if (!SetFileAttributes(path.c_str(),
- bhfi.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY))
- ThrowError(path + ": SetFileAttributes: ");
- }
- } else {
- if (!(bhfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY)) {
- if (!SetFileAttributes(path.c_str(),
- bhfi.dwFileAttributes | FILE_ATTRIBUTE_READONLY))
- ThrowError(path + ": SetFileAttributes: ");
- }
- }
-
- return true;
-}
-
-void
-sys::CopyFile(const sys::Path &Dest, const sys::Path &Src) {
- // Can't use CopyFile macro defined in Windows.h because it would mess up the
- // above line. We use the expansion it would have in a non-UNICODE build.
- if (!::CopyFileA(Src.c_str(), Dest.c_str(), false))
- ThrowError("Can't copy '" + Src.toString() +
- "' to '" + Dest.toString() + "': ");
-}
-
-void
-Path::makeUnique(bool reuse_current) {
- if (reuse_current && !exists())
- return; // File doesn't exist already, just use it!
-
- Path dir (*this);
- dir.elideFile();
- std::string fname = this->getLast();
-
- char newName[MAX_PATH + 1];
- if (!GetTempFileName(dir.c_str(), fname.c_str(), 0, newName))
- ThrowError("Cannot make unique filename for '" + path + "': ");
-
- path = newName;
-}
-
-bool
-Path::createTemporaryFile(bool reuse_current) {
- // Make sure we're dealing with a file
- if (!isFile())
- return false;
-
- // Make this into a unique file name
- makeUnique( reuse_current );
- return true;
-}
-
-}
-}
-
-// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
-
+++ /dev/null
-//===- Win32/Process.cpp - Win32 Process Implementation ------- -*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file was developed by Jeff Cohen and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file provides the Win32 specific implementation of the Process class.
-//
-//===----------------------------------------------------------------------===//
-
-#include "Win32.h"
-#include <psapi.h>
-#include <malloc.h>
-#include <io.h>
-
-#pragma comment(lib, "psapi.lib")
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only Win32 specific code
-//=== and must not be UNIX code
-//===----------------------------------------------------------------------===//
-
-#ifdef __MINGW
-// This ban should be lifted when MinGW 1.0+ has defined this value.
-# define _HEAPOK (-2)
-#endif
-
-namespace llvm {
-using namespace sys;
-
-// This function retrieves the page size using GetSystemInfo and is present
-// solely so it can be called once in Process::GetPageSize to initialize the
-// static variable PageSize.
-inline unsigned GetPageSizeOnce() {
- // NOTE: A 32-bit application running under WOW64 is supposed to use
- // GetNativeSystemInfo. However, this interface is not present prior
- // to Windows XP so to use it requires dynamic linking. It is not clear
- // how this affects the reported page size, if at all. One could argue
- // that LLVM ought to run as 64-bits on a 64-bit system, anyway.
- SYSTEM_INFO info;
- GetSystemInfo(&info);
- return static_cast<unsigned>(info.dwPageSize);
-}
-
-unsigned
-Process::GetPageSize() {
- static const unsigned PageSize = GetPageSizeOnce();
- return PageSize;
-}
-
-size_t
-Process::GetMallocUsage()
-{
- _HEAPINFO hinfo;
- hinfo._pentry = NULL;
-
- size_t size = 0;
-
- while (_heapwalk(&hinfo) == _HEAPOK)
- size += hinfo._size;
-
- return size;
-}
-
-size_t
-Process::GetTotalMemoryUsage()
-{
- PROCESS_MEMORY_COUNTERS pmc;
- GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));
- return pmc.PagefileUsage;
-}
-
-void
-Process::GetTimeUsage(
- TimeValue& elapsed, TimeValue& user_time, TimeValue& sys_time)
-{
- elapsed = TimeValue::now();
-
- uint64_t ProcCreate, ProcExit, KernelTime, UserTime;
- GetProcessTimes(GetCurrentProcess(), (FILETIME*)&ProcCreate,
- (FILETIME*)&ProcExit, (FILETIME*)&KernelTime,
- (FILETIME*)&UserTime);
-
- // FILETIME's are # of 100 nanosecond ticks (1/10th of a microsecond)
- user_time.seconds( UserTime / 10000000 );
- user_time.nanoseconds( unsigned(UserTime % 10000000) * 100 );
- sys_time.seconds( KernelTime / 10000000 );
- sys_time.nanoseconds( unsigned(KernelTime % 10000000) * 100 );
-}
-
-// Some LLVM programs such as bugpoint produce core files as a normal part of
-// their operation. To prevent the disk from filling up, this configuration item
-// does what's necessary to prevent their generation.
-void Process::PreventCoreFiles() {
- // Windows doesn't do core files, so nothing to do.
- // Although... it might be nice to prevent the do-you-want-to-debug
- // dialog box from coming up. Or maybe not...
-}
-
-bool Process::StandardInIsUserInput() {
- return GetFileType((HANDLE)_get_osfhandle(0)) == FILE_TYPE_CHAR;
-}
-
-bool Process::StandardOutIsDisplayed() {
- return GetFileType((HANDLE)_get_osfhandle(1)) == FILE_TYPE_CHAR;
-}
-
-bool Process::StandardErrIsDisplayed() {
- return GetFileType((HANDLE)_get_osfhandle(2)) == FILE_TYPE_CHAR;
-}
-
-}
-// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
+++ /dev/null
-//===- Win32/Program.cpp - Win32 Program Implementation ------- -*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file was developed by Jeff Cohen and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file provides the Win32 specific implementation of the Program class.
-//
-//===----------------------------------------------------------------------===//
-
-#include "Win32.h"
-#include <malloc.h>
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only Win32 specific code
-//=== and must not be UNIX code
-//===----------------------------------------------------------------------===//
-
-namespace llvm {
-using namespace sys;
-
-// This function just uses the PATH environment variable to find the program.
-Path
-Program::FindProgramByName(const std::string& progName) {
-
- // Check some degenerate cases
- if (progName.length() == 0) // no program
- return Path();
- Path temp;
- if (!temp.setFile(progName)) // invalid name
- return Path();
- if (temp.executable()) // already executable as is
- return temp;
-
- // At this point, the file name is valid and its not executable.
- // Let Windows search for it.
- char buffer[MAX_PATH];
- char *dummy = NULL;
- DWORD len = SearchPath(NULL, progName.c_str(), ".exe", MAX_PATH,
- buffer, &dummy);
-
- // See if it wasn't found.
- if (len == 0)
- return Path();
-
- // See if we got the entire path.
- if (len < MAX_PATH)
- return Path(buffer);
-
- // Buffer was too small; grow and retry.
- while (true) {
- char *b = reinterpret_cast<char *>(_alloca(len+1));
- DWORD len2 = SearchPath(NULL, progName.c_str(), ".exe", len+1, b, &dummy);
-
- // It is unlikely the search failed, but it's always possible some file
- // was added or removed since the last search, so be paranoid...
- if (len2 == 0)
- return Path();
- else if (len2 <= len)
- return Path(b);
-
- len = len2;
- }
-}
-
-//
-int
-Program::ExecuteAndWait(const Path& path,
- const char** args,
- const char** envp,
- const Path** redirects,
- unsigned secondsToWait) {
- if (!path.executable())
- throw path.toString() + " is not executable";
-
- // Windows wants a command line, not an array of args, to pass to the new
- // process. We have to concatenate them all, while quoting the args that
- // have embedded spaces.
-
- // First, determine the length of the command line.
- std::string progname(path.getLast());
- unsigned len = progname.length() + 1;
- if (progname.find(' ') != std::string::npos)
- len += 2;
-
- for (unsigned i = 0; args[i]; i++) {
- len += strlen(args[i]) + 1;
- if (strchr(args[i], ' '))
- len += 2;
- }
-
- // Now build the command line.
- char *command = reinterpret_cast<char *>(_alloca(len));
- char *p = command;
-
- bool needsQuoting = progname.find(' ') != std::string::npos;
- if (needsQuoting)
- *p++ = '"';
- memcpy(p, progname.c_str(), progname.length());
- p += progname.length();
- if (needsQuoting)
- *p++ = '"';
- *p++ = ' ';
-
- for (unsigned i = 0; args[i]; i++) {
- const char *arg = args[i];
- size_t len = strlen(arg);
- needsQuoting = strchr(arg, ' ') != 0;
- if (needsQuoting)
- *p++ = '"';
- memcpy(p, arg, len);
- p += len;
- if (needsQuoting)
- *p++ = '"';
- *p++ = ' ';
- }
-
- *p = 0;
-
- // Create a child process.
- STARTUPINFO si;
- memset(&si, 0, sizeof(si));
- si.cb = sizeof(si);
-
- // TODO: do replacement of standard input/output/error handles.
-
- PROCESS_INFORMATION pi;
- memset(&pi, 0, sizeof(pi));
-
- if (!CreateProcess(path.c_str(), command, NULL, NULL, FALSE, 0,
- envp, NULL, &si, &pi))
- {
- ThrowError(std::string("Couldn't execute program '") +
- path.toString() + "'");
- }
-
- // Wait for it to terminate.
- DWORD millisecondsToWait = INFINITE;
- if (secondsToWait > 0)
- millisecondsToWait = secondsToWait * 1000;
-
- if (WaitForSingleObject(pi.hProcess, millisecondsToWait) == WAIT_TIMEOUT) {
- if (!TerminateProcess(pi.hProcess, 1)) {
- ThrowError(std::string("Failed to terminate timed-out program '") +
- path.toString() + "'");
- }
- WaitForSingleObject(pi.hProcess, INFINITE);
- }
-
- // Get its exit status.
- DWORD status;
- BOOL rc = GetExitCodeProcess(pi.hProcess, &status);
-
- // Done with the handles; go close them.
- CloseHandle(pi.hProcess);
- CloseHandle(pi.hThread);
-
- if (!rc)
- ThrowError(std::string("Failed getting status for program '") +
- path.toString() + "'");
-
- return status;
-}
-
-}
-// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
+++ /dev/null
-//===- Win32/Signals.cpp - Win32 Signals Implementation ---------*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file was developed by Jeff Cohen and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file provides the Win32 specific implementation of the Signals class.
-//
-//===----------------------------------------------------------------------===//
-
-#include "Win32.h"
-#include <stdio.h>
-#include <vector>
-
-#ifdef __MINGW
-#include <imagehlp.h>
-#else
-#include <dbghelp.h>
-#endif
-#include <psapi.h>
-
-#pragma comment(lib, "psapi.lib")
-#pragma comment(lib, "dbghelp.lib")
-
-// Forward declare.
-static LONG WINAPI LLVMUnhandledExceptionFilter(LPEXCEPTION_POINTERS ep);
-static BOOL WINAPI LLVMConsoleCtrlHandler(DWORD dwCtrlType);
-
-static std::vector<llvm::sys::Path> *FilesToRemove = NULL;
-static std::vector<llvm::sys::Path> *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
-// globals which this critical section addresses.
-static CRITICAL_SECTION CriticalSection;
-
-namespace llvm {
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only Win32 specific code
-//=== and must not be UNIX code
-//===----------------------------------------------------------------------===//
-
-
-static void RegisterHandler() {
- if (RegisteredUnhandledExceptionFilter) {
- EnterCriticalSection(&CriticalSection);
- return;
- }
-
- // Now's the time to create the critical section. This is the first time
- // through here, and there's only one thread.
- InitializeCriticalSection(&CriticalSection);
-
- // Enter it immediately. Now if someone hits CTRL/C, the console handler
- // can't proceed until the globals are updated.
- EnterCriticalSection(&CriticalSection);
-
- RegisteredUnhandledExceptionFilter = true;
- OldFilter = SetUnhandledExceptionFilter(LLVMUnhandledExceptionFilter);
- SetConsoleCtrlHandler(LLVMConsoleCtrlHandler, TRUE);
-
- // IMPORTANT NOTE: Caller must call LeaveCriticalSection(&CriticalSection) or
- // else multi-threading problems will ensue.
-}
-
-// RemoveFileOnSignal - The public API
-void sys::RemoveFileOnSignal(const sys::Path &Filename) {
- RegisterHandler();
-
- if (CleanupExecuted)
- throw std::string("Process terminating -- cannot register for removal");
-
- if (FilesToRemove == NULL)
- FilesToRemove = new std::vector<sys::Path>;
-
- FilesToRemove->push_back(Filename);
-
- LeaveCriticalSection(&CriticalSection);
-}
-
-// RemoveDirectoryOnSignal - The public API
-void sys::RemoveDirectoryOnSignal(const sys::Path& path) {
- RegisterHandler();
-
- if (CleanupExecuted)
- throw std::string("Process terminating -- cannot register for removal");
-
- if (path.isDirectory()) {
- if (DirectoriesToRemove == NULL)
- DirectoriesToRemove = new std::vector<sys::Path>;
-
- DirectoriesToRemove->push_back(path);
- }
-
- LeaveCriticalSection(&CriticalSection);
-}
-
-/// PrintStackTraceOnErrorSignal - When an error signal (such as SIBABRT or
-/// SIGSEGV) is delivered to the process, print a stack trace and then exit.
-void sys::PrintStackTraceOnErrorSignal() {
- RegisterHandler();
- LeaveCriticalSection(&CriticalSection);
-}
-
-}
-
-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 {
- FilesToRemove->back().destroyFile();
- } catch (...) {
- }
- FilesToRemove->pop_back();
- }
-
- if (DirectoriesToRemove != NULL)
- while (!DirectoriesToRemove->empty()) {
- try {
- DirectoriesToRemove->back().destroyDirectory(true);
- } catch (...) {
- }
- DirectoriesToRemove->pop_back();
- }
-
- LeaveCriticalSection(&CriticalSection);
-}
-
-static LONG WINAPI LLVMUnhandledExceptionFilter(LPEXCEPTION_POINTERS ep) {
- try {
- Cleanup();
-
- // Initialize the STACKFRAME structure.
- STACKFRAME StackFrame;
- memset(&StackFrame, 0, sizeof(StackFrame));
-
- StackFrame.AddrPC.Offset = ep->ContextRecord->Eip;
- StackFrame.AddrPC.Mode = AddrModeFlat;
- StackFrame.AddrStack.Offset = ep->ContextRecord->Esp;
- StackFrame.AddrStack.Mode = AddrModeFlat;
- StackFrame.AddrFrame.Offset = ep->ContextRecord->Ebp;
- StackFrame.AddrFrame.Mode = AddrModeFlat;
-
- HANDLE hProcess = GetCurrentProcess();
- HANDLE hThread = GetCurrentThread();
-
- // Initialize the symbol handler.
- SymSetOptions(SYMOPT_DEFERRED_LOADS|SYMOPT_LOAD_LINES);
- SymInitialize(hProcess, NULL, TRUE);
-
- while (true) {
- if (!StackWalk(IMAGE_FILE_MACHINE_I386, hProcess, hThread, &StackFrame,
- ep->ContextRecord, NULL, SymFunctionTableAccess,
- SymGetModuleBase, NULL)) {
- break;
- }
-
- if (StackFrame.AddrFrame.Offset == 0)
- break;
-
- // Print the PC in hexadecimal.
- DWORD PC = StackFrame.AddrPC.Offset;
- fprintf(stderr, "%08X", PC);
-
- // Print the parameters. Assume there are four.
- fprintf(stderr, " (0x%08X 0x%08X 0x%08X 0x%08X)", StackFrame.Params[0],
- StackFrame.Params[1], StackFrame.Params[2], StackFrame.Params[3]);
-
- // Verify the PC belongs to a module in this process.
- if (!SymGetModuleBase(hProcess, PC)) {
- fputs(" <unknown module>\n", stderr);
- continue;
- }
-
- // Print the symbol name.
- char buffer[512];
- IMAGEHLP_SYMBOL *symbol = reinterpret_cast<IMAGEHLP_SYMBOL *>(buffer);
- memset(symbol, 0, sizeof(IMAGEHLP_SYMBOL));
- symbol->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL);
- symbol->MaxNameLength = 512 - sizeof(IMAGEHLP_SYMBOL);
-
- DWORD dwDisp;
- if (!SymGetSymFromAddr(hProcess, PC, &dwDisp, symbol)) {
- fputc('\n', stderr);
- continue;
- }
-
- buffer[511] = 0;
- if (dwDisp > 0)
- fprintf(stderr, ", %s()+%04d bytes(s)", symbol->Name, dwDisp);
- else
- fprintf(stderr, ", %s", symbol->Name);
-
- // Print the source file and line number information.
- IMAGEHLP_LINE line;
- memset(&line, 0, sizeof(line));
- line.SizeOfStruct = sizeof(line);
- if (SymGetLineFromAddr(hProcess, PC, &dwDisp, &line)) {
- fprintf(stderr, ", %s, line %d", line.FileName, line.LineNumber);
- if (dwDisp > 0)
- fprintf(stderr, "+%04d byte(s)", dwDisp);
- }
-
- fputc('\n', stderr);
- }
- } catch (...) {
- assert(!"Crashed in LLVMUnhandledExceptionFilter");
- }
-
- // Allow dialog box to pop up allowing choice to start debugger.
- if (OldFilter)
- return (*OldFilter)(ep);
- else
- return EXCEPTION_CONTINUE_SEARCH;
-}
-
-static BOOL WINAPI LLVMConsoleCtrlHandler(DWORD dwCtrlType) {
- Cleanup();
-
- // Allow normal processing to take place; i.e., the process dies.
- return FALSE;
-}
-
-// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
+++ /dev/null
-//===- Win32/TimeValue.cpp - Win32 TimeValue Implementation -----*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file was developed by Jeff Cohen and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file provides the Win32 implementation of the TimeValue class.
-//
-//===----------------------------------------------------------------------===//
-
-#include "Win32.h"
-#include <time.h>
-
-namespace llvm {
-using namespace sys;
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only Win32 specific code.
-//===----------------------------------------------------------------------===//
-
-TimeValue TimeValue::now() {
- uint64_t ft;
- GetSystemTimeAsFileTime(reinterpret_cast<FILETIME *>(&ft));
-
- TimeValue t(0, 0);
- t.fromWin32Time(ft);
- return t;
-}
-
-std::string TimeValue::toString() const {
-#ifdef __MINGW
- // This ban may be lifted by either:
- // (i) a future MinGW version other than 1.0 inherents the __time64_t type, or
- // (ii) configure tests for either the time_t or __time64_t type.
- time_t ourTime = time_t(this->toEpochTime());
- struct tm *lt = ::localtime(&ourTime);
-#else
- __time64_t ourTime = this->toEpochTime();
- struct tm *lt = ::_localtime64(&ourTime);
-#endif
-
- char buffer[25];
- strftime(buffer, 25, "%a %b %d %H:%M:%S %Y", lt);
- return std::string(buffer);
-}
-
-// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
-
-}
projects / oota-llvm.git / commitdiff