Coverage Report

Created: 2019-05-19 14:56

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/Lex/DirectoryLookup.h
Line
Count
Source (jump to first uncovered line)
1
//===--- DirectoryLookup.h - Info for searching for headers -----*- 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 DirectoryLookup interface.
10
//
11
//===----------------------------------------------------------------------===//
12
13
#ifndef LLVM_CLANG_LEX_DIRECTORYLOOKUP_H
14
#define LLVM_CLANG_LEX_DIRECTORYLOOKUP_H
15
16
#include "clang/Basic/LLVM.h"
17
#include "clang/Basic/SourceManager.h"
18
#include "clang/Lex/ModuleMap.h"
19
20
namespace clang {
21
class HeaderMap;
22
class DirectoryEntry;
23
class FileEntry;
24
class HeaderSearch;
25
class Module;
26
27
/// DirectoryLookup - This class represents one entry in the search list that
28
/// specifies the search order for directories in \#include directives.  It
29
/// represents either a directory, a framework, or a headermap.
30
///
31
0
class DirectoryLookup {
32
public:
33
  enum LookupType_t {
34
    LT_NormalDir,
35
    LT_Framework,
36
    LT_HeaderMap
37
  };
38
private:
39
0
  union {  // This union is discriminated by isHeaderMap.
40
    /// Dir - This is the actual directory that we're referring to for a normal
41
    /// directory or a framework.
42
    const DirectoryEntry *Dir;
43
44
    /// Map - This is the HeaderMap if this is a headermap lookup.
45
    ///
46
    const HeaderMap *Map;
47
  } u;
48
49
  /// DirCharacteristic - The type of directory this is: this is an instance of
50
  /// SrcMgr::CharacteristicKind.
51
  unsigned DirCharacteristic : 2;
52
53
  /// LookupType - This indicates whether this DirectoryLookup object is a
54
  /// normal directory, a framework, or a headermap.
55
  unsigned LookupType : 2;
56
57
  /// Whether this is a header map used when building a framework.
58
  unsigned IsIndexHeaderMap : 1;
59
60
  /// Whether we've performed an exhaustive search for module maps
61
  /// within the subdirectories of this directory.
62
  unsigned SearchedAllModuleMaps : 1;
63
64
public:
65
  /// DirectoryLookup ctor - Note that this ctor *does not take ownership* of
66
  /// 'dir'.
67
  DirectoryLookup(const DirectoryEntry *dir, SrcMgr::CharacteristicKind DT,
68
                  bool isFramework)
69
    : DirCharacteristic(DT),
70
      LookupType(isFramework ? LT_Framework : LT_NormalDir),
71
108k
      IsIndexHeaderMap(false), SearchedAllModuleMaps(false) {
72
108k
    u.Dir = dir;
73
108k
  }
74
75
  /// DirectoryLookup ctor - Note that this ctor *does not take ownership* of
76
  /// 'map'.
77
  DirectoryLookup(const HeaderMap *map, SrcMgr::CharacteristicKind DT,
78
                  bool isIndexHeaderMap)
79
    : DirCharacteristic(DT), LookupType(LT_HeaderMap),
80
28
      IsIndexHeaderMap(isIndexHeaderMap), SearchedAllModuleMaps(false) {
81
28
    u.Map = map;
82
28
  }
83
84
  /// getLookupType - Return the kind of directory lookup that this is: either a
85
  /// normal directory, a framework path, or a HeaderMap.
86
7.52M
  LookupType_t getLookupType() const { return (LookupType_t)LookupType; }
87
88
  /// getName - Return the directory or filename corresponding to this lookup
89
  /// object.
90
  StringRef getName() const;
91
92
  /// getDir - Return the directory that this entry refers to.
93
  ///
94
4.79M
  const DirectoryEntry *getDir() const {
95
4.79M
    return isNormalDir() ? u.Dir : 
nullptr0
;
96
4.79M
  }
97
98
  /// getFrameworkDir - Return the directory that this framework refers to.
99
  ///
100
42.1k
  const DirectoryEntry *getFrameworkDir() const {
101
18.4E
    return isFramework() ? 
u.Dir42.1k
: nullptr;
102
42.1k
  }
103
104
  /// getHeaderMap - Return the directory that this entry refers to.
105
  ///
106
76
  const HeaderMap *getHeaderMap() const {
107
76
    return isHeaderMap() ? u.Map : 
nullptr0
;
108
76
  }
109
110
  /// isNormalDir - Return true if this is a normal directory, not a header map.
111
6.51M
  bool isNormalDir() const { return getLookupType() == LT_NormalDir; }
112
113
  /// isFramework - True if this is a framework directory.
114
  ///
115
91.8k
  bool isFramework() const { return getLookupType() == LT_Framework; }
116
117
  /// isHeaderMap - Return true if this is a header map, not a normal directory.
118
867k
  bool isHeaderMap() const { return getLookupType() == LT_HeaderMap; }
119
120
  /// Determine whether we have already searched this entire
121
  /// directory for module maps.
122
180
  bool haveSearchedAllModuleMaps() const { return SearchedAllModuleMaps; }
123
124
  /// Specify whether we have already searched all of the subdirectories
125
  /// for module maps.
126
79
  void setSearchedAllModuleMaps(bool SAMM) {
127
79
    SearchedAllModuleMaps = SAMM;
128
79
  }
129
130
  /// DirCharacteristic - The type of directory this is, one of the DirType enum
131
  /// values.
132
2.49M
  SrcMgr::CharacteristicKind getDirCharacteristic() const {
133
2.49M
    return (SrcMgr::CharacteristicKind)DirCharacteristic;
134
2.49M
  }
135
136
  /// Whether this describes a system header directory.
137
1.57M
  bool isSystemHeaderDirectory() const {
138
1.57M
    return getDirCharacteristic() != SrcMgr::C_User;
139
1.57M
  }
140
141
  /// Whether this header map is building a framework or not.
142
867k
  bool isIndexHeaderMap() const {
143
867k
    return isHeaderMap() && 
IsIndexHeaderMap0
;
144
867k
  }
145
146
  /// LookupFile - Lookup the specified file in this search path, returning it
147
  /// if it exists or returning null if not.
148
  ///
149
  /// \param Filename The file to look up relative to the search paths.
150
  ///
151
  /// \param HS The header search instance to search with.
152
  ///
153
  /// \param IncludeLoc the source location of the #include or #import
154
  /// directive.
155
  ///
156
  /// \param SearchPath If not NULL, will be set to the search path relative
157
  /// to which the file was found.
158
  ///
159
  /// \param RelativePath If not NULL, will be set to the path relative to
160
  /// SearchPath at which the file was found. This only differs from the
161
  /// Filename for framework includes.
162
  ///
163
  /// \param RequestingModule The module in which the lookup was performed.
164
  ///
165
  /// \param SuggestedModule If non-null, and the file found is semantically
166
  /// part of a known module, this will be set to the module that should
167
  /// be imported instead of preprocessing/parsing the file found.
168
  ///
169
  /// \param [out] InUserSpecifiedSystemFramework If the file is found,
170
  /// set to true if the file is located in a framework that has been
171
  /// user-specified to be treated as a system framework.
172
  ///
173
  /// \param [out] IsFrameworkFound For a framework directory set to true if
174
  /// specified '.framework' directory is found.
175
  ///
176
  /// \param [out] MappedName if this is a headermap which maps the filename to
177
  /// a framework include ("Foo.h" -> "Foo/Foo.h"), set the new name to this
178
  /// vector and point Filename to it.
179
  const FileEntry *LookupFile(StringRef &Filename, HeaderSearch &HS,
180
                              SourceLocation IncludeLoc,
181
                              SmallVectorImpl<char> *SearchPath,
182
                              SmallVectorImpl<char> *RelativePath,
183
                              Module *RequestingModule,
184
                              ModuleMap::KnownHeader *SuggestedModule,
185
                              bool &InUserSpecifiedSystemFramework,
186
                              bool &IsFrameworkFound,
187
                              bool &HasBeenMapped,
188
                              SmallVectorImpl<char> &MappedName) const;
189
190
private:
191
  const FileEntry *DoFrameworkLookup(
192
      StringRef Filename, HeaderSearch &HS,
193
      SmallVectorImpl<char> *SearchPath,
194
      SmallVectorImpl<char> *RelativePath,
195
      Module *RequestingModule,
196
      ModuleMap::KnownHeader *SuggestedModule,
197
      bool &InUserSpecifiedSystemFramework,
198
      bool &IsFrameworkFound) const;
199
200
};
201
202
}  // end namespace clang
203
204
#endif