llvm-project

1
//===--- ModuleAssistant.cpp - Module map generation manager --*- 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 module generation entry point function,
10
// createModuleMap, a Module class for representing a module,
11
// and various implementation functions for doing the underlying
12
// work, described below.
13
//
14
// The "Module" class represents a module, with members for storing the module
15
// name, associated header file names, and sub-modules, and an "output"
16
// function that recursively writes the module definitions.
17
//
18
// The "createModuleMap" function implements the top-level logic of the
19
// assistant mode.  It calls a loadModuleDescriptions function to walk
20
// the header list passed to it and creates a tree of Module objects
21
// representing the module hierarchy, represented by a "Module" object,
22
// the "RootModule".  This root module may or may not represent an actual
23
// module in the module map, depending on the "--root-module" option passed
24
// to modularize.  It then calls a writeModuleMap function to set up the
25
// module map file output and walk the module tree, outputting the module
26
// map file using a stream obtained and managed by an
27
// llvm::ToolOutputFile object.
28
//
29
//===----------------------------------------------------------------------===//
30

31
#include "Modularize.h"
32
#include "llvm/ADT/SmallString.h"
33
#include "llvm/Support/FileSystem.h"
34
#include "llvm/Support/Path.h"
35
#include "llvm/Support/ToolOutputFile.h"
36
#include <vector>
37

38
// Local definitions:
39

40
namespace {
41

42
// Internal class definitions:
43

44
// Represents a module.
45
class Module {
46
public:
47
  Module(llvm::StringRef Name, bool Problem);
48
  ~Module();
49
  bool output(llvm::raw_fd_ostream &OS, int Indent);
50
  Module *findSubModule(llvm::StringRef SubName);
51

52
public:
53
  std::string Name;
54
  std::vector<std::string> HeaderFileNames;
55
  std::vector<Module *> SubModules;
56
  bool IsProblem;
57
};
58

59
} // end anonymous namespace.
60

61
// Module functions:
62

63
// Constructors.
64
Module::Module(llvm::StringRef Name, bool Problem)
65
  : Name(Name), IsProblem(Problem) {}
66

67
// Destructor.
68
Module::~Module() {
69
  // Free submodules.
70
  while (!SubModules.empty()) {
71
    Module *last = SubModules.back();
72
    SubModules.pop_back();
73
    delete last;
74
  }
75
}
76

77
// Write a module hierarchy to the given output stream.
78
bool Module::output(llvm::raw_fd_ostream &OS, int Indent) {
79
  // If this is not the nameless root module, start a module definition.
80
  if (Name.size() != 0) {
81
    OS.indent(Indent);
82
    OS << "module " << Name << " {\n";
83
    Indent += 2;
84
  }
85

86
  // Output submodules.
87
  for (auto I = SubModules.begin(), E = SubModules.end(); I != E; ++I) {
88
    if (!(*I)->output(OS, Indent))
89
      return false;
90
  }
91

92
  // Output header files.
93
  for (auto I = HeaderFileNames.begin(), E = HeaderFileNames.end(); I != E;
94
       ++I) {
95
    OS.indent(Indent);
96
    if (IsProblem || strstr((*I).c_str(), ".inl"))
97
      OS << "exclude header \"" << *I << "\"\n";
98
    else
99
      OS << "header \"" << *I << "\"\n";
100
  }
101

102
  // If this module has header files, output export directive.
103
  if (HeaderFileNames.size() != 0) {
104
    OS.indent(Indent);
105
    OS << "export *\n";
106
  }
107

108
  // If this is not the nameless root module, close the module definition.
109
  if (Name.size() != 0) {
110
    Indent -= 2;
111
    OS.indent(Indent);
112
    OS << "}\n";
113
  }
114

115
  return true;
116
}
117

118
// Lookup a sub-module.
119
Module *Module::findSubModule(llvm::StringRef SubName) {
120
  for (auto I = SubModules.begin(), E = SubModules.end(); I != E; ++I) {
121
    if ((*I)->Name == SubName)
122
      return *I;
123
  }
124
  return nullptr;
125
}
126

127
// Implementation functions:
128

