mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2025-05-14 09:56:33 +00:00
3116d60494
This new method repeatedly calls Lex() until end of file is reached and optionally fills a std::vector of Tokens. Use it in Clang's unit tests to avoid quite some code duplication. Differential Revision: https://reviews.llvm.org/D158413
93 lines
3.2 KiB
C++
93 lines
3.2 KiB
C++
//===- unittests/Lex/PPMemoryAllocationsTest.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
|
|
//
|
|
//===--------------------------------------------------------------===//
|
|
|
|
#include "clang/Basic/Diagnostic.h"
|
|
#include "clang/Basic/DiagnosticOptions.h"
|
|
#include "clang/Basic/FileManager.h"
|
|
#include "clang/Basic/LangOptions.h"
|
|
#include "clang/Basic/SourceManager.h"
|
|
#include "clang/Basic/TargetInfo.h"
|
|
#include "clang/Basic/TargetOptions.h"
|
|
#include "clang/Lex/HeaderSearch.h"
|
|
#include "clang/Lex/HeaderSearchOptions.h"
|
|
#include "clang/Lex/ModuleLoader.h"
|
|
#include "clang/Lex/Preprocessor.h"
|
|
#include "clang/Lex/PreprocessorOptions.h"
|
|
#include "gtest/gtest.h"
|
|
|
|
using namespace clang;
|
|
|
|
namespace {
|
|
|
|
class PPMemoryAllocationsTest : public ::testing::Test {
|
|
protected:
|
|
PPMemoryAllocationsTest()
|
|
: FileMgr(FileMgrOpts), DiagID(new DiagnosticIDs()),
|
|
Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
|
|
SourceMgr(Diags, FileMgr), TargetOpts(new TargetOptions) {
|
|
TargetOpts->Triple = "x86_64-apple-darwin11.1.0";
|
|
Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
|
|
}
|
|
|
|
FileSystemOptions FileMgrOpts;
|
|
FileManager FileMgr;
|
|
IntrusiveRefCntPtr<DiagnosticIDs> DiagID;
|
|
DiagnosticsEngine Diags;
|
|
SourceManager SourceMgr;
|
|
LangOptions LangOpts;
|
|
std::shared_ptr<TargetOptions> TargetOpts;
|
|
IntrusiveRefCntPtr<TargetInfo> Target;
|
|
};
|
|
|
|
TEST_F(PPMemoryAllocationsTest, PPMacroDefinesAllocations) {
|
|
std::string Source;
|
|
size_t NumMacros = 1000000;
|
|
{
|
|
llvm::raw_string_ostream SourceOS(Source);
|
|
|
|
// Create a combination of 1 or 3 token macros.
|
|
for (size_t I = 0; I < NumMacros; ++I) {
|
|
SourceOS << "#define MACRO_ID_" << I << " ";
|
|
if ((I % 2) == 0)
|
|
SourceOS << "(" << I << ")";
|
|
else
|
|
SourceOS << I;
|
|
SourceOS << "\n";
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<llvm::MemoryBuffer> Buf =
|
|
llvm::MemoryBuffer::getMemBuffer(Source);
|
|
SourceMgr.setMainFileID(SourceMgr.createFileID(std::move(Buf)));
|
|
|
|
TrivialModuleLoader ModLoader;
|
|
HeaderSearch HeaderInfo(std::make_shared<HeaderSearchOptions>(), SourceMgr,
|
|
Diags, LangOpts, Target.get());
|
|
Preprocessor PP(std::make_shared<PreprocessorOptions>(), Diags, LangOpts,
|
|
SourceMgr, HeaderInfo, ModLoader,
|
|
/*IILookup =*/nullptr,
|
|
/*OwnsHeaderSearch =*/false);
|
|
PP.Initialize(*Target);
|
|
PP.EnterMainSourceFile();
|
|
|
|
PP.LexTokensUntilEOF();
|
|
|
|
size_t NumAllocated = PP.getPreprocessorAllocator().getBytesAllocated();
|
|
float BytesPerDefine = float(NumAllocated) / float(NumMacros);
|
|
llvm::errs() << "Num preprocessor allocations for " << NumMacros
|
|
<< " #define: " << NumAllocated << "\n";
|
|
llvm::errs() << "Bytes per #define: " << BytesPerDefine << "\n";
|
|
// On arm64-apple-macos, we get around 120 bytes per define.
|
|
// Assume a reasonable upper bound based on that number that we don't want
|
|
// to exceed when storing information about a macro #define with 1 or 3
|
|
// tokens.
|
|
EXPECT_LT(BytesPerDefine, 130.0f);
|
|
}
|
|
|
|
} // anonymous namespace
|