[clang][debug] port clang-cl /JMC flag to ELF

[ychen]

Summary

The motivation is to enable the MSVC-style JMC instrumentation usable by a ELF-based
debugger. Since there is no prior experience implementing JMC feature for ELF-based
debugger, it might be better to just reuse existing MSVC-style JMC instrumentation.
For debuggers that support both ELF&COFF (like lldb), the JMC implementation might
be shared between ELF&COFF. If this is found to inadequate, it is pretty low-cost
switching to alternatives.

Implementation:

• The '-fjmc' is already a driver and cc1 flag. Wire it up for ELF in the driver.
• Refactor the JMC instrumentation pass a little bit.
• The ELF handling is different from MSVC in two places:
  • the flag section name is ".just.my.code" instead of ".msvcjmc"
  • the way default function is provided: MSVC uses /alternatename; ELF uses weak function.

Based on D118428.

[labath]

Not my usual wheelhouse, but since I'm here, here are some of my thoughts:

• reusing the existing solution/code seems like a good idea -- no need to reinvent the wheel
• how does that work, actually? How does it differentiate between "my" code and "code that happens to be compiled in the current CU" (e.g. the STL). What's the significance of the funky __XXXXXXXX_x@c symbols?
• if the goal is to integrate this into lldb (and given that lldb currently does not support any feature like this), I'd recommend sending an RFC/heads up early, to identify possible issues

[ychen]

• how does that work, actually? How does it differentiate between "my" code and "code that happens to be compiled in the current CU" (e.g. the STL). What's the significance of the funky __XXXXXXXX_x@c symbols?

