Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
14 pmbaty 1
//===- llvm/TextAPI/InterfaceFile.h - TAPI Interface File -------*- 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
// A generic and abstract interface representation for linkable objects. This
10
// could be an MachO executable, bundle, dylib, or text-based stub file.
11
//
12
//===----------------------------------------------------------------------===//
13
 
14
#ifndef LLVM_TEXTAPI_INTERFACEFILE_H
15
#define LLVM_TEXTAPI_INTERFACEFILE_H
16
 
17
#include "llvm/ADT/BitmaskEnum.h"
18
#include "llvm/ADT/DenseMap.h"
19
#include "llvm/ADT/Hashing.h"
20
#include "llvm/ADT/StringRef.h"
21
#include "llvm/ADT/iterator.h"
22
#include "llvm/Support/Allocator.h"
23
#include "llvm/TextAPI/ArchitectureSet.h"
24
#include "llvm/TextAPI/PackedVersion.h"
25
#include "llvm/TextAPI/Platform.h"
26
#include "llvm/TextAPI/Symbol.h"
27
#include "llvm/TextAPI/Target.h"
28
 
29
namespace llvm {
30
namespace MachO {
31
 
32
/// Defines a list of Objective-C constraints.
33
enum class ObjCConstraintType : unsigned {
34
  /// No constraint.
35
  None = 0,
36
 
37
  /// Retain/Release.
38
  Retain_Release = 1,
39
 
40
  /// Retain/Release for Simulator.
41
  Retain_Release_For_Simulator = 2,
42
 
43
  /// Retain/Release or Garbage Collection.
44
  Retain_Release_Or_GC = 3,
45
 
46
  /// Garbage Collection.
47
  GC = 4,
48
};
49
 
50
// clang-format off
51
 
52
/// Defines the file type this file represents.
53
enum FileType : unsigned {
54
  /// Invalid file type.
55
  Invalid = 0U,
56
 
57
  /// Text-based stub file (.tbd) version 1.0
58
  TBD_V1  = 1U <<  0,
59
 
60
  /// Text-based stub file (.tbd) version 2.0
61
  TBD_V2  = 1U <<  1,
62
 
63
  /// Text-based stub file (.tbd) version 3.0
64
  TBD_V3  = 1U <<  2,
65
 
66
  /// Text-based stub file (.tbd) version 4.0
67
  TBD_V4  = 1U <<  3,
68
 
69
  All     = ~0U,
70
 
71
  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/All),
72
};
73
 
74
// clang-format on
75
 
76
/// Reference to an interface file.
77
class InterfaceFileRef {
78
public:
79
  InterfaceFileRef() = default;
80
 
81
  InterfaceFileRef(StringRef InstallName) : InstallName(InstallName) {}
82
 
83
  InterfaceFileRef(StringRef InstallName, const TargetList Targets)
84
      : InstallName(InstallName), Targets(std::move(Targets)) {}
85
 
86
  StringRef getInstallName() const { return InstallName; };
87
 
88
  void addTarget(const Target &Target);
89
  template <typename RangeT> void addTargets(RangeT &&Targets) {
90
    for (const auto &Target : Targets)
91
      addTarget(Target(Target));
92
  }
93
 
94
  using const_target_iterator = TargetList::const_iterator;
95
  using const_target_range = llvm::iterator_range<const_target_iterator>;
96
  const_target_range targets() const { return {Targets}; }
97
 
98
  ArchitectureSet getArchitectures() const {
99
    return mapToArchitectureSet(Targets);
100
  }
101
 
102
  PlatformSet getPlatforms() const { return mapToPlatformSet(Targets); }
103
 
104
  bool operator==(const InterfaceFileRef &O) const {
105
    return std::tie(InstallName, Targets) == std::tie(O.InstallName, O.Targets);
106
  }
107
 
108
  bool operator!=(const InterfaceFileRef &O) const {
109
    return std::tie(InstallName, Targets) != std::tie(O.InstallName, O.Targets);
110
  }
111
 
112
  bool operator<(const InterfaceFileRef &O) const {
113
    return std::tie(InstallName, Targets) < std::tie(O.InstallName, O.Targets);
114
  }
115
 
116
private:
117
  std::string InstallName;
118
  TargetList Targets;
119
};
120
 
121
} // end namespace MachO.
122
 
