adds __FILE_BASENAME__ builtin macro

[kristina]

Summary

FILE will be expanded to the full path. In some scenarios, only part of the full path is needed.
This patch adds the option below:

-ffile-macro-prefix-to-remove=/foo/bar

to strip away matched prefix.

[bcraig]

Note: this doesn't count as an official "LGTM".

The code change seems fine to me. I think this has been implemented in gcc as well, but I don't recall for certain. If this has been implemented in gcc, then I would expect the semantics to be the same. If it hasn't been implemented in gcc, then we might want to pick a different name for the macro (e.g. CLANG_FILE_BASENAME).

[thakis]

Instead of doing this, would it make sense to have a flag like -ffile-basename that changes what FILE expands to?

I had wished I'd be able to have some control over FILE (I'd like to say "make all FILEs relative to this given directory for my use case), and changing FILE to something else in all the world's code isn't easy – so maybe having a flag that provides some control over FILE instead of adding a separate macro would be a good idea.

[joerg]

I've added functionality like that to NetBSD's GCC a long time ago. That functionality is useful for a variety of situations, cutting down file space or canonicalization are two uses.

[weimingz]

In D17741#364742, @bcraig wrote:

Note: this doesn't count as an official "LGTM".

The code change seems fine to me. I think this has been implemented in gcc as well, but I don't recall for certain. If this has been implemented in gcc, then I would expect the semantics to be the same. If it hasn't been implemented in gcc, then we might want to pick a different name for the macro (e.g. CLANG_FILE_BASENAME).

GCC has a macro "BASE_FILE", which I initially thought was for this purpose, but it's not.
BASE_FILE

This macro expands to the name of the main input file, in the form of a C string constant. This is the source file that was specified on the command line of the preprocessor or C compiler.

I will rename the macro to CLANG_FILE_BASENAME

[weimingz]

In D17741#364756, @thakis wrote:

Instead of doing this, would it make sense to have a flag like -ffile-basename that changes what FILE expands to?

I had wished I'd be able to have some control over FILE (I'd like to say "make all FILEs relative to this given directory for my use case), and changing FILE to something else in all the world's code isn't easy – so maybe having a flag that provides some control over FILE instead of adding a separate macro would be a good idea.

do you mean this?
if source file is /a/b/c/d/foo.c and if -ffile-name-stem-remove=/a/b/c, then _FILE_ will be expanded to "d/foo.c" ?

[weimingz]

rename the macro to CLANG_FILE_BASENAME per Ben's comments.

[thakis]

In D17741#364931, @weimingz wrote:

In D17741#364756, @thakis wrote:

Instead of doing this, would it make sense to have a flag like -ffile-basename that changes what FILE expands to?

I had wished I'd be able to have some control over FILE (I'd like to say "make all FILEs relative to this given directory for my use case), and changing FILE to something else in all the world's code isn't easy – so maybe having a flag that provides some control over FILE instead of adding a separate macro would be a good idea.

do you mean this?
if source file is /a/b/c/d/foo.c and if -ffile-name-stem-remove=/a/b/c, then _FILE_ will be expanded to "d/foo.c" ?

Yes, something like that. Maybe it could look like -f__file__-expansion=basename (to make FILE expand to just the basename, what you want), -f__file__-expansion=relative-to:/a/b/c to make it relative to a given path.

[weimingz]

In D17741#364954, @thakis wrote:

In D17741#364931, @weimingz wrote:

In D17741#364756, @thakis wrote:

Instead of doing this, would it make sense to have a flag like -ffile-basename that changes what FILE expands to?

I had wished I'd be able to have some control over FILE (I'd like to say "make all FILEs relative to this given directory for my use case), and changing FILE to something else in all the world's code isn't easy – so maybe having a flag that provides some control over FILE instead of adding a separate macro would be a good idea.

do you mean this?
if source file is /a/b/c/d/foo.c and if -ffile-name-stem-remove=/a/b/c, then _FILE_ will be expanded to "d/foo.c" ?

Yes, something like that. Maybe it could look like -f__file__-expansion=basename (to make FILE expand to just the basename, what you want), -f__file__-expansion=relative-to:/a/b/c to make it relative to a given path.

