rpm/llvm
SHA256
1
0
Fork 0
forked from pool/llvm
Code Pull Requests Activity

Accepting request 116319 from devel:tools:compiler

Browse Source 
As discussed previously, the patch that improves usage with icecream.
 (forwarded request 116316 from llunak)

OBS-URL: https://build.opensuse.org/request/show/116319
OBS-URL: https://build.opensuse.org/package/show/openSUSE:Factory/llvm?expand=0&rev=25
This commit is contained in:
Stephan Kulow 2012-05-08 09:15:06 +00:00 committed by Git OBS Bridge
commit dfca6e72ba
5 changed files with 770 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
llvm-3.0.99+svn154914.tar.bz2
View File

@ -1,3 +0,0 @@
version https://git-lfs.github.com/spec/v1
oid sha256:af9ae518982b9385f4bceae48eafcf1ffb309bbd2422a5a95aa1df00f0d216aa
size 16144645

3
llvm-3.0.99+svn155819.tar.bz2 Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:f46df932ad690171d2f5e2de4f2ca542139675b48f921cc7913eda2f027f85d3
size 16437850

48
llvm.changes
View File

@ -1,3 +1,51 @@
-------------------------------------------------------------------
Thu May 3 07:32:06 UTC 2012 - llunak@suse.com
- patch for -rewrite-includes feature
-------------------------------------------------------------------
Mon Apr 30 12:39:14 UTC 2012 - idonmez@suse.com
- Update to svn revision 155819 from 3.1 branch
* C++11 fixes
-------------------------------------------------------------------
Fri Apr 27 10:02:17 UTC 2012 - idonmez@suse.com
- Update to svn revision 155700 from 3.1 branch
* Crash fixes
* C++11 fixes
-------------------------------------------------------------------
Thu Apr 26 12:35:35 UTC 2012 - idonmez@suse.com
- Update to svn revision 155574 from 3.1 branch
* Crash fixes
* Correctly enable compiler-rt
* Remove unneeded runtime python dependencies
-------------------------------------------------------------------
Thu Apr 26 10:55:02 UTC 2012 - idonmez@suse.com
- Switch to 2-stage bootstrap because we don't do build-compare
anyway.
-------------------------------------------------------------------
Wed Apr 25 09:40:32 UTC 2012 - idonmez@suse.com
- More fixes to llvm-config
-------------------------------------------------------------------
Tue Apr 24 10:12:32 UTC 2012 - idonmez@suse.com
- Fix llvm-config --libs output
-------------------------------------------------------------------
Sun Apr 22 19:24:24 UTC 2012 - idonmez@suse.com
- Update to svn revision 155320 from 3.1 branch
* AVX fixes
-------------------------------------------------------------------
Tue Apr 17 07:48:50 UTC 2012 - idonmez@suse.com

72
llvm.spec
View File

