| //===--- PreprocessorTracker.cpp - Preprocessor tracking -*- C++ -*------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===--------------------------------------------------------------------===// |
| // |
| // The Basic Idea (Macro and Conditional Checking) |
| // |
| // Basically we install a PPCallbacks-derived object to track preprocessor |
| // activity, namely when a header file is entered/exited, when a macro |
| // is expanded, when "defined" is used, and when #if, #elif, #ifdef, |
| // and #ifndef are used. We save the state of macro and "defined" |
| // expressions in a map, keyed on a name/file/line/column quadruple. |
| // The map entries store the different states (values) that a macro expansion, |
| // "defined" expression, or condition expression has in the course of |
| // processing for the one location in the one header containing it, |
| // plus a list of the nested include stacks for the states. When a macro |
| // or "defined" expression evaluates to the same value, which is the |
| // desired case, only one state is stored. Similarly, for conditional |
| // directives, we save the condition expression states in a separate map. |
| // |
| // This information is collected as modularize compiles all the headers |
| // given to it to process. After all the compilations are performed, |
| // a check is performed for any entries in the maps that contain more |
| // than one different state, and for these an output message is generated. |
| // |
| // For example: |
| // |
| // (...)/SubHeader.h:11:5: |
| // #if SYMBOL == 1 |
| // ^ |
| // error: Macro instance 'SYMBOL' has different values in this header, |
| // depending on how it was included. |
| // 'SYMBOL' expanded to: '1' with respect to these inclusion paths: |
| // (...)/Header1.h |
| // (...)/SubHeader.h |
| // (...)/SubHeader.h:3:9: |
| // #define SYMBOL 1 |
| // ^ |
| // Macro defined here. |
| // 'SYMBOL' expanded to: '2' with respect to these inclusion paths: |
| // (...)/Header2.h |
| // (...)/SubHeader.h |
| // (...)/SubHeader.h:7:9: |
| // #define SYMBOL 2 |
| // ^ |
| // Macro defined here. |
| // |
| // The Basic Idea ('Extern "C/C++" {}' Or 'namespace {}') With Nested |
| // '#include' Checking) |
| // |
| // To check for '#include' directives nested inside 'Extern "C/C++" {}' |
| // or 'namespace {}' blocks, we keep track of the '#include' directives |
| // while running the preprocessor, and later during a walk of the AST |
| // we call a function to check for any '#include' directies inside |
| // an 'Extern "C/C++" {}' or 'namespace {}' block, given its source |
| // range. |
| // |
| // Design and Implementation Details (Macro and Conditional Checking) |
| // |
| // A PreprocessorTrackerImpl class implements the PreprocessorTracker |
| // interface. It uses a PreprocessorCallbacks class derived from PPCallbacks |
| // to track preprocessor activity, namely entering/exiting a header, macro |
| // expansions, use of "defined" expressions, and #if, #elif, #ifdef, and |
| // #ifndef conditional directives. PreprocessorTrackerImpl stores a map |
| // of MacroExpansionTracker objects keyed on a name/file/line/column |
| // value represented by a light-weight PPItemKey value object. This |
| // is the key top-level data structure tracking the values of macro |
| // expansion instances. Similarly, it stores a map of ConditionalTracker |
| // objects with the same kind of key, for tracking preprocessor conditional |
| // directives. |
| // |
| // The MacroExpansionTracker object represents one macro reference or use |
| // of a "defined" expression in a header file. It stores a handle to a |
| // string representing the unexpanded macro instance, a handle to a string |
| // representing the unpreprocessed source line containing the unexpanded |
| // macro instance, and a vector of one or more MacroExpansionInstance |
| // objects. |
| // |
| // The MacroExpansionInstance object represents one or more expansions |
| // of a macro reference, for the case where the macro expands to the same |
| // value. MacroExpansionInstance stores a handle to a string representing |
| // the expanded macro value, a PPItemKey representing the file/line/column |
| // where the macro was defined, a handle to a string representing the source |
| // line containing the macro definition, and a vector of InclusionPathHandle |
| // values that represents the hierarchies of include files for each case |
| // where the particular header containing the macro reference was referenced |
| // or included. |
| |
| // In the normal case where a macro instance always expands to the same |
| // value, the MacroExpansionTracker object will only contain one |
| // MacroExpansionInstance representing all the macro expansion instances. |
| // If a case was encountered where a macro instance expands to a value |
| // that is different from that seen before, or the macro was defined in |
| // a different place, a new MacroExpansionInstance object representing |
| // that case will be added to the vector in MacroExpansionTracker. If a |
| // macro instance expands to a value already seen before, the |
| // InclusionPathHandle representing that case's include file hierarchy |
| // will be added to the existing MacroExpansionInstance object. |
| |
| // For checking conditional directives, the ConditionalTracker class |
| // functions similarly to MacroExpansionTracker, but tracks an #if, |
| // #elif, #ifdef, or #ifndef directive in a header file. It stores |
| // a vector of one or two ConditionalExpansionInstance objects, |
| // representing the cases where the conditional expression evaluates |
| // to true or false. This latter object stores the evaluated value |
| // of the condition expression (a bool) and a vector of |
| // InclusionPathHandles. |
| // |
| // To reduce the instances of string and object copying, the |
| // PreprocessorTrackerImpl class uses a StringPool to save all stored |
| // strings, and defines a StringHandle type to abstract the references |
| // to the strings. |
| // |
| // PreprocessorTrackerImpl also maintains a list representing the unique |
| // headers, which is just a vector of StringHandle's for the header file |
| // paths. A HeaderHandle abstracts a reference to a header, and is simply |
| // the index of the stored header file path. |
| // |
| // A HeaderInclusionPath class abstracts a unique hierarchy of header file |
| // inclusions. It simply stores a vector of HeaderHandles ordered from the |
| // top-most header (the one from the header list passed to modularize) down |
| // to the header containing the macro reference. PreprocessorTrackerImpl |
| // stores a vector of these objects. An InclusionPathHandle typedef |
| // abstracts a reference to one of the HeaderInclusionPath objects, and is |
| // simply the index of the stored HeaderInclusionPath object. The |
| // MacroExpansionInstance object stores a vector of these handles so that |
| // the reporting function can display the include hierarchies for the macro |
| // expansion instances represented by that object, to help the user |
| // understand how the header was included. (A future enhancement might |
| // be to associate a line number for the #include directives, but I |
| // think not doing so is good enough for the present.) |
| // |
| // A key reason for using these opaque handles was to try to keep all the |
| // internal objects light-weight value objects, in order to reduce string |
| // and object copying overhead, and to abstract this implementation detail. |
| // |
| // The key data structures are built up while modularize runs the headers |
| // through the compilation. A PreprocessorTracker instance is created and |
| // passed down to the AST action and consumer objects in modularize. For |
| // each new compilation instance, the consumer calls the |
| // PreprocessorTracker's handleNewPreprocessorEntry function, which sets |
| // up a PreprocessorCallbacks object for the preprocessor. At the end of |
| // the compilation instance, the PreprocessorTracker's |
| // handleNewPreprocessorExit function handles cleaning up with respect |
| // to the preprocessing instance. |
| // |
| // The PreprocessorCallbacks object uses an overidden FileChanged callback |
| // to determine when a header is entered and exited (including exiting the |
| // header during #include directives). It calls PreprocessorTracker's |
| // handleHeaderEntry and handleHeaderExit functions upon entering and |
| // exiting a header. These functions manage a stack of header handles |
| // representing by a vector, pushing and popping header handles as headers |
| // are entered and exited. When a HeaderInclusionPath object is created, |
| // it simply copies this stack. |
| // |
| // The PreprocessorCallbacks object uses an overridden MacroExpands callback |
| // to track when a macro expansion is performed. It calls a couple of helper |
| // functions to get the unexpanded and expanded macro values as strings, but |
| // then calls PreprocessorTrackerImpl's addMacroExpansionInstance function to |
| // do the rest of the work. The getMacroExpandedString function uses the |
| // preprocessor's getSpelling to convert tokens to strings using the |
| // information passed to the MacroExpands callback, and simply concatenates |
| // them. It makes recursive calls to itself to handle nested macro |
| // definitions, and also handles function-style macros. |
| // |
| // PreprocessorTrackerImpl's addMacroExpansionInstance function looks for |
| // an existing MacroExpansionTracker entry in its map of MacroExampleTracker |
| // objects. If none exists, it adds one with one MacroExpansionInstance and |
| // returns. If a MacroExpansionTracker object already exists, it looks for |
| // an existing MacroExpansionInstance object stored in the |
| // MacroExpansionTracker object, one that matches the macro expanded value |
| // and the macro definition location. If a matching MacroExpansionInstance |
| // object is found, it just adds the current HeaderInclusionPath object to |
| // it. If not found, it creates and stores a new MacroExpantionInstance |
| // object. The addMacroExpansionInstance function calls a couple of helper |
| // functions to get the pre-formatted location and source line strings for |
| // the macro reference and the macro definition stored as string handles. |
| // These helper functions use the current source manager from the |
| // preprocessor. This is done in advance at this point in time because the |
| // source manager doesn't exist at the time of the reporting. |
| // |
| // For conditional check, the PreprocessorCallbacks class overrides the |
| // PPCallbacks handlers for #if, #elif, #ifdef, and #ifndef. These handlers |
| // call the addConditionalExpansionInstance method of |
| // PreprocessorTrackerImpl. The process is similar to that of macros, but |
| // with some different data and error messages. A lookup is performed for |
| // the conditional, and if a ConditionalTracker object doesn't yet exist for |
| // the conditional, a new one is added, including adding a |
| // ConditionalExpansionInstance object to it to represent the condition |
| // expression state. If a ConditionalTracker for the conditional does |
| // exist, a lookup is made for a ConditionalExpansionInstance object |
| // matching the condition expression state. If one exists, a |
| // HeaderInclusionPath is added to it. Otherwise a new |
| // ConditionalExpansionInstance entry is made. If a ConditionalTracker |
| // has two ConditionalExpansionInstance objects, it means there was a |
| // conflict, meaning the conditional expression evaluated differently in |
| // one or more cases. |
| // |
| // After modularize has performed all the compilations, it enters a phase |
| // of error reporting. This new feature adds to this reporting phase calls |
| // to the PreprocessorTracker's reportInconsistentMacros and |
| // reportInconsistentConditionals functions. These functions walk the maps |
| // of MacroExpansionTracker's and ConditionalTracker's respectively. If |
| // any of these objects have more than one MacroExpansionInstance or |
| // ConditionalExpansionInstance objects, it formats and outputs an error |
| // message like the example shown previously, using the stored data. |
| // |
| // A potential issue is that there is some overlap between the #if/#elif |
| // conditional and macro reporting. I could disable the #if and #elif, |
| // leaving just the #ifdef and #ifndef, since these don't overlap. Or, |
| // to make clearer the separate reporting phases, I could add an output |
| // message marking the phases. |
| // |
| // Design and Implementation Details ('Extern "C/C++" {}' Or |
| // 'namespace {}') With Nested '#include' Checking) |
| // |
| // We override the InclusionDirective in PPCallbacks to record information |
| // about each '#include' directive encountered during preprocessing. |
| // We co-opt the PPItemKey class to store the information about each |
| // '#include' directive, including the source file name containing the |
| // directive, the name of the file being included, and the source line |
| // and column of the directive. We store these object in a vector, |
| // after first check to see if an entry already exists. |
| // |
| // Later, while the AST is being walked for other checks, we provide |
| // visit handlers for 'extern "C/C++" {}' and 'namespace (name) {}' |
| // blocks, checking to see if any '#include' directives occurred |
| // within the blocks, reporting errors if any found. |
| // |
| // Future Directions |
| // |
| // We probably should add options to disable any of the checks, in case |
| // there is some problem with them, or the messages get too verbose. |
| // |
| // With the map of all the macro and conditional expansion instances, |
| // it might be possible to add to the existing modularize error messages |
| // (the second part referring to definitions being different), attempting |
| // to tie them to the last macro conflict encountered with respect to the |
| // order of the code encountered. |
| // |
| //===--------------------------------------------------------------------===// |
| |
| #include "clang/Lex/LexDiagnostic.h" |
| #include "PreprocessorTracker.h" |
| #include "clang/Lex/MacroArgs.h" |
| #include "clang/Lex/PPCallbacks.h" |
| #include "llvm/ADT/SmallSet.h" |
| #include "llvm/Support/StringPool.h" |
| #include "llvm/Support/raw_ostream.h" |
| #include "ModularizeUtilities.h" |
| |
| namespace Modularize { |
| |
| // Some handle types |
| typedef llvm::PooledStringPtr StringHandle; |
| |
| typedef int HeaderHandle; |
| const HeaderHandle HeaderHandleInvalid = -1; |
| |
| typedef int InclusionPathHandle; |
| const InclusionPathHandle InclusionPathHandleInvalid = -1; |
| |
| // Some utility functions. |
| |
| // Get a "file:line:column" source location string. |
| static std::string getSourceLocationString(clang::Preprocessor &PP, |
| clang::SourceLocation Loc) { |
| if (Loc.isInvalid()) |
| return std::string("(none)"); |
| else |
| return Loc.printToString(PP.getSourceManager()); |
| } |
| |
| // Get just the file name from a source location. |
| static std::string getSourceLocationFile(clang::Preprocessor &PP, |
| clang::SourceLocation Loc) { |
| std::string Source(getSourceLocationString(PP, Loc)); |
| size_t Offset = Source.find(':', 2); |
| if (Offset == std::string::npos) |
| return Source; |
| return Source.substr(0, Offset); |
| } |
| |
| // Get just the line and column from a source location. |
| static void getSourceLocationLineAndColumn(clang::Preprocessor &PP, |
| clang::SourceLocation Loc, int &Line, |
| int &Column) { |
| clang::PresumedLoc PLoc = PP.getSourceManager().getPresumedLoc(Loc); |
| if (PLoc.isInvalid()) { |
| Line = 0; |
| Column = 0; |
| return; |
| } |
| Line = PLoc.getLine(); |
| Column = PLoc.getColumn(); |
| } |
| |
| // Retrieve source snippet from file image. |
| static std::string getSourceString(clang::Preprocessor &PP, |
| clang::SourceRange Range) { |
| clang::SourceLocation BeginLoc = Range.getBegin(); |
| clang::SourceLocation EndLoc = Range.getEnd(); |
| const char *BeginPtr = PP.getSourceManager().getCharacterData(BeginLoc); |
| const char *EndPtr = PP.getSourceManager().getCharacterData(EndLoc); |
| size_t Length = EndPtr - BeginPtr; |
| return llvm::StringRef(BeginPtr, Length).trim().str(); |
| } |
| |
| // Retrieve source line from file image given a location. |
| static std::string getSourceLine(clang::Preprocessor &PP, |
| clang::SourceLocation Loc) { |
| const llvm::MemoryBuffer *MemBuffer = |
| PP.getSourceManager().getBuffer(PP.getSourceManager().getFileID(Loc)); |
| const char *Buffer = MemBuffer->getBufferStart(); |
| const char *BufferEnd = MemBuffer->getBufferEnd(); |
| const char *BeginPtr = PP.getSourceManager().getCharacterData(Loc); |
| const char *EndPtr = BeginPtr; |
| while (BeginPtr > Buffer) { |
| if (*BeginPtr == '\n') { |
| BeginPtr++; |
| break; |
| } |
| BeginPtr--; |
| } |
| while (EndPtr < BufferEnd) { |
| if (*EndPtr == '\n') { |
| break; |
| } |
| EndPtr++; |
| } |
| size_t Length = EndPtr - BeginPtr; |
| return llvm::StringRef(BeginPtr, Length).str(); |
| } |
| |
| // Retrieve source line from file image given a file ID and line number. |
| static std::string getSourceLine(clang::Preprocessor &PP, clang::FileID FileID, |
| int Line) { |
| const llvm::MemoryBuffer *MemBuffer = PP.getSourceManager().getBuffer(FileID); |
| const char *Buffer = MemBuffer->getBufferStart(); |
| const char *BufferEnd = MemBuffer->getBufferEnd(); |
| const char *BeginPtr = Buffer; |
| const char *EndPtr = BufferEnd; |
| int LineCounter = 1; |
| if (Line == 1) |
| BeginPtr = Buffer; |
| else { |
| while (Buffer < BufferEnd) { |
| if (*Buffer == '\n') { |
| if (++LineCounter == Line) { |
| BeginPtr = Buffer++ + 1; |
| break; |
| } |
| } |
| Buffer++; |
| } |
| } |
| while (Buffer < BufferEnd) { |
| if (*Buffer == '\n') { |
| EndPtr = Buffer; |
| break; |
| } |
| Buffer++; |
| } |
| size_t Length = EndPtr - BeginPtr; |
| return llvm::StringRef(BeginPtr, Length).str(); |
| } |
| |
| // Get the string for the Unexpanded macro instance. |
| // The soureRange is expected to end at the last token |
| // for the macro instance, which in the case of a function-style |
| // macro will be a ')', but for an object-style macro, it |
| // will be the macro name itself. |
| static std::string getMacroUnexpandedString(clang::SourceRange Range, |
| clang::Preprocessor &PP, |
| llvm::StringRef MacroName, |
| const clang::MacroInfo *MI) { |
| clang::SourceLocation BeginLoc(Range.getBegin()); |
| const char *BeginPtr = PP.getSourceManager().getCharacterData(BeginLoc); |
| size_t Length; |
| std::string Unexpanded; |
| if (MI->isFunctionLike()) { |
| clang::SourceLocation EndLoc(Range.getEnd()); |
| const char *EndPtr = PP.getSourceManager().getCharacterData(EndLoc) + 1; |
| Length = (EndPtr - BeginPtr) + 1; // +1 is ')' width. |
| } else |
| Length = MacroName.size(); |
| return llvm::StringRef(BeginPtr, Length).trim().str(); |
| } |
| |
| // Get the expansion for a macro instance, given the information |
| // provided by PPCallbacks. |
| // FIXME: This doesn't support function-style macro instances |
| // passed as arguments to another function-style macro. However, |
| // since it still expands the inner arguments, it still |
| // allows modularize to effectively work with respect to macro |
| // consistency checking, although it displays the incorrect |
| // expansion in error messages. |
| static std::string getMacroExpandedString(clang::Preprocessor &PP, |
| llvm::StringRef MacroName, |
| const clang::MacroInfo *MI, |
| const clang::MacroArgs *Args) { |
| std::string Expanded; |
| // Walk over the macro Tokens. |
| for (const auto &T : MI->tokens()) { |
| clang::IdentifierInfo *II = T.getIdentifierInfo(); |
| int ArgNo = (II && Args ? MI->getParameterNum(II) : -1); |
| if (ArgNo == -1) { |
| // This isn't an argument, just add it. |
| if (II == nullptr) |
| Expanded += PP.getSpelling(T); // Not an identifier. |
| else { |
| // Token is for an identifier. |
| std::string Name = II->getName().str(); |
| // Check for nexted macro references. |
| clang::MacroInfo *MacroInfo = PP.getMacroInfo(II); |
| if (MacroInfo && (Name != MacroName)) |
| Expanded += getMacroExpandedString(PP, Name, MacroInfo, nullptr); |
| else |
| Expanded += Name; |
| } |
| continue; |
| } |
| // We get here if it's a function-style macro with arguments. |
| const clang::Token *ResultArgToks; |
| const clang::Token *ArgTok = Args->getUnexpArgument(ArgNo); |
| if (Args->ArgNeedsPreexpansion(ArgTok, PP)) |
| ResultArgToks = &(const_cast<clang::MacroArgs *>(Args)) |
| ->getPreExpArgument(ArgNo, PP)[0]; |
| else |
| ResultArgToks = ArgTok; // Use non-preexpanded Tokens. |
| // If the arg token didn't expand into anything, ignore it. |
| if (ResultArgToks->is(clang::tok::eof)) |
| continue; |
| unsigned NumToks = clang::MacroArgs::getArgLength(ResultArgToks); |
| // Append the resulting argument expansions. |
| for (unsigned ArgumentIndex = 0; ArgumentIndex < NumToks; ++ArgumentIndex) { |
| const clang::Token &AT = ResultArgToks[ArgumentIndex]; |
| clang::IdentifierInfo *II = AT.getIdentifierInfo(); |
| if (II == nullptr) |
| Expanded += PP.getSpelling(AT); // Not an identifier. |
| else { |
| // It's an identifier. Check for further expansion. |
| std::string Name = II->getName().str(); |
| clang::MacroInfo *MacroInfo = PP.getMacroInfo(II); |
| if (MacroInfo) |
| Expanded += getMacroExpandedString(PP, Name, MacroInfo, nullptr); |
| else |
| Expanded += Name; |
| } |
| } |
| } |
| return Expanded; |
| } |
| |
| namespace { |
| |
| // ConditionValueKind strings. |
| const char * |
| ConditionValueKindStrings[] = { |
| "(not evaluated)", "false", "true" |
| }; |
| |
| bool operator<(const StringHandle &H1, const StringHandle &H2) { |
| const char *S1 = (H1 ? *H1 : ""); |
| const char *S2 = (H2 ? *H2 : ""); |
| int Diff = strcmp(S1, S2); |
| return Diff < 0; |
| } |
| bool operator>(const StringHandle &H1, const StringHandle &H2) { |
| const char *S1 = (H1 ? *H1 : ""); |
| const char *S2 = (H2 ? *H2 : ""); |
| int Diff = strcmp(S1, S2); |
| return Diff > 0; |
| } |
| |
| // Preprocessor item key. |
| // |
| // This class represents a location in a source file, for use |
| // as a key representing a unique name/file/line/column quadruplet, |
| // which in this case is used to identify a macro expansion instance, |
| // but could be used for other things as well. |
| // The file is a header file handle, the line is a line number, |
| // and the column is a column number. |
| class PPItemKey { |
| public: |
| PPItemKey(clang::Preprocessor &PP, StringHandle Name, HeaderHandle File, |
| clang::SourceLocation Loc) |
| : Name(Name), File(File) { |
| getSourceLocationLineAndColumn(PP, Loc, Line, Column); |
| } |
| PPItemKey(StringHandle Name, HeaderHandle File, int Line, int Column) |
| : Name(Name), File(File), Line(Line), Column(Column) {} |
| PPItemKey(const PPItemKey &Other) |
| : Name(Other.Name), File(Other.File), Line(Other.Line), |
| Column(Other.Column) {} |
| PPItemKey() : File(HeaderHandleInvalid), Line(0), Column(0) {} |
| bool operator==(const PPItemKey &Other) const { |
| if (Name != Other.Name) |
| return false; |
| if (File != Other.File) |
| return false; |
| if (Line != Other.Line) |
| return false; |
| return Column == Other.Column; |
| } |
| bool operator<(const PPItemKey &Other) const { |
| if (Name < Other.Name) |
| return true; |
| else if (Name > Other.Name) |
| return false; |
| if (File < Other.File) |
| return true; |
| else if (File > Other.File) |
| return false; |
| if (Line < Other.Line) |
| return true; |
| else if (Line > Other.Line) |
| return false; |
| return Column < Other.Column; |
| } |
| StringHandle Name; |
| HeaderHandle File; |
| int Line; |
| int Column; |
| }; |
| |
| // Header inclusion path. |
| class HeaderInclusionPath { |
| public: |
| HeaderInclusionPath(std::vector<HeaderHandle> HeaderInclusionPath) |
| : Path(HeaderInclusionPath) {} |
| HeaderInclusionPath(const HeaderInclusionPath &Other) : Path(Other.Path) {} |
| HeaderInclusionPath() {} |
| std::vector<HeaderHandle> Path; |
| }; |
| |
| // Macro expansion instance. |
| // |
| // This class represents an instance of a macro expansion with a |
| // unique value. It also stores the unique header inclusion paths |
| // for use in telling the user the nested include path to the header. |
| class MacroExpansionInstance { |
| public: |
| MacroExpansionInstance(StringHandle MacroExpanded, |
| PPItemKey &DefinitionLocation, |
| StringHandle DefinitionSourceLine, |
| InclusionPathHandle H) |
| : MacroExpanded(MacroExpanded), DefinitionLocation(DefinitionLocation), |
| DefinitionSourceLine(DefinitionSourceLine) { |
| InclusionPathHandles.push_back(H); |
| } |
| MacroExpansionInstance() {} |
| |
| // Check for the presence of a header inclusion path handle entry. |
| // Return false if not found. |
| bool haveInclusionPathHandle(InclusionPathHandle H) { |
| for (auto I = InclusionPathHandles.begin(), E = InclusionPathHandles.end(); |
| I != E; ++I) { |
| if (*I == H) |
| return true; |
| } |
| return InclusionPathHandleInvalid; |
| } |
| // Add a new header inclusion path entry, if not already present. |
| void addInclusionPathHandle(InclusionPathHandle H) { |
| if (!haveInclusionPathHandle(H)) |
| InclusionPathHandles.push_back(H); |
| } |
| |
| // A string representing the macro instance after preprocessing. |
| StringHandle MacroExpanded; |
| // A file/line/column triplet representing the macro definition location. |
| PPItemKey DefinitionLocation; |
| // A place to save the macro definition line string. |
| StringHandle DefinitionSourceLine; |
| // The header inclusion path handles for all the instances. |
| std::vector<InclusionPathHandle> InclusionPathHandles; |
| }; |
| |
| // Macro expansion instance tracker. |
| // |
| // This class represents one macro expansion, keyed by a PPItemKey. |
| // It stores a string representing the macro reference in the source, |
| // and a list of ConditionalExpansionInstances objects representing |
| // the unique values the condition expands to in instances of the header. |
| class MacroExpansionTracker { |
| public: |
| MacroExpansionTracker(StringHandle MacroUnexpanded, |
| StringHandle MacroExpanded, |
| StringHandle InstanceSourceLine, |
| PPItemKey &DefinitionLocation, |
| StringHandle DefinitionSourceLine, |
| InclusionPathHandle InclusionPathHandle) |
| : MacroUnexpanded(MacroUnexpanded), |
| InstanceSourceLine(InstanceSourceLine) { |
| addMacroExpansionInstance(MacroExpanded, DefinitionLocation, |
| DefinitionSourceLine, InclusionPathHandle); |
| } |
| MacroExpansionTracker() {} |
| |
| // Find a matching macro expansion instance. |
| MacroExpansionInstance * |
| findMacroExpansionInstance(StringHandle MacroExpanded, |
| PPItemKey &DefinitionLocation) { |
| for (auto I = MacroExpansionInstances.begin(), |
| E = MacroExpansionInstances.end(); |
| I != E; ++I) { |
| if ((I->MacroExpanded == MacroExpanded) && |
| (I->DefinitionLocation == DefinitionLocation)) { |
| return &*I; // Found. |
| } |
| } |
| return nullptr; // Not found. |
| } |
| |
| // Add a macro expansion instance. |
| void addMacroExpansionInstance(StringHandle MacroExpanded, |
| PPItemKey &DefinitionLocation, |
| StringHandle DefinitionSourceLine, |
| InclusionPathHandle InclusionPathHandle) { |
| MacroExpansionInstances.push_back( |
| MacroExpansionInstance(MacroExpanded, DefinitionLocation, |
| DefinitionSourceLine, InclusionPathHandle)); |
| } |
| |
| // Return true if there is a mismatch. |
| bool hasMismatch() { return MacroExpansionInstances.size() > 1; } |
| |
| // A string representing the macro instance without expansion. |
| StringHandle MacroUnexpanded; |
| // A place to save the macro instance source line string. |
| StringHandle InstanceSourceLine; |
| // The macro expansion instances. |
| // If all instances of the macro expansion expand to the same value, |
| // This vector will only have one instance. |
| std::vector<MacroExpansionInstance> MacroExpansionInstances; |
| }; |
| |
| // Conditional expansion instance. |
| // |
| // This class represents an instance of a condition exoression result |
| // with a unique value. It also stores the unique header inclusion paths |
| // for use in telling the user the nested include path to the header. |
| class ConditionalExpansionInstance { |
| public: |
| ConditionalExpansionInstance(clang::PPCallbacks::ConditionValueKind ConditionValue, InclusionPathHandle H) |
| : ConditionValue(ConditionValue) { |
| InclusionPathHandles.push_back(H); |
| } |
| ConditionalExpansionInstance() {} |
| |
| // Check for the presence of a header inclusion path handle entry. |
| // Return false if not found. |
| bool haveInclusionPathHandle(InclusionPathHandle H) { |
| for (auto I = InclusionPathHandles.begin(), E = InclusionPathHandles.end(); |
| I != E; ++I) { |
| if (*I == H) |
| return true; |
| } |
| return InclusionPathHandleInvalid; |
| } |
| // Add a new header inclusion path entry, if not already present. |
| void addInclusionPathHandle(InclusionPathHandle H) { |
| if (!haveInclusionPathHandle(H)) |
| InclusionPathHandles.push_back(H); |
| } |
| |
| // A flag representing the evaluated condition value. |
| clang::PPCallbacks::ConditionValueKind ConditionValue; |
| // The header inclusion path handles for all the instances. |
| std::vector<InclusionPathHandle> InclusionPathHandles; |
| }; |
| |
| // Conditional directive instance tracker. |
| // |
| // This class represents one conditional directive, keyed by a PPItemKey. |
| // It stores a string representing the macro reference in the source, |
| // and a list of ConditionExpansionInstance objects representing |
| // the unique value the condition expression expands to in instances of |
| // the header. |
| class ConditionalTracker { |
| public: |
| ConditionalTracker(clang::tok::PPKeywordKind DirectiveKind, |
| clang::PPCallbacks::ConditionValueKind ConditionValue, |
| StringHandle ConditionUnexpanded, |
| InclusionPathHandle InclusionPathHandle) |
| : DirectiveKind(DirectiveKind), ConditionUnexpanded(ConditionUnexpanded) { |
| addConditionalExpansionInstance(ConditionValue, InclusionPathHandle); |
| } |
| ConditionalTracker() {} |
| |
| // Find a matching condition expansion instance. |
| ConditionalExpansionInstance * |
| findConditionalExpansionInstance(clang::PPCallbacks::ConditionValueKind ConditionValue) { |
| for (auto I = ConditionalExpansionInstances.begin(), |
| E = ConditionalExpansionInstances.end(); |
| I != E; ++I) { |
| if (I->ConditionValue == ConditionValue) { |
| return &*I; // Found. |
| } |
| } |
| return nullptr; // Not found. |
| } |
| |
| // Add a conditional expansion instance. |
| void |
| addConditionalExpansionInstance(clang::PPCallbacks::ConditionValueKind ConditionValue, |
| InclusionPathHandle InclusionPathHandle) { |
| ConditionalExpansionInstances.push_back( |
| ConditionalExpansionInstance(ConditionValue, InclusionPathHandle)); |
| } |
| |
| // Return true if there is a mismatch. |
| bool hasMismatch() { return ConditionalExpansionInstances.size() > 1; } |
| |
| // The kind of directive. |
| clang::tok::PPKeywordKind DirectiveKind; |
| // A string representing the macro instance without expansion. |
| StringHandle ConditionUnexpanded; |
| // The condition expansion instances. |
| // If all instances of the conditional expression expand to the same value, |
| // This vector will only have one instance. |
| std::vector<ConditionalExpansionInstance> ConditionalExpansionInstances; |
| }; |
| |
| class PreprocessorTrackerImpl; |
| |
| // Preprocessor callbacks for modularize. |
| // |
| // This class derives from the Clang PPCallbacks class to track preprocessor |
| // actions, such as changing files and handling preprocessor directives and |
| // macro expansions. It has to figure out when a new header file is entered |
| // and left, as the provided handler is not particularly clear about it. |
| class PreprocessorCallbacks : public clang::PPCallbacks { |
| public: |
| PreprocessorCallbacks(PreprocessorTrackerImpl &ppTracker, |
| clang::Preprocessor &PP, llvm::StringRef rootHeaderFile) |
| : PPTracker(ppTracker), PP(PP), RootHeaderFile(rootHeaderFile) {} |
| ~PreprocessorCallbacks() override {} |
| |
| // Overridden handlers. |
| void InclusionDirective(clang::SourceLocation HashLoc, |
| const clang::Token &IncludeTok, |
| llvm::StringRef FileName, bool IsAngled, |
| clang::CharSourceRange FilenameRange, |
| const clang::FileEntry *File, |
| llvm::StringRef SearchPath, |
| llvm::StringRef RelativePath, |
| const clang::Module *Imported, |
| clang::SrcMgr::CharacteristicKind FileType) override; |
| void FileChanged(clang::SourceLocation Loc, |
| clang::PPCallbacks::FileChangeReason Reason, |
| clang::SrcMgr::CharacteristicKind FileType, |
| clang::FileID PrevFID = clang::FileID()) override; |
| void MacroExpands(const clang::Token &MacroNameTok, |
| const clang::MacroDefinition &MD, clang::SourceRange Range, |
| const clang::MacroArgs *Args) override; |
| void Defined(const clang::Token &MacroNameTok, |
| const clang::MacroDefinition &MD, |
| clang::SourceRange Range) override; |
| void If(clang::SourceLocation Loc, clang::SourceRange ConditionRange, |
| clang::PPCallbacks::ConditionValueKind ConditionResult) override; |
| void Elif(clang::SourceLocation Loc, clang::SourceRange ConditionRange, |
| clang::PPCallbacks::ConditionValueKind ConditionResult, |
| clang::SourceLocation IfLoc) override; |
| void Ifdef(clang::SourceLocation Loc, const clang::Token &MacroNameTok, |
| const clang::MacroDefinition &MD) override; |
| void Ifndef(clang::SourceLocation Loc, const clang::Token &MacroNameTok, |
| const clang::MacroDefinition &MD) override; |
| |
| private: |
| PreprocessorTrackerImpl &PPTracker; |
| clang::Preprocessor &PP; |
| std::string RootHeaderFile; |
| }; |
| |
| // Preprocessor macro expansion item map types. |
| typedef std::map<PPItemKey, MacroExpansionTracker> MacroExpansionMap; |
| typedef std::map<PPItemKey, MacroExpansionTracker>::iterator |
| MacroExpansionMapIter; |
| |
| // Preprocessor conditional expansion item map types. |
| typedef std::map<PPItemKey, ConditionalTracker> ConditionalExpansionMap; |
| typedef std::map<PPItemKey, ConditionalTracker>::iterator |
| ConditionalExpansionMapIter; |
| |
| // Preprocessor tracker for modularize. |
| // |
| // This class stores information about all the headers processed in the |
| // course of running modularize. |
| class PreprocessorTrackerImpl : public PreprocessorTracker { |
| public: |
| PreprocessorTrackerImpl(llvm::SmallVector<std::string, 32> &Headers, |
| bool DoBlockCheckHeaderListOnly) |
| : BlockCheckHeaderListOnly(DoBlockCheckHeaderListOnly), |
| CurrentInclusionPathHandle(InclusionPathHandleInvalid), |
| InNestedHeader(false) { |
| // Use canonical header path representation. |
| for (llvm::ArrayRef<std::string>::iterator I = Headers.begin(), |
| E = Headers.end(); |
| I != E; ++I) { |
| HeaderList.push_back(getCanonicalPath(*I)); |
| } |
| } |
| |
| ~PreprocessorTrackerImpl() override {} |
| |
| // Handle entering a preprocessing session. |
| void handlePreprocessorEntry(clang::Preprocessor &PP, |
| llvm::StringRef rootHeaderFile) override { |
| HeadersInThisCompile.clear(); |
| assert((HeaderStack.size() == 0) && "Header stack should be empty."); |
| pushHeaderHandle(addHeader(rootHeaderFile)); |
| PP.addPPCallbacks(llvm::make_unique<PreprocessorCallbacks>(*this, PP, |
| rootHeaderFile)); |
| } |
| // Handle exiting a preprocessing session. |
| void handlePreprocessorExit() override { HeaderStack.clear(); } |
| |
| // Handle include directive. |
| // This function is called every time an include directive is seen by the |
| // preprocessor, for the purpose of later checking for 'extern "" {}' or |
| // "namespace {}" blocks containing #include directives. |
| void handleIncludeDirective(llvm::StringRef DirectivePath, int DirectiveLine, |
| int DirectiveColumn, |
| llvm::StringRef TargetPath) override { |
| // If it's not a header in the header list, ignore it with respect to |
| // the check. |
| if (BlockCheckHeaderListOnly && !isHeaderListHeader(TargetPath)) |
| return; |
| HeaderHandle CurrentHeaderHandle = findHeaderHandle(DirectivePath); |
| StringHandle IncludeHeaderHandle = addString(TargetPath); |
| for (std::vector<PPItemKey>::const_iterator I = IncludeDirectives.begin(), |
| E = IncludeDirectives.end(); |
| I != E; ++I) { |
| // If we already have an entry for this directive, return now. |
| if ((I->File == CurrentHeaderHandle) && (I->Line == DirectiveLine)) |
| return; |
| } |
| PPItemKey IncludeDirectiveItem(IncludeHeaderHandle, CurrentHeaderHandle, |
| DirectiveLine, DirectiveColumn); |
| IncludeDirectives.push_back(IncludeDirectiveItem); |
| } |
| |
| // Check for include directives within the given source line range. |
| // Report errors if any found. Returns true if no include directives |
| // found in block. |
| bool checkForIncludesInBlock(clang::Preprocessor &PP, |
| clang::SourceRange BlockSourceRange, |
| const char *BlockIdentifierMessage, |
| llvm::raw_ostream &OS) override { |
| clang::SourceLocation BlockStartLoc = BlockSourceRange.getBegin(); |
| clang::SourceLocation BlockEndLoc = BlockSourceRange.getEnd(); |
| // Use block location to get FileID of both the include directive |
| // and block statement. |
| clang::FileID FileID = PP.getSourceManager().getFileID(BlockStartLoc); |
| std::string SourcePath = getSourceLocationFile(PP, BlockStartLoc); |
| SourcePath = ModularizeUtilities::getCanonicalPath(SourcePath); |
| HeaderHandle SourceHandle = findHeaderHandle(SourcePath); |
| if (SourceHandle == -1) |
| return true; |
| int BlockStartLine, BlockStartColumn, BlockEndLine, BlockEndColumn; |
| bool returnValue = true; |
| getSourceLocationLineAndColumn(PP, BlockStartLoc, BlockStartLine, |
| BlockStartColumn); |
| getSourceLocationLineAndColumn(PP, BlockEndLoc, BlockEndLine, |
| BlockEndColumn); |
| for (std::vector<PPItemKey>::const_iterator I = IncludeDirectives.begin(), |
| E = IncludeDirectives.end(); |
| I != E; ++I) { |
| // If we find an entry within the block, report an error. |
| if ((I->File == SourceHandle) && (I->Line >= BlockStartLine) && |
| (I->Line < BlockEndLine)) { |
| returnValue = false; |
| OS << SourcePath << ":" << I->Line << ":" << I->Column << ":\n"; |
| OS << getSourceLine(PP, FileID, I->Line) << "\n"; |
| if (I->Column > 0) |
| OS << std::string(I->Column - 1, ' ') << "^\n"; |
| OS << "error: Include directive within " << BlockIdentifierMessage |
| << ".\n"; |
| OS << SourcePath << ":" << BlockStartLine << ":" << BlockStartColumn |
| << ":\n"; |
| OS << getSourceLine(PP, BlockStartLoc) << "\n"; |
| if (BlockStartColumn > 0) |
| OS << std::string(BlockStartColumn - 1, ' ') << "^\n"; |
| OS << "The \"" << BlockIdentifierMessage << "\" block is here.\n"; |
| } |
| } |
| return returnValue; |
| } |
| |
| // Handle entering a header source file. |
| void handleHeaderEntry(clang::Preprocessor &PP, llvm::StringRef HeaderPath) { |
| // Ignore <built-in> and <command-line> to reduce message clutter. |
| if (HeaderPath.startswith("<")) |
| return; |
| HeaderHandle H = addHeader(HeaderPath); |
| if (H != getCurrentHeaderHandle()) |
| pushHeaderHandle(H); |
| // Check for nested header. |
| if (!InNestedHeader) |
| InNestedHeader = !HeadersInThisCompile.insert(H).second; |
| } |
| |
| // Handle exiting a header source file. |
| void handleHeaderExit(llvm::StringRef HeaderPath) { |
| // Ignore <built-in> and <command-line> to reduce message clutter. |
| if (HeaderPath.startswith("<")) |
| return; |
| HeaderHandle H = findHeaderHandle(HeaderPath); |
| HeaderHandle TH; |
| if (isHeaderHandleInStack(H)) { |
| do { |
| TH = getCurrentHeaderHandle(); |
| popHeaderHandle(); |
| } while ((TH != H) && (HeaderStack.size() != 0)); |
| } |
| InNestedHeader = false; |
| } |
| |
| // Lookup/add string. |
| StringHandle addString(llvm::StringRef Str) { return Strings.intern(Str); } |
| |
| // Convert to a canonical path. |
| std::string getCanonicalPath(llvm::StringRef path) const { |
| std::string CanonicalPath(path); |
| std::replace(CanonicalPath.begin(), CanonicalPath.end(), '\\', '/'); |
| return CanonicalPath; |
| } |
| |
| // Return true if the given header is in the header list. |
| bool isHeaderListHeader(llvm::StringRef HeaderPath) const { |
| std::string CanonicalPath = getCanonicalPath(HeaderPath); |
| for (llvm::ArrayRef<std::string>::iterator I = HeaderList.begin(), |
| E = HeaderList.end(); |
| I != E; ++I) { |
| if (*I == CanonicalPath) |
| return true; |
| } |
| return false; |
| } |
| |
| // Get the handle of a header file entry. |
| // Return HeaderHandleInvalid if not found. |
| HeaderHandle findHeaderHandle(llvm::StringRef HeaderPath) const { |
| std::string CanonicalPath = getCanonicalPath(HeaderPath); |
| HeaderHandle H = 0; |
| for (auto I = HeaderPaths.begin(), E = HeaderPaths.end(); I != E; |
| ++I, ++H) { |
| if (**I == CanonicalPath) |
| return H; |
| } |
| return HeaderHandleInvalid; |
| } |
| |
| // Add a new header file entry, or return existing handle. |
| // Return the header handle. |
| HeaderHandle addHeader(llvm::StringRef HeaderPath) { |
| std::string CanonicalPath = getCanonicalPath(HeaderPath); |
| HeaderHandle H = findHeaderHandle(CanonicalPath); |
| if (H == HeaderHandleInvalid) { |
| H = HeaderPaths.size(); |
| HeaderPaths.push_back(addString(CanonicalPath)); |
| } |
| return H; |
| } |
| |
| // Return a header file path string given its handle. |
| StringHandle getHeaderFilePath(HeaderHandle H) const { |
| if ((H >= 0) && (H < (HeaderHandle)HeaderPaths.size())) |
| return HeaderPaths[H]; |
| return StringHandle(); |
| } |
| |
| // Returns a handle to the inclusion path. |
| InclusionPathHandle pushHeaderHandle(HeaderHandle H) { |
| HeaderStack.push_back(H); |
| return CurrentInclusionPathHandle = addInclusionPathHandle(HeaderStack); |
| } |
| // Pops the last header handle from the stack; |
| void popHeaderHandle() { |
| // assert((HeaderStack.size() != 0) && "Header stack already empty."); |
| if (HeaderStack.size() != 0) { |
| HeaderStack.pop_back(); |
| CurrentInclusionPathHandle = addInclusionPathHandle(HeaderStack); |
| } |
| } |
| // Get the top handle on the header stack. |
| HeaderHandle getCurrentHeaderHandle() const { |
| if (HeaderStack.size() != 0) |
| return HeaderStack.back(); |
| return HeaderHandleInvalid; |
| } |
| |
| // Check for presence of header handle in the header stack. |
| bool isHeaderHandleInStack(HeaderHandle H) const { |
| for (auto I = HeaderStack.begin(), E = HeaderStack.end(); I != E; ++I) { |
| if (*I == H) |
| return true; |
| } |
| return false; |
| } |
| |
| // Get the handle of a header inclusion path entry. |
| // Return InclusionPathHandleInvalid if not found. |
| InclusionPathHandle |
| findInclusionPathHandle(const std::vector<HeaderHandle> &Path) const { |
| InclusionPathHandle H = 0; |
| for (auto I = InclusionPaths.begin(), E = InclusionPaths.end(); I != E; |
| ++I, ++H) { |
| if (I->Path == Path) |
| return H; |
| } |
| return HeaderHandleInvalid; |
| } |
| // Add a new header inclusion path entry, or return existing handle. |
| // Return the header inclusion path entry handle. |
| InclusionPathHandle |
| addInclusionPathHandle(const std::vector<HeaderHandle> &Path) { |
| InclusionPathHandle H = findInclusionPathHandle(Path); |
| if (H == HeaderHandleInvalid) { |
| H = InclusionPaths.size(); |
| InclusionPaths.push_back(HeaderInclusionPath(Path)); |
| } |
| return H; |
| } |
| // Return the current inclusion path handle. |
| InclusionPathHandle getCurrentInclusionPathHandle() const { |
| return CurrentInclusionPathHandle; |
| } |
| |
| // Return an inclusion path given its handle. |
| const std::vector<HeaderHandle> & |
| getInclusionPath(InclusionPathHandle H) const { |
| if ((H >= 0) && (H <= (InclusionPathHandle)InclusionPaths.size())) |
| return InclusionPaths[H].Path; |
| static std::vector<HeaderHandle> Empty; |
| return Empty; |
| } |
| |
| // Add a macro expansion instance. |
| void addMacroExpansionInstance(clang::Preprocessor &PP, HeaderHandle H, |
| clang::SourceLocation InstanceLoc, |
| clang::SourceLocation DefinitionLoc, |
| clang::IdentifierInfo *II, |
| llvm::StringRef MacroUnexpanded, |
| llvm::StringRef MacroExpanded, |
| InclusionPathHandle InclusionPathHandle) { |
| if (InNestedHeader) |
| return; |
| StringHandle MacroName = addString(II->getName()); |
| PPItemKey InstanceKey(PP, MacroName, H, InstanceLoc); |
| PPItemKey DefinitionKey(PP, MacroName, H, DefinitionLoc); |
| auto I = MacroExpansions.find(InstanceKey); |
| // If existing instance of expansion not found, add one. |
| if (I == MacroExpansions.end()) { |
| std::string InstanceSourceLine = |
| getSourceLocationString(PP, InstanceLoc) + ":\n" + |
| getSourceLine(PP, InstanceLoc) + "\n"; |
| std::string DefinitionSourceLine = |
| getSourceLocationString(PP, DefinitionLoc) + ":\n" + |
| getSourceLine(PP, DefinitionLoc) + "\n"; |
| MacroExpansions[InstanceKey] = MacroExpansionTracker( |
| addString(MacroUnexpanded), addString(MacroExpanded), |
| addString(InstanceSourceLine), DefinitionKey, |
| addString(DefinitionSourceLine), InclusionPathHandle); |
| } else { |
| // We've seen the macro before. Get its tracker. |
| MacroExpansionTracker &CondTracker = I->second; |
| // Look up an existing instance value for the macro. |
| MacroExpansionInstance *MacroInfo = |
| CondTracker.findMacroExpansionInstance(addString(MacroExpanded), |
| DefinitionKey); |
| // If found, just add the inclusion path to the instance. |
| if (MacroInfo) |
| MacroInfo->addInclusionPathHandle(InclusionPathHandle); |
| else { |
| // Otherwise add a new instance with the unique value. |
| std::string DefinitionSourceLine = |
| getSourceLocationString(PP, DefinitionLoc) + ":\n" + |
| getSourceLine(PP, DefinitionLoc) + "\n"; |
| CondTracker.addMacroExpansionInstance( |
| addString(MacroExpanded), DefinitionKey, |
| addString(DefinitionSourceLine), InclusionPathHandle); |
| } |
| } |
| } |
| |
| // Add a conditional expansion instance. |
| void |
| addConditionalExpansionInstance(clang::Preprocessor &PP, HeaderHandle H, |
| clang::SourceLocation InstanceLoc, |
| clang::tok::PPKeywordKind DirectiveKind, |
| clang::PPCallbacks::ConditionValueKind ConditionValue, |
| llvm::StringRef ConditionUnexpanded, |
| InclusionPathHandle InclusionPathHandle) { |
| // Ignore header guards, assuming the header guard is the only conditional. |
| if (InNestedHeader) |
| return; |
| StringHandle ConditionUnexpandedHandle(addString(ConditionUnexpanded)); |
| PPItemKey InstanceKey(PP, ConditionUnexpandedHandle, H, InstanceLoc); |
| auto I = ConditionalExpansions.find(InstanceKey); |
| // If existing instance of condition not found, add one. |
| if (I == ConditionalExpansions.end()) { |
| std::string InstanceSourceLine = |
| getSourceLocationString(PP, InstanceLoc) + ":\n" + |
| getSourceLine(PP, InstanceLoc) + "\n"; |
| ConditionalExpansions[InstanceKey] = |
| ConditionalTracker(DirectiveKind, ConditionValue, |
| ConditionUnexpandedHandle, InclusionPathHandle); |
| } else { |
| // We've seen the conditional before. Get its tracker. |
| ConditionalTracker &CondTracker = I->second; |
| // Look up an existing instance value for the condition. |
| ConditionalExpansionInstance *MacroInfo = |
| CondTracker.findConditionalExpansionInstance(ConditionValue); |
| // If found, just add the inclusion path to the instance. |
| if (MacroInfo) |
| MacroInfo->addInclusionPathHandle(InclusionPathHandle); |
| else { |
| // Otherwise add a new instance with the unique value. |
| CondTracker.addConditionalExpansionInstance(ConditionValue, |
| InclusionPathHandle); |
| } |
| } |
| } |
| |
| // Report on inconsistent macro instances. |
| // Returns true if any mismatches. |
| bool reportInconsistentMacros(llvm::raw_ostream &OS) override { |
| bool ReturnValue = false; |
| // Walk all the macro expansion trackers in the map. |
| for (auto I = MacroExpansions.begin(), E = MacroExpansions.end(); I != E; |
| ++I) { |
| const PPItemKey &ItemKey = I->first; |
| MacroExpansionTracker &MacroExpTracker = I->second; |
| // If no mismatch (only one instance value) continue. |
| if (!MacroExpTracker.hasMismatch()) |
| continue; |
| // Tell caller we found one or more errors. |
| ReturnValue = true; |
| // Start the error message. |
| OS << *MacroExpTracker.InstanceSourceLine; |
| if (ItemKey.Column > 0) |
| OS << std::string(ItemKey.Column - 1, ' ') << "^\n"; |
| OS << "error: Macro instance '" << *MacroExpTracker.MacroUnexpanded |
| << "' has different values in this header, depending on how it was " |
| "included.\n"; |
| // Walk all the instances. |
| for (auto IMT = MacroExpTracker.MacroExpansionInstances.begin(), |
| EMT = MacroExpTracker.MacroExpansionInstances.end(); |
| IMT != EMT; ++IMT) { |
| MacroExpansionInstance &MacroInfo = *IMT; |
| OS << " '" << *MacroExpTracker.MacroUnexpanded << "' expanded to: '" |
| << *MacroInfo.MacroExpanded |
| << "' with respect to these inclusion paths:\n"; |
| // Walk all the inclusion path hierarchies. |
| for (auto IIP = MacroInfo.InclusionPathHandles.begin(), |
| EIP = MacroInfo.InclusionPathHandles.end(); |
| IIP != EIP; ++IIP) { |
| const std::vector<HeaderHandle> &ip = getInclusionPath(*IIP); |
| auto Count = (int)ip.size(); |
| for (int Index = 0; Index < Count; ++Index) { |
| HeaderHandle H = ip[Index]; |
| OS << std::string((Index * 2) + 4, ' ') << *getHeaderFilePath(H) |
| << "\n"; |
| } |
| } |
| // For a macro that wasn't defined, we flag it by using the |
| // instance location. |
| // If there is a definition... |
| if (MacroInfo.DefinitionLocation.Line != ItemKey.Line) { |
| OS << *MacroInfo.DefinitionSourceLine; |
| if (MacroInfo.DefinitionLocation.Column > 0) |
| OS << std::string(MacroInfo.DefinitionLocation.Column - 1, ' ') |
| << "^\n"; |
| OS << "Macro defined here.\n"; |
| } else |
| OS << "(no macro definition)" |
| << "\n"; |
| } |
| } |
| return ReturnValue; |
| } |
| |
| // Report on inconsistent conditional instances. |
| // Returns true if any mismatches. |
| bool reportInconsistentConditionals(llvm::raw_ostream &OS) override { |
| bool ReturnValue = false; |
| // Walk all the conditional trackers in the map. |
| for (auto I = ConditionalExpansions.begin(), |
| E = ConditionalExpansions.end(); |
| I != E; ++I) { |
| const PPItemKey &ItemKey = I->first; |
| ConditionalTracker &CondTracker = I->second; |
| if (!CondTracker.hasMismatch()) |
| continue; |
| // Tell caller we found one or more errors. |
| ReturnValue = true; |
| // Start the error message. |
| OS << *HeaderPaths[ItemKey.File] << ":" << ItemKey.Line << ":" |
| << ItemKey.Column << "\n"; |
| OS << "#" << getDirectiveSpelling(CondTracker.DirectiveKind) << " " |
| << *CondTracker.ConditionUnexpanded << "\n"; |
| OS << "^\n"; |
| OS << "error: Conditional expression instance '" |
| << *CondTracker.ConditionUnexpanded |
| << "' has different values in this header, depending on how it was " |
| "included.\n"; |
| // Walk all the instances. |
| for (auto IMT = CondTracker.ConditionalExpansionInstances.begin(), |
| EMT = CondTracker.ConditionalExpansionInstances.end(); |
| IMT != EMT; ++IMT) { |
| ConditionalExpansionInstance &MacroInfo = *IMT; |
| OS << " '" << *CondTracker.ConditionUnexpanded << "' expanded to: '" |
| << ConditionValueKindStrings[MacroInfo.ConditionValue] |
| << "' with respect to these inclusion paths:\n"; |
| // Walk all the inclusion path hierarchies. |
| for (auto IIP = MacroInfo.InclusionPathHandles.begin(), |
| EIP = MacroInfo.InclusionPathHandles.end(); |
| IIP != EIP; ++IIP) { |
| const std::vector<HeaderHandle> &ip = getInclusionPath(*IIP); |
| auto Count = (int)ip.size(); |
| for (int Index = 0; Index < Count; ++Index) { |
| HeaderHandle H = ip[Index]; |
| OS << std::string((Index * 2) + 4, ' ') << *getHeaderFilePath(H) |
| << "\n"; |
| } |
| } |
| } |
| } |
| return ReturnValue; |
| } |
| |
| // Get directive spelling. |
| static const char *getDirectiveSpelling(clang::tok::PPKeywordKind kind) { |
| switch (kind) { |
| case clang::tok::pp_if: |
| return "if"; |
| case clang::tok::pp_elif: |
| return "elif"; |
| case clang::tok::pp_ifdef: |
| return "ifdef"; |
| case clang::tok::pp_ifndef: |
| return "ifndef"; |
| default: |
| return "(unknown)"; |
| } |
| } |
| |
| private: |
| llvm::SmallVector<std::string, 32> HeaderList; |
| // Only do extern, namespace check for headers in HeaderList. |
| bool BlockCheckHeaderListOnly; |
| llvm::StringPool Strings; |
| std::vector<StringHandle> HeaderPaths; |
| std::vector<HeaderHandle> HeaderStack; |
| std::vector<HeaderInclusionPath> InclusionPaths; |
| InclusionPathHandle CurrentInclusionPathHandle; |
| llvm::SmallSet<HeaderHandle, 32> HeadersInThisCompile; |
| std::vector<PPItemKey> IncludeDirectives; |
| MacroExpansionMap MacroExpansions; |
| ConditionalExpansionMap ConditionalExpansions; |
| bool InNestedHeader; |
| }; |
| |
| } // namespace |
| |
| // PreprocessorTracker functions. |
| |
| // PreprocessorTracker desctructor. |
| PreprocessorTracker::~PreprocessorTracker() {} |
| |
| // Create instance of PreprocessorTracker. |
| PreprocessorTracker *PreprocessorTracker::create( |
| llvm::SmallVector<std::string, 32> &Headers, |
| bool DoBlockCheckHeaderListOnly) { |
| return new PreprocessorTrackerImpl(Headers, DoBlockCheckHeaderListOnly); |
| } |
| |
| // Preprocessor callbacks for modularize. |
| |
| // Handle include directive. |
| void PreprocessorCallbacks::InclusionDirective( |
| clang::SourceLocation HashLoc, const clang::Token &IncludeTok, |
| llvm::StringRef FileName, bool IsAngled, |
| clang::CharSourceRange FilenameRange, const clang::FileEntry *File, |
| llvm::StringRef SearchPath, llvm::StringRef RelativePath, |
| const clang::Module *Imported, clang::SrcMgr::CharacteristicKind FileType) { |
| int DirectiveLine, DirectiveColumn; |
| std::string HeaderPath = getSourceLocationFile(PP, HashLoc); |
| getSourceLocationLineAndColumn(PP, HashLoc, DirectiveLine, DirectiveColumn); |
| PPTracker.handleIncludeDirective(HeaderPath, DirectiveLine, DirectiveColumn, |
| FileName); |
| } |
| |
| // Handle file entry/exit. |
| void PreprocessorCallbacks::FileChanged( |
| clang::SourceLocation Loc, clang::PPCallbacks::FileChangeReason Reason, |
| clang::SrcMgr::CharacteristicKind FileType, clang::FileID PrevFID) { |
| switch (Reason) { |
| case EnterFile: |
| PPTracker.handleHeaderEntry(PP, getSourceLocationFile(PP, Loc)); |
| break; |
| case ExitFile: { |
| const clang::FileEntry *F = |
| PP.getSourceManager().getFileEntryForID(PrevFID); |
| if (F) |
| PPTracker.handleHeaderExit(F->getName()); |
| } break; |
| case SystemHeaderPragma: |
| case RenameFile: |
| break; |
| } |
| } |
| |
| // Handle macro expansion. |
| void PreprocessorCallbacks::MacroExpands(const clang::Token &MacroNameTok, |
| const clang::MacroDefinition &MD, |
| clang::SourceRange Range, |
| const clang::MacroArgs *Args) { |
| clang::SourceLocation Loc = Range.getBegin(); |
| // Ignore macro argument expansions. |
| if (!Loc.isFileID()) |
| return; |
| clang::IdentifierInfo *II = MacroNameTok.getIdentifierInfo(); |
| const clang::MacroInfo *MI = MD.getMacroInfo(); |
| std::string MacroName = II->getName().str(); |
| std::string Unexpanded(getMacroUnexpandedString(Range, PP, MacroName, MI)); |
| std::string Expanded(getMacroExpandedString(PP, MacroName, MI, Args)); |
| PPTracker.addMacroExpansionInstance( |
| PP, PPTracker.getCurrentHeaderHandle(), Loc, MI->getDefinitionLoc(), II, |
| Unexpanded, Expanded, PPTracker.getCurrentInclusionPathHandle()); |
| } |
| |
| void PreprocessorCallbacks::Defined(const clang::Token &MacroNameTok, |
| const clang::MacroDefinition &MD, |
| clang::SourceRange Range) { |
| clang::SourceLocation Loc(Range.getBegin()); |
| clang::IdentifierInfo *II = MacroNameTok.getIdentifierInfo(); |
| const clang::MacroInfo *MI = MD.getMacroInfo(); |
| std::string MacroName = II->getName().str(); |
| std::string Unexpanded(getSourceString(PP, Range)); |
| PPTracker.addMacroExpansionInstance( |
| PP, PPTracker.getCurrentHeaderHandle(), Loc, |
| (MI ? MI->getDefinitionLoc() : Loc), II, Unexpanded, |
| (MI ? "true" : "false"), PPTracker.getCurrentInclusionPathHandle()); |
| } |
| |
| void PreprocessorCallbacks::If(clang::SourceLocation Loc, |
| clang::SourceRange ConditionRange, |
| clang::PPCallbacks::ConditionValueKind ConditionResult) { |
| std::string Unexpanded(getSourceString(PP, ConditionRange)); |
| PPTracker.addConditionalExpansionInstance( |
| PP, PPTracker.getCurrentHeaderHandle(), Loc, clang::tok::pp_if, |
| ConditionResult, Unexpanded, PPTracker.getCurrentInclusionPathHandle()); |
| } |
| |
| void PreprocessorCallbacks::Elif(clang::SourceLocation Loc, |
| clang::SourceRange ConditionRange, |
| clang::PPCallbacks::ConditionValueKind ConditionResult, |
| clang::SourceLocation IfLoc) { |
| std::string Unexpanded(getSourceString(PP, ConditionRange)); |
| PPTracker.addConditionalExpansionInstance( |
| PP, PPTracker.getCurrentHeaderHandle(), Loc, clang::tok::pp_elif, |
| ConditionResult, Unexpanded, PPTracker.getCurrentInclusionPathHandle()); |
| } |
| |
| void PreprocessorCallbacks::Ifdef(clang::SourceLocation Loc, |
| const clang::Token &MacroNameTok, |
| const clang::MacroDefinition &MD) { |
| clang::PPCallbacks::ConditionValueKind IsDefined = |
| (MD ? clang::PPCallbacks::CVK_True : clang::PPCallbacks::CVK_False ); |
| PPTracker.addConditionalExpansionInstance( |
| PP, PPTracker.getCurrentHeaderHandle(), Loc, clang::tok::pp_ifdef, |
| IsDefined, PP.getSpelling(MacroNameTok), |
| PPTracker.getCurrentInclusionPathHandle()); |
| } |
| |
| void PreprocessorCallbacks::Ifndef(clang::SourceLocation Loc, |
| const clang::Token &MacroNameTok, |
| const clang::MacroDefinition &MD) { |
| clang::PPCallbacks::ConditionValueKind IsNotDefined = |
| (!MD ? clang::PPCallbacks::CVK_True : clang::PPCallbacks::CVK_False ); |
| PPTracker.addConditionalExpansionInstance( |
| PP, PPTracker.getCurrentHeaderHandle(), Loc, clang::tok::pp_ifndef, |
| IsNotDefined, PP.getSpelling(MacroNameTok), |
| PPTracker.getCurrentInclusionPathHandle()); |
| } |
| } // end namespace Modularize |