I think we can do this separately. A "basename" macro is easier for programmers to use and no build system change needed.

[bcraig]

LGTM. You should probably wait for someone else to approve it though.

[thakis]

I think we can do this separately. A "basename" macro is easier for programmers to use and no build system change needed.

Hm, I would think that adding a flag to your CFLAGS is easier than getting all your dependencies to use a clang-only new macro…

[bcraig]

In D17741#365457, @thakis wrote:

I think we can do this separately. A "basename" macro is easier for programmers to use and no build system change needed.

Hm, I would think that adding a flag to your CFLAGS is easier than getting all your dependencies to use a clang-only new macro…

Depends a lot on the person and code base.
Pro-macro situations:
I've had code bases where the bulk of the code refused to use compiler / environment provided preprocessor tokens. In those environments, all of the uses of FILE and the like were in one place. Adding a compiler test and switching to CLANG_FILE_BASENAME would be easy in those code bases. Changing CFLAGS in dozens of different compiles wouldn't.

I've also seen uses of FILE that would break if the file name changed drastically and unexpectedly.

Pro-compilation switch situation:
If FILE is used in a lot of places, and the files are compiled with multiple compilers, then switching to a different macro would be problematic. If it is easy to change CFLAGS in all of your builds then the compilation switch makes sense.

[weimingz]

Add "-fFILE-prefix-to-remove" flag to support the trim of the prefix.
Passing special value ALL_DIR to remove all dir parts.

For example FILE is /a/b/c
-fFILE-prefix-to-remove=/a/ will cause FILE be expanded to b/c

[hfinkel]

In D17741#367113, @weimingz wrote:

Add "-fFILE-prefix-to-remove" flag to support the trim of the prefix.
Passing special value ALL_DIR to remove all dir parts.

For example FILE is /a/b/c
-fFILE-prefix-to-remove=/a/ will cause FILE be expanded to b/c

I *really* don't like having __FILE__ in the option name. That will look visually disjointing on the command line. How about: -ffile-macro-prefix-to-remove?

[weimingz]

Change the option name to -ffile-macro-prefix-to-remove

[weimingz]

rebased

[weimingz]

In D17741#372098, @weimingz wrote:

rebased

ping~

[weimingz]

In D17741#374725, @weimingz wrote:

In D17741#372098, @weimingz wrote:

rebased

ping~

HI,

Any comments/suggestions?

[alexr]

There are multiple features in this patch that should be considered separately. Please split the patch.

That said, I don't think we want to add a fundamental new preprocessor feature like FILE_BASENAME without at least getting some early buy-in from the WG14 and WG21 committees. I suspect they’d not want to add to the preprocessor at all.

The flag concept seems much more tractable. Please split it into two flags, one to force FILE to only be the basename, and one that handles the prefix stripping. That is, a magic value of ALL_DIR seems like the wrong choice here.

[weimingz]

Sounds good. Will do.

Thanks for reviewing

[weimingz]

per Alex's suggestion, split into 2 flags:
-ffile-macro-prefix-to-remove=xxx : remove matched prefix
-ffile-macro-basename-only : remove the whole dir part

[weimingz]

Ping ?

[weimingz]

ping?

[dexonsmith]

Hal requested splitting the patch in two, since the two features are separable, but they both still seem to be here. Perhaps start with the prefix patch?

include/clang/Driver/Options.td

828

This opt name doesn’t match the command line option.

831

Same here.

include/clang/Lex/PreprocessorOptions.h

122

This identifier name is reserved for the implementation.

126

Same here.

lib/Lex/PPMacroExpansion.cpp

1608

Why not use =?

[JetForMe]

Just want to comment that this functionality is also good for security, as it enables hiding of path information in final builds (while still allowing logging to show file and line number). Because a lot of third-party code can get incorporated into a build, command-line options to modify the rendering of FILE are preferred.

[weimingz]

split the original into two parts. This one supports -ffile-macro-prefix-to-remove function.

I locally verified it. To add a test case, do we need to use VFS?

[dexonsmith]

In D17741#1067816, @weimingz wrote:

