maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/unittests/Basic/SourceManagerTest.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

587 lines
21 KiB
C++
Raw Normal View History

For SourceManager::isBeforeInTranslationUnit(), have it consider macro arg expanded token locations as coming before the closing ')' of a function macro expansion. Include a unit test for SourceManager. llvm-svn: 147056
2011-12-22 00:56:29 +08:00
//===- unittests/Basic/SourceManagerTest.cpp ------ SourceManager tests ---===//
//
Update the file headers across all of the LLVM projects in the monorepo to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
2019-01-19 16:50:56 +08:00
// 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
For SourceManager::isBeforeInTranslationUnit(), have it consider macro arg expanded token locations as coming before the closing ')' of a function macro expansion. Include a unit test for SourceManager. llvm-svn: 147056
2011-12-22 00:56:29 +08:00
//
//===----------------------------------------------------------------------===//
#include "clang/Basic/SourceManager.h"
#include "clang/Basic/Diagnostic.h"
More unit-test fixes llvm-svn: 166511
2012-10-24 06:38:58 +08:00
#include "clang/Basic/DiagnosticOptions.h"
Sort the #include lines for unittests/... I've tried to place sensible headers at the top as main-module headers. llvm-svn: 169243
2012-12-04 17:45:34 +08:00
#include "clang/Basic/FileManager.h"
For SourceManager::isBeforeInTranslationUnit(), have it consider macro arg expanded token locations as coming before the closing ')' of a function macro expansion. Include a unit test for SourceManager. llvm-svn: 147056
2011-12-22 00:56:29 +08:00
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/TargetInfo.h"
Sort the #include lines for unittests/... I've tried to place sensible headers at the top as main-module headers. llvm-svn: 169243
2012-12-04 17:45:34 +08:00
#include "clang/Basic/TargetOptions.h"
For SourceManager::isBeforeInTranslationUnit(), have it consider macro arg expanded token locations as coming before the closing ')' of a function macro expansion. Include a unit test for SourceManager. llvm-svn: 147056
2011-12-22 00:56:29 +08:00
#include "clang/Lex/HeaderSearch.h"
Update unit tests for HeaderSearch change llvm-svn: 166584
2012-10-25 00:24:38 +08:00
#include "clang/Lex/HeaderSearchOptions.h"
Sort the #include lines for unittests/... I've tried to place sensible headers at the top as main-module headers. llvm-svn: 169243
2012-12-04 17:45:34 +08:00
#include "clang/Lex/ModuleLoader.h"
For SourceManager::isBeforeInTranslationUnit(), have it consider macro arg expanded token locations as coming before the closing ')' of a function macro expansion. Include a unit test for SourceManager. llvm-svn: 147056
2011-12-22 00:56:29 +08:00
#include "clang/Lex/Preprocessor.h"
Teach the preprocessor to hold onto the preprocessor options. llvm-svn: 166599
2012-10-25 01:46:57 +08:00
#include "clang/Lex/PreprocessorOptions.h"
Move a method from IdentifierTable.h out of line and remove the SmallString include. Fix all the transitive include users. llvm-svn: 149783
2012-02-04 21:45:25 +08:00
#include "llvm/ADT/SmallString.h"
Remove the last remaining llvm/Config/config.h includes This corrects long-standing misuses of LLVM's internal config.h. In most cases the public llvm-config.h header was intended and we can now remove the old hacks thanks to LLVM r210144. The config.h header is private, won't be installed and should no longer be included by clang or other modules. llvm-svn: 210145
2014-06-04 11:28:55 +08:00
#include "llvm/Config/llvm-config.h"
[clang] Fix out-of-bounds memory access in ComputeLineNumbers Differential Revision: https://reviews.llvm.org/D72409
2020-01-11 03:04:22 +08:00
#include "llvm/Support/Process.h"
For SourceManager::isBeforeInTranslationUnit(), have it consider macro arg expanded token locations as coming before the closing ')' of a function macro expansion. Include a unit test for SourceManager. llvm-svn: 147056
2011-12-22 00:56:29 +08:00
#include "gtest/gtest.h"
[clang] Fix out-of-bounds memory access in ComputeLineNumbers Differential Revision: https://reviews.llvm.org/D72409
2020-01-11 03:04:22 +08:00
#include <cstddef>
For SourceManager::isBeforeInTranslationUnit(), have it consider macro arg expanded token locations as coming before the closing ')' of a function macro expansion. Include a unit test for SourceManager. llvm-svn: 147056
2011-12-22 00:56:29 +08:00
using namespace clang;
namespace {
// The test fixture.
class SourceManagerTest : public ::testing::Test {
protected:
SourceManagerTest()
: FileMgr(FileMgrOpts),
DiagID(new DiagnosticIDs()),
Fixup unit tests for DiagnosticOptions change llvm-svn: 166509
2012-10-24 06:31:51 +08:00
Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
Fix the handling of target options in our unit tests. llvm-svn: 166079
2012-10-17 08:11:35 +08:00
SourceMgr(Diags, FileMgr),
TargetOpts(new TargetOptions) {
TargetOpts->Triple = "x86_64-apple-darwin11.1.0";
Use non-intrusive refcounting for TargetOptions llvm-svn: 212388
2014-07-06 13:26:44 +08:00
Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
For SourceManager::isBeforeInTranslationUnit(), have it consider macro arg expanded token locations as coming before the closing ')' of a function macro expansion. Include a unit test for SourceManager. llvm-svn: 147056
2011-12-22 00:56:29 +08:00
}
FileSystemOptions FileMgrOpts;
FileManager FileMgr;
Basic: import IntrusiveRefCntPtr<> into clang namespace The class name is long enough without the llvm:: added. Also bring in RefCountedBase and RefCountedBaseVPTR. llvm-svn: 150958
2012-02-20 22:00:23 +08:00
IntrusiveRefCntPtr<DiagnosticIDs> DiagID;
For SourceManager::isBeforeInTranslationUnit(), have it consider macro arg expanded token locations as coming before the closing ')' of a function macro expansion. Include a unit test for SourceManager. llvm-svn: 147056
2011-12-22 00:56:29 +08:00
DiagnosticsEngine Diags;
SourceManager SourceMgr;
LangOptions LangOpts;
Use non-intrusive refcounting for TargetOptions llvm-svn: 212388
2014-07-06 13:26:44 +08:00
std::shared_ptr<TargetOptions> TargetOpts;
Basic: import IntrusiveRefCntPtr<> into clang namespace The class name is long enough without the llvm:: added. Also bring in RefCountedBase and RefCountedBaseVPTR. llvm-svn: 150958
2012-02-20 22:00:23 +08:00
IntrusiveRefCntPtr<TargetInfo> Target;
For SourceManager::isBeforeInTranslationUnit(), have it consider macro arg expanded token locations as coming before the closing ')' of a function macro expansion. Include a unit test for SourceManager. llvm-svn: 147056
2011-12-22 00:56:29 +08:00
};
Allow interfaces to operate on in-memory buffers with no source location info. This patch is a part of the upstreaming efforts. Cling has the ability to spawn child interpreters (mainly for auto completions). The child interpreter import Decls using the ASTImporter which casuses the assertion here https://github.com/llvm/llvm-project/blob/65eb74e94b414fcde6bfa810d1c30c7fcb136b77/clang/include/clang/Basic/SourceLocation.h#L322 The patch is co-developed with V. Vassilev. Differential revision: https://reviews.llvm.org/D88780
2022-06-26 17:40:43 +08:00
TEST_F(SourceManagerTest, isInMemoryBuffersNoSourceLocationInfo) {
// Check for invalid source location for each method
SourceLocation LocEmpty;
bool isWrittenInBuiltInFileFalse = SourceMgr.isWrittenInBuiltinFile(LocEmpty);
bool isWrittenInCommandLineFileFalse =
SourceMgr.isWrittenInCommandLineFile(LocEmpty);
bool isWrittenInScratchSpaceFalse =
SourceMgr.isWrittenInScratchSpace(LocEmpty);
EXPECT_FALSE(isWrittenInBuiltInFileFalse);
EXPECT_FALSE(isWrittenInCommandLineFileFalse);
EXPECT_FALSE(isWrittenInScratchSpaceFalse);
// Check for valid source location per filename for each method
const char *Source = "int x";
std::unique_ptr<llvm::MemoryBuffer> BuiltInBuf =
llvm::MemoryBuffer::getMemBuffer(Source);
const FileEntry *BuiltInFile =
FileMgr.getVirtualFile("<built-in>", BuiltInBuf->getBufferSize(), 0);
SourceMgr.overrideFileContents(BuiltInFile, std::move(BuiltInBuf));
FileID BuiltInFileID =
SourceMgr.getOrCreateFileID(BuiltInFile, SrcMgr::C_User);
SourceMgr.setMainFileID(BuiltInFileID);
SourceLocation LocBuiltIn =
SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
bool isWrittenInBuiltInFileTrue =
SourceMgr.isWrittenInBuiltinFile(LocBuiltIn);
std::unique_ptr<llvm::MemoryBuffer> CommandLineBuf =
llvm::MemoryBuffer::getMemBuffer(Source);
const FileEntry *CommandLineFile = FileMgr.getVirtualFile(
"<command line>", CommandLineBuf->getBufferSize(), 0);
SourceMgr.overrideFileContents(CommandLineFile, std::move(CommandLineBuf));
FileID CommandLineFileID =
SourceMgr.getOrCreateFileID(CommandLineFile, SrcMgr::C_User);
SourceMgr.setMainFileID(CommandLineFileID);
SourceLocation LocCommandLine =
SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
bool isWrittenInCommandLineFileTrue =
SourceMgr.isWrittenInCommandLineFile(LocCommandLine);
std::unique_ptr<llvm::MemoryBuffer> ScratchSpaceBuf =
llvm::MemoryBuffer::getMemBuffer(Source);
const FileEntry *ScratchSpaceFile = FileMgr.getVirtualFile(
"<scratch space>", ScratchSpaceBuf->getBufferSize(), 0);
SourceMgr.overrideFileContents(ScratchSpaceFile, std::move(ScratchSpaceBuf));
FileID ScratchSpaceFileID =
SourceMgr.getOrCreateFileID(ScratchSpaceFile, SrcMgr::C_User);
SourceMgr.setMainFileID(ScratchSpaceFileID);
SourceLocation LocScratchSpace =
SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
bool isWrittenInScratchSpaceTrue =
SourceMgr.isWrittenInScratchSpace(LocScratchSpace);
EXPECT_TRUE(isWrittenInBuiltInFileTrue);
EXPECT_TRUE(isWrittenInCommandLineFileTrue);
EXPECT_TRUE(isWrittenInScratchSpaceTrue);
}
TEST_F(SourceManagerTest, isInSystemHeader) {
// Check for invalid source location
SourceLocation LocEmpty;
bool isInSystemHeaderFalse = SourceMgr.isInSystemHeader(LocEmpty);
ASSERT_FALSE(isInSystemHeaderFalse);
}
For SourceManager::isBeforeInTranslationUnit(), have it consider macro arg expanded token locations as coming before the closing ')' of a function macro expansion. Include a unit test for SourceManager. llvm-svn: 147056
2011-12-22 00:56:29 +08:00
TEST_F(SourceManagerTest, isBeforeInTranslationUnit) {
const char *source =
"#define M(x) [x]\n"
"M(foo)";
Make TargetInfo store an actual DataLayout instead of a string. Use it to calculate UserLabelPrefix, instead of specifying it (often incorrectly). Note that the *actual* user label prefix has always come from the DataLayout, and is handled within LLVM. The main thing clang's TargetInfo::UserLabelPrefix did was to set the #define value. Having these be different from each-other is just silly. Differential Revision: http://reviews.llvm.org/D17183 llvm-svn: 262737
2016-03-05 03:00:41 +08:00
std::unique_ptr<llvm::MemoryBuffer> Buf =
llvm::MemoryBuffer::getMemBuffer(source);
unique_ptrify SourceManager::createFileID llvm-svn: 216715
2014-08-29 15:59:55 +08:00
FileID mainFileID = SourceMgr.createFileID(std::move(Buf));
SourceManager: Use setMainFileID() consistently Eliminate createMainFileID() / createMainFileIDForMemBuffer() utility functions. These didn't add much convenience and conflated two distinct operations. This change makes things easier to follow by providing a consistent interface and getting rid of a bunch of cast-to-voids. llvm-svn: 209266
2014-05-21 09:12:41 +08:00
SourceMgr.setMainFileID(mainFileID);
For SourceManager::isBeforeInTranslationUnit(), have it consider macro arg expanded token locations as coming before the closing ')' of a function macro expansion. Include a unit test for SourceManager. llvm-svn: 147056
2011-12-22 00:56:29 +08:00
Add #pragma clang module build/endbuild pragmas for performing a module build as part of a compilation. This is intended for two purposes: 1) Writing self-contained test cases for modules: we can now write a single source file test that builds some number of module files on the side and imports them. 2) Debugging / test case reduction. A single-source testcase is much more amenable to reduction, compared to a VFS tarball or .pcm files. llvm-svn: 305101
2017-06-10 03:22:32 +08:00
TrivialModuleLoader ModLoader;
shared_ptrify (from InclusiveRefCntPtr) HeaderSearchOptions llvm-svn: 291202
2017-01-06 09:04:46 +08:00
HeaderSearch HeaderInfo(std::make_shared<HeaderSearchOptions>(), SourceMgr,
Diags, LangOpts, &*Target);
Move PreprocessorOptions to std::shared_ptr from IntrusiveRefCntPtr llvm-svn: 291160
2017-01-06 03:11:36 +08:00
Preprocessor PP(std::make_shared<PreprocessorOptions>(), Diags, LangOpts,
Modules: Rename MemoryBufferCache to InMemoryModuleCache Change MemoryBufferCache to InMemoryModuleCache, moving it from Basic to Serialization. Another patch will start using it to manage module build more explicitly, but this is split out because it's mostly mechanical. Because of the move to Serialization we can no longer abuse the Preprocessor to forward it to the ASTReader. Besides the rename and file move, that means Preprocessor::Preprocessor has one fewer parameter and ASTReader::ASTReader has one more. llvm-svn: 355777
2019-03-10 01:33:56 +08:00
SourceMgr, HeaderInfo, ModLoader,
[C++11] Use 'nullptr'. Unittests edition. llvm-svn: 210423
2014-06-08 16:38:12 +08:00
/*IILookup =*/nullptr,
Factor TargetInfo pointer/DelayInitialization bool pair out of Preprocessor ctor The Preprocessor::Initialize() function already offers a clear interface to achieve this, further reducing the confusing number of states a newly constructed preprocessor can have. llvm-svn: 207825
2014-05-02 11:43:30 +08:00
/*OwnsHeaderSearch =*/false);
PP.Initialize(*Target);
For SourceManager::isBeforeInTranslationUnit(), have it consider macro arg expanded token locations as coming before the closing ')' of a function macro expansion. Include a unit test for SourceManager. llvm-svn: 147056
2011-12-22 00:56:29 +08:00
PP.EnterMainSourceFile();
std::vector<Token> toks;
while (1) {
Token tok;
PP.Lex(tok);
if (tok.is(tok::eof))
break;
toks.push_back(tok);
}
// Make sure we got the tokens that we expected.
ASSERT_EQ(3U, toks.size());
ASSERT_EQ(tok::l_square, toks[0].getKind());
ASSERT_EQ(tok::identifier, toks[1].getKind());
ASSERT_EQ(tok::r_square, toks[2].getKind());
SourceLocation lsqrLoc = toks[0].getLocation();
SourceLocation idLoc = toks[1].getLocation();
SourceLocation rsqrLoc = toks[2].getLocation();
SourceLocation macroExpStartLoc = SourceMgr.translateLineCol(mainFileID, 2, 1);
SourceLocation macroExpEndLoc = SourceMgr.translateLineCol(mainFileID, 2, 6);
ASSERT_TRUE(macroExpStartLoc.isFileID());
ASSERT_TRUE(macroExpEndLoc.isFileID());
drop more llvm:: prefixes on SmallString<> More cleanup after r149799. llvm-svn: 150380
2012-02-13 20:32:26 +08:00
SmallString<32> str;
For SourceManager::isBeforeInTranslationUnit(), have it consider macro arg expanded token locations as coming before the closing ')' of a function macro expansion. Include a unit test for SourceManager. llvm-svn: 147056
2011-12-22 00:56:29 +08:00
ASSERT_EQ("M", PP.getSpelling(macroExpStartLoc, str));
ASSERT_EQ(")", PP.getSpelling(macroExpEndLoc, str));
EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(lsqrLoc, idLoc));
EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(idLoc, rsqrLoc));
EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(macroExpStartLoc, idLoc));
EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(idLoc, macroExpEndLoc));
}
Fix the location of the fixit for -Wnewline-eof. It turns out SourceManager treating the "one-past-the-end" location as invalid, but then failing to set the invalid flag properly. llvm-svn: 158699
2012-06-19 11:09:38 +08:00
TEST_F(SourceManagerTest, getColumnNumber) {
const char *Source =
"int x;\n"
"int y;";
Make TargetInfo store an actual DataLayout instead of a string. Use it to calculate UserLabelPrefix, instead of specifying it (often incorrectly). Note that the *actual* user label prefix has always come from the DataLayout, and is handled within LLVM. The main thing clang's TargetInfo::UserLabelPrefix did was to set the #define value. Having these be different from each-other is just silly. Differential Revision: http://reviews.llvm.org/D17183 llvm-svn: 262737
2016-03-05 03:00:41 +08:00
std::unique_ptr<llvm::MemoryBuffer> Buf =
llvm::MemoryBuffer::getMemBuffer(Source);
unique_ptrify SourceManager::createFileID llvm-svn: 216715
2014-08-29 15:59:55 +08:00
FileID MainFileID = SourceMgr.createFileID(std::move(Buf));
SourceManager: Use setMainFileID() consistently Eliminate createMainFileID() / createMainFileIDForMemBuffer() utility functions. These didn't add much convenience and conflated two distinct operations. This change makes things easier to follow by providing a consistent interface and getting rid of a bunch of cast-to-voids. llvm-svn: 209266
2014-05-21 09:12:41 +08:00
SourceMgr.setMainFileID(MainFileID);
Fix the location of the fixit for -Wnewline-eof. It turns out SourceManager treating the "one-past-the-end" location as invalid, but then failing to set the invalid flag properly. llvm-svn: 158699
2012-06-19 11:09:38 +08:00
bool Invalid;
Invalid = false;
EXPECT_EQ(1U, SourceMgr.getColumnNumber(MainFileID, 0, &Invalid));
EXPECT_TRUE(!Invalid);
Invalid = false;
EXPECT_EQ(5U, SourceMgr.getColumnNumber(MainFileID, 4, &Invalid));
EXPECT_TRUE(!Invalid);
Invalid = false;
EXPECT_EQ(1U, SourceMgr.getColumnNumber(MainFileID, 7, &Invalid));
EXPECT_TRUE(!Invalid);
Invalid = false;
EXPECT_EQ(5U, SourceMgr.getColumnNumber(MainFileID, 11, &Invalid));
EXPECT_TRUE(!Invalid);
Invalid = false;
EXPECT_EQ(7U, SourceMgr.getColumnNumber(MainFileID, strlen(Source),
&Invalid));
EXPECT_TRUE(!Invalid);
Invalid = false;
SourceMgr.getColumnNumber(MainFileID, strlen(Source)+1, &Invalid);
EXPECT_TRUE(Invalid);
// Test invalid files
Invalid = false;
SourceMgr.getColumnNumber(FileID(), 0, &Invalid);
EXPECT_TRUE(Invalid);
Invalid = false;
SourceMgr.getColumnNumber(FileID(), 1, &Invalid);
EXPECT_TRUE(Invalid);
// Test with no invalid flag.
[C++11] Use 'nullptr'. Unittests edition. llvm-svn: 210423
2014-06-08 16:38:12 +08:00
EXPECT_EQ(1U, SourceMgr.getColumnNumber(MainFileID, 0, nullptr));
Fix the location of the fixit for -Wnewline-eof. It turns out SourceManager treating the "one-past-the-end" location as invalid, but then failing to set the invalid flag properly. llvm-svn: 158699
2012-06-19 11:09:38 +08:00
}
Add dump() method for SourceRange Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D50662 llvm-svn: 341140
2018-08-31 07:10:52 +08:00
TEST_F(SourceManagerTest, locationPrintTest) {
const char *header = "#define IDENTITY(x) x\n";
const char *Source = "int x;\n"
"include \"test-header.h\"\n"
"IDENTITY(int y);\n"
"int z;";
std::unique_ptr<llvm::MemoryBuffer> HeaderBuf =
llvm::MemoryBuffer::getMemBuffer(header);
std::unique_ptr<llvm::MemoryBuffer> Buf =
llvm::MemoryBuffer::getMemBuffer(Source);
const FileEntry *SourceFile =
FileMgr.getVirtualFile("/mainFile.cpp", Buf->getBufferSize(), 0);
SourceMgr.overrideFileContents(SourceFile, std::move(Buf));
const FileEntry *HeaderFile =
FileMgr.getVirtualFile("/test-header.h", HeaderBuf->getBufferSize(), 0);
SourceMgr.overrideFileContents(HeaderFile, std::move(HeaderBuf));
FileID MainFileID = SourceMgr.getOrCreateFileID(SourceFile, SrcMgr::C_User);
FileID HeaderFileID = SourceMgr.getOrCreateFileID(HeaderFile, SrcMgr::C_User);
SourceMgr.setMainFileID(MainFileID);
auto BeginLoc = SourceMgr.getLocForStartOfFile(MainFileID);
auto EndLoc = SourceMgr.getLocForEndOfFile(MainFileID);
auto BeginEOLLoc = SourceMgr.translateLineCol(MainFileID, 1, 7);
auto HeaderLoc = SourceMgr.getLocForStartOfFile(HeaderFileID);
EXPECT_EQ(BeginLoc.printToString(SourceMgr), "/mainFile.cpp:1:1");
EXPECT_EQ(EndLoc.printToString(SourceMgr), "/mainFile.cpp:4:7");
EXPECT_EQ(BeginEOLLoc.printToString(SourceMgr), "/mainFile.cpp:1:7");
EXPECT_EQ(HeaderLoc.printToString(SourceMgr), "/test-header.h:1:1");
EXPECT_EQ(SourceRange(BeginLoc, BeginLoc).printToString(SourceMgr),
"</mainFile.cpp:1:1>");
EXPECT_EQ(SourceRange(BeginLoc, BeginEOLLoc).printToString(SourceMgr),
"</mainFile.cpp:1:1, col:7>");
EXPECT_EQ(SourceRange(BeginLoc, EndLoc).printToString(SourceMgr),
"</mainFile.cpp:1:1, line:4:7>");
EXPECT_EQ(SourceRange(BeginLoc, HeaderLoc).printToString(SourceMgr),
"</mainFile.cpp:1:1, /test-header.h:1:1>");
}
[clang-format] Remove duplciate code from Invalid BOM detection Summary: Review comments on {D68767} asked that this duplicated code in clang-format was moved to one central location that being SourceManager (where it had originally be copied from I assume) Moved function into static function ContentCache::getInvalidBOM(...) - (closest class to where it was defined before) Updated clang-format to call this static function Added unit tests for said new function in BasicTests Sorry not my normal code area so may have the wrong reviewers. (but your names were on the recent history) Reviewers: bruno, arphaman, klimek, owenpan, mitchell-stellar, dexonsmith Reviewed By: owenpan Subscribers: cfe-commits Tags: #clang, #clang-format, #clang-tools-extra Differential Revision: https://reviews.llvm.org/D68914
2019-10-25 03:24:03 +08:00
TEST_F(SourceManagerTest, getInvalidBOM) {
ASSERT_EQ(SrcMgr::ContentCache::getInvalidBOM(""), nullptr);
ASSERT_EQ(SrcMgr::ContentCache::getInvalidBOM("\x00\x00\x00"), nullptr);
ASSERT_EQ(SrcMgr::ContentCache::getInvalidBOM("\xFF\xFF\xFF"), nullptr);
ASSERT_EQ(SrcMgr::ContentCache::getInvalidBOM("#include <iostream>"),
nullptr);
ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
"\xFE\xFF#include <iostream>")),
"UTF-16 (BE)");
ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
"\xFF\xFE#include <iostream>")),
"UTF-16 (LE)");
ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
"\x2B\x2F\x76#include <iostream>")),
"UTF-7");
ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
"\xF7\x64\x4C#include <iostream>")),
"UTF-1");
ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
"\xDD\x73\x66\x73#include <iostream>")),
"UTF-EBCDIC");
ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
"\x0E\xFE\xFF#include <iostream>")),
"SCSU");
ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
"\xFB\xEE\x28#include <iostream>")),
"BOCU-1");
ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
"\x84\x31\x95\x33#include <iostream>")),
"GB-18030");
ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
llvm::StringLiteral::withInnerNUL(
"\x00\x00\xFE\xFF#include <iostream>"))),
"UTF-32 (BE)");
ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
llvm::StringLiteral::withInnerNUL(
"\xFF\xFE\x00\x00#include <iostream>"))),
"UTF-32 (LE)");
}
[clang] Fix out-of-bounds memory access in ComputeLineNumbers Differential Revision: https://reviews.llvm.org/D72409
2020-01-11 03:04:22 +08:00
// Regression test - there was an out of bound access for buffers not terminated by zero.
TEST_F(SourceManagerTest, getLineNumber) {
const unsigned pageSize = llvm::sys::Process::getPageSizeEstimate();
std::unique_ptr<char[]> source(new char[pageSize]);
for(unsigned i = 0; i < pageSize; ++i) {
source[i] = 'a';
}
std::unique_ptr<llvm::MemoryBuffer> Buf =
llvm::MemoryBuffer::getMemBuffer(
llvm::MemoryBufferRef(
llvm::StringRef(source.get(), 3), "whatever"
),
false
);
FileID mainFileID = SourceMgr.createFileID(std::move(Buf));
SourceMgr.setMainFileID(mainFileID);
ASSERT_NO_FATAL_FAILURE(SourceMgr.getLineNumber(mainFileID, 1, nullptr));
}
Fix bugs in SourceManager::computeMacroArgsCache() and add a unit test for it. llvm-svn: 147057
2011-12-22 00:56:35 +08:00
#if defined(LLVM_ON_UNIX)
TEST_F(SourceManagerTest, getMacroArgExpandedLocation) {
const char *header =
"#define FM(x,y) x\n";
const char *main =
"#include \"/test-header.h\"\n"
"#define VAL 0\n"
"FM(VAL,0)\n"
"FM(0,VAL)\n"
"FM(FM(0,VAL),0)\n"
"#define CONCAT(X, Y) X##Y\n"
"CONCAT(1,1)\n";
Make TargetInfo store an actual DataLayout instead of a string. Use it to calculate UserLabelPrefix, instead of specifying it (often incorrectly). Note that the *actual* user label prefix has always come from the DataLayout, and is handled within LLVM. The main thing clang's TargetInfo::UserLabelPrefix did was to set the #define value. Having these be different from each-other is just silly. Differential Revision: http://reviews.llvm.org/D17183 llvm-svn: 262737
2016-03-05 03:00:41 +08:00
std::unique_ptr<llvm::MemoryBuffer> HeaderBuf =
llvm::MemoryBuffer::getMemBuffer(header);
std::unique_ptr<llvm::MemoryBuffer> MainBuf =
llvm::MemoryBuffer::getMemBuffer(main);
unique_ptrify SourceManager::createFileID llvm-svn: 216715
2014-08-29 15:59:55 +08:00
FileID mainFileID = SourceMgr.createFileID(std::move(MainBuf));
SourceManager: Use setMainFileID() consistently Eliminate createMainFileID() / createMainFileIDForMemBuffer() utility functions. These didn't add much convenience and conflated two distinct operations. This change makes things easier to follow by providing a consistent interface and getting rid of a bunch of cast-to-voids. llvm-svn: 209266
2014-05-21 09:12:41 +08:00
SourceMgr.setMainFileID(mainFileID);
Fix bugs in SourceManager::computeMacroArgsCache() and add a unit test for it. llvm-svn: 147057
2011-12-22 00:56:35 +08:00
const FileEntry *headerFile = FileMgr.getVirtualFile("/test-header.h",
Update for LLVM api change. llvm-svn: 216585
2014-08-28 04:03:29 +08:00
HeaderBuf->getBufferSize(), 0);
Overload SourceManager::overrideFileContents so that unconditionally passing ownership is explicitly done using unique_ptr. Only those callers who are dynamically passing ownership should need the 3 argument form. Those accepting the default ("do pass ownership") should do so explicitly with a unique_ptr now. llvm-svn: 216614
2014-08-28 04:54:45 +08:00
SourceMgr.overrideFileContents(headerFile, std::move(HeaderBuf));
Fix bugs in SourceManager::computeMacroArgsCache() and add a unit test for it. llvm-svn: 147057
2011-12-22 00:56:35 +08:00
Add #pragma clang module build/endbuild pragmas for performing a module build as part of a compilation. This is intended for two purposes: 1) Writing self-contained test cases for modules: we can now write a single source file test that builds some number of module files on the side and imports them. 2) Debugging / test case reduction. A single-source testcase is much more amenable to reduction, compared to a VFS tarball or .pcm files. llvm-svn: 305101
2017-06-10 03:22:32 +08:00
TrivialModuleLoader ModLoader;
shared_ptrify (from InclusiveRefCntPtr) HeaderSearchOptions llvm-svn: 291202
2017-01-06 09:04:46 +08:00
HeaderSearch HeaderInfo(std::make_shared<HeaderSearchOptions>(), SourceMgr,
Diags, LangOpts, &*Target);
[clang] Make sure argument expansion locations are correct in presence of predefined buffer Summary: Macro argument expansion logic relies on skipping file IDs that created as a result of an include. Unfortunately it fails to do that for predefined buffer since it doesn't have a valid insertion location. As a result of that any file ID created for an include inside the predefined buffers breaks the traversal logic in SourceManager::computeMacroArgsCache. To fix this issue we first record number of created FIDs for predefined buffer, and then skip them explicitly in source manager. Another solution would be to just give predefined buffers a valid source location, but it is unclear where that should be.. Reviewers: sammccall Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D78649
2020-04-22 22:37:27 +08:00
Move PreprocessorOptions to std::shared_ptr from IntrusiveRefCntPtr llvm-svn: 291160
2017-01-06 03:11:36 +08:00
Preprocessor PP(std::make_shared<PreprocessorOptions>(), Diags, LangOpts,
Modules: Rename MemoryBufferCache to InMemoryModuleCache Change MemoryBufferCache to InMemoryModuleCache, moving it from Basic to Serialization. Another patch will start using it to manage module build more explicitly, but this is split out because it's mostly mechanical. Because of the move to Serialization we can no longer abuse the Preprocessor to forward it to the ASTReader. Besides the rename and file move, that means Preprocessor::Preprocessor has one fewer parameter and ASTReader::ASTReader has one more. llvm-svn: 355777
2019-03-10 01:33:56 +08:00
SourceMgr, HeaderInfo, ModLoader,
[C++11] Use 'nullptr'. Unittests edition. llvm-svn: 210423
2014-06-08 16:38:12 +08:00
/*IILookup =*/nullptr,
Factor TargetInfo pointer/DelayInitialization bool pair out of Preprocessor ctor The Preprocessor::Initialize() function already offers a clear interface to achieve this, further reducing the confusing number of states a newly constructed preprocessor can have. llvm-svn: 207825
2014-05-02 11:43:30 +08:00
/*OwnsHeaderSearch =*/false);
[clang] Make sure argument expansion locations are correct in presence of predefined buffer Summary: Macro argument expansion logic relies on skipping file IDs that created as a result of an include. Unfortunately it fails to do that for predefined buffer since it doesn't have a valid insertion location. As a result of that any file ID created for an include inside the predefined buffers breaks the traversal logic in SourceManager::computeMacroArgsCache. To fix this issue we first record number of created FIDs for predefined buffer, and then skip them explicitly in source manager. Another solution would be to just give predefined buffers a valid source location, but it is unclear where that should be.. Reviewers: sammccall Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D78649
2020-04-22 22:37:27 +08:00
// Ensure we can get expanded locations in presence of implicit includes.
// These are different than normal includes since predefines buffer doesn't
// have a valid insertion location.
PP.setPredefines("#include \"/implicit-header.h\"");
FileMgr.getVirtualFile("/implicit-header.h", 0, 0);
Factor TargetInfo pointer/DelayInitialization bool pair out of Preprocessor ctor The Preprocessor::Initialize() function already offers a clear interface to achieve this, further reducing the confusing number of states a newly constructed preprocessor can have. llvm-svn: 207825
2014-05-02 11:43:30 +08:00
PP.Initialize(*Target);
Fix bugs in SourceManager::computeMacroArgsCache() and add a unit test for it. llvm-svn: 147057
2011-12-22 00:56:35 +08:00
PP.EnterMainSourceFile();
std::vector<Token> toks;
while (1) {
Token tok;
PP.Lex(tok);
if (tok.is(tok::eof))
break;
toks.push_back(tok);
}
// Make sure we got the tokens that we expected.
ASSERT_EQ(4U, toks.size());
ASSERT_EQ(tok::numeric_constant, toks[0].getKind());
ASSERT_EQ(tok::numeric_constant, toks[1].getKind());
ASSERT_EQ(tok::numeric_constant, toks[2].getKind());
ASSERT_EQ(tok::numeric_constant, toks[3].getKind());
SourceLocation defLoc = SourceMgr.translateLineCol(mainFileID, 2, 13);
SourceLocation loc1 = SourceMgr.translateLineCol(mainFileID, 3, 8);
SourceLocation loc2 = SourceMgr.translateLineCol(mainFileID, 4, 4);
SourceLocation loc3 = SourceMgr.translateLineCol(mainFileID, 5, 7);
SourceLocation defLoc2 = SourceMgr.translateLineCol(mainFileID, 6, 22);
defLoc = SourceMgr.getMacroArgExpandedLocation(defLoc);
loc1 = SourceMgr.getMacroArgExpandedLocation(loc1);
loc2 = SourceMgr.getMacroArgExpandedLocation(loc2);
loc3 = SourceMgr.getMacroArgExpandedLocation(loc3);
defLoc2 = SourceMgr.getMacroArgExpandedLocation(defLoc2);
EXPECT_TRUE(defLoc.isFileID());
EXPECT_TRUE(loc1.isFileID());
EXPECT_TRUE(SourceMgr.isMacroArgExpansion(loc2));
EXPECT_TRUE(SourceMgr.isMacroArgExpansion(loc3));
EXPECT_EQ(loc2, toks[1].getLocation());
EXPECT_EQ(loc3, toks[2].getLocation());
EXPECT_TRUE(defLoc2.isFileID());
}
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
namespace {
struct MacroAction {
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
enum Kind { kExpansion, kDefinition, kUnDefinition};
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
SourceLocation Loc;
std::string Name;
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
unsigned MAKind : 3;
MacroAction(SourceLocation Loc, StringRef Name, unsigned K)
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
: Loc(Loc), Name(std::string(Name)), MAKind(K) {}
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
bool isExpansion() const { return MAKind == kExpansion; }
bool isDefinition() const { return MAKind & kDefinition; }
bool isUnDefinition() const { return MAKind & kUnDefinition; }
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
};
class MacroTracker : public PPCallbacks {
std::vector<MacroAction> &Macros;
public:
explicit MacroTracker(std::vector<MacroAction> &Macros) : Macros(Macros) { }
Use 'override/final' instead of 'virtual' for overridden methods Summary: The patch is generated using clang-tidy misc-use-override check. This command was used: tools/clang/tools/extra/clang-tidy/tool/run-clang-tidy.py \ -checks='-*,misc-use-override' -header-filter='llvm|clang' -j=32 -fix Reviewers: dblaikie Reviewed By: dblaikie Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D8926 llvm-svn: 234678
2015-04-11 10:00:23 +08:00
void MacroDefined(const Token &MacroNameTok,
const MacroDirective *MD) override {
[preprocessor] Use MacroDirective in the preprocessor callbacks to make available the full information about the macro (e.g if it was imported and where). llvm-svn: 175978
2013-02-24 08:05:14 +08:00
Macros.push_back(MacroAction(MD->getLocation(),
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
MacroNameTok.getIdentifierInfo()->getName(),
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
MacroAction::kDefinition));
}
void MacroUndefined(const Token &MacroNameTok,
const MacroDefinition &MD,
const MacroDirective *UD) override {
Macros.push_back(
MacroAction(UD ? UD->getLocation() : SourceLocation(),
MacroNameTok.getIdentifierInfo()->getName(),
UD ? MacroAction::kDefinition | MacroAction::kUnDefinition
: MacroAction::kUnDefinition));
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
}
Switch PPCallbacks to take the new MacroDefinition instead of MacroDirective*, in order to preserve full information on module macro expansion. llvm-svn: 236404
2015-05-04 11:15:40 +08:00
void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
Use 'override/final' instead of 'virtual' for overridden methods Summary: The patch is generated using clang-tidy misc-use-override check. This command was used: tools/clang/tools/extra/clang-tidy/tool/run-clang-tidy.py \ -checks='-*,misc-use-override' -header-filter='llvm|clang' -j=32 -fix Reviewers: dblaikie Reviewed By: dblaikie Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D8926 llvm-svn: 234678
2015-04-11 10:00:23 +08:00
SourceRange Range, const MacroArgs *Args) override {
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
Macros.push_back(MacroAction(MacroNameTok.getLocation(),
MacroNameTok.getIdentifierInfo()->getName(),
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
MacroAction::kExpansion));
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
}
};
Revert r240270 ("Fixed/added namespace ending comments using clang-tidy"). llvm-svn: 240353
2015-06-23 07:07:51 +08:00
}
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
TEST_F(SourceManagerTest, isBeforeInTranslationUnitWithMacroInInclude) {
const char *header =
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
"#define MACRO_IN_INCLUDE 0\n"
"#define MACRO_DEFINED\n"
"#undef MACRO_DEFINED\n"
"#undef MACRO_UNDEFINED\n";
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
const char *main =
"#define M(x) x\n"
"#define INC \"/test-header.h\"\n"
"#include M(INC)\n"
"#define INC2 </test-header.h>\n"
"#include M(INC2)\n";
Make TargetInfo store an actual DataLayout instead of a string. Use it to calculate UserLabelPrefix, instead of specifying it (often incorrectly). Note that the *actual* user label prefix has always come from the DataLayout, and is handled within LLVM. The main thing clang's TargetInfo::UserLabelPrefix did was to set the #define value. Having these be different from each-other is just silly. Differential Revision: http://reviews.llvm.org/D17183 llvm-svn: 262737
2016-03-05 03:00:41 +08:00
std::unique_ptr<llvm::MemoryBuffer> HeaderBuf =
llvm::MemoryBuffer::getMemBuffer(header);
std::unique_ptr<llvm::MemoryBuffer> MainBuf =
llvm::MemoryBuffer::getMemBuffer(main);
unique_ptrify SourceManager::createFileID llvm-svn: 216715
2014-08-29 15:59:55 +08:00
SourceMgr.setMainFileID(SourceMgr.createFileID(std::move(MainBuf)));
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
const FileEntry *headerFile = FileMgr.getVirtualFile("/test-header.h",
Update for LLVM api change. llvm-svn: 216585
2014-08-28 04:03:29 +08:00
HeaderBuf->getBufferSize(), 0);
Overload SourceManager::overrideFileContents so that unconditionally passing ownership is explicitly done using unique_ptr. Only those callers who are dynamically passing ownership should need the 3 argument form. Those accepting the default ("do pass ownership") should do so explicitly with a unique_ptr now. llvm-svn: 216614
2014-08-28 04:54:45 +08:00
SourceMgr.overrideFileContents(headerFile, std::move(HeaderBuf));
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
Add #pragma clang module build/endbuild pragmas for performing a module build as part of a compilation. This is intended for two purposes: 1) Writing self-contained test cases for modules: we can now write a single source file test that builds some number of module files on the side and imports them. 2) Debugging / test case reduction. A single-source testcase is much more amenable to reduction, compared to a VFS tarball or .pcm files. llvm-svn: 305101
2017-06-10 03:22:32 +08:00
TrivialModuleLoader ModLoader;
shared_ptrify (from InclusiveRefCntPtr) HeaderSearchOptions llvm-svn: 291202
2017-01-06 09:04:46 +08:00
HeaderSearch HeaderInfo(std::make_shared<HeaderSearchOptions>(), SourceMgr,
Diags, LangOpts, &*Target);
Move PreprocessorOptions to std::shared_ptr from IntrusiveRefCntPtr llvm-svn: 291160
2017-01-06 03:11:36 +08:00
Preprocessor PP(std::make_shared<PreprocessorOptions>(), Diags, LangOpts,
Modules: Rename MemoryBufferCache to InMemoryModuleCache Change MemoryBufferCache to InMemoryModuleCache, moving it from Basic to Serialization. Another patch will start using it to manage module build more explicitly, but this is split out because it's mostly mechanical. Because of the move to Serialization we can no longer abuse the Preprocessor to forward it to the ASTReader. Besides the rename and file move, that means Preprocessor::Preprocessor has one fewer parameter and ASTReader::ASTReader has one more. llvm-svn: 355777
2019-03-10 01:33:56 +08:00
SourceMgr, HeaderInfo, ModLoader,
[C++11] Use 'nullptr'. Unittests edition. llvm-svn: 210423
2014-06-08 16:38:12 +08:00
/*IILookup =*/nullptr,
Factor TargetInfo pointer/DelayInitialization bool pair out of Preprocessor ctor The Preprocessor::Initialize() function already offers a clear interface to achieve this, further reducing the confusing number of states a newly constructed preprocessor can have. llvm-svn: 207825
2014-05-02 11:43:30 +08:00
/*OwnsHeaderSearch =*/false);
PP.Initialize(*Target);
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
std::vector<MacroAction> Macros;
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
PP.addPPCallbacks(std::make_unique<MacroTracker>(Macros));
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
PP.EnterMainSourceFile();
std::vector<Token> toks;
while (1) {
Token tok;
PP.Lex(tok);
if (tok.is(tok::eof))
break;
toks.push_back(tok);
}
// Make sure we got the tokens that we expected.
ASSERT_EQ(0U, toks.size());
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
ASSERT_EQ(15U, Macros.size());
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
// #define M(x) x
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
ASSERT_TRUE(Macros[0].isDefinition());
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
ASSERT_EQ("M", Macros[0].Name);
// #define INC "/test-header.h"
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
ASSERT_TRUE(Macros[1].isDefinition());
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
ASSERT_EQ("INC", Macros[1].Name);
// M expansion in #include M(INC)
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
ASSERT_FALSE(Macros[2].isDefinition());
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
ASSERT_EQ("M", Macros[2].Name);
// INC expansion in #include M(INC)
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
ASSERT_TRUE(Macros[3].isExpansion());
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
ASSERT_EQ("INC", Macros[3].Name);
// #define MACRO_IN_INCLUDE 0
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
ASSERT_TRUE(Macros[4].isDefinition());
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
ASSERT_EQ("MACRO_IN_INCLUDE", Macros[4].Name);
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
// #define MACRO_DEFINED
ASSERT_TRUE(Macros[5].isDefinition());
ASSERT_FALSE(Macros[5].isUnDefinition());
ASSERT_EQ("MACRO_DEFINED", Macros[5].Name);
// #undef MACRO_DEFINED
ASSERT_TRUE(Macros[6].isDefinition());
ASSERT_TRUE(Macros[6].isUnDefinition());
ASSERT_EQ("MACRO_DEFINED", Macros[6].Name);
// #undef MACRO_UNDEFINED
ASSERT_FALSE(Macros[7].isDefinition());
ASSERT_TRUE(Macros[7].isUnDefinition());
ASSERT_EQ("MACRO_UNDEFINED", Macros[7].Name);
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
// #define INC2 </test-header.h>
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
ASSERT_TRUE(Macros[8].isDefinition());
ASSERT_EQ("INC2", Macros[8].Name);
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
// M expansion in #include M(INC2)
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
ASSERT_FALSE(Macros[9].isDefinition());
ASSERT_EQ("M", Macros[9].Name);
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
// INC2 expansion in #include M(INC2)
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
ASSERT_TRUE(Macros[10].isExpansion());
ASSERT_EQ("INC2", Macros[10].Name);
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
// #define MACRO_IN_INCLUDE 0
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
ASSERT_TRUE(Macros[11].isDefinition());
ASSERT_EQ("MACRO_IN_INCLUDE", Macros[11].Name);
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
// The INC expansion in #include M(INC) comes before the first
// MACRO_IN_INCLUDE definition of the included file.
EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(Macros[3].Loc, Macros[4].Loc));
// The INC2 expansion in #include M(INC2) comes before the second
// MACRO_IN_INCLUDE definition of the included file.
Revert "Revert "PPCallbacks::MacroUndefined, change signature and add test."" This reverts commit r301469. It isn't needed with r301470, which fixes the API break introduced in the original commit. llvm-svn: 301472
2017-04-27 05:05:44 +08:00
EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(Macros[10].Loc, Macros[11].Loc));
[preprocessor] Handle correctly inclusion directives that have macro expansions, e.g "#include MACRO(STUFF)". -As an inclusion position for the included file, use the file location of the file where it was included but *after* the macro expansions. We want the macro expansions to be considered as before-in-translation-unit for everything in the included file. -In the preprocessing record take into account that only inclusion directives can be encountered as "out-of-order" (by comparing the start of the range which for inclusions is the hash location) and use binary search if there is an extreme number of macro expansions in the include directive. Fixes rdar://11111779 llvm-svn: 153527
2012-03-28 02:47:48 +08:00
}
[clang][Preprocessor] Replace the slow translateFile call by a new, faster isMainFile check The commit 3c28a2dc6bdc331e5a0d8097a5fa59d06682b9d0 introduced the check that checks if we're trying to re-enter a main file when building a preamble. Unfortunately this slowed down the preamble compilation by 80-90% in some test cases, as translateFile is really slow. This change checks to see if the FileEntry is the main file without calling translateFile, but by using the new isMainFile check instead. This speeds up preamble building by 1.5-2x for certain test cases that we have. rdar://59361291 Differential Revision: https://reviews.llvm.org/D79834
2020-05-15 05:11:31 +08:00
TEST_F(SourceManagerTest, isMainFile) {
const char *Source = "int x;";
std::unique_ptr<llvm::MemoryBuffer> Buf =
llvm::MemoryBuffer::getMemBuffer(Source);
const FileEntry *SourceFile =
FileMgr.getVirtualFile("mainFile.cpp", Buf->getBufferSize(), 0);
SourceMgr.overrideFileContents(SourceFile, std::move(Buf));
std::unique_ptr<llvm::MemoryBuffer> Buf2 =
llvm::MemoryBuffer::getMemBuffer(Source);
const FileEntry *SecondFile =
FileMgr.getVirtualFile("file2.cpp", Buf2->getBufferSize(), 0);
SourceMgr.overrideFileContents(SecondFile, std::move(Buf2));
FileID MainFileID = SourceMgr.getOrCreateFileID(SourceFile, SrcMgr::C_User);
SourceMgr.setMainFileID(MainFileID);
SourceManager: Change SourceManager::isMainFile to take a FileEntry, NFC `SourceManager::isMainFile` does not use the filename, so it doesn't need the full `FileEntryRef`; in fact, it's misleading to take the name because that makes it look relevant. Simplify the API, and in the process remove some calls to `FileEntryRef::FileEntryRef` in the unit tests (which were blocking making that private to `SourceManager`). Differential Revision: https://reviews.llvm.org/D89507
2020-10-16 06:32:34 +08:00
EXPECT_TRUE(SourceMgr.isMainFile(*SourceFile));
EXPECT_TRUE(SourceMgr.isMainFile(*SourceFile));
EXPECT_FALSE(SourceMgr.isMainFile(*SecondFile));
[clang][Preprocessor] Replace the slow translateFile call by a new, faster isMainFile check The commit 3c28a2dc6bdc331e5a0d8097a5fa59d06682b9d0 introduced the check that checks if we're trying to re-enter a main file when building a preamble. Unfortunately this slowed down the preamble compilation by 80-90% in some test cases, as translateFile is really slow. This change checks to see if the FileEntry is the main file without calling translateFile, but by using the new isMainFile check instead. This speeds up preamble building by 1.5-2x for certain test cases that we have. rdar://59361291 Differential Revision: https://reviews.llvm.org/D79834
2020-05-15 05:11:31 +08:00
}
Fix bugs in SourceManager::computeMacroArgsCache() and add a unit test for it. llvm-svn: 147057
2011-12-22 00:56:35 +08:00
#endif
For SourceManager::isBeforeInTranslationUnit(), have it consider macro arg expanded token locations as coming before the closing ')' of a function macro expansion. Include a unit test for SourceManager. llvm-svn: 147056
2011-12-22 00:56:29 +08:00
} // anonymous namespace