Introduce SourceManager::getMacroArgExpandedLocation function.

If we pass it a source location that points inside a function macro argument,
the returned location will be the macro location in which the argument was expanded.
If a macro argument is used multiple times, the expanded location will
be at the first expansion of the argument.
 e.g.
   MY_MACRO(foo);
             ^
Passing a file location pointing at 'foo', will yield a macro location
where 'foo' was expanded into.

Make SourceManager::getLocation call getMacroArgExpandedLocation as well.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@137794 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 105 insertions, 7 deletions

diff --git a/include/clang/Basic/SourceManager.h b/include/clang/Basic/SourceManager.h
index 2ea19ebc4d..68293a7887 100644
--- a/include/clang/Basic/SourceManager.h
+++ b/include/clang/Basic/SourceManager.h
@@ -489,6 +489,10 @@ class SourceManager : public llvm::RefCountedBase<SourceManager> {
   /// not have been loaded, so that value would be unknown.
   unsigned CurrentLoadedOffset;
 
+  /// \brief The highest possible offset is 2^31-1, so CurrentLoadedOffset
+  /// starts at 2^31.
+  static const unsigned MaxLoadedOffset = 1U << 31U;
+
   /// \brief A bitmap that indicates whether the entries of LoadedSLocEntryTable
   /// have already been loaded from the external source.
   ///
@@ -1001,8 +1005,33 @@ public:
   ///
   /// If the source file is included multiple times, the source location will
   /// be based upon the first inclusion.
+  ///
+  /// If the location points inside a function macro argument, the returned
+  /// location will be the macro location in which the argument was expanded.
+  /// \sa getMacroArgExpandedLocation
   SourceLocation getLocation(const FileEntry *SourceFile,
-                             unsigned Line, unsigned Col);
+                             unsigned Line, unsigned Col) {
+    SourceLocation Loc = translateFileLineCol(SourceFile, Line, Col);
+    return getMacroArgExpandedLocation(Loc);
+  }
+  
+  /// \brief Get the source location for the given file:line:col triplet.
+  ///
+  /// If the source file is included multiple times, the source location will
+  /// be based upon the first inclusion.
+  SourceLocation translateFileLineCol(const FileEntry *SourceFile,
+                                      unsigned Line, unsigned Col);
+
+  /// \brief If \arg Loc points inside a function macro argument, the returned
+  /// location will be the macro location in which the argument was expanded.
+  /// If a macro argument is used multiple times, the expanded location will
+  /// be at the first expansion of the argument.
+  /// e.g.
+  ///   MY_MACRO(foo);
+  ///             ^
+  /// Passing a file location pointing at 'foo', will yield a macro location
+  /// where 'foo' was expanded into.
+  SourceLocation getMacroArgExpandedLocation(SourceLocation Loc);
 
   /// \brief Determines the order of 2 source locations in the translation unit.
   ///
diff --git a/lib/Basic/SourceManager.cpp b/lib/Basic/SourceManager.cpp
index e3106c4a29..8190ca397a 100644
--- a/lib/Basic/SourceManager.cpp
+++ b/lib/Basic/SourceManager.cpp
@@ -403,9 +403,7 @@ void SourceManager::clearIDTables() {
 
   // Use up FileID #0 as an invalid expansion.
   NextLocalOffset = 0;
-  // The highest possible offset is 2^31-1, so CurrentLoadedOffset starts at
-  // 2^31.
-  CurrentLoadedOffset = 1U << 31U;
+  CurrentLoadedOffset = MaxLoadedOffset;
   createExpansionLoc(SourceLocation(),SourceLocation(),SourceLocation(), 1);
 }
 