split the original into two parts. This one supports -ffile-macro-prefix-to-remove function.

I locally verified it. To add a test case, do we need to use VFS?

VFS might work.

[Ka-Ka]

Ping?

Do you think this small lit testcase below work as a testcase for the -ffile-macro-prefix-to-remove option?

// RUN: %clang_cc1 -emit-llvm %s  -o - -ffile-macro-prefix-to-remove=%s | FileCheck %s
char this_file[] = __FILE__;
// CHECK: @this_file = global [1 x i8] zeroinitializer

[Ka-Ka]

Ping?

[kristina]

I like the idea of just getting the filename reliably, but I think an extension to strip path prefixes is a bit of an overkill especially as yet another compiler flag. I implemented a similar thing in my fork in form of a directive to __generate(...) which is my own weird extension to do meta-programming using the preprocessor, that's the implementation with no extra parameters (just as an idea, I know the implementation is not great):

else if (PS == kMPS_DirectiveFile)
 {
   PresumedLoc PLoc = SourceMgr.getPresumedLoc(Tok.getLocation());
   
   OutBuffer.clear();
   OutBuffer.push_back('"');
   
   if (PLoc.isValid()) {
     TokenBuffer.clear();
     TokenBuffer.append(PLoc.getFilename());
     
     size_t LastSlashPos = TokenBuffer.find_last_of('/');
     if (LastSlashPos != StringRef::npos) {
       std::string LastPathComponent = 
         Lexer::Stringify(TokenBuffer.substr(LastSlashPos+1));
       
       OutBuffer.append(LastPathComponent);
     }
     else {
       Lexer::Stringify(TokenBuffer);
       OutBuffer.append(TokenBuffer.str());
     }
   }
   else {
     OutBuffer.push_back('?');
   }
 }

I think this type of approach (I don't mean the PP extension, just the methodology) for getting the filename without the full path or shedding parts of the full path is a lot nicer. I'm not entirely sure why so many headers are getting pulled in either, though, I think the only issue is the path separator? Aside from that I don't think this needs a compiler flag, but a macro for just getting the filename reliably in upstream would be nice. Your flag idea means various build systems may have to do gymnastics to find out the right path to strip so it seems cumbersome.

[NSProgrammer]

To throw in my 2 cents. I don’t really have a preference between a compiler flag vs a different macro that’s just for the file name sans path prefix. But I have a real need for this to get into clang: with 1.2 million lines of code, the regular placement of log statements and custom asserts leads to megabytes in binary size from all the FILE usages, and that could easily be a few hundred KB with this kind of support in clang.

[kristina]

In D17741#1345171, @NSProgrammer wrote:

To throw in my 2 cents. I don’t really have a preference between a compiler flag vs a different macro that’s just for the file name sans path prefix. But I have a real need for this to get into clang: with 1.2 million lines of code, the regular placement of log statements and custom asserts leads to megabytes in binary size from all the FILE usages, and that could easily be a few hundred KB with this kind of support in clang.

Yeah that would only require adding a new macro in lib/Lex/PPMacroExpansion.cpp plus a test instead of a huge diff as it is now. So yes as I said, that would be a great patch. However this implementation is is needlessly complicated and I don't think this should be yet another driver/compiler flag for a seemingly obscure use case. So yes I'm with you on that, filename without the path prefix is definitely an extension I'd like to see upstreamed (I proposed it on cfe-dev a while ago but it wasn't well received so I never put it up for review (that was before the weird preprocessor stuff that I do now in my fork)).

[kristina]

I should add that this is not just about reproducible builds but about code size as mentioned by @NSProgrammer. There are ways to cheat with builtins but the problem is, entire __FILE__ string is still emitted into read-only data, despite the constexpressiveness of the value. The common way of getting the short filename in code would the the following (the #else case) which is a constant evaluated but has a side effect of dumping the full paths in rodata regardless (ICF seems unable to clean them up even in full LTO builds).

#ifdef __clang_extension_generate
    #define OS_CUR_FILENAME  __generate("file!0")
#else
    #define OS_CUR_FILENAME (__builtin_strrchr(__FILE__, '/') ? \
        __builtin_strrchr(__FILE__, '/') + 1 : __FILE__)
