Use filename in linemarker when compiling preprocessed source (Revised)

[twoh]

Summary

This is a revised version of D28796. Included test is changed to
resolve the target compatibility issue reported (rL293032).

[inglorion]

test/Frontend/preprocessed-input.c

3 ↗

(On Diff #90722)

Actually, I think you don't even have to run the preprocessor - you can just put the file with the linemarker here and check that the name from the linemarker is propagated, right?

Also, it seems that there is a similar issue to the one you're trying to fix when going from .ll to .o (or .ll to .s, for that matter) - the name is taken from the file you're reading from, not from the source_filename directive in that file. Of course, that doesn't differ from gcc (given that gcc doesn't handle .ll files), but you may want to address that, too, for consistency.

[twoh]

test/Frontend/preprocessed-input.c

3 ↗

(On Diff #90722)

@inglorion Thanks for the comments! Putting preprocessed file makes sense to me.

I recognize the second issue. If I do something like

clang -E -o test.i /abspath/test.c
clang -g -c -o test.o test.i

DW_AT_name is still test.i (for gcc, it is taken from the linemarker as well).

Moreover, if we use the absolute path of test.i for clang, i.e.

clang -g -c -o test.o /abspath/test.i

DW_AT_name becomes /abspath/test.i where DW_AT_comp_dir is /abspath. I think this could be a problem if the user of the object file assumes that DW_AT_name is a relative to DW_AT_comp_dir. I'm planning to address this with a separate patch.

[twoh]

addressing comments from @inglorion

[inglorion]

Fixing the other issues in a follow-up seems fine. This lgtm.

cfe/trunk/include/clang/Frontend/FrontendOptions.h

enum InputKind {
   IK_OpenCL,
   IK_CUDA,
   IK_PreprocessedCuda,
   IK_RenderScript,
   IK_AST,
   IK_LLVM_IR
 };
 
-  
 /// \brief An input file for the front end.
 class FrontendInputFile {
   /// \brief The file name, or "-" to read from standard input.
   std::string File;
 
   llvm::MemoryBuffer *Buffer;
 
   /// \brief The kind of input, e.g., C source, AST file, LLVM IR.
FrontendInputFile(llvm::MemoryBuffer *buffer, InputKind Kind,
     : Buffer(buffer), Kind(Kind), IsSystem(IsSystem) { }
 
   InputKind getKind() const { return Kind; }
   bool isSystem() const { return IsSystem; }
 
   bool isEmpty() const { return File.empty() && Buffer == nullptr; }
   bool isFile() const { return !isBuffer(); }
   bool isBuffer() const { return Buffer != nullptr; }
+  bool isPreprocessed() const {
+    return Kind == IK_PreprocessedC ||
+           Kind == IK_PreprocessedCXX ||
+           Kind == IK_PreprocessedObjC ||
+           Kind == IK_PreprocessedObjCXX ||
+           Kind == IK_PreprocessedCuda;
+  }
 
   StringRef getFile() const {
     assert(isFile());
     return File;
   }
   llvm::MemoryBuffer *getBuffer() const {
     assert(isBuffer());
     return Buffer;

cfe/trunk/lib/Frontend/FrontendAction.cpp

 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Frontend/FrontendPluginRegistry.h"
 #include "clang/Frontend/LayoutOverrideSource.h"
 #include "clang/Frontend/MultiplexConsumer.h"
 #include "clang/Frontend/Utils.h"
 #include "clang/Lex/HeaderSearch.h"
+#include "clang/Lex/LiteralSupport.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Parse/ParseAST.h"
 #include "clang/Serialization/ASTDeserializationListener.h"
 #include "clang/Serialization/ASTReader.h"
 #include "clang/Serialization/GlobalModuleIndex.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
FrontendAction::CreateWrappedASTConsumer(CompilerInstance &CI,
   Consumers.push_back(std::move(Consumer));
   for (auto &C : AfterConsumers) {
     Consumers.push_back(std::move(C));
   }
 
   return llvm::make_unique<MultiplexConsumer>(std::move(Consumers));
 }
 
+// For preprocessed files, if the first line is the linemarker and specifies
+// the original source file name, use that name as the input file name.
+static bool ReadOriginalFileName(CompilerInstance &CI, std::string &InputFile)
+{
+  bool Invalid = false;
+  auto &SourceMgr = CI.getSourceManager();
+  auto MainFileID = SourceMgr.getMainFileID();
+  const auto *MainFileBuf = SourceMgr.getBuffer(MainFileID, &Invalid);
+  if (Invalid)
+    return false;
+
+  std::unique_ptr<Lexer> RawLexer(
+      new Lexer(MainFileID, MainFileBuf, SourceMgr, CI.getLangOpts()));
+
+  // If the first line has the syntax of
+  //
+  // # NUM "FILENAME"
+  //
+  // we use FILENAME as the input file name.
+  Token T;
+  if (RawLexer->LexFromRawLexer(T) || T.getKind() != tok::hash)
+    return false;
+  if (RawLexer->LexFromRawLexer(T) || T.isAtStartOfLine() ||
+      T.getKind() != tok::numeric_constant)
+    return false;
+  RawLexer->LexFromRawLexer(T);
+  if (T.isAtStartOfLine() || T.getKind() != tok::string_literal)
+    return false;
+
+  StringLiteralParser Literal(T, CI.getPreprocessor());
+  if (Literal.hadError)
+    return false;
+  InputFile = Literal.GetString().str();
+  return true;
+}
+
 bool FrontendAction::BeginSourceFile(CompilerInstance &CI,
                                      const FrontendInputFile &Input) {
   assert(!Instance && "Already processing a source file!");
   assert(!Input.isEmpty() && "Unexpected empty filename!");
   setCurrentInput(Input);
   setCompilerInstance(&CI);
 
   StringRef InputFile = Input.getFile();
bool FrontendAction::BeginSourceFile(CompilerInstance &CI,
 
   // Create the AST context and consumer unless this is a preprocessor only
   // action.
   if (!usesPreprocessorOnly()) {
     // Parsing a model file should reuse the existing ASTContext.
     if (!isModelParsingAction())
       CI.createASTContext();
 
+    // For preprocessed files, check if the first line specifies the original
+    // source file name with a linemarker.
+    std::string OrigFile;
+    if (Input.isPreprocessed())
+      if (ReadOriginalFileName(CI, OrigFile))
+        InputFile = OrigFile;
+
     std::unique_ptr<ASTConsumer> Consumer =
         CreateWrappedASTConsumer(CI, InputFile);
     if (!Consumer)
       goto failure;
 
     // FIXME: should not overwrite ASTMutationListener when parsing model files?
     if (!isModelParsingAction())
       CI.getASTContext().setASTMutationListener(Consumer->GetASTMutationListener());
bool FrontendAction::BeginSourceFile(CompilerInstance &CI,
 
   // If we were asked to load any module files, do so now.
   for (const auto &ModuleFile : CI.getFrontendOpts().ModuleFiles)
     if (!CI.loadModuleFile(ModuleFile))
       goto failure;
 
   // If there is a layout overrides file, attach an external AST source that
   // provides the layouts from that file.
-  if (!CI.getFrontendOpts().OverrideRecordLayoutsFile.empty() && 
+  if (!CI.getFrontendOpts().OverrideRecordLayoutsFile.empty() &&
       CI.hasASTContext() && !CI.getASTContext().getExternalSource()) {
-    IntrusiveRefCntPtr<ExternalASTSource> 
+    IntrusiveRefCntPtr<ExternalASTSource>
       Override(new LayoutOverrideSource(
                      CI.getFrontendOpts().OverrideRecordLayoutsFile));
     CI.getASTContext().setExternalSource(Override);
   }
 
   return true;
 
   // If we failed, reset state since the client will not end up calling the

cfe/trunk/test/Frontend/preprocessed-input.i

+# 1 "preprocessed-input.c"
+# 1 "<built-in>" 1
+# 1 "<built-in>" 3
+# 318 "<built-in>" 3
+# 1 "<command line>" 1
+# 1 "<built-in>" 2
+# 1 "preprocessed-input.c" 2
+
+// RUN: %clang -emit-llvm -S -o - %s | FileCheck %s
+// CHECK: source_filename = "preprocessed-input.c"{{$}}