123
struct SymbolsMapKey {
124
  MachO::SymbolKind Kind;
125
  StringRef Name;
126
 
127
  SymbolsMapKey(MachO::SymbolKind Kind, StringRef Name)
128
      : Kind(Kind), Name(Name) {}
129
};
130
template <> struct DenseMapInfo<SymbolsMapKey> {
131
  static inline SymbolsMapKey getEmptyKey() {
132
    return SymbolsMapKey(MachO::SymbolKind::GlobalSymbol, StringRef{});
133
  }
134
 
135
  static inline SymbolsMapKey getTombstoneKey() {
136
    return SymbolsMapKey(MachO::SymbolKind::ObjectiveCInstanceVariable,
137
                         StringRef{});
138
  }
139
 
140
  static unsigned getHashValue(const SymbolsMapKey &Key) {
141
    return hash_combine(hash_value(Key.Kind), hash_value(Key.Name));
142
  }
143
 
144
  static bool isEqual(const SymbolsMapKey &LHS, const SymbolsMapKey &RHS) {
145
    return std::tie(LHS.Kind, LHS.Name) == std::tie(RHS.Kind, RHS.Name);
146
  }
147
};
148
 
149
namespace MachO {
150
 
151
/// Defines the interface file.
152
class InterfaceFile {
153
public:
154
  /// Set the path from which this file was generated (if applicable).
155
  ///
156
  /// \param Path_ The path to the source file.
157
  void setPath(StringRef Path_) { Path = std::string(Path_); }
158
 
159
  /// Get the path from which this file was generated (if applicable).
160
  ///
161
  /// \return The path to the source file or empty.
162
  StringRef getPath() const { return Path; }
163
 
164
  /// Set the file type.
165
  ///
166
  /// This is used by the YAML writer to identify the specification it should
167
  /// use for writing the file.
168
  ///
169
  /// \param Kind The file type.
170
  void setFileType(FileType Kind) { FileKind = Kind; }
171
 
172
  /// Get the file type.
173
  ///
174
  /// \return The file type.
175
  FileType getFileType() const { return FileKind; }
176
 
177
  /// Get the architectures.
178
  ///
179
  /// \return The applicable architectures.
180
  ArchitectureSet getArchitectures() const {
181
    return mapToArchitectureSet(Targets);
182
  }
183
 
184
  /// Get the platforms.
185
  ///
186
  /// \return The applicable platforms.
187
  PlatformSet getPlatforms() const { return mapToPlatformSet(Targets); }
188
 
189
  /// Set and add target.
190
  ///
191
  /// \param Target the target to add into.
192
  void addTarget(const Target &Target);
193
 
194
  /// Set and add targets.
195
  ///
196
  /// Add the subset of llvm::triples that is supported by Tapi
197
  ///
198
  /// \param Targets the collection of targets.
199
  template <typename RangeT> void addTargets(RangeT &&Targets) {
200
    for (const auto &Target_ : Targets)
201
      addTarget(Target(Target_));
202
  }
203
 
204
  using const_target_iterator = TargetList::const_iterator;
205
  using const_target_range = llvm::iterator_range<const_target_iterator>;
206
  const_target_range targets() const { return {Targets}; }
207
 
208
  using const_filtered_target_iterator =
209
      llvm::filter_iterator<const_target_iterator,
210
                            std::function<bool(const Target &)>>;
211
  using const_filtered_target_range =
212
      llvm::iterator_range<const_filtered_target_iterator>;
213
  const_filtered_target_range targets(ArchitectureSet Archs) const;
214
 
215
  /// Set the install name of the library.
216
  void setInstallName(StringRef InstallName_) {
217
    InstallName = std::string(InstallName_);
218
  }
219
 
220
  /// Get the install name of the library.
221
  StringRef getInstallName() const { return InstallName; }
222
 
223
  /// Set the current version of the library.
224
  void setCurrentVersion(PackedVersion Version) { CurrentVersion = Version; }
225
 
226
  /// Get the current version of the library.
227
  PackedVersion getCurrentVersion() const { return CurrentVersion; }
228
 
229
  /// Set the compatibility version of the library.
230
  void setCompatibilityVersion(PackedVersion Version) {
231
    CompatibilityVersion = Version;
232
  }
233
 
234
  /// Get the compatibility version of the library.
235
  PackedVersion getCompatibilityVersion() const { return CompatibilityVersion; }
236
 
237
  /// Set the Swift ABI version of the library.
238
  void setSwiftABIVersion(uint8_t Version) { SwiftABIVersion = Version; }
239
 
240
  /// Get the Swift ABI version of the library.
241
  uint8_t getSwiftABIVersion() const { return SwiftABIVersion; }
242
 
243
  /// Specify if the library uses two-level namespace (or flat namespace).
244
  void setTwoLevelNamespace(bool V = true) { IsTwoLevelNamespace = V; }
245
 
246
  /// Check if the library uses two-level namespace.
247
  bool isTwoLevelNamespace() const { return IsTwoLevelNamespace; }
248
 
249
  /// Specify if the library is application extension safe (or not).
250
  void setApplicationExtensionSafe(bool V = true) { IsAppExtensionSafe = V; }
251
 
252
  /// Check if the library is application extension safe.
253
  bool isApplicationExtensionSafe() const { return IsAppExtensionSafe; }
254
 
255
  /// Set the Objective-C constraint.
256
  void setObjCConstraint(ObjCConstraintType Constraint) {
257
    ObjcConstraint = Constraint;
258
  }
259
 
260
  /// Get the Objective-C constraint.
261
  ObjCConstraintType getObjCConstraint() const { return ObjcConstraint; }
262
 
263
  /// Specify if this file was generated during InstallAPI (or not).
264
  void setInstallAPI(bool V = true) { IsInstallAPI = V; }
265
 
266
  /// Check if this file was generated during InstallAPI.
267
  bool isInstallAPI() const { return IsInstallAPI; }
268
 
269
  /// Set the parent umbrella frameworks.
270
  /// \param Target_ The target applicable to Parent
271
  /// \param Parent  The name of Parent
272
  void addParentUmbrella(const Target &Target_, StringRef Parent);
273
 
274
  /// Get the list of Parent Umbrella frameworks.
275
  ///
276
  /// \return Returns a list of target information and install name of parent
277
  /// umbrellas.
278
  const std::vector<std::pair<Target, std::string>> &umbrellas() const {
279
    return ParentUmbrellas;
280
  }
281
 
282
  /// Add an allowable client.
283
  ///
284
  /// Mach-O Dynamic libraries have the concept of allowable clients that are
285
  /// checked during static link time. The name of the application or library
286
  /// that is being generated needs to match one of the allowable clients or the
287
  /// linker refuses to link this library.
288
  ///
289
  /// \param InstallName The name of the client that is allowed to link this
290
  /// library.
291
  /// \param Target The target triple for which this applies.
292
  void addAllowableClient(StringRef InstallName, const Target &Target);
293
 
294
  /// Get the list of allowable clients.
295
  ///
296
  /// \return Returns a list of allowable clients.
297
  const std::vector<InterfaceFileRef> &allowableClients() const {
298
    return AllowableClients;
299
  }
300
 
301
  /// Add a re-exported library.
302
  ///
303
  /// \param InstallName The name of the library to re-export.
304
  /// \param Target The target triple for which this applies.
305
  void addReexportedLibrary(StringRef InstallName, const Target &Target);
306
 
307
  /// Get the list of re-exported libraries.
308
  ///
309
  /// \return Returns a list of re-exported libraries.
310
  const std::vector<InterfaceFileRef> &reexportedLibraries() const {
311
    return ReexportedLibraries;
312
  }
313
 
314
  /// Add an Target/UUID pair.
315
  ///
316
  /// \param Target The target triple for which this applies.
317
  /// \param UUID The UUID of the library for the specified architecture.
318
  void addUUID(const Target &Target, StringRef UUID);
319
 
320
  /// Add an Target/UUID pair.
321
  ///
322
  /// \param Target The target triple for which this applies.
323
  /// \param UUID The UUID of the library for the specified architecture.
324
  void addUUID(const Target &Target, uint8_t UUID[16]);
325
 
326
  /// Get the list of Target/UUID pairs.
327
  ///
328
  /// \return Returns a list of Target/UUID pairs.
329
  const std::vector<std::pair<Target, std::string>> &uuids() const {
330
    return UUIDs;
331
  }
332
 
333
  /// Add a library for inlining to top level library.
334
  ///
335
  ///\param Document The library to inline with top level library.
336
  void addDocument(std::shared_ptr<InterfaceFile> &&Document);
337
 
338
  /// Returns the pointer to parent document if exists or nullptr otherwise.
339
  InterfaceFile *getParent() const { return Parent; }
340
 
341
  /// Get the list of inlined libraries.
342
  ///
343
  /// \return Returns a list of the inlined frameworks.
344
  const std::vector<std::shared_ptr<InterfaceFile>> &documents() const {
345
    return Documents;
346
  }
347
 
348
  /// Add a symbol to the symbols list or extend an existing one.
349
  void addSymbol(SymbolKind Kind, StringRef Name, const TargetList &Targets,
350
                 SymbolFlags Flags = SymbolFlags::None);
351
 
352
  using SymbolMapType = DenseMap<SymbolsMapKey, Symbol *>;
353
  struct const_symbol_iterator
354
      : public iterator_adaptor_base<
355
            const_symbol_iterator, SymbolMapType::const_iterator,
356
            std::forward_iterator_tag, const Symbol *, ptrdiff_t,
357
            const Symbol *, const Symbol *> {
358
    const_symbol_iterator() = default;
359
 
360
    template <typename U>
361
    const_symbol_iterator(U &&u)
362
        : iterator_adaptor_base(std::forward<U &&>(u)) {}
363
 
364
    reference operator*() const { return I->second; }
365
    pointer operator->() const { return I->second; }
366
  };
367
 
368
  using const_symbol_range = iterator_range<const_symbol_iterator>;
369
 
370
  using const_filtered_symbol_iterator =
371
      filter_iterator<const_symbol_iterator,
372
                      std::function<bool(const Symbol *)>>;
373
  using const_filtered_symbol_range =
374
      iterator_range<const_filtered_symbol_iterator>;
375
 
376
  const_symbol_range symbols() const {
377
    return {Symbols.begin(), Symbols.end()};
378
  }
379
 
380
  size_t symbolsCount() const { return Symbols.size(); }
381
 
382
  const_filtered_symbol_range exports() const {
383
    std::function<bool(const Symbol *)> fn = [](const Symbol *Symbol) {
384
      return !Symbol->isUndefined();
385
    };
386
    return make_filter_range(
387
        make_range<const_symbol_iterator>({Symbols.begin()}, {Symbols.end()}),
388
        fn);
389
  }
390
 
391
  const_filtered_symbol_range undefineds() const {
392
    std::function<bool(const Symbol *)> fn = [](const Symbol *Symbol) {
393
      return Symbol->isUndefined();
394
    };
395
    return make_filter_range(
396
        make_range<const_symbol_iterator>({Symbols.begin()}, {Symbols.end()}),
397
        fn);
398
  }
399
 
400
  /// The equality is determined by attributes that impact linking
401
  /// compatibilities. UUIDs, Path, & FileKind are irrelevant since these by
402
  /// itself should not impact linking.
403
  /// This is an expensive operation.
404
  bool operator==(const InterfaceFile &O) const;
405
 
406
  bool operator!=(const InterfaceFile &O) const { return !(*this == O); }
407
 
408
private:
409
  llvm::BumpPtrAllocator Allocator;
410
  StringRef copyString(StringRef String) {
411
    if (String.empty())
412
      return {};
413
 
414
    void *Ptr = Allocator.Allocate(String.size(), 1);
415
    memcpy(Ptr, String.data(), String.size());
416
    return StringRef(reinterpret_cast<const char *>(Ptr), String.size());
417
  }
418
 
419
  TargetList Targets;
420
  std::string Path;
421
  FileType FileKind;
422
  std::string InstallName;
423
  PackedVersion CurrentVersion;
424
  PackedVersion CompatibilityVersion;
425
  uint8_t SwiftABIVersion{0};
426
  bool IsTwoLevelNamespace{false};
427
  bool IsAppExtensionSafe{false};
428
  bool IsInstallAPI{false};
429
  ObjCConstraintType ObjcConstraint = ObjCConstraintType::None;
430
  std::vector<std::pair<Target, std::string>> ParentUmbrellas;
431
  std::vector<InterfaceFileRef> AllowableClients;
432
  std::vector<InterfaceFileRef> ReexportedLibraries;
433
  std::vector<std::shared_ptr<InterfaceFile>> Documents;
434
  std::vector<std::pair<Target, std::string>> UUIDs;
435
  SymbolMapType Symbols;
436
  InterfaceFile *Parent = nullptr;
437
};
438
 
439
template <typename DerivedT, typename KeyInfoT, typename BucketT>
440
bool operator==(const DenseMapBase<DerivedT, SymbolsMapKey, MachO::Symbol *,
441
                                   KeyInfoT, BucketT> &LHS,
442
                const DenseMapBase<DerivedT, SymbolsMapKey, MachO::Symbol *,
443
                                   KeyInfoT, BucketT> &RHS) {
444
  if (LHS.size() != RHS.size())
445
    return false;
446
  for (const auto &KV : LHS) {
447
    auto I = RHS.find(KV.first);
448
    if (I == RHS.end() || *I->second != *KV.second)
449
      return false;
450
  }
451
  return true;
452
}
453
 
454
} // end namespace MachO.
455
} // end namespace llvm.
456
 
457
#endif // LLVM_TEXTAPI_INTERFACEFILE_H