129
// Reserved keywords in module.modulemap syntax.
130
// Keep in sync with keywords in module map parser in Lex/ModuleMap.cpp,
131
// such as in ModuleMapParser::consumeToken().
132
static const char *const ReservedNames[] = {
133
  "config_macros", "export",   "module", "conflict", "framework",
134
  "requires",      "exclude",  "header", "private",  "explicit",
135
  "link",          "umbrella", "extern", "use",      nullptr // Flag end.
136
};
137

138
// Convert module name to a non-keyword.
139
// Prepends a '_' to the name if and only if the name is a keyword.
140
static std::string
141
ensureNoCollisionWithReservedName(llvm::StringRef MightBeReservedName) {
142
  std::string SafeName(MightBeReservedName);
143
  for (int Index = 0; ReservedNames[Index] != nullptr; ++Index) {
144
    if (MightBeReservedName == ReservedNames[Index]) {
145
      SafeName.insert(0, "_");
146
      break;
147
    }
148
  }
149
  return SafeName;
150
}
151

152
// Convert module name to a non-keyword.
153
// Prepends a '_' to the name if and only if the name is a keyword.
154
static std::string
155
ensureVaidModuleName(llvm::StringRef MightBeInvalidName) {
156
  std::string SafeName(MightBeInvalidName);
157
  std::replace(SafeName.begin(), SafeName.end(), '-', '_');
158
  std::replace(SafeName.begin(), SafeName.end(), '.', '_');
159
  if (isdigit(SafeName[0]))
160
    SafeName = "_" + SafeName;
161
  return SafeName;
162
}
163

164
// Add one module, given a header file path.
165
static bool addModuleDescription(Module *RootModule,
166
                                 llvm::StringRef HeaderFilePath,
167
                                 llvm::StringRef HeaderPrefix,
168
                                 DependencyMap &Dependencies,
169
                                 bool IsProblemFile) {
170
  Module *CurrentModule = RootModule;
171
  DependentsVector &FileDependents = Dependencies[HeaderFilePath];
172
  std::string FilePath;
173
  // Strip prefix.
174
  // HeaderFilePath should be compared to natively-canonicalized Prefix.
175
  llvm::SmallString<256> NativePath, NativePrefix;
176
  llvm::sys::path::native(HeaderFilePath, NativePath);
177
  llvm::sys::path::native(HeaderPrefix, NativePrefix);
178
  if (NativePath.starts_with(NativePrefix))
179
    FilePath = std::string(NativePath.substr(NativePrefix.size() + 1));
180
  else
181
    FilePath = std::string(HeaderFilePath);
182
  int Count = FileDependents.size();
183
  // Headers that go into modules must not depend on other files being
184
  // included first.  If there are any dependents, warn user and omit.
185
  if (Count != 0) {
186
    llvm::errs() << "warning: " << FilePath
187
                 << " depends on other headers being included first,"
188
                    " meaning the module.modulemap won't compile."
189
                    "  This header will be omitted from the module map.\n";
190
    return true;
191
  }
192
  // Make canonical.
193
  std::replace(FilePath.begin(), FilePath.end(), '\\', '/');
194
  // Insert module into tree, using subdirectories as submodules.
195
  for (llvm::sys::path::const_iterator I = llvm::sys::path::begin(FilePath),
196
                                       E = llvm::sys::path::end(FilePath);
197
       I != E; ++I) {
198
    if ((*I)[0] == '.')
199
      continue;
200
    std::string Stem(llvm::sys::path::stem(*I));
201
    Stem = ensureNoCollisionWithReservedName(Stem);
202
    Stem = ensureVaidModuleName(Stem);
203
    Module *SubModule = CurrentModule->findSubModule(Stem);
204
    if (!SubModule) {
205
      SubModule = new Module(Stem, IsProblemFile);
206
      CurrentModule->SubModules.push_back(SubModule);
207
    }
208
    CurrentModule = SubModule;
209
  }
210
  // Add header file name to headers.
211
  CurrentModule->HeaderFileNames.push_back(FilePath);
212
  return true;
213
}
214

