blob: 4b4406c4c9f4b9e94fee91edbdf52a428b30c955 [file] [log] [blame]
//===- FileOutputBuffer.cpp - File Output Buffer ----------------*- C++ -*-===//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// Utility for creating a in-memory buffer that will be written to a file.
#include "llvm/Support/FileOutputBuffer.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/Errc.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Memory.h"
#include "llvm/Support/Path.h"
#include <system_error>
#if !defined(_MSC_VER) && !defined(__MINGW32__)
#include <unistd.h>
#include <io.h>
using namespace llvm;
using namespace llvm::sys;
namespace {
// A FileOutputBuffer which creates a temporary file in the same directory
// as the final output file. The final output file is atomically replaced
// with the temporary file on commit().
class OnDiskBuffer : public FileOutputBuffer {
OnDiskBuffer(StringRef Path, fs::TempFile Temp, fs::mapped_file_region Buf)
: FileOutputBuffer(Path), Buffer(std::move(Buf)), Temp(std::move(Temp)) {}
uint8_t *getBufferStart() const override { return (uint8_t *); }
uint8_t *getBufferEnd() const override {
return (uint8_t *) + Buffer.size();
size_t getBufferSize() const override { return Buffer.size(); }
Error commit() override {
// Unmap buffer, letting OS flush dirty pages to file on disk.
// Atomically replace the existing file with the new one.
return Temp.keep(FinalPath);
~OnDiskBuffer() override {
// Close the mapping before deleting the temp file, so that the removal
// succeeds.
void discard() override {
// Delete the temp file if it still was open, but keeping the mapping
// active.
fs::mapped_file_region Buffer;
fs::TempFile Temp;
// A FileOutputBuffer which keeps data in memory and writes to the final
// output file on commit(). This is used only when we cannot use OnDiskBuffer.
class InMemoryBuffer : public FileOutputBuffer {
InMemoryBuffer(StringRef Path, MemoryBlock Buf, std::size_t BufSize,
unsigned Mode)
: FileOutputBuffer(Path), Buffer(Buf), BufferSize(BufSize),
Mode(Mode) {}
uint8_t *getBufferStart() const override { return (uint8_t *)Buffer.base(); }
uint8_t *getBufferEnd() const override {
return (uint8_t *)Buffer.base() + BufferSize;
size_t getBufferSize() const override { return BufferSize; }
Error commit() override {
if (FinalPath == "-") {
llvm::outs() << StringRef((const char *)Buffer.base(), BufferSize);
return Error::success();
using namespace sys::fs;
int FD;
std::error_code EC;
if (auto EC =
openFileForWrite(FinalPath, FD, CD_CreateAlways, OF_None, Mode))
return errorCodeToError(EC);
raw_fd_ostream OS(FD, /*shouldClose=*/true, /*unbuffered=*/true);
OS << StringRef((const char *)Buffer.base(), BufferSize);
return Error::success();
// Buffer may actually contain a larger memory block than BufferSize
OwningMemoryBlock Buffer;
size_t BufferSize;
unsigned Mode;
} // namespace
static Expected<std::unique_ptr<InMemoryBuffer>>
createInMemoryBuffer(StringRef Path, size_t Size, unsigned Mode) {
std::error_code EC;
MemoryBlock MB = Memory::allocateMappedMemory(
Size, nullptr, sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC);
if (EC)
return errorCodeToError(EC);
return std::make_unique<InMemoryBuffer>(Path, MB, Size, Mode);
static Expected<std::unique_ptr<FileOutputBuffer>>
createOnDiskBuffer(StringRef Path, size_t Size, unsigned Mode) {
Expected<fs::TempFile> FileOrErr =
fs::TempFile::create(Path + ".tmp%%%%%%%", Mode);
if (!FileOrErr)
return FileOrErr.takeError();
fs::TempFile File = std::move(*FileOrErr);
if (auto EC = fs::resize_file_before_mapping_readwrite(File.FD, Size)) {
return errorCodeToError(EC);
// Mmap it.
std::error_code EC;
fs::mapped_file_region MappedFile =
fs::mapped_file_region::readwrite, Size, 0, EC);
// mmap(2) can fail if the underlying filesystem does not support it.
// If that happens, we fall back to in-memory buffer as the last resort.
if (EC) {
return createInMemoryBuffer(Path, Size, Mode);
return std::make_unique<OnDiskBuffer>(Path, std::move(File),
// Create an instance of FileOutputBuffer.
FileOutputBuffer::create(StringRef Path, size_t Size, unsigned Flags) {
// Handle "-" as stdout just like llvm::raw_ostream does.
if (Path == "-")
return createInMemoryBuffer("-", Size, /*Mode=*/0);
unsigned Mode = fs::all_read | fs::all_write;
if (Flags & F_executable)
Mode |= fs::all_exe;
// If Size is zero, don't use mmap which will fail with EINVAL.
if (Size == 0)
return createInMemoryBuffer(Path, Size, Mode);
fs::file_status Stat;
fs::status(Path, Stat);
// Usually, we want to create OnDiskBuffer to create a temporary file in
// the same directory as the destination file and atomically replaces it
// by rename(2).
// However, if the destination file is a special file, we don't want to
// use rename (e.g. we don't want to replace /dev/null with a regular
// file.) If that's the case, we create an in-memory buffer, open the
// destination file and write to it on commit().
switch (Stat.type()) {
case fs::file_type::directory_file:
return errorCodeToError(errc::is_a_directory);
case fs::file_type::regular_file:
case fs::file_type::file_not_found:
case fs::file_type::status_error:
if (Flags & F_no_mmap)
return createInMemoryBuffer(Path, Size, Mode);
return createOnDiskBuffer(Path, Size, Mode);
return createInMemoryBuffer(Path, Size, Mode);