diff --git a/clang/include/clang/Basic/CodeGenOptions.h b/clang/include/clang/Basic/CodeGenOptions.h index e39a73bdb13ac..3e102d47312ec 100644 --- a/clang/include/clang/Basic/CodeGenOptions.h +++ b/clang/include/clang/Basic/CodeGenOptions.h @@ -493,6 +493,14 @@ class CodeGenOptions : public CodeGenOptionsBase { /// The name of a file to use with \c .secure_log_unique directives. std::string AsSecureLogFile; + /// The name of a file that contains functions which will be compiled for + /// hotpatching. See -fms-hot-patch-functions-file. + std::string MSHotPatchFunctionsFile; + + /// A list of functions which will be compiled for hotpatching. + /// See -fms-hot-patch-functions-list. + std::vector MSHotPatchFunctionsList; + public: // Define accessors/mutators for code generation options of enumeration type. #define CODEGENOPT(Name, Bits, Default) diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index 30ea75bb108d5..062c8544746c0 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -3793,6 +3793,20 @@ def fms_hotpatch : Flag<["-"], "fms-hotpatch">, Group, Visibility<[ClangOption, CC1Option, CLOption]>, HelpText<"Ensure that all functions can be hotpatched at runtime">, MarshallingInfoFlag>; +def fms_hotpatch_functions_file + : Joined<["-"], "fms-hotpatch-functions-file=">, + Group, + Visibility<[ClangOption, CC1Option, CLOption]>, + MarshallingInfoString>, + HelpText<"Path to a file that contains a list of mangled symbol names of " + "functions that should be hot-patched">; +def fms_hotpatch_functions_list + : CommaJoined<["-"], "fms-hotpatch-functions-list=">, + Group, + Visibility<[ClangOption, CC1Option, CLOption]>, + MarshallingInfoStringVector>, + HelpText<"List of mangled symbol names of functions that should be " + "hot-patched">; def fpcc_struct_return : Flag<["-"], "fpcc-struct-return">, Group, Visibility<[ClangOption, CC1Option]>, HelpText<"Override the default ABI to return all structs on the stack">; diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp index 2f1c7699d27c3..14dcdbd79e577 100644 --- a/clang/lib/CodeGen/CGCall.cpp +++ b/clang/lib/CodeGen/CGCall.cpp @@ -2636,6 +2636,15 @@ void CodeGenModule::ConstructAttributeList(StringRef Name, // CPU/feature overrides. addDefaultFunctionDefinitionAttributes // handles these separately to set them based on the global defaults. GetCPUAndFeaturesAttributes(CalleeInfo.getCalleeDecl(), FuncAttrs); + + // Windows hotpatching support + if (!MSHotPatchFunctions.empty()) { + bool IsHotPatched = std::binary_search(MSHotPatchFunctions.begin(), + MSHotPatchFunctions.end(), Name); + if (IsHotPatched) { + FuncAttrs.addAttribute(llvm::Attribute::MarkedForWindowsHotPatching); + } + } } // Collect attributes from arguments and return values. diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp index c27817604f6ca..f85b87f3bebb5 100644 --- a/clang/lib/CodeGen/CodeGenModule.cpp +++ b/clang/lib/CodeGen/CodeGenModule.cpp @@ -453,6 +453,55 @@ CodeGenModule::CodeGenModule(ASTContext &C, if (Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86) getModule().addModuleFlag(llvm::Module::Error, "NumRegisterParameters", CodeGenOpts.NumRegisterParameters); + + // If there are any functions that are marked for Windows hot-patching, + // then build the list of functions now. + if (M.getTargetTriple().isOSBinFormatCOFF()) { + if (!CGO.MSHotPatchFunctionsFile.empty()) { + auto BufOrErr = llvm::MemoryBuffer::getFile(CGO.MSHotPatchFunctionsFile); + if (BufOrErr) { + const llvm::MemoryBuffer &FileBuffer = **BufOrErr; + for (llvm::line_iterator I(FileBuffer.getMemBufferRef(), true), E; + I != E; ++I) { + llvm::StringRef Line = llvm::StringRef(*I).trim(); + if (!Line.empty()) { + this->MSHotPatchFunctions.push_back(std::string{Line}); + } + } + } else { + auto &DE = Context.getDiagnostics(); + unsigned DiagID = + DE.getCustomDiagID(DiagnosticsEngine::Error, + "failed to open hotpatch functions file " + "(-fms-hotpatch-functions-file): %0 : %1"); + DE.Report(DiagID) << CGO.MSHotPatchFunctionsFile + << BufOrErr.getError().message(); + } + } + + for (const auto &FuncName : CGO.MSHotPatchFunctionsList) { + this->MSHotPatchFunctions.push_back(FuncName); + } + + std::sort(this->MSHotPatchFunctions.begin(), + this->MSHotPatchFunctions.end()); + } else { + if (!CGO.MSHotPatchFunctionsFile.empty()) { + unsigned DiagID = diags.getCustomDiagID( + DiagnosticsEngine::Error, + "hotpatch functions file (-fms-hotpatch-functions-file) is only " + "supported on Windows targets"); + diags.Report(DiagID); + } + + if (!CGO.MSHotPatchFunctionsList.empty()) { + unsigned DiagID = diags.getCustomDiagID( + DiagnosticsEngine::Error, + "hotpatch functions list (-fms-hotpatch-functions-list) is only " + "supported on Windows targets"); + diags.Report(DiagID); + } + } } CodeGenModule::~CodeGenModule() {} diff --git a/clang/lib/CodeGen/CodeGenModule.h b/clang/lib/CodeGen/CodeGenModule.h index 1db5c3bc4e4ef..45411cb95b7d2 100644 --- a/clang/lib/CodeGen/CodeGenModule.h +++ b/clang/lib/CodeGen/CodeGenModule.h @@ -678,6 +678,11 @@ class CodeGenModule : public CodeGenTypeCache { AtomicOptions AtomicOpts; + // A set of functions which should be hot-patched; see + // -fms-hotpatch-functions-file (and -list). This will nearly always be empty. + // The list is sorted for binary-searching. + std::vector MSHotPatchFunctions; + public: CodeGenModule(ASTContext &C, IntrusiveRefCntPtr FS, const HeaderSearchOptions &headersearchopts, diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp index f87549baff5e1..a733c50e56b89 100644 --- a/clang/lib/Driver/ToolChains/Clang.cpp +++ b/clang/lib/Driver/ToolChains/Clang.cpp @@ -6945,6 +6945,16 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, Args.AddLastArg(CmdArgs, options::OPT_fms_hotpatch); + if (Arg *A = Args.getLastArg(options::OPT_fms_hotpatch_functions_file)) { + Args.AddLastArg(CmdArgs, options::OPT_fms_hotpatch_functions_file); + } + + for (const auto &A : + Args.getAllArgValues(options::OPT_fms_hotpatch_functions_list)) { + CmdArgs.push_back( + Args.MakeArgString("-fms-hotpatch-functions-list=" + Twine(A))); + } + if (TC.SupportsProfiling()) { Args.AddLastArg(CmdArgs, options::OPT_pg); diff --git a/clang/test/CodeGen/ms-hotpatch-bad-file.c b/clang/test/CodeGen/ms-hotpatch-bad-file.c new file mode 100644 index 0000000000000..55304488175df --- /dev/null +++ b/clang/test/CodeGen/ms-hotpatch-bad-file.c @@ -0,0 +1,16 @@ +// This verifies that we correctly handle a -fms-hotpatch-functions-file argument that points +// to a missing file. +// +// RUN: not %clang_cl -c --target=x86_64-windows-msvc -O2 /Z7 -fms-hotpatch-functions-file=%S/this-file-is-intentionally-missing-do-not-create-it.txt /Fo%t.obj %s 2>&1 | FileCheck %s +// CHECK: failed to open hotpatch functions file + +void this_might_have_side_effects(); + +int __declspec(noinline) this_gets_hotpatched() { + this_might_have_side_effects(); + return 42; +} + +int __declspec(noinline) this_does_not_get_hotpatched() { + return this_gets_hotpatched() + 100; +} diff --git a/clang/test/CodeGen/ms-hotpatch-bad-os.c b/clang/test/CodeGen/ms-hotpatch-bad-os.c new file mode 100644 index 0000000000000..91dffccdd82ce --- /dev/null +++ b/clang/test/CodeGen/ms-hotpatch-bad-os.c @@ -0,0 +1,7 @@ +// This verifies that enabling Windows hotpatching when targeting a non-Windows OS causes an error. +// +// RUN: not %clang -c --target=x86_64-unknown-linux-elf -fms-hotpatch -fms-hotpatch-functions-list=foo -fms-hotpatch-functions-file=this_will_never_be_accessed -o%t.o %s 2>&1 | FileCheck %s +// CHECK: hotpatch functions file (-fms-hotpatch-functions-file) is only supported on Windows targets +// CHECK: hotpatch functions list (-fms-hotpatch-functions-list) is only supported on Windows targets + +void foo(); diff --git a/clang/test/CodeGen/ms-hotpatch-cpp.cpp b/clang/test/CodeGen/ms-hotpatch-cpp.cpp new file mode 100644 index 0000000000000..26e11f429c962 --- /dev/null +++ b/clang/test/CodeGen/ms-hotpatch-cpp.cpp @@ -0,0 +1,22 @@ +// This verifies that hotpatch function attributes are correctly propagated when compiling directly to OBJ, +// and that name mangling works as expected. +// +// RUN: %clang_cl -c --target=x86_64-windows-msvc -O2 /Z7 -fms-hotpatch-functions-list=?this_gets_hotpatched@@YAHXZ /Fo%t.obj %s +// RUN: llvm-readobj --codeview %t.obj | FileCheck %s + +void this_might_have_side_effects(); + +int __declspec(noinline) this_gets_hotpatched() { + this_might_have_side_effects(); + return 42; +} + +// CHECK: Kind: S_HOTPATCHFUNC (0x1169) +// CHECK-NEXT: Function: this_gets_hotpatched +// CHECK-NEXT: Name: ?this_gets_hotpatched@@YAHXZ + +extern "C" int __declspec(noinline) this_does_not_get_hotpatched() { + return this_gets_hotpatched() + 100; +} + +// CHECK-NOT: S_HOTPATCHFUNC diff --git a/clang/test/CodeGen/ms-hotpatch-file.c b/clang/test/CodeGen/ms-hotpatch-file.c new file mode 100644 index 0000000000000..9ccbe12f72d66 --- /dev/null +++ b/clang/test/CodeGen/ms-hotpatch-file.c @@ -0,0 +1,21 @@ +// This verifies that hotpatch function attributes are correctly propagated when compiling directly to OBJ. +// +// RUN: echo this_gets_hotpatched > %t-hotpatch-functions.txt +// RUN: %clang_cl -c --target=x86_64-windows-msvc -O2 /Z7 -fms-hotpatch-functions-file=%t-hotpatch-functions.txt /Fo%t.obj %s +// RUN: llvm-readobj --codeview %t.obj | FileCheck %s + +void this_might_have_side_effects(); + +int __declspec(noinline) this_gets_hotpatched() { + this_might_have_side_effects(); + return 42; +} + +// CHECK: Kind: S_HOTPATCHFUNC (0x1169) +// CHECK-NEXT: Function: this_gets_hotpatched + +int __declspec(noinline) this_does_not_get_hotpatched() { + return this_gets_hotpatched() + 100; +} + +// CHECK-NOT: S_HOTPATCHFUNC diff --git a/clang/test/CodeGen/ms-hotpatch-globals.c b/clang/test/CodeGen/ms-hotpatch-globals.c new file mode 100644 index 0000000000000..c9128e98d4b0f --- /dev/null +++ b/clang/test/CodeGen/ms-hotpatch-globals.c @@ -0,0 +1,19 @@ +// This verifies different patterns of accesses to global variables within functions that are hotpatched +// +// RUN: %clang_cl -c --target=x86_64-windows-msvc -O2 -fms-hotpatch-functions-list=this_gets_hotpatched /Fo%t.obj /clang:-S /clang:-o- %s 2>& 1 | FileCheck %s + +extern int g_foo; +extern int g_bar; + +int* this_gets_hotpatched(int k, void g()) { + g_foo = 10; + + int* ret; + if (k) { + g(); + ret = &g_foo; + } else { + ret = &g_bar; + } + return ret; +} diff --git a/clang/test/CodeGen/ms-hotpatch-lto.c b/clang/test/CodeGen/ms-hotpatch-lto.c new file mode 100644 index 0000000000000..2b94b252154b2 --- /dev/null +++ b/clang/test/CodeGen/ms-hotpatch-lto.c @@ -0,0 +1,19 @@ +// This verifies that hotpatch function attributes are correctly propagated through LLVM IR when compiling with LTO. +// +// RUN: echo this_gets_hotpatched > %t-hotpatch-functions.txt +// RUN: %clang_cl -c --target=x86_64-windows-msvc -O2 /Z7 -fms-hotpatch-functions-file=%t-hotpatch-functions.txt -flto /Fo%t.bc %s +// RUN: llvm-dis %t.bc -o - | FileCheck %s +// +// CHECK: ; Function Attrs: marked_for_windows_hot_patching mustprogress nofree noinline norecurse nosync nounwind sspstrong willreturn memory(none) uwtable +// CHECK-NEXT: define dso_local noundef i32 @this_gets_hotpatched() +// +// CHECK: ; Function Attrs: mustprogress nofree noinline norecurse nosync nounwind sspstrong willreturn memory(none) uwtable +// CHECK-NEXT: define dso_local noundef i32 @this_does_not_get_hotpatched() + +int __declspec(noinline) this_gets_hotpatched() { + return 42; +} + +int __declspec(noinline) this_does_not_get_hotpatched() { + return this_gets_hotpatched() + 100; +} diff --git a/clang/test/CodeGen/ms-hotpatch.c b/clang/test/CodeGen/ms-hotpatch.c new file mode 100644 index 0000000000000..38376b09bfd44 --- /dev/null +++ b/clang/test/CodeGen/ms-hotpatch.c @@ -0,0 +1,20 @@ +// This verifies that hotpatch function attributes are correctly propagated when compiling directly to OBJ. +// +// RUN: %clang_cl -c --target=x86_64-windows-msvc -O2 /Z7 -fms-hotpatch-functions-list=this_gets_hotpatched /Fo%t.obj %s +// RUN: llvm-readobj --codeview %t.obj | FileCheck %s + +void this_might_have_side_effects(); + +int __declspec(noinline) this_gets_hotpatched() { + this_might_have_side_effects(); + return 42; +} + +// CHECK: Kind: S_HOTPATCHFUNC (0x1169) +// CHECK-NEXT: Function: this_gets_hotpatched + +int __declspec(noinline) this_does_not_get_hotpatched() { + return this_gets_hotpatched() + 100; +} + +// CHECK-NOT: S_HOTPATCHFUNC diff --git a/llvm/include/llvm/Bitcode/LLVMBitCodes.h b/llvm/include/llvm/Bitcode/LLVMBitCodes.h index 9317e6aa793de..d32191d51023a 100644 --- a/llvm/include/llvm/Bitcode/LLVMBitCodes.h +++ b/llvm/include/llvm/Bitcode/LLVMBitCodes.h @@ -793,6 +793,8 @@ enum AttributeKindCodes { ATTR_KIND_NO_DIVERGENCE_SOURCE = 100, ATTR_KIND_SANITIZE_TYPE = 101, ATTR_KIND_CAPTURES = 102, + ATTR_KIND_ALLOW_DIRECT_ACCESS_IN_HOT_PATCH_FUNCTION = 103, + ATTR_KIND_MARKED_FOR_WINDOWS_HOT_PATCHING = 104, }; enum ComdatSelectionKindCodes { diff --git a/llvm/include/llvm/CodeGen/Passes.h b/llvm/include/llvm/CodeGen/Passes.h index d214ab9306c2f..c4163617da5ae 100644 --- a/llvm/include/llvm/CodeGen/Passes.h +++ b/llvm/include/llvm/CodeGen/Passes.h @@ -617,6 +617,9 @@ namespace llvm { /// Lowers KCFI operand bundles for indirect calls. FunctionPass *createKCFIPass(); + + /// Creates Windows Hot Patch pass. \see WindowsHotPatch.cpp + ModulePass *createWindowsHotPatch(); } // End llvm namespace #endif diff --git a/llvm/include/llvm/DebugInfo/CodeView/CodeViewSymbols.def b/llvm/include/llvm/DebugInfo/CodeView/CodeViewSymbols.def index 9d85acc49fa02..b38bdb482df43 100644 --- a/llvm/include/llvm/DebugInfo/CodeView/CodeViewSymbols.def +++ b/llvm/include/llvm/DebugInfo/CodeView/CodeViewSymbols.def @@ -256,6 +256,8 @@ SYMBOL_RECORD_ALIAS(S_GTHREAD32 , 0x1113, GlobalTLS, ThreadLocalDataSym) SYMBOL_RECORD(S_UNAMESPACE , 0x1124, UsingNamespaceSym) SYMBOL_RECORD(S_ANNOTATION , 0x1019, AnnotationSym) +SYMBOL_RECORD(S_HOTPATCHFUNC , 0x1169, HotPatchFuncSym) + #undef CV_SYMBOL #undef SYMBOL_RECORD #undef SYMBOL_RECORD_ALIAS diff --git a/llvm/include/llvm/DebugInfo/CodeView/SymbolRecord.h b/llvm/include/llvm/DebugInfo/CodeView/SymbolRecord.h index 3cce40dcf735a..de80d37999890 100644 --- a/llvm/include/llvm/DebugInfo/CodeView/SymbolRecord.h +++ b/llvm/include/llvm/DebugInfo/CodeView/SymbolRecord.h @@ -176,6 +176,21 @@ class CallerSym : public SymbolRecord { uint32_t RecordOffset = 0; }; +class HotPatchFuncSym : public SymbolRecord { +public: + explicit HotPatchFuncSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {} + HotPatchFuncSym(uint32_t RecordOffset) + : SymbolRecord(SymbolRecordKind::HotPatchFuncSym), + RecordOffset(RecordOffset) {} + + // This is an ItemID in the IPI stream, which points to an LF_FUNC_ID or + // LF_MFUNC_ID record. + TypeIndex Function; + StringRef Name; + + uint32_t RecordOffset = 0; +}; + struct DecodedAnnotation { StringRef Name; ArrayRef Bytes; diff --git a/llvm/include/llvm/IR/Attributes.td b/llvm/include/llvm/IR/Attributes.td index fb94926043fc7..cbb19a41b9702 100644 --- a/llvm/include/llvm/IR/Attributes.td +++ b/llvm/include/llvm/IR/Attributes.td @@ -389,6 +389,17 @@ def CoroDestroyOnlyWhenComplete : EnumAttr<"coro_only_destroy_when_complete", In /// pipeline to perform elide on the call or invoke instruction. def CoroElideSafe : EnumAttr<"coro_elide_safe", IntersectPreserve, [FnAttr]>; +/// Function is marked for Windows Hot Patching +def MarkedForWindowsHotPatching + : EnumAttr<"marked_for_windows_hot_patching", IntersectPreserve, [FnAttr]>; + +/// Global variable should not be accessed through a "__ref_" global variable in +/// a hot patching function This attribute is applied to the global variable +/// decl, not the hotpatched function. +def AllowDirectAccessInHotPatchFunction + : EnumAttr<"allow_direct_access_in_hot_patch_function", + IntersectPreserve, [FnAttr]>; + /// Target-independent string attributes. def LessPreciseFPMAD : StrBoolAttr<"less-precise-fpmad">; def NoInfsFPMath : StrBoolAttr<"no-infs-fp-math">; diff --git a/llvm/include/llvm/InitializePasses.h b/llvm/include/llvm/InitializePasses.h index bff0526d4177a..1a067e6526eb2 100644 --- a/llvm/include/llvm/InitializePasses.h +++ b/llvm/include/llvm/InitializePasses.h @@ -322,6 +322,7 @@ void initializeVirtRegMapWrapperLegacyPass(PassRegistry &); void initializeVirtRegRewriterLegacyPass(PassRegistry &); void initializeWasmEHPreparePass(PassRegistry &); void initializeWinEHPreparePass(PassRegistry &); +void initializeWindowsHotPatchPass(PassRegistry &); void initializeWriteBitcodePassPass(PassRegistry &); void initializeXRayInstrumentationLegacyPass(PassRegistry &); diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp index 4074ed65885c7..46d1f883d5543 100644 --- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp @@ -2248,6 +2248,10 @@ static Attribute::AttrKind getAttrFromCode(uint64_t Code) { return Attribute::NoExt; case bitc::ATTR_KIND_CAPTURES: return Attribute::Captures; + case bitc::ATTR_KIND_ALLOW_DIRECT_ACCESS_IN_HOT_PATCH_FUNCTION: + return Attribute::AllowDirectAccessInHotPatchFunction; + case bitc::ATTR_KIND_MARKED_FOR_WINDOWS_HOT_PATCHING: + return Attribute::MarkedForWindowsHotPatching; } } diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp index 27ada0ddcd831..7e418a522a39e 100644 --- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp @@ -919,6 +919,10 @@ static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) { return bitc::ATTR_KIND_NO_EXT; case Attribute::Captures: return bitc::ATTR_KIND_CAPTURES; + case Attribute::AllowDirectAccessInHotPatchFunction: + return bitc::ATTR_KIND_ALLOW_DIRECT_ACCESS_IN_HOT_PATCH_FUNCTION; + case Attribute::MarkedForWindowsHotPatching: + return bitc::ATTR_KIND_MARKED_FOR_WINDOWS_HOT_PATCHING; case Attribute::EndAttrKinds: llvm_unreachable("Can not encode end-attribute kinds marker."); case Attribute::None: diff --git a/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp b/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp index df4e48571692c..c643bd269f3b1 100644 --- a/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp @@ -627,8 +627,6 @@ void CodeViewDebug::beginModule(Module *M) { CurrentSourceLanguage = MapDWLangToCVLang(CU->getSourceLanguage()); - collectGlobalVariableInfo(); - // Check if we should emit type record hashes. ConstantInt *GH = mdconst::extract_or_null(M->getModuleFlag("CodeViewGHash")); @@ -639,6 +637,8 @@ void CodeViewDebug::endModule() { if (!Asm || !Asm->hasDebugInfo()) return; + collectGlobalVariableInfo(); + // The COFF .debug$S section consists of several subsections, each starting // with a 4-byte control code (e.g. 0xF1, 0xF2, etc) and then a 4-byte length // of the payload followed by the payload itself. The subsections are 4-byte @@ -653,6 +653,8 @@ void CodeViewDebug::endModule() { emitCompilerInformation(); endCVSubsection(CompilerInfo); + emitHotPatchInformation(); + emitInlineeLinesSubsection(); // Emit per-function debug information. @@ -807,6 +809,32 @@ void CodeViewDebug::emitObjName() { endSymbolRecord(CompilerEnd); } +void CodeViewDebug::emitHotPatchInformation() { + MCSymbol *hotPatchInfo = nullptr; + for (const auto &F : MMI->getModule()->functions()) { + if (!F.isDeclarationForLinker() && + F.hasFnAttribute(Attribute::MarkedForWindowsHotPatching)) { + if (hotPatchInfo == nullptr) { + hotPatchInfo = beginCVSubsection(DebugSubsectionKind::Symbols); + } + MCSymbol *HotPatchEnd = beginSymbolRecord(SymbolKind::S_HOTPATCHFUNC); + auto *SP = F.getSubprogram(); + OS.AddComment("Function"); + OS.emitInt32(getFuncIdForSubprogram(SP).getIndex()); + OS.AddComment("Name"); + llvm::StringRef Name = SP->getLinkageName(); + if (Name.empty()) { + Name = F.getName(); + } + emitNullTerminatedSymbolName(OS, Name); + endSymbolRecord(HotPatchEnd); + } + } + if (hotPatchInfo != nullptr) { + endCVSubsection(hotPatchInfo); + } +} + namespace { struct Version { int Part[4]; diff --git a/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h b/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h index 7a138a0332b6d..3cc47b79b5b32 100644 --- a/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h +++ b/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h @@ -333,6 +333,8 @@ class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase { void emitCompilerInformation(); + void emitHotPatchInformation(); + void emitBuildInfo(); void emitInlineeLinesSubsection(); diff --git a/llvm/lib/CodeGen/CMakeLists.txt b/llvm/lib/CodeGen/CMakeLists.txt index 5dd6413431255..f18f085b0450b 100644 --- a/llvm/lib/CodeGen/CMakeLists.txt +++ b/llvm/lib/CodeGen/CMakeLists.txt @@ -250,6 +250,7 @@ add_llvm_component_library(LLVMCodeGen VirtRegMap.cpp WasmEHPrepare.cpp WindowScheduler.cpp + WindowsHotPatch.cpp WinEHPrepare.cpp XRayInstrumentation.cpp ${GeneratedMLSources} diff --git a/llvm/lib/CodeGen/TargetPassConfig.cpp b/llvm/lib/CodeGen/TargetPassConfig.cpp index 0095ce3d96277..22e2e077462ef 100644 --- a/llvm/lib/CodeGen/TargetPassConfig.cpp +++ b/llvm/lib/CodeGen/TargetPassConfig.cpp @@ -893,6 +893,8 @@ void TargetPassConfig::addIRPasses() { if (EnableGlobalMergeFunc) addPass(createGlobalMergeFuncPass()); + + addPass(createWindowsHotPatch()); } /// Turn exception handling constructs into something the code generators can diff --git a/llvm/lib/CodeGen/WindowsHotPatch.cpp b/llvm/lib/CodeGen/WindowsHotPatch.cpp new file mode 100644 index 0000000000000..a21cf6105b275 --- /dev/null +++ b/llvm/lib/CodeGen/WindowsHotPatch.cpp @@ -0,0 +1,295 @@ +//===------ WindowsHotPatch.cpp - Support for Windows hotpatching ---------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// Marks functions with the `marked_for_windows_hot_patching` attribute. +// +//===----------------------------------------------------------------------===// + +#include "llvm/ADT/SmallSet.h" +#include "llvm/CodeGen/Passes.h" +#include "llvm/IR/Attributes.h" +#include "llvm/IR/DIBuilder.h" +#include "llvm/IR/DiagnosticInfo.h" +#include "llvm/IR/Function.h" +#include "llvm/IR/IRBuilder.h" +#include "llvm/IR/InstIterator.h" +#include "llvm/IR/Module.h" +#include "llvm/InitializePasses.h" +#include "llvm/Pass.h" +#include "llvm/Support/CommandLine.h" +#include "llvm/Support/LineIterator.h" +#include "llvm/Support/MemoryBuffer.h" + +using namespace llvm; + +#define DEBUG_TYPE "windows-hot-patch" + +// A file containing list of mangled function names to mark for hot patching. +static cl::opt LLVMMSHotPatchFunctionsFile( + "ms-hotpatch-functions-file", cl::value_desc("filename"), + cl::desc("A file containing list of mangled function names to mark for hot " + "patching")); + +// A list of mangled function names to mark for hot patching. +static cl::list LLVMMSHotPatchFunctionsList( + "ms-hotpatch-functions-list", cl::value_desc("list"), + cl::desc("A list of mangled function names to mark for hot patching"), + cl::CommaSeparated); + +namespace { + +class WindowsHotPatch : public ModulePass { + struct GlobalVariableUse { + GlobalVariable *GV; + Instruction *User; + unsigned Op; + }; + +public: + static char ID; + + WindowsHotPatch() : ModulePass(ID) { + initializeWindowsHotPatchPass(*PassRegistry::getPassRegistry()); + } + + void getAnalysisUsage(AnalysisUsage &AU) const override { + AU.setPreservesCFG(); + } + + bool runOnModule(Module &M) override; + +private: + bool + runOnFunction(Function &F, + SmallDenseMap &RefMapping); +}; + +} // end anonymous namespace + +char WindowsHotPatch::ID = 0; + +INITIALIZE_PASS(WindowsHotPatch, "windows-hot-patch", + "Mark functions for Windows hot patch support", false, false) +ModulePass *llvm::createWindowsHotPatch() { return new WindowsHotPatch(); } + +// Find functions marked with Attribute::MarkedForWindowsHotPatching and modify +// their code (if necessary) to account for accesses to global variables. +bool WindowsHotPatch::runOnModule(Module &M) { + // If the target OS is not Windows, then check that there are no functions + // marked for Windows hot-patching. + if (!M.getTargetTriple().isOSBinFormatCOFF()) { + if (!LLVMMSHotPatchFunctionsFile.empty()) { + M.getContext().diagnose(llvm::DiagnosticInfoGeneric{ + llvm::Twine("--ms-hotpatch-functions-file is only supported when " + "target OS is Windows")}); + } + + if (!LLVMMSHotPatchFunctionsList.empty()) { + M.getContext().diagnose(llvm::DiagnosticInfoGeneric{ + llvm::Twine("--ms-hotpatch-functions-list is only supported when " + "target OS is Windows")}); + } + + // Functions may have already been marked for hot-patching by the front-end. + // Check for any functions marked for hot-patching and report an error if + // any are found. + for (auto &F : M.functions()) { + if (F.hasFnAttribute(Attribute::MarkedForWindowsHotPatching)) { + M.getContext().diagnose(llvm::DiagnosticInfoGeneric{ + llvm::Twine("function is marked for Windows hot-patching, but the " + "target OS is not Windows: ") + + F.getName()}); + } + } + return false; + } + + // The front end may have already marked functions for hot-patching. However, + // we also allow marking functions by passing -ms-hotpatch-functions-file or + // -ms-hotpatch-functions-list directly to LLVM. This allows hot-patching to + // work with languages that have not yet updated their front-ends. + if (!LLVMMSHotPatchFunctionsFile.empty() || + !LLVMMSHotPatchFunctionsList.empty()) { + std::vector HotPatchFunctionsList; + + if (!LLVMMSHotPatchFunctionsFile.empty()) { + auto BufOrErr = llvm::MemoryBuffer::getFile(LLVMMSHotPatchFunctionsFile); + if (BufOrErr) { + const llvm::MemoryBuffer &FileBuffer = **BufOrErr; + for (llvm::line_iterator I(FileBuffer.getMemBufferRef(), true), E; + I != E; ++I) { + auto Line = llvm::StringRef(*I).trim(); + if (!Line.empty()) { + HotPatchFunctionsList.push_back(std::string{Line}); + } + } + } else { + M.getContext().diagnose(llvm::DiagnosticInfoGeneric{ + llvm::Twine("failed to open hotpatch functions file " + "(--ms-hotpatch-functions-file): ") + + LLVMMSHotPatchFunctionsFile + llvm::Twine(" : ") + + BufOrErr.getError().message()}); + } + } + + if (!LLVMMSHotPatchFunctionsList.empty()) { + for (const auto &FuncName : LLVMMSHotPatchFunctionsList) { + HotPatchFunctionsList.push_back(FuncName); + } + } + + // Build a set for quick lookups. This points into HotPatchFunctionsList, so + // HotPatchFunctionsList must live longer than HotPatchFunctionsSet. + llvm::SmallSet HotPatchFunctionsSet; + for (const auto &FuncName : HotPatchFunctionsList) { + HotPatchFunctionsSet.insert(llvm::StringRef{FuncName}); + } + + // Iterate through all of the functions and check whether they need to be + // marked for hotpatching using the list provided directly to LLVM. + for (auto &F : M.functions()) { + // Ignore declarations that are not definitions. + if (F.isDeclarationForLinker()) { + continue; + } + + if (HotPatchFunctionsSet.contains(F.getName())) { + F.addFnAttr(Attribute::MarkedForWindowsHotPatching); + } + } + } + + SmallDenseMap RefMapping; + bool MadeChanges = false; + for (auto &F : M.functions()) { + if (F.hasFnAttribute(Attribute::MarkedForWindowsHotPatching)) { + if (runOnFunction(F, RefMapping)) { + MadeChanges = true; + } + } + } + return MadeChanges; +} + +// Processes a function that is marked for hot-patching. +// +// If a function is marked for hot-patching, we generate an S_HOTPATCHFUNC +// CodeView debug symbol. Tools that generate hot-patches look for +// S_HOTPATCHFUNC in final PDBs so that they can find functions that have been +// hot-patched and so that they can distinguish hot-patched functions from +// non-hot-patched functions. +// +// Also, in functions that are hot-patched, we must indirect all access to +// (mutable) global variables through a pointer. This pointer may point into the +// unpatched ("base") binary or may point into the patched image, depending on +// whether a hot-patch was loaded as a patch or as a base image. These +// indirections go through a new global variable, `named __ref_` where +// `` is the original symbol name of the global variable. +// +// This function handles rewriting accesses to global variables, but the +// generation of S_HOTPATCHFUNC occurs in +// CodeViewDebug::emitHotPatchInformation(). +// +// Returns true if any changes were made to the function. +bool WindowsHotPatch::runOnFunction( + Function &F, + SmallDenseMap &RefMapping) { + // First pass: Find any instructions that reference global variables. We do not modify the IR + // in this pass because we don't want to modify a collection while iterating the same collection. + SmallVector GVUses; + for (auto &I : instructions(F)) { + for (auto &U : I.operands()) { + // Discover all uses of GlobalVariable, these will need to be replaced. + GlobalVariable *GV = dyn_cast(&U); + if ((GV != nullptr) && + !GV->hasAttribute(Attribute::AllowDirectAccessInHotPatchFunction)) { + unsigned OpNo = &U - I.op_begin(); + GVUses.push_back({GV, &I, OpNo}); + } + } + } + + // Most functions do not touch global variables. + if (GVUses.empty()) { + return false; + } + + // For each unique global variable, we create a __ref_FOO global variable that points to it. + // The RefMapping collection maps from a global variable to its __ref_* global variable. + // + // A given function may reference the same global variable more than once, either at different + // instructions or in a loop (or both). During the lifetime of a hotpatched image, these + // __ref_FOO pointers never change. We generate a single load for each unique global variable + // that is used within a given function, and place that load at the start of the function. + // + // This avoids the cost of repeatedly loading each __ref_FOO within a function, such as + // within a hot loop. However, it comes with a minor cost: in each hot-patched function, the + // function will read all of the __ref_FOO pointers that it might need, even if control flow + // never reaches a place that uses a given pointer. This is a minor cost, compared to avoiding + // the cost of repeated fetches in a loop. + + const llvm::DISubprogram *Subprogram = F.getSubprogram(); + DIBuilder DebugInfo{*F.getParent(), true, + Subprogram != nullptr ? Subprogram->getUnit() + : nullptr}; + + auto& EntryBlock = F.getEntryBlock(); + + // Insert loads for __ref_* variables at the start of the entry block. + // Entry blocks can never have PHI nodes, so there is no conflict with PHI nodes at the start. + IRBuilder<> Builder(&EntryBlock, EntryBlock.begin(), nullptr, {}); + + // Maps GlobalVariable (the old one, not the pointer) to the result of a load instruction for that global + SmallDenseMap GVLoadInsts; + + for (auto &GVUse : GVUses) { + LoadInst *&LoadedRefGV = GVLoadInsts.try_emplace(GVUse.GV).first->second; + + if (LoadedRefGV == nullptr) { + // Get or create a new global variable that points to the old one and who's + // name begins with `__ref_`. + GlobalVariable *&ReplaceWithRefGV = + RefMapping.try_emplace(GVUse.GV).first->second; + if (ReplaceWithRefGV == nullptr) { + Constant *AddrOfOldGV = ConstantExpr::getGetElementPtr( + Builder.getPtrTy(), GVUse.GV, ArrayRef{}); + + ReplaceWithRefGV = + new GlobalVariable(*F.getParent(), Builder.getPtrTy(), true, + GlobalValue::InternalLinkage, AddrOfOldGV, + Twine("__ref_").concat(GVUse.GV->getName()), + nullptr, GlobalVariable::NotThreadLocal); + + // Create debug info for the replacement global variable. + DISubprogram *SP = F.getSubprogram(); + DataLayout Layout = F.getParent()->getDataLayout(); + DIType *DebugType = DebugInfo.createPointerType( + nullptr, Layout.getTypeSizeInBits(GVUse.GV->getValueType())); + DIGlobalVariableExpression *GVE = + DebugInfo.createGlobalVariableExpression( + SP != nullptr ? SP->getUnit() : nullptr, + ReplaceWithRefGV->getName(), StringRef{}, + SP != nullptr ? SP->getFile() : nullptr, /*LineNo*/ 0, DebugType, + /*IsLocalToUnit*/ false); + ReplaceWithRefGV->addDebugInfo(GVE); + } + + // Now replace the use of that global variable with the new one (via a load + // since it is a pointer to the old global variable). + LoadedRefGV = Builder.CreateLoad(ReplaceWithRefGV->getValueType(), ReplaceWithRefGV); + } + + GVUse.User->setOperand(GVUse.Op, LoadedRefGV); + } + + if (Subprogram != nullptr) { + DebugInfo.finalize(); + } + + return true; +} diff --git a/llvm/lib/DebugInfo/CodeView/SymbolDumper.cpp b/llvm/lib/DebugInfo/CodeView/SymbolDumper.cpp index f56739db7c75f..9cb3bca8d6e5e 100644 --- a/llvm/lib/DebugInfo/CodeView/SymbolDumper.cpp +++ b/llvm/lib/DebugInfo/CodeView/SymbolDumper.cpp @@ -672,6 +672,13 @@ Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR, return Error::success(); } +Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR, + HotPatchFuncSym &HotPatchFunc) { + printTypeIndex("Function", HotPatchFunc.Function); + W.printString("Name", HotPatchFunc.Name); + return Error::success(); +} + Error CVSymbolDumperImpl::visitUnknownSymbol(CVSymbol &CVR) { W.printNumber("Length", CVR.length()); return Error::success(); diff --git a/llvm/lib/DebugInfo/CodeView/SymbolRecordMapping.cpp b/llvm/lib/DebugInfo/CodeView/SymbolRecordMapping.cpp index b5e366b965a95..525343b90a3ae 100644 --- a/llvm/lib/DebugInfo/CodeView/SymbolRecordMapping.cpp +++ b/llvm/lib/DebugInfo/CodeView/SymbolRecordMapping.cpp @@ -496,6 +496,13 @@ Error SymbolRecordMapping::visitKnownRecord(CVSymbol &CVR, return Error::success(); } +Error SymbolRecordMapping::visitKnownRecord(CVSymbol &CVR, + HotPatchFuncSym &HotPatchFunc) { + error(IO.mapInteger(HotPatchFunc.Function)); + error(IO.mapStringZ(HotPatchFunc.Name)); + return Error::success(); +} + RegisterId codeview::decodeFramePtrReg(EncodedFramePtrReg EncodedReg, CPUType CPU) { assert(unsigned(EncodedReg) < 4); diff --git a/llvm/lib/ObjectYAML/CodeViewYAMLSymbols.cpp b/llvm/lib/ObjectYAML/CodeViewYAMLSymbols.cpp index b15919f68725f..3056251809308 100644 --- a/llvm/lib/ObjectYAML/CodeViewYAMLSymbols.cpp +++ b/llvm/lib/ObjectYAML/CodeViewYAMLSymbols.cpp @@ -605,6 +605,11 @@ template <> void SymbolRecordImpl::map(IO &IO) { IO.mapRequired("EntriesCount", Symbol.EntriesCount); } +template <> void SymbolRecordImpl::map(IO &IO) { + IO.mapRequired("Function", Symbol.Function); + IO.mapRequired("Name", Symbol.Name); +} + } // end namespace detail } // end namespace CodeViewYAML } // end namespace llvm diff --git a/llvm/lib/Transforms/Utils/CodeExtractor.cpp b/llvm/lib/Transforms/Utils/CodeExtractor.cpp index c4894c90c127f..37888210377f2 100644 --- a/llvm/lib/Transforms/Utils/CodeExtractor.cpp +++ b/llvm/lib/Transforms/Utils/CodeExtractor.cpp @@ -938,6 +938,8 @@ Function *CodeExtractor::constructFunctionDeclaration( case Attribute::CoroDestroyOnlyWhenComplete: case Attribute::CoroElideSafe: case Attribute::NoDivergenceSource: + case Attribute::MarkedForWindowsHotPatching: + case Attribute::AllowDirectAccessInHotPatchFunction: continue; // Those attributes should be safe to propagate to the extracted function. case Attribute::AlwaysInline: diff --git a/llvm/test/CodeGen/Generic/ms-hotpatch-attr.ll b/llvm/test/CodeGen/Generic/ms-hotpatch-attr.ll new file mode 100644 index 0000000000000..08fbc073e0716 --- /dev/null +++ b/llvm/test/CodeGen/Generic/ms-hotpatch-attr.ll @@ -0,0 +1,38 @@ +; This tests directly annotating a function with marked_for_windows_hot_patching. +; +; RUN: llc -mtriple=x86_64-windows < %s | FileCheck %s + +source_filename = ".\\ms-hotpatch-attr.ll" +target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-pc-windows-msvc19.36.32537" + +@some_global_var = external global i32 + +define noundef i32 @this_gets_hotpatched() #0 { + %1 = load i32, ptr @some_global_var + %2 = add i32 %1, 1 + ret i32 %2 +} + +attributes #0 = { marked_for_windows_hot_patching mustprogress noinline nounwind optnone uwtable } + +; CHECK: this_gets_hotpatched: # @this_gets_hotpatched +; CHECK-NEXT: bb.0: +; CHECK-NEXT: movq __ref_some_global_var(%rip), %rax +; CHECK-NEXT: movl (%rax), %eax +; CHECK-NEXT: addl $1, %eax +; CHECK-NEXT: retq + +define noundef i32 @this_does_not_get_hotpatched() #1 { + %1 = load i32, ptr @some_global_var + %2 = add i32 %1, 1 + ret i32 %2 +} + +attributes #1 = { mustprogress noinline nounwind optnone uwtable } + +; CHECK: this_does_not_get_hotpatched: # @this_does_not_get_hotpatched +; CHECK-NEXT: bb.0: +; CHECK-NEXT: movl some_global_var(%rip), %eax +; CHECK-NEXT: addl $1, %eax +; CHECK-NEXT: retq diff --git a/llvm/test/CodeGen/Generic/ms-hotpatch-bad-file.ll b/llvm/test/CodeGen/Generic/ms-hotpatch-bad-file.ll new file mode 100644 index 0000000000000..59a83c9040a41 --- /dev/null +++ b/llvm/test/CodeGen/Generic/ms-hotpatch-bad-file.ll @@ -0,0 +1,16 @@ +; RUN: not llc -mtriple=x86_64-windows --ms-hotpatch-functions-file=%S/this-file-is-intentionally-missing-do-not-create-it.txt < %s 2>&1 | FileCheck %s +; CHECK: failed to open hotpatch functions file + +source_filename = ".\\ms-hotpatch.ll" +target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-pc-windows-msvc19.36.32537" + +@some_global_var = external global i32 + +define noundef i32 @this_gets_hotpatched() #0 { + %1 = load i32, ptr @some_global_var + %2 = add i32 %1, 1 + ret i32 %2 +} + +attributes #0 = { marked_for_windows_hot_patching mustprogress noinline nounwind optnone uwtable } diff --git a/llvm/test/CodeGen/Generic/ms-hotpatch-bad-os.ll b/llvm/test/CodeGen/Generic/ms-hotpatch-bad-os.ll new file mode 100644 index 0000000000000..dbcff6e7b91a6 --- /dev/null +++ b/llvm/test/CodeGen/Generic/ms-hotpatch-bad-os.ll @@ -0,0 +1,17 @@ +; This tests directly annotating a function with marked_for_windows_hot_patching, but on the wrong target OS. +; +; RUN: not llc -mtriple=x86_64-unknown-linux --ms-hotpatch-functions-list=this_never_gets_used --ms-hotpatch-functions-file=this_never_gets_used < %s 2>&1 | FileCheck %s +; +; CHECK: error: --ms-hotpatch-functions-file is only supported when target OS is Windows +; CHECK: error: --ms-hotpatch-functions-list is only supported when target OS is Windows +; CHECK: error: function is marked for Windows hot-patching, but the target OS is not Windows: this_gets_hotpatched + +source_filename = ".\\ms-hotpatch-bad-os.ll" +target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-unknown-linux" + +define noundef i32 @this_gets_hotpatched() #0 { + ret i32 0 +} + +attributes #0 = { marked_for_windows_hot_patching mustprogress noinline nounwind optnone uwtable } diff --git a/llvm/test/CodeGen/Generic/ms-hotpatch-direct-global-access.ll b/llvm/test/CodeGen/Generic/ms-hotpatch-direct-global-access.ll new file mode 100644 index 0000000000000..eb8754ee6c3f7 --- /dev/null +++ b/llvm/test/CodeGen/Generic/ms-hotpatch-direct-global-access.ll @@ -0,0 +1,39 @@ +; This tests hotpatching functions that bypass double-indirection for global variables. +; +; RUN: llc -mtriple=x86_64-windows < %s | FileCheck %s + +source_filename = ".\\ms-hotpatch-direct-global-access.ll" +target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-pc-windows-msvc19.36.32537" + +@some_global_var = external global i32 #2 + +define noundef i32 @this_gets_hotpatched() #0 { + %1 = load i32, ptr @some_global_var + %2 = add i32 %1, 1 + ret i32 %2 +} + +attributes #0 = { marked_for_windows_hot_patching mustprogress noinline nounwind optnone uwtable } + +; CHECK: this_gets_hotpatched: # @this_gets_hotpatched +; CHECK-NEXT: bb.0: +; CHECK-NEXT: movl some_global_var(%rip), %eax +; CHECK-NEXT: addl $1, %eax +; CHECK-NEXT: retq + +define noundef i32 @this_does_not_get_hotpatched() #1 { + %1 = load i32, ptr @some_global_var + %2 = add i32 %1, 1 + ret i32 %2 +} + +attributes #1 = { mustprogress noinline nounwind optnone uwtable } + +attributes #2 = { allow_direct_access_in_hot_patch_function } + +; CHECK: this_does_not_get_hotpatched: # @this_does_not_get_hotpatched +; CHECK-NEXT: bb.0: +; CHECK-NEXT: movl some_global_var(%rip), %eax +; CHECK-NEXT: addl $1, %eax +; CHECK-NEXT: retq diff --git a/llvm/test/CodeGen/Generic/ms-hotpatch-functions-file.ll b/llvm/test/CodeGen/Generic/ms-hotpatch-functions-file.ll new file mode 100644 index 0000000000000..0c7e456d6f208 --- /dev/null +++ b/llvm/test/CodeGen/Generic/ms-hotpatch-functions-file.ll @@ -0,0 +1,39 @@ +; This tests annotating a function with marked_for_windows_hot_patching by using --ms-hotpatch-functions-file. +; +; RUN: echo this_gets_hotpatched > %t.ms-hotpatch-functions-file.txt +; RUN: llc -mtriple=x86_64-windows --ms-hotpatch-functions-file=%t.ms-hotpatch-functions-file.txt < %s | FileCheck %s + +source_filename = ".\\ms-hotpatch-functions-file.ll" +target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-pc-windows-msvc19.36.32537" + +@some_global_var = external global i32 + +define noundef i32 @this_gets_hotpatched() #0 { + %1 = load i32, ptr @some_global_var + %2 = add i32 %1, 1 + ret i32 %2 +} + +attributes #0 = { mustprogress noinline nounwind optnone uwtable } + +; CHECK: this_gets_hotpatched: # @this_gets_hotpatched +; CHECK-NEXT: bb.0: +; CHECK-NEXT: movq __ref_some_global_var(%rip), %rax +; CHECK-NEXT: movl (%rax), %eax +; CHECK-NEXT: addl $1, %eax +; CHECK-NEXT: retq + +define noundef i32 @this_does_not_get_hotpatched() #1 { + %1 = load i32, ptr @some_global_var + %2 = add i32 %1, 1 + ret i32 %2 +} + +attributes #1 = { mustprogress noinline nounwind optnone uwtable } + +; CHECK: this_does_not_get_hotpatched: # @this_does_not_get_hotpatched +; CHECK-NEXT: bb.0: +; CHECK-NEXT: movl some_global_var(%rip), %eax +; CHECK-NEXT: addl $1, %eax +; CHECK-NEXT: retq diff --git a/llvm/test/CodeGen/Generic/ms-hotpatch-functions-list.ll b/llvm/test/CodeGen/Generic/ms-hotpatch-functions-list.ll new file mode 100644 index 0000000000000..c5565824cbe6c --- /dev/null +++ b/llvm/test/CodeGen/Generic/ms-hotpatch-functions-list.ll @@ -0,0 +1,38 @@ +; This tests annotating a function with marked_for_windows_hot_patching by using --ms-hotpatch-functions-list. +; +; RUN: llc -mtriple=x86_64-windows --ms-hotpatch-functions-list=this_gets_hotpatched < %s | FileCheck %s + +source_filename = ".\\ms-hotpatch-functions-list.ll" +target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-pc-windows-msvc19.36.32537" + +@some_global_var = external global i32 + +define noundef i32 @this_gets_hotpatched() #0 { + %1 = load i32, ptr @some_global_var + %2 = add i32 %1, 1 + ret i32 %2 +} + +attributes #0 = { mustprogress noinline nounwind optnone uwtable } + +; CHECK: this_gets_hotpatched: # @this_gets_hotpatched +; CHECK-NEXT: bb.0: +; CHECK-NEXT: movq __ref_some_global_var(%rip), %rax +; CHECK-NEXT: movl (%rax), %eax +; CHECK-NEXT: addl $1, %eax +; CHECK-NEXT: retq + +define noundef i32 @this_does_not_get_hotpatched() #1 { + %1 = load i32, ptr @some_global_var + %2 = add i32 %1, 1 + ret i32 %2 +} + +attributes #1 = { mustprogress noinline nounwind optnone uwtable } + +; CHECK: this_does_not_get_hotpatched: # @this_does_not_get_hotpatched +; CHECK-NEXT: bb.0: +; CHECK-NEXT: movl some_global_var(%rip), %eax +; CHECK-NEXT: addl $1, %eax +; CHECK-NEXT: retq diff --git a/llvm/tools/llvm-pdbutil/MinimalSymbolDumper.cpp b/llvm/tools/llvm-pdbutil/MinimalSymbolDumper.cpp index 479d025835188..66a091f50d6b2 100644 --- a/llvm/tools/llvm-pdbutil/MinimalSymbolDumper.cpp +++ b/llvm/tools/llvm-pdbutil/MinimalSymbolDumper.cpp @@ -955,3 +955,11 @@ Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, JumpTable.EntriesCount); return Error::success(); } + +Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR, + HotPatchFuncSym &JumpTable) { + AutoIndent Indent(P, 7); + P.formatLine("function = {0}, name = {1}", typeIndex(JumpTable.Function), + JumpTable.Name); + return Error::success(); +}