#endif

The extension on the other hand avoids that. So it's a win for code size and reproducible builds. I would urge reconsidering something like __FILE_NAME__, or whatever name is preferable for just getting the last path component at preprocessor stage, despite it being poorly received by other developers the last time it seems to be a feature wanted by consumers. I would urge maintainers to reply to get another consensus regarding this since my stance is still the same, if a "missing" feature is widely hacked around, it's clearly desirable. While I understand that a lot have an aversion to nonstandard Clang-specific extensions, as long as a feature check is available it should be down to the consumer to decide if they want to make use of such extensions.

[kristina]

Ping for author? This is one of the changes I'd like to see through, though the complexity here can be massively reduced as stated above. I wouldn't mind opening a new diff if the author is away with just a change in PPMacroExpansion and a testcase (which should probably be included here) but I would appreciate some form of consensus since this exact idea with a special macro for filename was previously rejected.

[NSProgrammer]

We would prefer a macro like __FILE_NAME__ over a build flag for code reading consistency (they would clearly do different things vs varying based on an obscure flag being present/absent). (This contradicts my previous statement of having no preference since discussing it more, the macro approach would actually be preferable, but either is acceptable).

This patch is languishing, unless the original author thinks otherwise, a new patch to push this through would be great.

[kristina]

If the author is still missing at the end of next week, any objections to me resubmitting a similar patch that just implements __FILE_NAME__ or __BASE_NAME__ (Need a few more opinions here I guess, personally I think __FILE_NAME__ makes more sense)?

I'll carve it out from my PP extension which simply looks for the last path separator (depending on the OS) and only renders the filename after it (or the whole path if there's no separator). No need for additional complications like depths etc. Since this idea was shot down last time, is it possible to get a few people to voice their opinion before I mark this as abandoned and carve out and clean up this from my PP extension and add proper tests for it?

Would be appreciated, as this sort of thing is very useful (IMO) so would like to know if anyone is really against this proposal.

[NSProgrammer]

In D17741#1413864, @kristina wrote:

If the author is still missing at the end of next week, any objections to me resubmitting a similar patch that just implements __FILE_NAME__ or __BASE_NAME__ (Need a few more opinions here I guess, personally I think __FILE_NAME__ makes more sense)?

I'll carve it out from my PP extension which simply looks for the last path separator (depending on the OS) and only renders the filename after it (or the whole path if there's no separator). No need for additional complications like depths etc. Since this idea was shot down last time, is it possible to get a few people to voice their opinion before I mark this as abandoned and carve out and clean up this from my PP extension and add proper tests for it?

Would be appreciated, as this sort of thing is very useful (IMO) so would like to know if anyone is really against this proposal.

Kristina, it looks like there is no push back and even plenty of support. How do you feel about going forward with submitting a patch that implements __FILE_NAME__?

[kristina]

Sorry, forgot about this, will make a new diff with just the macro for review later tonight.

[kristina]

Superseded by D61756

include/clang/Driver/Options.td

 def femulated_tls : Flag<["-"], "femulated-tls">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Use emutls functions to access thread_local variables">;
 def fno_emulated_tls : Flag<["-"], "fno-emulated-tls">, Group<f_Group>, Flags<[CC1Option]>;
 def fencoding_EQ : Joined<["-"], "fencoding=">, Group<f_Group>;
 def ferror_limit_EQ : Joined<["-"], "ferror-limit=">, Group<f_Group>, Flags<[CoreOption]>;
 def fexceptions : Flag<["-"], "fexceptions">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable support for exception handling">;
 def fdwarf_exceptions : Flag<["-"], "fdwarf-exceptions">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Use DWARF style exceptions">;
 def fsjlj_exceptions : Flag<["-"], "fsjlj-exceptions">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Use SjLj style exceptions">;
 def fseh_exceptions : Flag<["-"], "fseh-exceptions">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Use SEH style exceptions">;
 def fexcess_precision_EQ : Joined<["-"], "fexcess-precision=">,
     Group<clang_ignored_gcc_optimization_f_Group>;
 def : Flag<["-"], "fexpensive-optimizations">, Group<clang_ignored_gcc_optimization_f_Group>;
 def : Flag<["-"], "fno-expensive-optimizations">, Group<clang_ignored_gcc_optimization_f_Group>;
 def fextdirs_EQ : Joined<["-"], "fextdirs=">, Group<f_Group>;
 def : Flag<["-"], "fdefer-pop">, Group<clang_ignored_gcc_optimization_f_Group>;
 def : Flag<["-"], "fno-defer-pop">, Group<clang_ignored_gcc_optimization_f_Group>;
