| //===--- MacroPPCallbacks.cpp ---------------------------------------------===// | |
| // | |
| // 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 | |
| // | |
| //===----------------------------------------------------------------------===// | |
| // | |
| // This file contains implementation for the macro preprocessors callbacks. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "MacroPPCallbacks.h" | |
| #include "CGDebugInfo.h" | |
| #include "clang/CodeGen/ModuleBuilder.h" | |
| #include "clang/Lex/MacroInfo.h" | |
| #include "clang/Lex/Preprocessor.h" | |
| using namespace clang; | |
| void MacroPPCallbacks::writeMacroDefinition(const IdentifierInfo &II, | |
| const MacroInfo &MI, | |
| Preprocessor &PP, raw_ostream &Name, | |
| raw_ostream &Value) { | |
| Name << II.getName(); | |
| if (MI.isFunctionLike()) { | |
| Name << '('; | |
| if (!MI.param_empty()) { | |
| MacroInfo::param_iterator AI = MI.param_begin(), E = MI.param_end(); | |
| for (; AI + 1 != E; ++AI) { | |
| Name << (*AI)->getName(); | |
| Name << ','; | |
| } | |
| // Last argument. | |
| if ((*AI)->getName() == "__VA_ARGS__") | |
| Name << "..."; | |
| else | |
| Name << (*AI)->getName(); | |
| } | |
| if (MI.isGNUVarargs()) | |
| // #define foo(x...) | |
| Name << "..."; | |
| Name << ')'; | |
| } | |
| SmallString<128> SpellingBuffer; | |
| bool First = true; | |
| for (const auto &T : MI.tokens()) { | |
| if (!First && T.hasLeadingSpace()) | |
| Value << ' '; | |
| Value << PP.getSpelling(T, SpellingBuffer); | |
| First = false; | |
| } | |
| } | |
| MacroPPCallbacks::MacroPPCallbacks(CodeGenerator *Gen, Preprocessor &PP) | |
| : Gen(Gen), PP(PP), Status(NoScope) {} | |
| // This is the expected flow of enter/exit compiler and user files: | |
| // - Main File Enter | |
| // - <built-in> file enter | |
| // {Compiler macro definitions} - (Line=0, no scope) | |
| // - (Optional) <command line> file enter | |
| // {Command line macro definitions} - (Line=0, no scope) | |
| // - (Optional) <command line> file exit | |
| // {Command line file includes} - (Line=0, Main file scope) | |
| // {macro definitions and file includes} - (Line!=0, Parent scope) | |
| // - <built-in> file exit | |
| // {User code macro definitions and file includes} - (Line!=0, Parent scope) | |
| llvm::DIMacroFile *MacroPPCallbacks::getCurrentScope() { | |
| if (Status == MainFileScope || Status == CommandLineIncludeScope) | |
| return Scopes.back(); | |
| return nullptr; | |
| } | |
| SourceLocation MacroPPCallbacks::getCorrectLocation(SourceLocation Loc) { | |
| if (Status == MainFileScope || EnteredCommandLineIncludeFiles) | |
| return Loc; | |
| // While parsing skipped files, location of macros is invalid. | |
| // Invalid location represents line zero. | |
| return SourceLocation(); | |
| } | |
| void MacroPPCallbacks::updateStatusToNextScope() { | |
| switch (Status) { | |
| case NoScope: | |
| Status = InitializedScope; | |
| break; | |
| case InitializedScope: | |
| Status = BuiltinScope; | |
| break; | |
| case BuiltinScope: | |
| Status = CommandLineIncludeScope; | |
| break; | |
| case CommandLineIncludeScope: | |
| Status = MainFileScope; | |
| break; | |
| case MainFileScope: | |
| llvm_unreachable("There is no next scope, already in the final scope"); | |
| } | |
| } | |
| void MacroPPCallbacks::FileEntered(SourceLocation Loc) { | |
| SourceLocation LineLoc = getCorrectLocation(LastHashLoc); | |
| switch (Status) { | |
| case NoScope: | |
| updateStatusToNextScope(); | |
| break; | |
| case InitializedScope: | |
| updateStatusToNextScope(); | |
| return; | |
| case BuiltinScope: | |
| if (PP.getSourceManager().isWrittenInCommandLineFile(Loc)) | |
| return; | |
| updateStatusToNextScope(); | |
| [[fallthrough]]; | |
| case CommandLineIncludeScope: | |
| EnteredCommandLineIncludeFiles++; | |
| break; | |
| case MainFileScope: | |
| break; | |
| } | |
| Scopes.push_back(Gen->getCGDebugInfo()->CreateTempMacroFile(getCurrentScope(), | |
| LineLoc, Loc)); | |
| } | |
| void MacroPPCallbacks::FileExited(SourceLocation Loc) { | |
| switch (Status) { | |
| default: | |
| llvm_unreachable("Do not expect to exit a file from current scope"); | |
| case BuiltinScope: | |
| if (!PP.getSourceManager().isWrittenInBuiltinFile(Loc)) | |
| // Skip next scope and change status to MainFileScope. | |
| Status = MainFileScope; | |
| return; | |
| case CommandLineIncludeScope: | |
| if (!EnteredCommandLineIncludeFiles) { | |
| updateStatusToNextScope(); | |
| return; | |
| } | |
| EnteredCommandLineIncludeFiles--; | |
| break; | |
| case MainFileScope: | |
| break; | |
| } | |
| Scopes.pop_back(); | |
| } | |
| void MacroPPCallbacks::FileChanged(SourceLocation Loc, FileChangeReason Reason, | |
| SrcMgr::CharacteristicKind FileType, | |
| FileID PrevFID) { | |
| // Only care about enter file or exit file changes. | |
| if (Reason == EnterFile) | |
| FileEntered(Loc); | |
| else if (Reason == ExitFile) | |
| FileExited(Loc); | |
| } | |
| void MacroPPCallbacks::InclusionDirective( | |
| SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName, | |
| bool IsAngled, CharSourceRange FilenameRange, OptionalFileEntryRef File, | |
| StringRef SearchPath, StringRef RelativePath, const Module *SuggestedModule, | |
| bool ModuleImported, SrcMgr::CharacteristicKind FileType) { | |
| // Record the line location of the current included file. | |
| LastHashLoc = HashLoc; | |
| } | |
| void MacroPPCallbacks::MacroDefined(const Token &MacroNameTok, | |
| const MacroDirective *MD) { | |
| IdentifierInfo *Id = MacroNameTok.getIdentifierInfo(); | |
| SourceLocation location = getCorrectLocation(MacroNameTok.getLocation()); | |
| std::string NameBuffer, ValueBuffer; | |
| llvm::raw_string_ostream Name(NameBuffer); | |
| llvm::raw_string_ostream Value(ValueBuffer); | |
| writeMacroDefinition(*Id, *MD->getMacroInfo(), PP, Name, Value); | |
| Gen->getCGDebugInfo()->CreateMacro(getCurrentScope(), | |
| llvm::dwarf::DW_MACINFO_define, location, | |
| NameBuffer, ValueBuffer); | |
| } | |
| void MacroPPCallbacks::MacroUndefined(const Token &MacroNameTok, | |
| const MacroDefinition &MD, | |
| const MacroDirective *Undef) { | |
| IdentifierInfo *Id = MacroNameTok.getIdentifierInfo(); | |
| SourceLocation location = getCorrectLocation(MacroNameTok.getLocation()); | |
| Gen->getCGDebugInfo()->CreateMacro(getCurrentScope(), | |
| llvm::dwarf::DW_MACINFO_undef, location, | |
| Id->getName(), ""); | |
| } |