Update from https://crrev.com/312398

tools/clang/translation_unit/TranslationUnitGenerator.cpp

 // Copyright (c) 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // This implements a Clang tool to generate compilation information that is
 // sufficient to recompile the code with clang. For each compilation unit, all
 // source files which are necessary for compiling it are determined. For each
 // compilation unit, a file is created containing a list of all file paths of
 // included files.
 
 #include <assert.h>
 #include <unistd.h>
 #include <fstream>
 #include <iostream>
 #include <memory>
 #include <set>
 #include <stack>
 #include <string>
 #include <vector>
 
+#include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Tooling/Tooling.h"
@@ skipping 98 matching lines @@
 
     // If the file is a top level file ("file.cc"), we normalize to a path
     // relative to "./".
     if (parent.empty() || parent == "/")
       parent = ".";
 
     // Otherwise we take the literal path as we stored it for the current
     // file, and append the relative path.
     last_inclusion_directive_ = parent + "/" + relative_path.str();
   } else if (!search_path.empty()) {
-    last_inclusion_directive_ = string(search_path) + "/" + relative_path.str();
+    // We want to be able to extract the search path relative to which the
+    // include statement is defined. Therefore if search_path is an absolute
+    // path (indicating it is most likely a system header) we use "//" as a
+    // separator between the search path and the relative path.
+    last_inclusion_directive_ = search_path.str() +
+        (llvm::sys::path::is_absolute(search_path) ? "//" : "/") +
+        relative_path.str();
   } else {
     last_inclusion_directive_ = file_name.str();
   }
   AddFile(last_inclusion_directive_);
 }
 
 void IncludeFinderPPCallbacks::EndOfMainFile() {
   const clang::FileEntry* main_file =
       source_manager_->getFileEntryForID(source_manager_->getMainFileID());
   assert(*main_source_file_ == main_file->getName());
@@ skipping 27 matching lines @@
 
   Preprocess();
 }
 
 void CompilationIndexerAction::Preprocess() {
   clang::Preprocessor& preprocessor = getCompilerInstance().getPreprocessor();
   preprocessor.addPPCallbacks(llvm::make_unique<IncludeFinderPPCallbacks>(
       &getCompilerInstance().getSourceManager(),
       &main_source_file_,
       &source_file_paths_));
-  preprocessor.IgnorePragmas();
+  preprocessor.getDiagnostics().setIgnoreAllWarnings(true);
   preprocessor.SetSuppressIncludeNotFoundError(true);
   preprocessor.EnterMainSourceFile();
   clang::Token token;
   do {
     preprocessor.Lex(token);
   } while (token.isNot(clang::tok::eof));
 }
 
 void CompilationIndexerAction::EndSourceFileAction() {
   std::ofstream out(main_source_file_ + ".filepaths");
@@ skipping 11 matching lines @@
   std::unique_ptr<clang::tooling::FrontendActionFactory> frontend_factory =
       clang::tooling::newFrontendActionFactory<CompilationIndexerAction>();
   clang::tooling::ClangTool tool(options.getCompilations(),
                                  options.getSourcePathList());
   // This clang tool does not actually produce edits, but run_tool.py expects
   // this. So we just print an empty edit block.
   llvm::outs() << "==== BEGIN EDITS ====\n";
   llvm::outs() << "==== END EDITS ====\n";
   return tool.run(frontend_factory.get());
 }