215
// Create the internal module tree representation.
216
static Module *loadModuleDescriptions(
217
    llvm::StringRef RootModuleName, llvm::ArrayRef<std::string> HeaderFileNames,
218
    llvm::ArrayRef<std::string> ProblemFileNames,
219
    DependencyMap &Dependencies, llvm::StringRef HeaderPrefix) {
220

221
  // Create root module.
222
  auto *RootModule = new Module(RootModuleName, false);
223

224
  llvm::SmallString<256> CurrentDirectory;
225
  llvm::sys::fs::current_path(CurrentDirectory);
226

227
  // If no header prefix, use current directory.
228
  if (HeaderPrefix.size() == 0)
229
    HeaderPrefix = CurrentDirectory;
230

231
  // Walk the header file names and output the module map.
232
  for (llvm::ArrayRef<std::string>::iterator I = HeaderFileNames.begin(),
233
                                             E = HeaderFileNames.end();
234
       I != E; ++I) {
235
    std::string Header(*I);
236
    bool IsProblemFile = false;
237
    for (auto &ProblemFile : ProblemFileNames) {
238
      if (ProblemFile == Header) {
239
        IsProblemFile = true;
240
        break;
241
      }
242
    }
243
    // Add as a module.
244
    if (!addModuleDescription(RootModule, Header, HeaderPrefix, Dependencies, IsProblemFile))
245
      return nullptr;
246
  }
247

248
  return RootModule;
249
}
250

251
// Kick off the writing of the module map.
252
static bool writeModuleMap(llvm::StringRef ModuleMapPath,
253
                           llvm::StringRef HeaderPrefix, Module *RootModule) {
254
  llvm::SmallString<256> HeaderDirectory(ModuleMapPath);
255
  llvm::sys::path::remove_filename(HeaderDirectory);
256
  llvm::SmallString<256> FilePath;
257

258
  // Get the module map file path to be used.
259
  if ((HeaderDirectory.size() == 0) && (HeaderPrefix.size() != 0)) {
260
    FilePath = HeaderPrefix;
261
    // Prepend header file name prefix if it's not absolute.
262
    llvm::sys::path::append(FilePath, ModuleMapPath);
263
    llvm::sys::path::native(FilePath);
264
  } else {
265
    FilePath = ModuleMapPath;
266
    llvm::sys::path::native(FilePath);
267
  }
268

269
  // Set up module map output file.
270
  std::error_code EC;
271
  llvm::ToolOutputFile Out(FilePath, EC, llvm::sys::fs::OF_TextWithCRLF);
272
  if (EC) {
273
    llvm::errs() << Argv0 << ": error opening " << FilePath << ":"
274
                 << EC.message() << "\n";
275
    return false;
276
  }
277

278
  // Get output stream from tool output buffer/manager.
279
  llvm::raw_fd_ostream &OS = Out.os();
280

281
  // Output file comment.
282
  OS << "// " << ModuleMapPath << "\n";
283
  OS << "// Generated by: " << CommandLine << "\n\n";
284

285
  // Write module hierarchy from internal representation.
286
  if (!RootModule->output(OS, 0))
287
    return false;
288

289
  // Tell ToolOutputFile that we want to keep the file.
290
  Out.keep();
291

292
  return true;
293
}
294

295
// Global functions:
296

297
// Module map generation entry point.
298
bool createModuleMap(llvm::StringRef ModuleMapPath,
299
                     llvm::ArrayRef<std::string> HeaderFileNames,
300
                     llvm::ArrayRef<std::string> ProblemFileNames,
301
                     DependencyMap &Dependencies, llvm::StringRef HeaderPrefix,
302
                     llvm::StringRef RootModuleName) {
303
  // Load internal representation of modules.
304
  std::unique_ptr<Module> RootModule(
305
    loadModuleDescriptions(
306
      RootModuleName, HeaderFileNames, ProblemFileNames, Dependencies,
307
      HeaderPrefix));
308
  if (!RootModule)
309
    return false;
310

311
  // Write module map file.
312
  return writeModuleMap(ModuleMapPath, HeaderPrefix, RootModule.get());
313
}
314