Closes #13

Author: gmh5225

clang/lib/Lex/PPMacroExpansion.cpp

@@ -47,6 +47,7 @@
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Transforms/IPO/MSVCMacroRebuilding.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
@@ -1581,9 +1582,13 @@ void Preprocessor::ExpandBuiltinMacro(Token &Tok) {
         //[MSVC Compalibility] Use file name and line to replace '__FUNCTION__'
 #ifdef _WIN32
         if (II == Ident__FUNCTION__) {
-          FN += "(Line:";
-          FN += Twine(PLoc.getLine()).str();
-          FN += ")";
+          SmallString<256> FNTemp =
+              llvm::MSVCMacroRebuildingPass::get__FUNCTION__MarkerName();
+          FNTemp += FN;
+          FNTemp += "(Line:";
+          FNTemp += Twine(PLoc.getLine()).str();
+          FNTemp += ")";
+          FN = FNTemp;
         }
 #endif
       }

llvm/include/llvm/Transforms/IPO/MSVCMacroRebuilding.h

@@ -0,0 +1,41 @@
+#ifndef LLVM_MSVC_MACRO_REBUILDING_PASS_H
+#define LLVM_MSVC_MACRO_REBUILDING_PASS_H
+
+#include "llvm/IR/PassManager.h"
+#include <string>
+
+namespace llvm {
+// Forward declarations of classes used in the implementation of the pass.
+class raw_ostream;
+class Function;
+class Module;
+class GlobalVariable;
+class ConstantDataArray;
+class Pass;
+
+class MSVCMacroRebuildingPass : public PassInfoMixin<MSVCMacroRebuildingPass> {
+
+private:
+  // Replace '__FUNCTION__'
+  bool replace__FUNCTION__(GlobalVariable &GV, ConstantDataArray *CDA,
+                           StringRef FunctionName);
+
+public:
+  MSVCMacroRebuildingPass() {}
+
+  // Run the pass on the given module, and return the results as a set of
+  // preserved analyses.
+  PreservedAnalyses run(Module &M, AnalysisManager<Module> &);
+
+  // Check whether this pass is required for correctness. This should always
+  // return true.
+  static bool isRequired() { return true; }
+
+  // Return the name of marker for '__FUNCTION__'.
+  static StringRef get__FUNCTION__MarkerName() {
+    return "llvm_msvc__FUNCTION__E94550C93CD70FE748E6982B3439AD3B_";
+  }
+};
+
+} // namespace llvm
+#endif

llvm/lib/Transforms/IPO/CMakeLists.txt

@@ -43,6 +43,7 @@ add_llvm_component_library(LLVMipo
   ThinLTOBitcodeWriter.cpp
   WholeProgramDevirt.cpp
   WelComeToLLVMMSVC.cpp
+  MSVCMacroRebuilding.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Transforms

llvm/lib/Transforms/IPO/MSVCMacroRebuilding.cpp

@@ -0,0 +1,117 @@
+#include "llvm/Transforms/IPO/MSVCMacroRebuilding.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Analysis/ModuleSummaryAnalysis.h"
+#include "llvm/Demangle/Demangle.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/InlineAsm.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/PrintPasses.h"
+#include "llvm/IRPrinter/IRAutoGeneratorPass.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/ToolOutputFile.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Transforms/Utils/ModuleUtils.h"
+#include <fstream>
+#include <iostream>
+#include <regex>
+
+using namespace llvm;
+
+// Replace '__FUNCTION__'
+bool MSVCMacroRebuildingPass::replace__FUNCTION__(GlobalVariable &GV,
+                                                  ConstantDataArray *CDA,
+                                                  StringRef FunctionName) {
+  // Construct the regular expression used to match the
+  // macro marker and the file name with escaped backslashes and line number.
+  static std::string RegexStr =
+      MSVCMacroRebuildingPass::get__FUNCTION__MarkerName().str() +
+      std::regex_replace(GV.getParent()->getSourceFileName(),
+                         std::regex("\\\\"), "\\\\") +
+      "\\(Line:\\d+\\)";
+
+  // Get the original string value of the constant data array.
+  std::string OriginalStr = CDA->getAsCString().str();
+  // Replace the macro marker and file name in the original string with
+  // the name of the function containing the instruction.
+  std::string ReplacedStr =
+      std::regex_replace(OriginalStr, std::regex(RegexStr), FunctionName.str());
+
+  // If the replaced string is the same as the original string, skip the
+  // variable.
+  if (ReplacedStr == OriginalStr)
+    return false;
+
+  // Demangle the replaced string and extract the function name.
+  std::string DemangledReplacedStr = demangle(ReplacedStr);
+  size_t StartIndex = DemangledReplacedStr.find("(");
+  if (StartIndex != std::string::npos) {
+    size_t EndIndex = DemangledReplacedStr.rfind(" ", StartIndex);
+    if (EndIndex != std::string::npos) {
+      DemangledReplacedStr =
+          DemangledReplacedStr.substr(EndIndex + 1, StartIndex - EndIndex - 1);
+    }
+  }
+
+  // Create a new constant data array containing the demangled function
+  // name and set it as the initializer of the global variable.
+  Constant *NewStr = ConstantDataArray::getString(GV.getParent()->getContext(),
+                                                  DemangledReplacedStr);
+  GV.setInitializer(NewStr);
+
+  return true;
+}
+
+// Implementation of the run() function for the MSVCMacroRebuildingPass
+// class
+PreservedAnalyses MSVCMacroRebuildingPass::run(Module &M,
+                                               ModuleAnalysisManager &AM) {
+  bool Changed = false;
+
+  // Iterate over all global variables in the input module.
+  for (GlobalVariable &GV : M.globals()) {
+    // Skip the variable if it does not have an initializer.
+    if (!GV.hasInitializer())
+      continue;
+
+    // Check if the initializer is a constant data array of strings.
+    if (ConstantDataArray *CDA =
+            dyn_cast<ConstantDataArray>(GV.getInitializer())) {
+      if (!CDA->isString())
+        continue;
+
+      // Iterate over all users of the global variable and check if it is an
+      // instruction in a function.
+      for (auto UserIt = GV.users().begin(); UserIt != GV.users().end();
+           ++UserIt) {
+        if (Instruction *Inst = dyn_cast<Instruction>(*UserIt)) {
+          if (!Inst->getParent())
+            continue;
+
+          Function *F = Inst->getParent()->getParent();
+          if (!F)
+            continue;
+
+          // Replace '__FUNCTION__'
+          Changed |= replace__FUNCTION__(GV, CDA, F->getName());
+        }
+      }
+    }
+  }
+
+  /**
+   * This statement returns a PreservedAnalyses object based on whether there
+   * were any changes during the pass execution. If `Changed` is true,
+   * indicating that changes occurred, it returns
+   * `llvm::PreservedAnalyses::none()`. This means that some analyses may not be
+   * preserved and should be re-run as the pass has potentially invalidated
+   * their results. If `Changed` is false, indicating that no changes occurred,
+   * it returns `llvm::PreservedAnalyses::all()`. This means that all analyses
+   * are preserved and their results are still valid after the pass execution.
+   */
+  return (Changed ? llvm::PreservedAnalyses::none()
+                  : llvm::PreservedAnalyses::all());
+}