@@ -1303,8 +1301,8 @@ static llvm::Optional<ino_t> getActualFileInode(const FileEntry *File) {
 ///
 /// If the source file is included multiple times, the source location will
 /// be based upon an arbitrary inclusion.
-SourceLocation SourceManager::getLocation(const FileEntry *SourceFile,
-                                          unsigned Line, unsigned Col) {
+SourceLocation SourceManager::translateFileLineCol(const FileEntry *SourceFile,
+                                                  unsigned Line, unsigned Col) {
   assert(SourceFile && "Null source file!");
   assert(Line && Col && "Line and column should start from 1!");
 
@@ -1454,6 +1452,77 @@ SourceLocation SourceManager::getLocation(const FileEntry *SourceFile,
   return getLocForStartOfFile(FirstFID).getFileLocWithOffset(FilePos + Col - 1);
 }
 
+/// \brief If \arg Loc points inside a function macro argument, the returned
+/// location will be the macro location in which the argument was expanded.
+/// If a macro argument is used multiple times, the expanded location will
+/// be at the first expansion of the argument.
+/// e.g.
+///   MY_MACRO(foo);
+///             ^
+/// Passing a file location pointing at 'foo', will yield a macro location
+/// where 'foo' was expanded into.
+SourceLocation SourceManager::getMacroArgExpandedLocation(SourceLocation Loc) {
+  if (Loc.isInvalid())
+    return Loc;
+  
+  FileID FID = getFileID(Loc);
+  if (FID.isInvalid())
+    return Loc;
+
+  int ID = FID.ID;
+  while (1) {
+    ++ID;
+    // Stop if there are no more FileIDs to check.
+    if (ID > 0) {
+      if (unsigned(ID) >= local_sloc_entry_size())
+        return Loc;
+    } else if (ID == -1) {
+      return Loc;
+    }
+
+    const SrcMgr::SLocEntry &Entry = getSLocEntryByID(ID);
+    if (Entry.isFile()) {
+      if (Entry.getFile().getIncludeLoc().isValid() &&
+          !isBeforeInTranslationUnit(Entry.getFile().getIncludeLoc(), Loc))
+        return Loc;
+      continue;
+    }
+  
+    if (isBeforeInTranslationUnit(Loc,
+                                  Entry.getExpansion().getExpansionLocStart()))
+      return Loc;
+    if (!Entry.getExpansion().isMacroArgExpansion())
+      continue;
+
+    // This is a macro argument expansion. See if Loc points in the argument
+    // that was lexed.
+
+    SourceLocation SpellLoc = Entry.getExpansion().getSpellingLoc();
+    unsigned NextOffset;
+    if (ID > 0) {
+      if (unsigned(ID+1) == local_sloc_entry_size())
+        NextOffset = getNextLocalOffset();
+      else
+        NextOffset = getLocalSLocEntry(ID+1).getOffset();
+    } else {
+      if (ID+1 == -1)
+        NextOffset = MaxLoadedOffset;
+      else
+        NextOffset = getSLocEntry(FileID::get(ID+1)).getOffset();
+    }
+    unsigned EntrySize = NextOffset - Entry.getOffset() - 1;
+    unsigned BeginOffs = SpellLoc.getOffset();
+    unsigned EndOffs = BeginOffs + EntrySize;
+    if (BeginOffs <= Loc.getOffset() && Loc.getOffset() < EndOffs) {
+      SourceLocation ExpandLoc = SourceLocation::getMacroLoc(Entry.getOffset());
+      // Replace current Loc with the expanded location and continue.
+      // The expanded argument may end up being passed to another function macro
+      // and relexed again.
+      Loc = ExpandLoc.getFileLocWithOffset(Loc.getOffset()-BeginOffs);
+    }
+  }
+}
+
 /// Given a decomposed source location, move it up the include/expansion stack
 /// to the parent source location.  If this is possible, return the decomposed
 /// version of the parent in Loc and return false.  If Loc is the top-level
@@ -1557,7 +1626,7 @@ void SourceManager::PrintStats() const {
                << NextLocalOffset << "B of Sloc address space used.\n";
   llvm::errs() << LoadedSLocEntryTable.size()
                << " loaded SLocEntries allocated, "
-               << (1U << 31U) - CurrentLoadedOffset
+               << MaxLoadedOffset - CurrentLoadedOffset
                << "B of Sloc address space used.\n";
   
   unsigned NumLineNumsComputed = 0;