6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-17 05:29:24 +00:00
Code Issues Projects Releases Wiki Activity

Remove MappedFile support for mapping files for write and exec

Browse Source 
and shared.  This complicates the design, is not used, and probably
doesn't even work.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49022 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2008-04-01 03:10:22 +00:00
parent 558755ce1a
commit bdbd2d710c
8 changed files with 23 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/llvm/Debugger/SourceFile.h
View File

@ -52,7 +52,7 @@ namespace llvm {
SourceFile(const std::string &fn, const GlobalVariable *Desc)
: Filename(fn), Descriptor(Desc), File() {
std::string ErrMsg;
if (File.open(Filename, sys::MappedFile::READ_ACCESS, &ErrMsg))
if (File.open(Filename, &ErrMsg))
throw ErrMsg;
readFile();
}

28
include/llvm/System/MappedFile.h
View File

@ -25,26 +25,16 @@ namespace sys {
/// This class provides an abstraction for a memory mapped file in the
/// operating system's filesystem. It provides platform independent operations
/// for mapping a file into memory for both read and write access. This class
/// does not provide facilities for finding the file or operating on paths to
/// files. The sys::Path class is used for that.
/// for mapping a file into memory for both read access.
class MappedFile {
sys::PathWithStatus Path; ///< Path to the file.
unsigned Options; ///< Options used to create the mapping
void *BasePtr; ///< Pointer to the base memory address
mutable MappedFileInfo *MapInfo; ///< Platform specific info for the mapping
MappedFile& operator=(const MappedFile &that); // DO NOT IMPLEMENT
MappedFile(const MappedFile &that); // DO NOT IMPLEMENT
public:
enum MappingOptions {
READ_ACCESS = 0x0001, ///< Map the file for reading
WRITE_ACCESS = 0x0002, ///< Map the file for write access
EXEC_ACCESS = 0x0004, ///< Map the file for execution access
SHARED_MAPPING = 0x0008 ///< Map the file shared with other processes
};
MappedFile() : Options(READ_ACCESS), BasePtr(0), MapInfo(0) {}
MappedFile() : BasePtr(0), MapInfo(0) {}
/// Destruct a MappedFile and release all memory associated with it.
~MappedFile() { close(); }
@ -71,7 +61,7 @@ namespace sys {
/// This function returns a reference to the sys::Path object kept by the
/// MappedFile object. This contains the path to the file that is or
/// will be mapped.
const sys::Path& path() const { return Path; }
const sys::PathWithStatus &path() const { return Path; }
/// This function returns the number of bytes in the file.
size_t size() const;
@ -80,10 +70,8 @@ namespace sys {
/// Open a file to be mapped and get its size but don't map it yet. Return
/// true on error.
bool open(const sys::Path &P, int options = READ_ACCESS,
std::string *ErrMsg = 0) {
bool open(const sys::Path &P, std::string *ErrMsg = 0) {
Path = P;
Options = options;
return initialize(ErrMsg);
}
@ -97,14 +85,6 @@ namespace sys {
/// or 0 if an error occurred.
void *map(std::string* ErrMsg = 0);
/// resize - This method causes the size of the file, and consequently the
/// size of the mapping to be set. This is logically the same as unmap(),
/// adjust size of the file, map(). Consequently, when calling this
/// function, the caller should not rely on previous results of the
/// map(), base(), or baseChar() members as they may point to invalid
/// areas of memory after this call.
bool resize(size_t new_size, std::string *ErrMsg = 0);
void close() { if (MapInfo) terminate(); }
private:

2
lib/Archive/Archive.cpp
View File

@ -148,7 +148,7 @@ bool
Archive::mapToMemory(std::string* ErrMsg)
{
mapfile = new sys::MappedFile();
if (mapfile->open(archPath, sys::MappedFile::READ_ACCESS, ErrMsg))
if (mapfile->open(archPath, ErrMsg))
return true;
if (!(base = (char*) mapfile->map(ErrMsg)))
return true;

4
lib/Archive/ArchiveWriter.cpp
View File

@ -212,7 +212,7 @@ Archive::writeMember(
sys::MappedFile* mFile = 0;
if (!data) {
mFile = new sys::MappedFile();
if (mFile->open(member.getPath(), sys::MappedFile::READ_ACCESS, ErrMsg))
if (mFile->open(member.getPath(), ErrMsg))
return true;
if (!(data = (const char*) mFile->map(ErrMsg)))
return true;
@ -411,7 +411,7 @@ Archive::writeToDisk(bool CreateSymbolTable, bool TruncateNames, bool Compress,
// Map in the archive we just wrote.
sys::MappedFile arch;
if (arch.open(TmpArchive, sys::MappedFile::READ_ACCESS, ErrMsg))
if (arch.open(TmpArchive, ErrMsg))
return true;
const char* base;
if (!(base = (const char*) arch.map(ErrMsg)))

4
lib/Support/FileUtilities.cpp
View File

@ -192,10 +192,10 @@ int llvm::DiffFilesWithTolerance(const sys::PathWithStatus &FileA,
// Now its safe to mmap the files into memory becasue both files
// have a non-zero size.
sys::MappedFile F1;
if (F1.open(FileA, sys::MappedFile::READ_ACCESS, Error))
if (F1.open(FileA, Error))
return 2;
sys::MappedFile F2;
if (F2.open(FileB, sys::MappedFile::READ_ACCESS, Error))
if (F2.open(FileB, Error))
return 2;
if (!F1.map(Error))
return 2;

2
lib/Support/MemoryBuffer.cpp
View File

@ -159,7 +159,7 @@ bool MemoryBufferMMapFile::open(const sys::Path &Filename,
std::string *ErrStr) {
// FIXME: This does an extra stat syscall to figure out the size, but we
// already know the size!
bool Failure = File.open(Filename, sys::MappedFile::READ_ACCESS, ErrStr);
bool Failure = File.open(Filename, ErrStr);
if (Failure) return true;
if (!File.map(ErrStr))

70
lib/System/Unix/MappedFile.inc
View File

@ -1,4 +1,4 @@
//===- Unix/MappedFile.cpp - Unix MappedFile Implementation -----*- C++ -*-===//
//===- Unix/MappedFile.inc - Unix MappedFile Implementation -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@ -11,11 +11,6 @@
//
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
//=== 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"
@ -44,16 +39,7 @@ namespace llvm {
}
bool MappedFile::initialize(std::string* ErrMsg) {
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;
int FD = ::open(Path.c_str(), mode);
int FD = ::open(Path.c_str(), O_RDONLY);
if (FD < 0) {
MakeErrMsg(ErrMsg, "can't open file '" + Path.toString() + "'");
return true;
@ -80,8 +66,6 @@ void MappedFile::unmap() {
assert(MapInfo && "MappedFile not initialized");
if (!isMapped()) return;
if (Options & WRITE_ACCESS)
::msync(BasePtr, MapInfo->Size, MS_SYNC);
::munmap(BasePtr, MapInfo->Size);
BasePtr = 0; // Mark this as non-mapped.
}
@ -90,28 +74,13 @@ void* MappedFile::map(std::string* ErrMsg) {
assert(MapInfo && "MappedFile not initialized");
if (isMapped()) return BasePtr;
int prot = PROT_NONE;
int flags = 0;
int prot = PROT_READ;
int flags = MAP_PRIVATE;
#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 = ((MapInfo->Size / Process::GetPageSize())+1) *
Process::GetPageSize();
size_t PageSize = Process::GetPageSize();
size_t map_size = ((MapInfo->Size / PageSize)+1) * PageSize;
BasePtr = ::mmap(0, map_size, prot, flags, MapInfo->FD, 0);
if (BasePtr == MAP_FAILED) {
@ -126,30 +95,3 @@ size_t MappedFile::size() const {
return MapInfo->Size;
}
bool MappedFile::resize(size_t new_size, std::string* ErrMsg) {
assert(MapInfo && "MappedFile not initialized");
// Take the mapping out of memory
unmap();
// Adjust the current size to a page boundary
size_t cur_size = ((MapInfo->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.
if ((off_t)-1 == ::lseek(MapInfo->FD, new_size, SEEK_SET))
return MakeErrMsg(ErrMsg, "Can't lseek: ");
if (-1 == ::write(MapInfo->FD, "\0", 1))
return MakeErrMsg(ErrMsg, "Can't write: ");
}
// Put the mapping back into memory.
return map(ErrMsg);
}

48
lib/System/Win32/MappedFile.inc
View File

@ -33,17 +33,13 @@ bool MappedFile::initialize(std::string* ErrMsg) {
MapInfo->hFile = INVALID_HANDLE_VALUE;
MapInfo->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;
MapInfo->hFile = CreateFile(Path.c_str(), mode, share, NULL, disposition,
FILE_ATTRIBUTE_NORMAL, NULL);
MapInfo->hFile = CreateFile(Path.c_str(), GENERIC_READ, 0, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (MapInfo->hFile == INVALID_HANDLE_VALUE) {
delete MapInfo;
MapInfo = NULL;
return MakeErrMsg(ErrMsg,
std::string("Can't open file: ") + Path.toString());
std::string("Can't open file: ") + Path.toString());
}
LARGE_INTEGER size;
@ -81,19 +77,14 @@ void MappedFile::unmap() {
void* MappedFile::map(std::string* ErrMsg) {
if (!isMapped()) {
DWORD prot = PAGE_READONLY;
if (Options & EXEC_ACCESS)
prot = SEC_IMAGE;
else if (Options & WRITE_ACCESS)
prot = PAGE_READWRITE;
MapInfo->hMapping = CreateFileMapping(MapInfo->hFile, NULL, prot, 0, 0, NULL);
MapInfo->hMapping = CreateFileMapping(MapInfo->hFile, NULL, PAGE_READONLY,
0, 0, NULL);
if (MapInfo->hMapping == NULL) {
MakeErrMsg(ErrMsg, std::string("Can't map file: ") + Path.toString());
return 0;
}
prot = (Options & WRITE_ACCESS) ? FILE_MAP_WRITE : FILE_MAP_READ;
BasePtr = MapViewOfFileEx(MapInfo->hMapping, prot, 0, 0, 0, NULL);
BasePtr = MapViewOfFileEx(MapInfo->hMapping, FILE_MAP_READ, 0, 0, 0, NULL);
if (BasePtr == NULL) {
CloseHandle(MapInfo->hMapping);
MapInfo->hMapping = NULL;
@ -109,32 +100,5 @@ size_t MappedFile::size() const {
return MapInfo->size;
}
bool MappedFile::resize(size_t new_size, std::string* ErrMsg) {
assert(MapInfo && "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 > MapInfo->size) {
LARGE_INTEGER eof;
eof.QuadPart = new_size;
if (!SetFilePointerEx(MapInfo->hFile, eof, NULL, FILE_BEGIN))
return MakeErrMsg(ErrMsg,
std::string("Can't set end of file: ") + Path.toString());
if (!SetEndOfFile(MapInfo->hFile))
return MakeErrMsg(ErrMsg,
std::string("Can't set end of file: ") + Path.toString());
MapInfo->size = new_size;
}
// Remap the file.
return map(ErrMsg);
}
}