@ -16,12 +16,12 @@
#
%define _revision 154914
%define _revision 155819
%define _release_version 3.1
%define _supported_archs "arm,x86"
Name: llvm
Version: 3.0.99+svn154914
Version: 3.0.99+svn155819
Release: 0
Summary: Low Level Virtual Machine
License: NCSA
@ -38,6 +38,7 @@ Patch3: clang-disable-ada-extension.patch
# PATCH-FIX-OPENSUSE default-to-i586.patch -- Use i586 as default target for 32bit
Patch4: default-to-i586.patch
Patch5: clang-fix-mips-test.patch
Patch6: rewrite-includes.patch
BuildRoot: %{_tmppath}/%{name}-%{version}-build
BuildRequires: autoconf
BuildRequires: automake
@ -54,14 +55,10 @@ BuildRequires: gcc-c++
# For tests
BuildRequires: glibc-devel-32bit
%endif
BuildRequires: libffi-devel
BuildRequires: libtool
BuildRequires: python
# Code10 does not have libffi
%if 0%{?suse_version} > 1100
BuildRequires: libffi-devel
%endif
# LLVM is not supported on PPC64
# http://llvm.org/bugs/show_bug.cgi?id=3729
ExcludeArch: ppc64
@ -100,8 +97,9 @@ Documentation for the LLVM compiler infrastructure.
Summary: CLANG frontend for LLVM
Group: Development/Languages/Other
Requires: %{name} = %{version}
Requires: binutils
Requires: libstdc++-devel
Provides: clang
%{py_requires}
%description clang
This package contains the clang (C language) frontend for LLVM.
@ -112,7 +110,6 @@ Summary: CLANG frontend for LLVM (devel package)
Group: Development/Languages/Other
Requires: clang = %{version}
Requires: llvm-devel = %{version}
%{py_requires}
%description clang-devel
This package contains the clang (C language) frontend for LLVM.
@ -136,6 +133,7 @@ This package contains vim plugins for LLVM like syntax highlighting.
%ifarch x86_64
%patch5 -p1
%endif
%patch6 -p0
# We hardcode i586
rm tools/clang/test/Driver/x86_features.c
@ -143,15 +141,17 @@ rm tools/clang/test/Driver/x86_features.c
sed -i s,SVN_REVISION,\"%{_revision}\",g tools/clang/lib/Basic/Version.cpp
sed -i s,LLVM_REVISION,\"%{_revision}\",g tools/clang/lib/Basic/Version.cpp
# FIXME
rm -rf projects/compiler_rt
# Nasty hardcoded path
sed -i s,/lib/,/%{_lib}/,g tools/clang/lib/Driver/Tools.cpp
# Only enable target archs otherwise llvm-config is messed up
sed -i s,"subdirectories = .*","subdirectories = ARM X86", lib/Target/LLVMBuild.txt
sed -i s,"IntelJITEvents OProfileJIT","", lib/ExecutionEngine/LLVMBuild.txt
echo > utils/unittest/LLVMBuild.txt
%build
TOPLEVEL=$PWD
mkdir stage1 stage2 stage3
mkdir stage1 stage2
pushd stage1
../configure \
@ -165,33 +165,20 @@ make %{?_smp_mflags}
popd
pushd stage2
export CC=$TOPLEVEL/stage1/Release/bin/clang
export CXX=$TOPLEVEL/stage1/Release/bin/clang++
../configure \
--enable-optimized \
--disable-assertions \
--enable-targets=host
make %{?_smp_mflags}
popd
pushd stage3
# autotools ignore --libdir
mkdir Release
ln -s lib Release/lib64
export CC=$TOPLEVEL/stage2/Release/bin/clang
export CXX=$TOPLEVEL/stage2/Release/bin/clang++
export CC=$TOPLEVEL/stage1/Release/bin/clang
export CXX=$TOPLEVEL/stage1/Release/bin/clang++
../configure \
--prefix=%{_prefix} \
--prefix=%{_prefix} \
--enable-optimized \
--disable-assertions \
--enable-pic \
--disable-timestamps \
--enable-targets=%{_supported_archs} \
--enable-targets=%{_supported_archs} \
%if 0%{?suse_version} >= 1220
--with-binutils-include=/usr/include \
%endif
@ -200,13 +187,13 @@ export CXX=$TOPLEVEL/stage2/Release/bin/clang++
make %{?_smp_mflags} REQUIRES_RTTI=1
%check
cd stage3
cd stage2
make check
cd tools/clang
make test
%install
cd stage3
cd stage2
%makeinstall
cd ..
@ -281,22 +268,15 @@ install -m 755 -d %{buildroot}%{_datadir}/vim/site/syntax/
install -m 644 utils/vim/*.vim %{buildroot}%{_datadir}/vim/site/syntax/
mv utils/vim/README utils/vim/README.vim
# Remove gtest library
rm -f %{buildroot}%{_libdir}/*gtest*
# Wrong lib name + static
rm -f %{buildroot}%{_libdir}/liblibclang.a
# Stuff we don't want to include
rm -f %{buildroot}%{_libdir}/BugpointPasses.*
rm -f %{buildroot}%{_libdir}/LLVMHello.*
rm -f %{buildroot}%{_libdir}/libCompilerDriver.*
rm -f %{buildroot}%{_libdir}/libEnhancedDisassembly.*
rm %{buildroot}%{_libdir}/libclang.a
rm %{buildroot}%{_libdir}/BugpointPasses.*
rm %{buildroot}%{_libdir}/LLVMHello.*
%fdupes -s %{buildroot}%{_docdir}/%{name}
%fdupes -s %{buildroot}%{_docdir}/%{name}-doc
%post clang -p /sbin/ldconfig
%post clang -p /sbin/ldconfig
%postun clang -p /sbin/ldconfig
@ -345,11 +325,7 @@ rm -f %{buildroot}%{_libdir}/libEnhancedDisassembly.*
%if 0%{?suse_version} >= 1220
%{_libdir}/LLVMgold.so
%endif
%dir %{_libdir}/clang
%dir %{_libdir}/clang/*
%dir %{_libdir}/clang/*/include
%{_libdir}/clang/*/include/*.h
%{_libdir}/clang/*/include/module.map
%{_libdir}/clang
%files clang-devel
%defattr(-,root,root)

695
rewrite-includes.patch Normal file
View File