The non-user code is specified by a config file (https://docs.microsoft.com/en-us/visualstudio/debugger/just-my-code?view=vs-2022#BKMK_CPP_Customize_call_stack_behavior). Then the debugger would know user/non-user code by looking at the debuginfo. The boolean __XXXXXXXX_x@c symbol has a one-to-one mapping to a source file. For all functions defined in the corresponding source file, it decides if a breakpoint would be hit. It is the JMC_flag in https://github.com/ojdkbuild/tools_toolchain_vs2017bt_1416/blob/master/VC/Tools/MSVC/14.16.27023/crt/src/vcruntime/debugger_jmc.c.

• if the goal is to integrate this into lldb (and given that lldb currently does not support any feature like this), I'd recommend sending an RFC/heads up early, to identify possible issues

The goal is to make the feature usable by an ELF-based compiler(actually we have a downstream debugger that needed this. lldb/gdb as well). I think this could benefit upstream debuggers hence this patch. I'll send an RFC. Thanks.

[ychen]

RFC sent: https://discourse.llvm.org/t/rfc-just-my-code-stepping-for-non-msvc-debuggers/60279

[ychen]

Gentle ping...

[rnk]

clang/lib/Driver/ToolChains/Clang.cpp

5396

Generally all flags have an fno- variant. Normally, this would be hasFlag(OPT_fjmc, OPT_fno_jmc, false), which handles the behavior of making the last flag win. Any reason not to set that up?

llvm/lib/CodeGen/JMCInstrumenter.cpp

177

This is a bit pedantic, but the idea is that this weak function will be overridden with a strong function, right? Technically, for that use case, weak linkage is the correct linkage. Because the JMC pass runs late after inlining, it is unlikely that this will ever cause issues in practice, but I think it expresses the intention better to use the linkage that matches the use case.

ODR linkage is supposed to indicate that all definitions must be functionally equivalent. It just turns out that the only real power that grants the optimizer is the ability to inline.

llvm/test/Instrumentation/JustMyCode/jmc-instrument-elf.ll

1–2

Please remove the REQUIRES line, this test should pass on Windows, and the other test should pass on Linux as well. Neither of these tests depend on anything from the system.

[ychen]

clang/lib/Driver/ToolChains/Clang.cpp

5396

I missed that. Before this port, fjmc is supposed to be used as cc1 option only. With this port, it is also a driver option now. I'll add the no-variant.

llvm/lib/CodeGen/JMCInstrumenter.cpp

177

Agreed. I'll change it to weak linkage.

llvm/test/Instrumentation/JustMyCode/jmc-instrument-elf.ll

1–2

Yeah, this is a little tricky. It is about the host rather than the target. The flag symbol name is computed using sys::path functions. It is different between Windows and Linux. For testing purposes, I need to anchor them to a specific system to check the result. I could've made this ; REQUIRES: system-windows and check the result, I thought it is more intuitive to test the ELF on Linux.

[ychen]

• Address Reid's comments

[ychen]

@rnk, thanks for taking a look. Patch updated.

[rnk]

llvm/lib/CodeGen/JMCInstrumenter.cpp

72

These sys::path calls introduce host-dependence, and that should be eliminated

llvm/test/Instrumentation/JustMyCode/jmc-instrument-elf.ll

1–2

That seems like a bug. LLVM optimization and code generation should not depend on the host. This is a requirement for distributed build systems, which may migrate inputs to other machines, cross compile, and expect the results to match local compilation.

[rnk]

Looks like I hit submit too early...

I wanted to say the path thing is a pre-existing issue, and it seems reasonable to address that as a separate patch. If you don't have plans to do a follow up patch, please file a bug about it, and maybe I can hand it off to someone.

[ychen]

llvm/test/Instrumentation/JustMyCode/jmc-instrument-elf.ll

1–2

The symbol names are host-dependent. It does not depend on the host to work correctly though. It works on both Windows and Linux.

[rnk]

llvm/test/Instrumentation/JustMyCode/jmc-instrument-elf.ll

1–2

Yes, you say they are host dependent, I see that, but I don't think that's a requirement. opt should be a pure function of its inputs. The paths are in the debug info, it shouldn't let the environment leak into the compilation.

[ychen]

llvm/test/Instrumentation/JustMyCode/jmc-instrument-elf.ll

1–2

Great point. This is not ideal in principle. For the distributed build, this may break if the remote and host compilation uses different environments like Windows/Linux. I'll create a follow-up patch.

[ychen]

llvm/test/Instrumentation/JustMyCode/jmc-instrument-elf.ll

1–2

Filed https://github.com/llvm/llvm-project/issues/54219 to follow up on the bug.

[thakis]

Looks like this breaks tests on mac and win:
http://45.33.8.238/win/54551/step_7.txt
http://45.33.8.238/macm1/29590/step_7.txt

Please take a look, and revert for now if it takes a while to fix.

[ychen]

In D119910#3364892, @thakis wrote:

Looks like this breaks tests on mac and win:
http://45.33.8.238/win/54551/step_7.txt
http://45.33.8.238/macm1/29590/step_7.txt

Please take a look, and revert for now if it takes a while to fix.

Thanks for the report. I'm looking at it.

[ychen]

In D119910#3364920, @ychen wrote:

In D119910#3364892, @thakis wrote:

Looks like this breaks tests on mac and win:
http://45.33.8.238/win/54551/step_7.txt
http://45.33.8.238/macm1/29590/step_7.txt

Please take a look, and revert for now if it takes a while to fix.

Thanks for the report. I'm looking at it.

Recommited as eddd94c27df609113af1d1b795d8483aa6dd662c

clang/include/clang/Basic/DiagnosticDriverKinds.td

 def err_drv_only_one_offload_target_supported : Error<
   "only one offload target is supported">;
 def err_drv_invalid_or_unsupported_offload_target : Error<
   "invalid or unsupported offload target: '%0'">;
 def err_drv_cuda_offload_only_emit_bc : Error<
   "CUDA offload target is supported only along with --emit-llvm">;
 
 def warn_drv_jmc_requires_debuginfo : Warning<
-  "/JMC requires debug info. Use '/Zi', '/Z7' or other debug options; option ignored">,
+  "%0 requires debug info. Use %1 or debug options that enable debugger's "
+  "stepping function; option ignored">,
   InGroup<OptionIgnored>;
 
 def err_drv_target_variant_invalid : Error<
   "unsupported '%0' value '%1'; use 'ios-macabi' instead">;
 
 }

clang/include/clang/Driver/Options.td

 def fno_elide_type : Flag<["-"], "fno-elide-type">, Group<f_Group>,
     Flags<[CC1Option]>,
     HelpText<"Do not elide types when printing diagnostics">,
     MarshallingInfoNegativeFlag<DiagnosticOpts<"ElideType">>;
 def feliminate_unused_debug_symbols : Flag<["-"], "feliminate-unused-debug-symbols">, Group<f_Group>;
 def fjmc : Flag<["-"], "fjmc">, Group<f_Group>,Flags<[CC1Option]>,
     HelpText<"Enable just-my-code debugging">,
     MarshallingInfoFlag<CodeGenOpts<"JMCInstrument">>;
+def fno_jmc : Flag<["-"], "fno-jmc">, Group<f_Group>, Flags<[CC1Option]>;
 defm eliminate_unused_debug_types : OptOutCC1FFlag<"eliminate-unused-debug-types",
   "Do not emit ", "Emit ", " debug info for defined but unused types">;
 def femit_all_decls : Flag<["-"], "femit-all-decls">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Emit all declarations, even if unused">,
   MarshallingInfoFlag<LangOpts<"EmitAllDecls">>;
 defm emulated_tls : BoolFOption<"emulated-tls",
   CodeGenOpts<"EmulatedTLS">, DefaultFalse,
   PosFlag<SetTrue, [CC1Option], "Use emutls functions to access thread_local variables">,

clang/lib/Driver/ToolChains/Clang.cpp

