1//===- Caching.h - LLVM Local File Cache ------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the CachedFileStream and the localCache function, which
10// simplifies caching files on the local filesystem in a directory whose
11// contents are managed by a CachePruningPolicy.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_SUPPORT_CACHING_H
16#define LLVM_SUPPORT_CACHING_H
17
18#include "llvm/Support/Error.h"
19
20namespace llvm {
21
22class MemoryBuffer;
23
24/// This class wraps an output stream for a file. Most clients should just be
25/// able to return an instance of this base class from the stream callback, but
26/// if a client needs to perform some action after the stream is written to,
27/// that can be done by deriving from this class and overriding the destructor.
28class CachedFileStream {
29public:
30 CachedFileStream(std::unique_ptr<raw_pwrite_stream> OS,
31 std::string OSPath = "")
32 : OS(std::move(OS)), ObjectPathName(OSPath) {}
33 std::unique_ptr<raw_pwrite_stream> OS;
34 std::string ObjectPathName;
35 virtual ~CachedFileStream() = default;
36};
37
38/// This type defines the callback to add a file that is generated on the fly.
39///
40/// Stream callbacks must be thread safe.
41using AddStreamFn = std::function<Expected<std::unique_ptr<CachedFileStream>>(
42 unsigned Task, const Twine &ModuleName)>;
43
44/// This is the type of a file cache. To request an item from the cache, pass a
45/// unique string as the Key. For hits, the cached file will be added to the
46/// link and this function will return AddStreamFn(). For misses, the cache will
47/// return a stream callback which must be called at most once to produce
48/// content for the stream. The file stream produced by the stream callback will
49/// add the file to the link after the stream is written to. ModuleName is the
50/// unique module identifier for the bitcode module the cache is being checked
51/// for.
52///
53/// Clients generally look like this:
54///
55/// if (AddStreamFn AddStream = Cache(Task, Key, ModuleName))
56/// ProduceContent(AddStream);
57using FileCache = std::function<Expected<AddStreamFn>(
58 unsigned Task, StringRef Key, const Twine &ModuleName)>;
59
60/// This type defines the callback to add a pre-existing file (e.g. in a cache).
61///
62/// Buffer callbacks must be thread safe.
63using AddBufferFn = std::function<void(unsigned Task, const Twine &ModuleName,
64 std::unique_ptr<MemoryBuffer> MB)>;
65
66/// Create a local file system cache which uses the given cache name, temporary
67/// file prefix, cache directory and file callback. This function does not
68/// immediately create the cache directory if it does not yet exist; this is
69/// done lazily the first time a file is added. The cache name appears in error
70/// messages for errors during caching. The temporary file prefix is used in the
71/// temporary file naming scheme used when writing files atomically.
72Expected<FileCache> localCache(
73 const Twine &CacheNameRef, const Twine &TempFilePrefixRef,
74 const Twine &CacheDirectoryPathRef,
75 AddBufferFn AddBuffer = [](size_t Task, const Twine &ModuleName,
76 std::unique_ptr<MemoryBuffer> MB) {});
77} // namespace llvm
78
79#endif
80

source code of llvm/include/llvm/Support/Caching.h