mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-17 05:29:24 +00:00
Remove MappedFile support for mapping files for write and exec
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:
parent
558755ce1a
commit
bdbd2d710c
@ -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();
|
||||
}
|
||||
|
@ -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:
|
||||
|
@ -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;
|
||||
|
@ -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)))
|
||||
|
@ -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;
|
||||
|
@ -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))
|
||||
|
@ -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);
|
||||
}
|
||||
|
@ -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);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user