#endif
   if (D.IsCLMode())
     AddClangCLArgs(Args, InputType, CmdArgs, &DebugInfoKind, &EmitCodeView);
 
   DwarfFissionKind DwarfFission = DwarfFissionKind::None;
   renderDebugOptions(TC, D, RawTriple, Args, EmitCodeView,
                      types::isLLVMIR(InputType), CmdArgs, DebugInfoKind,
                      DwarfFission);
 
+  // This controls whether or not we perform JustMyCode instrumentation.
+  if (TC.getTriple().isOSBinFormatELF() &&
+      Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc, false)) {
+    if (DebugInfoKind >= codegenoptions::DebugInfoConstructor)
+      CmdArgs.push_back("-fjmc");
+    else
+      D.Diag(clang::diag::warn_drv_jmc_requires_debuginfo) << "-fjmc"
+                                                           << "-g";
+  }
+
   // Add the split debug info name to the command lines here so we
   // can propagate it to the backend.
   bool SplitDWARF = (DwarfFission != DwarfFissionKind::None) &&
                     (TC.getTriple().isOSBinFormatELF() ||
                      TC.getTriple().isOSBinFormatWasm()) &&
                     (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
                      isa<BackendJobAction>(JA));
   if (SplitDWARF) {
void Clang::AddClangCLArgs(const ArgList &Args, types::ID InputType,
   const Driver &D = getToolChain().getDriver();
 
   // This controls whether or not we perform JustMyCode instrumentation.
   if (Args.hasFlag(options::OPT__SLASH_JMC, options::OPT__SLASH_JMC_,
                    /*Default=*/false)) {
     if (*EmitCodeView && *DebugInfoKind >= codegenoptions::DebugInfoConstructor)
       CmdArgs.push_back("-fjmc");
     else
-      D.Diag(clang::diag::warn_drv_jmc_requires_debuginfo);
+      D.Diag(clang::diag::warn_drv_jmc_requires_debuginfo) << "/JMC"
+                                                           << "'/Zi', '/Z7'";
   }
 
   EHFlags EH = parseClangCLEHFlags(D, Args);
   if (!isNVPTX && (EH.Synch || EH.Asynch)) {
     if (types::isCXX(InputType))
       CmdArgs.push_back("-fcxx-exceptions");
     CmdArgs.push_back("-fexceptions");
   }

clang/test/Driver/cl-options.c

 // FAKEDIR: "-libpath:/foo{{/|\\\\}}Lib{{/|\\\\}}10.0.12345.0{{/|\\\\}}um
 
 // Accept both the -target and --target= spellings.
 // RUN: %clang_cl --target=i686-pc-windows-msvc19.14.0 -### -- %s 2>&1 | FileCheck -check-prefix=TARGET %s
 // RUN: %clang_cl -target i686-pc-windows-msvc19.14.0  -### -- %s 2>&1 | FileCheck -check-prefix=TARGET %s
 // TARGET: "-triple" "i686-pc-windows-msvc19.14.0"
 
 // RUN: %clang_cl /JMC /c -### -- %s 2>&1 | FileCheck %s --check-prefix JMCWARN
-// JMCWARN: /JMC requires debug info. Use '/Zi', '/Z7' or other debug options; option ignored
+// JMCWARN: /JMC requires debug info. Use '/Zi', '/Z7' or debug options that enable debugger's stepping function; option ignored
 
 // RUN: %clang_cl /JMC /c -### -- %s 2>&1 | FileCheck %s --check-prefix NOJMC
 // RUN: %clang_cl /JMC /Z7 /JMC- /c -### -- %s 2>&1 | FileCheck %s --check-prefix NOJMC
 // NOJMC-NOT: -fjmc
 
 // RUN: %clang_cl /JMC /Z7 /c -### -- %s 2>&1 | FileCheck %s --check-prefix JMC
 // JMC: -fjmc
 
 void f(void) { }

clang/test/Driver/clang_f_opts.c

 
 // RUN: %clang -### -S -fno-temp-file %s 2>&1 | FileCheck -check-prefix=CHECK-NO-TEMP-FILE %s
 // CHECK-NO-TEMP-FILE: "-fno-temp-file"
 
 // RUN: %clang -### -xobjective-c -fobjc-disable-direct-methods-for-testing %s 2>&1 | FileCheck -check-prefix=CHECK_DISABLE_DIRECT %s
 // RUN: %clang -### -xobjective-c %s 2>&1 | FileCheck -check-prefix=CHECK_NO_DISABLE_DIRECT %s
 // CHECK_DISABLE_DIRECT: -fobjc-disable-direct-methods-for-testing
 // CHECK_NO_DISABLE_DIRECT-NOT: -fobjc-disable-direct-methods-for-testing
+
+// RUN: %clang -### -S -fjmc %s 2>&1 | FileCheck -check-prefixes=CHECK_JMC_WARN,CHECK_NOJMC %s
+// RUN: %clang -### -S -fjmc -g %s 2>&1 | FileCheck -check-prefix=CHECK_JMC %s
+// RUN: %clang -### -S -fjmc -g -fno-jmc %s 2>&1 | FileCheck -check-prefix=CHECK_NOJMC %s
+// CHECK_JMC_WARN: -fjmc requires debug info. Use -g or debug options that enable debugger's stepping function; option ignored
+// CHECK_NOJMC-NOT: -fjmc
+// CHECK_JMC: -fjmc

llvm/lib/CodeGen/JMCInstrumenter.cpp

 //===- JMCInstrumenter.cpp - JMC Instrumentation --------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // JMCInstrumenter pass:
-// - add "/alternatename:__CheckForDebuggerJustMyCode=__JustMyCode_Default" to
-//   "llvm.linker.options"
-// - create the dummy COMDAT function __JustMyCode_Default
 // - instrument each function with a call to __CheckForDebuggerJustMyCode. The
 //   sole argument should be defined in .msvcjmc. Each flag is 1 byte initilized
 //   to 1.
-// - (TODO) currently targeting MSVC, adds ELF debuggers support
-//
+// - create the dummy COMDAT function __JustMyCode_Default to prevent linking
+//   error if __CheckForDebuggerJustMyCode is not available.
+// - For MSVC:
+//   add "/alternatename:__CheckForDebuggerJustMyCode=__JustMyCode_Default" to
+//   "llvm.linker.options"
+//   For ELF:
+//   Rename __JustMyCode_Default to __CheckForDebuggerJustMyCode and mark it as
+//   weak symbol.
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DerivedTypes.h"

 
 std::string getFlagName(DISubprogram &SP, bool UseX86FastCall) {
   // Best effort path normalization. This is to guarantee an unique flag symbol
   // is produced for the same directory. Some builds may want to use relative
   // paths, or paths with a specific prefix (see the -fdebug-compilation-dir
   // flag), so only hash paths in debuginfo. Don't expand them to absolute
   // paths.
   SmallString<256> FilePath(SP.getDirectory());
   sys::path::append(FilePath, SP.getFilename());
   sys::path::native(FilePath);
   sys::path::remove_dots(FilePath, /*remove_dot_dot=*/true);
 
   // The naming convention for the flag name is __<hash>_<file name> with '.' in
   // <file name> replaced with '@'. For example C:\file.any.c would have a flag
   // __D032E919_file@any@c. The naming convention match MSVC's format however
   // the match is not required to make JMC work. The hashing function used here
   // is different from MSVC's.

 }
 
 FunctionType *getCheckFunctionType(LLVMContext &Ctx) {
   Type *VoidTy = Type::getVoidTy(Ctx);
   PointerType *VoidPtrTy = Type::getInt8PtrTy(Ctx);
   return FunctionType::get(VoidTy, VoidPtrTy, false);
 }
 
-void createDefaultCheckFunction(Module &M, bool UseX86FastCall) {
+Function *createDefaultCheckFunction(Module &M, bool UseX86FastCall) {
   LLVMContext &Ctx = M.getContext();
   const char *DefaultCheckFunctionName =
       UseX86FastCall ? "_JustMyCode_Default" : "__JustMyCode_Default";
   // Create the function.
   Function *DefaultCheckFunc =
       Function::Create(getCheckFunctionType(Ctx), GlobalValue::ExternalLinkage,
                        DefaultCheckFunctionName, &M);
   DefaultCheckFunc->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   DefaultCheckFunc->addParamAttr(0, Attribute::NoUndef);
   if (UseX86FastCall)
     DefaultCheckFunc->addParamAttr(0, Attribute::InReg);
-  appendToUsed(M, {DefaultCheckFunc});
-  Comdat *C = M.getOrInsertComdat(DefaultCheckFunctionName);
-  C->setSelectionKind(Comdat::Any);
-  DefaultCheckFunc->setComdat(C);
+
   BasicBlock *EntryBB = BasicBlock::Create(Ctx, "", DefaultCheckFunc);
   ReturnInst::Create(Ctx, EntryBB);
-
-  // Add a linker option /alternatename to set the default implementation for
-  // the check function.
-  // https://devblogs.microsoft.com/oldnewthing/20200731-00/?p=104024
-  std::string AltOption = std::string("/alternatename:") + CheckFunctionName +
-                          "=" + DefaultCheckFunctionName;
-  llvm::Metadata *Ops[] = {llvm::MDString::get(Ctx, AltOption)};
-  MDTuple *N = MDNode::get(Ctx, Ops);
-  M.getOrInsertNamedMetadata("llvm.linker.options")->addOperand(N);
+  return DefaultCheckFunc;
 }
 } // namespace
 
 bool JMCInstrumenter::runOnModule(Module &M) {
   bool Changed = false;
   LLVMContext &Ctx = M.getContext();
   Triple ModuleTriple(M.getTargetTriple());
-  bool UseX86FastCall =
-      ModuleTriple.isOSWindows() && ModuleTriple.getArch() == Triple::x86;
+  bool IsMSVC = ModuleTriple.isKnownWindowsMSVCEnvironment();
+  bool IsELF = ModuleTriple.isOSBinFormatELF();
+  assert((IsELF || IsMSVC) && "Unsupported triple for JMC");
+  bool UseX86FastCall = IsMSVC && ModuleTriple.getArch() == Triple::x86;
+  const char *const FlagSymbolSection = IsELF ? ".just.my.code" : ".msvcjmc";
 
-  Function *CheckFunction = nullptr;
+  GlobalValue *CheckFunction = nullptr;
   DenseMap<DISubprogram *, Constant *> SavedFlags(8);
   for (auto &F : M) {
     if (F.isDeclaration())
       continue;
     auto *SP = F.getSubprogram();
     if (!SP)
       continue;
 
     Constant *&Flag = SavedFlags[SP];
     if (!Flag) {
       std::string FlagName = getFlagName(*SP, UseX86FastCall);
       IntegerType *FlagTy = Type::getInt8Ty(Ctx);
       Flag = M.getOrInsertGlobal(FlagName, FlagTy, [&] {
         // FIXME: Put the GV in comdat and have linkonce_odr linkage to save
         //        .msvcjmc section space? maybe not worth it.
         GlobalVariable *GV = new GlobalVariable(
             M, FlagTy, /*isConstant=*/false, GlobalValue::InternalLinkage,
             ConstantInt::get(FlagTy, 1), FlagName);
-        GV->setSection(".msvcjmc");
+        GV->setSection(FlagSymbolSection);
         GV->setAlignment(Align(1));
         GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
         attachDebugInfo(*GV, *SP);
         return GV;
       });
     }
 
     if (!CheckFunction) {
+      Function *DefaultCheckFunc =
+          createDefaultCheckFunction(M, UseX86FastCall);
+      if (IsELF) {
+        DefaultCheckFunc->setName(CheckFunctionName);
+        DefaultCheckFunc->setLinkage(GlobalValue::WeakAnyLinkage);
+        CheckFunction = DefaultCheckFunc;
+      } else {
         assert(!M.getFunction(CheckFunctionName) &&
                "JMC instrument more than once?");
-      CheckFunction = cast<Function>(
+        auto *CheckFunc = cast<Function>(
             M.getOrInsertFunction(CheckFunctionName, getCheckFunctionType(Ctx))
                 .getCallee());
-      CheckFunction->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
-      CheckFunction->addParamAttr(0, Attribute::NoUndef);
+        CheckFunc->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
+        CheckFunc->addParamAttr(0, Attribute::NoUndef);
         if (UseX86FastCall) {
-        CheckFunction->setCallingConv(CallingConv::X86_FastCall);
-        CheckFunction->addParamAttr(0, Attribute::InReg);
+          CheckFunc->setCallingConv(CallingConv::X86_FastCall);
+          CheckFunc->addParamAttr(0, Attribute::InReg);
+        }
+        CheckFunction = CheckFunc;
+
+        StringRef DefaultCheckFunctionName = DefaultCheckFunc->getName();
+        appendToUsed(M, {DefaultCheckFunc});
+        Comdat *C = M.getOrInsertComdat(DefaultCheckFunctionName);
+        C->setSelectionKind(Comdat::Any);
+        DefaultCheckFunc->setComdat(C);
+        // Add a linker option /alternatename to set the default implementation
+        // for the check function.
+        // https://devblogs.microsoft.com/oldnewthing/20200731-00/?p=104024
+        std::string AltOption = std::string("/alternatename:") +
+                                CheckFunctionName + "=" +
+                                DefaultCheckFunctionName.str();
+        llvm::Metadata *Ops[] = {llvm::MDString::get(Ctx, AltOption)};
+        MDTuple *N = MDNode::get(Ctx, Ops);
+        M.getOrInsertNamedMetadata("llvm.linker.options")->addOperand(N);
       }
     }
     // FIXME: it would be nice to make CI scheduling boundary, although in
     //        practice it does not matter much.
-    auto *CI = CallInst::Create(CheckFunction, {Flag}, "",
-                                &*F.begin()->getFirstInsertionPt());
+    auto *CI = CallInst::Create(getCheckFunctionType(Ctx), CheckFunction,
+                                {Flag}, "", &*F.begin()->getFirstInsertionPt());
     CI->addParamAttr(0, Attribute::NoUndef);
     if (UseX86FastCall) {
       CI->setCallingConv(CallingConv::X86_FastCall);
       CI->addParamAttr(0, Attribute::InReg);
     }
 
     Changed = true;
   }
-  if (!Changed)
-    return false;
-
-  createDefaultCheckFunction(M, UseX86FastCall);
-  return true;
+  return Changed;
 }

llvm/test/Instrumentation/JustMyCode/jmc-instrument-elf.ll

-; REQUIRES: system-windows
-; RUN: opt -jmc-instrument -mtriple=x86_64-pc-windows-msvc  -S < %s | FileCheck %s
-; RUN: opt -jmc-instrument -mtriple=aarch64-pc-windows-msvc -S < %s | FileCheck %s
-; RUN: opt -jmc-instrument -mtriple=arm-pc-windows-msvc     -S < %s | FileCheck %s
+; REQUIRES: system-linux
+; RUN: opt -jmc-instrument -mtriple=x86_64-unknown-linux-gnu  -S < %s | FileCheck %s
 
-; CHECK: $__JustMyCode_Default = comdat any
+; CHECK: @"__7DF23CF5_x@c" = internal unnamed_addr global i8 1, section ".just.my.code", align 1, !dbg !0
+; CHECK: @"__A85D9D03_x@c" = internal unnamed_addr global i8 1, section ".just.my.code", align 1, !dbg !5
 
-; CHECK: @"__E6EA670F_x@c" = internal unnamed_addr global i8 1, section ".msvcjmc", align 1, !dbg !0
-; CHECK: @"__A8764FDD_x@c" = internal unnamed_addr global i8 1, section ".msvcjmc", align 1, !dbg !5
-; CHECK: @llvm.used = appending global [1 x i8*] [i8* bitcast (void (i8*)* @__JustMyCode_Default to i8*)], section "llvm.metadata"
-
-; CHECK: define void @l1() !dbg !13 {
-; CHECK:   call void @__CheckForDebuggerJustMyCode(i8* noundef @"__E6EA670F_x@c")
+; CHECK: define void @l1() !dbg !12 {
+; CHECK:   call void @__CheckForDebuggerJustMyCode(i8* noundef @"__7DF23CF5_x@c")
 ; CHECK:   ret void
 ; CHECK: }
 
-; CHECK: define void @l2() !dbg !17 {
-; CHECK:   call void @__CheckForDebuggerJustMyCode(i8* noundef @"__E6EA670F_x@c")
+; CHECK: define void @l2() !dbg !16 {
+; CHECK:   call void @__CheckForDebuggerJustMyCode(i8* noundef @"__7DF23CF5_x@c")
 ; CHECK:   ret void
 ; CHECK: }
 
-; CHECK: define void @w1() !dbg !19 {
-; CHECK:   call void @__CheckForDebuggerJustMyCode(i8* noundef @"__A8764FDD_x@c")
+; CHECK: define void @w1() !dbg !18 {
+; CHECK:   call void @__CheckForDebuggerJustMyCode(i8* noundef @"__A85D9D03_x@c")
 ; CHECK:   ret void
 ; CHECK: }
 
-; CHECK: define void @w2() !dbg !20 {
-; CHECK:   call void @__CheckForDebuggerJustMyCode(i8* noundef @"__A8764FDD_x@c")
+; CHECK: define void @w2() !dbg !19 {
+; CHECK:   call void @__CheckForDebuggerJustMyCode(i8* noundef @"__A85D9D03_x@c")
 ; CHECK:   ret void
 ; CHECK: }
 
-; CHECK: define void @w3() !dbg !22 {
-; CHECK:   call void @__CheckForDebuggerJustMyCode(i8* noundef @"__A8764FDD_x@c")
+; CHECK: define void @w3() !dbg !21 {
+; CHECK:   call void @__CheckForDebuggerJustMyCode(i8* noundef @"__A85D9D03_x@c")
 ; CHECK:   ret void
 ; CHECK: }
 
-; CHECK: define void @w4() !dbg !24 {
-; CHECK:   call void @__CheckForDebuggerJustMyCode(i8* noundef @"__A8764FDD_x@c")
+; CHECK: define void @w4() !dbg !23 {
+; CHECK:   call void @__CheckForDebuggerJustMyCode(i8* noundef @"__A85D9D03_x@c")
 ; CHECK:   ret void
 ; CHECK: }
 
-; CHECK: declare void @__CheckForDebuggerJustMyCode(i8* noundef) unnamed_addr
-
-; CHECK: define void @__JustMyCode_Default(i8* noundef %0) unnamed_addr comdat {
+; CHECK: define weak void @__CheckForDebuggerJustMyCode(i8* noundef %0) unnamed_addr {
 ; CHECK:   ret void
 ; CHECK: }
 
-; CHECK: !llvm.linker.options = !{!12}
+; CHECK: !llvm.dbg.cu = !{!2}
+; CHECK: !llvm.module.flags = !{!9, !10}
+; CHECK: !llvm.ident = !{!11}
 
 ; CHECK: !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
-; CHECK: !1 = distinct !DIGlobalVariable(name: "__E6EA670F_x@c", scope: !2, file: !3, type: !8, isLocal: true, isDefinition: true)
+; CHECK: !1 = distinct !DIGlobalVariable(name: "__7DF23CF5_x@c", scope: !2, file: !3, type: !8, isLocal: true, isDefinition: true)
 ; CHECK: !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
 ; CHECK: !3 = !DIFile(filename: "a/x.c", directory: "/tmp")
 ; CHECK: !4 = !{!0, !5}
 ; CHECK: !5 = !DIGlobalVariableExpression(var: !6, expr: !DIExpression())
-; CHECK: !6 = distinct !DIGlobalVariable(name: "__A8764FDD_x@c", scope: !2, file: !7, type: !8, isLocal: true, isDefinition: true)
+; CHECK: !6 = distinct !DIGlobalVariable(name: "__A85D9D03_x@c", scope: !2, file: !7, type: !8, isLocal: true, isDefinition: true)
 ; CHECK: !7 = !DIFile(filename: "./x.c", directory: "C:\\\\a\\\\b\\\\")
 ; CHECK: !8 = !DIBasicType(name: "unsigned char", size: 8, encoding: DW_ATE_unsigned_char, flags: DIFlagArtificial)
 ; CHECK: !9 = !{i32 2, !"CodeView", i32 1}
 ; CHECK: !10 = !{i32 2, !"Debug Info Version", i32 3}
 ; CHECK: !11 = !{!"clang"}
-; CHECK: !12 = !{!"/alternatename:__CheckForDebuggerJustMyCode=__JustMyCode_Default"}
-; CHECK: !13 = distinct !DISubprogram(name: "f", scope: !3, file: !3, line: 1, type: !14, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !16)
-; CHECK: !14 = !DISubroutineType(types: !15)
-; CHECK: !15 = !{null}
-; CHECK: !16 = !{}
-; CHECK: !17 = distinct !DISubprogram(name: "f", scope: !18, file: !18, line: 1, type: !14, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !16)
-; CHECK: !18 = !DIFile(filename: "x.c", directory: "/tmp/a")
-; CHECK: !19 = distinct !DISubprogram(name: "f", scope: !7, file: !7, line: 1, type: !14, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !16)
-; CHECK: !20 = distinct !DISubprogram(name: "f", scope: !21, file: !21, line: 1, type: !14, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !16)
-; CHECK: !21 = !DIFile(filename: "./b\\x.c", directory: "C:\\\\a\\\\")
-; CHECK: !22 = distinct !DISubprogram(name: "f", scope: !23, file: !23, line: 1, type: !14, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !16)
-; CHECK: !23 = !DIFile(filename: "./b/x.c", directory: "C:\\\\a\\\\")
-; CHECK: !24 = distinct !DISubprogram(name: "f", scope: !25, file: !25, line: 1, type: !14, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !16)
-; CHECK: !25 = !DIFile(filename: "./b/./../b/x.c", directory: "C:\\\\a")
+; CHECK: !12 = distinct !DISubprogram(name: "f", scope: !3, file: !3, line: 1, type: !13, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !15)
+; CHECK: !13 = !DISubroutineType(types: !14)
+; CHECK: !14 = !{null}
+; CHECK: !15 = !{}
+; CHECK: !16 = distinct !DISubprogram(name: "f", scope: !17, file: !17, line: 1, type: !13, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !15)
+; CHECK: !17 = !DIFile(filename: "x.c", directory: "/tmp/a")
+; CHECK: !18 = distinct !DISubprogram(name: "f", scope: !7, file: !7, line: 1, type: !13, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !15)
+; CHECK: !19 = distinct !DISubprogram(name: "f", scope: !20, file: !20, line: 1, type: !13, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !15)
+; CHECK: !20 = !DIFile(filename: "./b\\x.c", directory: "C:\\\\a\\\\")
+; CHECK: !21 = distinct !DISubprogram(name: "f", scope: !22, file: !22, line: 1, type: !13, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !15)
+; CHECK: !22 = !DIFile(filename: "./b/x.c", directory: "C:\\\\a\\\\")
+; CHECK: !23 = distinct !DISubprogram(name: "f", scope: !24, file: !24, line: 1, type: !13, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !15)
+; CHECK: !24 = !DIFile(filename: "./b/./../b/x.c", directory: "C:\\\\a")
 
 ; All use the same flag
 define void @l1() !dbg !10 {
   ret void
 }
 define void @l2() !dbg !11 {
   ret void
 }

llvm/test/Instrumentation/JustMyCode/jmc-instrument-x86.ll

 ; REQUIRES: system-windows
 ; RUN: opt -jmc-instrument -S < %s | FileCheck %s
 
 ; CHECK: $_JustMyCode_Default = comdat any
 
 ; CHECK: @"_A8764FDD_x@c" = internal unnamed_addr global i8 1, section ".msvcjmc", align 1, !dbg !0
 ; CHECK: @llvm.used = appending global [1 x i8*] [i8* bitcast (void (i8*)* @_JustMyCode_Default to i8*)], section "llvm.metadata"
 
 ; CHECK: define void @w1() #0 !dbg !10 {
 ; CHECK:   call x86_fastcallcc void @__CheckForDebuggerJustMyCode(i8* inreg noundef @"_A8764FDD_x@c")
 ; CHECK:   ret void
 ; CHECK: }
 
-; CHECK: declare x86_fastcallcc void @__CheckForDebuggerJustMyCode(i8* inreg noundef) unnamed_addr
-
 ; CHECK: define void @_JustMyCode_Default(i8* inreg noundef %0) unnamed_addr comdat {
 ; CHECK:   ret void
 ; CHECK: }
 
+; CHECK: declare x86_fastcallcc void @__CheckForDebuggerJustMyCode(i8* inreg noundef) unnamed_addr
+
 ; CHECK: !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 ; CHECK: !1 = distinct !DIGlobalVariable(name: "_A8764FDD_x@c", scope: !2, file: !3, type: !5, isLocal: true, isDefinition: true)
 ; CHECK: !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
 ; CHECK: !3 = !DIFile(filename: "./b/./../b/x.c", directory: "C:\\\\a\\\\")
 ; CHECK: !4 = !{!0}
 ; CHECK: !5 = !DIBasicType(name: "unsigned char", size: 8, encoding: DW_ATE_unsigned_char, flags: DIFlagArtificial)
 ; CHECK: !6 = !{i32 2, !"CodeView", i32 1}
 ; CHECK: !7 = !{i32 2, !"Debug Info Version", i32 3}

llvm/test/Instrumentation/JustMyCode/jmc-instrument.ll

 ; REQUIRES: system-windows
 ; RUN: opt -jmc-instrument -mtriple=x86_64-pc-windows-msvc  -S < %s | FileCheck %s
 ; RUN: opt -jmc-instrument -mtriple=aarch64-pc-windows-msvc -S < %s | FileCheck %s
 ; RUN: opt -jmc-instrument -mtriple=arm-pc-windows-msvc     -S < %s | FileCheck %s
 
 ; CHECK: $__JustMyCode_Default = comdat any
 
 ; CHECK: @"__E6EA670F_x@c" = internal unnamed_addr global i8 1, section ".msvcjmc", align 1, !dbg !0
-; CHECK: @"__A8764FDD_x@c" = internal unnamed_addr global i8 1, section ".msvcjmc", align 1, !dbg !5
 ; CHECK: @llvm.used = appending global [1 x i8*] [i8* bitcast (void (i8*)* @__JustMyCode_Default to i8*)], section "llvm.metadata"
+; CHECK: @"__A8764FDD_x@c" = internal unnamed_addr global i8 1, section ".msvcjmc", align 1, !dbg !5
 
 ; CHECK: define void @l1() !dbg !13 {
 ; CHECK:   call void @__CheckForDebuggerJustMyCode(i8* noundef @"__E6EA670F_x@c")
 ; CHECK:   ret void
 ; CHECK: }
 
 ; CHECK: define void @l2() !dbg !17 {
 ; CHECK:   call void @__CheckForDebuggerJustMyCode(i8* noundef @"__E6EA670F_x@c")

 ; CHECK:   ret void
 ; CHECK: }
 
 ; CHECK: define void @w4() !dbg !24 {
 ; CHECK:   call void @__CheckForDebuggerJustMyCode(i8* noundef @"__A8764FDD_x@c")
 ; CHECK:   ret void
 ; CHECK: }
 
-; CHECK: declare void @__CheckForDebuggerJustMyCode(i8* noundef) unnamed_addr
-
 ; CHECK: define void @__JustMyCode_Default(i8* noundef %0) unnamed_addr comdat {
 ; CHECK:   ret void
 ; CHECK: }
 
+; CHECK: declare void @__CheckForDebuggerJustMyCode(i8* noundef) unnamed_addr
+
 ; CHECK: !llvm.linker.options = !{!12}
 
 ; CHECK: !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 ; CHECK: !1 = distinct !DIGlobalVariable(name: "__E6EA670F_x@c", scope: !2, file: !3, type: !8, isLocal: true, isDefinition: true)
 ; CHECK: !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
 ; CHECK: !3 = !DIFile(filename: "a/x.c", directory: "/tmp")
 ; CHECK: !4 = !{!0, !5}
 ; CHECK: !5 = !DIGlobalVariableExpression(var: !6, expr: !DIExpression())