def fmodules_strict_decluse : Flag <["-"], "fmodules-strict-decluse">, Group<f_Group>,
   Flags<[DriverOption,CC1Option]>,
   HelpText<"Like -fmodules-decluse but requires all headers to be in modules">;
 def fno_modules_search_all : Flag <["-"], "fno-modules-search-all">, Group<f_Group>,
   Flags<[DriverOption, CC1Option]>;
 def fno_implicit_modules :
   Flag <["-"], "fno-implicit-modules">,
   Group<f_Group>, Flags<[DriverOption, CC1Option]>;
 def fretain_comments_from_system_headers : Flag<["-"], "fretain-comments-from-system-headers">, Group<f_Group>, Flags<[CC1Option]>;
+def ffile_macro_prefix_to_remove : Joined<["-"], "ffile-macro-prefix-to-remove=">,
+  Group<f_Group>, Flags<[DriverOption, CC1Option]>,
+  HelpText<"prefix to be removed from expanded string of __FILE__ macro">;
 
 def fmudflapth : Flag<["-"], "fmudflapth">, Group<f_Group>;
 def fmudflap : Flag<["-"], "fmudflap">, Group<f_Group>;
 def fnested_functions : Flag<["-"], "fnested-functions">, Group<f_Group>;
 def fnext_runtime : Flag<["-"], "fnext-runtime">, Group<f_Group>;
 def fno_access_control : Flag<["-"], "fno-access-control">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Disable C++ access control">;
 def fno_apple_pragma_pack : Flag<["-"], "fno-apple-pragma-pack">, Group<f_Group>;

include/clang/Lex/PreprocessorOptions.h

public:
   /// contents of other files on the system (the second part of each
   /// pair).
   std::vector<std::pair<std::string, std::string>> RemappedFiles;
 
   /// \brief The set of file-to-buffer remappings, which take existing files
   /// on the system (the first part of each pair) and gives them the contents
   /// of the specified memory buffer (the second part of each pair).
   std::vector<std::pair<std::string, llvm::MemoryBuffer *>> RemappedFileBuffers;
 
   /// \brief Whether the compiler instance should retain (i.e., not free)
   /// the buffers associated with remapped files.
   ///
   /// This flag defaults to false; it can be set true only through direct
   /// manipulation of the compiler invocation object, in cases where the 
   /// compiler invocation and its buffers will be reused.
   bool RetainRemappedFileBuffers = false;
-  
   /// \brief The Objective-C++ ARC standard library that we should support,
   /// by providing appropriate definitions to retrofit the standard library
   /// with support for lifetime-qualified pointers.
   ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary = ARCXX_nolib;