@ -0,0 +1,695 @@
diff --git a/include/clang/Driver/CC1Options.td b/include/clang/Driver/CC1Options.td
index 83c988a..b278082 100644
--- tools/clang/include/clang/Driver/CC1Options.td
+++ tools/clang/include/clang/Driver/CC1Options.td
@@ -452,6 +452,8 @@ def rewrite_objc : Flag<"-rewrite-objc">,
HelpText<"Rewrite ObjC into C (code rewriter example)">;
def rewrite_macros : Flag<"-rewrite-macros">,
HelpText<"Expand macros without full preprocessing">;
+def rewrite_includes : Flag<"-rewrite-includes">,
+ HelpText<"Expand includes without full preprocessing">;
def migrate : Flag<"-migrate">,
HelpText<"Migrate source code">;
}
diff --git a/include/clang/Frontend/FrontendOptions.h b/include/clang/Frontend/FrontendOptions.h
index 888388c..78d3adf 100644
--- tools/clang/include/clang/Frontend/FrontendOptions.h
+++ tools/clang/include/clang/Frontend/FrontendOptions.h
@@ -43,6 +43,7 @@ namespace frontend {
PrintPreamble, ///< Print the "preamble" of the input file
PrintPreprocessedInput, ///< -E mode.
RewriteMacros, ///< Expand macros but not #includes.
+ RewriteIncludes, ///< Expand #includes but not macros.
RewriteObjC, ///< ObjC->C Rewriter.
RewriteTest, ///< Rewriter playground
RunAnalysis, ///< Run one or more source code analyses.
diff --git a/include/clang/Lex/Preprocessor.h b/include/clang/Lex/Preprocessor.h
index 055008f..638b4aa 100644
--- tools/clang/include/clang/Lex/Preprocessor.h
+++ tools/clang/include/clang/Lex/Preprocessor.h
@@ -121,6 +121,13 @@ class Preprocessor : public RefCountedBase<Preprocessor> {
/// DisableMacroExpansion - True if macro expansion is disabled.
bool DisableMacroExpansion : 1;
+ /// MacroExpansionInDirectivesOverride - Temporarily disables
+ /// DisableMacroExpansion (i.e. enables expansion) when parsing preprocessor
+ /// directives.
+ bool MacroExpansionInDirectivesOverride : 1;
+
+ class ResetMacroExpansionHelper;
+
/// \brief Whether we have already loaded macros from the external source.
mutable bool ReadMacrosFromExternalSource : 1;
@@ -634,6 +641,12 @@ public:
while (Result.getKind() == tok::comment);
}
+ /// Disables macro expansion everywhere except for preprocessor directives.
+ void SetMacroExpansionOnlyInDirectives() {
+ DisableMacroExpansion = true;
+ MacroExpansionInDirectivesOverride = true;
+ }
+
/// LookAhead - This peeks ahead N tokens and returns that token without
/// consuming any tokens. LookAhead(0) returns the next token that would be
/// returned by Lex(), LookAhead(1) returns the token after it, etc. This
diff --git a/include/clang/Rewrite/FrontendActions.h b/include/clang/Rewrite/FrontendActions.h
index 6e9ecac..ea876d9 100644
--- tools/clang/include/clang/Rewrite/FrontendActions.h
+++ tools/clang/include/clang/Rewrite/FrontendActions.h
@@ -73,6 +73,11 @@ protected:
void ExecuteAction();
};
+class RewriteIncludesAction : public PreprocessorFrontendAction {
+protected:
+ void ExecuteAction();
+};
+
} // end namespace clang
#endif
diff --git a/include/clang/Rewrite/Rewriters.h b/include/clang/Rewrite/Rewriters.h
index 203b9bc..9704fe3 100644
--- tools/clang/include/clang/Rewrite/Rewriters.h
+++ tools/clang/include/clang/Rewrite/Rewriters.h
@@ -18,6 +18,7 @@
namespace clang {
class Preprocessor;
+class PreprocessorOutputOptions;
/// RewriteMacrosInInput - Implement -rewrite-macros mode.
void RewriteMacrosInInput(Preprocessor &PP, raw_ostream *OS);
@@ -25,6 +26,9 @@ void RewriteMacrosInInput(Preprocessor &PP, raw_ostream *OS);
/// DoRewriteTest - A simple test for the TokenRewriter class.
void DoRewriteTest(Preprocessor &PP, raw_ostream *OS);
+/// RewriteIncludesInInput - Implement -rewrite-includes mode.
+void RewriteIncludesInInput(Preprocessor &PP, raw_ostream *OS, const PreprocessorOutputOptions &Opts);
+
} // end namespace clang
#endif
diff --git a/lib/Frontend/CompilerInvocation.cpp b/lib/Frontend/CompilerInvocation.cpp
index 4c5b063..4e46973 100644
--- tools/clang/lib/Frontend/CompilerInvocation.cpp
+++ tools/clang/lib/Frontend/CompilerInvocation.cpp
@@ -430,6 +430,7 @@ static const char *getActionName(frontend::ActionKind Kind) {
case frontend::PrintPreamble: return "-print-preamble";
case frontend::PrintPreprocessedInput: return "-E";
case frontend::RewriteMacros: return "-rewrite-macros";
+ case frontend::RewriteIncludes: return "-rewrite-includes";
case frontend::RewriteObjC: return "-rewrite-objc";
case frontend::RewriteTest: return "-rewrite-test";
case frontend::RunAnalysis: return "-analyze";
@@ -1370,6 +1371,8 @@ static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args,
Opts.ProgramAction = frontend::PrintPreprocessedInput; break;
case OPT_rewrite_macros:
Opts.ProgramAction = frontend::RewriteMacros; break;
+ case OPT_rewrite_includes:
+ Opts.ProgramAction = frontend::RewriteIncludes; break;
case OPT_rewrite_objc:
Opts.ProgramAction = frontend::RewriteObjC; break;
case OPT_rewrite_test:
diff --git a/lib/FrontendTool/ExecuteCompilerInvocation.cpp b/lib/FrontendTool/ExecuteCompilerInvocation.cpp
index 07d2b8d..49d0bb8 100644
--- tools/clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp
+++ tools/clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp
@@ -73,6 +73,7 @@ static FrontendAction *CreateFrontendBaseAction(CompilerInstance &CI) {
case PrintPreamble: return new PrintPreambleAction();
case PrintPreprocessedInput: return new PrintPreprocessedAction();
case RewriteMacros: return new RewriteMacrosAction();
+ case RewriteIncludes: return new RewriteIncludesAction();
case RewriteObjC: return new RewriteObjCAction();
case RewriteTest: return new RewriteTestAction();
case RunAnalysis: return new ento::AnalysisAction();
diff --git a/lib/Lex/Lexer.cpp b/lib/Lex/Lexer.cpp
index 535a852..aa424b4 100644
--- tools/clang/lib/Lex/Lexer.cpp
+++ tools/clang/lib/Lex/Lexer.cpp
@@ -2022,7 +2022,7 @@ bool Lexer::SaveBCPLComment(Token &Result, const char *CurPtr) {
// directly.
FormTokenWithChars(Result, CurPtr, tok::comment);
- if (!ParsingPreprocessorDirective)
+ if (!ParsingPreprocessorDirective || LexingRawMode)
return true;
// If this BCPL-style comment is in a macro definition, transmogrify it into
@@ -2625,7 +2625,8 @@ LexNextToken:
ParsingPreprocessorDirective = false;
// Restore comment saving mode, in case it was disabled for directive.
- SetCommentRetentionState(PP->getCommentRetentionState());
+ if (!LexingRawMode)
+ SetCommentRetentionState(PP->getCommentRetentionState());
// Since we consumed a newline, we are back at the start of a line.
IsAtStartOfLine = true;
diff --git a/lib/Lex/PPDirectives.cpp b/lib/Lex/PPDirectives.cpp
index 625a204..29a8614 100644
--- tools/clang/lib/Lex/PPDirectives.cpp
+++ tools/clang/lib/Lex/PPDirectives.cpp
@@ -553,6 +553,22 @@ const FileEntry *Preprocessor::LookupFile(
// Preprocessor Directive Handling.
//===----------------------------------------------------------------------===//
+class Preprocessor::ResetMacroExpansionHelper
+{
+public:
+ ResetMacroExpansionHelper(Preprocessor*pp)
+ : PP(pp), save(pp->DisableMacroExpansion) {
+ if (pp->MacroExpansionInDirectivesOverride)
+ pp->DisableMacroExpansion = false;
+ }
+ ~ResetMacroExpansionHelper() {
+ PP->DisableMacroExpansion = save;
+ }
+private:
+ Preprocessor* PP;
+ bool save;
+};
+
/// HandleDirective - This callback is invoked when the lexer sees a # token
/// at the start of a line. This consumes the directive, modifies the
/// lexer/preprocessor state, and advances the lexer(s) so that the next token
@@ -604,6 +620,10 @@ void Preprocessor::HandleDirective(Token &Result) {
Diag(Result, diag::ext_embedded_directive);
}
+ // temporarily enable macro expansion if set so
+ // and reset to previous state when returning from this function
+ ResetMacroExpansionHelper helper(this);
+
TryAgain:
switch (Result.getKind()) {
case tok::eod:
diff --git a/lib/Lex/Preprocessor.cpp b/lib/Lex/Preprocessor.cpp
index 06e5685..f5d7a51 100644
--- tools/clang/lib/Lex/Preprocessor.cpp
+++ tools/clang/lib/Lex/Preprocessor.cpp
@@ -134,6 +134,7 @@ void Preprocessor::Initialize(const TargetInfo &Target) {
// Macro expansion is enabled.
DisableMacroExpansion = false;
+ MacroExpansionInDirectivesOverride = false;
InMacroArgs = false;
InMacroArgPreExpansion = false;
NumCachedTokenLexers = 0;
diff --git a/lib/Rewrite/CMakeLists.txt b/lib/Rewrite/CMakeLists.txt
index 2a05040..8070ba2 100644
--- tools/clang/lib/Rewrite/CMakeLists.txt
+++ tools/clang/lib/Rewrite/CMakeLists.txt
@@ -6,6 +6,7 @@ add_clang_library(clangRewrite
FrontendActions.cpp
HTMLPrint.cpp
HTMLRewrite.cpp
+ RewriteIncludes.cpp
RewriteMacros.cpp
RewriteModernObjC.cpp
RewriteObjC.cpp
diff --git a/lib/Rewrite/FrontendActions.cpp b/lib/Rewrite/FrontendActions.cpp
index 1753325..e462671 100644
--- tools/clang/lib/Rewrite/FrontendActions.cpp
+++ tools/clang/lib/Rewrite/FrontendActions.cpp
@@ -181,3 +181,11 @@ void RewriteTestAction::ExecuteAction() {
DoRewriteTest(CI.getPreprocessor(), OS);
}
+
+void RewriteIncludesAction::ExecuteAction() {
+ CompilerInstance &CI = getCompilerInstance();
+ raw_ostream *OS = CI.createDefaultOutputFile(true, getCurrentFile());
+ if (!OS) return;
+
+ RewriteIncludesInInput(CI.getPreprocessor(), OS, CI.getPreprocessorOutputOpts());
+}
diff --git a/lib/Rewrite/RewriteIncludes.cpp b/lib/Rewrite/RewriteIncludes.cpp
new file mode 100644
index 0000000..679e556
--- /dev/null
+++ tools/clang/lib/Rewrite/RewriteIncludes.cpp
@@ -0,0 +1,333 @@
+//===--- RewriteIncludes.cpp - Rewrite includes into their expansions -----===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This code rewrites include invocations into their expansions. This gives you
+// a file with all included files merged into it.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Rewrite/Rewriters.h"
+#include "clang/Lex/Preprocessor.h"
+#include "clang/Basic/SourceManager.h"
+#include "clang/Frontend/PreprocessorOutputOptions.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace clang;
+using namespace llvm;
+
+namespace {
+
+class IncludeRewriter : public PPCallbacks {
+ /// Information about which #includes were actually performed,
+ /// created by preprocessor callbacks.
+ struct FileChange {
+ SourceLocation From;
+ FileID Id;
+ SrcMgr::CharacteristicKind Type;
+ };
+ Preprocessor &PP;
+ SourceManager &SM;
+ raw_ostream &OS;
+ bool DisableLineMarkers;
+ bool UseLineDirective;
+ typedef std::map<unsigned, FileChange> FileChangeMap;
+ FileChangeMap FileChanges;
+ unsigned LastInsertedFileChange;
+public:
+ IncludeRewriter(Preprocessor &PP, raw_ostream &OS, bool LineMarkers);
+ bool Process(FileID FileId, SrcMgr::CharacteristicKind Type);
+private:
+ virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,
+ SrcMgr::CharacteristicKind FileType,
+ FileID PrevFID);
+ virtual void InclusionDirective(SourceLocation HashLoc,
+ const Token &IncludeTok,
+ StringRef FileName,
+ bool IsAngled,
+ const FileEntry *File,
+ SourceLocation EndLoc,
+ StringRef SearchPath,
+ StringRef RelativePath);
+ void WriteLineInfo(const char* Filename, int Line,
+ SrcMgr::CharacteristicKind Type,
+ const char* EOL, StringRef Extra = StringRef());
+ void OutputContentUpTo(unsigned WriteEnd, unsigned& NextToWrite,
+ int& Lines, const char* EOL,
+ const MemoryBuffer* FromFile,
+ bool EnsureNewline = false);
+ void CommentOutDirective(Lexer& DirectivesLex, const Token& StartToken,
+ unsigned& NextToWrite, int& Lines,
+ const char* EOL, const MemoryBuffer* FromFile);
+ const FileChange* FindFileChangeLocation(SourceLocation Loc) const;
+ StringRef NextIdentifierName(Lexer& RawLex, Token& RawToken);
+};
+
+} // end anonymous namespace
+
+IncludeRewriter::IncludeRewriter(Preprocessor &pp, raw_ostream &os,
+ bool lineMarkers)
+ : PP(pp), SM(PP.getSourceManager()), OS(os),
+ DisableLineMarkers(lineMarkers), LastInsertedFileChange(0) {
+ // If we're in microsoft mode, use normal #line instead of line markers.
+ UseLineDirective = PP.getLangOpts().MicrosoftExt;
+}
+
+void IncludeRewriter::WriteLineInfo(const char* Filename, int Line,
+ SrcMgr::CharacteristicKind Type,
+ const char* EOL, StringRef Extra) {
+ // Emit #line directives or GNU line markers depending on what mode we're in.
+ if (UseLineDirective) {
+ OS << "#line" << ' ' << Line << ' ' << '"' << Filename << '"';
+ } else {
+ OS << '#' << ' ' << Line << ' ' << '"' << Filename << '"';
+ if (!Extra.empty())
+ OS << Extra;
+ if (Type == SrcMgr::C_System)
+ OS << " 3";
+ else if (Type == SrcMgr::C_ExternCSystem)
+ OS << " 3 4";
+ }
+ OS << EOL;
+}
+
+/// FileChanged - Whenever the preprocessor enters or exits a #include file
+/// it invokes this handler.
+void IncludeRewriter::FileChanged(SourceLocation Loc,
+ FileChangeReason Reason,
+ SrcMgr::CharacteristicKind NewFileType,
+ FileID) {
+ if (Reason == EnterFile) {
+ // InclusionDirective() has already been called, add more info
+ FileID Id = FullSourceLoc(Loc,SM).getFileID();
+ if (LastInsertedFileChange != 0) { // there may be e.g. "<built-in>" first
+ FileChange& Ref = FileChanges[LastInsertedFileChange];
+ Ref.Id = Id;
+ Ref.Type = NewFileType;
+ }
+ }
+}
+
+/// This should be called whenever the preprocessor encounters include
+/// directives. It does not say whether the file has been included, but it
+/// provides more information about the directive (hash location istead
+/// of location inside the included file. It is assumed that the matching
+/// FileChanged() is called after this (if at all).
+void IncludeRewriter::InclusionDirective(SourceLocation HashLoc,
+ const Token &/*IncludeTok*/,
+ StringRef /*FileName*/,
+ bool /*IsAngled*/,
+ const FileEntry* /*File*/,
+ SourceLocation /*EndLoc*/,
+ StringRef /*SearchPath*/,
+ StringRef /*RelativePath*/) {
+ FileChange Change;
+ Change.From = HashLoc;
+ LastInsertedFileChange = HashLoc.getRawEncoding();
+ FileChanges[LastInsertedFileChange] = Change;
+}
+
+const IncludeRewriter::FileChange*
+IncludeRewriter::FindFileChangeLocation(SourceLocation Loc) const {
+ FileChangeMap ::const_iterator Find = FileChanges.find(Loc.getRawEncoding());
+ if(Find != FileChanges.end())
+ return &Find->second;
+ return NULL;
+}
+
+inline unsigned CountNewLines(const char* Pos, int Len) {
+ const char* End = Pos + Len;
+ unsigned Lines = 0;
+ --Pos;
+ while ((Pos = static_cast<const char*>(memchr(Pos + 1, '\n', End - Pos - 1))))
+ ++Lines;
+ return Lines;
+}
+
+static const char* DetectEOL(const MemoryBuffer* FromFile) {
+ // detect what line endings the file uses, so that added content does not mix
+ // the style
+ const char* Pos = strchr(FromFile->getBufferStart(), '\n');
+ if (Pos == NULL)
+ return "\n";
+ if (Pos+1 < FromFile->getBufferEnd() && *(Pos+1) == '\r')
+ return "\n\r";
+ if (Pos-1 >= FromFile->getBufferStart() && *(Pos+1) == '\r')
+ return "\r\n";
+ return "\n";
+}
+
+/// Copies next not yet written file content up (and not including) to writeEnd.
+void IncludeRewriter::OutputContentUpTo(unsigned WriteEnd,
+ unsigned& NextToWrite,
+ int& Lines, const char* EOL,
+ const MemoryBuffer* FromFile,
+ bool EnsureNewline) {
+ if (WriteEnd > NextToWrite) {
+ OS.write(FromFile->getBufferStart() + NextToWrite, WriteEnd - NextToWrite);
+ // count lines manually, it's faster than getPresumedLoc()
+ Lines += CountNewLines(FromFile->getBufferStart() + NextToWrite,
+ WriteEnd - NextToWrite);
+ if (EnsureNewline) {
+ char LastChar = FromFile->getBufferStart()[WriteEnd - 1];
+ if (LastChar != '\n' && LastChar != '\r')
+ OS << EOL;
+ }
+ NextToWrite = WriteEnd;
+ }
+}
+
+void IncludeRewriter::CommentOutDirective(Lexer& DirectiveLex,
+ const Token& StartToken,
+ unsigned& NextToWrite, int& Lines,
+ const char* EOL,
+ const MemoryBuffer* FromFile) {
+ OutputContentUpTo(SM.getFileOffset(StartToken.getLocation()), NextToWrite,
+ Lines, EOL, FromFile);
+ Token DirectiveToken;
+ do {
+ DirectiveLex.LexFromRawLexer(DirectiveToken);
+ } while (!DirectiveToken.is(tok::eod) && DirectiveToken.isNot(tok::eof));
+ OS << "#if 0 /* expanded by -rewrite-includes */" << EOL;
+ OutputContentUpTo(SM.getFileOffset(DirectiveToken.getLocation())
+ + DirectiveToken.getLength(), NextToWrite, Lines, EOL, FromFile);
+ OS << "#endif /* expanded by -rewrite-includes */" << EOL;
+}
+
+StringRef IncludeRewriter::NextIdentifierName(Lexer& RawLex, Token& RawToken) {
+ RawLex.LexFromRawLexer(RawToken);
+ if (RawToken.is(tok::raw_identifier))
+ PP.LookUpIdentifierInfo(RawToken);
+ if (RawToken.is(tok::identifier))
+ return RawToken.getIdentifierInfo()->getName();
+ return StringRef();
+}
+
+bool IncludeRewriter::Process(FileID FileId, SrcMgr::CharacteristicKind Type)
+{
+ bool Invalid;
+ const char* FileName = SM.getBufferName(SM.getLocForStartOfFile(FileId),
+ &Invalid);
+ if (Invalid)
+ return false;
+
+ // Use a raw lexer to analyze the input file, incrementally copying parts of
+ // it and including content of included files recursively.
+ const MemoryBuffer *FromFile = SM.getBuffer(FileId);
+ Lexer RawLex(FileId, FromFile, PP.getSourceManager(), PP.getLangOpts());
+ RawLex.SetCommentRetentionState(false);
+
+ const char* EOL = DetectEOL(FromFile);
+
+ WriteLineInfo(FileName, 1, Type, EOL, " 1");
+
+ if (SM.getFileIDSize(FileId) == 0)
+ return true;
+
+ // file position from which the content has not yet been copied to the output
+ unsigned NextToWrite = 0;
+ int Lines = 1; // current input file line number
+
+ Token RawToken;
+ RawLex.LexFromRawLexer(RawToken);
+
+ // TODO: It might be beneficial to have a switch that removes content of lines
+ // that are irrevelant for compile, i.e. comments. Comments are usually
+ // a significant part of the resulting file and cleaning up such lines would
+ // significantly reduce the size of the resulting file without having any
+ // effect on any following usage (with the exception of human inspection).
+ while (RawToken.isNot(tok::eof)) {
+ if (RawToken.is(tok::hash) && RawToken.isAtStartOfLine()) {
+ RawLex.setParsingPreprocessorDirective(true);
+ Token HashToken = RawToken;
+ RawLex.LexFromRawLexer(RawToken);
+ if (RawToken.is(tok::raw_identifier))
+ PP.LookUpIdentifierInfo(RawToken);
+ if (RawToken.is(tok::identifier)) {
+ switch (RawToken.getIdentifierInfo()->getPPKeywordID()) {
+ case tok::pp_include:
+ case tok::pp_include_next:
+ case tok::pp_import: {
+ // keep the directive in, commented out
+ // (clang sometimes optimizes and does not repeatedly include some
+ // files even though it should, so all includes need to be
+ // commented, otherwise valid directives would be left in)
+ CommentOutDirective(RawLex, HashToken, NextToWrite, Lines, EOL,
+ FromFile);
+ // fix up lineinfo, commenting out has added lines
+ bool NeedFixup = true;
+ if (const FileChange* Change = FindFileChangeLocation(
+ HashToken.getLocation())) {
+ // now include and recursively process the file
+ if(Process(Change->Id, Change->Type)) {
+ // and set lineinfo back to this file, if the nested one was
+ // actually included
+ WriteLineInfo(FileName, Lines, Type, EOL, " 2");
+ NeedFixup = false;
+ }
+ }
+ if(NeedFixup)
+ WriteLineInfo(FileName, Lines, Type, EOL);
+ break;
+ }
+ case tok::pp_pragma: {
+ StringRef Identifier = NextIdentifierName(RawLex, RawToken);
+ if (Identifier == "clang" || Identifier == "GCC") {
+ if (NextIdentifierName(RawLex, RawToken) == "system_header") {
+ // keep the directive in, commented out
+ CommentOutDirective(RawLex, HashToken, NextToWrite, Lines,
+ EOL, FromFile);
+ // update our own type
+ Type = SM.getFileCharacteristic(RawToken.getLocation());
+ WriteLineInfo(FileName, Lines, Type, EOL);
+ }
+ } else if (Identifier == "once") {
+ // keep the directive in, commented out
+ CommentOutDirective(RawLex, HashToken, NextToWrite, Lines,
+ EOL, FromFile);
+ WriteLineInfo(FileName, Lines, Type, EOL);
+ }
+ break;
+ }
+ default:
+ break;
+ }
+ }
+ RawLex.setParsingPreprocessorDirective(false);
+ RawLex.SetCommentRetentionState(false);
+ }
+ RawLex.LexFromRawLexer(RawToken);
+ }
+ OutputContentUpTo(SM.getFileOffset(SM.getLocForEndOfFile(FileId)) + 1,
+ NextToWrite, Lines, EOL, FromFile, true);
+ return true;
+}
+
+/// RewriteIncludesInInput - Implement -rewrite-includes mode.
+void clang::RewriteIncludesInInput(Preprocessor &PP, raw_ostream *OS,
+ const PreprocessorOutputOptions &Opts) {
+ SourceManager &SM = PP.getSourceManager();
+ IncludeRewriter* Rewrite = new IncludeRewriter(PP, *OS,!Opts.ShowLineMarkers);
+ PP.addPPCallbacks(Rewrite);
+
+ // First let the preprocessor process the entire file and call callbacks.
+ // Callbacks will record which #include's were actually performed.
+ PP.EnterMainSourceFile();
+ Token Tok;
+ // Only preprocessor directives matter here, so disable macro expansion
+ // everywhere else as an optimization.
+ // TODO: It would be even faster if the preprocessor could be switched
+ // to a mode where it would parse only preprocessor directives and comments,
+ // nothing else matters for parsing or processing.
+ PP.SetMacroExpansionOnlyInDirectives();
+ do {
+ PP.Lex(Tok);
+ } while (Tok.isNot(tok::eof));
+ Rewrite->Process(SM.getMainFileID(), SrcMgr::C_User);
+ OS->flush();
+}
diff --git a/test/Frontend/Inputs/rewrite-includes1.h b/test/Frontend/Inputs/rewrite-includes1.h
new file mode 100644
index 0000000..1b6c80d
--- /dev/null
+++ tools/clang/test/Frontend/Inputs/rewrite-includes1.h
@@ -0,0 +1,3 @@
+#pragma clang system_header
+included_line1
+#include "rewrite-includes2.h"
diff --git a/test/Frontend/Inputs/rewrite-includes2.h b/test/Frontend/Inputs/rewrite-includes2.h
new file mode 100644
index 0000000..1114e51
--- /dev/null
+++ tools/clang/test/Frontend/Inputs/rewrite-includes2.h
@@ -0,0 +1 @@
+included_line2
diff --git a/test/Frontend/Inputs/rewrite-includes3.h b/test/Frontend/Inputs/rewrite-includes3.h
new file mode 100644
index 0000000..3757bc8
--- /dev/null
+++ tools/clang/test/Frontend/Inputs/rewrite-includes3.h
@@ -0,0 +1 @@
+included_line3
diff --git a/test/Frontend/Inputs/rewrite-includes4.h b/test/Frontend/Inputs/rewrite-includes4.h
new file mode 100644
index 0000000..b4e25d2
--- /dev/null
+++ tools/clang/test/Frontend/Inputs/rewrite-includes4.h
@@ -0,0 +1 @@
+included_line4
diff --git a/test/Frontend/Inputs/rewrite-includes5.h b/test/Frontend/Inputs/rewrite-includes5.h
new file mode 100644
index 0000000..934bf41
--- /dev/null
+++ tools/clang/test/Frontend/Inputs/rewrite-includes5.h
@@ -0,0 +1 @@
+included_line5
diff --git a/test/Frontend/Inputs/rewrite-includes6.h b/test/Frontend/Inputs/rewrite-includes6.h
new file mode 100644
index 0000000..c18e501
--- /dev/null
+++ tools/clang/test/Frontend/Inputs/rewrite-includes6.h
@@ -0,0 +1,2 @@
+#pragma once
+included_line6
diff --git a/test/Frontend/rewrite-includes.c b/test/Frontend/rewrite-includes.c
new file mode 100644
index 0000000..fbe901f
--- /dev/null
+++ tools/clang/test/Frontend/rewrite-includes.c
@@ -0,0 +1,77 @@
+// RUN: %clang_cc1 -verify -rewrite-includes -DFIRST -I %S/Inputs %s -o %t
+// RUN: cat %t | FileCheck -strict-whitespace %s
+// STARTCOMPARE
+#define A(a,b) a ## b
+A(1,2)
+#include "rewrite-includes1.h"
+#ifdef FIRST
+#define HEADER "rewrite-includes3.h"
+#include HEADER
+#else
+#include "rewrite-includes4.h"
+#endif
+#/**/include /**/ "rewrite-includes5.h" /**/ \
+
+#include "rewrite-includes6.h" // comment
+
+#include "rewrite-includes6.h" /* comment
+ continues */
+// ENDCOMPARE
+
+// CHECK: {{^}}// STARTCOMPARE{{$}}
+// CHECK-NEXT: {{^}}#define A(a,b) a ## b{{$}}
+// CHECK-NEXT: {{^}}A(1,2){{$}}
+// CHECK-NEXT: {{^}}#if 0 /* expanded by -rewrite-includes */{{$}}
+// CHECK-NEXT: {{^}}#include "rewrite-includes1.h"{{$}}
+// CHECK-NEXT: {{^}}#endif /* expanded by -rewrite-includes */{{$}}
+// CHECK-NEXT: {{^}}# 1 "{{.*}}/Inputs/rewrite-includes1.h" 1{{$}}
+// CHECK-NEXT: {{^}}#if 0 /* expanded by -rewrite-includes */{{$}}
+// CHECK-NEXT: {{^}}#pragma clang system_header{{$}}
+// CHECK-NEXT: {{^}}#endif /* expanded by -rewrite-includes */{{$}}
+// CHECK-NEXT: {{^}}# 2 "{{.*}}/Inputs/rewrite-includes1.h" 3{{$}}
+// CHECK-NEXT: {{^}}included_line1{{$}}
+// CHECK-NEXT: {{^}}#if 0 /* expanded by -rewrite-includes */{{$}}
+// CHECK-NEXT: {{^}}#include "rewrite-includes2.h"{{$}}
+// CHECK-NEXT: {{^}}#endif /* expanded by -rewrite-includes */{{$}}
+// CHECK-NEXT: {{^}}# 1 "{{.*}}/Inputs/rewrite-includes2.h" 1 3{{$}}
+// CHECK-NEXT: {{^}}included_line2{{$}}
+// CHECK-NEXT: {{^}}# 4 "{{.*}}/Inputs/rewrite-includes1.h" 2 3{{$}}
+// CHECK-NEXT: {{^}}# 7 "{{.*}}rewrite-includes.c" 2{{$}}
+// CHECK-NEXT: {{^}}#ifdef FIRST{{$}}
+// CHECK-NEXT: {{^}}#define HEADER "rewrite-includes3.h"{{$}}
+// CHECK-NEXT: {{^}}#if 0 /* expanded by -rewrite-includes */{{$}}
+// CHECK-NEXT: {{^}}#include HEADER{{$}}
+// CHECK-NEXT: {{^}}#endif /* expanded by -rewrite-includes */{{$}}
+// CHECK-NEXT: {{^}}# 1 "{{.*}}/Inputs/rewrite-includes3.h" 1{{$}}
+// CHECK-NEXT: {{^}}included_line3{{$}}
+// CHECK-NEXT: {{^}}# 10 "{{.*}}rewrite-includes.c" 2{{$}}
+// CHECK-NEXT: {{^}}#else{{$}}
+// CHECK-NEXT: {{^}}#if 0 /* expanded by -rewrite-includes */{{$}}
+// CHECK-NEXT: {{^}}#include "rewrite-includes4.h"{{$}}
+// CHECK-NEXT: {{^}}#endif /* expanded by -rewrite-includes */{{$}}
+// CHECK-NEXT: {{^}}# 12 "{{.*}}rewrite-includes.c"{{$}}
+// CHECK-NEXT: {{^}}#endif{{$}}
+// CHECK-NEXT: {{^}}#if 0 /* expanded by -rewrite-includes */{{$}}
+// CHECK-NEXT: {{^}}#/**/include /**/ "rewrite-includes5.h" /**/ {{\\}}{{$}}
+// CHECK-NEXT: {{^}} {{$}}
+// CHECK-NEXT: {{^}}#endif /* expanded by -rewrite-includes */{{$}}
+// CHECK-NEXT: {{^}}# 1 "{{.*}}/Inputs/rewrite-includes5.h" 1{{$}}
+// CHECK-NEXT: {{^}}included_line5{{$}}
+// CHECK-NEXT: {{^}}# 15 "{{.*}}rewrite-includes.c" 2{{$}}
+// CHECK-NEXT: {{^}}#if 0 /* expanded by -rewrite-includes */{{$}}
+// CHECK-NEXT: {{^}}#include "rewrite-includes6.h" // comment{{$}}
+// CHECK-NEXT: {{^}}#endif /* expanded by -rewrite-includes */{{$}}
+// CHECK-NEXT: {{^}}# 1 "{{.*}}/Inputs/rewrite-includes6.h" 1{{$}}
+// CHECK-NEXT: {{^}}#if 0 /* expanded by -rewrite-includes */{{$}}
+// CHECK-NEXT: {{^}}#pragma once{{$}}
+// CHECK-NEXT: {{^}}#endif /* expanded by -rewrite-includes */{{$}}
+// CHECK-NEXT: {{^}}# 2 "{{.*}}/Inputs/rewrite-includes6.h"{{$}}
+// CHECK-NEXT: {{^}}included_line6{{$}}
+// CHECK-NEXT: {{^}}# 16 "{{.*}}rewrite-includes.c" 2{{$}}
+// CHECK-NEXT: {{^}} {{$}}
+// CHECK-NEXT: {{^}}#if 0 /* expanded by -rewrite-includes */{{$}}
+// CHECK-NEXT: {{^}}#include "rewrite-includes6.h" /* comment{{$}}
+// CHECK-NEXT: {{^}} continues */{{$}}
+// CHECK-NEXT: {{^}}#endif /* expanded by -rewrite-includes */{{$}}
+// CHECK-NEXT: {{^}}# 19 "{{.*}}rewrite-includes.c"{{$}}
+// CHECK-NEXT: {{^}}// ENDCOMPARE{{$}}