-    
+  /// \brief This string will be used in expanding __FILE__ macro. If it
+  /// matches the prefix of __FILE__, the matched part won't be expanded.
+  std::string FileMacroPrefixToRemove;
+
   /// \brief Records the set of modules
   class FailedModulesSet {
     llvm::StringSet<> Failed;
 
   public:
     bool hasAlreadyFailed(StringRef module) {
       return Failed.count(module) > 0;
     }

lib/Driver/ToolChains/Clang.cpp

if (!IsIAMCU)
     forAllAssociatedToolChains(C, JA, getToolChain(),
                                [&Args, &CmdArgs](const ToolChain &TC) {
                                  TC.AddClangSystemIncludeArgs(Args, CmdArgs);
                                });
   else {
     // For IAMCU add special include arguments.
     getToolChain().AddIAMCUIncludeArgs(Args, CmdArgs);
   }
+
+  // Add FILE macro prefix removing arguments or basename only flags.
+  if (const Arg *A =
+          Args.getLastArg(options::OPT_ffile_macro_prefix_to_remove)) {
+    StringRef PrefixToRemove(A->getValue());
+    if (!PrefixToRemove.empty())
+      CmdArgs.push_back(Args.MakeArgString("-ffile-macro-prefix-to-remove=" +
+                                           PrefixToRemove));
+  }
 }
 
 // FIXME: Move to target hook.
 static bool isSignedCharDefault(const llvm::Triple &Triple) {
   switch (Triple.getArch()) {
   default:
     return true;
 

lib/Frontend/CompilerInvocation.cpp

unsigned Library = llvm::StringSwitch<unsigned>(Name)
       .Case("none", ARCXX_nolib)
       .Default(~0U);
     if (Library == ~0U)
       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
     else
       Opts.ObjCXXARCStandardLibrary = (ObjCXXARCStandardLibraryKind)Library;
   }
 
+  if (Arg *A = Args.getLastArg(OPT_ffile_macro_prefix_to_remove)) {
+    Opts.FileMacroPrefixToRemove = A->getValue();
+  }
+
   // Always avoid lexing editor placeholders when we're just running the
   // preprocessor as we never want to emit the
   // "editor placeholder in source file" error in PP only mode.
   if (isStrictlyPreprocessorAction(Action))
     Opts.LexEditorPlaceholders = false;
 }
 
 static void ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts,

lib/Lex/PPMacroExpansion.cpp

 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/CodeCompletionHandler.h"
 #include "clang/Lex/DirectoryLookup.h"
 #include "clang/Lex/ExternalPreprocessorSource.h"
 #include "clang/Lex/LexDiagnostic.h"
 #include "clang/Lex/MacroArgs.h"
 #include "clang/Lex/MacroInfo.h"
+#include "clang/Lex/PTHLexer.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorLexer.h"
-#include "clang/Lex/PTHLexer.h"
+#include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Lex/Token.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstring>
 #include <ctime>
 #include <string>
 #include <tuple>
static IdentifierInfo *ExpectFeatureIdentifierInfo(Token &Tok,
   if (!Tok.isAnnotation() && (II = Tok.getIdentifierInfo()))
     return II;
 
   PP.Diag(Tok.getLocation(), DiagID);
   return nullptr;
 }
 
 /// Implements the __is_target_arch builtin macro.
 static bool isTargetArch(const TargetInfo &TI, const IdentifierInfo *II) {
   std::string ArchName = II->getName().lower() + "--";
   llvm::Triple Arch(ArchName);
   const llvm::Triple &TT = TI.getTriple();
   if (TT.isThumb()) {
     // arm matches thumb or thumbv7. armv7 matches thumbv7.
     if ((Arch.getSubArch() == llvm::Triple::NoSubArch ||
          Arch.getSubArch() == TT.getSubArch()) &&
         ((TT.getArch() == llvm::Triple::thumb &&
if (II == Ident__BASE_FILE__ && PLoc.isValid()) {
         
         NextLoc = PLoc.getIncludeLoc();
       }
     }
 
     // Escape this filename.  Turn '\' -> '\\' '"' -> '\"'
     SmallString<128> FN;
     if (PLoc.isValid()) {
-      FN += PLoc.getFilename();
+      StringRef Filename = PLoc.getFilename();
+      if (II == Ident__FILE__) {
+        const std::string &PrefixToRemove =
+            getPreprocessorOpts().FileMacroPrefixToRemove;
+        if (Filename.startswith(PrefixToRemove))
+          FN += Filename.substr(PrefixToRemove.size());
+        else
+          FN += Filename;
+      } else
+        FN += Filename;
       Lexer::Stringify(FN);
       OS << '"' << FN << '"';
     }
     Tok.setKind(tok::string_literal);
   } else if (II == Ident__DATE__) {
     Diag(Tok.getLocation(), diag::warn_pp_date_time);
     if (!DATELoc.isValid())
       ComputeDATE_TIME(DATELoc, TIMELoc, *this);